SE3Groupe2025-19

De projets-se.plil.fr
Aller à la navigation Aller à la recherche

Programmation des systèmes embarqués

Carte électronique

Carte réalisée en utilisant le logiciel KiCAD : Fichier:2025-PSE-B19-PROG.zip.

Schéma électronique de la carte :

Mon schéma électronique

Résultat du routage :

Mon routage

Vue 3D de la carte :

Vue 3D



Photo de la carte soudée :

carte




carte










Programmation

Code pour faire clignoter les LEDs :

clig__led_19.c Vidéo: Média:2025-PSE-B19-PROG-clig.G19video.mp4

Code pour faire clignoter les LEDs par les boutons:

bouton_led_19.c Vidéo: Média:2025-PSE-B19-PROG-bouton.G19video.mp4

Bilan

Séance 1 : Schématique + routage (demande fabrication carte)

Séance 2 : Cours (1h) + Soudage des premiers composants — uniquement le microcontrôleur soudé, manque de temps pour aller plus loin.

Séance 3 : Préparation et rédaction des codes ( clig__led_19.c, gestion des boutons;bouton_led_19.c)

Séance 4 : Soudage des composants restants (carte complètement soudée) + finalisation du code. Premiers tests : problèmes de compilation et d'exécution détectés.

Travail à domicile (hors séance) : Correction des erreurs de compilation et d'exécution. Tests concluants — les LEDs s'allument correctement.

Premier système embarqué

Archive GIT

Mon archive GIT pour le projet KiCAD et pour les programmes : [1].

Archive privée. Binôme comme administrateur. Boé et Redon comme administrateur.

Ajouter un .gitignore pour KiCAD et langage C.

Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).

Description du système embarqué

Objectif : Conception d'un système d'irrigation automatisé intelligent basé sur l'ATmega32U4.

Description : Le dispositif mesure l'humidité du sol en temps réel pour déclencher une pompe dès qu'un seuil critique est atteint. Le système intègre une interface USB permettant de monitorer les données sur ordinateur, d'ajuster les paramètres de contrôle et d'analyser l'historique d'irrigation. Des capteurs de pH et de température complètent le dispositif pour une gestion optimisée de la culture.

Carte électronique

Carte réalisée en utilisant le logiciel KiCAD : Fichier:2025-PSE-19-PROG-Pse.zip.

Schéma électronique de la carte :

Mon schéma électronique

Résultat du routage :

Mon routage

Vue 3D de la carte :

Vue 3D


Photo de la carte soudée :


carte recto
carte verso

Vidéo très courte et en basse résolution de la carte en fonctionnement :


Média:2025-PSE-B19-systeme-video.mp4

Programmation

Pour réaliser la partie logicielle du projet, nous avons développé le programme embarqué en C (Arduino) pour le microcontrôleur ATmega32U4, compilé via arduino-cli et flashé par DFU sous Linux.

Environnement de développement

  • arduino-cli : compilation et gestion des bibliothèques
  • dfu-programmer : flash du microcontrôleur via le bootloader DFU Atmel
  • minicom : moniteur série pour l'affichage des données sur PC
  • Profil de carte : SparkFun Pro Micro 8 MHz (ATmega32U4 à 8 MHz)

Compilation et téléversement

Compilation : 

arduino-cli compile --fqbn SparkFun:avr:promicro:cpu=8MHzatmega32U4 ~/pse/humidite_complet --output-dir ~/pse/build

Appuyer sur le bouton RESET de la carte pour entrer en mode DFU, puis :

Effacer : 

sudo dfu-programmer atmega32u4 erase

Téléversement : 

sudo dfu-programmer atmega32u4 flash ~/pse/build/humidite_complet.ino.hex
sudo dfu-programmer atmega32u4 start

Moniteur série : 

minicom -D /dev/ttyACM0 -b 9600

Programme 1 : Test LED (validation de la soudure)

Ce premier programme a été utilisé pour valider la soudure de la carte après assemblage. Les deux LEDs (LED1 et LED2) s'allument ensemble puis s'éteignent ensemble toutes les 500 ms, confirmant le bon fonctionnement du microcontrôleur et des connexions soudées.

  • LED1 : PB4 = pin 8
  • LED2 : PB5 = pin 9
#define PIN_LED1  8
#define PIN_LED2  9

void setup() {
  pinMode(PIN_LED1, OUTPUT);
  pinMode(PIN_LED2, OUTPUT);
}

