Arduino
Programmation & Composants

// R = (Vcc - Vled) / I_led
// Vcc  = 5V (Arduino)
// Vled = 2.0V (LED rouge/verte) ou 3.2V (bleue/blanche)
// I    = 20 mA = 0.020 A (courant typique)

// LED rouge sur 5V :
// R = (5.0 - 2.0) / 0.020 = 150 Ω → utiliser 220 Ω (standard)

// LED bleue sur 5V :
// R = (5.0 - 3.2) / 0.020 = 90 Ω → utiliser 100 Ω

// Types entiers
int           x = 42;      // -32768 à 32767 (16 bits)
unsigned int  u = 65535;  // 0 à 65535
long          l = 100000; // -2M à 2M (32 bits)
byte          b = 255;    // 0 à 255 — très utilisé pour les broches

// Types décimaux (éviter — lents sur Arduino)
float  f = 3.14;
double d = 3.14159;

// Booléens
bool  actif = true;
bool  etat  = false;

// Constantes prédéfinies
HIGH    // = 1  (broche à 5V)
LOW     // = 0  (broche à 0V)
INPUT   // broche en entrée
OUTPUT  // broche en sortie
INPUT_PULLUP  // entrée avec résistance pull-up interne

// Tableaux
int broches[] = {2, 3, 4, 5};
byte segments[7] = {0, 0, 0, 0, 0, 0, 0};

// ── Configuration des broches ──────────────
pinMode(13, OUTPUT);        // broche 13 en sortie
pinMode(2,  INPUT);         // broche 2 en entrée
pinMode(7,  INPUT_PULLUP);  // entrée + résistance interne 20kΩ

// ── Écriture digitale ─────────────────────
digitalWrite(13, HIGH);  // broche 13 → 5V  (LED allumée)
digitalWrite(13, LOW);   // broche 13 → 0V  (LED éteinte)

// ── Lecture digitale ──────────────────────
int etat = digitalRead(2); // HIGH ou LOW

// ── PWM (broches ~) ───────────────────────
analogWrite(9, 128);   // 0–255 → 0%–100% (50% ici)
analogWrite(9, 0);     // éteint
analogWrite(9, 255);   // pleine puissance

// ── Lecture analogique ────────────────────
int val = analogRead(A0); // 0–1023 (10 bits)

// ── Temporisation ─────────────────────────
delay(1000);           // attendre 1 seconde (bloquant !)
delayMicroseconds(500);// attendre 500 µs
unsigned long t = millis(); // temps écoulé depuis démarrage (ms)

// ── Cartographie de valeurs ───────────────
int angle = map(val, 0, 1023, 0, 180); // remappe 0-1023 → 0-180
int clamp = constrain(val, 0, 255);     // borne entre 0 et 255

// ① Variables et constantes globales
const int PIN_LED = 13;   // LED intégrée de l'Uno
const int PIN_BTN = 2;
bool etatLed = false;
unsigned long dernierAppui = 0;

// ② setup() — exécuté UNE SEULE FOIS au démarrage
void setup() {
  Serial.begin(9600);              // ouvrir port série
  pinMode(PIN_LED, OUTPUT);         // LED = sortie
  pinMode(PIN_BTN, INPUT_PULLUP);   // bouton = entrée
  Serial.println("Arduino démarré !");
}

// ③ loop() — exécuté EN BOUCLE INFINIE (le cœur du programme)
void loop() {
  if (digitalRead(PIN_BTN) == LOW) { // bouton pressé (pull-up → LOW)
    unsigned long maintenant = millis();
    if (maintenant - dernierAppui > 200) { // anti-rebond 200ms
      etatLed = !etatLed;
      digitalWrite(PIN_LED, etatLed ? HIGH : LOW);
      dernierAppui = maintenant;
      Serial.print("LED : ");
      Serial.println(etatLed ? "ON" : "OFF");
    }
  }
}

