I2L 2022 Groupe3

Proposition de système

Le projet est une matrice de bouton qui va exécuter des raccourcis clavier pour visual studio code. Le clavier est organisé sous la forme d'une matrice de touches.

Contre-proposition

Rien à ajouter :

• une difficulté pour la carte au niveau du connecteur USB C ;
• une autre difficulté au niveau de la carte avec les LED des touches ;
• une difficulté avec la gestion de la matrice de touches.

Carte

Schéma

Carte

Carte soudée :

Cette première version de la carte est défaillante du coté du connecteur USB : le bord de la carte n'est pas conforme à l'empreinte du connecteur et l'épaisseur du PCB pour ce type de connecteurs doit être de 0,6mm et pas de 0,8mm comme ce qui à été demandé au fabricant. Du coup le connecteur USB C est très difficile à souder et aussi très fragile.

De plus la partie clavier avait aussi un défaut dont la conséquence était que l'appui sur une touche allumait toutes les LED de la même ligne. Le nouveau clavier est prévu pour que les LED soient éteintes durant le scan des touches et puissent être activées en inversant le mode des E/S entre lignes et colonnes.

Du coup une autre carte déjà réalisée a été utilisée pour le début de la programmation :

Le nouveau clavier est prévu pour que les LED soient éteintes durant le scan des touches et puissent être activées en inversant le mode des E/S entre lignes et colonnes.

Schéma

Carte

Carte soudée :

Code du clavier

Vous trouverez dans cette section les parties importantes du code, le code complet est disponible dans la section Fichiers.

Ce code crée une structure `IO_Config` qui contient des pointeurs vers des registres de données (`ddr`, `port`, `pin`) et un entier qui correspond au numéro de pin. Ensuite, deux tableaux `cols` et `rows` sont déclarés pour stocker des configurations d'E/S spécifiques utilisant la structure `IO_Config`.

typedef struct {
    volatile unsigned char *ddr;
    volatile unsigned char *port;
    volatile unsigned char *pin;
    int n;
} IO_Config;

IO_Config cols[NB_COLS] = {
    {&DDRD, &PORTD, &PIND, 6},
    {&DDRD, &PORTD, &PIND, 5},
    {&DDRD, &PORTD, &PIND, 4},
    {&DDRD, &PORTD, &PIND, 3}
};

IO_Config rows[NB_ROWS] = {
    {&DDRB, &PORTB, NULL, 3},
    {&DDRB, &PORTB, NULL, 2},
    {&DDRB, &PORTB, NULL, 1},
    {&DDRB, &PORTB, NULL, 0}
};

Le code définit un tableau `keyActions` de dimensions `[NB_ROWS][NB_COLS]`, qui contient des structures `KeyAction` représentant des actions de touche spécifiques avec des modificateurs et des codes de touche.{HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_N} --> Appui sur la touche 'N' avec le modificateur 'Ctrl' gauche.

typedef struct {
    uint8_t modifier1;
    uint8_t modifier2;
    uint8_t keyCode;
} KeyAction;



KeyAction keyActions[NB_ROWS][NB_COLS] = {
    // Ligne 1
    {
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_N},
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_O},
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_B},
		{HID_KEYBOARD_MODIFIER_LEFTCTRL, HID_KEYBOARD_MODIFIER_LEFTSHIFT, HID_KEYBOARD_SC_N}
        // Autres actions...
    },
    // Ligne 2
    {
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_Q},
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_X},
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_C},
		{HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_V},
    }, 
	// Ligne 3
	   {
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_H},
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_F},
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_W},
		{HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_Y},
    },
    {
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, HID_KEYBOARD_MODIFIER_LEFTSHIFT, HID_KEYBOARD_SC_X},
        {HID_KEYBOARD_MODIFIER_LEFTCTRL, 0, HID_KEYBOARD_SC_F4},
        {0, 0, HID_KEYBOARD_SC_ESCAPE},
		{HID_KEYBOARD_MODIFIER_LEFTALT, 0, HID_KEYBOARD_SC_F4},
    },
    // Autres lignes...
};

Ce code allume la première ligne de touches en configurant les broches appropriées. Par la suite, on allume les lignes séquentiellement, avec un délai de 1 seconde entre chaque ligne.

//Allumer la 1ere ligne
	DDRD |= (1 << 6);
	PORTD |=(1 << 6);

	DDRB |= (1 << 3);
	DDRB |= (1 << 2);
	DDRB |= (1 << 1);
	DDRB |= (1 << 0);
	PORTB  &= ~(1 << 3);
	PORTB  &= ~(1 << 2);
	PORTB  &= ~(1 << 1);
	PORTB  &= ~(1 << 0);

	_delay_ms(1000);

Le code permet d'initialiser les DDRs et PORTs permettant l'utilisation des boutons du clavier.

	for (int col = 0; col < NB_COLS; col++) {
		*(cols[col].ddr) &= ~(1 << cols[col].n);
		*(cols[col].port) |= (1 << cols[col].n);
	}

	for (int row = 0; row < NB_ROWS; row++) {
		*(rows[row].ddr) |= (1 << rows[row].n);
		*(rows[row].port) &= ~(1 << rows[row].n);
	}

La fonction CreateKeyboardReport parcours le clavier matriciel, détectant les touches enfoncées. Elle utilise les informations stockées dans le tableau keyActions pour déterminer les actions à effectuer pour chaque touche détectée.

void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
{

	uint8_t UsedKeyCodes      = 0;
	memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));


	for (int row = 0; row < NB_ROWS; row++) {
		*(rows[row].port) &= ~(1 << rows[row].n);
		for (int col = 0; col < NB_COLS; col++) {
			unsigned char key = (*(cols[col].pin) & (1 << cols[col].n)) ? 0 : 1;
			if (key) {
				int touche = row * NB_COLS + col;
				if (touche < NB_ROWS * NB_COLS) {
					KeyAction action = keyActions[row][col];
					if (action.modifier1 != 0 && action.modifier2 != 0) {
						ReportData->Modifier = action.modifier1;
						ReportData->Modifier |= action.modifier2;
						ReportData->KeyCode[UsedKeyCodes++] = action.keyCode;
					} else if (action.modifier1 != 0) {
						ReportData->Modifier = action.modifier1;
						ReportData->KeyCode[UsedKeyCodes++] = action.keyCode;
					}else{
						ReportData->KeyCode[UsedKeyCodes++] = action.keyCode;
					}

				}
			}
		}
		*(rows[row].port) |= (1 << rows[row].n);
	}

}

Fonctionnalités

Au branchement, l'appareil lance une séquence je jeu de lumière, un peu comme au 14 juillet.

Bilan

• La séquence LED au branchement est fonctionnelle.
• L'USB-C est fonctionnel avec ou sans adaptateur.
• Le clavier de raccourcis pour Visual Studio Code est fonctionnel

Fichiers

Projet KiCAD : Fichier:I2L-2022-CLIPET-MATHON-BOUKELLAL.zip.

Seconde version du projet KiCAD : Fichier:I2L-2022-CLIPET-MATHON-BOUKELLAL version 2.zip.

Code Final du projet:Fichier:CODE-CLIPET-MATHON-BOUKELLAL.zip