Dans cette catégorie, sont regroupés les sketchs qui permettent l’apprentissage du principe de fonctionnement des entrées et sorties de l’Arduino Uno.

 

1. Blink

Le sketch permet de faire clignoter une DEL rouge connectée sur la broche 9.

Cette activité a pour but l’apprentissage de l’utilisation des sorties digitales de l’Arduino qui ne peuvent prendre que 2 valeurs : 0 (niveau bas) ou 1 (niveau haut), soit électriquement : 0 V ou +5 V.

Donc, pour allumer la DEL, la broche de l’Arduino sur laquelle celle-ci est connectée, doit être au niveau haut (+5V) et pour l’éteindre, elle doit être au niveau bas (0 V).

Pour réaliser cette activité, on va demander à l’Arduino d’allumer la DEL (donc d’appliquer un niveau haut sur la broche de la DEL) pendant une durée définie par une variable, puis de l’éteindre (donc d’appliquer un niveau bas sur la broche de la DEL) pendant une durée définie par une autre variable, puis à nouveau de l’allumer et cela indéfiniment.

De cette façon, on verra la DEL clignoter.

// Déclaration des constantes et variables const int PinLed = 9; const int TimeSleep1= 500; const int TimeSleep2= 500; // Initialisation des entrées et sorties void setup() { pinMode(PinLed, OUTPUT); } // Fonction principale en boucle void loop() { digitalWrite(PinLed, HIGH); delay(TimeSleep1); digitalWrite(PinLed, LOW); delay(TimeSleep2); }

2. Bouton_poussoir

Dans cette activité, la DEL rouge s’allume en appuyant sur le bouton poussoir et s’éteint si on le relâche. L’objectif est de se familiariser avec les entrées numériques de l’Arduino.

En effet, en appuyant sur le bouton poussoir, une tension de + 5V est appliquée sur la broche sur laquelle celui-ci est connecté. La broche est alors à un niveau haut. Si on relâche le bouton poussoir, le circuit électrique est ouvert, la tension sur la broche du bouton poussoir est alors de 0 V et passe à un niveau bas.

Si on demande à l’Arduino d’interroger l’état logique (niveau haut ou bas) de la broche du bouton poussoir qui a été déclaré comme une entrée numérique, on peut savoir si celui-ci est appuyé ou pas et donc lui donner l’ordre d’allumer ou d’éteindre la DEL.

// Déclaration des constantes et variables const int PinLED = 9; const int PinButton = 12; int ValButton = 0; // Initialisation des entrées et sorties void setup() { pinMode (PinLED, OUTPUT); pinMode (PinButton, INPUT); } // Fonction principale en boucle void loop() { ValButton = digitalRead(PinButton); if (ValButton == HIGH) { digitalWrite(PinLED, HIGH); } else { digitalWrite(PinLED, LOW); } }

3. Interrupteur

 

Dans cette activité, quand la DEL est éteinte, si on appuie sur le bouton poussoir, la DEL s’allume, mais contrairement à l’activité « Bouton-poussoir », la DEL ne s’éteint pas quand on relâche le bouton poussoir.

En effet, si la DEL est allumée, celle-ci s’éteint en appuyant de nouveau sur le bouton poussoir.

Le principe de fonctionnement du bouton poussoir est donc comme celui d’un interrupteur.

Pour réaliser cette activité, on va demander à l’Arduino d’interroger l’état logique (niveau haut ou bas) de la broche du bouton poussoir qui a été déclaré comme une entrée numérique.
A l’aide de variables permettant de stocker les valeurs (actuelle et précédente) de cet état, l’Arduino pourra savoir quelle action effectuer (allumer ou éteindre la DEL) après l’appui sur le bouton poussoir.

// Déclaration des constantes et variables const int PinLED = 8; const int PinButton = 12; int ValButton = 0; int OldValButton = 0; int State = 0; // Initialisation des entrées et sorties void setup() { pinMode (PinLED, OUTPUT); pinMode (PinButton, INPUT); } // Fonction principale en boucle void loop() { ValButton = digitalRead(PinButton); delay(10); if ((ValButton == HIGH) && (OldValButton == LOW)) { State = 1 – State; } OldValButton = ValButton; if (State == 1) { digitalWrite(PinLED, HIGH); } else { digitalWrite(PinLED, LOW); } }

4. Potentiometre

L’objectif de cette activité est l’apprentissage du principe de fonctionnement des entrées analogiques de l’Arduino et de l’utilisation du moniteur série.

