Système embarqué TCP/IP : Différence entre versions
De Wiki d'activités IMA
(→Matériel requis) |
|||
| (58 révisions intermédiaires par 4 utilisateurs non affichées) | |||
| Ligne 1 : | Ligne 1 : | ||
| + | <include nopre noesc src="/home/pedago/pimasc/include/video-ArduinoTCPIP-iframe.html" /> | ||
== Présentation == | == Présentation == | ||
| Ligne 9 : | Ligne 10 : | ||
*microcontroleur [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html Arduino Duemilanove]] (disponible) ; | *microcontroleur [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html Arduino Duemilanove]] (disponible) ; | ||
*LEDs multicolores (disponibles) ; | *LEDs multicolores (disponibles) ; | ||
| − | * | + | *moulins à vent avec moteur à courant continu : nous augmenterons la tension d'alimentation des moteurs proportionnellement à l'occupation des switch ; (commande annulée) |
| − | + | *plateforme Altium ; | |
| − | * | + | *un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (disponible). |
| − | + | *l'Ether card de Jeelabs | |
| − | + | *Matrice de leds 8*8 | |
| − | *un module ELZ50 | ||
=== Commentaires des encadrants sur le matériel === | === Commentaires des encadrants sur le matériel === | ||
| − | + | Préciser le dispositif "moulin à vent". En particulier, ils doivent être motorisés (comment ?). Vous devez aussi vous préoccuper de la commande des moteurs, ce qui impactera l'architecture à implémenter sous Altium. | |
== Avancement du projet == | == Avancement du projet == | ||
| − | === Objectifs suggérés par les encadrants === | + | === Objectifs suggérés par les encadrants pour la prise en main du sujet === |
* Ecrire un programme avec les fichiers fournis permettant dans un premier temps de créer une machine virtuelle répondant à la commande ping : | * Ecrire un programme avec les fichiers fournis permettant dans un premier temps de créer une machine virtuelle répondant à la commande ping : | ||
| − | ** nettoyer les fichiers fournis pour enlever toute référence aux sockets Unix ou Internet ; | + | ** nettoyer les fichiers fournis pour enlever toute référence aux sockets Unix ou Internet ; '''FAIT''' |
| − | ** réaliser des fonctions de lecture et d'écriture pour une interface TAP ; | + | ** réaliser des fonctions de lecture et d'écriture pour une interface TAP ; '''FAIT''' |
** écrire une procedure main réalisant les actions suivantes : | ** écrire une procedure main réalisant les actions suivantes : | ||
| − | *** initialisation d'une variables de pile TCP/IP (type netstack) ; | + | *** initialisation d'une variables de pile TCP/IP (type netstack) ; '''FAIT''' |
| − | *** création d'une interface de type TAP avec les fichiers libtap.c et libtab.h fournis ; | + | *** création d'une interface de type TAP avec les fichiers libtap.c et libtab.h fournis ; '''FAIT''' |
*** écriture d'un "pilote" pour cette interface (c'est à dire remplissage d'une structure avec le descripteur lié à l'interface et les fonctions de lecture et d'écriture sur l'interface TAP) ; | *** écriture d'un "pilote" pour cette interface (c'est à dire remplissage d'une structure avec le descripteur lié à l'interface et les fonctions de lecture et d'écriture sur l'interface TAP) ; | ||
| − | *** ajout d'une interface réseau et d'une adresse IP à cette pile (par exemple 192.168.0.100/24) ; | + | *** ajout d'une interface réseau et d'une adresse IP à cette pile (par exemple 192.168.0.100/24) ; '''FAIT''' |
| − | *** démarrage de la fonction de gestion de la pile (stackOn). | + | *** démarrage de la fonction de gestion de la pile (stackOn). '''FAIT''' |
| − | * Test de votre programme; lancement du programme, ajout d'une adresse IP (par exemple 192.168.0.200/24) sur l'interface tap0 créée par le programme, test de réponse de la pile par la commande ping (par exemple sur l'adresse 192.168.0.100). | + | * Test de votre programme; lancement du programme, ajout d'une adresse IP (par exemple 192.168.0.200/24) sur l'interface tap0 créée par le programme, test de réponse de la pile par la commande ping (par exemple sur l'adresse 192.168.0.100). '''FAIT''' |
| − | + | ||
| + | === Objectifs progressifs === | ||
| + | |||
| + | ==== '''Partie Informatique''' ==== | ||
| + | |||
| + | *Faire du profiling d'utilisation d'espace mémoire afin de voir de quelle taille il faudrait réduire le programme pour qu'il soit portable sur un arduino '''FAIT''' | ||
| + | *Tester une ou deux fonctions sur l'arduino pour savoir qu'est-ce-qu'il faut changer dans le code '''FAIT''' | ||
| + | *Inclure les fichiers en-tête de la librairie stack '''FAIT''' | ||
| + | *Créer un fichier de compilation, makefile propre à l'arduino '''FAIT''' | ||
| + | *Répartir l'analyse des différentes couches des trames | ||
| + | **Reception d'un paquet Ethernet sur l'arduino '''FAIT''' | ||
| + | **Reception d'un paquet ARP: fonction programmee | ||
| + | **Reception d'un paquet IP: fonction programmee | ||
| + | **Reception d'un paquet ICMP: fonction pragrammee | ||
| + | **Tests fonctions: '''FAIT''' | ||
| + | **Programmer une fontion avec une variable locale pour le paquet (trames ethernet contenant toutes les couches) '''FAIT''' | ||
| + | **Supprimer les tableaux de paquets et utiliser plutôt des pointeurs '''FAIT''' | ||
| + | **Augmenter la table ARP '''FAIT''' | ||
| + | **Faire la reception et le renvoi d'une trame ethernet en test '''FAIT''' | ||
| + | |||
| + | *Communication par liaison série | ||
| + | **Modifier les fonctions pour recevoir et envoyer des paquets par liaison serie '''FAIT''' | ||
| + | **Allumer une led lorsqu'on reçoit un paquet '''FAIT''' | ||
| + | **Eteindre la led lorsque le paquet reponse est envoyé | ||
| + | **Instancier une variable globale "echo" pour gerer la led multicolore '''FAIT''' | ||
| + | **Changer la couleur de la led RVB en fonction de la taille du paquet reçu | ||
| + | |||
| + | *Perspectives | ||
| + | **Créer une fonction de renvoi des paquets Ethernet reçus qui contiendra une variable Packet dans laquelle seront stockés les en-têtes dudit paquet pour l'optimisation d'espace mémoire à l’exécution du programme sur l'arduino | ||
| + | |||
| + | *Matrice de leds | ||
| + | **Ecrire une routine pour réaliser un effet graphique en fonction de l'événement repéré: envoi/réception de paquets par liaison série ou en réseau '''FAIT''' | ||
| + | *Module EZL60 | ||
| + | **ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module (module finalement non utilisé) | ||
| + | |||
| + | ==== '''Partie Électronique''' ==== | ||
| + | |||
| + | *Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet. | ||
| + | Note : Dans un premier temps, les tests sont fait avec un petit exécutable développé pour récupérer et envoyer des octets avec un adaptateur USB-Série sur un ordinateur. Dans un second temps, il faudra adapter ce code C pour faire deux fonctions intégrées à l'Arduino. | ||
| + | |||
| + | * Architecture matérielle '''FAIT''' | ||
| + | * Émission seule '''FAIT''' | ||
| + | ** Récupération d'un paquet Ethernet '''FAIT''' | ||
| + | ** Émission du paquet sur la liaison série '''FAIT''' | ||
| + | * Réception seule | ||
| + | ** Récupération d'un paquet Ethernet en série '''FAIT''' | ||
| + | ** Émission de la requête sur la liaison Ethernet '''FAIT''' | ||
| + | * E/R simultanés | ||
| + | ** Processus Multithreadé '''FAIT''' | ||
| + | ** Éventuellement : Gestion de la ressource avec un sémaphore | ||
| + | * Réception sur l'Arduino | ||
| + | ** Portage du code C de réception sur l'Arduino | ||
| + | ** Gestion de la simultanéité E/R | ||
| + | *Concevoir le module de réception des commandes actionneur de l'arduino | ||
| + | |||
| + | === Difficultés rencontrées === | ||
| + | * '''Partie Informatique''' | ||
| + | ** Comprendre le code fourni et savoir se servir des fonctions | ||
| + | ** Comprendre la syntaxe d'un makefile avec le compilateur avr dude et une édition de liens entre fichiers codés en C et ceux codés en C++,et maîtriser la compilation modulaire sur l'arduino (impossibilité d'inclure certaines bibliothèques du C) | ||
| + | ** Saisir la particularité du compilateur avr-dude dans le traitement de types de données tels "long int" qui sont tronqués; solution: on a utilisé des "short int" | ||
| + | ** Gérer la communication par liaison série avec l'arduino à l'aide de thread ( bibliothèque time) | ||
| + | |||
| + | * '''Partie Électronique''' | ||
| + | ** Conception de l'architecture matérielle avec un buffer associé à la liaison Ethernet | ||
| + | ** Décomposition de la taille du paquet Ethernet (short int = 2 octets) en deux paquets d'un octet chacun, et récupération des deux premiers paquets sur l'arduino pour reconstruire la taille du paquet. | ||
Version actuelle datée du 25 mai 2011 à 19:29
Présentation
Le but de ce projet est principalement de réaliser un système embarqué TCP/IP, qui pourrait représenter grâce aux LEDs ou à des moulins à vent la charge sur les différents commutateurs de l'école, décrivant ainsi l'activité de ces derniers.
Préparation du projet
Matériel requis
- microcontroleur [Arduino Duemilanove] (disponible) ;
- LEDs multicolores (disponibles) ;
- moulins à vent avec moteur à courant continu : nous augmenterons la tension d'alimentation des moteurs proportionnellement à l'occupation des switch ; (commande annulée)
- plateforme Altium ;
- un module ELZ50 [1] (disponible).
- l'Ether card de Jeelabs
- Matrice de leds 8*8
Commentaires des encadrants sur le matériel
Préciser le dispositif "moulin à vent". En particulier, ils doivent être motorisés (comment ?). Vous devez aussi vous préoccuper de la commande des moteurs, ce qui impactera l'architecture à implémenter sous Altium.
Avancement du projet
Objectifs suggérés par les encadrants pour la prise en main du sujet
- Ecrire un programme avec les fichiers fournis permettant dans un premier temps de créer une machine virtuelle répondant à la commande ping :
- nettoyer les fichiers fournis pour enlever toute référence aux sockets Unix ou Internet ; FAIT
- réaliser des fonctions de lecture et d'écriture pour une interface TAP ; FAIT
- écrire une procedure main réalisant les actions suivantes :
- initialisation d'une variables de pile TCP/IP (type netstack) ; FAIT
- création d'une interface de type TAP avec les fichiers libtap.c et libtab.h fournis ; FAIT
- écriture d'un "pilote" pour cette interface (c'est à dire remplissage d'une structure avec le descripteur lié à l'interface et les fonctions de lecture et d'écriture sur l'interface TAP) ;
- ajout d'une interface réseau et d'une adresse IP à cette pile (par exemple 192.168.0.100/24) ; FAIT
- démarrage de la fonction de gestion de la pile (stackOn). FAIT
- Test de votre programme; lancement du programme, ajout d'une adresse IP (par exemple 192.168.0.200/24) sur l'interface tap0 créée par le programme, test de réponse de la pile par la commande ping (par exemple sur l'adresse 192.168.0.100). FAIT
Objectifs progressifs
Partie Informatique
- Faire du profiling d'utilisation d'espace mémoire afin de voir de quelle taille il faudrait réduire le programme pour qu'il soit portable sur un arduino FAIT
- Tester une ou deux fonctions sur l'arduino pour savoir qu'est-ce-qu'il faut changer dans le code FAIT
- Inclure les fichiers en-tête de la librairie stack FAIT
- Créer un fichier de compilation, makefile propre à l'arduino FAIT
- Répartir l'analyse des différentes couches des trames
- Reception d'un paquet Ethernet sur l'arduino FAIT
- Reception d'un paquet ARP: fonction programmee
- Reception d'un paquet IP: fonction programmee
- Reception d'un paquet ICMP: fonction pragrammee
- Tests fonctions: FAIT
- Programmer une fontion avec une variable locale pour le paquet (trames ethernet contenant toutes les couches) FAIT
- Supprimer les tableaux de paquets et utiliser plutôt des pointeurs FAIT
- Augmenter la table ARP FAIT
- Faire la reception et le renvoi d'une trame ethernet en test FAIT
- Communication par liaison série
- Modifier les fonctions pour recevoir et envoyer des paquets par liaison serie FAIT
- Allumer une led lorsqu'on reçoit un paquet FAIT
- Eteindre la led lorsque le paquet reponse est envoyé
- Instancier une variable globale "echo" pour gerer la led multicolore FAIT
- Changer la couleur de la led RVB en fonction de la taille du paquet reçu
- Perspectives
- Créer une fonction de renvoi des paquets Ethernet reçus qui contiendra une variable Packet dans laquelle seront stockés les en-têtes dudit paquet pour l'optimisation d'espace mémoire à l’exécution du programme sur l'arduino
- Matrice de leds
- Ecrire une routine pour réaliser un effet graphique en fonction de l'événement repéré: envoi/réception de paquets par liaison série ou en réseau FAIT
- Module EZL60
- ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module (module finalement non utilisé)
Partie Électronique
- Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet.
Note : Dans un premier temps, les tests sont fait avec un petit exécutable développé pour récupérer et envoyer des octets avec un adaptateur USB-Série sur un ordinateur. Dans un second temps, il faudra adapter ce code C pour faire deux fonctions intégrées à l'Arduino.
- Architecture matérielle FAIT
- Émission seule FAIT
- Récupération d'un paquet Ethernet FAIT
- Émission du paquet sur la liaison série FAIT
- Réception seule
- Récupération d'un paquet Ethernet en série FAIT
- Émission de la requête sur la liaison Ethernet FAIT
- E/R simultanés
- Processus Multithreadé FAIT
- Éventuellement : Gestion de la ressource avec un sémaphore
- Réception sur l'Arduino
- Portage du code C de réception sur l'Arduino
- Gestion de la simultanéité E/R
- Concevoir le module de réception des commandes actionneur de l'arduino
Difficultés rencontrées
- Partie Informatique
- Comprendre le code fourni et savoir se servir des fonctions
- Comprendre la syntaxe d'un makefile avec le compilateur avr dude et une édition de liens entre fichiers codés en C et ceux codés en C++,et maîtriser la compilation modulaire sur l'arduino (impossibilité d'inclure certaines bibliothèques du C)
- Saisir la particularité du compilateur avr-dude dans le traitement de types de données tels "long int" qui sont tronqués; solution: on a utilisé des "short int"
- Gérer la communication par liaison série avec l'arduino à l'aide de thread ( bibliothèque time)
- Partie Électronique
- Conception de l'architecture matérielle avec un buffer associé à la liaison Ethernet
- Décomposition de la taille du paquet Ethernet (short int = 2 octets) en deux paquets d'un octet chacun, et récupération des deux premiers paquets sur l'arduino pour reconstruire la taille du paquet.
