1. Réalisation du Programme

• Durée estimée : 6h
• Responsable : Responsable Technique + Scrib (documentation)

Tâches à réaliser

1. Définir l’architecture logicielle :

   • Décomposer le programme en modules (ex. :

     • Module 1 : Lecture des capteurs.

     • Module 2 : Traitement des données (filtrage, seuils).

     • Module 3 : Commande des actionneurs (ventilateur, LED).

     • Module 4 : Interface utilisateur (écran LCD, série).

   • Outils : Diagramme de flux (draw.io) ou pseudocode.

2. Écrire le code :

   • Langage : Arduino (C++), Python (Raspberry Pi), ou Blockly (pour les débutants).

   • Bonnes pratiques :

     • Commenter chaque fonction (ex. : /* Fonction : Lit la température du LM35 et retourne la valeur en °C */).

     • Utiliser des noms de variables clairs (ex. : float temperatureAmbiante au lieu de float t).

     • Structurer le code en fonctions (ex. : void lireCapteur(), void commanderVentilateur()).

   • Exemple de structure :

     // Bibliothèques
     #include <LiquidCrystal.h>
     
     // Brochages
     const int pinLM35 = A0;
     const int pinVentilateur = 9;
     
     void setup() {
       pinMode(pinVentilateur, OUTPUT);
       Serial.begin(9600);
     }
     
     void loop() {
       float temp = lireTemperature();
       if (temp > 25.0) {
         digitalWrite(pinVentilateur, HIGH);
       } else {
         digitalWrite(pinVentilateur, LOW);
       }
       delay(1000);
     }
     
     float lireTemperature() {
       // Code pour lire le LM35
     }

3. Tester le code par étapes :

   • Simuler avant de brancher :

     • Utiliser Tinkercad Circuits ou Wokwi pour tester la logique sans matériel.

     • Exemple : Lien vers un simulateur Arduino en ligne.

   • Valider chaque module :

     • Tester la lecture du capteur seul (affichage série).

     • Tester la commande du ventilateur seul (avec un LED en remplacement).

   • Outils : Moniteur série Arduino (Tools > Serial Monitor).

4. Gérer les erreurs :

   • Ajouter des messages de debug (ex. : Serial.println("Erreur : Capteur non détecté");).

   • Prévoir des sécurités (ex. : « Si la température dépasse 50°C, couper le système. »).

Livrables :

• Code source commenté (fichier .ino ou .py).

• Diagramme de flux du programme (PDF ou image).

• Compte-rendu de tests (tableau des essais et résultats) :

2. Réalisation du Câblage

• Durée estimée : 5h
• Responsable : Responsable Technique + Logistique

Tâches à réaliser

1. Préparer les composants :

   • Vérifier que tous les éléments sont disponibles (liste de matériels de l’étape 3).

   • Étiqueter les câbles (ex. : « Fil rouge = +12V », « Fil noir = GND »).

   • Outils : Pince à dénuder, fer à souder, gaines thermorétractables.

2. Suivre le schéma électrique :

   • Respecter les couleurs des fils (norme :

     • Rouge = +Vcc.

     • Noir = GND.

     • Autres couleurs pour les signaux).

   • Vérifier les polarités (ex. : « Le LM35 a une broche +5V, une broche GND, et une broche OUT. »).

   • Astuce : Utiliser un testeur de continuité pour repérer les courts-circuits.

3. Assembler par étapes :

   • Étape 1 : Alimentation (12V/5V) + fusible.

   • Étape 2 : Capteurs (ex. : LM35, boutons).

   • Étape 3 : Actionneurs (ventilateur, LED).

   • Étape 4 : Microcontrôleur (Arduino/Raspberry Pi).

   • Exemple de photo annotée : Exemple de câblage Légende : « Branchement du LM35 sur A0, avec résistance de pull-up. »

4. Tester le câblage :

   • Vérifications visuelles :

     • Pas de fils dénudés qui se touchent.

     • Composants bien fixés (pas de faux contacts).

   • Tests électriques :

     • Mesurer les tensions avec un multimètre (ex. : « 12V entre Vcc et GND. »).

     • Vérifier la continuité des masses.

   • Outils : Multimètre, oscilloscope (si disponible).

Livrables :

• Photos du câblage (avec annotations).

• Schéma de câblage réel (mis à jour si modifications).

• Rapport de tests électriques (tableau des mesures) :

3. Réalisation du Prototype

• Durée estimée : 9h
• Responsable : Toute l’équipe (répartition des tâches)

Tâches à réaliser

1. Fabriquer la structure mécanique :

   • Découper/imprimer les pièces :

     • Utiliser la modélisation 3D de l’étape 3 (fichiers STL/DXF).

     • Outils :

       • Imprimante 3D (pour les pièces plastiques).

       • Découpeuse laser (pour le bois/acrylique).

       • Perceuse, scie (pour les ajustements manuels).

   • Assembler les éléments :

     • Coller, visser, ou emboîter les pièces (selon le design).

     • Exemple : « Fixation du ventilateur avec 4 vis M3. »

2. Intégrer l’électronique :

   • Placer les composants dans la structure (ex. : « Carte Arduino fixée avec des entretoises. »).

   • Protéger les câbles (gainage, attaches plastiques).

   • Astuce : Prévoir des trappe d’accès pour les réglages futurs.

3. Premiers tests fonctionnels :

   • Test 1 : Alimentation :

     • Brancher le prototype et vérifier que :

       • Aucune fumée/odeur de brûlé.

       • Les LED s’allument (si présentes).

   • Test 2 : Capteurs :

     • Vérifier que les valeurs lues sont cohérentes (ex. : « Le LM35 affiche 20°C dans une pièce à 20°C. »).

   • Test 3 : Actionneurs :

     • Commander manuellement le ventilateur (ex. : « Envoyer un signal HIGH sur la broche 9. »).

   • Outils : Alimentation stabilisée, multimètre.

4. Résoudre les problèmes :

   • Diagnostic :

     • « Le ventilateur ne tourne pas » → Vérifier :

       • Alimentation (12V présents ?).

       • Câblage (fil bien branché ?).

       • Code (broche correcte dans digitalWrite?).

   • Solutions :

     • Documenter les correctifs appliqués (ex. : « Inversion des fils + et – sur le ventilateur. »).

Livrables :

• Prototype assemblé (photos sous tous les angles).

• Rapport d’assemblage :

  • Étapes suivies (avec photos).

  • Problèmes rencontrés et solutions.

• Vidéo courte (30 sec max) :

  • Montrer le prototype en fonctionnement (ex. : « Ventilateur qui s’active quand on chauffe le capteur. »).