| |
arduino:esnumeriques [2022/07/29 19:21] – [3.5.2 Temporisation non bloquante] phil | arduino:esnumeriques [Date inconnue] (Version actuelle) – supprimée - modification externe (Date inconnue) 127.0.0.1 |
---|
{{ :suivant.png?nolink&30|}} {{ :retour.png?nolink&30|}} [[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}} | |
<note warning>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]]</note> | |
| |
=== 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> | |
| |