Les Fabriques du Ponant - Contributions de l’utilisateur [fr]

ENIB 2026 : En route !

2026-01-22T15:10:28Z

Albane : /* fichiers joint */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers joint==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:EnRouteSchema.jpg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joint", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API : 
https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Pour la prоgrammаtiоn : 
https://shinyu.org/fr/arduino/data-formats-and-serialization/working-with-json/#google_vignette

Nous avons aussi utilisé ChatGPT avec le prompt suivant : "Aide moi à comprendre l'erreur dans mon code au niveau du déchifrage du fihier JSON"

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T15:08:05Z

Albane : /* Sources et documentation complémentaire */

ENIB 2026 : En route !

2026-01-22T15:07:36Z

Albane : /* Sources et documentation complémentaire */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers joint==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:EnRouteSchema.jpg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joint", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API : 
https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Pour la prоgrammаtiоn : 
https://shinyu.org/fr/arduino/data-formats-and-serialization/working-with-json/#google_vignette

Nous avons utilisé ChatGPT avec le prompt suivant : "Aide moi à comprendre l'erreur dans mon code au niveau du déchifrage du fihier JSON"

En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:58:01Z

Albane : /* Sources et documentation complémentaire */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers joint==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:EnRouteSchema.jpg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joint", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API : 
https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Pour la prоgrammаtiоn : 
https://shinyu.org/fr/arduino/data-formats-and-serialization/working-with-json/#google_vignette

En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:56:42Z

Albane : /* Sources et documentation complémentaire */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers joint==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:EnRouteSchema.jpg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joint", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API : 

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:55:57Z

Albane : /* étape 1 : conception de l'objet */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers joint==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:EnRouteSchema.jpg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joint", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

Fichier:EnRouteSchema.jpg

2026-01-22T14:55:25Z

Albane :

ENIB 2026 : En route !

2026-01-22T14:52:17Z

Albane : /* étape 4 : connexion ordinateur-carte */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers joint==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joint", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:51:35Z

Albane : /* fichiers à joindre */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers joint==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:50:48Z

Albane : /* fichiers à joindre */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==

===Code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:50:04Z

Albane : /* Mettre du code Arduino */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]
Notre équipe de droite à gauche : Jûna, Fanny, Julie, Albane

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
// Librairies additionnelles :
#include <ArduinoJson.h>
#include <Stepper.h>

// ici on initialise les broches pour le moteur
const int ENA = 23;
const int IN1 = 22;
const int IN2 = 21;

// Fonction pour contrôler le moteur
// sens = true -> horaire, false -> antihoraire
// vitesse = 0 à 255
void setMotor(bool sens, int vitesse) {
vitesse = constrain(vitesse, 0, 255); // Sécurité

if (sens) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

analogWrite(ENA, vitesse); // PWM pour vitesse
}

const char* SSID = "Formation";
const char* PSWD = "Apdgo29200!";

StaticJsonDocument<200> json_parse(String json) {
StaticJsonDocument<200> doc;

// Deserialize the JSON document
DeserializationError error = deserializeJson(doc, json);

// Test if parsing succeeds.
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.f_str());
}

return doc;
}

void wifi_setup() {
WiFi.begin(SSID, PSWD);
Serial.print("\nConnecting");

while(WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}

String get_http_string(String url) {
WiFiClientSecure client;
client.setInsecure(); // ignore SSL certificate (OK for APIs)

HTTPClient https;
https.begin(client, url);

String payload = "{}";
int httpCode = https.GET();

if (httpCode > 0) {
payload = https.getString();
} else {
Serial.println("HTTP ERROR");
}

https.end();
return payload;
}

void setup(){

//moteur
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

Serial.begin(9600);
int vitesse = 1;
Serial.println("on alume le moteur");
setMotor(true, vitesse); // on commence avec une vitesse faible tant qu'on a pas encore les données
wifi_setup();
char * url = "https://data.rennesmetropole.fr/api/explore/v2.1/catalog/datasets/etat-du-trafic-en-temps-reel/records?limit=20";
String json = get_http_string(url);
StaticJsonDocument doc = json_parse(json);
for (int i = 0; i < 15; i++) {
float averagevehiclespeed = doc["results"][i]["averagevehiclespeed"];
Serial.print("averagevehiclespeed ");
Serial.print(averagevehiclespeed);
Serial.print(i);
Serial.print(" : ");

float v = (averagevehiclespeed*255)/130;
setMotor(true, v); // sens horaire et vitesse v
delay(10000);
Serial.print("v");
Serial.println(v);
}

}

void loop(){

}

</syntaxhighlight>

==étapes de fabrication==

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteMaquette2.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRoutBranchement3.JPG|300px]]
[[Fichier:EnRouteL295N.png|400px]]

