Binome2022-2 : Différence entre versions

De Wiki de bureau d'études PeiP
(→‎Troisième étape : programmation du micro-controleur)
(→‎Deuxième étape : Soudage)
 
(3 révisions intermédiaires par un autre utilisateur non affichées)
Ligne 61 : Ligne 61 :
  
 
Complication :
 
Complication :
−
Nous n'avions pas mis la bonne empreinte du port miniUSB sur Kicad, par chance, notre erreer fut minime car nous n'avions qu'à couper avec des ciseaux la petite accroche situé sous le port pour pouvoir le soudé.
+
Nous n'avions pas mis la bonne empreinte du port miniUSB sur Kicad, par chance, notre erreur fut minime car nous n'avions qu'à couper avec des ciseaux la petite accroche situé sous le port pour pouvoir le soudé.
  
 
===Troisième étape : programmation du micro-controleur===
 
===Troisième étape : programmation du micro-controleur===
Ligne 236 : Ligne 236 :
 
===Troisième étape : programmation du micro-controleur===
 
===Troisième étape : programmation du micro-controleur===
  
−
Cette fois-ci, le programmation ne se fera pas à l'aide d'un programmeur Arduino. On implémentera directement le programme à l'aide de l'invité de commande via plusieurs commandes. Sans oublier de reset avant chaque implémentation.
+
Cette fois-ci, le programmation ne se fera pas à l'aide d'un programmeur Arduino. On implémentera directement le programme à l'aide de l'invité de commande via plusieurs commandes, on s'aidera de la bibliothèque LUFA cette fois-ci. Sans oublier de reset avant chaque implémentation.
 
Voici la partie du code permettant d'agir sur le rôle des touches à l'issue d'une pression sur celle-ci :
 
Voici la partie du code permettant d'agir sur le rôle des touches à l'issue d'une pression sur celle-ci :
  
Ligne 555 : Ligne 555 :
 
Clavier en action !
 
Clavier en action !
 
[[media:Binome2022-22-Keypad6.mp4]]
 
[[media:Binome2022-22-Keypad6.mp4]]
 +
 +
 +
=<div class="mcwiki-header" style="border-radius: 10px; padding: 15px;border:solid #000000; font-weight: bold; color: #000000; text-align: center; font-size: 80%; background: #CAA5F4; vertical-align: left; width: 97%;">Conclusion</div>=
 +
 +
La réalisation de la première carte nous a vraiment aidé pour la deuxième. Cette étape fut alors très importante pour obtenir une carte finale fonctionnelle et aboutit. Que ce soit pour le routage, le codage ou le soudage, chacun des ces aspects de conception a suscité notre curiosité. Ce bureau d'étude a, d'ailleurs, monté le vœu SE plus haut dans notre liste. Ces cours nous ont aussi permis de se rendre compte des difficultés et des erreurs à ne pas reproduire (Nom d'étiquettes KiCad), en effet une moindre petite erreur peut retarder notre travail pour plusieurs heures, il était alors important d'être un minimum investie et minutieux dans la conception de notre clavier. Enfin, ces +40 heures de SE nous ont permis d'éclairer notre image de la spécialité SE, nous étions intéressé et nous nous sentions impliqué dans notre projet.
 +
 +
De plus, avec du temps en plus (et des erreurs en moins de notre part), nous aurions pu finir de programmer la mémoire soudé sur la carte. Celle-ci était détecter à l'aide d'un programme donné par ls professeurs, mais les journées sont composés de seulement 24 heures ;-) ,nous avons préféré priorisé le plus important pour un clavier : le fonctionnement et la programmation des touches. Nous aurions pu aussi, avec plus de temps, souder le haut-parleur ainsi que le faire fonctionner.
 +
 +
Enfin, nous sommes très heureux (et fier) d'avoir pu finir avec la fonctionnalité que nous avions comme objectif : programmer des touches raccourcies tel que copier/coller/couper. Merci aux professeurs ainsi qu'aux autres étudiants avec qui nous partagions ce BE de nous avoir aidé et assisté.

Version actuelle datée du 17 mai 2023 à 12:37

Première carte

Nous avons réalisé un clavier USB. Ce clavier possède 12 touches, chacune d'entre elles sert à interagir et faire fonctionner des LED's selon le progamme importé dans le microprocesseur.