// Déclaration des constantes et variables const int PinPOT = 0; int ValPot = 0; int OldValPot =0; float Tension=0.00; // Initialisation des entrées et sorties void setup() { Serial.begin(9600); Serial.println(”Valeur A0 ; Tension (V):”); } // Fonction principale en boucle void loop() { ValPot = analogRead(PinPOT); if (abs(ValPot – OldValPot)>=2) { Serial.print(ValPot); Serial.print(” ; ”); Tension=ValPot*5.00/1023; Serial.println(Tension); OldValPot = ValPot; } delay(100); }

5. Sorties_analogiques

 

Le circuit d’étude dispose d’un potentiomètre dont le « point milieu » est relié à la broche A0 de l’Arduino.
Suivant la position du « point milieu », la tension appliquée à la broche A0 varie entre 0 et 5 V. On peut donc utiliser le potentiomètre pour régler la luminosité de la DEL rouge.

En effet, la DEL est connectée sur une broche PWM et contrairement aux sorties numériques qui ne peuvent avoir que deux valeurs 0 ou 1 (0 ou 5V), une sortie analogique (ou plutôt PWM) permet d’obtenir une tension entre 0 et 5 V (les broches 3, 5, 6, 9, 10 et 11 peuvent être configurés en sortie analogique).

Nous allons donc apprendre à utiliser une sortie PWM.

// Déclaration des constantes et variables const int PinPOT = 0; const int PinLED = 9; int ValPot = 0; // Initialisation des entrées et sorties void setup() { pinMode(PinLED, OUTPUT); } // Fonction principale en boucle void loop() { ValPot = analogRead(PinPOT); analogWrite(PinLED, int(ValPot/4)); delay(100); }

6. Bouton_poussoir_Alternance

Dans cette activité, l’allumage en alternance des DELs est géré par le bouton poussoir. Un premier appui sur le bouton allume la diode rouge, un deuxième appui allume la diode verte, un troisième appui allume la diode bleue et ainsi de suite…

Un appui prolongé sur le bouton éteint la DEL allumée.

Comme pour l’activité « Interrupteur« , c’est à l’aide des variables permettant de stocker les valeurs
(actuelle et précédente) de l’état logique de la broche du bouton poussoir, mais aussi d’une variable pour compter le nombre d’appui sur le bouton et de variables pour mesurer la durée d’appui, que l’Arduino pourra allumer ou éteindre les DELs.

// Déclaration des constantes et variables const int PinLEDR = 8; const int PinLEDV = 7; const int PinLEDB = 2; const int PinButton = 12; int ValButton=0; int OldValButton=0; int ComptBtn=0; unsigned long StartTime = 0; unsigned long DeltaTime = 0; // Initialisation des entrées et sorties void setup() { pinMode (PinLEDR, OUTPUT); pinMode (PinLEDV, OUTPUT); pinMode (PinLEDB, OUTPUT); pinMode (PinButton, INPUT); } // Fonction principale en boucle void loop() { ValButton = digitalRead(PinButton); delay(10); if ((ValButton == HIGH)&& (OldValButton == LOW)) { StartTime = millis(); ComptBtn = ComptBtn +1; if (ComptBtn == 4) { ComptBtn = 1; } } if ((ValButton == HIGH) && (OldValButton == HIGH)) { DeltaTime = millis() – StartTime; if (DeltaTime > 500) { ComptBtn = 0; } } OldValButton = ValButton; switch (ComptBtn) { case 1 : digitalWrite(PinLEDR, HIGH); digitalWrite(PinLEDV, LOW); digitalWrite(PinLEDB, LOW); break; case 2 : digitalWrite(PinLEDR, LOW); digitalWrite(PinLEDV, HIGH); digitalWrite(PinLEDB, LOW); break; case 3 : digitalWrite(PinLEDR, LOW); digitalWrite(PinLEDV, LOW); digitalWrite(PinLEDB, HIGH); break; case 0 : digitalWrite(PinLEDR, LOW); digitalWrite(PinLEDV, LOW); digitalWrite(PinLEDB, LOW); break; } }

7. DEL_RVB_Brightness

 

Cette activité a pour objectif l’apprentissage de l’utilisation des sorties analogiques de l’Arduino UNO.

Contrairement aux sorties numériques qui ne peuvent avoir que deux valeurs 0 ou 1 (0 ou 5V), une sortie analogique (ou plutôt PWM) permet d’obtenir une tension entre 0 et 5 V. les broches 3, 5, 6, 9, 10 et 11 peuvent être configurés en sortie analogique.

C’est pour cela que les anodes de la DEL RVB (à cathode commune) de notre circuit sont connectées sur les broches :

