Feu tricolore sur ESP8266 et CH32V003 : Code et Schéma

Construire un feu tricolore de salle avec ESP8266 et CH32V003

Connectez un module feu tricolore rouge-jaune-vert à un ESP8266 ou un CH32V003 et implémentez un cycle basique : rouge pendant 5 secondes, jaune pendant 1 seconde, vert pendant 5 secondes avec clignotement. Ce projet démontre la configuration des GPIO, les délais et les boucles sans bibliothèques externes. Parfait pour vos premiers pas en développement embarqué.

L'ESP8266 utilise les GPIO 13 (rouge), 12 (jaune), 14 (vert). Le CH32V003 utilise les ports PC5, PC6, PC7. Le code est optimisé, simulant un vrai feu tricolore avec préparation des transitions.

Configuration des GPIO sur ESP8266

Définissez les broches et configurez-les en sortie. Utilisez des résistances de limitation de courant pour protéger les LED.

const byte redLedPin = 14;
const byte yellowLedPin = 12;
const byte greenLedPin = 13;

void setup() {
  pinMode(redLedPin, OUTPUT);
  pinMode(yellowLedPin, OUTPUT);
  pinMode(greenLedPin, OUTPUT);
}

Dans loop(), exécutez cette séquence :

• Rouge HIGH pendant 5000 ms.
• Jaune HIGH pendant 1000 ms, puis LOW pour les deux.
• Vert HIGH pendant 5000 ms.
• Trois cycles de clignotement : HIGH 500 ms, LOW 500 ms.
• Jaune HIGH 1000 ms, puis LOW.

void loop() {
  // rouge
  digitalWrite(redLedPin, HIGH);
  delay(5000);

  // jaune
  digitalWrite(yellowLedPin, HIGH);
  delay(1000);

  digitalWrite(redLedPin, LOW);
  digitalWrite(yellowLedPin, LOW);
  
  // vert
  digitalWrite(greenLedPin, HIGH);
  delay(5000);

  for (byte i = 0; i < 3; i++) {
    digitalWrite(greenLedPin, HIGH);
    delay(500);
    
    digitalWrite(greenLedPin, LOW);
    delay(500);
  }

  // jaune
  digitalWrite(yellowLedPin, HIGH);
  delay(1000);
  digitalWrite(yellowLedPin, LOW);
}

Connectez via USB avec les pilotes CH340 et l'IDE Arduino avec le package carte ESP8266. Flashez comme d'habitude.

Passage au CH32V003

Un microcontrôleur RISC-V compact pour les tâches basse consommation. Nécessite un programmateur WCH LinkE : alimentation USB pour la carte, SWD pour le flashage. Connectez le feu tricolore sur PC5 (rouge), PC6 (jaune), PC7 (vert).

/* Définition globale */
#define RED_LED_PIN     GPIO_Pin_5 
#define YELLOW_LED_PIN  GPIO_Pin_6
#define GREEN_LED_PIN   GPIO_Pin_7

La logique reste identique : delay_ms au lieu de delay, GPIO_WriteBit. Initialisation :

• RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
• GPIO_InitTypeDef pour OutputPushPull.

La loop() est adaptée au SDK WCH : séquence d'états avec temporiseurs. Le code complet utilise les fonctions standard CH32V003FUN pour minimiser les dépendances.

Comparaison des plateformes

| Paramètre | ESP8266 | CH32V003 |

|----------|---------|----------|

| Cœur | Tensilica L106 | RISC-V2A |

| Broches | GPIO12-14 | PC5-7 |

| Alimentation | USB | USB + programmateur |

| Flashage | IDE Arduino | WCH LinkE + IDE |

| Prix | Moyen | Bas |

L'ESP8266 est idéal pour les débutants grâce à l'USB et l'écosystème Arduino. Le CH32V003 économise des ressources mais requiert un programmateur.

Avantages clés :

• Code minimal, sans bibliothèques.
• Facile à ajuster les timings.
• Évolutif vers boutons ou capteurs.

Astuces essentielles

• Câblage GPIO : Toujours utiliser des résistances de 220–330 ohms pour limiter le courant.
• Timings : delay() bloque le CPU ; pour des projets avancés, utilisez millis() ou des temporiseurs.
• Débogage : Surveillez le port série pour les logs d'état.
• Ports : Restez sur PCx avec le CH32V003 pour la simplicité — pas de PWM au début.
• Évolutivité : Ajoutez une machine à états finis (FSM) pour les états au lieu d'une boucle linéaire.

Ce projet est simple à reproduire : procurez-vous un module RYG et montez-le sur une platine d'essai. Idéal pour démontrer les bases du codage embarqué.

— Editorial Team