Introduction

Premièrement, la première carte PCB (pour s'entraîner) n'aura pas de micro-processeur nous permettant d'intéragir avec l'ordinateur auquel le clavier est branché. Donc, nous avons choisi de faire un clavier ayant 12 touches et 4 LEDS. Les touches permettront de contrôler les leds selon le programme qu'on injecte au micro-processeur.

Rôle des touches

  • 4 touches permettent d'allumer individuellement les 4 LEDS.
  • 4 touches permettent d'éteindre individuellement les 4 LEDS.
  • 1 touche permet d'allumer toute les LEDS en même temps.
  • 1 touche permet d'allumer "en vague" les 4 LEDS.
  • 1 touche permet d'éteindre "en vague" les 4 LEDS.
  • 1 touche fait clignoter chaque LED tour à tour individuellement.

Fonctionnalités supplémentaires

Ayant seulement des LEDS et des touches ne pouvant pas intéragir avec l'ordinateur, nous nous sommes contentés de programmer les touches afin de contrôler les LEDS afin de prendre en main le soudage et la programmation en C++ via Arduino.

Liste composants

  • boutons poussoirs EVQ-Q2F01W (matrice 4x3) ;
  • LED empreinte CMS 0603 ;
  • ATtiny84.

Pour réaliser le routage de la matrice vous pouvez regarder l'objet https://fr.aliexpress.com/i/1893745690.html. Utilisez la bibliothèque keypad de l'IDE Arduino pour lire les touches.

Ne pas oublier le connecteur ISP (2x3 broches, espacement 2,54mm) pour programmer l'ATtiny84 et le connecteur USB (https://www.sparkfun.com/products/587) pour alimenter la carte.

Vous pouvez commencer à concevoir le schéma du premier circuit.

Conception

Première étape : Kicad

Tout d'abord, nous nous sommes occupés de faire le schéma électronique Kicad :

Binome2022-22-Kicad1.png

Après avoir vérifié soigneusement le schéma, nous sommes passés à l'étape du routage. Voici une photo du routage : media:Binome2022-22-Root1.pdf

  • PCB 3D :
Binome2022-22-PCB 3D.png

Fichier KiCad final : media:Binome2022-22-kicad.zip

Deuxième étape : Soudage

La carte ,une fois imprimé, ressemblait à ça :

  • PCB imprimé :
Binome2022-22-PCB.png

Ensuite, nous avons soudé tout nos composants :

  • PCB Soudé :
Binome2022-22-PCB SOUDE.png


Complication : Nous n'avions pas mis la bonne empreinte du port miniUSB sur Kicad, par chance, notre erreur fut minime car nous n'avions qu'à couper avec des ciseaux la petite accroche situé sous le port pour pouvoir le soudé.

Troisième étape : programmation du micro-controleur

Après avoir soudé tout nos composants, il manquait plus qu'à programmer notre carte afin qu'elle soit utilisable. Pour cette première carte, nous avons programmer le micro-contrôleur avec ISP en utilisant le logiciel ARDUINO et sa bibliothèque Keypad 


#include <Keypad.h>

const byte ROWS = 3; //3 lignes
const byte COLS = 4; //4 colonnes
const int ledPin1 =  10;
const int ledPin2 =  9;
const int ledPin3 =  8;
const int ledPin4 =  7;

char keys[ROWS][COLS] = {
  {'1','2','3','4'},
  {'5','6','7','8'},
  {'9','A','B','C'}
};

byte rowPins[ROWS] = {0,1,2};
byte colsPins[COLS] = {3,4,5,6};

Keypad clavier = Keypad(makeKeymap(keys), rowPins, colsPins, ROWS, COLS);

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

}

