ARDUBLOCKLY.png
Le plus simple :
faire clignoter une LED
Nombre de visites :
290
 

 

Tout d'abord, qu'est-ce qu'un programme ?

(Question à l'usage des enfants de 9 à 11 ans... et de 98% des adultes).


 

Si vous posez cette question : «– Quelle est la succession d'actes élémentaires nécessaires pour faire clignoter une LED ? »

... vous aurez presque immanquablement la réponse suivante : «on allume, puis on éteint».

Cela semble simple et évident.

Cependant une réponse sérieuse aurait été :

  • on allume ;

  • on attend ;

  • on éteint ;

  • on attend ;

  • on recommence indéfiniment (ou presque).

 

Ceci est la suite des opérations élémentaires.

... mais ce n'est pas encore la liste complète des opérations à effectuer pour obtenir un vrai programme.



 

Alors finalement, que faut-il pour faire clignoter cette LED ?

Il faut décrire en détails la décomposition du problème en ses actions élémentaires :

  • dire sur quelle sortie de la carte ARDUINO est connectée la LED ;

  • activer cette sortie ;

  • attendre un certain temps ;

  • désactiver la sortie ;

  • attendre de nouveau ;

  • ... et inclure tout cela dans une boucle de répétition infinie.

 


 

... et en « ARDUBLOCKLY »​ ?

Dans ARDUBLOCKLY, chaque fonction est matérialisée par un bloc.

Une fonction peut réaliser plusieurs actions élémentaires.

Les blocs de fonctions s'assemblent comme des LEGO.

Il va donc être très facile de constituer le programme par un assemblage de blocs de fonctions.

 


 

Sur l'image ci-dessous, on peut voir les 4 blocs de fonction nécessaires au clignotement,
juste déposés mais non assemblés.

BLINK-PRINCIPE-2.png
 
Le bloc «set digital pin #» se trouve dans le menu «Input/Output» ;
Le bloc «wait» se trouve dans le menu «Time» ;

Ci-dessous, ces mêmes blocs sont assemblés et enchâssés dans la boucle de répétition infinie «Arduino loop forever».
(Côté blocs, les commentaires ont été masqués, mais on les voit toujours dans la fenêtre du code source ARDUINO, à droite).
BLINK-PRINCIPE-3.png
 
Le code source ARDUINO (fenêtre de droite) est écrit en langage C++.
Finalement ce sera une manière sympa d'apprendre les bases du langage C++, sans trop de douleur !

Remarque :

Pour obtenir un clignotement plus ou moins rapide, il suffit de changer les valeurs des temporisations dans les 2 blocs 

Avec 500 / 500 on aura un clignotement plus rapide.

Avec 500 / 1000 on aura un clignotement dissymétrique.

Bloc-WAIT-1000.png
 
Schéma de branchement en utilisant un breadboard (plaque d'essai)
ARDUBLOCKLY_num-103_(2020-02-28_18-22).p
La résistance en série avec la LED est indispensable.
On choisira une valeur entre 220 Ω et 3,3 kΩ.
 
 
Transférer le code C++ depuis ARDUBLOCKLY dans L'IDE ARDUINO
Sur l'image ci-dessus on voit une petite icône  en haut à droite de la fenêtre des blocs.
Icone-ARD-1.png
Un «clic» sur cette icône ouvre l'IDE de l'ARDUINO  c'est à dire l'environnement de programmation ARDUINO «en lignes de code» et affiche le texte du programme en langage C++.
C'est à partir de cet IDE que le programme sera compilé puis téléversé dans la carte ARDUINO.
Il semble que dans certains cas cette icône jaune refuse de fonctionner.
Il suffit alors de transférer le code du programme par copier/coller, depuis ARDUBLOCKLY vers L'IDE ARDUINO.
La petite video ci-dessous montre cette manip finalement très simple :
 
Flash périodique
 
 
 
Qu'y a-t-il de différent avec le précédent programme de clignotement d'une LED ?
Peu de choses :
  • on allume la LED ;
  • on attend très peu de temps ;
  • on éteint ;
  • on attend longtemps ;
  • on recommence indéfiniment.
FLASH-1.png
 
L'assemblage de blocs est le même que dans l'article précédent.

Seules les valeurs de temps d'allumage et d'extinction ont été modifiées.

void setup() {

  pinMode(3, OUTPUT);

}

 

void loop() {

  // Déclarer que la LED est branchée sur la sortie n°3...

  // ... et allumer la LED (sortie=état "HAUT")

  digitalWrite(3, HIGH);

  // La LED reste allumée pendant 20 millisecondes.

  delay(20);

  // Eteindre la LED (sortie3 = état "BAS")

  digitalWrite(3, LOW);

  // LED éteinte pendant 3 secondes.

  delay(3000);

 

}

 
Intensité atténuée
 
 
Le programme de base est le même que celui du clignotant.
Pensez à régler la définition de la video sur « 720 p » pour une meilleure définition de l'image.
 
AMUSEZ-VOUS !
 
PWM et intensité variable
CLIGNOTANT AVEC EXTINCTIONS ET ALLUMAGES PROGRESSIFS
(Construction du programme pas à pas)
 
 
Dans le programme précédent «03-INTENSITÉ ATTÉNUÉE» le fonctionnement de la LED avec une intensité atténuée nécessitait 4 blocs.
Or il existe une fonction qui fait la même chose de façon plus élégante, avec un seul bloc : 
BLOC-PWM-0.png
 
 
Associée à une valeur numérique comprise entre 0 et 254, elle fournit sur la sortie PWM choisie un rapport cyclique compris entre 0 et 100% !
BLOC-PWM-1.png
 
 
Ici, avec la valeur numérique «100», on obtiendra un rapport cyclique de 100/254 ≈ 39% ⇒ la LED s'éclairera avec 39% de l'intensité maximale.
Si à la place de cette valeur numérique fixe on utilise une valeur variable, on peut faire varier par programme la valeur de l'éclairement de la LED.
 
Pour faire varier automatiquement le fameux rapport cyclique depuis 0 jusqu'à 254 (par exemple) on va utiliser une boucle de comptage.
 
Mise en place de la boucle de comptage
 
Le microcontrôleur de l'ARDUINO est très rapide et dans ces conditions les boucles
«count with...do... by...» sont parcourues tellement vite qu'on n'a pas le temps de voir une quelconque progression du niveau de luminosité.
Il faut donc accorder du temps à chaque palier d'intensité en insérant une temporisation à l'intérieur de chacune des deux boucles de comptage.
C'est le rôle du bloc «wait» en ARDUBLOCKLY («delay» en langage C++ ).
Décodage du fonctionnement :
  • à chaque tour de la boucle de comptage, la fonction «set analog pin # 3» augmente la luminosité de la LED d'un cran de durée 5 millisecondes, pour partir d'un état «éteint» à un état «allumé au maximum» ;
  • quand le compteur « luminosite » ou «INTENSITE» – suivant notre choix de nom de variable – atteint la valeur «254», le programme sort de la boucle «count with... do... by...» ;
  • ... et la boucle reprend le comptage à partir du début.
Calcul de la durée du cycle de croissance de la luminosité :
nbr de paliers x durée de la temporisation
Pour 254 paliers de 20 millisecondes le cycle dure 5,08 secondes
Si on utilise une temporisation « wait » de 5 millisecondes, le cycle dure 1,27 secondes.
bravo.gif
​Ça y est, le programme
est complet !
informatik.gif
Que nenni !
 
 
Bien entendu, ceci ne suffit pas à obtenir le résultat recherché, à savoir un allumage progressif suivi d'une extinction progressive.
Que manque-t-il ?
La partie «extinction progressive» de la LED.
Duplication de la boucle de comptage
La deuxième boucle fait varier la valeur du compteur, donc de la variable «INTENSITE», de la valeur 254 (éclairé à fond) à la valeur 1 (éteint).
 
Premières variables
Un tel programme est opérationnel.
Cependant, quand on modifie les valeurs mini et maxi dans LES boucles de comptage, il faut faire attention que les deux maxima soient identiques et les deux minima aussi.
C'est ce que montre la video ci-dessus.
La video montre aussi la mise en place des deux variables qui vont résoudre ce problème avec élégance.
Grâce à ces deux variables on est sûr que lorsqu'on modifie dans le setup (Arduino run first) l'une ou l'autre des valeurs de luminosité, cette valeur sera prise en compte sans erreur dans les deux boucles de comptage, càd dans la totalité du programme.
Note :
Peu importe les noms qu'on attribue aux variables, du moment qu'ils sont explicites.
Une variable est un récipient qui contient une valeur, comme une bouteille contient de l'eau en quantité variable.
bravo.gif
​Ça y est, c'est fini maintenant ?
informatik.gif
​Quelle impatience !
Tant qu'on y est, on ajoute deux autres temporisations...
 
juste après chaque boucle «count with...do... by...» :
  • la première fixe la durée pendant laquelle la LED reste allumée à pleine intensité ;
  • la deuxième fixe la durée pendant laquelle la LED reste éteinte
... et aussi deux variables de plus...
 
 
 
Voici à quoi ressemble le programme une fois terminé.
Note :
Sur la copie d'écran ci-dessous, les noms des variables sont différents de ceux visibles dans les videos.
Ils sont un peu plus explicites, mais nous l'avons dit : peu importe le nom des variables, du moment que ce nom nous parle.
LED-PWM-1b.png
 
 
Je vous rassure : un tel programme, une fois compilé et téléversé, ne prend pas plus de place mémoire dans L'ARDUINO que la version sans les 6 variables supplémentaires.
Il n'y a qu'à l'écran, dans la présentation blocs ou C++, qu'il est plus... encombrant.
 
Il suffit maintenant, dans le setup du programme, de jouer avec les différentes valeurs des variables pour obtenir des effets variés d'éclairages de la LED.
Il est d'ailleurs plus rapide de modifier les valeurs directement dans le code C++ depuis L'IDE ARDUINO puisque de toutes façons c'est depuis L'IDE que le programme sera téléversé dans la carte ARDUINO.
 
informatik.gif
 
... et puis va bien falloir vous y mettre, à la ligne de code,
non mais sans blague !
 
 
QUELQUES EXEMPLES EXTRÊMES...
Si on règle la durée des 2 paliers à «0», on obtient un clignotant comme celui de l'article «01-DEBUTER EN DOUCEUR», sans progressivité.
Avec le réglage ci-dessus, on obtient un flash dont la période est 1,6 secondes et avec allumage et extinctions progressifs rapides.
Avec INTENSITE_MINI = 50, la LED ne s'éteint pas complètement.
LED-PWM-2r.png
LED-PWM-2s.png
LED-PWM-2t.png
 
 
Le programme élaboré dans cet article possède donc une sorte d'universalité puisqu'il permet
d'obtenir toute une gamme d'effets en modifiant quelques paramètres.
On pourra utiliser ce programme pour :
  • clignoteur simple, plus ou moins rapide ;
  • feux de P.N. avec simulation de l'inertie thermique du filament des lampes ;
  • flash périodique ;
  • simple fluctuation d'intensité d'une LED pour un éclairage intérieur d'un bâtiment ;
Ça, c'est de la programmation intelligente et organisée :
  • pas besoin de chercher partout dans le programme les bons endroits pour modifier telle valeur de temporisation ou telle valeur de seuil d'intensité... ;
  • ⇒ toutes les variables sont déclarées dans un endroit unique, en tête du programme ;
  • ⇒ le nom des variables est explicite et facilite la compréhension du fonctionnement du programme.
 
 
 
PETIT TOPO SUR LES NOMS DE VARIABLES
ou
«Autant prendre tout de suite des bonnes habitudes»
 
Il est indispensable que les noms de variables que l'on créé soient explicites.
Un nom comme «INTENSITE» ne pose aucun problème.
 
Par contre, si on désire créer une variable pour la durée du palier d'allumage, il faut respecter quelques règles.
 
Le nom de la variable peut contenir :
  • des minuscules ;
  • des majuscules ;
  • des chiffres ;
  • le signe «_» (qui est la minuscule du «8» sur la plupart des claviers).
... mais PAS D'ESPACES.
 
Disons que l'on va se contenter de cela.
 
Sont interdits :
  • les signes «-», «+», «*», «/», «^», «=» qui seraient interprétés comme des opérateurs mathématiques ;
  • les signes «&», «|»,  «!» qui sont des opérateurs booléens ou compound ;
  • les signes «>», «<», «==», «%» qui seraient interprétés comme des opérateurs logiques ;
  • les caractères «{», «}», le point-virgule, «#», les parenthèses ( et ), qui sont utilisés pour structurer le code C++ ;
  • le signe «/» marque aussi les lignes de commentaires, en association avec «*» ou doublé «//» ;
  • le signe «\» qui est utilisé par le système ;
  • les lettres accentuées, qu'elles soient minuscules ou majuscules ;
  • les guillemets «, », ou " ;
  • l'apostrophe «'», les espaces ;
 
Donc, faisons simple : dans le cas de la variable durée du palier d'allumage, on aura droit à ;
  • dureedupalierdallumage ;
  • DureeDuPalierDallumage  (c'est mieux) ;
  • DUREEDUPALIERDALLUMAGE (... pas très facile à lire) ;
  • DUREEduPALIERdALLUMAGE (pourquoi pas) ;
 
... ou encore :
  • duree_du_palier_d_allumage ;
 
et ses variantes :
  • DUREE_PALIER_ALLUMAGE ;
  • Duree_Palier_Allumage ;
  • ...
 
... beaucoup plus faciles à lire.
L'utilisation du signe «_» comme séparateur de mots à la place de l'espace, est une convention universellement utilisée dans le monde de la programmation, quel que soit le langage.
 
En effet, «_» est un caractère qui existe dans tous les alphabets informatiques – y compris anglo-saxon – et qui n'est jamais employé comme opérateur ou caractère structurant.
 
Les lettres accentuées ne sont pas présentes dans l'alphabet anglo-saxon, seule langue utilisée dans les langages de programmation.
 
C'est ce qui explique qu'elles peuvent poser des problèmes si on les utilise dans les noms de variables.
Amusement avec un
servo-moteur
 
 
POUR COMMENCER EN DOUCEUR :
un petit programme tout simple qui fait «gigoter» le servomoteur entre 2 angles choisis.
Préambule
De nombreux modèles de servomoteurs peuvent être utilisés avec ce programme, sauf les servos digitaux.
Ci-dessous, un modèle peu coûteux (moins de 3,00 € sur le net) et qui rend de grands services en modélisme grâce à sa petite taille :
SERVO-9G.jpg
 
 
Le brochage est normalisé, mais la couleur des fils varie d'un fabricant à l'autre.
  • le «+» est rouge. Toujours ;
  • le «-» est souvent noir, jamais bleu, mais l'image ci-dessous prouve qu'il y a des cas particuliers ;
  • le fil pour le «signal» est souvent jaune ou orange... mais pas toujours (bleu sur le connecteur de droite, mais c'est une exception).
SERVO-9G_Connexionx.jpg
 
 
Ce petit préambule n'est destiné qu'à vous éviter des déboires au moment des branchements.
 
BRANCHEMENT DU SERVOMOTEUR SUR LA CARTE ARDUINO
ARDUINO-SERVO_1.png
 
 
Le fil «signal» jaune sera connecté à la broche «~9» de la carte ARDUINO UNO.
Les broches marquées «~x» sont les seules qui ont la possibilité de générer un signal PWM.

 
POUR COMMANDER FACILEMENT LE SERVO...

 
Pas besoin d'écrire nous-même un programme (compliqué) qui génère les impulsions de commande du servo.
Un bloc tout prêt le fait à notre place. Il se trouve dans la rubrique «Motors» :
 
 
Voyons cela avec une toute petite video...
 
 
LE PROGRAMME
Pas plus compliqué que de faire clignoter une LED !
D'ailleurs, les deux programmes se ressemblent étrangement :
 
 
  • positionner le palonnier à 45° ;
  • attendre ;
  • positionner le palonnier à 135° ;
  • attendre ;
  • ... et recommencer.
Plus simple, ce n'est pas possible !
ARDUBLOCKLY-SERVO-3.png
 
 
Le CODE en C++
 
La fenêtre «Arduino Source Code» à droite ci-dessus retranscrit le code en langage C++.
On y retrouve les 4 lignes de code qui positionnent le servo à 45° puis à 135°, avec un temps d'attente après chaque mouvement.
Plus intéressant :
Le bloc 
a automatiquement mis en place :
  • #include <Servo.h> la librairie qui gère la commande des servos en nous facilitant le paramétrage de l'angle en «°» (entre autre) ;
  • Servo myServo9; qui déclare le servomoteur en lui donnant un nom, de façon à pouvoir disposer de fonctions spécifiques à ce servo, telle que la fonction «myServo9.write(45) ; »
Remarque : si on avait connecté et utilisé des servos sur les sorties PWM 3,5,6,9,10 et 11 la librairie «Servo.h» aurait créé 6 instances pour les 6 servos :
  • Servo myServo3 ;
  • Servo myServo5 ;
  • Servo myServo6 ;
  • Servo myServo9 ;
  • Servo myServo10 ;
  • Servo myServo11 ;
... chacune de ses instances donnant par exemple accès au fonctions «myServo3.write(xx)», «myServo5.write(xx)»,... , «myServo11.write(xx)», sans qu'il soit nécessaire de programmer nous-même ces fonctions.
Merci «Servo.h» ! 
Merci surtout à son créateur.

 
... et pour jouer un peu...
 
Oh, ce programme est si simple que les possibilités de paramétrages sont peu nombreuses :
  • la modification des 2 angles, en respectant la plage 0 - 180 °, modifie l'amplitude de déplacement ;
  • la modification des temporisations «wait...» changera la cadence du «gigotage».
Rien de bien extraordinaire.
Cependant, on a appris qu'un servo peut être positionné à un angle précis, et cela avec simplicité.
ARDUBLOCKLY-SERVO-2 (1).png
 
Servo et mouvement lent
En modélisme ferroviaire (entre autre) les les projets d'animations qui nécessitent des mouvements lents ne manquent pas :
  • commandes réalistes d'aiguillages ;
  • ouverture / fermetures de portes de bâtiments industriels ;
  • chute d'arbre ;
  • mouvements d'une grue ;
  • commande de passage à niveau ;
  • pilotage d'une caméra de surveillance (dans une gare cachée par exemple) ;
  • ...
 
 
RACCORDEMENT DU SERVO A LA CARTE ARDUINO
Identique à celui du chapitre précédent
Servo et mouvement lent
ARDUINO-SERVO_1.png
 
 
PREMIÈRE VERSION
SERVO_LENT_0.png
 
 
Le débattement choisi est «1° à 175°» et retour.
La première boucle fait varier «ANGLE» de 1° à chaque tour de boucle, en partant de 1° pour atteindre 175°.
 
Pour obtenir un mouvement lent, on introduit une temporisation de 5 millisecondes avant de calculer la valeur d'angle suivante.
 
La deuxième boucle fonctionne de la même façon, mais de 175° vers 1°.
 
A droite, le code C++.
 
Note :
 
Le servo parcourt 176 pas dans chaque sens.
Chaque pas dure 5 ms.
 
⇒ le cycle «aller» dure 176 x 5 = 880ms, soit un peu moins d'une seconde. Le cycle de retour aussi.
Amusez-vous à modifier la valeur des deux temporisations et constatez les effets.
 
Si les deux temporisations sont différentes, les vitesses aller et retour seront différentes.
 
On peut aussi modifier la valeur du débattement.
 
 

 
DEUXIÈME PROGRAMME
Le défaut de ce premier programme est que, pour savoir où modifier les valeurs de débattement et de rapidité, il faut examiner tous les blocs et les comprendre.
 
La bonne idée consiste alors à créer des variables avec un libellé explicite, lesquelles qui seront déclarées en tête du code, blocs ou C++.
SERVO-LENT-1.png
SERVO-LENT-2.png
 
 
Cette fois, tous les paramètres sont regroupés au début.
Si par exemple on doit modifier «ANGLE_MINI» il suffit de le faire une seule fois dans l'instruction «set ANGLE_MINI to...», alors que la variable «ANGLE_MINI» est utilisée 2 fois.
Imaginez le bazar si le programme comporte plusieurs centaines de lignes (ne rigolez pas, cela arrive plus vite qu'on ne croit ! ) et qu'un même paramètre soit utilisé à dix endroits différents ⇒ comment être sûr de les corriger tous, sans en oublier, si on s'est contenté de les écrire sous forme de valeur chiffrée ?
confused-smiley.png
Ben ! J'avais pas pensé à ça !
 
Servomoteur et contact
  • le contact met l'entrée de commande à la masse
    (0 volts = état «LOW»)
    ⇒ le servo se déplace rapidement vers sa position angulaire maximale ;
  • le contact est relâché
    ⇒ le servo revient rapidement à sa position d'origine.
 
Juste une petite video de 2 minutes...
 
 
 
Pensez à mettre la video en « 720p » pour une meilleure netteté.
(il n'est pas nécessaire de la mettre en mode « plein écran » ).
 
Icone_Video_1.png
720p
Servo, mouvement lent et switch
  • le contact met l'entrée de commande à la masse (0 volts = état «LOW») ⇒ le servo se déplace lentement vers sa position angulaire maximale ;
  • le contact est relâché ⇒ le servo revient lentement à sa position d'origine.
On veut pouvoir paramétrer :
  • la vitesse de déplacement «aller» ;
  • la vitesse de déplacement «retour» ;
  • les consignes d'angle mini et maxi du servo.
RACCORDEMENT DU SERVO ET DU CONTACT
ARDUBLOCKLY_num-591_(2020-06-03_15-16).p
ARDUBLOCKLY_num-592_(2020-06-03_15-18).p
 
À gauche : le switch est relâché ⇒ le servo est en position initiale.
À droite, le switch est actionné ⇒ le servo est en position finale.
 
La broche «commande» du servo est connectée à la broche «~3».
Le contact est raccordé entre «Gnd» et la broche «5».
La résistance PULL UP est raccordée entre « +5V » et la broche «5».
 
Petite video de 11 minutes.
 
 
Pour finir, une petite simulation du résultat :
 
Fache.png

OUPS !
Le programme ARDUBLOCKLY tel qu'il est visible à partir de la minute 9:30 de la video comporte une erreur stupide : le test de la 2e boucle «repeat while» (celle tout en bas) doit se terminer par «HIGH», bien évidemment !
Mea culpa.

 
 
SERVO 2 CONTACTS-6.png
1 SERVO + 2 CONTACTS
+ MÉMOIRE DE POSITION
Ce programme est destiné à piloter un servomoteur pour actionner un aiguillage .
Les mouvements du servo sont déclenchés grâce à 2 contacts fugitifs ;

PETIT CAHIER DES CHARGES
 
Le but est de piloter un servomoteur pour commander un aiguillage.
  • chaque sens de rotation du servo est déclenché par un contact fugitif différent ;
  • les contacts de déclenchement peuvent être non fugitifs, à condition de ne pas être enclenchés en même temps : utilisation du contact ON-OFF d'un relais ou d'un switch ;
  • les lames de l'aiguillage se déplacent avec un mouvement lent, de rapidité réglable ;
  • 2 LED-témoins indiquent que le servo a atteint l'une ou l'autre position finale.
    (Ces LED de contrôle peuvent être installées sur un TCO).
  • le programme peut être étendu à 4 servo-moteurs (pour actionner 4 aiguillages) ;
  • à la place des LED, on peut actionner des relais.

CÂBLAGE DU MONTAGE D'ESSAIS
 
SCHEMA_3.png
 
Ci-contre : le schéma électrique des contacts fugitifs, uniquement (avec les deux résistances «pullup» de 10 kΩ).
Le servo n'est volontairement pas représenté.

Note : ne pas tenir compte des numéros «11», «12»... «18», etc. notés à l'extérieur du rectangle de l'ARDUINO UNO.
 
Seuls sont à considérer les labels «intérieurs» qui correspondent aux indications sérigraphiées sur la carte elle-même.

 
SERVO 2 CONTACTS-8.png
SERVO 2 CONTACTS-7.png
 
Une petite platine d'essai (Breadboard) de 170 points suffira.​
  • à gauche : câblage du servomoteur seul, sur la sortie «3» :
  • à droite : on a ajouté les deux contacts fugitifs (poussoirs) avec leurs résistances «PullUp» de 10 kΩ.
LES VARIABLES


Petit préambule...

Les questions qu'on doit se poser chaque fois nos application sont les suivantes :
– quelles sont les valeurs que le programme va faire évoluer au cours de son  fonctionnement ?
– quelles sont les valeurs qui sont susceptibles d'être ajustées ou modifiées au cours de la mise au point du programme, mais qui ne seront pas modifiées par le programme : paramétrage ?

Dans le premier cas, la création de variables est indispensable.
Dans le deuxième cas on pourrait effectivement ne pas créer de variables et se contenter d'écrire la valeur numérique du paramètre là où on en a besoin. Pourtant, la création de variables donne une meilleure lisibilité au programme, et les interventions sur ces paramètres sont plus aisées et plus sûres.
 

1.– Variables pour les valeurs qui évoluent au cours du fonctionnement :
«Position_palonnier» : position angulaire du palonnier du servomoteur
  • dans ce programme, c'est la seule variable absolument indispensable ;
  • varie de 0 à 180° ;​
  • initialisée à «Position_repos = 90°» (voir ci-dessous) ;
 
2.– Variables de paramétrages :
 
«Position_repos» : position angulaire du palonnier, imposée au démarrage du programme
  • fixée à «90°» ;
  • utilisée pour recaler le servomoteur sur une position médiane ;
«Angle_de_depart» : position angulaire du servomoteur correspondant à l'aiguillage dévié à gauche
  • fixé à une valeur qui permet à la lame de l'aiguillage de plaquer correctement, mais sans plus ;
  • cette valeur dépend de la transmission mécanique entre le palonnier et la barre de commande de l'aiguillage ;
«Angle_d_arrivee» : position angulaire du servomoteur correspondant à l'aiguillage dévié à droite
  • fixé à une valeur qui permet à la lame de l'aiguillage de plaquer correctement, mais sans plus ;
  • cette valeur dépend de la transmission mécanique entre le palonnier et la barre de commande de l'aiguillage ;
«Duree_du_pas» : temps entre 2 position successives du palonnier lors des rotations lentes
  • fixé arbitrairement à 10 millisecondes ;
  • sera ajusté en fonction de la rapidité désirée pour le déplacement des lames d'aiguillage.
STRUCTURE DU PROGRAMME
Que doit faire le programme ?
  1. initialiser la variable et les paramètres ;
  2. amener le servomoteur à une position neutre ;
  3. amener le servomoteur à sa position de départ, càd à la position de départ souhaitée pour l'aiguillage ;
  4. tester en permanence (presque) les contacts fugitifs pour savoir lequel est actif ;
  5. faire tourner le servomoteur à droite ou à gauche, en fonction du contact qui est actionné ;
  6. conserver la position du servomoteur si on relâche le contact ;
  7. ne rien faire si un contact donné reste appuyé longtemps ;
  8. ne rien faire si on relâche un contact et qu'on l'actionne de nouveau (sans avoir actionné l'autre contact).
 
Pour les occurrences «6» à «8», il faudra donc mémoriser dans quelle position le servomoteur s'est arrêté.
 
1.– Installer et initialiser les variables
 
SERVO_variables_1.png
Toutes les variables sont déclarées dans
«Arduino run first».
 
On pourrait ne pas affecter de valeur à «Position_palonnier» puisque cette valeur est constamment calculée par le programme.



 

2.– Amener le servomoteur à une position neutre «Position_repos»
 
SERVO 2 CONTACTS-5.png
Dans «Arduino run first» on insère la commande
«set SERVO...» qui va forcer le servomoteur à se positionner à «Position_repos» que l'on a paramétrée à la valeur 90°.



3.– Amener le servomoteur à sa position de départ : «Angle _de_depart»
 
SERVO 2 CONTACTS-4.png
On créé une fonction personnelle :
«Aller_a_la_position_de_depart».

Grâce à la boucle «count with [Position_palonnier]...», elle va commander commander le déplacement lent du palonnier depuis l'angle «Position_repos» – fixé et atteint dans «Arduino run first» –, jusqu'à l'angle «Angle_de_depart», par pas de 1°.

Entre chaque déplacement de 1°, on attend pendant «Duree_du_pas» fixé a priori à 10 millisecondes.
Ce paramètre sera ajusté en fonction de la vitesse désirée du déplacement des lames de l'aiguillage.
 
Important !

En sortant de la boucle «count with Position_palonnier...» on insère l'instruction «set [Position_servo] to [Angle_de_depart]». 

Cette nouvelle variable «Position_servo» va stocker la position angulaire du servomoteur dans laquelle il s'est arrêté.

Note : avant la boucle de comptage figure une instruction «wait 1000 milliseconds».Cette temporisation n'est pas indispensable.


4.– Tester les contacts dans «Arduino loop forever».
C'est le corps principal du programme.

 
SERVO 2 CONTACTS-1.png
La boucle principale contient 2 fonctions de test :
  • la première teste l'état du contact sur l'entrée «7» ;
  • la deuxième teste l'état du contact sur l'entrée «8».
Si aucun contact n'est appuyé, aucun des 2 tests n'est vrai ⇒ les fonctions «Aiguille_deviee_a_droite» et
«Aiguille_deviee_a_gauche» ne sont pas appelées.
La boucle principale contient seulement les 2 fonctions de test :
  • la première teste l'état du contact sur l'entrée «7» ;
  • la deuxième teste l'état du contact sur l'entrée «8».
Si aucun contact n'est appuyé, aucun des 2 tests n'est vrai :
⇒ les fonctions «Aiguille_deviee_a_droite» et «Aiguille_deviee_a_gauche» ne sont pas appelées.
Analysons maintenant comment sont constituées les deux fonctions personnelles «Aiguille_deviee_a_droite» et «Aiguille_deviee_a_gauche», et comment elles fonctionnent.

5.– Faire tourner le servomoteur à droite ou à gauche
 
SERVO 2 CONTACTS-2.png
On créé deux fonctions personnelles :

«Aiguille_1_deviee_a_droite»

«Aiguille_1_deviee_a_gauche».

 

Fonctionnement : 
 
Les initialisations ont eu lieu et le servomoteur est en position «Angle_de_depart».
La position mémorisée dans «Position servo» est «Angle_de_depart» (voir alinea 3 ci-dessus)

1.– On actionne et on relâche le contact sur l'entrée «7» pour dévier l'aiguille à droite :
  • le test «if read digital pin # [7] = [LOW]» est vrai ⇒ appel de la fonction personnelle «Aiguille_1_deviee_a_droite» ;
  • «Position servo» est différente de «Angle_d_arrivee».
⇒ la boucle fonctionne et amène le palonnier à «Angle_d_arrivee» ;
  • «set [Position_servo] to [Angle_d_arrivee]»  mémorise la nouvelle «Position_servo».
2.– On actionne une nouvelle fois le contact sur l'entrée «7» :
  • «Position_servo» = «Angle_d_arrivee» ⇒ les deux bornes de la boucle sont identiques
    ⇒ la boucle n'est donc pas utilisée.
  • «set [Position_servo] to [Angle_d_arrivee]»  ne fait que confirmer la valeur de «Position_servo».
 
3.– On actionne et on relâche le contact sur l'entrée «8» pour dévier l'aiguille à gauche:
  • le test «if read digital pin # [8] = [LOW]» est vrai ⇒ appel de la fonction personnelle «Aiguille_1_deviee_a_gauche» ;
  • «Position servo» = «Angle_d_arrivee», donc différente de «Angle_de_depart».
⇒ la boucle fonctionne et amène le palonnier à «Angle_de_depart» ;
  • «set [Position_servo] to [Angle_de_depart]»  mémorise la nouvelle «Position_servo».
 
 
4.– On actionne une nouvelle fois le contact sur l'entrée «8» :
  • «Position_servo» = «Angle_de_depart» ⇒ les deux bornes de la boucle sont identiques
    ⇒ la boucle n'est donc pas utilisée.
  • «set [Position_servo] to [Angle_de_depart]»  ne fait que confirmer la valeur de «Position_servo».

 
LE PROGRAMME COMPLET
SERVO_2 CONTACTS_2_LED_COMPLET.png




 
 
SERVO 2 CONTACTS-6.png
1 SERVO + 2 CONTACTS
+ 2 TÉMOINS LUMINEUX
+ MÉMOIRE DE POSITION
Ce programme est destiné à piloter un servomoteur pour actionner un aiguillage .
  • les mouvements du servo sont déclenchés grâce à 2 contacts fugitifs ;
  • 2 LED-témoins indiquent que le servo a atteint l'une ou l'autre position finale ;
  • le programme peut être étendu à 4 servomoteurs.

Qu'y a-t-il de différent avec le programme précédent ?

Pas grand chose.

On veut qu'un témoin s'allume à la fin de chaque cycle de déplacement des lames d'aiguillage, différent pour chaque fin de course.

 
CABLAGE
SERVO 2 CONTACTS-6.png
On ajoute 2 LED avec leurs résistances (environ 330 Ω).

Elles seront commandées par les sorties «4» et «5».








 
LES MODIFICATIONS
On ajoute 2 LED avec leurs résistances (environ 330 Ω).

Elles seront commandées par les sorties «4» et «5».
  • la LED sur la sortie «4» indiquera que l'aiguillage est arrivé à sa position «déviée à droite» ;
  • la LED sur la sortie «5» indiquera que l'aiguillage est arrivé à sa position «déviée à gauche» ;

Les instructions pour commander ces LED seront ajoutées dans les fonctions personnelle :
  • «Position_de_depart» ;
  • «Aiguille_deviee_a_droite» ;
  • «Aiguille_deviee_a_gauche».
SERVO 2 CONTACTS-9A.png
SERVO 2 CONTACTS-9B.png
SERVO 2 CONTACTS-9C.png


Note :

À la place des LED, on peut connecter des relais.

On disposes ainsi de 2 relais, c'est à dire de 2 jeux de contacts «2RT».


On peut ainsi commuter le cœur de l'aiguillage ou commander un signal...



 
... ET SI ON VEUT LES LED ET UN RELAIS ?
SERVO 2 CONTACTS-10C.png
SERVO 2 CONTACTS-10B.png
Le relais est connecté sur la sortie «2» (par exemple).

Dans «Position-de-depart» le relais est coupé tout de suite au début de la séquence.

Dans «Aiguille_deviee_a_droite» et dans «Aiguille_deviee_a_gauche», on attend la fin de la séquence pour commuter le relais.

Le programme principal n'a pas été modifié.
Seules les actions ont été retouchées.
 
SERVO 2 CONTACTS-10A.png
Ah ! Vous voulez commuter le relais
«en cours de cycle» !
Saperlipopette ! Et puis quoi encore ?
Tournesol-2.jpg
Bon. Allons-y.

On peut avoir une très bonne raison pour que la commutation du relais se fasse à mi-course.

Le problème se complique un peu, mais pas tant que cela.

Au lieu d'avoir une seule boucle qui réalise le déplacement complet du servomoteur, il suffit d'en avoir deux :
– une qui réalise la première moitié du cycle ;
– une autre qui termine le cycle.
– entre les deux on insère la commutation du relais.
 
Voici ce que cela donnerait sur une des fonctions personnelles précédentes :
 
SERVO 2 CONTACTS-10B.png
SERVO 2 CONTACTS-10D.png
Au lieu de ceci...









... on aurait cela.

 
 
Feux de carrefour : comment utiliser les fonctions personnelles
  • La mise au point d'un petit programme pour commander les feux de carrefour est le prétexte  pour apprendre à créer des fonctions personnelles.
  • Ces fonctions personnelles sont parfois appelées «sous-programmes».

    Dans ARDUINO (Blockly ou ligne de code), elles sont tout simplement appelées «fonctions».
CYCLE D'ALLUMAGE DES FEUX
FEUX_de_CARREFOUR_1.png
6 phases ; 2x3 LED ⇒ 6 sorties


 
PREMIÈRE VERSION
FEUX_de_CARREFOUR_2.png
FEUX_de_CARREFOUR_2b.png
 
À gauche : le programme complet. À droite : le détail du début.
Bof !
 
Peut-on appeler cela «un programme» ?
 
C'est plutôt une liste de commissions : pain, beurre, chocolat...
 
Il fonctionne parfaitement bien, mais il est illisible.
 
En effet, aucune indication ne permet de savoir quelle LED est connectée sur quelle sortie.
 


 
DEUXIÈME VERSION
(Première fonction personnelle)

 
On obtiendrait des programmes bien plus élégants avec les fonctionnalités de CocoBLOCKLY ou de BLOCKLY@RDUINO.
Cependant ARDUBLOCKLY, malgré des capacités plus limitées que ses proches cousins, permet d'améliorer grandement le sketch de départ.
 
Dans cette deuxième version, on a une vraie vision de l'organisation des LED :