Votre premier module de cockpit avec l’IA : quatre LED et un OLED

Définir un résultat facile à vérifier

Imaginez un petit panneau près de votre volant ou de vos commandes de vol. Quatre voyants indiquent des états, tandis qu’un OLED affiche vitesse, régime moteur et carburant. Dans cet exercice, les nombres viennent volontairement du moniteur série de l’IDE Arduino. Aucun simulateur n’est nécessaire et chaque réaction peut être déclenchée séparément.

L’exigence est de commander les quatre LED indépendamment et d’afficher les valeurs reçues. Le programme doit vérifier les messages complets, accepter tous leurs champs ensemble et signaler les données périmées. Le résultat est un élément compréhensible à faire évoluer, pas une intégration automatique avec tous les simulateurs.

L’IA peut expliquer un branchement, proposer du code et éclaircir une erreur. Vous choisissez ce qui doit se passer, à quel moment et comment reconnaître la réussite. Ces questions sont accessibles avant de connaître les variables ou les fonctions. Demandez une explication de chaque nouveau terme à partir de votre montage.

Les composants précis de cet exemple

Préparez un Arduino Uno R3, un câble USB de données, une plaque d’essai, des fils, quatre LED rouges ordinaires et quatre résistances individuelles de 1 kΩ, au moins 0,125 W. L’OLED est précisément l’Adafruit 4440 : SSD1306, 128 × 32 pixels, I²C à l’adresse 0x3C et réinitialisation automatique. Utilisez un câble adaptateur STEMMA QT ou des broches correctement soudées.

Le fabricant prévoit une logique 5 V pour ce module. Cela ne signifie pas qu’un OLED ressemblant accepte les mêmes branchements : contrôleur, ordre des broches, alimentation et niveaux logiques doivent être vérifiés. Un écran SH1106 ou une ancienne carte nécessitant un fil de reset demande des adaptations. Identifiez le produit avant la mise sous tension.

Le Uno R3 suffit pour cet exercice. Sa mémoire limitée invite à commencer par un affichage simple. Le comparatif des microcontrôleurs vous aidera ensuite pour davantage de graphiques, de périphériques ou de puissance.

Raccorder les quatre LED et l’OLED

Débranchez l’USB avant le montage ou tout déplacement de fil. Reliez les masses, puis ajoutez une fonction à la fois. Chaque LED reçoit sa propre résistance série ; une résistance commune aux quatre ne convient pas. L’anode est généralement la patte longue, le méplat du boîtier repère le côté cathode. Pour des pattes coupées, consultez le marquage ou la fiche technique.

Avec environ 2 V aux bornes d’une LED rouge, 5 V et 1 kΩ donnent environ 3 mA. Ce courant modéré convient à l’essai sur table. Ce montage ne commande ni ruban LED, ni éclairage puissant, ni alimentation externe. Consultez l’éclairage LED avant d’ajouter de telles charges.

Donner un sens clair aux données

Le protocole pédagogique est V1,vitesse,régime,carburant,masque, terminé par LF, à 115200 bauds. Il accepte uniquement des entiers positifs ou nuls : vitesse 0–999, régime 0–20000, carburant 0–100 et masque 0–15. N’ajoutez ni espaces, ni unités, ni décimales. Limitez l’envoi à cinq messages complets par seconde.

Le masque additionne des valeurs : 1 pour LED 1, 2 pour LED 2, 4 pour LED 3 et 8 pour LED 4. La valeur 5 allume donc LED 1 et 3, 15 les allume toutes et 0 les éteint. Sur l’écran, les chiffres vont de LED 1 à LED 4 de gauche à droite : 1010 signifie LED 1 et 3 allumées.

Au démarrage, l’écran indique WAIT. Un message correct reçoit OK et affiche DATA. Un message incorrect reçoit ERR sans modifier partiellement les valeurs précédentes. Après trois secondes sans message valide, les LED s’éteignent et STALE signale que les derniers nombres conservés sont anciens. Ce comportement doit figurer dans la demande initiale.

Ici, S représente la vitesse en km/h, R les tours par minute et F le pourcentage de carburant. Le sketch affiche les nombres sans conversion ; toute conversion ultérieure appartient à l’émetteur. Les bits LED sont des indicateurs d’essai sans fonction prédéfinie dans un simulateur.