void loop() {
  digitalWrite(PIN_LED1, HIGH);
  digitalWrite(PIN_LED2, HIGH);
  delay(500);
  digitalWrite(PIN_LED1, LOW);
  digitalWrite(PIN_LED2, LOW);
  delay(500);
}
  • Les deux LEDs clignotent simultanément toutes les 500 ms, validant ainsi que la soudure et l'alimentation de la carte sont correctes.
Clignotement des LEDs

Programme 2 : Système complet (humidité + température + pompe)

Ce programme intègre l'ensemble des fonctionnalités du système d'irrigation automatique :

  • Lecture du capteur d'humidité FC-28 sur PF0 (A5)
  • Lecture du capteur de température NTC 100 kΩ B3950 sur PF1 (A4) via la formule Steinhart-Hart
  • Commande automatique du moteur (pompe) via PUMP_CTRL (PD4 = pin 4) et MOSFET 2N7002
  • Indicateurs LED et affichage série sur PC
#include <math.h>

#define PIN_SOIL  A5   // FC-28 humidité
#define PIN_TEMP  A4   // NTC 100kΩ B3950
#define PIN_LED1  8    // LED sol sec
#define PIN_LED2  9    // LED humidité OK
#define PIN_PUMP  4    // Commande pompe (PUMP_CTRL)

#define SEUIL     600  // Seuil humidité (0-1023)

// Paramètres NTC B3950
#define R_PULLUP  10000.0   // Résistance pull-up R10 = 10 kΩ
#define R0        100000.0  // Résistance NTC à 25°C = 100 kΩ
#define T0        298.15    // 25°C en Kelvin
#define B_COEF    3950.0    // Coefficient B du NTC

void setup() {
  Serial.begin(9600);
  pinMode(PIN_LED1, OUTPUT);
  pinMode(PIN_LED2, OUTPUT);
  pinMode(PIN_PUMP, OUTPUT);
  digitalWrite(PIN_LED1, LOW);
  digitalWrite(PIN_LED2, LOW);
  digitalWrite(PIN_PUMP, LOW);
  Serial.println("=== Humidite + Temperature + Moteur ===");
  Serial.println("---------------------------------------");
}

float lireTemperature() {
  int adc = analogRead(PIN_TEMP);
  if (adc <= 1 || adc >= 1022) return -999;
  float vout   = adc * (5.0 / 1023.0);
  float r_ntc  = R_PULLUP * vout / (5.0 - vout);
  float temp_k = 1.0 / (1.0/T0 + log(r_ntc/R0)/B_COEF);
  return temp_k - 273.15;
}

void loop() {
  int valeur = analogRead(PIN_SOIL);
  int pct = map(valeur, 1023, 0, 0, 100);
  pct = constrain(pct, 0, 100);

  float temp = lireTemperature();

  Serial.print("Humidite : ");
  Serial.print(pct);
  Serial.print("%  |  Temperature : ");
  if (temp == -999) {
    Serial.print("erreur capteur");
  } else {
    Serial.print(temp, 1);
    Serial.print("C");
  }
  Serial.print("  ->  ");

  if (valeur > SEUIL) {
    digitalWrite(PIN_LED1, HIGH);
    digitalWrite(PIN_LED2, LOW);
    digitalWrite(PIN_PUMP, HIGH);
    Serial.println("BESOIN D'EAU - Moteur ON");
  } else {
    digitalWrite(PIN_LED1, LOW);
    digitalWrite(PIN_LED2, HIGH);
    digitalWrite(PIN_PUMP, LOW);
    Serial.println("Humidite OK - Moteur OFF");
  }
  delay(500);
}
  • Le capteur FC-28 est placé dans l'air (sol sec) : aucune humidité détectée, la valeur ADC dépasse le seuil de 600. Le système affiche "BESOIN D'EAU" et la LED1 s'allume.
Capteur humidité — BESOIN D'EAU
  • Le capteur FC-28 est plongé dans une éponge imbibée d'eau, simulant une terre humide. L'humidité détectée est suffisante, le système affiche "Humidité OK" et la LED2 s'allume.
Capteur humidité — Humidité OK
  • Le capteur NTC est chauffé à l'aide d'un souffleur d'air chaud réglé à 340 °C. Le moniteur série affiche une montée progressive jusqu'à 341 °C puis se stabilise, confirmant la précision du capteur et la validité de la formule Steinhart-Hart.
Test capteur température
  • La pompe d'eau n'étant pas disponible lors des tests, nous avons utilisé un moteur en assimilation. Lorsque l'éponge est humide, le capteur détecte une humidité suffisante et le moteur reste à l'arrêt.
