Wiki d'activités IMA - Contributions de l’utilisateur [fr]

Système embarqué TCP/IP

2011-05-04T07:39:46Z

Byanou-t : /* Partie Informatique */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (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.

Système embarqué TCP/IP

2011-05-04T07:38:31Z

Byanou-t : /* Matériel requis */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (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
*Module EZL60
**ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module

==== '''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.

Système embarqué TCP/IP

2011-05-04T07:37:13Z

Byanou-t : /* Objectifs suggérés par les encadrants */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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
*Module EZL60
**ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module

==== '''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.

Système embarqué TCP/IP

2011-05-04T07:36:43Z

Byanou-t : /* Partie Informatique */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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
*Module EZL60
**ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module

==== '''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.

Système embarqué TCP/IP

2011-05-04T07:34:59Z

Byanou-t : /* Partie Informatique */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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
*Module EZL60
**ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module

==== '''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.

Système embarqué TCP/IP

2011-05-04T07:32:56Z

Byanou-t : /* Difficultés rencontrées */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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
**Eteindre la led lorsque le paquet reponse est envoyé
**Instancier une variable globale "echo" pour gerer la led multicolore et le buzzer
*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
*Module EZL60
**ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module

==== '''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.

Système embarqué TCP/IP

2011-04-28T12:10:55Z

Byanou-t : /* Difficultés rencontrées */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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
**Eteindre la led lorsque le paquet reponse est envoyé
**Instancier une variable globale "echo" pour gerer la led multicolore et le buzzer
*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
*Module EZL60
**ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module

==== '''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 et maîtriser la compilation modulaire sur l'arduino
** 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.

Système embarqué TCP/IP

2011-04-28T12:09:15Z

Byanou-t : /* Partie Informatique */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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
**Eteindre la led lorsque le paquet reponse est envoyé
**Instancier une variable globale "echo" pour gerer la led multicolore et le buzzer
*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
*Module EZL60
**ecrire un programme permettant à l'arduino d'envoyer et de recevoir des paquets par liaison série vers le module

==== '''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 et maîtriser la compilation modulaire sur l'arduino
** 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"

* '''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.

Système embarqué TCP/IP

2011-04-12T17:34:10Z

Byanou-t : /* Difficultés rencontrées */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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
**Eteindre la led lorsque le paquet reponse est envoyé
**Instancier une variable globale "echo" pour gerer la led multicolore et le buzzer
*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

==== '''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 et maîtriser la compilation modulaire sur l'arduino
** 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"

* '''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.

Système embarqué TCP/IP

2011-04-12T17:32:28Z

Byanou-t : /* Objectifs suggérés pas les élèves (les encadrants y ont droit de modification) */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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
**Eteindre la led lorsque le paquet reponse est envoyé
**Instancier une variable globale "echo" pour gerer la led multicolore et le buzzer
*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

==== '''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 et maîtriser la compilation modulaire sur l'arduino

* '''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.

Système embarqué TCP/IP

2011-04-12T17:28:51Z

Byanou-t : /* Partie Informatique */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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 suggérés pas les élèves (les encadrants y ont droit de modification) ===

==== '''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
**Eteindre la led lorsque le paquet reponse est envoyé
**Instancier une variable globale "echo" pour gerer la led multicolore et le buzzer
*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

==== '''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 et maîtriser la compilation modulaire sur l'arduino

* '''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.

Système embarqué TCP/IP

2011-04-07T12:08:55Z

Byanou-t : /* Partie Informatique */

== 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 [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html 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 ;
*câbles ;
*plateforme Altium ;
*un module ELZ50 [http://www.atmicroprog.com/realisations/elz50/elz50.php] (commande en cours).

=== 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 ===

* 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 suggérés pas les élèves (les encadrants y ont droit de modification) ===

==== '''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
*Programmer une fontion avec une variable locale pour le paquet (trames ethernet contenant toutes les couches)
*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

==== '''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 et maîtriser la compilation modulaire sur l'arduino

* '''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.

Système embarqué TCP/IP

2011-03-21T15:03:01Z

Byanou-t : /* Objectifs suggérés pas les élèves (les encadrants y ont droit de modification) */

Système embarqué TCP/IP

2011-03-21T15:02:12Z

Byanou-t : /* Difficultes rencontrees */

Système embarqué TCP/IP

2011-03-17T08:18:39Z

Byanou-t : /* Difficultes rencontrees */

Système embarqué TCP/IP

2011-03-17T08:18:06Z

Byanou-t : /* Objectifs suggérés pas les élèves (les encadrants y ont droit de modification) */

Système embarqué TCP/IP

2011-03-17T08:14:25Z

Byanou-t : /* Difficultes rencontrees */

Système embarqué TCP/IP

2011-03-17T08:12:09Z

Byanou-t : /* Objectifs suggérés pas les élèves (les encadrants y ont droit de modification) */

Système embarqué TCP/IP

2011-03-08T15:34:31Z

Byanou-t : /* Objectifs suggérés pas les élèves (les encadrants y ont droit de modification) */

Système embarqué TCP/IP

2011-03-08T15:33:48Z

Byanou-t : /* Objectifs suggérés pas les élèves (les encadrants y ont droit de modification) */

Système embarqué TCP/IP

2011-03-08T15:33:28Z

Byanou-t : /* Objectifs suggérés pas les élèves (les encadrants y ont droit de modification) */

Système embarqué TCP/IP

2011-03-04T15:36:58Z

Byanou-t : /* Objectifs suggérés par les encadrants */

Système embarqué TCP/IP

2011-03-04T13:58:29Z

Byanou-t : /* Difficultes rencontrees */

Système embarqué TCP/IP

2011-03-03T08:46:30Z

Byanou-t : /* Avancement du projet */

Système embarqué TCP/IP

2011-03-03T08:46:02Z

Byanou-t : /* Préparation du projet */

Système embarqué TCP/IP

2011-03-03T08:45:17Z

Byanou-t : /* Objectifs suggérés par les encadrants */

Système embarqué TCP/IP

2011-03-03T07:39:04Z

Byanou-t : /* Objectifs suggérés par les encadrants */

Système embarqué TCP/IP

2011-03-03T07:37:58Z

Byanou-t : /* Objectifs suggérés par les encadrants */

Système embarqué TCP/IP

2011-03-03T07:35:42Z

Byanou-t : /* Préparation du projet */

Système embarqué TCP/IP

2011-02-28T14:51:13Z

Byanou-t : /* Présentation */

== 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 les commutateurs des différents départements de l'école, décrivant ainsi l'activité de chacun de ces derniers. Il vient à la suite du sujet GIS4 2010/2011 sans la partie IPC.

== Préparation du projet ==

=== Matériel requis ===
*microcontroleur [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html Arduino Duemilanove]] ;
*LEDs multicolores ;
*système FoxBoard ;
*clé wifi ou câbles croisés (choix pas encore fait)
*Adaptateur Wifi USB
*Plateforme Altium
*Un modem soft
*un module ELZ50 (http://www.atmicroprog.com/realisations/elz50/elz50.php)

== Avancement du projet ==
'''1ère étape''':

Nous partirons tout d'abord du projet GIS4 2010/2011 pour implanter sur l'arduino la pile TCP/IP.

Système embarqué TCP/IP

2011-02-16T21:00:36Z

Byanou-t : /* Matériel requis */

== 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 consommation d'énergie des différents départements de l'école, décrivant ainsi l'activité de chacun de ces derniers. Il vient à la suite du sujet GIS4 2010/2011 sans la partie IPC.

== Préparation du projet ==

=== Matériel requis ===
*microcontroleur [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html Arduino Duemilanove]] ;
*LEDs multicolores ;
*système FoxBoard ;
*clé wifi ou câbles croisés (choix pas encore fait)
*Adaptateur Wifi USB
*Plateforme Altium
*Un modem soft
*un module ELZ50 (http://www.atmicroprog.com/realisations/elz50/elz50.php)

== Avancement du projet ==
'''1ère étape''':

Nous partirons tout d'abord du projet GIS4 2010/2011 pour implanter sur l'arduino la pile TCP/IP.

Système embarqué TCP/IP

2011-02-16T20:44:13Z

Byanou-t : /* Avancement du projet */

== 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 consommation d'énergie des différents départements de l'école, décrivant ainsi l'activité de chacun de ces derniers. Il vient à la suite du sujet GIS4 2010/2011 sans la partie IPC.

== Préparation du projet ==

=== Matériel requis ===
*microcontroleur [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html Arduino Duemilanove]] ;
*LEDs multicolores ;
*système FoxBoard ;
*clé wifi ou câbles croisés (choix pas encore fait)
*Adaptateur Wifi USB
*Plateforme Altium

== Avancement du projet ==
'''1ère étape''':

Nous partirons tout d'abord du projet GIS4 2010/2011 pour implanter sur l'arduino la pile TCP/IP.

Système embarqué TCP/IP

2011-02-16T20:41:08Z

Byanou-t : /* Matériel requis */

== 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 consommation d'énergie des différents départements de l'école, décrivant ainsi l'activité de chacun de ces derniers. Il vient à la suite du sujet GIS4 2010/2011 sans la partie IPC.

== Préparation du projet ==

=== Matériel requis ===
*microcontroleur [[http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html Arduino Duemilanove]] ;
*LEDs multicolores ;
*système FoxBoard ;
*clé wifi ou câbles croisés (choix pas encore fait)
*Adaptateur Wifi USB
*Plateforme Altium

== Avancement du projet ==
'''1ère étape''':

Nous partirons tout d'abord du projet GIS4 2010/2011 pour implanter sur l'arduino pour implanter la pile TCP/IP.

Système embarqué TCP/IP

2011-02-15T21:09:59Z

Byanou-t : /* Matériel requis */

== '''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 consommation d'énergie des différents départements de l'école, décrivant ainsi l'activité de chacun de ces derniers. Il vient à la suite du sujet GIS4 2010/2011 sans la partie IPC.

== Préparation du projet ==

=== Matériel requis ===
*Un microcontroleur Arduino Duemilanove (http://www.robotshop.com/microcontroleur-arduino-uno-usb-2.html)
*LEDs multicolores
*Système foxboard
*Clé wifi ou câbles croisés (choix pas encore fait)

== Avancement du projet ==
'''1ère étape''':

Nous partirons tout d'abord du projet GIS4 2010/2011 pour implanter sur l'arduino pour implanter la pile TCP/IP.

Système embarqué TCP/IP

2011-02-15T21:06:38Z

Byanou-t : /* Présentation */

== '''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 consommation d'énergie des différents départements de l'école, décrivant ainsi l'activité de chacun de ces derniers. Il vient à la suite du sujet GIS4 2010/2011 sans la partie IPC.

== Préparation du projet ==

=== Matériel requis ===
*Un microcontroleur Arduino Duemilanove
*LEDs multicolores
*Système foxboard
*Clé wifi ou câbles croisés (choix pas encore fait)

== Avancement du projet ==
'''1ère étape''':

Nous partirons tout d'abord du projet GIS4 2010/2011 pour implanter sur l'arduino pour implanter la pile TCP/IP.

Système embarqué TCP/IP

2011-02-15T21:04:19Z

Byanou-t : /* Préparation du projet */

== '''Présentation''' ==

Le but de ce projet est principalement de réaliser un système embarqué TCP/IP.

== Préparation du projet ==

=== Matériel requis ===
*Un microcontroleur Arduino Duemilanove
*LEDs multicolores
*Système foxboard
*Clé wifi ou câbles croisés (choix pas encore fait)

== Avancement du projet ==
'''1ère étape''':

Nous partirons tout d'abord du projet GIS4 2010/2011 pour implanter sur l'arduino pour implanter la pile TCP/IP.

Système embarqué TCP/IP

2011-02-15T20:59:08Z

Byanou-t : /* Matériel requis */

Système embarqué TCP/IP

2011-02-15T20:54:43Z

Byanou-t : /* Matériel requis */

Système embarqué TCP/IP

2011-02-15T20:53:37Z

Byanou-t : /* Matériel requis */

== '''Présentation''' ==

Le but de ce projet est principalement de réaliser un système embarqué TCP/IP.

== Préparation du projet ==

== Matériel requis ==

Un microcontroleur Arduino Duemilanove
LEDs multicolores

Système embarqué TCP/IP

2011-02-15T20:50:52Z

Byanou-t :

Système embarqué TCP/IP

2011-02-15T20:30:17Z

Byanou-t : Nouvelle page : == '''Présentation''' == Le but de ce projet est principalement de réaliser un système embarqué TCP/IP.

== '''Présentation''' ==

Le but de ce projet est principalement de réaliser un système embarqué TCP/IP.