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

IMA4 2017/2018 EC5

2018-06-14T14:13:19Z

Groux : /* Documents */

== Présentation du projet ==

=== Contexte ===

L'élève continue son semestre S8 à l'école.

=== Objectif ===

Il vous est demandé d'écrire un programme C permettant de simuler l'ordonnancement de processus avec gestion de ressources communes suivant les algorithmes tourniquet et priorité avec préemption.

=== Description du projet ===

Vous commencerez par créer les structures de données pour pouvoir décrire, dans le code C, les processus que votre ordonnanceur va devoir gérer.

Les caractéristiques des processus à prendre en compte sont :
* un numéro permettant d'identifier les processus ;
* une date de départ du processus par rapport à une horloge globale ;
* les divers événements du processus par rapport à son horloge interne correspondant au temps passé en exécution :
** réclamation d'une ressource commune ;
** libération d'une ressource commune ;
** terminaison du processus.

Un exemple de description de processus est donné ci-après.

int nb_procs=4;
struct event p1_events[]={ {30,OP_CLAIM,R1}, {70,OP_RELEASE,R1}, {100,OP_STOP} };
struct event p2_events[]={ {80,OP_CLAIM,R1}, {180,OP_RELEASE,R1}, {200,OP_STOP} };
struct event p3_events[]={ {40,OP_CLAIM,R1}, {160,OP_RELEASE,R1}, {300,OP_STOP} };
struct event p4_events[]={ {400,OP_STOP} };
struct process procs[]={
{.number=1,.start=150,.priority=1,.events=p1_events},
{.number=2,.start=100,.priority=2,.events=p2_events},
{.number=3,.start=50,.priority=3,.events=p3_events},
{.number=4,.start=0,.priority=4,.events=p4_events}
};

Les caractéristiques des ressources à prendre en compte sont :
* un numéro permettant d'identifier les ressources ;
* le nombre d'occurrences de la ressource disponibles.

Pour simuler les deux algorithmes d'ordonnancement, vous utiliserez un algorithme "intelligent" :
* faites partir le temps de zéro puis rentrez dans une boucle infinie où le temps saute directement à l'événement suivant (arrivé d'un processus, événement pour le processus courant, fin du quantum de temps, etc) ;
* voyez si un nouvel événement se traduit par un changement d'état du processus courant et l'activation d'un autre processus ;
* si tous les processus sont terminés, sortez de la boucle.

A chaque événement imprimez un code permettant de suivre l'exécution :
* pour la réclamation ou la libération d'une ressource affichez le temps global, le caractére <code>R</code> comme ressource, son numéro et <code>+</code> ou <code>-</code> suivant qu'il s'agit d'une réclamation ou d'une libération ;
* pour le changement d'état d'un processus, affichez le temps global, le caractére <code>P</code> comme processus, son numéro et <code>[</code> ou <code>]</code> suivant qu'il s'agit de l'activation ou de la mise en sommeil du processus.

Pour chaque simulation lancez les deux algorithmes d'ordonnancement. Vérifiez votre programme avec les différents exercices d'ordonnancement des DS de système des années passées.

Une fois le programme fonctionnel étudiez les différentes variantes possibles pour les deux algorithmes. Par exemple pour le tourniquet, le quantum de temps est-il ou non prioritaire sur une opération sur une ressource qui est programmée au même instant ? Par exemple pour la priorité avec préemption, comment choisir entre des processus avec la même priorité ?

=== Planning prévisionnel ===

== Travail effectué ==
Le début de travail à été de créer les différentes structures afin de pouvoir construire l'ordonnancement.

On a pu différencier 3 structures différentes : Celle de la ressource, celle du processus et celle d'un événement.

Les structures sont les suivantes :

struct ressource
{
int num_ressource;
int nb_occurence;
};
typedef struct ressource Ressource;

struct event
{
int demande;
int action;
Ressource R;
};
typedef struct event Event;

struct process
{
int number;
int start;
int priority;
int nbEvent;
Event* event;
};
typedef struct process Process;

Une fois celle ci définit, il a donc fallu créer un ordonnancement par tourniquet dans un premier temps, puis dans un second temps par priorité avec préemption.

Afin de réaliser ces ordonnancement, j'ai repris les événements et les processus du Ds du 6 janvier 2017.

Une fois cette étapes de retranscription finie il a fallu créer les fonctions utile au déroulement de l'ordonnancement : afin que celui ci se rapproche au plus près de la réalité, j'ai établie les règles suivantes :
-Un temps de switch era mis en place afin qu'il existe un temps de battement entre les changements de processus
-Si deux processus démarre en même temps, c'est le premier arrivé dans le programme qui s'exécutera
-Un temps de switch et de quantum sera demandé au début du programme

Pour le second, si un processus en cours, demande de prendre la main alors qu'il a une priorité égale, la demande sera rejetée.

Réponse aux questions :
Le quantum de temps est-il ou non prioritaire sur une opération sur une ressource qui est programmée au même instant ?
Dans mon programme, avant de commencer une opération qui demandera une ressource quelconque il est observé si le quantum de temps se termine. En effet si l'inverse était fait, un processus pourrait prendre un ressource sans l'utiliser. Si celle est demandé dans le future elle ne pourra pas être utilisé. Je pense donc que la priorité doit être donné au quantum et non à l'opération.

Pour la priorité avec préemption, comment choisir entre des processus avec la même priorité ?

Pour choisir entre deux processus ayant la même priorité, il existe plusieurs solution : soit le premier arrivé reste tant qu'il n'est pas fini, soit on compare le temps restant pour chacun d'entre eux et l'on prend celui dont le temps restant est le plus court afin de libérer au plus vite les ressources.

== Sources ==
Les principales sources ont été celles données au début du rattrapage ainsi que le cours de système et de temps réel du semestre 7.

== Documents ==

[[Fichier:Rattrapage_système.zip]]

Fichier:Rattrapage système.zip

2018-06-14T14:11:15Z

Groux :

IMA4 2017/2018 EC5

2018-06-12T07:25:57Z

Groux : /* Travail effectué */

IMA4 2017/2018 EC5

2018-06-12T07:05:04Z

Groux : /* Sources */