Rédiger une demande complète pour l’IA

Un bon prompt Arduino décrit le matériel, les données et les réactions observables. Ajoutez les liens du fabricant et les références vérifiées. Demandez d’abord une liste des connexions et des questions ouvertes. Si vos composants diffèrent, clarifiez ces différences avant d’adopter un schéma généré. Voici une demande complète :

Aide un débutant à construire un module de cockpit pédagogique. Explique les étapes sans inventer de broches ou d’interfaces de simulateur.
Matériel : Arduino Uno R3 ; quatre LED rouges sur D2,D3,D4,D5, chacune avec 1 kOhm, cathodes à GND. OLED Adafruit 4440, SSD1306 128x32 I2C 0x3C ; VIN=5V, GND=GND, SDA=A4, SCL=A5, reset automatique sans fil RST.
Tâche : fournir un sketch complet avec Wire, Adafruit GFX et Adafruit SSD1306. Recevoir mes messages d’essai USB-série à 115200 bauds, maximum 5 lignes/s : V1,speed,rpm,fuel,flags puis LF ; accepter CRLF. Limites : speed 0..999, rpm 0..20000, fuel 0..100, flags 0..15. Les valeurs 1,2,4,8 sélectionnent LED1..4.
Résultat : quatre lignes affichant valeurs et états. Démarrage WAIT, message correct DATA/OK, incorrect ERR sans modification partielle. Après 3000 ms sans données valides, LED éteintes et STALE, derniers nombres conservés.
Contraintes : tampon fixe de 64 octets ; rejeter les lignes trop longues jusqu’au LF ; aucun objet String dynamique ni delay dans loop ; rafraîchissement au maximum toutes les 200 ms. Compter la SRAM et les 512 octets du tampon OLED. Expliquer les erreurs de connexion et d’allocation.
Donne câblage, code complet, bibliothèques et tests : chaque LED, toutes ensemble, valeurs erronées, ligne excessive et interruption. Distingue compilation et validation matérielle.

Préparer, téléverser et comprendre le programme

Dans l’IDE, choisissez “Arduino Uno” et le bon port. Installez Adafruit SSD1306 et Adafruit GFX Library avec leur dépendance Adafruit BusIO via le gestionnaire de bibliothèques. Wire appartient au paquet AVR. Ouvrez le sketch dans un dossier nommé uno-led-oled, vérifiez la compilation puis téléversez vers votre carte.

Le code intégral est consultable et téléchargeable ci-dessous. Sa logique traite progressivement la réception sans attente par delay() et renouvelle l’affichage au plus cinq fois par seconde. La transmission I²C prend néanmoins du temps : il ne s’agit pas d’une garantie temps réel. Des câbles longs ou d’autres périphériques demandent des essais supplémentaires.

Le tampon graphique occupe 512 octets en plus des variables, tampons de bibliothèques et pile. Le bilan statique de RAM de l’IDE n’inclut pas entièrement cette allocation dynamique. F() garde les textes constants en flash ; aucun objet Arduino String n’est utilisé. Une compilation réussie ne valide ni le câblage ni l’image affichée.

Ce sketch a été compilé localement pour arduino:avr:uno avec AVR 1.8.7, Adafruit SSD1306 2.5.9, GFX 1.11.9 et BusIO 1.15.0 : 15 168 octets de flash et 614 octets de RAM statique, auxquels ajouter les 512 octets du tampon graphique. Aucun montage physique n’a été testé ici.

Télécharger le sketch Arduino complet

// Cockpit Suite workshop learning example. This is not a simulator protocol.
// Board: Arduino Uno R3. OLED: Adafruit 4440, SSD1306 128x32, I2C 0x3C.
// OLED VIN=5V, GND=GND, SDA=A4, SCL=A5; auto-reset, no reset wire.
// LEDs: D2/D3/D4/D5 -> individual 1k resistor -> anode; cathodes -> GND.
// Send at most 5 lines/second: V1,speed,rpm,fuel,flags followed by LF.
// Example: V1,120,3500,65,5 (LED1 and LED3 on). CR before LF is accepted.
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <string.h>

