Initiation Arduino (2ème séance)

Le vendredi 08 mars 2019

Sept participants étaient présent à cette soirée (André, Daniel, Eric, Jean-Claude, Jean-Pierre, Michel et Pascal).
Sans oublier Patrick qui est venu m’épauler pour les travaux pratique.

Patrick a présenté un document rassemblant quelques éléments comme l’historique et la philosophie de l’Arduino, les différentes versions hardwares, la connectique de l’Arduino Nano, un comparatif des différentes versions de cartes, une synthèse des entrées/sorties numériques et analogiques, ….

@Zdjęcia Arkadiusz Sikorski 2012

Le document utilisé par Patrick étant sous copyright pour partie, je ne me permettrais pas de le publier ici.

Pour ceux qui souhaiteraient creuser le sujet, je les invite à visiter ces quelques sites :

Ci-dessous, vous trouverez le pinout de l’Arduino Nano :

@wikimedia.org

Rappelons-nous qu’il est préférable de ne pas utiliser la sortie numérique D13, qui est raccordée à une diode LED sur la carte, ce qui risque de perturber ce que vous pourriez tenter de faire (pensez au chiffre 13 portant malheur HiHi !).
Deux autres entrées/sorties sont également déconseillées, il s’agit des D0 et D1, qui sont réservées à la communication série et entre autre avec la prise USB.
Sur un Arduino Nano, nous n’avons en réalité que l’usage de 10 entrées/sorties numériques de D2 à D12.
Si vos besoins en entrées/sorties sont supérieurs, vous devrez vous tournez vers des versions d’Arduino comme les Due ou Mega.
Il existe aussi des cartes d’extensions.

La recommandation à propos des entrées digitales et afin qu’une valeur logique soit stable, il faut que le niveau 0 logique soit compris entre 0 et 1 V. Quant à la valeur logique 1, elle devra se trouver entre 3,5 V et 5 V.
La zone comprise entre 1 V et 3,5 V sera considérée comme une zone d’incertitude, elle pourra prendre une valeur logique de 0 ou de 1, de manière aléatoire et en fonction du matériel.
Donc à proscrire !!!!

Arduino Zones de Valeurs logiques

Toujours pour les pines digitales en entrée, nous avons 3 cas de figure :

Montage d'entrée Arduino

Fig. 1 : Malgré avoir défini la pine en entrée par pinMode(N° de pine, INPUT), n’ayant pas de résistance de tirage au +5V ou au 0 (Pullup ou Pulldown), nous risquons d’être dans une incertitude logique
Fig. 2 : Dans ce cas, nous avons défini en entrée la pine [pinMode(N° de pine, INPUT)] et avons placé une résistance de tirage au + 5V (Pullup). Le switch ouvert donnera un 1 logique. En fermant le switch, nous forcerons la pine à la masse (0 V), soit le niveau logique 0.
Fig. 3 : Cette fois nous utilisons la commande « pinMode(N° de pine, INPUT_PULLUP) » qui connectera en interne une résistance de tirage au niveau logique 1. Nous obtenons alors l’équivalent de la Fig. 2. (C’est la solution que nous utilisons avec notre kit)

A notez que la commande « pinMode(N° de pine, INPUT_PULLDOWN) » n’existe pas !!!!!!

Et nous avons résumé en quelques mots les notions acquises lors de la première séance.

Les 2 exercices du jour

Feux Tricolores

//***************************************
//*                                     *
//* Initiation à Arduino par l'exemple  *
//*                                     *
//* Par Stievenart Freddy ON6FS         *
//* Version 1.0 - 23/12/2018            *
//*                                     *
//***************************************
//*                                     *
//*  Exercice 2                         *
//*  Feux tricolores                    *
//*                                     *
//***************************************

const int LEDR = 10; // On assigne à l'étiquette LEDR (Feu Rouge) la broche D10 
const int LEDO = 9;  // On assigne à l'étiquette LEDO (Feu Orange) la broche D9
const int LEDV = 8;  // On assigne à l'étiquette LEDV (Feu Vert) la broche D8


//***************************************
//*                                     *
//*  Zone de Setup                      *
//*                                     *
//***************************************

void setup() {
pinMode(LEDV, OUTPUT); //LED1 est une broche de sortie
pinMode(LEDO, OUTPUT); //LED2 est une broche de sortie
pinMode(LEDR, OUTPUT); //LED3 est une broche de sortie
//Serial.begin(9600);    //Initiation du port série USB pour le monitorage

}