== Présentation du projet ==

=== Contexte ===

L'élève continue son semestre S8 à l'école.

=== Objectif ===

Il vous est demandé d'écrire un programme C permettant de simuler l'ordonnancement de processus avec gestion de ressources communes suivant les algorithmes tourniquet et priorité avec préemption.

=== Description du projet ===

Vous commencerez par créer les structures de données pour pouvoir décrire, dans le code C, les processus que votre ordonnanceur va devoir gérer.

Les caractéristiques des processus à prendre en compte sont :
* un numéro permettant d'identifier les processus ;
* une date de départ du processus par rapport à une horloge globale ;
* les divers événements du processus par rapport à son horloge interne correspondant au temps passé en exécution :
** réclamation d'une ressource commune ;
** libération d'une ressource commune ;
** terminaison du processus.

Un exemple de description de processus est donné ci-après.

int nb_procs=4;
struct event p1_events[]={ {30,OP_CLAIM,R1}, {70,OP_RELEASE,R1}, {100,OP_STOP} };
struct event p2_events[]={ {80,OP_CLAIM,R1}, {180,OP_RELEASE,R1}, {200,OP_STOP} };
struct event p3_events[]={ {40,OP_CLAIM,R1}, {160,OP_RELEASE,R1}, {300,OP_STOP} };
struct event p4_events[]={ {400,OP_STOP} };
struct process procs[]={
{.number=1,.start=150,.priority=1,.events=p1_events},
{.number=2,.start=100,.priority=2,.events=p2_events},
{.number=3,.start=50,.priority=3,.events=p3_events},
{.number=4,.start=0,.priority=4,.events=p4_events}
};

Les caractéristiques des ressources à prendre en compte sont :
* un numéro permettant d'identifier les ressources ;
* le nombre d'occurrences de la ressource disponibles.

Pour simuler les deux algorithmes d'ordonnancement, vous utiliserez un algorithme "intelligent" :
* faites partir le temps de zéro puis rentrez dans une boucle infinie où le temps saute directement à l'événement suivant (arrivé d'un processus, événement pour le processus courant, fin du quantum de temps, etc) ;
* voyez si un nouvel événement se traduit par un changement d'état du processus courant et l'activation d'un autre processus ;
* si tous les processus sont terminés, sortez de la boucle.

A chaque événement imprimez un code permettant de suivre l'exécution :
* pour la réclamation ou la libération d'une ressource affichez le temps global, le caractére <code>R</code> comme ressource, son numéro et <code>+</code> ou <code>-</code> suivant qu'il s'agit d'une réclamation ou d'une libération ;
* pour le changement d'état d'un processus, affichez le temps global, le caractére <code>P</code> comme processus, son numéro et <code>[</code> ou <code>]</code> suivant qu'il s'agit de l'activation ou de la mise en sommeil du processus.

Pour chaque simulation lancez les deux algorithmes d'ordonnancement. Vérifiez votre programme avec les différents exercices d'ordonnancement des DS de système des années passées.

Une fois le programme fonctionnel étudiez les différentes variantes possibles pour les deux algorithmes. Par exemple pour le tourniquet, le quantum de temps est-il ou non prioritaire sur une opération sur une ressource qui est programmée au même instant ? Par exemple pour la priorité avec préemption, comment choisir entre des processus avec la même priorité ?

=== Planning prévisionnel ===

== Travail effectué ==
Le début de travail à été de créer les différentes structures afin de pouvoir construire l'ordonnancement.

On a pu différencier 3 structures différentes : Celle de la ressource, celle du processus et celle d'un événement.

Les structures sont les suivantes :

struct ressource
{
int num_ressource;
int nb_occurence;
};
typedef struct ressource Ressource;

struct event
{
int demande;
int action;
Ressource R;
};
typedef struct event Event;

struct process
{
int number;
int start;
int priority;
int nbEvent;
Event* event;
};
typedef struct process Process;

Une fois celle ci définit, il a donc fallu créer un ordonnancement par tourniquet dans un premier temps, puis dans un second temps par priorité avec préemption.

Afin de réaliser ces ordonnancement, j'ai repris les événements et les processus du Ds du 6 janvier 2017.

Une fois cette étapes de retranscription finie il a fallu créer les fonctions utile au déroulement de l'ordonnancement : afin que celui ci se rapproche au plus près de la réalité, j'ai établie les règles suivantes :
-Un temps de switch era mis en place afin qu'il existe un temps de battement entre les changements de processus
-Si deux processus démarre en même temps, c'est le premier arrivé dans le programme qui s'exécutera
-Un temps de switch et de quantum sera demandé au début du programme

Pour le second, si un processus en cours, demande de prendre la main alors qu'il a une priorité égale, la demande sera rejetée.

== Sources ==
Les principales sources ont été celles données au début du rattrapage ainsi que le cours de système et de temps réel du semestre 7.

== Documents ==

IMA4 2017/2018 EC5

2018-06-12T07:03:48Z

Groux :

IMA4 2017/2018 EC5

2018-06-12T06:56:58Z

Groux : /* Travail effectué */

== Présentation du projet ==

=== Contexte ===

L'élève continue son semestre S8 à l'école.

=== Objectif ===

Il vous est demandé d'écrire un programme C permettant de simuler l'ordonnancement de processus avec gestion de ressources communes suivant les algorithmes tourniquet et priorité avec préemption.

=== Description du projet ===

Vous commencerez par créer les structures de données pour pouvoir décrire, dans le code C, les processus que votre ordonnanceur va devoir gérer.

Les caractéristiques des processus à prendre en compte sont :
* un numéro permettant d'identifier les processus ;
* une date de départ du processus par rapport à une horloge globale ;
* les divers événements du processus par rapport à son horloge interne correspondant au temps passé en exécution :
** réclamation d'une ressource commune ;
** libération d'une ressource commune ;
** terminaison du processus.

Un exemple de description de processus est donné ci-après.