const uint8_t LED_PINS[4] = {2, 3, 4, 5};
const uint8_t OLED_ADDRESS = 0x3C;
const uint32_t DATA_TIMEOUT_MS = 3000;
const uint32_t SCREEN_INTERVAL_MS = 200;
Adafruit_SSD1306 display(128, 32, &Wire, -1);
char lineBuffer[64];
uint8_t lineLength = 0;
bool discardLine = false;
bool haveData = false;
bool oledReady = false;
uint16_t speedValue = 0, rpmValue = 0, fuelValue = 0, flagValue = 0;
uint32_t lastDataMs = 0, lastScreenMs = 0;

bool parseNumber(const char *&cursor, uint16_t limit, char separator,
                 uint16_t &result) {
  if (*cursor < '0' || *cursor > '9') return false;
  uint16_t value = 0;
  while (*cursor >= '0' && *cursor <= '9') {
    uint8_t digit = *cursor++ - '0';
    if (value > limit / 10 ||
        (value == limit / 10 && digit > limit % 10)) return false;
    value = value * 10 + digit;
  }
  if (*cursor != separator) return false;
  if (separator != '\0') ++cursor;
  result = value;
  return true;
}

bool parseLine(const char *line) {
  if (strncmp(line, "V1,", 3) != 0) return false;
  const char *cursor = line + 3;
  uint16_t speed, rpm, fuel, flags;
  if (!parseNumber(cursor, 999, ',', speed) ||
      !parseNumber(cursor, 20000, ',', rpm) ||
      !parseNumber(cursor, 100, ',', fuel) ||
      !parseNumber(cursor, 15, '\0', flags)) return false;
  speedValue = speed;
  rpmValue = rpm;
  fuelValue = fuel;
  flagValue = flags;
  lastDataMs = millis();
  haveData = true;
  return true;
}

void readSerial() {
  // Bound each pass so a continuous stream cannot starve the outputs.
  for (uint8_t count = 0; count < 32 && Serial.available(); ++count) {
    char character = (char)Serial.read();
    if (character == '\r') continue;
    if (character == '\n') {
      lineBuffer[lineLength] = '\0';
      if (!discardLine && parseLine(lineBuffer)) Serial.println(F("OK"));
      else Serial.println(F("ERR"));
      lineLength = 0;
      discardLine = false;
    } else if (!discardLine) {
      // NUL and non-printable input are not part of this text protocol.
      if (character < 32 || character > 126 ||
          lineLength >= sizeof(lineBuffer) - 1) {
        discardLine = true;
      } else {
        lineBuffer[lineLength++] = character;
      }
    }
  }
}

void renderScreen(bool fresh) {
  display.clearDisplay();
  display.setCursor(0, 0);
  display.print(F("S:")); display.print(speedValue);
  display.print(F(" R:")); display.println(rpmValue);
  display.print(F("F:")); display.print(fuelValue);
  display.print(F("% LED:"));
  for (uint8_t index = 0; index < 4; ++index)
    display.print(fresh && (flagValue & (1U << index)) ? '1' : '0');
  display.println();
  display.println(!haveData ? F("WAIT") : (fresh ? F("DATA") : F("STALE")));
  display.print(F("DEMO SERIAL"));
  display.display();
}

void setup() {
  for (uint8_t index = 0; index < 4; ++index) {
    digitalWrite(LED_PINS[index], LOW);
    pinMode(LED_PINS[index], OUTPUT);
  }
  Serial.begin(115200);
  Wire.begin();
#if defined(WIRE_HAS_TIMEOUT)
  Wire.setWireTimeout(25000, true);
#endif
  Wire.beginTransmission(OLED_ADDRESS);
  bool addressResponds = (Wire.endTransmission() == 0);
  oledReady = addressResponds &&
      display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS, false, false);
  if (oledReady) {
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setTextWrap(false);
    renderScreen(false);
  } else {
    Serial.println(F("OLED ERROR: check model, wiring, address, RAM"));
  }
  Serial.println(F("READY: V1,speed,rpm,fuel,flags"));
}

void loop() {
  readSerial();
  uint32_t now = millis();
  bool fresh = haveData && (uint32_t)(now - lastDataMs) < DATA_TIMEOUT_MS;
  for (uint8_t index = 0; index < 4; ++index)
    digitalWrite(LED_PINS[index],
                 fresh && (flagValue & (1U << index)) ? HIGH : LOW);
  if (oledReady && (uint32_t)(now - lastScreenMs) >= SCREEN_INTERVAL_MS) {
    lastScreenMs = now;
    renderScreen(fresh);
  }
}