//***************************************
//*                                     *
//*  Zone de Loop                       *
//*                                     *
//***************************************

void loop() {
digitalWrite(LEDV, HIGH);       //allumer LEDV
digitalWrite(LEDO, LOW);        //Eteindre LEDO
digitalWrite(LEDR, LOW);        //Eteindre LEDR
//Serial.print(" - LEDV : HIGH");
//Serial.print(" - LEDO : LOW");
//Serial.println(" - LEDR : LOW");
delay(10000);                   // attendre 10 seconde
digitalWrite(LEDV, LOW);        // Eteindre LEDV
digitalWrite(LEDO, HIGH);       // allumer LEDO
digitalWrite(LEDR, LOW);        // Eteindre LEDR
//Serial.print(" - LEDV : LOW");
//Serial.print(" - LEDO : HIGH");
//Serial.println(" - LEDR : LOW");
//BlinkO();                       //clignotement de LEDO
delay(4000);                    // attendre 4 seconde
digitalWrite(LEDV, LOW);        // Eteindre LEDV
digitalWrite(LEDO, LOW);        // Eteindre LEDO
digitalWrite(LEDR, HIGH);       // allumer LEDR
//Serial.print(" - LEDV : LOW");
//Serial.print(" - LEDO : LOW");
//Serial.println(" - LEDR : HIGH");
delay(10000);                   // attendre 10 seconde
}

//***************************************
//*                                     *
//*  Fonction clignotant orange         *
//*                                     *
//***************************************

void BlinkO(){
  int i;
// 4 cligtements
  for (i = 0; i < 4; i++){
    digitalWrite(LEDO, HIGH);   // allumer LEDO
    delay(500);                 // attendre 500 ms
    digitalWrite(LEDO, LOW);    // éteindre LEDO
    delay(500);                 // attendre 500 ms
  }
}

//***************************************

//* *

//* Initiation à Arduino par l'exemple *

//* *

//* Par Stievenart Freddy ON6FS *

//* Version 1.0 - 23/12/2018 *

//* *

//***************************************

//* *

//* Exercice 2 *

//* Feux tricolores *

//* *

//***************************************

const int LEDR = 10; // On assigne à l'étiquette LEDR (Feu Rouge) la broche D10

const int LEDO = 9; // On assigne à l'étiquette LEDO (Feu Orange) la broche D9

const int LEDV = 8; // On assigne à l'étiquette LEDV (Feu Vert) la broche D8

//***************************************

//* *

//* Zone de Setup *

//* *

//***************************************

void setup() {

pinMode(LEDV, OUTPUT); //LED1 est une broche de sortie

pinMode(LEDO, OUTPUT); //LED2 est une broche de sortie

pinMode(LEDR, OUTPUT); //LED3 est une broche de sortie

//Serial.begin(9600); //Initiation du port série USB pour le monitorage

}

//***************************************

//* *

//* Zone de Loop *

//* *

//***************************************

void loop() {

digitalWrite(LEDV, HIGH); //allumer LEDV

digitalWrite(LEDO, LOW); //Eteindre LEDO

digitalWrite(LEDR, LOW); //Eteindre LEDR

//Serial.print(" - LEDV : HIGH");

//Serial.print(" - LEDO : LOW");

//Serial.println(" - LEDR : LOW");

delay(10000); // attendre 10 seconde

digitalWrite(LEDV, LOW); // Eteindre LEDV

digitalWrite(LEDO, HIGH); // allumer LEDO

digitalWrite(LEDR, LOW); // Eteindre LEDR

//Serial.print(" - LEDV : LOW");

//Serial.print(" - LEDO : HIGH");

//Serial.println(" - LEDR : LOW");

//BlinkO(); //clignotement de LEDO

delay(4000); // attendre 4 seconde

digitalWrite(LEDV, LOW); // Eteindre LEDV

digitalWrite(LEDO, LOW); // Eteindre LEDO

digitalWrite(LEDR, HIGH); // allumer LEDR

//Serial.print(" - LEDV : LOW");

//Serial.print(" - LEDO : LOW");

//Serial.println(" - LEDR : HIGH");

delay(10000); // attendre 10 seconde

}

//***************************************

//* *

//* Fonction clignotant orange *

//* *

//***************************************