// ④ Fonctions personnalisées (après loop)
void cligner(int broche, int fois, int duree) {
  for (int i = 0; i < fois; i++) {
    digitalWrite(broche, HIGH); delay(duree);
    digitalWrite(broche, LOW);  delay(duree);
  }
}

unsigned long dernierBlink = 0;
bool etatLed = false;

void loop() {
  if (millis() - dernierBlink >= 500) {
    etatLed = !etatLed;
    digitalWrite(LED_BUILTIN, etatLed);
    dernierBlink = millis(); // reset chrono
  }
  // Ici d'autres traitements peuvent tourner en parallèle !
}

void setup() {
  pinMode(13, OUTPUT);  // ou LED_BUILTIN
}

void loop() {
  digitalWrite(13, HIGH); // LED allumée
  delay(1000);             // attendre 1s
  digitalWrite(13, LOW);  // LED éteinte
  delay(1000);             // attendre 1s
}

const int NB_LEDS = 4;
int broches[NB_LEDS] = {8, 9, 10, 11};

void setup() {
  for (int i = 0; i < NB_LEDS; i++) {
    pinMode(broches[i], OUTPUT);
  }
}

void loop() {
  // Chenillard de gauche à droite
  for (int i = 0; i < NB_LEDS; i++) {
    digitalWrite(broches[i], HIGH);
    delay(100);
    digitalWrite(broches[i], LOW);
  }
}

// Câblage : broche 2 → bouton → GND
// Pas de résistance externe nécessaire — pull-up interne 20kΩ
// Logique inversée : broche LOW quand bouton pressé !

const int BTN = 2;
const int LED = 13;
bool ledOn = false;
bool dernierEtat = HIGH;
unsigned long dernierChangement = 0;

void setup() {
  pinMode(BTN, INPUT_PULLUP); // résistance interne 20kΩ vers 5V
  pinMode(LED, OUTPUT);
}

void loop() {
  bool etatActuel = digitalRead(BTN);

  // Anti-rebond : ignorer les changements < 50ms
  if (etatActuel != dernierEtat &&
      millis() - dernierChangement > 50) {

    if (etatActuel == LOW) { // front descendant = appui
      ledOn = !ledOn;
      digitalWrite(LED, ledOn);
    }
    dernierChangement = millis();
    dernierEtat = etatActuel;
  }
}

int compteur = 0;

void loop() {
  if (etatActuel == LOW && dernierEtat == HIGH) {
    compteur++;
    Serial.print("Appuis : ");
    Serial.println(compteur);
  }
  // Affichage moniteur série : Outils → Moniteur série (9600)
}

// Câblage :
// Potentiomètre : VCC → curseur → A0, et les 2 extrémités à 5V et GND
// LED : broche 9 (PWM) → 220Ω → LED → GND

const int POT = A0;
const int LED = 9;  // doit être une broche PWM (~)

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int lecture = analogRead(POT);        // 0 à 1023
  int luminosite = map(lecture, 0, 1023, 0, 255);
  analogWrite(LED, luminosite);          // 0 à 255
  Serial.println(luminosite);
  delay(10);
}

const int LED = 9;

void loop() {
  // Augmenter progressivement
  for (int i = 0; i <= 255; i++) {
    analogWrite(LED, i);
    delay(8);  // 8ms × 255 = ~2 secondes
  }
  // Diminuer progressivement
  for (int i = 255; i >= 0; i--) {
    analogWrite(LED, i);
    delay(8);
  }
}

// LED RGB — 3 broches PWM
void setCouleur(int r, int v, int b) {
  analogWrite(9,  r);  // Rouge
  analogWrite(10, v);  // Vert
  analogWrite(11, b);  // Bleu
}

void loop() {
  setCouleur(255, 0,   0);   delay(500); // Rouge
  setCouleur(0,   255, 0);   delay(500); // Vert
  setCouleur(0,   0,   255); delay(500); // Bleu
  setCouleur(255, 100, 0);   delay(500); // Orange
}