void loop() {
  char key = clavier.getKey();

  if (key == '1'){
    digitalWrite(ledPin1, HIGH);
  }
  if (key == '2'){
    digitalWrite(ledPin2, HIGH);
  }
  if (key == '3'){
    digitalWrite(ledPin3, HIGH);
  }
  if (key == '4'){
    digitalWrite(ledPin4, HIGH);
  }

  if (key == '5'){
    digitalWrite(ledPin1, LOW);
  }
  if (key == '6'){
    digitalWrite(ledPin2, LOW);
  }
  if (key == '7'){
    digitalWrite(ledPin3, LOW);
  }
  if (key == '8'){
    digitalWrite(ledPin4, LOW);
  }

  if (key == '9'){
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    digitalWrite(ledPin4, HIGH);
  }

  if (key == 'A'){
    digitalWrite(ledPin1, HIGH);
    delay(250);
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, HIGH);
    delay(250);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, HIGH);
    delay(250);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, HIGH);
    delay(250);
    digitalWrite(ledPin4, LOW);
  }
   
   if (key == 'B'){
    digitalWrite(ledPin1, HIGH);
    delay(250);
    digitalWrite(ledPin2, HIGH);
    delay(250);
    digitalWrite(ledPin3, HIGH);
    delay(250);
    digitalWrite(ledPin4, HIGH);
  }
  
  if (key == 'C'){
    digitalWrite(ledPin4, LOW);
    delay(250);
    digitalWrite(ledPin3, LOW);
    delay(250);
    digitalWrite(ledPin2, LOW);
    delay(250);
    digitalWrite(ledPin1, LOW);
  }

  

}

Photo du code : media:Binome2022-22-Code1.pdf

Fichier du code Arduino : media:Binome2022-22-arduino1.zip

Rendu vidéo final

media:Binome2022-22-Keypad1.mp4

Seconde carte

Pour notre deuxième carte, nous voulons faire un clavier dynamique avec plus de touches, 2 LED, un haut parleur et une mémoire.

Introduction

Les touches vont servir de pavé numérique (+lettre) et de raccourcies clavier.

Exemple :

Une seule touche va permettre le raccourcie Copier (CTRL+C).

Rôle des touches

Binome2022-22-roles.png


Fonctionnalités supplémentaires

La fonctionnalité supplémentaire se trouve principalement dans la programmation. En effet, nous voulons faire un clavier dynamique, c'est à dire que les touches changent de valeurs après la pression d'une certaine touche. Dans notre cas, initialement le clavier sera seulement numérique, mais après la pression de la touche situéé tout en bas à droite, le clavier deviendra un clavier uniquement de lettres. De plus, certaines touches sont des raccourcies clavier elle seule, c'est à dire qu'après la pression d'une seule touche, un raccourcie (qui est en réalité une pression simultanée de plusieurs touches en même temps, souvent deux ou trois) sera effectué. Concernant les composants, sur notre routage Kicad, nou avons laissé place à une mémoire, un haut parleur et une trentaine de touches.

Conception

Première étape : Kicad

Tout d'abord, nous nous sommes occupés de faire le schéma électronique Kicad, bien plus consistant que le précédent, il était alors bien plus difficile d'en voir le bout. Heureusement pour nous, nous pouvions router en deux couches car la carte sera imprimé par une entreprise :

Binome2022-22-Kicad2.png

Après avoir fait vérifier le schéma, nous sommes passés à l'étape du routage, les traits semi-transparents signifient alors que le soudage se fera sur une seconde couche. Voici une photo du routage :

Binome2022-22-Root2.png
  • PCB 3D :
Binome2022-22-PCB 3D2.png

Fichier KiCad final : media:Binome2-2022-kicadfinal.zip

Deuxième étape : Soudage

La carte ,une fois imprimé, ressemblait à ça :

  • PCB imprimé :
Binome2022-22-PCB2.png
Binome2022-22-PCB3.png

Ensuite, nous avons soudé tout nos composants :

  • PCB Soudé :
Binome2022-22-PCB SOUDE2.png

Troisième étape : programmation du micro-controleur

Cette fois-ci, le programmation ne se fera pas à l'aide d'un programmeur Arduino. On implémentera directement le programme à l'aide de l'invité de commande via plusieurs commandes, on s'aidera de la bibliothèque LUFA cette fois-ci. Sans oublier de reset avant chaque implémentation. Voici la partie du code permettant d'agir sur le rôle des touches à l'issue d'une pression sur celle-ci :

Définition de variables pour implanter notre matrice de touches : 


