| |
| arduino:esnumeriques [2022/08/03 09:22] – phil | arduino:esnumeriques [Date inconnue] (Version actuelle) – supprimée - modification externe (Date inconnue) 127.0.0.1 |
|---|
| [[arduino:accueilarduino|{{ :iconemaison.jpg?nolink&30|Sommaire Arduino}}]] | |
| |
| ===== Les entrées, sorties numériques ===== | |
| |
| [Mise à jour le 26/4/2021] | |
| {{ :arduino:arduino.png?nolink&100|}} | |
| |
| ==== 1. Généralités ==== | |
| //« Dans un système à base de **microcontrôleur**, on appelle **entrées-sorties** les échanges d'informations entre le processeur et les périphériques qui lui sont associés. De la sorte, le système peut réagir à des modifications de son environnement, voire le contrôler. Elles sont parfois désignées par l'acronyme **I**/**O**, issu de l'anglais **Input**/**Output** ou encore **E**/**S** pour **entrées**/**sorties**. »// Source Wikipédia | |
| |
| Pour éviter de faire référence à des valeurs électriques (tension ou intensité), on définit souvent l’état d’un signal numérique en utilisant la logique booléenne. | |
| * **true** (« **1** » logique) correspondra par exemple à **5V** ou **3,3V** | |
| * **false** (« **0** » logique) correspondra à **0V**. | |
| |
| <callout type="primary" icon="true">Le nombre de broches d’un microcontrôleur est limité. Il est fréquent d’avoir plusieurs fonctionnalités sur une même broche.</callout> | |
| |
| <callout type="warning" icon="true">Une sortie numérique conserve la dernière information qui lui a été envoyée. Elle se comporte comme une **mémoire**.</callout> | |
| |
| ---- | |
| |
| ==== 2. Les entrées/sorties numériques de la carte Arduino Uno ==== | |
| Les entrées, sorties numériques sont numérotées entre **0** et **13** sur la carte. Certaines peuvent assurer plusieurs fonctions. Le symbole **~** identifie les broches capables de délivrer un signal PWM. | |
| |
| {{ :arduino:esnum.png?nolink |}} | |
| |
| <callout type="primary" icon="true">Le **schéma** de la carte est téléchargeable <html><a href="http://marcusjenkins.com/wp-content/uploads/2014/06/ARDUINO_V2.pdf" target="_blank">ici</a></html>.</callout> | |
| ==== 3. Programmation ==== | |
| |
| === 3.1 Configurer une broche en entrée ou en sortie === | |
| **Source** : <html><a href="https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/" target="_blank">pinMode()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html> | |
| |
| <callout type="tip" icon="true">**Configurer** une broche signifie qu'on précise qu'elle doit se comporter soit comme une entrée d'information, soit comme une sortie d'information.</callout> | |
| |
| __Exemple__ | |
| |
| <code cpp *.cpp> | |
| // Sauf exception la configuration d'une broche se fait dans la fonction setup() | |
| void setup() { | |
| pinMode(13,OUTPUT); // la broche 13 se comporte comme une sortie | |
| pinMode(12,INPUT); // la broche 12 se comporte comme une entrée, | |
| // optionnel si la broche n'a pas été préalablement | |
| // configurée en sortie, car c'est le mode par défaut | |
| } | |
| </code> | |
| |
| === 3.2 Lire l'état logique présent sur une broche === | |
| **Source** : <html><a href="https://www.arduino.cc/reference/en/language/functions/digital-io/digitalread/" target="_blank">digitalRead()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html> | |
| |
| <callout type="tip" icon="true">La valeur lue sur une broche configurée en entrée doit être sauvegardée dans une **variable**.</callout> | |
| |
| __Exemple__ | |
| |
| <code cpp *.cpp> | |
| // L'opération de lecture se fait dans la fonction loop(). | |
| void loop() { | |
| int valeur = digitalRead(12); // l'état logique présent sur la broche 12 est sauvegardé | |
| // dans la variable valeur | |
| } | |
| </code> | |
| |
| === 3.3 Ecrire un état logique sur une broche === | |
| **Source** : <html><a href="https://www.arduino.cc/reference/en/language/functions/digital-io/digitalwrite/" target="_blank">digitalWrite()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html> | |
| |
| <callout type="tip" icon="true">Un état logique **haut(HIGH)** ou **bas(LOW)** peut être écrit sur une broche préalablement configurée en sortie.</callout> | |
| |
| __Exemple__ | |
| |
| <code cpp *.cpp> | |
| void setup() { | |
| pinMode(13, OUTPUT); // la broche 13 se comportera comme une sortie | |
| } | |
| |
| // L'opération d'écriture se fait dans la fonction loop(). | |
| void loop() { | |
| digitalWrite(13, HIGH); // La broche 13 présente un état logique haut (par exemple 5V) | |
| } | |
| </code> | |
| |
| === 3.4 Générer un signal PWM === | |
| **Source** : <html><a href="https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/" target="_blank">analogWrite()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html> | |
| |
| <callout type="tip" icon="true">Seules les broches identifiées ci-dessous peuvent délivrer un signal PWM.</callout> | |
| |
| ^ Cartes ^ Broche PWM ^ Fréquence ^ | |
| |Uno, Nano, Mini|3, 5, 6, 9, 10, 11|490 Hz (broches 5 et 6: 980 Hz)| | |
| |
| __Exemple__ | |
| |
| <code cpp *.cpp> | |
| void setup() { | |
| pinMode(11, OUTPUT); // la broche 11 se comportera comme une sortie | |
| } | |
| |
| // L'opération d'écriture se fait dans la fonction loop(). | |
| void loop() { | |
| analogWrite(11, 127); // La broche 11 délivre un signal PWM de fréquence F=490Hz | |
| // et de rapport cyclique = 1/2 | |
| } | |
| </code> | |
| |
| === 3.5 Temporisations === | |
| * **Sources** : <html><a href="https://www.arduino.cc/reference/en/language/functions/time/delay/" target="_blank">delay</a></html>, <html><a href="https://www.arduino.cc/reference/en/language/functions/time/delaymicroseconds/" target="_blank">delayMicroseconds</a></html>, <html><a href="https://www.arduino.cc/reference/en/language/functions/time/micros/" target="_blank">micros</a></html> et <html><a href="https://www.arduino.cc/reference/en/language/functions/time/millis/" target="_blank">millis</a></html> sur le site arduino. | |
| |
| == 3.5.1 Temporisation bloquante== | |
| * de **n millisecondes** avec la fonction : //void **delay**(int millisecondes)// | |
| |
| <code cpp *.cpp> | |
| // Le code met le programme en pause pendant une seconde avant de faire basculer l'état logique de la broche. | |
| |
| int ledPin = 13; // LED connected to digital pin 13 | |
| |
| void setup() { | |
| pinMode(ledPin, OUTPUT); // sets the digital pin as output | |
| } | |
| |
| void loop() { | |
| digitalWrite(ledPin, HIGH); // sets the LED on | |
| delay(1000); // waits for a second | |
| digitalWrite(ledPin, LOW); // sets the LED off | |
| delay(1000); // waits for a second | |
| } | |
| </code> | |
| |
| * de **n microsecondes** avec la fonction : //void **delayMicroseconds**(int microsecondes)// (Erreur = +/-3µs) | |
| |
| <code cpp *.cpp> | |
| // Le code configure la broche numéro 8 en sortie. | |
| // Il envoie un train d'impulsions d'une période d'environ 100 microsecondes. | |
| // L'approximation est due à l'exécution des autres instructions. | |
| |
| int outPin = 8; // digital pin 8 | |
| |
| void setup() { | |
| pinMode(outPin, OUTPUT); // sets the digital pin as output | |
| } | |
| |
| void loop() { | |
| digitalWrite(outPin, HIGH); // sets the pin on | |
| delayMicroseconds(50); // pauses for 50 microseconds | |
| digitalWrite(outPin, LOW); // sets the pin off | |
| delayMicroseconds(50); // pauses for 50 microseconds | |
| } | |
| </code> | |
| |
| == 3.5.2 Temporisation non bloquante == | |
| |
| * **Temps écoulé**, en **millisecondes**, depuis le démarrage du programme avec la fonction : // unsigned long **millis**()// | |
| |
| <callout type="primary" icon="true">**millis()** renvoie le nombre de millisecondes écoulées depuis que la carte Arduino a commencé à exécuter le programme. Ce nombre va déborder (revenir à zéro), après environ 50 jours.</callout> | |
| |
| |
| * // Structure d'une temporisation non bloquante // | |
| <code cpp *.cpp> | |
| // Répétition d'un bloc de code tous les intervalles de temps sans bloquer le programme | |
| unsigned long previousMillis = 0; // Mémorise le temps écoulé depuis la dernière mesure | |
| const long interval = 1000; // Durée non bloquante souhaitée | |
| |
| void setup() { | |
| // Le contenu de setup dépend de l'application | |
| } | |
| |
| void loop() { | |
| // Mesure du temps écoulé depuis que le programme s'exécute | |
| unsigned long currentMillis = millis(); | |
| | |
| // Si l'attente souhaitée est atteinte on exécute le bloc de code | |
| if (currentMillis - previousMillis >= interval) { | |
| // la mesure de temps actuelle devient la dernière mesure | |
| previousMillis = currentMillis; | |
| // | |
| // Bloc de code à exécuter tous les intervalles de temps | |
| // | |
| } | |
| // | |
| // sinon d'autres actions sont possibles | |
| // | |
| } | |
| | |
| </code> | |
| |
| * **Temps écoulé**, en **microsecondes**, depuis le démarrage du programme avec la fonction : // unsigned long **micros**()// | |
| |
| <callout type="primary" icon="true">**micros()** renvoie le nombre de microsecondes depuis que la carte Arduino a commencé à exécuter le programme. Ce nombre va déborder (revenir à zéro), après environ 70 minutes. Sur les cartes Arduino 16 MHz (par exemple Duemilanove et Nano), cette fonction a une résolution de quatre microsecondes (c'est-à-dire que la valeur renvoyée est toujours un multiple de quatre).</callout> | |
| |
| <code cpp *.cpp> | |
| unsigned long time; | |
| |
| void setup() { | |
| Serial.begin(9600); | |
| } | |
| void loop() { | |
| Serial.print("Time: "); | |
| time = micros(); | |
| |
| Serial.println(time); | |
| delay(1000); | |
| } | |
| </code> | |
| |
| === 3.6 Interruption === | |
| |
| == 3.6.1 Attacher une interruption == | |
| * **Source** : <html><a href="https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/" target="_blank">attachinterrupt</a></html> sur le site Arduino. | |
| |
| * **Syntaxe** | |
| <code cpp *.cpp> | |
| attachInterrupt(digitalPinToInterrupt(pin), ISR, mode) | |
| </code> | |
| |
| * **ISR** : gestionnaire d'interruption à appeler lorsque l'interruption se produit | |
| * **pin** : broche de la carte (concernée par l'interruption) | |
| * **mode** : définit le moment de déclenchement de l'interruption \\ | |
| * **Paramètres** | |
| * **LOW** déclenche l'interruption chaque fois que la broche est à l'état bas, | |
| * **CHANGE** déclenche l'interruption chaque fois que la broche change de valeur, | |
| * **RISING** déclenche l'interruption sur un front montant, | |
| * **FALLING** déclenche l'interruption sur un front descendant. | |
| |
| * //Exemple// | |
| <code cpp *.cpp> | |
| // Le front montant du signal présent sur la broche 3 de la carte Arduino Uno | |
| // déclenche l'exécution du sous-programme blink | |
| |
| const byte ledPin = 11; // O0 du shield Tinkerkit | |
| const byte interruptPin = 3; // O5 du shield Tinkerkit | |
| volatile byte state = LOW; | |
| |
| void setup() { | |
| pinMode(ledPin, OUTPUT); | |
| pinMode(interruptPin, INPUT_PULLUP); | |
| attachInterrupt(digitalPinToInterrupt(interruptPin), blink, CHANGE); | |
| } | |
| |
| void loop() { | |
| digitalWrite(ledPin, state); | |
| } | |
| |
| void blink() { | |
| state = !state; | |
| } | |
| </code> | |
| |
| {{ :arduino:uc:platformioico.png?50|VSCode & PlatformIO}} | |
| <callout type="info" icon="true">Le projet **PlatformIO** pour l'IDE **VSCode** de l'exemple ci-dessus est téléchargeable [[https://webge.fr/doc/wikis/code/Arduino/ARD_Uno_Interruption.zip|ici]]</callout> | |
| |
| === 3.6.2 Détacher une interruption === | |
| La fonction //detachInterrupt()// désactive l'interruption donnée. | |
| |
| * **Source** : <html><a href="https://www.arduino.cc/reference/en/language/functions/external-interrupts/detachinterrupt/" target="_blank">detachInterrupt</a></html> sur le site Arduino. | |
| |
| * **Syntaxe** | |
| <code cpp *.cpp> | |
| detachInterrupt(digitalPinToInterrupt(pin)) | |
| </code> | |
| |