– 9 pour la DEL rouge
– 11 pour la DEL verte
– 10 pour la DEL Bleue

Nous allons utiliser ces sorties pour alimenter une DEL (DEL rouge, verte ou bleue de la DEL RVB) et faire varier sa luminosité suivant ce principe de fonctionnement :

– La DEL étant éteinte, si on appuie sur le bouton poussoir, la diode s’allume.
– On règle la luminosité de la DEL en maintenant le bouton poussoir appuyé, du moins au plus lumineux (broche de la DEL à +0V) jusqu’à un maximum (broche de la DEL à +5V).
– Quand le maximum de la luminosité est atteint et que le bouton poussoir est maintenu appuyé, la luminosité revient au minimum (broche de la DEL à 0V).
– La DEL étant allumée, si on appuie sur le bouton poussoir, elle s’éteint.

// Déclaration des constantes et variables const int PinLED = 11; const int PinButton = 12; int ValButton = 0; int OldValButton = 0; int State = 0; int Brightness = 0; unsigned long StartTime = 0; unsigned long DeltaTime = 0; // Initialisation des entrées et sorties void setup() { pinMode (PinButton, INPUT); } // Fonction principale en boucle void loop() { ValButton = digitalRead(PinButton); delay(10); if ((ValButton == HIGH) && (OldValButton == LOW)) { State=1-State; StartTime= millis(); } if ((ValButton == HIGH) && (OldValButton == HIGH)) { DeltaTime = millis() – StartTime; if (State == 1 && DeltaTime > 500) { Brightness = Brightness + 1; delay(10); if (Brightness > 255) { Brightness = 0; } } } OldValButton = ValButton; if (State == 1) { analogWrite(PinLED, Brightness); } else { analogWrite(PinLED, 0); Brightness = 0; } }

8. DEL_RVB_Clignotant

 

Cette activité a pour objectif, l’étude des entrées analogiques de l’Arduino.

Ces entrées (A0 à A5), qui peuvent être également utilisées en entrées digitales, sont capables de mesurer la tension réelle, entre 0 et 5V, qui leur est appliquée. On utilisera ces entrées pour les acquisitions avec des capteurs qui délivrent une tension entre 0 et 5 V suivant ce qu’ils mesurent.

Ici, le capteur utilisé est une photorésistance, dont la résistance varie en fonction de l’intensité lumineuse qu’elle reçoit. C’est donc un capteur résistif.

La sortie de la photorésistance est branchée sur une des entrées analogiques de la carte Arduino (entrée A5).

L’objectif est de faire clignoter une DEL à une fréquence dépendant de la lumière ambiante.

Pour cela, on va faire varier le délai entre 2 allumages de la DEL en fonction de la tension de l’entrée A5 et donc de l’intensité lumineuse reçue par la photorésistance.

Quand l’intensité lumineuse reçue par la photorésistance diminue, la fréquence de clignotement augmente.

// Déclaration des constantes et variables const int PinLED = 11; const int PinSensor = A5; int ValSensor = 0; // Initialisation des entrées et sorties void setup() { pinMode (PinLED, OUTPUT); } // Fonction principale en boucle void loop() { ValSensor = analogRead(PinSensor); digitalWrite(PinLED, HIGH); delay(ValSensor); digitalWrite(PinLED, LOW); delay(ValSensor); }

9. DEL_RVB_Analog_brightness

 

Dans cette activité, selon le même principe que l’activité « DEL RVB – Clignotant », on va faire varier la luminosité d’une DEL en fonction de l’intensité lumineuse reçue par la photorésistance.

La luminosité de la DEL sera inversement proportionnelle à l’intensité lumineuse reçue:

– La DEL est allumée ou éteinte en appuyant sur le bouton-poussoir.
– La luminosité de la DEL varie en fonction de la tension de l’entrée A5.

// Déclaration des constantes et variables const int PinLED = 11; const int PinSensor = A5; const int PinButton = 12; int ValButton = 0; int ValSensor = 0; int OldValButton = 0; int State = 0; // Initialisation des entrées et sorties void setup() { pinMode (PinLED, OUTPUT); pinMode (PinButton, INPUT); } // Fonction principale en boucle void loop() { ValButton = digitalRead(PinButton); ValSensor = analogRead(PinSensor); delay(10); if ((ValButton == HIGH) && (OldValButton == LOW)) { State = 1 – State; } OldValButton = ValButton; if (State == 1) { analogWrite(PinLED, 255 – ValSensor/4); } else { analogWrite(PinLED, 0); } }