volatile unsigned char *cols_d[NB_COLS]={&DDRC,&DDRD,&DDRD,&DDRD,&DDRD,&DDRD,&DDRD};
volatile unsigned char *cols_p[NB_COLS]={&PORTC,&PORTD,&PORTD,&PORTD,&PORTD,&PORTD,&PORTD};
volatile unsigned char *cols_i[NB_COLS]={&PINC,&PIND,&PIND,&PIND,&PIND,&PIND,&PIND};
int cols_n[NB_COLS]={2,0,1,2,3,4,5};

volatile unsigned char *rows_d[NB_ROWS]={&DDRD,&DDRB,&DDRB,&DDRB,&DDRB};
volatile unsigned char *rows_p[NB_ROWS]={&PORTD,&PORTB,&PORTB,&PORTB,&PORTB};
int rows_n[NB_ROWS]={6,0,1,2,3};

Ces lignes de codes initialisent chaque touches. Elles se situent dans le SetupHardware 


for(int col=0;col<NB_COLS;col++){
  *cols_d[col] &= ~(1<<cols_n[col]);
  *cols_p[col] |= (1<<cols_n[col]);
  }  
	for(int row=0;row<NB_ROWS;row++){
  *rows_d[row] |= (1<<rows_n[row]);
  *rows_p[row] &= ~(1<<rows_n[row]);
};

for (int i= 0;i<5;i++){
	PORTB |= (1<<6);
	PORTB |= (1<<5);
	_delay_ms(200);
	PORTB &= ~(1<<6);
	PORTB &= ~(1<<5);
	_delay_ms(200);
}

Enfin, celles-ci définissent l'agissement de la touche une fois pressée. 


for(int row=0;row<NB_ROWS;row++){
   	 *rows_p[row] &= ~(1<<rows_n[row]);
     	 for(int col=0;col<NB_COLS;col++){
   		 unsigned char key = (*cols_i[col] & (1<<cols_n[col]))?0:1;
   		 if (key){
            	int touche = row*7+col;
					if (ALPHA == 0) {
            		switch (touche){
                		case 0 : 
							 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
							 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE;
							 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
                         	break;
						case 1 : 	ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
									ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN ;
									ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
                         	break;
						case 2 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_BACKSLASH_AND_PIPE ;
                         	break;
						case 3 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_6_AND_CARET;
                         	break;
						case 4 :ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
							ReportData->KeyCode[UsedKeyCodes++] =HID_KEYBOARD_SC_C;
							ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
							PORTB |= (1<<5);
                         	break;
						case 5 : ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
							ReportData->KeyCode[UsedKeyCodes++] =HID_KEYBOARD_SC_V;
							ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
							LED_PORT &= ~(1<<5);
                         	break;
						case 6 : ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
							ReportData->KeyCode[UsedKeyCodes++] =HID_KEYBOARD_SC_X;
							ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
							PORTB |= (1<<5);
                         	break;
						case 7 : ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_7_AND_AMPERSAND ;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
                         	break;
						case 8 : ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_8_AND_ASTERISK;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
                         	break;
						case 9 : ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
                         	break;
						case 10 : 
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_EQUAL_AND_PLUS;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
                         	break;
						case 11 :
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_ESCAPE;  
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTCTRL;
							break;
						case 12 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_UP_ARROW;
							break;
						case 13 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_PRINT_SCREEN;
							break;
						case 14 :
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_4_AND_DOLLAR;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
							break;
						case 15 :
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_5_AND_PERCENTAGE;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
							break;
						case 16 :
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_6_AND_CARET;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
							break;
						case 17 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_ENTER;
								
							break;
						case 18 :
								
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_LEFT_ARROW;
								
							break;

						case 19 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_DOWN_ARROW;
							
							break;
						case 20 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_RIGHT_ARROW;
						
							break;	
						case 21 :
								 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_1_AND_EXCLAMATION;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								
							break;
						case 22 :
								 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_2_AND_AT;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								
							break;
						case 23 :
								 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_3_AND_HASHMARK;
								ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								
							break;
						case 24 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_BACKSPACE;
								
							break;
						case 27 :
								ALPHA = 1;
								PORTB |= (1<<6);
							break;
						case 28 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_ESCAPE;
								
							break;
						case 29 :ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS;
								 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
							break;
						case 30 :
								 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_1_AND_EXCLAMATION;
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS;
								 ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_E;
								 
								
							break;
						case 31 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_DELETE;
								
							break;
                		default : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_A;
					};}
				else
				{
					switch (touche){
                		case 0 : 
							 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_Q;
                         	break;
						case 1 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_B;
                         	break;
						case 2 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_C;
                         	break;
						case 3 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_D;
                         	break;
						case 4 :ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_E;
                         	break;
						case 5 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_F;
                         	break;
						case 6 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_G;
                         	break;
						case 7 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_H;
                         	break;
						case 8 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_I;
                         	break;
						case 9 : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_J;
                         	break;
						case 10 : 
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_K;
                         	break;
						case 11 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_L;
							break;
						case 12 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_SEMICOLON_AND_COLON;
				
							break;
						case 13 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_N;
							break;
						case 14 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_O;
							break;
						case 15 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_P;
							break;
						case 16 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_A;
							break;
						case 17 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_R;
								
							break;
						case 18 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_S;
							break;

						case 19 :ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_T;
							break;
						case 20 :ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_U;
							break;	
						case 21 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_V;
							break;
						case 22 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_Z;
								
							break;
						case 23 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_X;
								
							break;
						case 24 :
								ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_Y;
								
							break;
						case 27 :
								ALPHA = 0;
								PORTB &= ~(1<<6);
							break;
						case 28 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_W;
								
							break;
						case 29 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_SPACE;
							break;
						case 30 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_BACKSPACE;
								
								 
								
							break;
						case 31 :
								 ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_ENTER;
								
							break;
					default : ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_A;
				};
            	};
   		 }
   	 };
     	 *rows_p[row] |= (1<<rows_n[row]);
	 }

