SE4Binome2023-4

GIT

Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git

Ordonnanceur

Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.

Réalisation du shield

La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d'effectuer tous les tests liés au programme de l'ordonnanceur.

Première partie du shield	Shield terminé
Adaptateur LED	Câbles

Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :

LED Shield

#include <avr/io.h>

void init_led(){
  DDRD=0x92;
  DDRC=0x09;
}

int main(){
  init_led();
  while(1)
    {
	PORTD=0x92;
	PORTC=0x09;
    }
  return 0;
}

Programmation

Nous pouvons donc commencer à travailler sur l’ordonnanceur :

• Première étape : Création d'un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK

• Deuxième étape : Modification du code afin d'avoir un état "ACTIF" ou "SLEEP" sur une tâche : OK
• Troisième étape : Ajout de la lecture et de l'écriture sur le port USB avec utilisation des sémaphores : OK

La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :

Demo USART

• Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )

Matrice de LED

• Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )

7-segments

Nous avons complété l'ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.

Carte électronique numérique

Carte choisie : Carte Réseau RNDIS

Commentaire :

- Problème 1 : Mauvais positionnement de Chip Select dans la conception --> OK

Partie 1 : Réalisation de la carte

Il faut donc effectuer la conception de la carte :

On commence par le schematic ci-joint

Schematic carte RNDIS

Après avoir terminé le schematic, on peut passer au routage de la carte

Routage

Une fois la carte recue, il faut passer à la soudure :

Carte Vide Carte Vide	Carte Soudée Carte Soudée

Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d'étain entre PB0 et PB4 pour régler ce problème

Partie 2 : Programmation

Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci

Test Basique

Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l'envoie du code s'effectue correctement sur la carte et que les soudures sont bonnes.

LED RNDIS

#include <avr/io.h>
#include <util/delay.h>

void init_led()
{
  DDRD=0x01;
}

int main(){
  CLKSEL0 = 0b00010101;   // sélection de l'horloge externe
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz
  CLKPR = 0b10000000;     // modification du diviseur d'horloge (CLKPCE=1)
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)
  init_led();
  while(1)
    {
      PORTD=0x01;
      _delay_ms(500);
      PORTD=0x00;
      _delay_ms(500);
    }
  return 0;
}

Test LUFA RNDIS

Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS

Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l'Ethernet et ICMP.

Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface "usb0"

Test lsusb

Par la suite, il faut affecter une adresse IP à notre carte :

ip address add 10.0.0.100/24 dev usb0

Et "allumer" l'interface usb0 :

ip link set usb0 up

On obtient avec ip a :

Vérification ip a

Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS (10.0.0.2) :

ping 10.0.0.2

Création du protocole

Nous allons d'abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l'état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)

PingLED

Il faut ensuite utiliser une application développer sur le PC pour recevoir ou envoyer des paquets Ethernet sur notre carte :

• Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d'un ping sur celle ci --> OK (voir vidéo ci-dessous)

Lecture des paquets sur l'application

• La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.

	switch (SwapEndian_16(FrameINHeader->EtherType))
	  {
	  case ETHERTYPE_ARP:
	    RetSize = ARP_ProcessARPPacket(&FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],
					   &FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);
	    break;
	  case ETHERTYPE_IPV4:
	    RetSize = IP_ProcessIPPacket(&FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],
					   &FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);
	    break;
	  case ETHERTYPE_MONPROTO:	  
	    RetSize = MonProto_ProcessPacket(&FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],
				       &FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);
	    break;
	  }

Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d'un envoi de paquet. Voici la structure de notre protocole :

typedef struct
{
  uint8_t       Operation;
  MAC_Address_t MAddr_SRC;
  IP_Address_t  PAddr_SRC;
  MAC_Address_t MAddr_DESC;
  IP_Address_t  PAddr_DESC;
  uint8_t       Longueur;
  uint8_t       Data[MAX_DATA];
} Proto_Header_t;

• La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --> OK (voir vidéo ci-dessous)

Il faut que, avant d'envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.

Renvoie d'un "écho" du paquet

Image des paquets

Nous avons donc bien un écho avec inversion des adresses lorsqu'on utilise notre protocole.

Paquet

Réception

Pour créer un fichier sur le PC, nous devons :

- Envoyer avec l'application, un paquet contenant "l'ordre" d'envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --> Il aurait fallu que cette opération s'effectue grâce au bus SPI et à la carte mère.

- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.

- Le paquet est ensuite renvoyé sur l'application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.

Exemple :

Nous envoyons donc notre ordre avec en plus un texte : "Test Envoi :" --> Avec l'application pas avec la carte mère

Paquet envoyé par l'application

La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : " Ajout par la carte"

Elle envoie donc le paquet modifié à l'application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.

Paquet reçu par l'application

Nous avons donc un fichier qui contient le texte : "Test Envoi : Ajout par la carte".

Contenu du fichier

Lecture

Pour lire un fichier sur le PC, nous devons:

- Envoyer avec l'application, un paquet contenant "l'ordre" de lire un fichier (0x02) --> Il aurait fallu que cette opération s'effectue grâce au bus SPI et à la carte mère.

- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d'ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l'application

- L'application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --> a envoyer à la carte mère.