int nb_procs=4;
struct event p1_events[]={ {30,OP_CLAIM,R1}, {70,OP_RELEASE,R1}, {100,OP_STOP} };
struct event p2_events[]={ {80,OP_CLAIM,R1}, {180,OP_RELEASE,R1}, {200,OP_STOP} };
struct event p3_events[]={ {40,OP_CLAIM,R1}, {160,OP_RELEASE,R1}, {300,OP_STOP} };
struct event p4_events[]={ {400,OP_STOP} };
struct process procs[]={
{.number=1,.start=150,.priority=1,.events=p1_events},
{.number=2,.start=100,.priority=2,.events=p2_events},
{.number=3,.start=50,.priority=3,.events=p3_events},
{.number=4,.start=0,.priority=4,.events=p4_events}
};

Les caractéristiques des ressources à prendre en compte sont :
* un numéro permettant d'identifier les ressources ;
* le nombre d'occurrences de la ressource disponibles.

Pour simuler les deux algorithmes d'ordonnancement, vous utiliserez un algorithme "intelligent" :
* faites partir le temps de zéro puis rentrez dans une boucle infinie où le temps saute directement à l'événement suivant (arrivé d'un processus, événement pour le processus courant, fin du quantum de temps, etc) ;
* voyez si un nouvel événement se traduit par un changement d'état du processus courant et l'activation d'un autre processus ;
* si tous les processus sont terminés, sortez de la boucle.

A chaque événement imprimez un code permettant de suivre l'exécution :
* pour la réclamation ou la libération d'une ressource affichez le temps global, le caractére <code>R</code> comme ressource, son numéro et <code>+</code> ou <code>-</code> suivant qu'il s'agit d'une réclamation ou d'une libération ;
* pour le changement d'état d'un processus, affichez le temps global, le caractére <code>P</code> comme processus, son numéro et <code>[</code> ou <code>]</code> suivant qu'il s'agit de l'activation ou de la mise en sommeil du processus.

Pour chaque simulation lancez les deux algorithmes d'ordonnancement. Vérifiez votre programme avec les différents exercices d'ordonnancement des DS de système des années passées.

Une fois le programme fonctionnel étudiez les différentes variantes possibles pour les deux algorithmes. Par exemple pour le tourniquet, le quantum de temps est-il ou non prioritaire sur une opération sur une ressource qui est programmée au même instant ? Par exemple pour la priorité avec préemption, comment choisir entre des processus avec la même priorité ?

=== Planning prévisionnel ===

== Travail effectué ==
Le début de travail à été de créer les différentes structures afin de pouvoir construire l'ordonnancement.

On a pu différencier 3 structures différentes : Celle de la ressource, celle du processus et celle d'un événement.

Les structures sont les suivantes :

struct ressource
{
int num_ressource;
int nb_occurence;
};
typedef struct ressource Ressource;

struct event
{
int demande;
int action;
Ressource R;
};
typedef struct event Event;

struct process
{
int number;
int start;
int priority;
int nbEvent;
Event* event;
};
typedef struct process Process;

Une fois celle ci définit, il a donc fallu créer un ordonnancement par tourniquet dans un premier temps, puis dans un second temps par priorité avec préemption.

Afin de réaliser ces ordonnancement, j'ai repris les evenements et les processus du Ds du 6 janvier 2017.

== Sources ==

== Documents ==

IMA4 2017/2018 EC5

2018-06-12T06:37:01Z

Groux : /* Travail effectué */

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T14:53:21Z

Groux : /* Conclusion */

= Projet IMA3-SC 2016/2017 : Station météo connectée =

== Cahier des charges ==

Pour notre projet Système Communicant, nous avons choisi de réaliser une station météo qui pourrait mesurer la température, l'humidité et la pression atmosphérique. Nous pourrions songer également à relever la luminosité, la quantité de précipitation etc mais il faut rester vigilent au nombre de pins de l'Arduino. Grâce à celui-ci, nous pourrons réaliser une application web qui afficherait en détails les grandeurs mesurées.

'''=== Le matériel ==='''

*Un capteur de pression (type BMP180)
*Un capteur d'humidité (A0SONG AM2302)
*Un capteur de température
*Un Raspberry Pi
*Une alimentation
*Un Arduino
*Une nanoboard
*Plaque d'essais
*Fils

== Séance 1 ==

=== Partie électronique ===

Pour le capteur AM2302, on constate que la broche de sortie SDA est une broche complexe et bidirectionnelle.
On souhaite, grâce au FPGA, lire les informations envoyées par le capteur AM2302 toutes les n secondes.
Pour lire une mesure, il faut envoyer un front descendant sur SDA, puis le capteur envoie 5 octets :

[[Fichier:AM2302.jpeg]]

Pour pouvoir gérer la bidirectionnalité de la broche SDA, on utilisera un composant spécifique de Altium : le IOBUF

Voici les caractéristiques sensorielles du capteur de température et d'humidité

[[Fichier:AM2302_sensor.jpeg]]

=== Partie informatique ===

Pour la programmation, nous avons décidé de ne pas utiliser la carte arduino mais plutôt un circuit logique programmable (puce FPGA). Cette puce servira à collecter les informations envoyées par les différents capteurs et les convertir en valeurs numériques pour pouvoir les afficher sur notre application web.

== Séance 2 ==

=== Partie électronique ===

Etude de la transmission d’informations avec la sonde AM2302 :
Attendre la détection d’un front descendant (entre 0,8 et 20 ms) envoyé par l’utilisateur.
On reçoit ensuit un signal haut nommé Tgo qui correspond à la libération du bus de données compris entre 20 et 200 us
On recoit une réponse du signal bas et une réponse du signal haut compris tous les duex entre 75 et 85 µs
Ensuite, la transmission des 40 caractères de données commence. Pour chaque bit, le capteur envoie un signal bas puis un signal haut. Pour envoyer un 0 ou un 1, le temps du signal bas (TLOW) ne varie pas. C’est donc grâce au temps de signal haut que l’on va distinguer la reception d’un « 0 » ou d’un « 1 »
Pour compter le temps de signal haut et savoir si le capteur nous a envoyé un 1 ou un 0, il faut détecter le front montant, lancer un compteur toutes les 1 µs puis détecter un front descendant pour arrêter le compteur. Si 48 < compteur < 55 µs, alors le capteur nous a envoyé un « 0 » Si 22 < compteur < 30 µs, alors le capteur nous a envoyé un « 1 »
Après avoir envoyé 40 bits de données à traiter, le capteur envoie un dernier signal bas compris entre 45 et 55 µs pour indiquer que la transmission est terminée