Il faut brancher la Pin 23 de la carte à A Enable du L295N, la Pin 22 à IN1, la Pin 21 à IN2.

Il faut branche les deux câbles du moteur à Output A.

Il faut brancher les fils rouge de la batterie à +5V Power.

Le reste des câbles doivent être branché à la masse.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:48:03Z

Albane : /* étape 3 : branchement de la carte */

ENIB 2026 : En route !

2026-01-22T14:47:01Z

Albane : /* étape 3 : branchement de la carte */

ENIB 2026 : En route !

2026-01-22T14:44:10Z

Albane : /* étape 3 : branchement de la carte */

ENIB 2026 : En route !

2026-01-22T14:43:01Z

Albane : /* étape 3 : branchement de la carte */

ENIB 2026 : En route !

2026-01-22T14:42:38Z

Albane : /* étape 3 : branchement de la carte */

Fichier:EnRoutBranchement3.JPG

2026-01-22T14:42:12Z

Albane :

Fichier:EnRouteBranchement2.jpeg

2026-01-22T14:39:47Z

Albane :

ENIB 2026 : En route !

2026-01-22T14:34:19Z

Albane : /* étape 3 : branchement de la carte */

ENIB 2026 : En route !

2026-01-22T14:33:58Z

Albane : /* étape 3 : branchement de la carte */

Fichier:EnRouteL295N.png

2026-01-22T14:32:59Z

Albane :

Fichier:EnRouteConstr.jpeg

2026-01-22T14:21:45Z

Albane : Albane a téléversé une nouvelle version de Fichier:EnRouteConstr.jpeg

ENIB 2026 : En route !

2026-01-22T14:19:55Z

Albane : /* étapes de fabrication */

ENIB 2026 : En route !

2026-01-22T14:17:53Z

Albane : /* étapes de fabrication */

ENIB 2026 : En route !

2026-01-22T14:15:26Z

Albane : /* Introduction */

ENIB 2026 : En route !

2026-01-22T14:14:25Z

Albane : /* Introduction */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T14:14:06Z

Albane : /* Introduction */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteEquipe2.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

Fichier:EnRouteEquipe.jpeg

2026-01-22T14:13:26Z

Albane : Albane a téléversé une nouvelle version de Fichier:EnRouteEquipe.jpeg

Fichier:EnRouteEquipe.jpeg

2026-01-22T14:10:59Z

Albane : Albane a téléversé une nouvelle version de Fichier:EnRouteEquipe.jpeg

Fichier:EnRouteEquipe.jpeg

2026-01-22T14:08:44Z

Albane :

ENIB 2026 : En route !

2026-01-22T14:03:32Z

Albane : /* Sources et documentation complémentaire */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Pour l'API :

https://data.rennesmetropole.fr/explore/dataset/etat-du-trafic-en-temps-reel/api/

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T13:57:51Z

Albane : /* Introduction */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette2.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

Fichier:EnRouteMaquette2.jpeg

2026-01-22T13:55:44Z

Albane :

ENIB 2026 : En route !

2026-01-22T13:48:23Z

Albane : /* le matériel */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* une batterie
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T13:47:39Z

Albane : /* étapes de fabrication */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===Troubleshouting===

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière. Nous avons fini par en trouver non pas sur la ville de Brest mais sur la ville de Rennes.

On a eu beaucoup de mal à la configuration du logiciel Arduino pour qu'il détecte la carte. Une des solutions que nous avons trouvé est qu'il faut appuyer sur le bouton Boot pour que le programme se lance.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T13:43:49Z

Albane : /* étape 4 : */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : connexion ordinateur-carte===
Copiez le code qui est donné avant, dans la partie "fichers joints", sur le logiciel Arduino. Puis lancez le code Arduino de manière classique et appuyiez sur le bouton Boot de la carte ESP32 en même temps.

===étape 5 : ===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T13:39:45Z

Albane : /* étape 3 : branchement de la carte */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30, le pont en H L295N et la batterie selon la photo ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]

Il faut brancher la Pin 23, 22, 21 et les masses.

===étape 4 : ===