void BlinkO(){

int i;

// 4 cligtements

for (i = 0; i < 4; i++){

digitalWrite(LEDO, HIGH); // allumer LEDO

delay(500); // attendre 500 ms

digitalWrite(LEDO, LOW); // éteindre LEDO

delay(500); // attendre 500 ms

}

Certains auront remarqué que la séquence normale ne se déroule pas correctement (Vert => Orange => Rouge => Vert => …..) !
A vous de revoir l’attribution des couleurs en jouant sur les numéros de pines.
J’espère que Pascal me pardonnera pour cet exercice !!!!!

Vous pouvez décommanter la ligne 54 « BlinkO(); », vous observerez une nouvelle séquence : Vert => Orange clignotant => Orange => Rouge => Vert => …..

Vous pouvez décommenter tous les « Serial.print » et « Serial.println » pour regarder ce qui se passe sur le Monitoring.

Contrôle d’état d’un switch

//***************************************
//*                                     *
//* Initiation à Arduino par l'exemple  *
//*                                     *
//* Par Stievenart Freddy ON6FS         *
//* Version 1.0 - 24/12/2018            *
//*                                     *
//***************************************
//*                                     *
//*  Exercice 3                         *
//*  Contrôle état d'un switch +        *
//*  affichage de l'état                *
//*                                     *
//***************************************

const int SW1 = 3;   // On assigne à l'étiquette SW1 la broche D3 (Switch 1)
const int SW2 = 12;  // On assigne à l'étiquette SW2 la broche D12 (Switch 2)
const int SW3 = 11;  // On assigne à l'étiquette SW3 la broche D11 (Switch 3)
const int LEDR = 10; // On assigne à l'étiquette LEDR (Rouge) la broche D10
const int LEDO = 9;  // On assigne à l'étiquette LEDO (Orange) la broche D9
const int LEDV = 8;  // On assigne à l'étiquette LEDV (Vert) la broche D8
int SW1State = HIGH;    // Init status SW1
int SW2State = HIGH;    // Init status SW2
int SW3State = HIGH;    // Init status SW3


//***************************************
//*                                     *
//*  Zone de Setup                      *
//*                                     *
//***************************************

void setup() {
pinMode(LEDV, OUTPUT);        //LED1 est une broche de sortie
pinMode(LEDO, OUTPUT);        //LED2 est une broche de sortie
pinMode(LEDR, OUTPUT);        //LED3 est une broche de sortie
pinMode(SW1, INPUT_PULLUP);   //SW1 est une broche d'entrée (avec résistance de tirage au niveau logique 1 en interne)
pinMode(SW2, INPUT_PULLUP);   //SW2 est une broche d'entrée (avec résistance de tirage au niveau logique 1 en interne)
pinMode(SW3, INPUT_PULLUP);   //SW3 est une broche d'entrée (avec résistance de tirage au niveau logique 1 en interne)
digitalWrite(LEDV, LOW);      //Eteindre LEDV
digitalWrite(LEDO, LOW);      //Eteindre LEDO
digitalWrite(LEDR, LOW);      //Eteindre LEDR
Serial.begin(9600);           //Initiation du port série USB r le monitorage
}

//***************************************
//*                                     *
//*  Zone de Loop                       *
//*                                     *
//***************************************

void loop() {
SW1State = digitalRead(SW1); //Lecture état SW1
//Serial.print(" - SW1 : ");
//Serial.println(SW1State);
//delay(100);

  // Tester si le switch SW2 est pressé. Si oui, la LED Rouge sera allumée
  if (SW1State == LOW) {
    // turn LED on:
    digitalWrite(LEDR, HIGH);
  } else {
    // turn LED off:
    digitalWrite(LEDR, LOW);
  }

SW2State = digitalRead(SW2); //Lecture état SW2
//Serial.print(" - SW2 : ");
//Serial.println(SW2State);
//delay(100);

  // Tester si le switch SW2 est pressé. Si oui, la LED Orange sera allumée
  if (SW2State == LOW) {
    // turn LED on:
    digitalWrite(LEDO, HIGH);
  } else {
    // turn LED off:
    digitalWrite(LEDO, LOW);
  }

SW3State = digitalRead(SW3); //Lecture état SW3
//Serial.print(" - SW3 : ");
//Serial.println(SW3State);
//delay(100);

  // Tester si le switch SW3 est pressé.  Si oui, la LED Verte sera allumée
  if (SW3State == LOW) {
    // turn LED on:
    digitalWrite(LEDV, HIGH);
  } else {
    // turn LED off:
    digitalWrite(LEDV, LOW);
  }
}

//***************************************

//* *

//* Initiation à Arduino par l'exemple *

//* *

//* Par Stievenart Freddy ON6FS *

//* Version 1.0 - 24/12/2018 *

//* *

//***************************************

//* *

//* Exercice 3 *

//* Contrôle état d'un switch + *

//* affichage de l'état *

//* *

//***************************************

const int SW1 = 3; // On assigne à l'étiquette SW1 la broche D3 (Switch 1)

const int SW2 = 12; // On assigne à l'étiquette SW2 la broche D12 (Switch 2)

const int SW3 = 11; // On assigne à l'étiquette SW3 la broche D11 (Switch 3)

const int LEDR = 10; // On assigne à l'étiquette LEDR (Rouge) la broche D10

const int LEDO = 9; // On assigne à l'étiquette LEDO (Orange) la broche D9

const int LEDV = 8; // On assigne à l'étiquette LEDV (Vert) la broche D8

int SW1State = HIGH; // Init status SW1

int SW2State = HIGH; // Init status SW2

int SW3State = HIGH; // Init status SW3

//***************************************

//* *

//* Zone de Setup *

//* *

//***************************************

void setup() {

pinMode(LEDV, OUTPUT); //LED1 est une broche de sortie

pinMode(LEDO, OUTPUT); //LED2 est une broche de sortie

pinMode(LEDR, OUTPUT); //LED3 est une broche de sortie

pinMode(SW1, INPUT_PULLUP); //SW1 est une broche d'entrée (avec résistance de tirage au niveau logique 1 en interne)

pinMode(SW2, INPUT_PULLUP); //SW2 est une broche d'entrée (avec résistance de tirage au niveau logique 1 en interne)

pinMode(SW3, INPUT_PULLUP); //SW3 est une broche d'entrée (avec résistance de tirage au niveau logique 1 en interne)

digitalWrite(LEDV, LOW); //Eteindre LEDV

digitalWrite(LEDO, LOW); //Eteindre LEDO

digitalWrite(LEDR, LOW); //Eteindre LEDR

Serial.begin(9600); //Initiation du port série USB r le monitorage

}

//***************************************

//* *

//* Zone de Loop *

//* *

//***************************************

void loop() {

SW1State = digitalRead(SW1); //Lecture état SW1

//Serial.print(" - SW1 : ");

//Serial.println(SW1State);

//delay(100);

// Tester si le switch SW2 est pressé. Si oui, la LED Rouge sera allumée

if (SW1State == LOW) {

// turn LED on:

digitalWrite(LEDR, HIGH);

} else {

// turn LED off:

digitalWrite(LEDR, LOW);

}

SW2State = digitalRead(SW2); //Lecture état SW2

//Serial.print(" - SW2 : ");

//Serial.println(SW2State);

//delay(100);

// Tester si le switch SW2 est pressé. Si oui, la LED Orange sera allumée

if (SW2State == LOW) {

// turn LED on:

digitalWrite(LEDO, HIGH);

} else {

// turn LED off:

digitalWrite(LEDO, LOW);

}

SW3State = digitalRead(SW3); //Lecture état SW3

//Serial.print(" - SW3 : ");

//Serial.println(SW3State);

//delay(100);

// Tester si le switch SW3 est pressé. Si oui, la LED Verte sera allumée

if (SW3State == LOW) {

// turn LED on:

digitalWrite(LEDV, HIGH);

} else {

// turn LED off:

digitalWrite(LEDV, LOW);

}

Une fois le sketch installé sur votre Arduino, pressez les switches et vérifiez si la LED correspondante s’allume.

Vous pouvez décommenter tous les « Serial.print » et « Serial.println » pour regarder ce qui se passe sur le Monitoring.

Ce qu’il faut retenir de cette soirée !

Les quelques éléments présentés par Patrick et que j’ai tenté de reprendre en début de cette page
Les quelques nouvelles fonctions que nous avons abordé dans ces quelques exercices
- Appel d’une fonction et création d’une fonction
- La boucle « for » avec comme paramètres : la valeur de départ, la condition de sortie de boucle et l’incrémentation à chaque boucle
- « pinMode(N° de pine digitale, INPUT) » ou « pinMode(SW1, INPUT_PULLUP) » : initiation d’une pine en entrée, sans ou avec résistance de « Pullup » interne
- digitalWrite(N° de pine digitale, LOW ou HIGHT) : positionnement à un niveau logique O ou 1 d’une sortie digitale
- La condition « if(condition) …. else » : servira à prendre des décisions selon la situation

Radio-Club de Viry-Châtillon (91) - F5KEE

Nos activités autour de la radio, des techniques et des sciences, explorant et développant diverses activités et projets connexes.