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

Système embarqué TCP/IP

2011-04-06T11:45:24Z

Rproyart : /* 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
*Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
*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 sur à l’exécution du programme sur l'arduino
*Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

==== '''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-06T11:44:53Z

Rproyart : /* Partie Électronique */

== 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

==== '''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-06T11:44:21Z

Rproyart : /* *Partie Électronique */

== 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

==== '''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-06T11:44:09Z

Rproyart : /* *Partie Électronique */

== 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

==== *'''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-06T11:43:58Z

Rproyart : /* 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

=== *'''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-06T11:43:33Z

Rproyart : /* *Partie Électronique */

== 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

=== *'''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-06T11:42:43Z

Rproyart : /* *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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

== *'''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-06T11:41:44Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)

== *'''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-06T11:38:08Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)
*'''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-06T11:36:02Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)
*'''Partie Électronique'''
**Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet.
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

**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-06T11:35:18Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)
*'''Partie Électronique'''
**Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet.
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

**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-06T11:28:29Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)
*'''Partie Électronique'''
**Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet.
** Émission seule '''FAIT'''
*** => Architecture matérielle '''FAIT'''
*** => Récupération d'un paquet Ethernet '''FAIT'''

** Réception seule
*** => E/R simultanés (processus multithreadé)
*** => Réception sur l'Arduino

**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-06T11:23:55Z

Rproyart : /* Difficultes rencontrees */

== 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)
*'''Partie Électronique'''
**Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet.
** => Émission seule '''FAIT'''
** => Réception seule
** => E/R simultanés (processus multithreadé)
** => Réception sur l'Arduino

**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-06T11:20:06Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)
*'''Partie Électronique'''
**Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet.
** => Émission seule '''FAIT'''
** => Réception seule
** => E/R simultanés (processus multithreadé)
** => Réception sur l'Arduino

**Concevoir le module de réception des commandes actionneur de l'arduino

=== Difficultes rencontrees ===
* 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

Système embarqué TCP/IP

2011-04-06T11:19:43Z

Rproyart :

== 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets Ethernet
**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 sur à l’exécution du programme sur l'arduino
**Vérifier et tester le renvoi correct du/des paquet(s) reçu(s)
*Partie Électronique
**Concevoir le module d'émission/réception de la plate-forme altium vers l'arduino des trames Ethernet.
** => Émission seule '''FAIT'''
** => Réception seule
** => E/R simultanés (processus multithreadé)
** => Réception sur l'Arduino

**Concevoir le module de réception des commandes actionneur de l'arduino

=== Difficultes rencontrees ===
* 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

Système embarqué TCP/IP

2011-03-28T14:39:17Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets ethernet
**Creer 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 sur à l'xécution du programme sur l'arduino
**Verifier et tester le renvoi correct du/des paquet(s) reçu(s)
*Partie Electronique
**Concevoir le module d'émission/réception de la plateforme altium vers l'arduino des trames Ethernet. Emission : '''FAIT'''
**Concevoir le module de réception des commandes actionneur de l'arduino

=== Difficultes rencontrees ===
* 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

Système embarqué TCP/IP

2011-03-28T14:39:00Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets ethernet
**Creer 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 sur à l'xécution du programme sur l'arduino
**Verifier et tester le renvoi correct du/des paquet(s) reçu(s)
*Partie Electronique
**Concevoir le module d'émission/réception de la plateforme altium vers l'arduino des trames Ethernet. Emission : '"FAIT'"
**Concevoir le module de réception des commandes actionneur de l'arduino

=== Difficultes rencontrees ===
* 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

Système embarqué TCP/IP

2011-03-28T14:38:47Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets ethernet
**Creer 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 sur à l'xécution du programme sur l'arduino
**Verifier et tester le renvoi correct du/des paquet(s) reçu(s)
*Partie Electronique
**Concevoir le module d'émission/réception de la plateforme altium vers l'arduino des trames Ethernet. Emission : '"FAIT"'
**Concevoir le module de réception des commandes actionneur de l'arduino

=== Difficultes rencontrees ===
* 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

Système embarqué TCP/IP

2011-03-28T14:38:23Z

Rproyart : /* 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 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 ainsi que le Makefile arduino et vérifier qu'on peut bien créer une machine virtuelle sur l'arduino '''FAIT'''
**Vérifier qu'avec la machine virtuelle créée sur l'arduino on peut bien envoyer et recevoir des paquets ethernet
**Creer 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 sur à l'xécution du programme sur l'arduino
**Verifier et tester le renvoi correct du/des paquet(s) reçu(s)
*Partie Electronique
**Concevoir le module d'émission/réception de la plateforme altium vers l'arduino des trames Ethernet. Emission : "FAIT"
**Concevoir le module de réception des commandes actionneur de l'arduino

=== Difficultes rencontrees ===
* 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

Système embarqué TCP/IP

2011-03-03T10:00:17Z

Rproyart : /* Matériel requis */

Système embarqué TCP/IP

2011-03-03T09:59:53Z

Rproyart : /* Matériel requis */

Système embarqué TCP/IP

2011-02-28T17:08:48Z

Rproyart : /* Matériel requis */

Système embarqué TCP/IP

2011-02-28T17:08:13Z

Rproyart : /* Matériel requis */