// Diviseur de tension : 5V → R_fixe(10kΩ) → A0 → NTC → GND
#include <math.h>

const float R_FIXE = 10000.0;   // 10 kΩ
const float BETA   = 3950.0;    // coefficient NTC (vérifier datasheet)
const float T0     = 298.15;    // 25°C en Kelvin
const float R0     = 10000.0;   // résistance à 25°C

void setup() { Serial.begin(9600); }

void loop() {
  int   brut = analogRead(A0);              // 0–1023
  float R_ntc = R_FIXE * (1023.0 / brut - 1.0);
  float tempK = 1.0 / (log(R_ntc / R0) / BETA + 1.0 / T0);
  float tempC = tempK - 273.15;

  Serial.print("Temp : ");
  Serial.print(tempC, 1);
  Serial.println(" °C");
  delay(1000);
}

// LDR (Light Dependent Resistor) — diviseur de tension
// 5V → 10kΩ → A0 → LDR → GND
// Plus il fait sombre, plus la valeur lue est haute

const int LDR    = A0;
const int LED    = 13;
const int SEUIL  = 600;  // à calibrer selon ambiance

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int lumiere = analogRead(LDR);  // 0 (lumineux) → 1023 (sombre)

  if (lumiere > SEUIL) {
    digitalWrite(LED, HIGH);  // veilleuse automatique
    Serial.println("Sombre → LED ON");
  } else {
    digitalWrite(LED, LOW);
  }
  delay(100);
}

// Calibration interactive via Serial
void loop() {
  Serial.println(analogRead(LDR));  // observer les valeurs en direct
  delay(200);
}

const int DATA  = 11;  // DS
const int CLOCK = 13;  // SH_CP
const int LATCH = 10;  // ST_CP

// Chaque octet encode les 8 segments (bit 0 = a, bit 7 = dp)
// Cathode commune — 1 = allumé
const byte CHIFFRES[10] = {
  0b00111111, // 0 : a,b,c,d,e,f
  0b00000110, // 1 : b,c
  0b01011011, // 2 : a,b,d,e,g
  0b01001111, // 3 : a,b,c,d,g
  0b01100110, // 4 : b,c,f,g
  0b01101101, // 5 : a,c,d,f,g
  0b01111101, // 6 : a,c,d,e,f,g
  0b00000111, // 7 : a,b,c
  0b01111111, // 8 : tous
  0b01101111, // 9 : a,b,c,d,f,g
};

void afficher(byte donnee) {
  digitalWrite(LATCH, LOW);              // bloquer l'affichage
  shiftOut(DATA, CLOCK, MSBFIRST, donnee); // envoyer 8 bits en série
  digitalWrite(LATCH, HIGH);             // valider → afficher
}

void setup() {
  pinMode(DATA,  OUTPUT);
  pinMode(CLOCK, OUTPUT);
  pinMode(LATCH, OUTPUT);
}

void loop() {
  for (int i = 0; i <= 9; i++) {
    afficher(CHIFFRES[i]);
    delay(800);
  }
  // Éteindre
  afficher(0b00000000);
  delay(500);
}

// Bibliothèque : LiquidCrystal_I2C (gestionnaire de bibliothèques IDE)
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// LiquidCrystal_I2C(adresse, colonnes, lignes)
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();         // initialiser
  lcd.backlight();    // allumer le rétroéclairage

  lcd.setCursor(0, 0);       // colonne 0, ligne 0
  lcd.print("Arduino LCD !");

  lcd.setCursor(0, 1);       // colonne 0, ligne 1
  lcd.print("Temp: -- degC");
}

void loop() {
  float temperature = lireTemperature(); // fonction de l'ex. 08

  lcd.setCursor(6, 1);   // positionner après "Temp: "
  lcd.print(temperature, 1);
  lcd.print(" C  ");       // espaces pour effacer les anciens chiffres

  delay(1000);
}

