« SE4Binome2023-4 » : différence entre les versions
(→Paquet) |
|||
Ligne 138 : | Ligne 138 : | ||
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]] | [[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]] | ||
==== | ==== Création du protocole ==== | ||
Ligne 170 : | Ligne 170 : | ||
Voici la structure de notre protocole :<syntaxhighlight lang="c"> | Voici la structure de notre protocole :<syntaxhighlight lang="c"> | ||
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; | |||
</syntaxhighlight> | </syntaxhighlight> | ||
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --> OK (voir vidéo ci-dessous) | * La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --> OK (voir vidéo ci-dessous) | ||
Ligne 178 : | Ligne 187 : | ||
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu'on utilise notre protocole. | [[Fichier:Image des paquets.jpg|néant|vignette|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 | |||
[[Fichier:Envoi.png|néant|vignette|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. | |||
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l'application]] | |||
Nous avons donc un fichier qui contient le texte : "Test Envoi : Ajout par la carte". | |||
[[Fichier:Recept.png|néant|vignette|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. |
Version du 21 décembre 2023 à 11:21
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.
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 :
#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 :
- Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )
- Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )
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
Après avoir terminé le schematic, on peut passer au routage de la carte
Une fois la carte recue, il faut passer à la soudure :
Carte Vide | 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.
#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"
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 :
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS (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)
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)
- 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.
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
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.
Nous avons donc un fichier qui contient le texte : "Test Envoi : Ajout par la carte".
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.