Moteur OFF — Humidité OK
  • Lorsque le capteur FC-28 est sorti de l'éponge et placé dans l'air (sol sec), le système déclenche automatiquement le moteur, simulant l'activation de la pompe d'eau pour l'arrosage.
Moteur ON — BESOIN D'EAU

Erreurs / Points d'amélioration

Erreurs

  • Mauvaise fréquence de compilation : le profil Arduino Leonardo (16 MHz) avait été utilisé à la place du profil SparkFun Pro Micro 8 MHz, empêchant l'USB de s'initialiser correctement.
  • Inversion des lignes D+ et D− sur le PCB, corrigée par ajout de fils de liaison sur la carte.
  • Capteur de température mal identifié (PT100 supposé, NTC 100 kΩ B3950 réel), ce qui donnait des valeurs aberrantes (26 000 °C). Résolu par l'implémentation de la formule Steinhart-Hart.
  • Utilisation de la référence interne (2,56 V) pour la température qui saturait la lecture du capteur d'humidité (0-5 V). Résolu en revenant à la référence par défaut (5 V).

Points d'amélioration

  • Résoudre le problème de commande du moteur via Q1 (gate bloquée à 5 V en permanence).
  • Ajouter une interface d'affichage (écran OLED) pour visualiser les données sans PC.
  • Ajouter un mode veille pour économiser la batterie.
  • Implémenter la lecture de la tension batterie via le pin VOLT (PB6).
  • Ajouter une alarme sonore ou visuelle en cas de batterie faible.

Travail effectué

1ère séance (17/02/2026) :

• Validation officielle : L'idée du projet de système d'irrigation automatique a été validée par l'enseignant.