// Effacer une partie de l'écran (éviter lcd.clear() — clignote)
void effacerLigne(int ligne) {
  lcd.setCursor(0, ligne);
  lcd.print("                "); // 16 espaces
}

// Projet combiné :
// - Potentiomètre sur A0 → simule une température
// - LCD 16×2 affiche "Temp: XX.X °C"
// - Afficheur 7 seg : dizaine de degrés (0–9)

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);
const int SEG[7] = {2,3,4,5,6,7,8};
const byte DIGITS[10] = {
  0b00111111,0b00000110,0b01011011,0b01001111,0b01100110,
  0b01101101,0b01111101,0b00000111,0b01111111,0b01101111
};

void setup() {
  for(int i=0;i<7;i++) pinMode(SEG[i], OUTPUT);
  lcd.init(); lcd.backlight();
  lcd.setCursor(0,0); lcd.print("Station Meteo");
}

void afficher7Seg(int chiffre) {
  byte masque = DIGITS[chiffre];
  for(int i=0;i<7;i++)
    digitalWrite(SEG[i], (masque >> i) & 1);
}

void loop() {
  float temp = map(analogRead(A0), 0, 1023, 0, 400) / 10.0;

  lcd.setCursor(0,1);
  lcd.print("Temp: ");
  lcd.print(temp, 1);
  lcd.print(" C  ");

  int dizaine = (int)temp / 10;         // dizaine
  afficher7Seg(constrain(dizaine, 0, 9));
  delay(500);
}

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
  Serial.println("Commandes: ON, OFF, BLINK");
}

void loop() {
  if (Serial.available() > 0) {
    String cmd = Serial.readStringUntil('\n');
    cmd.trim();  // supprimer \r\n

    if      (cmd == "ON")    { digitalWrite(13, HIGH); Serial.println("LED allumée"); }
    else if (cmd == "OFF")   { digitalWrite(13, LOW);  Serial.println("LED éteinte"); }
    else if (cmd == "BLINK") { cligner(13, 5, 100);  Serial.println("Blink !"); }
    else                       { Serial.println("Commande inconnue"); }
  }
}

// Depuis Python (pyserial) ─────────────────────
// import serial, time
// s = serial.Serial('COM3', 9600, timeout=1)
// time.sleep(2)  # laisser l'Arduino se réinitialiser
// s.write(b'ON\n')
// print(s.readline().decode().strip())

// Arduino envoie : timestamp,temperature,luminosite
void loop() {
  float temp  = lireTemperature();
  int   lum   = analogRead(A1);

  Serial.print(millis());
  Serial.print(',');
  Serial.print(temp, 2);
  Serial.print(',');
  Serial.println(lum);    // println = fin de ligne
  delay(1000);
}
// Sortie : 5000,22.50,450
//          6000,22.48,460

// Python — lire et tracer en temps réel ────────
// import serial, csv, matplotlib.pyplot as plt
// s = serial.Serial('COM3', 9600)
// with open('data.csv','w') as f:
//   w = csv.writer(f)
//   w.writerow(['t','temp','lum'])
//   for _ in range(60):
//     line = s.readline().decode().strip().split(',')
//     w.writerow(line)
//     print(line)

#include <Servo.h>

Servo monServo;

void setup() {
  monServo.attach(9);   // broche signal du servo
  monServo.write(90);  // position centrale
}

void loop() {
  int pos = map(analogRead(A0), 0, 1023, 0, 180);
  monServo.write(pos);  // 0° à 180°
  delay(15);            // laisser le servo bouger
}

#include <DHT.h>

DHT dht(4, DHT22); // broche 4, type DHT22

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (isnan(h) || isnan(t)) {
    Serial.println("Erreur lecture DHT !");
    return;
  }
  Serial.print("Humidité: "); Serial.print(h); Serial.print(" %  ");
  Serial.print("Temp: ");     Serial.print(t); Serial.println(" °C");
  delay(2000);
}