[[Fichier:capture1.png]]

[[Fichier:capture2roux.png]]

  [[Fichier:capture3.png]]

[[Fichier:capture4.png]]

Grâce à ce compteur, nous stockons chaque bit reçu grâce à des bascules D. Une fois les 5 octets de données récupérées, il suffit d’effectuer quelques opérations mathématiques pour récupérer les valeurs décimales du pourcentage d’Humidité et de la température.
Voici à quoi correspondent les 5 octets reçus :
Le temps maximum de réception est (55 + 75 µs) x 8 x 5 = 5,2 ms. C’est l’intervalle de temps minimum avec lequel on peut récupérer une nouvelle valeur de température et d’humidité.

[[Fichier:capture5.png]]

Pour vérifier que les informations reçues sont correctes, on additionne les 4 premiers octets (HH + HL + TH + TL). Si cette somme est égale au dernier octet (Parity bit), alors la transmission est correcte.
Pour avoir la valeur décimale de l’hygrométrie (en %), on converti en décimal les deux octets HH et HL puis on divise cette valeur par 10.
On applique les mêmes manipulations pour la température en °C.
Exemple : 40 bits recus :
0000 0010 1001 0010 0000 0001 0000 1101 1010 0010 High Humidity Low Humidity High Temperature Low Temperature Parity bit
Calculs :
0000 0010 + 1001 0010 + 0000 0001 + 0000 1101 = 1010 0010 Ici, cette égalité est vraie, donc la transmission est correcte.
Humidité : 0000 0010 1001 0010 = 0292H = 2 x 256 + 9x16 + 2 = 658  On divise cette valeur décimale par 10  Humidité = 65,8%RH
Température : 0000 0001 0000 1101 = 010DH = 1 x 256 + 0 x x16 + 13 = 269 On divise cette valeur décimale par 10  Température = 26,9°C

=== Partie informatique ===
Lors de cette deuxième séance nous nous sommes intéressé au programme arduino de nos deux capteurs : Le BMP180 et la sonde DHT22

Voici donc leur code arduino :
BMP180 (on télécharge la librairie Adafruit_BMP085 préalablement)

#include <Wire.h>
#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;

void setup() {
Serial.begin(9600);
if (!bmp.begin()) {
Serial.println("Could not find a valid BMP085 sensor, check wiring!");
while (1) {}
}
}

void loop() {
Serial.print("Temperature = ");
Serial.print(bmp.readTemperature());
Serial.println(" *C");
Serial.print("Pressure = ");
Serial.print(bmp.readPressure());
Serial.println(" Pa");

// Calculate altitude assuming 'standard' barometric
// pressure of 1013.25 millibar = 101325 Pascal
Serial.print("Altitude = ");
Serial.print(bmp.readAltitude());
Serial.println(" meters");

Serial.print("Real altitude = ");
Serial.print(bmp.readAltitude(101500));
Serial.println(" meters");

Serial.println();
delay(500);
}

''Pour le DHT22''

{
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup()
{
Serial.begin(9600);
Serial.println("DHTxx test!");
dht.begin();
}

void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(t) || isnan(h)) {
Serial.println("Failed to read from DHT");
}
else {
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.println(" *C");
}
}

== Séance 3 ==

=== Partie électronique ===
Lors de la troisième séance nous avons décider de créer la partie FPGA de notre système.
Après avoir réaliser le tutoriel proposé nous avons essayé de comprendre la façon dont fonctionne nos capteurs afin de réaliser au mieux l'interface FPGA afin de réussir a lire les informations envoyé par les capteurs.
Malgré de nombreux essais et de nombreuse recherche sur internet nous n'avons pas réussi a aboutir a un sytème concret afin de lire les information.

Voici les différent lien qui nous nt aidé dans la réalisation de notre projet :