Vérifier chaque comportement avec des messages

Réglez le moniteur série sur 115200 bauds avec “Nouvelle ligne” ou “NL & CR”. L’ouverture du port peut réinitialiser le Uno : attendez READY. Au premier démarrage, l’écran doit afficher WAIT et les quatre LED restent éteintes.

Envoyez V1,120,3500,65,1 : seule LED 1 doit s’allumer. Remplacez le dernier chiffre par 2, 4 puis 8 pour vérifier chaque sortie. Avec V1,120,3500,65,15, toutes s’allument ; avec 0, toutes s’éteignent. Comparez les trois valeurs affichées au message. Testez aussi V1,999,20000,100,15 et V1,0,0,0,0.

Envoyez volontairement V1,120,3500,101,5 ou supprimez un champ : la réponse doit être ERR, sans mise à jour partielle. Une ligne de plus de 63 caractères doit être rejetée jusqu’à sa fin ; la ligne correcte suivante doit fonctionner. Attendez plus de trois secondes : LED éteintes et STALE. Une nouvelle ligne valide doit rétablir le fonctionnement. Notez séparément résultat attendu et résultat observé.

Comparaison directe : V1,120,3500,65,15 allume les quatre LED, V1,120,3500,65,0 les éteint et V1,120,3500,65,5 allume seulement LED 1 et 3.

Poser une question de dépannage précise

Une LED sombre demande d’abord de vérifier polarité, résistance individuelle et broche. Pour un OLED entièrement sombre, vérifiez référence, alimentation, masse, SDA/SCL et adresse. OLED ERROR peut indiquer une absence de réponse I²C ou une allocation mémoire impossible. Une adresse qui répond ne garantit pas une image correcte.

Décrivez un constat précis à l’IA : “Uno R3, module 4440, sketch inchangé. READY apparaît, V1,120,3500,65,1 renvoie OK, LED1 s’allume, mais l’OLED reste noir. Quelles connexions vérifier hors tension en premier ?” Indiquez les versions et les erreurs de compilation complètes. Demandez un changement justifié à la fois.

Conservez une copie du programme fonctionnel avant de l’étendre, faites expliquer les modifications et répétez les tests. Le guide de dépannage structure cette démarche. Mots de passe, configurations privées et dossiers sans rapport n’ont pas leur place dans une demande d’aide.

Passer de l’exercice aux données du simulateur

Les données réelles nécessitent un chemin documenté côté PC : lecture de la source, conversion des unités, contrôle puis transmission. V1 est le format de cet exercice, pas une interface annoncée de Cockpit Suite. Vérifiez la liaison matérielle prise en charge avant de prévoir un pont automatique. Le moniteur série et une autre application ne peuvent généralement pas partager simultanément le même port.

Définissez ce que prouve un voyant : une commande demandée ou un état confirmé par le simulateur ? Comment distinguer “aucune donnée” de “état désactivé” ? Approfondissez avec l’association des données et les écrans et instruments.

Pour des boutons et axes reconnus comme joystick USB, FreeJoy constitue une autre voie sur le matériel adapté. Le présent sketch utilise la liaison série USB du Uno ; il ne crée pas un joystick natif. Choisissez selon votre besoin et agrandissez le panneau après validation d’un chemin complet.

Avancer avec la communauté

Cockpit Suite réunit les simulateurs et appareils compatibles dans un environnement logiciel commun. Le projet est jeune, avec un logiciel disponible et des réalisations concrètes. Les combinaisons préparées simplifient les étapes prises en charge ; un module Arduino personnel reste un travail d’apprentissage et d’intégration. Vos observations reproductibles nous aident à progresser.

Présentez votre objectif, vos composants et le dernier essai réussi sur le forum Cockpit Suite. Nous voulons vous accompagner et essayons de répondre le jour même lorsque c’est possible ; une question tardive peut recevoir sa réponse plus tard. L’atelier couvre aussi impression 3D, fraiseuses CNC à portique et laser avec LightBurn. Une communauté active en Europe et au-delà transforme les réussites individuelles en ressources utiles.

Poursuivre votre construction