GUIDE COMPLET

Programmation Arduino
Du langage C aux microcontrôleurs

Pour étudiants en électronique & automation

IUT Nazi Boni — Burkina Faso

 Table des Matières
1. Introduction à Arduino
1.1 Qu'est-ce qu'Arduino ?
1.2 Matériel nécessaire
1.3 Installation de l'IDE
2. Structure d'un Programme Arduino
2.1 Les fonctions setup() et loop()
2.2 Commentaires et bonnes pratiques
3. Variables et Types de Données
3.1 Types courants
3.2 Constantes et #define
4. Entrées / Sorties Numériques
4.1 pinMode(), digitalWrite(), digitalRead()
4.2 Projet : LED clignotante
5. Entrées / Sorties Analogiques
5.1 analogRead() et analogWrite() (PWM)
5.2 Projet : Variation de luminosité
6. Structures de Contrôle
6.1 Conditions if/else, switch
6.2 Boucles for, while, do-while
7. Fonctions
7.1 Définir et appeler une fonction
7.2 Paramètres et valeurs de retour
8. Communication Série (UART)
8.1 [Link](), print(), println()
8.2 Lire les données série
9. Bibliothèques Arduino
9.1 Installer et utiliser une bibliothèque
9.2 LCD, Servo, capteur DHT
10. Projets Complets
10.1 Alarme avec capteur PIR
10.2 Régulateur de température
 10.3 Contrôle moteur DC avec PWM
11. Comparatif C ↔ Arduino

12. Référence Rapide

Guide Arduino — C → Microcontrôleurs —1— IUT Nazi Boni

 CHAPITRE 01

Introduction à Arduino

1.1 Qu'est-ce qu'Arduino ?

Arduino est une plateforme open-source composée d'un microcontrôleur programmable et d'un
environnement de développement (IDE). Elle permet de créer des objets électroniques interactifs en
liant le monde physique (capteurs, actionneurs) au monde numérique. Le langage de programmation
Arduino est basé sur le C/C++, ce qui en fait un outil idéal si tu as déjà des bases en C.

Carte Arduino UNO (ATmega328P — 8 bits, 16 MHz)

Mémoire Flash 32 Ko, SRAM 2 Ko, EEPROM 1 Ko

Broches E/S 14 numériques (dont 6 PWM) + 6 analogiques

Alimentation 5 V via USB ou 7–12 V via connecteur

Language C/C++ simplifié (wiring)

1.2 Matériel nécessaire

• Carte Arduino UNO (ou Nano, Mega…)

• Câble USB A→B (pour UNO)