• Étude technique : Nous avons finalisé la liste des composants nécessaires (capteurs d'humidité, pompe, microcontrôleur ATmega32U4) après une phase de recherche sur leurs spécifications.

• Conception Électronique (KiCad) : - Initialisation du projet sous KiCad. - Début de la saisie du schéma de principe (Schematic). - Sélection des symboles pour le microcontrôleur et les interfaces de puissance pour la pompe.


2ème séance (03/03/2026) : Finalisation du schéma et premier retour du professeur

• Conception Électronique (KiCad) : Finalisation du schéma électronique du système d'irrigation automatique. Vérification globale du schéma et des connexions entre les composants. Présentation du schéma au professeur pour validation. Analyse du schéma par le professeur et réception d'un premier retour contenant des modifications à effectuer.

3ème séance (10/03/2026) : Modifications après retour du professeur

Suite au retour du professeur sur notre schéma, nous avons apporté les corrections demandées. Nous avons : corrigé certaines connexions du schéma ; ajusté l'organisation du schéma afin d'améliorer sa lisibilité ; vérifié que les modifications respectent les remarques du professeur.


4ème séance (17/03/2026) : Vérification et problèmes restants

• Relecture du schéma sous KiCad avec Mr Boe.


• Identification d'erreurs dans la commande de la pompe.

• Problèmes de polarisation du transistor et de sens de commande (inversé).

• Tentative de correction : certains problèmes ont été résolus, d'autres restent en cours.


5ème séance (20/03/2026) : Corrections avancées

• Correction de la commande de la pompe (polarisation et sens).

• Ajustement des connexions critiques.

• Stabilisation du fonctionnement du montage.

• Début de la réflexion sur la partie alimentation.


6ème séance (24/03/2026) : Refonte de l'alimentation et finalisation du schéma

• Remplacement du régulateur initial par un convertisseur DC-DC (MCP1640Bx-xCHY) afin de convertir 3,7 V en 5 V pour la pompe.

• Correction de l'empreinte de l'inductance (erreur initiale).

• Validation du transistor 2N7002.

• Finalisation complète du schéma.


7ème séance (31/03/2026) : Routage et validation finale

• Réalisation du routage du PCB sous KiCad.

• Organisation et optimisation des pistes.

• Vérification des règles de conception (DRC).

• Finalisation du routage.

• Validation finale du projet par le professeur.


8ème séance (07/04/2026) : Étude des datasheets

• Lecture et analyse des datasheets des composants principaux.

• Attente de la réception de la carte PCB pour commencer la soudure.


9ème séance (05/05/2026) : Étude des datasheets (suite)

• Poursuite de l'étude des datasheets des composants.

• Attente de la réception de la carte PCB pour commencer la soudure.


10ème séance (12/05/2026) : Achat des matériaux

• Achat des composants et matériaux nécessaires au projet.

• Attente de la réception de la carte PCB pour commencer la soudure.


11ème séance (26/05/2026) : Soudure et premiers tests

• Soudure des blocs principaux de la carte : microcontrôleur, alimentation batterie, régulateur et LEDs.

• Test de validation de la soudure : flash d'un programme simple d'alternance des LEDs (LED1 et LED2 toutes les 500 ms).

• Résultat : les LEDs s'allument correctement, la carte est fonctionnelle après soudure.

• Test du capteur d'humidité FC-28 : lecture analogique sur PF0 (A5).

• Développement et flash du code sur ATmega32U4 (8 MHz) via DFU.

• Validation du seuil de déclenchement : affichage "BESOIN D'EAU" et allumage LED1 lorsque le sol est sec.

• Résultat : capteur opérationnel, seuil fonctionnel. Test concluant.


12ème séance (02/06/2026) : Test du capteur de température

• Connexion du capteur NTC 100kΩ B3950 sur J3 (PF1 = A4).

• Implémentation de la formule Steinhart-Hart pour la conversion résistance/température.

• Identification et correction du problème de référence interne qui perturbait le capteur d'humidité.

• Validation avec fer à souder : montée en température confirmée. Test concluant.


13ème séance (04/06/2026) : Intégration du moteur (assimilation pompe)

• Connexion d'un moteur sur J6 en remplacement de la pompe (non disponible).

• Intégration de la commande moteur via PUMP_CTRL (PD4 = pin 4) et MOSFET 2N7002 (Q1).

• Code complet fonctionnel : humidité + température + commande moteur automatique.

• Le moteur se déclenche automatiquement lorsque le seuil d'humidité est dépassé.

Bilan

Problèmes rencontrés et solutions

Problème 1 : Inversion des lignes D+ et D− sur le PCB

• Problème : Les pistes D+ et D− du connecteur USB étaient inversées dans le schéma KiCad, rendant la communication USB impossible.

• Solution : Correction directe sur le PCB en coupant les pistes et en ajoutant des fils de liaison croisés.

Problème 2 : Mauvaise fréquence de compilation (8 MHz vs 16 MHz)

• Problème : La carte utilise un cristal 8 MHz mais le profil Arduino Leonardo (16 MHz) était utilisé, empêchant l'USB de s'initialiser correctement.

• Solution : Utilisation du profil SparkFun Pro Micro 8 MHz (arduino-cli) adapté à notre ATmega32U4.

Problème 3 : Capteur de température mal identifié

• Problème : Le capteur était supposé être un PT100 alors qu'il s'agissait d'un NTC 100 kΩ B3950, ce qui donnait des valeurs aberrantes (26 000 °C).

• Solution : Identification correcte du composant et implémentation de la formule Steinhart-Hart adaptée au NTC.

Problème 4 : Référence analogique perturbant le capteur d'humidité

• Problème : L'utilisation de la référence interne (2,56 V) pour améliorer la résolution de la température saturait la lecture du capteur FC-28 (0-5 V).

• Solution : Retour à la référence par défaut (5 V) pour les deux capteurs.

Problème 5 : Commande du moteur non fonctionnelle

• Problème : Le moteur tourne en permanence malgré la commande LOW sur PUMP_CTRL. La gate du MOSFET Q1 (2N7002) mesure 5 V en permanence.

• Solution : Diagnostic en cours. Vérification du signal PUMP_CTRL sur le PCB et du numéro de pin correspondant à PD4.

Bilan du projet

Le projet de système d'irrigation automatique a permis de concevoir et réaliser une carte électronique complète intégrant :

• Un microcontrôleur ATmega32U4 programmé en C (Arduino) et flashé via DFU sous Linux.

• Un capteur d'humidité du sol FC-28 avec seuil configurable et indicateurs LED.

• Un capteur de température NTC 100 kΩ B3950 avec conversion mathématique (Steinhart-Hart).

• Une commande automatique de pompe (moteur) selon l'état d'humidité du sol.

• Un système d'alimentation sur batterie LiPo avec chargeur MAX1811 et convertisseur boost MCP1640 (3,7 V → 5 V).

• Un affichage des données en temps réel sur PC via le moniteur série USB.

L'ensemble du processus a été couvert : de la conception du schéma (KiCad) au routage PCB, en passant par la soudure des composants, le développement logiciel et les tests fonctionnels. Malgré quelques problèmes rencontrés en cours de route, les fonctionnalités principales sont opérationnelles et le projet remplit son objectif d'irrigation automatique basée sur la mesure d'humidité.

Récupérée de « http:///mediawiki/index.php?title=SE3Groupe2025-19&oldid=10527 »