Différences
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente | |||
formation:arduino [15/10/2020 14:51] – [Code Arduino] fjiang | formation:arduino [16/10/2020 07:58] (Version actuelle) – [... avec une photorésistance] mderansart | ||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
+ | ====== Introduction à Arduino ====== | ||
+ | {{ : | ||
+ | ===== Microcontrôleur ===== | ||
+ | ==== Présentation ==== | ||
+ | {{: | ||
+ | <WRAP center round info 60%> | ||
+ | Un microcontrôleur est un composant électronique qui regroupe les principaux composants d'un ordinateur. | ||
+ | </ | ||
+ | |||
+ | |||
+ | Ils sont utilisés dans des systèmes électroniques et informatiques de taille limitée et spécialisée dans une tâche, ce sont les **systèmes embarqués**, | ||
+ | |||
+ | Un microcontrôleur n'est pas aussi puissant qu'un micro-ordinateur (un ordinateur personnel). Il | ||
+ | est destiné à réaliser une tâche unique/ | ||
+ | permet une faible consommation d' | ||
+ | nombreux systèmes. | ||
+ | |||
+ | ==== Composition ==== | ||
+ | Un microcontrôleur est composé (principalement) de: | ||
+ | * **Horloge** : Elle permet d' | ||
+ | * **Mémoire volatile** : (RAM) Elle stock les données temporaires comme les variables de calculs. | ||
+ | * **Mémoire morte** : (ROM) Elle stock les données qui ne sont pas amenées à changer, comme le programme de mise sous tension de la carte ou encore le programme implémenté dans la carte. | ||
+ | * **Bornes entrées/ | ||
+ | |||
+ | ==== Périphériques ==== | ||
+ | {{: | ||
+ | Les microcontrôleurs sont implémentés sur une carte électronique qui est reliée à des périphériques. Ces périphériques peuvent être des périphériques de capture ou chargé d’exécuter une action. | ||
+ | |||
+ | //Par exemple un thermomètre capture l' | ||
+ | |||
+ | Le microcontrôleur est chargé de faire le lien entre informations entrantes et informations sortantes en fonction du **programme** qui lui a été donné d’exécuter. | ||
+ | |||
+ | //Par exemple: en fonction de la température détectée par le thermomètre, | ||
+ | |||
+ | La notion de **transport de l' | ||
+ | |||
+ | ==== Programmation ==== | ||
+ | Un microcontrôleur est programmable. C' | ||
+ | |||
+ | Pour programmer une carte Arduino il est nécessaire d' | ||
+ | importées et destinées à faciliter la programmation. | ||
+ | |||
+ | Une fois écrit via l' | ||
+ | |||
+ | <WRAP center round info 80%> | ||
+ | La compilation est l' | ||
+ | </ | ||
+ | |||
+ | |||
+ | Les langages Python et Matlab ne sont pas compilables (sauf manipulation spéciale), ils nécessitent un système plus complexe fonctionnant " | ||
+ | une fois compilé est un fichier qui peut être directement exécuté par le processeur, hormis les inconvénients, | ||
+ | |||
+ | Ainsi les microcontrôleurs ne possèdent pas de systèmes d' | ||
+ | |||
+ | ==== Fonctionnement ==== | ||
+ | === Exécution de l' | ||
+ | L’exécution de l' | ||
+ | être exécutée (sauf indications spéciales dans le code). | ||
+ | |||
+ | L’exécution d'une instruction est réalisée en plusieurs étapes, qui sont en général : | ||
+ | * **Lire** en mémoire l' | ||
+ | * **Analyser** l' | ||
+ | * **Exécuter** l' | ||
+ | * **Écrire** en mémoire les résultats de l' | ||
+ | |||
+ | Les parties lire en mémoire et écrire en mémoire nécessite un **adressage des données**, une sorte de carte où les coordonnées dans la mémoire de chaque donnée est écrite. | ||
+ | |||
+ | === Cycle d' | ||
+ | <WRAP center round info 80%> | ||
+ | Le cycle d' | ||
+ | </ | ||
+ | |||
+ | L' | ||
+ | compte le nombre d' | ||
+ | |||
+ | ===== Carte Arduino : Premiers pas ===== | ||
+ | ==== Carte Arduino ==== | ||
+ | <WRAP group> | ||
+ | <WRAP half column> | ||
+ | {{ formation: | ||
+ | </ | ||
+ | |||
+ | <WRAP half column> | ||
+ | 1. Port USB | ||
+ | |||
+ | 2. Port d' | ||
+ | |||
+ | 3. Microcontrôleur | ||
+ | |||
+ | 4. Pins digitaux | ||
+ | |||
+ | 5. Pins analogiques | ||
+ | |||
+ | 6. Sortie de tension et masses (GND) | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ==== Breadboard ==== | ||
+ | {{ formation: | ||
+ | On se sert d’une breadboard pour faire des circuits sans avoir besoin de souder les composants, ce qui est pratique pour l' | ||
+ | |||
+ | {{ formation: | ||
+ | Dans cet exemple, la résistance est reliée à l’alimentation grâce aux fils rouge et vert (**lien horizontale**) alors que la résistance et la LED sont liées grâce à un **lien vertical** (encadré orange). | ||
+ | |||
+ | ===== IDE Arduino ===== | ||
+ | > Un IDE (Integrated Developpement Environment) est un logiciel qui fournit des outils facilitant le développement, | ||
+ | |||
+ | L’IDE d’Arduino est l’un des moyen les plus simples et le plus pratiques pour développer un programme puis le **téléverser** (l’enregistrer sur la carte). Il automatise de nombreuses tâches et facilite la communication avec la carte. | ||
+ | |||
+ | Il est disponible gratuitement sur ce lien: [[https:// | ||
+ | |||
+ | ==== Interface de l’éditeur ==== | ||
+ | <WRAP group> | ||
+ | <WRAP half column> | ||
+ | {{ : | ||
+ | La zone **1** est la zone de saisie. C’est ici que le code devra être typer. | ||
+ | |||
+ | La zone **2** est le **terminal**, | ||
+ | |||
+ | </ | ||
+ | |||
+ | <WRAP half column> | ||
+ | {{ : | ||
+ | Le bouton: | ||
+ | * **1** permet de vérifier le code et détecter les éventuelles erreurs | ||
+ | * **2** permet de téléverser le programme **compilé** dans la mémoire de la carte | ||
+ | * **3** permet d’afficher la fenêtre du moniteur série | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ==== Moniteur Série ==== | ||
+ | Le moniteur série permet d' | ||
+ | ==== Connexion d’une carte ==== | ||
+ | <WRAP group> | ||
+ | <WRAP half column> | ||
+ | Voici comment connecter une carte à votre ordinateur. | ||
+ | * Brancher la carte à votre ordinateur via le câble USB | ||
+ | * Ouvrez l’IDE | ||
+ | * Indiquer la carte qui a été branchée (le nom est inscrit sur la carte) :\\ Outils > Type de carte > “votre_carte” | ||
+ | {{ : | ||
+ | </ | ||
+ | |||
+ | <WRAP half column> | ||
+ | * Indiquer le port USB de communication de votre ordinateur sur lequel est branché le câble : \\ Outils > Port série > “votre_port” | ||
+ | * Il peut y avoir plusieurs ports (essayer un par un) | ||
+ | * Le nom des ports varie en fonction des systèmes d’exploitations Windows ou OSX/Linux | ||
+ | {{ : | ||
+ | |||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ===== Code ===== | ||
+ | ==== Code de base ==== | ||
+ | Le langage utilisé avec Arduino est le langage **C++**, avec des bibliothèques importées par défaut. Ceux ayant déjà codé en C++ ou C ne seront donc pas dépaysés. | ||
+ | |||
+ | Ces langages induisent des principes que ceux n’ayant utilisé que python peuvent ne pas connaître, nous en détaillons quelques-uns. | ||
+ | |||
+ | * Déclaration des variables : Chaque variable doit être **déclarée** avant d’être utilisée. Ceci revient à dire quelles données **type** elles contiendrons et quelle taille de mémoire leur sera allouée. Deux types utilisés sont //int// pour un entier ou //double// pour un nombre à virgule.< | ||
+ | int a; // | ||
+ | a = 10; // | ||
+ | double b; // | ||
+ | b = 10.05; | ||
+ | int c = 5; //forme contracté de déclaration & attribution | ||
+ | </ | ||
+ | * Chaque instruction doit se terminer par un <code cpp>;</ | ||
+ | * L’indentation n’est pas obligatoire (on peut tout écrire sur une seule ligne). | ||
+ | * Ligne de commentaire <code cpp>// exemple</ | ||
+ | * Bloc de commentaire <code cpp>/* exemple */</ | ||
+ | * Les fonctions de bases sont les suivantes: | ||
+ | * pour k allant de 0 à n (exclu)< | ||
+ | for(int k = 0; k < n; k++){ | ||
+ | //bloc de code | ||
+ | } | ||
+ | </ | ||
+ | * si condition est vraie< | ||
+ | if(condition == true){ | ||
+ | //bloc de code | ||
+ | } | ||
+ | </ | ||
+ | * tant que condition est vraie< | ||
+ | while(condition == true){ | ||
+ | //bloc de code | ||
+ | } | ||
+ | </ | ||
+ | ==== Code Arduino ==== | ||
+ | Nous détaillons ici les fonctions de bases d' | ||
+ | |||
+ | * **pinMode()** : Définir comme entrée **INPUT** ou comme sortie **OUTPUT** le pin (branchement) :<code C++> | ||
+ | pinMode(5, INPUT); | ||
+ | pinMode(1, OUTPUT); | ||
+ | |||
+ | //ou en encore : | ||
+ | int nom_pin = 2; | ||
+ | pinMode(nom_pin, | ||
+ | </ | ||
+ | |||
+ | * **digitalRead()** : Lire la valeur binaire (soit **HIGH** soit **LOW**) du pin spécifié. <code C++> | ||
+ | int valeur; | ||
+ | valeur = digitalRead(5); | ||
+ | </ | ||
+ | |||
+ | * **digitalWrite()** : Envoyer la valeur binaire (soit **HIGH** soit **LOW**) au pin spécifié. <code C++> | ||
+ | int nom_pin = 5; | ||
+ | int valeur = LOW; | ||
+ | digitalWrite(nom_pin, | ||
+ | </ | ||
+ | |||
+ | * **analogRead()** : Lire la valeur analogique (de 0 à 1023 (dépendant des cartes) codée sur un type //int//) du pin spécifié. <code C++> | ||
+ | int valeur; | ||
+ | valeur = analogRead(A5); | ||
+ | </ | ||
+ | |||
+ | * **analogWrite()** : Envoyer la valeur analogique (de 0 à 1023 codée sur un type //int//) au pin spécifié. <code C++> | ||
+ | int valeur; | ||
+ | valeur = 500; | ||
+ | int nom_pin; | ||
+ | analogWrite(nom_pin, | ||
+ | </ | ||
+ | |||
+ | * **delay()** : Mettre en " | ||
+ | |||
+ | === Liste exhaustive des fonctions Arduino === | ||
+ | Le site d' | ||
+ | [[https:// | ||
+ | |||
+ | ==== Structure du programme ==== | ||
+ | <WRAP group> | ||
+ | <WRAP half column> | ||
+ | {{ formation: | ||
+ | </ | ||
+ | |||
+ | <WRAP half column> | ||
+ | === Déclaration des variables === | ||
+ | Il se fait avant toute chose. on y insérer les différent nom de pin en gardant des noms caractéristiques. | ||
+ | |||
+ | Par exemple :<code cpp>int Led = 2;</ | ||
+ | |||
+ | === Initialisation === | ||
+ | Elle se fait durant la bloc **setup()**, | ||
+ | |||
+ | === Boucle d' | ||
+ | Le bloc de code **loop()** est l' | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ==== Baud ==== | ||
+ | Le baud concerne la commande énigmatique **Serial.begin(9600); | ||
+ | |||
+ | ===== Applications ===== | ||
+ | ==== Une LED... ==== | ||
+ | === Matériel === | ||
+ | * une LED | ||
+ | * une résistance de 10 k𝞨 | ||
+ | * une breadboard | ||
+ | * des cables | ||
+ | |||
+ | <WRAP center round info 80%> | ||
+ | La catode d'une **LED** ou **diode électroluminescente** est sa plus longue pate. | ||
+ | </ | ||
+ | |||
+ | === Enoncé === | ||
+ | Allumer une LED avec une carte Arduino. | ||
+ | |||
+ | <hidden Solution> | ||
+ | |||
+ | === Enoncé Bis === | ||
+ | Faire clignoter une LED avec une carte Arduino. | ||
+ | |||
+ | <hidden Solution> | ||
+ | <WRAP group> | ||
+ | <WRAP half column> | ||
+ | {{ : | ||
+ | </ | ||
+ | |||
+ | <WRAP half column> | ||
+ | <code C++ / | ||
+ | int pin_led = 9; | ||
+ | |||
+ | void setup() | ||
+ | { | ||
+ | pinMode(pin_led, | ||
+ | } | ||
+ | |||
+ | void loop() | ||
+ | { | ||
+ | digitalWrite(pin_led, | ||
+ | delay(3000); | ||
+ | digitalWrite(pin_led, | ||
+ | delay(3000); | ||
+ | } | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ==== ... avec un bouton poussoir ==== | ||
+ | === Matériel === | ||
+ | * une LED | ||
+ | * un bouton poussoir | ||
+ | * deux résistances de 10 k𝞨 | ||
+ | * une breadboard | ||
+ | * des cables | ||
+ | |||
+ | <WRAP center round important 80%> | ||
+ | Même si un **bouton poussoir** a quatre pattes, il reste un dipôle. Les pattes sont reliées deux à deux. | ||
+ | </ | ||
+ | |||
+ | === Enoncé === | ||
+ | Allumer la LED si le bouton poussoir est activé. | ||
+ | |||
+ | <hidden Solution> | ||
+ | |||
+ | === Enoncé Bis === | ||
+ | Allumer ou éteindre la LED lorsqu' | ||
+ | |||
+ | <hidden Solution> | ||
+ | <WRAP group> | ||
+ | <WRAP half column> | ||
+ | {{ : | ||
+ | </ | ||
+ | |||
+ | <WRAP half column> | ||
+ | <code C++ / | ||
+ | int pin_led = 9; | ||
+ | int pin_etat = 8; | ||
+ | int pin_bouton = 7; | ||
+ | |||
+ | void setup() | ||
+ | { | ||
+ | pinMode(pin_led, | ||
+ | pinMode(pin_etat, | ||
+ | pinMode(pin_bouton, | ||
+ | } | ||
+ | |||
+ | void loop() | ||
+ | { | ||
+ | if(digitalRead(pin_bouton) == LOW){ | ||
+ | if(digitalRead(pin_etat) == LOW){ | ||
+ | digitalWrite(pin_led, | ||
+ | } | ||
+ | else{ | ||
+ | digitalWrite(pin_led, | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ==== ... avec une photorésistance ==== | ||
+ | === Matériel === | ||
+ | * une LED | ||
+ | * une photorésistance | ||
+ | * deux résistances de 10 k𝞨 | ||
+ | * une breadboard | ||
+ | * des cables | ||
+ | |||
+ | <WRAP center round info 80%> | ||
+ | Plus la photorésistance reçoit de la lumière, plus la résistance est faible. Elle renvoie à la carte Arduino une valeur entre 0 et 1023. | ||
+ | </ | ||
+ | |||
+ | === Enoncé === | ||
+ | Si la valeur de la photorésistance est supérieure à 500, allumez la LED. Sinon éteignez-la. | ||
+ | |||
+ | <hidden Solution> | ||
+ | <WRAP group> | ||
+ | <WRAP half column> | ||
+ | {{ : | ||
+ | </ | ||
+ | |||
+ | <WRAP half column> | ||
+ | <code C++ / | ||
+ | int pin_photo = A5; | ||
+ | int pin_led = 6; | ||
+ | float val_res; | ||
+ | |||
+ | void setup() { | ||
+ | pinMode(pin_photo, | ||
+ | pinMode(pin_led, | ||
+ | Serial.begin(9600); | ||
+ | } | ||
+ | |||
+ | void loop() { | ||
+ | val_res = analogRead(pin_photo); | ||
+ | if (val_res >= 500) { | ||
+ | digitalWrite(pin_led, | ||
+ | } | ||
+ | else { | ||
+ | digitalWrite(pin_led, | ||
+ | } | ||
+ | delay(1000); | ||
+ | } | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ===== Ce qu'il faut retenir... ===== | ||
+ | {{ : |