MTsoftPWM: Exemple 1

Ce programme va faire clignoter LED_BUILTIN avec des flashs

On va utiliser le PWM soft pour faire une succession de 5 flashs et s'arrêter. Un métronome va régulièrement relancer le PWM. C'est le PWM qui fera donc les flashs et le métronome qu donnera globalement le clignotement.

Le PWM

Cet objet va, quand on l'active, va faire 5 flashs (0,05s allumé, 0,05s éteint). Nous allons prendre un objet MTsoftPWM. Le signal va sortir sur la broche LED_BUILTIN (13):

MTsoftPWM CinqFlash(LED_BUILTIN, ...

Cela va créer un objet (en gros une variable) de type MTsoftPWM qui fera nos 5 flashs.

Si l'on veut un cycle allumé pendant 0,05s et éteint pendant 0,05s en prenant un MTsoftPWM, il faut donner le temps de l'impulsion (état HIGH ou led allumée) et la période. Le temps à HIGH est de 0,05s et doit être exprimée en microsecondes. On peut écrire:

MTsoftPWM CinqFlash(... 50000, ...

Mais pour documenter le code et pour rajouter des commentaires, nous allons donc écrire:

MTsoftPWM CinqFlash(... impulsions_de 50000 micro_secondes, ...

Ainsi, nous saurons d'une part que c'est le temps de l'impulsion, et d'autre part que le temps est exprimé en microsecondes. Les mots impulsions_de et micro_secondes sont des mots commentaires ignorés par le compilateur. On reconnaît ces mots à la présence d'un caractère "_" au milieu de plein de lettres minuscules sans avoir ce caractère en début.

De même pour donner la période, on préférera l'écriture:

MTsoftPWM CinqFlash(... periodes_de 100000 micro_secondes, ...

Si nous voulons 5 flashs, il faut demander 10 niveaux puis un arrêt:

Et il faut que l'on commence par le niveau HIGH. Notez que ce qui se passe avant ne nous intéresse pas. Au démarrage du PWM le niveau ne dépend que du départ que l'on indique (ici HIGH). Ces 10 niveaux et ce départ à HIGH se demandent par:

MTsoftPWM CinqFlash(..., on_commence_par HIGH, 10 niveaux_et_arret, ...

Deux paramètres facultatifs peuvent suivre, tout d'abord le nom d'une fonction qui sera appelée quand le train d'impulsion sera terminé. Par défaut on n'appelle rien, ce qui nous convient ici. A la fin de impulsions, on ne fait qu'attendre un nouveau déclenchement.

Le deuxième paramètre facultatifs est l'état du PWM, en marche (par défaut) ou en arrêt à l'initialisation. Ici ce choix ne se verrait pas trop car les flashs vont recommencer à intervalles réguliers. Toutefois si on veut qu'à l’initialisation le clignotement démarre tout de suite, il faut que le PWM soit en marche (MT_ON). Comme ce paramètre prend cette valeur par défaut, on peut ne pas le préciser.

La définition complète de notre PWM est donc:

MTsoftPWM CinqFlash(LED_BUILTIN, impulsions_de 50000 micro_secondes, periodes_de 100000 micro_secondes, on_commence_par HIGH, 10 niveaux_et_arret);

Il faut comme dans tous les programmes qui utilisent MTobjets, inclure la bibliothèque utile. Ici on utilise comme seul objet un PWM (le nom de l'objet est MTsoftPWM):

#include "MTsoftPWM.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects

Je conseille fortement de laisser le commentaire, si une autre personne voulait essayer le programme, elle aurait directement un lien de téléchargement. C'est valable pour toutes les bibliothèques que vous utilisez.

Le clignotement global

On va utiliser un métronome qui va mettre en marche le clignotement.

Voici comment on peut définir une fonction qui met en marche ce PWM:

void flash(void)
{
  CinqFlash.start();
}

Un métronome va donc appeler régulièrement cette fonctions. On n'a qu'une action (démarrer le PWM), on choisira un métronome simple.

MTclock Metronome( ...

Cela va créer un objet (en gros une variable) de type MTclock.

La temps du clignotement est imposé à 0,5s par le PWM (10 niveaux soit 5 impulsions de 0,1s) Si on veut une répétition toutes les deux secondes, on choisira une période de 2s:

MTclock Metronome(500 milli_secondes, ... , arret, ...

Les temps étant exprimés obligatoirement en millisecondes, on a donc le nombre 500. Le milli_secondes est un mot commentaire ignoré par le compilateur.

Et pour la deuxième action, ce sera au bout de 1000ms. La définition complète de notre métronome est donc:

MTclock Metronome(2000 milli_secondes, flash);

Il faut comme dans tous les programmes qui utilisent MTobjets, inclure la bibliothèque utile. Ici on utilise comme seul objet un métronome (le nom de l'objet est MTclock):

#include "MTclock.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects

setup() et loop()

Il n'y a rien à faire de plus, setup() et loop() ne nous servent à rien. Il vont rester vide. Mais vous pouvez y mettre un autre programme, celui que nous avons fait est indépendant. Donc:

void setup(){}

void loop(){}

J'ai tout mis sur la même ligne mais vous pouvez en prendre deux ou trois. Même si les fonctions sont vides et ne nous servent à rien apparemment, il faut les définir. En fait, loop() va servir de boucle d'attente car notre programme ne fait pus rien après initialisation.

Programme complet

Voici donc le programme complet:

// Ce programme fait clignoter une led avec des flashs.

#include "MTclock.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
#include "MTsoftPWM.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects

MTsoftPWM CinqFlash(LED_BUILTIN, impulsions_de 50000 micro_secondes, periodes_de 100000 micro_secondes, on_commence_par HIGH, 10 niveaux_et_arret);


void flash(void)
{
  CinqFlash.start();
}

MTclock Metronome(2000 milli_secondes, flash);


void setup(){}

void loop(){}