===étape 5 : ===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T13:37:19Z

Albane : /* étape 3 : connexion de la carte */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : branchement de la carte===
Branchez la carte ESP30 et le pont en H L295N selon la photo ci-dessous.

===étape 4 : ===

===étape 5 : ===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T13:34:48Z

Albane :

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===étape 4 : ===

===étape 5 : ===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T11:05:57Z

Albane : /* étape 2 : construction de la maquette */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteDecoupe.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T11:05:03Z

Albane : /* étape 2 : construction de la maquette */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette suivant les photos ci-dessous.

[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteConstr.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T11:04:04Z

Albane : /* étape 2 : construction de la maquette */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette

[[Fichier:EnRouteConstr.jpeg|200px]]
[[Fichier:EnRouteDisque.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

Fichier:EnRoutreconstr2.jpeg

2026-01-22T11:02:24Z

Albane : Albane a téléversé une nouvelle version de Fichier:EnRoutreconstr2.jpeg

Fichier:EnRoutreconstr2.jpeg

2026-01-22T11:00:53Z

Albane :

Fichier:EnRouteConstr.jpeg

2026-01-22T11:00:14Z

Albane :

Fichier:EnRouteDecoupe.jpeg

2026-01-22T10:38:17Z

Albane :

ENIB 2026 : En route !

2026-01-22T09:51:35Z

Albane : /* le matériel */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298N Dual H-Bridge
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette

[[Fichier:EnRouteSocleSupport.jpeg|200px]]
[[Fichier:EnRouteDisque.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T09:50:53Z

Albane : /* le matériel */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un L298 Dual H-Bridge Motor Driver Integrated Circuit
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette

[[Fichier:EnRouteSocleSupport.jpeg|200px]]
[[Fichier:EnRouteDisque.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T09:42:47Z

Albane : /* outil */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un pont en H
* des câbles

===les outils===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette

[[Fichier:EnRouteSocleSupport.jpeg|200px]]
[[Fichier:EnRouteDisque.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]

ENIB 2026 : En route !

2026-01-22T09:23:25Z

Albane : /* matériel */

Titre de la fiche expérience :
==Introduction==
Nous sommes quatre étudiantes de troisième année à l'ENIB : l'Ecole Nationale d'Ingénieur de Brest.

[[Fichier:EnRouteMaquette.jpeg|200px]]

Dans le cadre du hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant, nous devons rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Nous avons conçus une maquette qui permet de voir en temps réel le trafic dans la métropole de Rennes. Si la voiture bouge rapidement, cela signifie que le trafic est fluide et inversement si la voiture bouge lentement.

[[Fichier:EnRouteMaquette.jpeg|200px]]

==outil et matériel==
===le matériel===
* une carte ESP32
* une plaque labdec
* un moteur continu
* un pont en H
* des câbles

===outil===
* du carton
* un cutter
* un pistolet à colle

==fichiers à joindre==
code, ficher d'impression 3D, de découpe laser ou vinyle, ...
===Mettre du code Arduino===
<syntaxhighlight lang="Arduino" line>
const int motorPin = 22; // Broche connectée à la base du transistor (via résistance)
int i = 0;
void setup() {
pinMode(motorPin, OUTPUT); // Définit la broche comme sortie
}

void loop() {

if (i!= 20){
digitalWrite(motorPin, HIGH); // Allume le moteur
delay(2000); // Attend 2 secondes
digitalWrite(motorPin, LOW);
i+=1;} // Éteint le moteur
}

</syntaxhighlight>

==étapes de fabrication==
indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

===étape 1 : conception de l'objet===
Faire un schéma papier aux dimensions souhaitées de la maquette.

[[Fichier:En route schema.jpeg|200px]]

===étape 2 : construction de la maquette===
Construire la maquette

[[Fichier:EnRouteSocleSupport.jpeg|200px]]
[[Fichier:EnRouteDisque.jpeg|200px]]

===étape 3 : connexion de la carte===
Sur l'application Arduino, copiez le code fournis plus haut.

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

On a eu du mal à trouver des données en temps réel qui avaient un rapport avec la circulation routière.

On a eu beaucoup de mal à la configuration de la carte et lors de l'installation des configurations de ESP32.

==Sources et documentation complémentaire==

* Rédаctiоn et illustratiоn : 
Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

* Prоgrammаtiоn : 
En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

* Transpаrence et dосumеntatiоn : 
Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

* Traçabilité : 
Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2026]]