SE4Binome2023-8

Matériel :

Préparation de la carte Shield :

Pour la première séance de TP, nous avons dû souder des composants sur la carte Shield fournie. Nous nous sommes alors séparés, un qui faisait la soudure, et un autre préparant les câble reliant la carte Shield aux cartes filles.

Pour les câbles, nous avons comparé notre travail avec le câble de l'enseignant. Le plus dur était de savoir dans quel sens mettre les fiches HE10 femelle, un renfoncement permet heureusement de savoir le sens dans lequel insérer le câble. Après cela, le câble est un peu fragile si on tire dessus, nous avons donc replier le câble et mis un bloqueur pour augmenter sa résistance. Nous avons réalisé au total 3 câbles, donc un de plus que le nombre de base au cas où un des câbles ne fonctionne pas. Voici une photo des trois câbles :

• 
• 

  Photos des trois câbles

Par la suite, nous avons dû souder une carte Shield pouvant être ajoutée à un Arduino Uno. Cette carte Shield était déjà partiellement soudée. De plus nous avons dû souder 2 connecteurs permettant la jonction avec les cartes . Voici une photo de la carte soudée :

• 
• 

  Carte et connecteurs soudés

Ordonnanceur

1) Clignotement de 2 LEDs

Nous avons commencé l'ordonnanceur avec l'objectif de faire clignoter dans un premier temps 2 LEDs, à l'aide de deux tâches statiques, avec des périodes différentes.

Pour cela, nous avons utilisé un ISR permettant de gérer plusieurs tâches en même temps. Avant cela, il y a des fonctions de gestion et de restitution des registres afin que l'ISR commence le programme avec tous les registres à 0. Nous avons utilisé le lien suivant pour nous aider : https://tvantroys.plil.fr/IMA4/system/Multitasking%20on%20an%20AVR.pdf. Ensuite, nous avons implémenté un "scheduler" avec tout d'abord une première version où nous utilisions des "_delay_ms_". Par la suite, une mise à jour de ce "scheduler" s'imposait afin de supprimer les _delay_ms_ pour que chaque tâche possède son propre délai.

void scheduler(void){
    for(int i = 0; i < MAX_TASKS; i++){
        if(tasks[i].state == SLEEPING && tasks[i].reason == DELAY){
            uint16_t time = 20;
            if(TCNT1 != 0){
                time = TCNT1 * 200 / OCR1A / 10;
                TCNT1 = 0;
            }
            tasks[i].duration = tasks[i].duration - time;
            if(tasks[i].duration <= 0) { tasks[i].state = WORKING; }
        }
    }
    
    do{
        actuel++;
        if(actuel == MAX_TASKS) { actuel = 0; }
    } while(tasks[actuel].state == SLEEPING);
}


ISR(TIMER1_COMPA_vect,ISR_NAKED){
    /* Sauvegarde du contexte de la tâche interrompue */
    portSAVE_CONTEXT();
    tasks[actuel].StackPointeur = SP;
    /* Appel à l'ordonnanceur */
    scheduler();
    /* Récupération du contexte de la tâche ré-activée */
    SP = tasks[actuel].StackPointeur;
    portRESTORE_CONTEXT();
    asm volatile ("reti");
}

Au final, nous arrivons à faire clignoter 2 LEDs avec deux périodes différentes :

Clignotement des LEDs grâce à l'ordonnanceur

4) Matrice de LEDs

Dans cette partie, nous souhaitons gérer l'affichage d'une matrice de LEDs 8x8.

Dans un premier temps, nous avons rédiger un programme à part de notre ordonnanceur afin d'afficher différents caractères sur la matrice.

Après vérification du bon fonctionnement de notre programme, nous avons ajouté la fonction principale dans notre fichier de gestion des tâches. Enfin, dans cette fonction, nous y avons ajouté le fait de pouvoir lire au clavier n'importe quel caractère sur la matrice.

Affichage de caractères sur la matrice

5) Afficheur 7 segments

Pour le 7 segments nous avons fait de la même manière que pour la matrice.

Si nous appuyons sur un caractère du clavier, il s'affiche sur les quatre 7 segments de l'afficheur.

Affichage des caractères sur le 7 segments

Carte électronique numérique :

ReX : utilisez le squelette présenté en séance.

Carte fille réseau RNDIS :

1) Création de la carte électronique RNDIS

Nous avons choisi de réaliser la carte réseau RNDIS car nous pensons que ce projet était aussi en lien avec nos cours de réseau et de système d'exploitation, cette carte été pour nous un moyen d'en apprendre plus sur ces aspects.

La première chose à faire était de réaliser la carte électronique. Pour cela, des informations nous sont fournies. On sait alors que le microcontrôleur a utiliser doit avoir des capacités USB et que l'on peut utiliser soit un ATMega16u2, un ATMega32u4 ou un AT90USB suivant la mémoire que l'on veut disposer. Nous avons choisi d'utiliser un ATMega16u2 car nous en avions déjà utiliser un lors de notre projet en SE3 et nous étions plus à l'aise avec.

