Autres articles / Other articles

Clignotement d'une LED par timer

publication: 2 juillet 2022 / mis à jour 5 juillet 2022

Read this page in english

 

Appel à collaboration

Vous développez des montages, simples ou complexes avec ESP32 et ESP32forth.

Partagez-les ici sur ce site.

ESP32forth ne pourra se développer qu'avec la collaboration active de toutes les bonnes volontés.

Vos montages peuvent aider d'autres développeurs.

Les montages des autres développeurs peuvent vous aider.

Pour proposer un article ou un montage, cliquez ici


Débuter en programmation FORTH

Tout débutant en programmation connait très bien cet exemple plus que classique: le clignotement d'une LED. Voici le code source, en langage C pour ESP32:

/*
 * This ESP32 code is created by esp32io.com
 * This ESP32 code is released in the public domain
 * For more detail (instruction and wiring diagram), 
 *  visit https://esp32io.com/tutorials/esp32-led-blink
 */
 
// the code in setup function runs only one time when ESP32 starts
void setup() {
  // initialize digital pin GIOP18 as an output.
  pinMode(18, OUTPUT);
}
 
// the code in loop function is executed repeatedly infinitely
void loop() {
  digitalWrite(18, HIGH); // turn the LED on
  delay(500);             // wait for 500 milliseconds
  digitalWrite(18, LOW);  // turn the LED off
  delay(500);             // wait for 500 milliseconds
}

En langage FORTH, ce n'est guère différent:

18 constant myLED 
 
: led.blink ( -- ) 
    myLED output pinMode 
    begin 
        HIGH myLED pin  
        500 ms 
        LOW myLED  pin 
        500 ms 
    key? until 
  ;

Si vous compilez ce code FORTH avec ESP32forth installé sur votre carte ESP32 et que vous tapez led.blink depuis le terminal, la LED connectée au port GPIO18 va clignoter.

Au passage, on notera que pour injecter un code écrit en langage C, il faudra le compiler sur le PC, puis le téléverser sur la carte ESP32, opérations qui prennent un certain temps.

Alors qu'avec le langage FORTH, le compilateur est déjà opérationnel sur notre carte ESP32. Le compilateur va compiler le programme écrit en langage FORTH en deux à trois secondes et permettre son exécution immédiate en tapant simplement le mot contenant ce code, ici led.blink pour notre exemple.

En langage FORTH, on peut compiler des centaines de mots et les tester immédiatement, tous de manière individuelle, ce que ne permet pas du tout le langage C.

Pour expliquer ce qui est dit dans cet encadré, on va simplement factoriser notre code FORTH comme ceci:

18 constant myLED 
 
: led.on ( -- )       
    HIGH myLED pin 
  ; 
         
: led.off ( -- )       
    LOW myLED pin 
  ; 
         
: waiting ( -- ) 
    500 ms 
  ; 
         
: led.blink ( -- ) 
    myLED output pinMode 
    begin 
        led.on      waiting 
        led.off     waiting 
    key? until 
  ;

Depuis le terminal, on peut simplement allumer la LED en tapant led.on et l'éteindre en tapant led.off. L'exécution de led.blink reste possible.

En FORTH, chaque mot est l'équivalent d'une fonction en langage C.

Un mot FORTH peut être exécuté seul ou intégré à un nouveau mot. C'est le cas de led.on et led.off qui sont intégrés à led.blink.

La factorisation a pour but de découper une fonction complexe et peu lisible en un ensemble de fonctions plus simples et lisibles. Avec FORTH, la factorisation est conseillée, d'une part pour permettre une mise au point plus facile, d'autre part pour permettre la réutilisation des mots factorisés.

Ces explications peuvent paraitre triviales pour ceux qui connaissent et maitrisent le langage FORTH. C'est loin d'être évident pour les personnes programmant en langage C, obligés de regrouper les appels de fonctions dans la fonction générale loop().

Avec FORTH, on peut s'amuser à définir des mots en ne se limitant pas aux seuls caractères alphabétiques:

18 constant =O  \ myLED 
 
: =O_/ ( -- )   \ led.high  
    HIGH =O pin 
  ; 
         
: =0\_ ( -- )   \ led.low     
    LOW =O pin 
  ; 
         
: ... ( -- )    \ waiting 
    500 ms 
  ; 
         
: =O_/\_ ( -- ) 
    =O output pinMode 
    begin 
        =O_/   ... 
        =O\_   ... 
    key? until 
  ;

On peut tester le clignotement de la LED en exécutant =O_/\_

Maintenant que ceci est expliqué, on va tout oublier!

Parce que...

On va oublier tout ce qui a été expliqué précédemment. Parce que cet exemple de clignotement de LED a un énorme inconvénient. Notre programme ne fait que ça et rien d'autre. En clair, c'est un vrai gâchis matériel et logiciel de faire clignoter une LED à notre carte ESP32. Nous allons voir une manière très différente de produire ce clignotement, en langage FORTH exclusivement.

ESP32forth dispose deux mots qui vont être très utiles pour gérer ce clignotement de LED: interval et rerun.

Mais avant d'aborder le fonctionnement de ces deux mots, intéressons-nous à la notion d'interruption...

Les interruptions matérielles et logicielles

Si vous pensez gérer des micro-contrôleurs sans vous intéresser aux interruptions matérielles ou logicielles, alors abandonnez le développement informatique pour les cartes!

Vous avez le droit de débuter et ne pas connaître les interruptions. Et on va vous expliquer les interruptions et la manière d'utiliser les interruptions par timers dans le cadre de cet article.

On va vous expliquer, par un exemple pas du tout informatique de ce qu'est une interruption:

Dans ce scénario, vous passez en fait votre temps à descendre, regarder, remongter. En fait, vous n'avez quasiment plus le temps de faire autre chose...

Voici ce qui se passe en réalité:

Un micro-contrôleur, ce qui inclue la carte ESP32, dispose de deux types d'interruptions:

C'est le cas des interruption par timer, que nous allons définir comme interruptions logicielles.

Utiliser les mots interval et rerun

Le mot interval ( xt usec t ) est défini dans le vocabulaire timers.

Il accepte trois paramètres:

Reprenons partiellement le code factorisé de notre clignotement LED:

18 constant myLED 
 
0 value LED_STATE         
 
: led.on ( -- )       
    HIGH  dup myLED pin 
    to LED_STATE 
  ; 
         
: led.off ( -- )       
    LOW  dup myLED pin 
    to LED_STATE 
  ; 
      
timers  \ select timers vocabulary 
: led.toggle ( -- ) 
    LED_STATE if 
        led.off 
    else 
        led.on 
    then 
    0 rerun 
  ; 
 
' led.toggle 500000 0 interval 
 
: led.blink 
    myLED output pinMode 
    led.toggle 
  ;

Le mot rerun est précédé du numéro de timer activé avant la définition de interval. Le mot rerun doit être utilisé dans la définition du mot exécuté par le timer.

Le mot led.blink initialise la sortie GPIO utilisée par la LED. Puis exécute led.toggle.

Dans cette séquence FORTH dans cette séquence FORTH: ' led.toggle 500000 0 interval, on initialise le timer 0 en récupérant le code d'exécution du mot utilisant rerun, suivi de l'intervalle de temps, ici 500 millisecondes, puis le numéro du timer à déclencher.

Le clignotement de la LED démarre immédiatement après exécution du mot led.blink.

L'interpréteur FORTh de ESP32forth reste accessible pendant le clignotement de la LED, chose impossible en langage C!

Legal: site web personnel sans commerce / personal site without seling