[https://cdn.sparkfun.com/datasheets/Sensors/Pressure/BMP180%20breakout.pdf BMP180]
[https://cdn.sparkfun.com/datasheets/Sensors/Pressure/BMP180.pdf Datasheet BMP180]

Et pour le DHT22 nous avons trouvé ce model :
[[Fichier:DHT22.png]]

=== Partie informatique ===
Pour cette partie informatique nous avons suivi quelque tutoriel afin de créer une page HTML qui nous servira d'application WEB.
Voici le code HTML :

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Station météo</title>
</head>
<body>
<div id="corps">
<h1>Station météo</h1>
<h2>Roux-Mairesse</h2>
<p>Bienvenue sur notre station météo connectée</p>
<div id="relevesMeteo">
<button onclick="requeteEnvoi();">Affichage des données</button>
<table>
<tr>
<th>Température DHT122</th>
<th>Température BMP180</th>
<th>Humidité</th>
<th>Pression</th>
</tr>
<tr>
<td class="temperature DHT122">0 °C</td>
<td class="temperature BMP180">0 °C</td>
<td class="humidite">0 %</td>
<td class="pression">0 hPa</td>
</tr>
</table>
</div>
</div>
</body>
</html>

[[Fichier:web2.png]]

Cependant, après avoir réaliser cette partie nous ne savons pas comment obtenir les information des capteurs obtenu par arduino et les envoyer sur notre page web...

== Conclusion ==

Pour conclure, ce projet n'est pas une grande réussite... Nous avons passé beaucoup de temps a essayer de comprendre le fonctionnement du FPGA afin de ne pas utiliser d'arduino comme on nous l'avais demandé.
La plus grosse Partei manquante du projet est la liaison entre l'application web et l'arduino. A ce jour, malgré les recherches et les séance de projet, nous manquons de compétences nécessaires a la bonne réalisation de notre projet.
Cependant, nous avons pu approcher la filière sc grâce a ce projet et cela a pu nous montrer ce que cette filière pourra nous apporter l'année prochaine.

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T14:43:26Z

Groux : /* Séance supplémentaire 1 */

Fichier:Web2.png

2017-06-18T14:41:47Z

Groux :

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T14:41:28Z

Groux : /* Partie informatique */

= Projet IMA3-SC 2016/2017 : Station météo connectée =

== Cahier des charges ==

Pour notre projet Système Communicant, nous avons choisi de réaliser une station météo qui pourrait mesurer la température, l'humidité et la pression atmosphérique. Nous pourrions songer également à relever la luminosité, la quantité de précipitation etc mais il faut rester vigilent au nombre de pins de l'Arduino. Grâce à celui-ci, nous pourrons réaliser une application web qui afficherait en détails les grandeurs mesurées.

'''=== Le matériel ==='''

*Un capteur de pression (type BMP180)
*Un capteur d'humidité (A0SONG AM2302)
*Un capteur de température
*Un Raspberry Pi
*Une alimentation
*Un Arduino
*Une nanoboard
*Plaque d'essais
*Fils

== Séance 1 ==

=== Partie électronique ===

Pour le capteur AM2302, on constate que la broche de sortie SDA est une broche complexe et bidirectionnelle.
On souhaite, grâce au FPGA, lire les informations envoyées par le capteur AM2302 toutes les n secondes.
Pour lire une mesure, il faut envoyer un front descendant sur SDA, puis le capteur envoie 5 octets :

[[Fichier:AM2302.jpeg]]

Pour pouvoir gérer la bidirectionnalité de la broche SDA, on utilisera un composant spécifique de Altium : le IOBUF

Voici les caractéristiques sensorielles du capteur de température et d'humidité

[[Fichier:AM2302_sensor.jpeg]]

=== Partie informatique ===

Pour la programmation, nous avons décidé de ne pas utiliser la carte arduino mais plutôt un circuit logique programmable (puce FPGA). Cette puce servira à collecter les informations envoyées par les différents capteurs et les convertir en valeurs numériques pour pouvoir les afficher sur notre application web.

== Séance 2 ==

=== Partie électronique ===

Etude de la transmission d’informations avec la sonde AM2302 :
Attendre la détection d’un front descendant (entre 0,8 et 20 ms) envoyé par l’utilisateur.
On reçoit ensuit un signal haut nommé Tgo qui correspond à la libération du bus de données compris entre 20 et 200 us
On recoit une réponse du signal bas et une réponse du signal haut compris tous les duex entre 75 et 85 µs
Ensuite, la transmission des 40 caractères de données commence. Pour chaque bit, le capteur envoie un signal bas puis un signal haut. Pour envoyer un 0 ou un 1, le temps du signal bas (TLOW) ne varie pas. C’est donc grâce au temps de signal haut que l’on va distinguer la reception d’un « 0 » ou d’un « 1 »
Pour compter le temps de signal haut et savoir si le capteur nous a envoyé un 1 ou un 0, il faut détecter le front montant, lancer un compteur toutes les 1 µs puis détecter un front descendant pour arrêter le compteur. Si 48 < compteur < 55 µs, alors le capteur nous a envoyé un « 0 » Si 22 < compteur < 30 µs, alors le capteur nous a envoyé un « 1 »
Après avoir envoyé 40 bits de données à traiter, le capteur envoie un dernier signal bas compris entre 45 et 55 µs pour indiquer que la transmission est terminée

[[Fichier:capture1.png]]

[[Fichier:capture2roux.png]]

  [[Fichier:capture3.png]]

[[Fichier:capture4.png]]

Grâce à ce compteur, nous stockons chaque bit reçu grâce à des bascules D. Une fois les 5 octets de données récupérées, il suffit d’effectuer quelques opérations mathématiques pour récupérer les valeurs décimales du pourcentage d’Humidité et de la température.
Voici à quoi correspondent les 5 octets reçus :
Le temps maximum de réception est (55 + 75 µs) x 8 x 5 = 5,2 ms. C’est l’intervalle de temps minimum avec lequel on peut récupérer une nouvelle valeur de température et d’humidité.

[[Fichier:capture5.png]]

Pour vérifier que les informations reçues sont correctes, on additionne les 4 premiers octets (HH + HL + TH + TL). Si cette somme est égale au dernier octet (Parity bit), alors la transmission est correcte.
Pour avoir la valeur décimale de l’hygrométrie (en %), on converti en décimal les deux octets HH et HL puis on divise cette valeur par 10.
On applique les mêmes manipulations pour la température en °C.
Exemple : 40 bits recus :
0000 0010 1001 0010 0000 0001 0000 1101 1010 0010 High Humidity Low Humidity High Temperature Low Temperature Parity bit
Calculs :
0000 0010 + 1001 0010 + 0000 0001 + 0000 1101 = 1010 0010 Ici, cette égalité est vraie, donc la transmission est correcte.
Humidité : 0000 0010 1001 0010 = 0292H = 2 x 256 + 9x16 + 2 = 658  On divise cette valeur décimale par 10  Humidité = 65,8%RH
Température : 0000 0001 0000 1101 = 010DH = 1 x 256 + 0 x x16 + 13 = 269 On divise cette valeur décimale par 10  Température = 26,9°C

=== Partie informatique ===
Lors de cette deuxième séance nous nous sommes intéressé au programme arduino de nos deux capteurs : Le BMP180 et la sonde DHT22

Voici donc leur code arduino :
BMP180 (on télécharge la librairie Adafruit_BMP085 préalablement)

#include <Wire.h>
#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;

void setup() {
Serial.begin(9600);
if (!bmp.begin()) {
Serial.println("Could not find a valid BMP085 sensor, check wiring!");
while (1) {}
}
}

void loop() {
Serial.print("Temperature = ");
Serial.print(bmp.readTemperature());
Serial.println(" *C");
Serial.print("Pressure = ");
Serial.print(bmp.readPressure());
Serial.println(" Pa");

// Calculate altitude assuming 'standard' barometric
// pressure of 1013.25 millibar = 101325 Pascal
Serial.print("Altitude = ");
Serial.print(bmp.readAltitude());
Serial.println(" meters");

Serial.print("Real altitude = ");
Serial.print(bmp.readAltitude(101500));
Serial.println(" meters");

Serial.println();
delay(500);
}

''Pour le DHT22''

{
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup()
{
Serial.begin(9600);
Serial.println("DHTxx test!");
dht.begin();
}

void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(t) || isnan(h)) {
Serial.println("Failed to read from DHT");
}
else {
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.println(" *C");
}
}

== Séance 3 ==

=== Partie électronique ===
Lors de la troisième séance nous avons décider de créer la partie FPGA de notre système.
Après avoir réaliser le tutoriel proposé nous avons essayé de comprendre la façon dont fonctionne nos capteurs afin de réaliser au mieux l'interface FPGA afin de réussir a lire les informations envoyé par les capteurs.
Malgré de nombreux essais et de nombreuse recherche sur internet nous n'avons pas réussi a aboutir a un sytème concret afin de lire les information.

Voici les différent lien qui nous nt aidé dans la réalisation de notre projet :

[https://cdn.sparkfun.com/datasheets/Sensors/Pressure/BMP180%20breakout.pdf BMP180]
[https://cdn.sparkfun.com/datasheets/Sensors/Pressure/BMP180.pdf Datasheet BMP180]

Et pour le DHT22 nous avons trouvé ce model :
[[Fichier:DHT22.png]]

=== Partie informatique ===
Pour cette partie informatique nous avons suivi quelque tutoriel afin de créer une page HTML qui nous servira d'application WEB.
Voici le code HTML :

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Station météo</title>
</head>
<body>
<div id="corps">
<h1>Station météo</h1>
<h2>Roux-Mairesse</h2>
<p>Bienvenue sur notre station météo connectée</p>
<div id="relevesMeteo">
<button onclick="requeteEnvoi();">Affichage des données</button>
<table>
<tr>
<th>Température DHT122</th>
<th>Température BMP180</th>
<th>Humidité</th>
<th>Pression</th>
</tr>
<tr>
<td class="temperature DHT122">0 °C</td>
<td class="temperature BMP180">0 °C</td>
<td class="humidite">0 %</td>
<td class="pression">0 hPa</td>
</tr>
</table>
</div>
</div>
</body>
</html>

[[Fichier:web2.png]]

Cependant, après avoir réaliser cette partie nous ne savons pas comment obtenir les information des capteurs obtenu par arduino et les envoyer sur notre page web...

== Séance supplémentaire 1 ==

=== Partie électronique ===

=== Partie informatique ===

== Conclusion ==

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T14:27:38Z

Groux : /* Partie électronique */

= Projet IMA3-SC 2016/2017 : Station météo connectée =

== Cahier des charges ==

Pour notre projet Système Communicant, nous avons choisi de réaliser une station météo qui pourrait mesurer la température, l'humidité et la pression atmosphérique. Nous pourrions songer également à relever la luminosité, la quantité de précipitation etc mais il faut rester vigilent au nombre de pins de l'Arduino. Grâce à celui-ci, nous pourrons réaliser une application web qui afficherait en détails les grandeurs mesurées.

'''=== Le matériel ==='''

*Un capteur de pression (type BMP180)
*Un capteur d'humidité (A0SONG AM2302)
*Un capteur de température
*Un Raspberry Pi
*Une alimentation
*Un Arduino
*Une nanoboard
*Plaque d'essais
*Fils

== Séance 1 ==

=== Partie électronique ===

Pour le capteur AM2302, on constate que la broche de sortie SDA est une broche complexe et bidirectionnelle.
On souhaite, grâce au FPGA, lire les informations envoyées par le capteur AM2302 toutes les n secondes.
Pour lire une mesure, il faut envoyer un front descendant sur SDA, puis le capteur envoie 5 octets :

[[Fichier:AM2302.jpeg]]

Pour pouvoir gérer la bidirectionnalité de la broche SDA, on utilisera un composant spécifique de Altium : le IOBUF

Voici les caractéristiques sensorielles du capteur de température et d'humidité

[[Fichier:AM2302_sensor.jpeg]]

=== Partie informatique ===

Pour la programmation, nous avons décidé de ne pas utiliser la carte arduino mais plutôt un circuit logique programmable (puce FPGA). Cette puce servira à collecter les informations envoyées par les différents capteurs et les convertir en valeurs numériques pour pouvoir les afficher sur notre application web.

== Séance 2 ==

=== Partie électronique ===

Etude de la transmission d’informations avec la sonde AM2302 :
Attendre la détection d’un front descendant (entre 0,8 et 20 ms) envoyé par l’utilisateur.
On reçoit ensuit un signal haut nommé Tgo qui correspond à la libération du bus de données compris entre 20 et 200 us
On recoit une réponse du signal bas et une réponse du signal haut compris tous les duex entre 75 et 85 µs
Ensuite, la transmission des 40 caractères de données commence. Pour chaque bit, le capteur envoie un signal bas puis un signal haut. Pour envoyer un 0 ou un 1, le temps du signal bas (TLOW) ne varie pas. C’est donc grâce au temps de signal haut que l’on va distinguer la reception d’un « 0 » ou d’un « 1 »
Pour compter le temps de signal haut et savoir si le capteur nous a envoyé un 1 ou un 0, il faut détecter le front montant, lancer un compteur toutes les 1 µs puis détecter un front descendant pour arrêter le compteur. Si 48 < compteur < 55 µs, alors le capteur nous a envoyé un « 0 » Si 22 < compteur < 30 µs, alors le capteur nous a envoyé un « 1 »
Après avoir envoyé 40 bits de données à traiter, le capteur envoie un dernier signal bas compris entre 45 et 55 µs pour indiquer que la transmission est terminée

[[Fichier:capture1.png]]

[[Fichier:capture2roux.png]]

  [[Fichier:capture3.png]]

[[Fichier:capture4.png]]

Grâce à ce compteur, nous stockons chaque bit reçu grâce à des bascules D. Une fois les 5 octets de données récupérées, il suffit d’effectuer quelques opérations mathématiques pour récupérer les valeurs décimales du pourcentage d’Humidité et de la température.
Voici à quoi correspondent les 5 octets reçus :
Le temps maximum de réception est (55 + 75 µs) x 8 x 5 = 5,2 ms. C’est l’intervalle de temps minimum avec lequel on peut récupérer une nouvelle valeur de température et d’humidité.

[[Fichier:capture5.png]]

Pour vérifier que les informations reçues sont correctes, on additionne les 4 premiers octets (HH + HL + TH + TL). Si cette somme est égale au dernier octet (Parity bit), alors la transmission est correcte.
Pour avoir la valeur décimale de l’hygrométrie (en %), on converti en décimal les deux octets HH et HL puis on divise cette valeur par 10.
On applique les mêmes manipulations pour la température en °C.
Exemple : 40 bits recus :
0000 0010 1001 0010 0000 0001 0000 1101 1010 0010 High Humidity Low Humidity High Temperature Low Temperature Parity bit
Calculs :
0000 0010 + 1001 0010 + 0000 0001 + 0000 1101 = 1010 0010 Ici, cette égalité est vraie, donc la transmission est correcte.
Humidité : 0000 0010 1001 0010 = 0292H = 2 x 256 + 9x16 + 2 = 658  On divise cette valeur décimale par 10  Humidité = 65,8%RH
Température : 0000 0001 0000 1101 = 010DH = 1 x 256 + 0 x x16 + 13 = 269 On divise cette valeur décimale par 10  Température = 26,9°C

=== Partie informatique ===
Lors de cette deuxième séance nous nous sommes intéressé au programme arduino de nos deux capteurs : Le BMP180 et la sonde DHT22

Voici donc leur code arduino :
BMP180 (on télécharge la librairie Adafruit_BMP085 préalablement)

#include <Wire.h>
#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;

void setup() {
Serial.begin(9600);
if (!bmp.begin()) {
Serial.println("Could not find a valid BMP085 sensor, check wiring!");
while (1) {}
}
}

void loop() {
Serial.print("Temperature = ");
Serial.print(bmp.readTemperature());
Serial.println(" *C");
Serial.print("Pressure = ");
Serial.print(bmp.readPressure());
Serial.println(" Pa");

// Calculate altitude assuming 'standard' barometric
// pressure of 1013.25 millibar = 101325 Pascal
Serial.print("Altitude = ");
Serial.print(bmp.readAltitude());
Serial.println(" meters");

Serial.print("Real altitude = ");
Serial.print(bmp.readAltitude(101500));
Serial.println(" meters");

Serial.println();
delay(500);
}

''Pour le DHT22''

{
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup()
{
Serial.begin(9600);
Serial.println("DHTxx test!");
dht.begin();
}

void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(t) || isnan(h)) {
Serial.println("Failed to read from DHT");
}
else {
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.println(" *C");
}
}

== Séance 3 ==

=== Partie électronique ===
Lors de la troisième séance nous avons décider de créer la partie FPGA de notre système.
Après avoir réaliser le tutoriel proposé nous avons essayé de comprendre la façon dont fonctionne nos capteurs afin de réaliser au mieux l'interface FPGA afin de réussir a lire les informations envoyé par les capteurs.
Malgré de nombreux essais et de nombreuse recherche sur internet nous n'avons pas réussi a aboutir a un sytème concret afin de lire les information.

Voici les différent lien qui nous nt aidé dans la réalisation de notre projet :

[https://cdn.sparkfun.com/datasheets/Sensors/Pressure/BMP180%20breakout.pdf BMP180]
[https://cdn.sparkfun.com/datasheets/Sensors/Pressure/BMP180.pdf Datasheet BMP180]

Et pour le DHT22 nous avons trouvé ce model :
[[Fichier:DHT22.png]]

=== Partie informatique ===

== Séance supplémentaire 1 ==

=== Partie électronique ===

=== Partie informatique ===

== Conclusion ==

Fichier:DHT22.png

2017-06-18T14:26:40Z

Groux :

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T14:08:28Z

Groux : /* Partie informatique */

= Projet IMA3-SC 2016/2017 : Station météo connectée =

== Cahier des charges ==

Pour notre projet Système Communicant, nous avons choisi de réaliser une station météo qui pourrait mesurer la température, l'humidité et la pression atmosphérique. Nous pourrions songer également à relever la luminosité, la quantité de précipitation etc mais il faut rester vigilent au nombre de pins de l'Arduino. Grâce à celui-ci, nous pourrons réaliser une application web qui afficherait en détails les grandeurs mesurées.

'''=== Le matériel ==='''

*Un capteur de pression (type BMP180)
*Un capteur d'humidité (A0SONG AM2302)
*Un capteur de température
*Un Raspberry Pi
*Une alimentation
*Un Arduino
*Une nanoboard
*Plaque d'essais
*Fils

== Séance 1 ==

=== Partie électronique ===

Pour le capteur AM2302, on constate que la broche de sortie SDA est une broche complexe et bidirectionnelle.
On souhaite, grâce au FPGA, lire les informations envoyées par le capteur AM2302 toutes les n secondes.
Pour lire une mesure, il faut envoyer un front descendant sur SDA, puis le capteur envoie 5 octets :

[[Fichier:AM2302.jpeg]]

Pour pouvoir gérer la bidirectionnalité de la broche SDA, on utilisera un composant spécifique de Altium : le IOBUF

Voici les caractéristiques sensorielles du capteur de température et d'humidité

[[Fichier:AM2302_sensor.jpeg]]

=== Partie informatique ===

Pour la programmation, nous avons décidé de ne pas utiliser la carte arduino mais plutôt un circuit logique programmable (puce FPGA). Cette puce servira à collecter les informations envoyées par les différents capteurs et les convertir en valeurs numériques pour pouvoir les afficher sur notre application web.

== Séance 2 ==

=== Partie électronique ===

Etude de la transmission d’informations avec la sonde AM2302 :
Attendre la détection d’un front descendant (entre 0,8 et 20 ms) envoyé par l’utilisateur.
On reçoit ensuit un signal haut nommé Tgo qui correspond à la libération du bus de données compris entre 20 et 200 us
On recoit une réponse du signal bas et une réponse du signal haut compris tous les duex entre 75 et 85 µs
Ensuite, la transmission des 40 caractères de données commence. Pour chaque bit, le capteur envoie un signal bas puis un signal haut. Pour envoyer un 0 ou un 1, le temps du signal bas (TLOW) ne varie pas. C’est donc grâce au temps de signal haut que l’on va distinguer la reception d’un « 0 » ou d’un « 1 »
Pour compter le temps de signal haut et savoir si le capteur nous a envoyé un 1 ou un 0, il faut détecter le front montant, lancer un compteur toutes les 1 µs puis détecter un front descendant pour arrêter le compteur. Si 48 < compteur < 55 µs, alors le capteur nous a envoyé un « 0 » Si 22 < compteur < 30 µs, alors le capteur nous a envoyé un « 1 »
Après avoir envoyé 40 bits de données à traiter, le capteur envoie un dernier signal bas compris entre 45 et 55 µs pour indiquer que la transmission est terminée

[[Fichier:capture1.png]]

[[Fichier:capture2roux.png]]

  [[Fichier:capture3.png]]

[[Fichier:capture4.png]]

Grâce à ce compteur, nous stockons chaque bit reçu grâce à des bascules D. Une fois les 5 octets de données récupérées, il suffit d’effectuer quelques opérations mathématiques pour récupérer les valeurs décimales du pourcentage d’Humidité et de la température.
Voici à quoi correspondent les 5 octets reçus :
Le temps maximum de réception est (55 + 75 µs) x 8 x 5 = 5,2 ms. C’est l’intervalle de temps minimum avec lequel on peut récupérer une nouvelle valeur de température et d’humidité.

[[Fichier:capture5.png]]

Pour vérifier que les informations reçues sont correctes, on additionne les 4 premiers octets (HH + HL + TH + TL). Si cette somme est égale au dernier octet (Parity bit), alors la transmission est correcte.
Pour avoir la valeur décimale de l’hygrométrie (en %), on converti en décimal les deux octets HH et HL puis on divise cette valeur par 10.
On applique les mêmes manipulations pour la température en °C.
Exemple : 40 bits recus :
0000 0010 1001 0010 0000 0001 0000 1101 1010 0010 High Humidity Low Humidity High Temperature Low Temperature Parity bit
Calculs :
0000 0010 + 1001 0010 + 0000 0001 + 0000 1101 = 1010 0010 Ici, cette égalité est vraie, donc la transmission est correcte.
Humidité : 0000 0010 1001 0010 = 0292H = 2 x 256 + 9x16 + 2 = 658  On divise cette valeur décimale par 10  Humidité = 65,8%RH
Température : 0000 0001 0000 1101 = 010DH = 1 x 256 + 0 x x16 + 13 = 269 On divise cette valeur décimale par 10  Température = 26,9°C

=== Partie informatique ===
Lors de cette deuxième séance nous nous sommes intéressé au programme arduino de nos deux capteurs : Le BMP180 et la sonde DHT22

Voici donc leur code arduino :
BMP180 (on télécharge la librairie Adafruit_BMP085 préalablement)

#include <Wire.h>
#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;

void setup() {
Serial.begin(9600);
if (!bmp.begin()) {
Serial.println("Could not find a valid BMP085 sensor, check wiring!");
while (1) {}
}
}

void loop() {
Serial.print("Temperature = ");
Serial.print(bmp.readTemperature());
Serial.println(" *C");
Serial.print("Pressure = ");
Serial.print(bmp.readPressure());
Serial.println(" Pa");

// Calculate altitude assuming 'standard' barometric
// pressure of 1013.25 millibar = 101325 Pascal
Serial.print("Altitude = ");
Serial.print(bmp.readAltitude());
Serial.println(" meters");

Serial.print("Real altitude = ");
Serial.print(bmp.readAltitude(101500));
Serial.println(" meters");

Serial.println();
delay(500);
}

''Pour le DHT22''

{
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup()
{
Serial.begin(9600);
Serial.println("DHTxx test!");
dht.begin();
}

void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(t) || isnan(h)) {
Serial.println("Failed to read from DHT");
}
else {
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.println(" *C");
}
}

== Séance 3 ==

=== Partie électronique ===

=== Partie informatique ===

== Séance supplémentaire 1 ==

=== Partie électronique ===

=== Partie informatique ===

== Conclusion ==

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T13:58:06Z

Groux : /* Cahier des charges */

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T13:56:58Z

Groux : /* Partie informatique */

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T13:36:44Z

Groux : /* Partie électronique */

Fichier:Capture5.png

2017-06-18T13:29:08Z

Groux :

Fichier:Capture4.png

2017-06-18T13:28:28Z

Groux :

Fichier:Capture3.png

2017-06-18T13:27:58Z

Groux :

Fichier:Capture2roux.png

2017-06-18T13:27:32Z

Groux :

Fichier:Capture1.png

2017-06-18T13:26:37Z

Groux :

Projet IMA3 P7, 2016/2017, TD2

2017-06-18T12:50:50Z

Groux : /* Partie électronique */

Projets troisième année, 2016/2017, TD2

2017-03-07T09:05:13Z

Groux : /* Répartition des binômes */

== Répartition des binômes ==

Ecrivez vos noms sous le format exact "Prénom Nom", séparez vos noms par des virgules.

{| class="wikitable"
! Projet !! Elèves
|-
| [[Projet IMA3 P1, 2016/2017, TD2]] || Paul Ribeiro, Naif Mehanna, Alexis Viscogliosi, Maxime Créteur
|-
| [[Projet IMA3 P2, 2016/2017, TD2]] || Nicolas Havard, Transley Gracias, Amaury Knockaert, Keren Quiang
|-
| [[Projet IMA3 P3, 2016/2017, TD2]] || Fan Gao, Fabrice Taingland, Thibault Lepoivre, Antonin Lépolard
|-
| [[Projet IMA3 P4, 2016/2017, TD2]] || Briois Zoé, Untereiner Antoine, Narbais Damien, Watine Jean Baptiste
|-
| [[Projet IMA3 P5, 2016/2017, TD2]] ||
Saad Camille, Senellart Justine, Vandamme Claire
|-
| [[Projet IMA3 P6, 2016/2017, TD2]] || Eloi Zalczer, Gabriel Waterlot, Lihe Zhang
|-
| [[Projet IMA3 P7, 2016/2017, TD2]] || Gustave ROUX, Rémi MAIRESSE
|}