• Breadboard (plaque d'essai)

• LEDs, résistances, boutons-poussoirs, capteurs

• Fils de connexion (jumpers)

• PC avec IDE Arduino installé

1.3 Installation de l'IDE Arduino

Télécharge l'IDE sur [Link]/en/software. Après installation :

• Branche ta carte Arduino via USB

• Dans Outils → Carte, sélectionne Arduino UNO

• Dans Outils → Port, sélectionne le port COM correspondant

• Clique sur ✓ (Vérifier) puis → (Téléverser) pour envoyer le programme

Guide Arduino — C → Microcontrôleurs —2— IUT Nazi Boni

 ■ Note : Sous Windows, installe le driver CH340 si ta carte n'est pas reconnue. Sous
Linux, ajoute ton utilisateur au groupe 'dialout'.

Guide Arduino — C → Microcontrôleurs —3— IUT Nazi Boni

 CHAPITRE 02

Structure d'un Programme Arduino

2.1 Les fonctions setup() et loop()

Tout sketch Arduino possède obligatoirement ces deux fonctions :

// Fichier : mon_premier_sketch.ino

void setup() {
// Exécuté UNE SEULE FOIS au démarrage
// → Initialisation des broches, Serial, bibliothèques...
[Link](9600); // Ouvre la communication série à 9600 baud
pinMode(13, OUTPUT); // Broche 13 configurée en sortie
}

void loop() {
// Exécuté EN BOUCLE INFINIE (comme while(1) en C)
// → Logique principale du programme
digitalWrite(13, HIGH); // Allume la LED
delay(1000); // Attend 1000 ms = 1 seconde
digitalWrite(13, LOW); // Éteint la LED
delay(1000); // Attend 1 seconde
}

Équivalent en C pur :

// Équivalent conceptuel en C (non compilable tel quel pour Arduino)

int main(void) {
setup(); // appel unique
while (1) {
loop(); // boucle infinie
}
return 0;
}

2.2 Commentaires et bonnes pratiques

Guide Arduino — C → Microcontrôleurs —4— IUT Nazi Boni

 // Commentaire sur une ligne (identique au C)

/* Commentaire
sur plusieurs lignes */

// Nommage : utilise des noms explicites

int tempCapteur = 0; // ✓ Bon
int t = 0; // ✗ Éviter

// Constantes en MAJUSCULES
#define PIN_LED 13
#define DELAI_MS 500

■ Note : Les fichiers Arduino ont l'extension .ino. Chaque projet est dans un dossier
portant le même nom que le fichier .ino.

Guide Arduino — C → Microcontrôleurs —5— IUT Nazi Boni

 CHAPITRE 03

Variables et Types de Données

3.1 Types courants

Arduino hérite des types C. Attention aux tailles qui dépendent du microcontrôleur (ATmega328 = 8
bits) :

Type Taille Plage Exemple

bool 1 octet true / false bool actif = true;

byte 1 octet 0 … 255 byte val = 200;

int 2 octets -32 768 … 32 767 int compteur = 0;

unsigned int 2 o 0 … 65 535 unsigned int x;

long 4 octets ±2 147 483 647 long dist = 100000L;

float 4 octets ±3.4 × 10³■ (6-7 déc.) float temp = 36.6;

char 1 octet -128 … 127 / ASCII char lettre = 'A';

String objet Chaîne de caractères String msg = "OK";

3.2 Constantes et #define

// Méthode 1 : #define (préprocesseur, pas de type, pas de mémoire)

#define PIN_LED 13
#define VITESSE 9600

// Méthode 2 : const (recommandée, typée)

const int PIN_BOUTON = 7;
const float PI_CUSTOM = 3.14159;

// Constantes intégrées Arduino

HIGH // 1 (niveau logique haut)
LOW // 0 (niveau logique bas)
INPUT // Mode entrée
OUTPUT // Mode sortie
INPUT_PULLUP // Entrée avec résistance pull-up interne
true / false // Booléens

Guide Arduino — C → Microcontrôleurs —6— IUT Nazi Boni

 CHAPITRE 04

Entrées / Sorties Numériques

4.1 Fonctions principales

// ■■ Configuration (dans setup())

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
pinMode(broche, mode);
// mode : OUTPUT, INPUT, INPUT_PULLUP

// ■■ Écriture numérique
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
digitalWrite(broche, valeur);
// valeur : HIGH (=1, 5V) ou LOW (=0, 0V)

// ■■ Lecture numérique
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
int etat = digitalRead(broche);
// Retourne HIGH ou LOW

4.2 Projet : LED clignotante avec bouton

La LED (broche 13) s'allume quand on appuie sur le bouton (broche 7) et clignote rapidement sinon.

Guide Arduino — C → Microcontrôleurs —7— IUT Nazi Boni

 #define PIN_LED 13
#define PIN_BOUTON 7

void setup() {
pinMode(PIN_LED, OUTPUT);
pinMode(PIN_BOUTON, INPUT_PULLUP); // Pull-up interne : repos = HIGH
[Link](9600);
}

void loop() {
int etatBouton = digitalRead(PIN_BOUTON);

if (etatBouton == LOW) {
// Bouton appuyé (pull-up → LOW quand appuyé)
digitalWrite(PIN_LED, HIGH);
[Link]("Bouton appuyé — LED allumée");
} else {
// Bouton relâché → clignotement
digitalWrite(PIN_LED, HIGH);
delay(100);
digitalWrite(PIN_LED, LOW);
delay(100);
}
}

■ Note : INPUT_PULLUP active la résistance pull-up interne (≈20 kΩ). Le bouton relie
la broche à la masse (GND). Avantage : pas besoin de résistance externe.

Guide Arduino — C → Microcontrôleurs —8— IUT Nazi Boni

 CHAPITRE 05

Entrées / Sorties Analogiques

5.1 analogRead() — Lecture analogique

L'Arduino UNO possède un CAN (Convertisseur Analogique-Numérique) 10 bits sur les broches A0 à
A5. Il convertit une tension (0–5 V) en valeur entière (0–1023).

int valeur = analogRead(A0); // Retourne 0 à 1023

// Conversion en tension (Vcc = 5V)

float tension = valeur * (5.0 / 1023.0);

// Exemple : lire un potentiomètre

void loop() {
int pot = analogRead(A0);
[Link]("Valeur brute : ");
[Link](pot);
delay(200);
}

5.2 analogWrite() — Sortie PWM

La sortie analogique sur Arduino est simulée par un signal PWM (Pulse Width Modulation —
Modulation de Largeur d'Impulsion). Disponible sur les broches marquées ~ : 3, 5, 6, 9, 10, 11. La
valeur va de 0 (0 V moyen) à 255 (5 V moyen).

Guide Arduino — C → Microcontrôleurs —9— IUT Nazi Boni

 analogWrite(broche, valeur); // valeur : 0 à 255

// Rapport cyclique = valeur / 255 × 100 %

// analogWrite(pin, 0) → 0 % (toujours LOW)
// analogWrite(pin, 127) → 50 % (signal carré)
// analogWrite(pin, 255) → 100 % (toujours HIGH)

// ■■ Projet : variation de luminosité LED via potentiomètre ■■

#define PIN_POT A0
#define PIN_LED 9 // Broche PWM

void setup() {
pinMode(PIN_LED, OUTPUT);
}

void loop() {
int pot = analogRead(PIN_POT); // 0–1023
int luminosite = map(pot, 0, 1023, 0, 255); // Remappage
analogWrite(PIN_LED, luminosite);
delay(10);
}

■ Note : La fonction map(val, fromLow, fromHigh, toLow, toHigh) est très utile pour
convertir des plages de valeurs. Ex : map(val, 0,1023, 0,255).

Guide Arduino — C → Microcontrôleurs — 10 — IUT Nazi Boni

 CHAPITRE 06

Structures de Contrôle

6.1 Conditions

// ■■ if / else if / else
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
int temp = analogRead(A0) * 0.48; // °C approximatif

if (temp > 40) {

[Link]("ALERTE : Surchauffe !");
} else if (temp > 25) {
[Link]("Température normale");
} else {
[Link]("Température basse");
}

// ■■ switch / case
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
int mode = 2;
switch (mode) {
case 1: [Link]("Mode Manuel"); break;
case 2: [Link]("Mode Automatique"); break;
case 3: [Link]("Mode Veille"); break;
default: [Link]("Mode inconnu"); break;
}

6.2 Boucles

Guide Arduino — C → Microcontrôleurs — 11 — IUT Nazi Boni

 // ■■ for ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■
// Faire clignoter une LED 5 fois
for (int i = 0; i < 5; i++) {
digitalWrite(13, HIGH); delay(200);
digitalWrite(13, LOW); delay(200);
}

// ■■ while ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■
// Attendre qu'un bouton soit appuyé
while (digitalRead(7) == HIGH) {
// Rien — boucle jusqu'à l'appui
}
[Link]("Bouton détecté !");

// ■■ do-while
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
int val;
do {
val = analogRead(A0);
delay(10);
} while (val < 512); // Continue jusqu'à dépasser 512

Guide Arduino — C → Microcontrôleurs — 12 — IUT Nazi Boni

 CHAPITRE 07

Fonctions

7.1 Définir et appeler une fonction

Comme en C, une fonction peut être déclarée avant ou après setup()/loop(). Arduino accepte la
déclaration après utilisation (prototype implicite).

// ■■ Déclaration
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
void clignote(int pin, int nb_fois, int duree_ms) {
for (int i = 0; i < nb_fois; i++) {
digitalWrite(pin, HIGH);
delay(duree_ms);
digitalWrite(pin, LOW);
delay(duree_ms);
}
}

// ■■ Fonction avec retour

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
float lireTension(int broche) {
int brut = analogRead(broche);
return brut * (5.0 / 1023.0); // Retourne la tension en volts
}

// ■■ Utilisation dans loop()

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
void setup() {
pinMode(13, OUTPUT);
[Link](9600);
}

void loop() {
clignote(13, 3, 200); // 3 clignotements de 200 ms
float v = lireTension(A0);
[Link]("Tension : ");
[Link](v);
[Link](" V");
delay(1000);
}

■ Note : Décompose ton programme en fonctions : setup() et loop() doivent rester

courtes et lisibles. C'est une bonne pratique en automatisme industriel aussi !

Guide Arduino — C → Microcontrôleurs — 13 — IUT Nazi Boni

 CHAPITRE 08

Communication Série (UART)

8.1 Envoyer des données au PC

La communication série permet d'envoyer/recevoir des données entre l'Arduino et le PC via USB.
C'est indispensable pour le débogage.

void setup() {
[Link](9600); // Vitesse en bauds (9600 standard)
// Autres vitesses communes : 115200, 57600
}

void loop() {
int val = analogRead(A0);

[Link]("Valeur = "); // Affiche sans saut de ligne

[Link](val); // Affiche avec saut de ligne

[Link]("Tension = ");
[Link](val * 5.0 / 1023.0, 2); // 2 décimales
[Link](" V");

delay(500);
}

8.2 Recevoir des données du PC

Guide Arduino — C → Microcontrôleurs — 14 — IUT Nazi Boni

 void setup() {
[Link](9600);
pinMode(13, OUTPUT);
[Link]("Envoie '1' pour allumer, '0' pour éteindre");
}

void loop() {
if ([Link]() > 0) { // Des données en attente ?
char commande = [Link](); // Lit un caractère

if (commande == '1') {
digitalWrite(13, HIGH);
[Link]("LED allumée");
} else if (commande == '0') {
digitalWrite(13, LOW);
[Link]("LED éteinte");
}
}
}

■ Note : Ouvre le Moniteur Série (Ctrl+Shift+M) dans l'IDE Arduino. Vérifie que la
vitesse en bas du moniteur correspond à [Link](vitesse).

Guide Arduino — C → Microcontrôleurs — 15 — IUT Nazi Boni

 CHAPITRE 09

Bibliothèques Arduino

9.1 Installer et inclure une bibliothèque

Les bibliothèques ajoutent des fonctionnalités sans réécrire le code depuis zéro. Installation : Croquis
→ Inclure une bibliothèque → Gérer les bibliothèques.

#include <NomBibliotheque.h> // Inclure en haut du sketch

// Exemple : bibliothèque Servo

#include <Servo.h>

Servo monServo; // Crée un objet Servo

void setup() {
[Link](9); // Servo sur broche 9
}

void loop() {
[Link](0); // Position 0°
delay(1000);
[Link](90); // Position 90°
delay(1000);
[Link](180); // Position 180°
delay(1000);
}

9.2 Affichage LCD (LiquidCrystal)

Guide Arduino — C → Microcontrôleurs — 16 — IUT Nazi Boni

 #include <LiquidCrystal.h>

// LCD branché sur : RS=12, E=11, D4=5, D5=4, D6=3, D7=2

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
[Link](16, 2); // LCD 16 colonnes, 2 lignes
[Link]("Arduino IUT");
}

void loop() {
[Link](0, 1); // Colonne 0, ligne 1
[Link]("T=");
[Link](analogRead(A0) * 0.48, 1);
[Link]((char)223); // Caractère °
[Link]("C ");
delay(500);
}

Guide Arduino — C → Microcontrôleurs — 17 — IUT Nazi Boni

 CHAPITRE 10

Projets Complets

10.1 Alarme avec capteur PIR

Détection de mouvement avec un capteur PIR HC-SR501. Quand un mouvement est détecté, une
LED rouge clignote et le buzzer sonne.

#define PIN_PIR 2 // Capteur PIR (détection mouvement)

#define PIN_LED 13 // LED rouge
#define PIN_BUZZ 8 // Buzzer passif

void setup() {
pinMode(PIN_PIR, INPUT);
pinMode(PIN_LED, OUTPUT);
pinMode(PIN_BUZZ, OUTPUT);
[Link](9600);
[Link]("Système d alarme actif");
}

void loop() {
if (digitalRead(PIN_PIR) == HIGH) {
[Link]("MOUVEMENT DÉTECTÉ !");
for (int i = 0; i < 5; i++) {
digitalWrite(PIN_LED, HIGH);
tone(PIN_BUZZ, 1000, 200); // Son 1000 Hz, 200 ms
delay(300);
digitalWrite(PIN_LED, LOW);
delay(200);
}
}
delay(100);
}

10.2 Contrôle moteur DC avec PWM

Un potentiomètre contrôle la vitesse d'un moteur DC via un transistor NPN (ou module L298N). La
direction est fixée par un bouton.

Guide Arduino — C → Microcontrôleurs — 18 — IUT Nazi Boni

 #define PIN_MOT_PWM 9 // Vitesse (PWM)
#define PIN_MOT_DIR 8 // Direction
#define PIN_POT A0 // Potentiomètre
#define PIN_BTN 7 // Bouton direction

void setup() {
pinMode(PIN_MOT_PWM, OUTPUT);
pinMode(PIN_MOT_DIR, OUTPUT);
pinMode(PIN_BTN, INPUT_PULLUP);
}

void loop() {
int pot = analogRead(PIN_POT);
int vit = map(pot, 0, 1023, 0, 255);
bool dir = (digitalRead(PIN_BTN) == LOW);

digitalWrite(PIN_MOT_DIR, dir ? HIGH : LOW);

analogWrite(PIN_MOT_PWM, vit);
delay(20);
}

Guide Arduino — C → Microcontrôleurs — 19 — IUT Nazi Boni

 CHAPITRE 11

Comparatif C ↔ Arduino

Concept Langage C standard Arduino

Entrée/Sortie printf() / scanf() [Link]() / [Link]()

Point d'entrée int main(void) setup() + loop()

Boucle infinie while(1) { ... } Contenu de loop()

Délai usleep() / nanosleep() delay(ms) / delayMicroseconds(us)

GPIO Registres directs ou lib OS pinMode() / digitalRead/Write()

Analogique Non natif (lib ou HAL) analogRead() / analogWrite()

Interruptions signal() / setitimer() attachInterrupt()

Mémoire malloc/free, OS géré Limitée — éviter String et malloc

Compilation gcc / clang avr-gcc (intégré dans l'IDE)

Déboggage gdb, printf, valgrind [Link]() + Moniteur Série

■ Note : La principale différence est l'absence de système d'exploitation sur Arduino.

Pas de gestionnaire de mémoire, pas de threads natifs, pas de système de fichiers. Ton
code s'exécute directement sur le métal (bare-metal).

Guide Arduino — C → Microcontrôleurs — 20 — IUT Nazi Boni

 CHAPITRE 12

Référence Rapide

Fonctions essentielles
Fonction Description

pinMode(pin, mode) Configure une broche (INPUT/OUTPUT/INPUT_PULLUP)

digitalWrite(pin, val) Écrit HIGH ou LOW sur une broche numérique

digitalRead(pin) Lit l'état d'une broche numérique (HIGH/LOW)

analogRead(pin) Lit une valeur analogique A0-A5 → 0 à 1023

analogWrite(pin, val) PWM sur broches ~ → 0 à 255

delay(ms) Pause en millisecondes

delayMicroseconds(us) Pause en microsecondes

millis() Temps écoulé depuis démarrage (ms) — non bloquant

micros() Temps écoulé en microsecondes

map(v,iL,iH,oL,oH) Remappage linéaire de plage de valeurs

constrain(v, min, max) Limite une valeur dans un intervalle

random(min, max) Nombre aléatoire entre min et max-1

tone(pin, freq, dur) Génère un son sur un buzzer

noTone(pin) Arrête le son

[Link](baud) Initialise la communication série

[Link](val) Envoie une valeur vers le PC

[Link](val) Idem avec saut de ligne

[Link]() Nombre d'octets disponibles en réception

[Link]() Lit un octet reçu

attachInterrupt(pin,fn,mode) Attache une interruption externe

detachInterrupt(pin) Désactive une interruption

[Link]/write(addr,val) Lecture/écriture mémoire EEPROM persistante

Guide Arduino — C → Microcontrôleurs — 21 — IUT Nazi Boni

 Bonne programmation !

Tu as maintenant toutes les bases pour programmer l'Arduino avec tes connaissances en C.

Prochaine étape : combine Arduino avec tes compétences en

automatisme industriel pour des projets Factory I/O et Step 7 !

[Link]/reference | [Link] | IUT Nazi Boni — EII/ETK

Guide Arduino — C → Microcontrôleurs — 22 — IUT Nazi Boni