Notes de cours : Programmation C Arduino pour Systèmes Embarqués

Introduction au Langage de Programmation C Arduino

• Définition de la carte Arduino UNO : Il s'agit d'une carte électronique à microcontrôleur utilisée pour piloter un système électronique intelligent au moyen d'un programme informatique.
• Définition d'un programme informatique : C'est un ensemble d'instructions et de données conçu pour effectuer des tâches spécifiques lorsqu'il est interprété et exécuté par un microprocesseur. Il représente l'intelligence du système et définit son comportement.
• Rôles du programme dans la carte Arduino :     * Lecture de données.     * Stockage de données.     * Traitement informatique de données.     * Transmission d'ordres et/ou de données.
• Langage Machine (Binaire) :     * Chaque microprocesseur possède son propre jeu d'instructions où chaque instruction machine (opération + opérandes) est codée par une séquence de bits.     * Les instructions machines sont des opérations arithmétiques, logiques, de contrôle du flux et de transfert de données.
• Code Source : Programme écrit par un programmeur dans un langage facilement lisible, compréhensible et modifiable par d'autres humains.
• Langage Assembleur : Langage de bas niveau utilisant des mots mnémoniques pour représenter le jeu d'instructions du microprocesseur. Il permet un code léger et rapide mais dépend fortement de l'architecture matérielle.
• Langages de Haut Niveau : Langages faisant abstraction du matériel (C/C++, Python, Pascal, Java, etc.). Ils sont plus faciles à apprendre et une instruction correspond généralement à plusieurs instructions en assembleur.
• Compilateur : Programme informatique qui transforme le code source en code objet ou langage machine directement exécutable par le microprocesseur.

Structure Générale et Organigramme d’un Programme Arduino

• En-tête déclarative :     * Comprend la déclaration des bibliothèques, la définition des constantes globales, la déclaration des variables globales, la création d'objets et la déclaration des fonctions.     * Les éléments déclarés ici sont valables pour l'intégralité du code.
• Programme principal :     * Bloc de configuration : void setup() : S'exécute une seule fois au début. Utilisé pour l'initialisation matérielle et logicielle.     * Bloc de traitement : void loop() : S'exécute en boucle infinie. Contient la lecture, le stockage, le traitement de données et la transmission d'ordres.
• Programmes secondaires : Fonctions et procédures définies en dehors des fonctions setup() et loop() et appelées par le programme principal.
• Organigramme de fonctionnement : L'exécution commence à l'alimentation de la carte et se poursuit (via la boucle loop) jusqu'à ce que la carte ne soit plus alimentée ou qu'un bouton de RESET soit actionné.

Règles de Syntaxe du Langage C Arduino

• Point-virgule $;$ : Obligatoire à la fin de chaque instruction (sauf exceptions). Il marque la fin d'une ligne de code pour le compilateur.
• Accolades {} : Utilisées par paires pour délimiter un bloc d'instructions. { marque le début et } marque la fin.
• Commentaires : Lignes ignorées par le compilateur.     * Une seule ligne : $//$ avant le texte.     * Plusieurs lignes : commence par $/*$ et finit par $*/$.
• Accents et Casse : Les accents sont interdits (sauf dans les commentaires). La casse est sensible (distinction entre majuscules et minuscules).
• Indentation : Mise en forme par retraits vers la droite pour visualiser l'emboîtement logique, facilitant la lecture humaine.

Données, Types et Stockage

• Donnée : Valeur représentant une information (nombre, caractère, état logique). Dans un système embarqué, elle correspond à un signal électrique (analogique, logique ou numérique).
• Types de données principaux :     * Nombres entiers : byte ($1$ octet), int ($2$ octets), long ($4$ octets).     * Nombres à virgule flottante : float ($4$ octets).     * Booléens : bool ($1$ octet), valeurs vrai/faux.     * Caractères : char ($1$ octet).     * Chaînes de caractères : String (taille variable).     * Note : Les nombres positifs sont spécifiés par le qualificatif unsigned.
• Variables : Étiquette liée à un emplacement mémoire dont la valeur est modifiable. Syntaxe : Type Nom_Variable = Valeur;.
• Constantes : Variables dont la valeur ne change pas.     * Avec const : const Type Nom_Constante = Valeur;.     * Avec #define : #define Nom_Constante Valeur.
• Pointeurs : Variables stockant l'adresse d'une donnée.     * Déclaration : Type * Nom_Pointeur = Valeur;.     * Opérateur d'adressage (référencement) : & placé devant le nom d'une variable pour obtenir son adresse.     * Opérateur de déréférencement : * placé devant le pointeur pour accéder à la valeur pointée.