La variable ALPHA vaut 1 lorsqu'on touche presse la dernière touche, cela signifie que le mode "LETTRE" du clavier est activé, après une autre pression elle revient à 0 et le clavier sera en mode "NUMERIQUE".

*Fichier Code : media:Binome2-2022-Code2.zip

Rendu vidéo final

Nous avons essayé de faire des vidéos pour chaque utilisation de touches.

Chiffres et caractères spéciaux : media:Binome2022-22-Keypad2.mp4

Lettres : media:Binome2022-22-Keypad3.mp4

Flèches, raccourcies copier/coller/couper, delete : media:Binome2022-22-Keypad4.mp4

Backspace, Impr.Ecran : media:Binome2022-22-Keypad5.mp4

Clavier en action ! media:Binome2022-22-Keypad6.mp4


Conclusion

La réalisation de la première carte nous a vraiment aidé pour la deuxième. Cette étape fut alors très importante pour obtenir une carte finale fonctionnelle et aboutit. Que ce soit pour le routage, le codage ou le soudage, chacun des ces aspects de conception a suscité notre curiosité. Ce bureau d'étude a, d'ailleurs, monté le vœu SE plus haut dans notre liste. Ces cours nous ont aussi permis de se rendre compte des difficultés et des erreurs à ne pas reproduire (Nom d'étiquettes KiCad), en effet une moindre petite erreur peut retarder notre travail pour plusieurs heures, il était alors important d'être un minimum investie et minutieux dans la conception de notre clavier. Enfin, ces +40 heures de SE nous ont permis d'éclairer notre image de la spécialité SE, nous étions intéressé et nous nous sentions impliqué dans notre projet.

De plus, avec du temps en plus (et des erreurs en moins de notre part), nous aurions pu finir de programmer la mémoire soudé sur la carte. Celle-ci était détecter à l'aide d'un programme donné par ls professeurs, mais les journées sont composés de seulement 24 heures ;-) ,nous avons préféré priorisé le plus important pour un clavier : le fonctionnement et la programmation des touches. Nous aurions pu aussi, avec plus de temps, souder le haut-parleur ainsi que le faire fonctionner.

Enfin, nous sommes très heureux (et fier) d'avoir pu finir avec la fonctionnalité que nous avions comme objectif : programmer des touches raccourcies tel que copier/coller/couper. Merci aux professeurs ainsi qu'aux autres étudiants avec qui nous partagions ce BE de nous avoir aidé et assisté.

Récupérée de « https://peip-ima.plil.fr/mediawiki/index.php?title=Binome2022-2&oldid=19236 »