Ensuite, nous avons commencé à faire le schéma électrique de la carte réseau. Nous avons commencé à mettre les composants pour faire fonctionner le microcontrôleur de la même façon que sur le projet de SE3. Après cela, nous avons commencé à faire les entrées et sorties. On sait que la carte va communiquer avec la carte mère via un connecteur HE10, des signaux MISO, MOSI, SCK et CS sont alors à connecter au microcontrôlleur. Nous avons choisi d'utiliser les ports suivants :

• SCK ==> PB1
• MOSI ==> PB2
• MISO ==> PB3
• CS ==> PB4

De cette façon, nous pouvons récupérer et envoyer simplement des informations depuis la carte mère. Nous avons aussi connecter des LEDs sur les ports PC4 à PC7. Les autres ports sont connectés à des testpoints. La communication RNDIS se faisant via le port USB, nous avons aussi implémenter un port USB communicant via D+ et D-. Par sécurité, nous avons aussi mis un AVR-ISP dans le cas où la programmation du microcontrôleur se fasse pas correctement. Voici alors le schéma électrique de notre carte RNDIS :

Schéma électrique de la carte RNDIS

Après avoir fais le schéma électrique, nous avons fait le routage de la carte. Le routage était simple, nous avons commencé par router les parties USB et microcontôleur car nous savons comment elles doivent êtres disposées. Le plus difficile dans ce routage a été de mettre le capacités les plus proches du quartz et du microcontôleur car nous avons essayé de faire une carte compacte, et les testpoints prennent beaucoup de place sur la carte. Il fallait donc être précis sur la disposition des composants. Il fallait aussi faire attention à ce que les pistes D+ et D- soient les plus courtes et avec le moins de via possibles pour ne pas endommager les signaux qu' l'on va envoyer. Nous avons fait le plan de masse de la carte et au final nous avons réussi à compacter la carte pour qu'elle fasse une taille de 33mm x 43mm. Voici alors le routage de notre carte RNDIS.

Routage de la carte RNDIS

Voici donc une réprésentation 3D de notre carte RNDIS :

Représentation 3D de notre carte RNDIS

Nous avons alors router notre carte, il fallait donc faire un fichier ZIP à partir de ces fichiers afin que la carte puisse être envoyée en production pour que l'on puisse souder les composants par la suite. Nous avons donc suivi les étapes de ce tutoriel : https://jlcpcb.com/help/article/16-How-to-generate-Gerber-and-Drill-files-in-KiCad-6.

2) Soudure de la carte électronique RNDIS

Durant deux séances, nous avons réalisé la soudure de la carte électronique sur laquelle nous avons été aidés pour souder le quartz ainsi que le port USB. A noter que sur la carte, deux diodes ont été enlevées au niveau de l'USB car il était impossible de la reconnaître par notre machine grâce à la commande "lsusb". Hormis les diodes à enlever, aucune difficulté n'a été relevée durant la soudure de la carte.

Au final, nous avons donc une carte électronique fonctionnelle et prête à être programmée.

Voici une photo de la carte soudée :

Carte soudée

Au final, la carte est bien reconnue grâce à la commande "lsusb" :

Carte reconnue par le "lsusb"

Après cela, nous allons commencer à programmer le programme pour avoir une communication RNDIS.

3) Programmation de la carte électronique RNDIS

Pour la programmation de la carte électronique RNDIS, nous avons utiliser une démonstration LUFA déjà existante qui implémente une pile TCP/IP. En faisant directement un "make", nous avons remarqué que l'espace mémoire était dépassée. En effet, notre microcontrôleur ATMega16u2 n'a que 2k de mémoire.

Pour réduire la taille du programme, nous avons déjà réduit la taille de la trame Ethernet qui est de 1500 octets à 100 octets. Ensuite nous avons réduit la pile TCP/IP en supprimant les fichiers UDP, TCP et Webserveur qui ne nous étaient pas utiles dans le fonctionnement de notre carte. Après la commande "make", un fichier hex est bien créer mais nous avons dû changer ce fichier Makefile en conséquence pour l'adapter à notre microcontrôleur. Enfn nous avond dû changer les VendorID et les productID dans certains fichiers :

• VendorID = 0x03EB
• ProductID = 0x2FEF

Après un upload du programme sur notre carte, nous avons réussi à obtenir une nouvelle interface réseau nommée "usb0" que l'on a pu visualiser grâce à la commande "ip a".

Interface usb0 créée

Par le suite, nous avons configuré cette nouvelle interface avec la commande "ip address add 10.0.0.100/24 dev usb0" qui lui ajoute l'adresse 10.0.0.100 et un masque de classe C qui convient à nos besoins. A présent, nous pouvons faire un ping l'addresse 10.0.0.2 pour voir si elle répond bien :

Ping vers la carte RNDIS

Il faut maintenant recevoir les paquets envoyés et leur bonne réception sur le terminal. Pour rendre compte des paquets envoyés/reçus, nous allumons une LED à chaque ping :

Rendus :

Lien de notre GIT : https://archives.plil.fr/ncazin/Projet_Pico_SE4.git

Note

flatpak run org.kicad.KiCad//stable --> Lance Kicad 7