Structures de Données, Classes et Objets

• Structure de données (struct) : Permet de regrouper des données de types différents sous une seule entité.     * Définition : struct Nom_Structure { Type1 Membre1; Type2 Membre2; };.     * Accès aux membres : Utilisation de l'opérateur point $.$ (ex: Nom_Variable.Nom_Membre1).
• Classe : Modèle définissant la structure d'un objet (attributs pour les propriétés, méthodes pour les fonctions internes).
• Objet : Instance d'une classe (variable dont le type est la classe).
• Droits d'accès :     * public : Appel possible depuis l'extérieur de la classe.     * private : Appel restreint à l'intérieur de la classe.
• Syntaxe POO :     * Création objet : Nom_Classe Nom_objet;.     * Appel de méthode : Nom_Objet.Nom_Methode;.

Opérateurs et Structures de Contrôle

• Opérateurs Arithmétiques :     * = : Assignation.     * + : Addition.     * - : Soustraction.     * * : Multiplication.     * / : Division.     * % : Modulo (reste de la division euclidienne).
• Opérateurs de Comparaison (résultat booléen) :     * == (Égal), != (Différent), < (Inférieur), > (Supérieur), <= et >=.
• Opérateurs Logiques :     * && : ET logique.     * || : OU logique.     * ! : NON logique (inverse l'état).
• Structures Conditionnelles :     * if (condition) : Exécute si vrai.     * if ... else : Exécution alternative si faux.     * switch ... case : Sélection selon plusieurs valeurs possibles d'une variable (utilise break pour quitter chaque cas).
• Structures Itératives (Boucles) :     * for (Initialisation; Test; Incrémentation) : Utilisé quand le nombre d'itérations est connu.     * while (condition) : Teste la condition avant l'exécution. Peut ne jamais s'exécuter.     * do ... while (condition) : Teste la condition après l'exécution. S'exécute au moins une fois.
• Instructions de Rupture :     * continue : Saute à l'itération suivante.     * break : Sort immédiatement de la boucle.     * return : Met fin à la fonction et renvoie éventuellement une valeur.

Fonctions et Éléments de l’En-tête

• Bibliothèques : #include <Nom_Bibliothèque.h> pour importer des fonctionnalités externes.
• Portée des variables :     * Locale : Visible uniquement dans la fonction de définition.     * Globale : Visible dans tout le projet.
• Fonctions / Procédures :     * Procédure (void) : Ne renvoie rien. Appel : NomFonction();.     * Fonction : Renvoie un type spécifique via return. Appel : Type Resultat = NomFonction();.

Gestion des Ports GPIO et Constantes Prédéfinies

• Modes GPIO : INPUT (entrée) ou OUTPUT (sortie).
• États numériques :     * HIGH : État haut ($5$ Volts, $1$, true).     * LOW : État bas ($0$ Volt, $0$, false).
• Ports Analogiques : Convertissent une tension ($0$ à $5$ V) en une valeur numérique entière de $0$ à $1023$ (convertisseur $10$ bits).
• Résistances de Rappel :     * Empêchent l'état "flottant" (haute impédance) des entrées non connectées.     * INPUT_PULLUP : Tirage au VCC (interne).     * INPUT_PULLDOWN : Tirage au GND (externe ou interne selon modèle).

Fonctions Arduino de Base

• Configuration :     * pinMode(Port, Mode); : Définit l'orientation de la broche.     * analogReference(TypeRef); : Définit la tension de référence (DEFAULT: $5$ V, INTERNAL: $1.1$ V, EXTERNAL: tension sur AREF).
• Lecture / Écriture :     * digitalRead(Port); : Lit l'état d'un port numérique.     * analogRead(Port); : Lit la valeur d'un port analogique.     * digitalWrite(Port, Etat); : Envoie HIGH ou LOW sur une sortie.     * analogWrite(Port, Valeur); : Génère un signal PWM (largeur d'impulsion de $0$ à $255$).
• Gestion du Temps :     * millis(); : Temps écoulé en ms depuis le démarrage (stocké en unsigned long, max $50$ jours).     * micros(); : Temps écoulé en $μs$.     * delay(ms); : Fonction bloquante mettant le programme en pause.
• Interruptions :     * attachInterrupt(digitalPinToInterrupt(Port_INT), prog_INT, Type_detection); : Exécute une routine en arrière-plan lors d'un événement.     * Types de détection : LOW, HIGH, RISING (front montant), FALLING (front descendant), CHANGE.     * Ports d'interruption externe fréquents : Port $2$ (INT0) et Port $3$ (INT1).     * noInterrupts(); / interrupts(); : Permettent de désactiver/réactiver les interruptions.