Pour calculer la somme des nombres de la table précédente, il faut deux boucles for.

On remarque que compactifier le tableau 2D sur une ligne n’est pas une bonne idée.

//A511 Tableau 2D
void setup() {
  Serial.begin(9600);
}
int table [3][2] = {{1,2},{10,20},{100,200}};
int result =0;
void loop () {
  for (byte i=0; i<3; i++) {
    for (byte j=0; j<2; j++) {
      result += table [i][j];
    }
  }
  Serial.println(result);
  while (1) {}
}

Comme pour les variables, le prefix const dit au compilateur de mettre les valeurs dans les instructions qui utilisent ces valeurs. Il n’y a pas de place perdue en mémoire.

La table pour un dé électronique par exemple dépend du câblage. Son écriture est facile et les erreurs faciles à corriger.

Pour initialiser nos 4 leds et la led 13, formons un tableau avec leurs numéros.

Une boucle for balance ces numéros dans des pinMode qui interprètent les constantes comme des numéros de pins.

Exécuter 10000 fois ces instructions avec un ToggleLed toutes les 10000 fois. Estimez le temps d’exécution.

//A521 Initialisation à la Arduino
byte pinsOut [] = {4,5,6,7,13};
void setup () {
  for (byte i=0; i<sizeof(pinsOut); i++) {
    pinMode (pinsOut [i],1);
  }
}
void loop () {
}

Il faut déclarer un tableau tampon de longueur LongTampon et deux pointeur indexIn indexOut.

La fonction PutData() écrit et incrémente circulairement le pointeur. La fonction GetData() lit s’il y a quelque chose à lire. Deux flags Available et Overflow dépendent de la distance des pointeurs, qui sont des bytes utilisés en booléens (0 faux, 1 vrai).

On peut écrire si Overflow ==0;

On peut lire si Available ==1;

Choisissons un exemple simple pour comprendre la synchronisation entre deux tâches asynchrones.

On presse irregulièrement sur un poussoir.

Chaque pression doit générer un clignotement de 1 seconde (500 ms allumé, 500 ms éteint).

Une solution est de faire communiquer les 2 tâches non bloquantes par une variable globale cnt.

Chaque pression augmente le compteur. Chaque clignotement complet décompte.

La fonction PousEdge() est dérivée de ce qui a été vu en 4.64. flagPous est remplacé par le compteur qui joue le même rôle.

Le clignotement non bloquant a été vu en 4.61.

C’est un peu plus compliqué ici parce qu’il faut maintenant voir 3 états : allumé 0.5 s, éteint 0.5 s, terminé. Un switch-case résout le problème.

On voudrait envoyer cnt sur le terminal. Où faut-il le faire ? Cela prend 5 ms, acceptable.

//A531 Cligote asynchrone
#include "LcDef.h"
void setup() {
  LcSetup ();
}
int cnt=0 ; // variable globale
void Pous1Edge () {
  volatile byte prevPous1;
  if (Pous1On && (prevPous1==0)) {
  cnt++;
  Led1Toggle;
}
prevPous1=Pous1On;
}
#define DurOn 1000/20
#define DurOff 1000/20

void CliLed2 () { // appelé toutes les 20ms 25+25 cycles
  byte etat;
  switch (etat) {
    static byte cntLed2; {
    case 0:
      Led2On;
      if (cntLed2++ > DurOn) {
        cntLed2 = 0;
        etat = 1;
      }
      break;
    case 1:
      Led2Off;
      if (cntLed2++ > DurOff) {
        cntLed2 = 0;
        etat = 2;
      }
      break;
    case 2:
      cnt--;
      etat = 2; break;
    }
  }
void loop () {
  delay (20);
  Pous1Edge ();
  if (cnt>0) {
    CliLed2();
  }
}

On a vu (3.31) comment moyenner les valeurs d’un capteur. La fréquence des mesures utilisables est divisée pas le nombre d’échantillons intervenant dans la moyenne.

La moyenne glissante se calcule à chaque mesure. A l’initialisation, on fait comme si les dernières mesures étaient identiques à la première mesure.

A défaut de capteur, introduisons des valeurs au terminal (voir 4.51) et affichons la moyenne glissante. Sans initialisation, on voit que les 3 premières moyennes sont fausses.

Compléter le setup pour que la première moyenne soit égale à la première valeur entrée. On voit que les variables concernées ont déjà été déclarées avant le setup.

Comment faire pour que cette initialisation soit faites dans la fonction ?

Indication : ajouter un flag qui est à zéro au premier appel de GetMoyGlis().

//5.42 Moyenne glissante
#include "LcDef.h"

int taGlis [4];
byte iTag; // index à taGlis
void setup() {
  LcSetup ();
  Serial.begin(9600);
}

// fonction GetMoyGlis (valeur);
//Rend la moyenne des 4 valeurs précédentes
int GetMoyGlis (int vv) {
  int mm = 0;
  taGlis [iTag++] = vv; // le ++ se fait après l’écriture
  if (iTag > 3) {iTag = 0; }
  for (byte i=0; i<4; i++) {
    mm += taGlis [i];
  }
  return mm/4;
}
int valeur, moyenne;
void loop() {
  while (Serial.available() > 0) {
    valeur = Serial.parseInt();
    Serial.print(valeur); Serial.print(" ");
    moyenne = GetMoyGlis (valeur);
    Serial.println(moyenne);
  }
}

Le timer compte sans cesse. La bascule TOVF signale le dépassement de capacité (quand le compteur passe de 0xFF à 0) et permet d’étendre le comptage par logiciel. Si TOVF est à un, on ajoute 1 dans un compteur soft et on remet à zéro la bascule.

Ce timer 8 bits est piloté par 3 registres. On peut lire et écrire le compteur 8 bits TCNT2. Il avance à la fréquence définie par le contenu des 3 bits de poids faible du registre TCCR2B. (Timer Control Register timer 2). Les autres bits sont à 0 dans ce mode simple.

Le registre TIFR2 contient le flag TOV2.

Clignotons de nouveau pour changer!
Si TOV2 est actif, on toggle la Led1 et le HP.
Le compteur est réinitialisé à 16 pour que la fréquence des TOV2 soit 1 kHz.
Un post-diviseur clignote la Led2 à 1Hz.

Corriger les paramètres pour avoir comme prédiviseur TCCR2B = 0b00000100; et garder le même timing pour les Leds et le HP.

Programmer une sirène en changeant la valeur initialisant le compteur-timer à chaque cycle.

//A552 Clignote via le timer2
#include "LcDef.h"
void setup () {
  LcSetup ();
  TCCR2A = 0;
  TCCR2B = 0b00000111; // clk/1024 16kHz 62,5us
}

int cntLed;
void loop () {
  if ( TIFR2 & (1<<TOV2) ) {
    TCNT2 = -16 ; // pour 1 kHz
    bitSet (TIFR2,TOV2);
    Led1Toggle;
    HPToggle;

    if (cntLed++ > 500) { // pour période 1Hz
      cntLed = 0;
      Led2Toggle;
    }
  }
}

Pour clignoter par interruption, les instructions de l’exemple 5.52 sont reportées dans la routine d’interruption du timer. Le programme principal ne fait plus rien. S’il clignote une autre led à la vieille mode, il est ralenti de ~5 microsecondes à chaque interruption, ceci toutes les millisecondes avec ce qui a été programmé, soit 0.5 % du temps.

Que se passe-t-il si le programme principal et l’interruption clignotent la même led à la même fréquence ? Essayez.

//A571.ino Clignote par interruption timer
#include "LcDef.h"
void setup () {
  LcSetup ();
  TCCR2A = 0; //default
  TCCR2B = 0b00000111; // clk/1024
  TIMSK2 = 0b00000001; // TOIE2
  sei();
}
int cntLed;
ISR (TIMER2_OVF_vect)
{
  TCNT2 = 16; // pour 1 kHz
  if (cntLed++ > 500) {
    cntLed = 0;
    Led1Toggle;
  }
}
void loop () {
  Led2Toggle;
  delay (500);
}

Clignotons en passant par les interruptions créées par P1, à l’instant ou l’on presse, c’est à dire quand le signal sur processeur passe de 1 à 0 (le 0 est actif sur le poussoir).

Le mode est donc 3 ou FALLING.

L’interruption réagit dans la microseconde, le Toggle led aussi, donc s’il y a un nombre impair de rebonds avant le contact, il n’y aura pas de basculement. S’il y a un nombre impair de rebonds au relâchement, il y aura basculement.

//A581 Toggle par interruption P1
#include "LcDef.h"
void setup () {
  LcSetup ();
  attachInterrupt(0,CliUneFois,FALLING);
}
void CliUneFois() {
  Led1Toggle;
}
void loop () {
}

Les instructions AVR 328 pour écrire en EEPROM sont compliquées, pour diminuer la probabilité d’une écriture intempestive si le programme déraille.

Arduino propose une librairie facile à utiliser.

EEPROM.write (ad,data); a deux paramètres, l’adresse de 0 à 255 et le contenu 8 bits, aussi entre 0 et 255.

EEPROM.read (ad); rend le contenu à l’adresse donnée.

Le programme ci-contre initialise un contenu dans le setup. Commentez cette partie à la 2e exécution et coupez l’alimentation.

La boucle demande de taper l’adresse 0 1 2..9 au terminal (suivi d’un retour à la ligne). Serial.read rend le code ASCII du chiffre, il faut soustraire le code du 0 pour avoir l’adresse binaire.

Modification : afficher le contenu complet avec une boucle for.

//A5101.ino Eeprom On écrit 00 11 22 33
// en 0 1 2 3 . . . 9 et on relit en tapant l’adresse
#include "LcDef.h"
#include <EEPROM.h>

byte ad=0,data=0;
void setup () {
  LcSetup ();
  Serial.begin(9600);

  for (byte i=0; i<10; i++) {
    EEPROM.write (ad,data);
    ad++; data +=11;
  }
}

void loop () {
  if (Serial.available() > 0) {
    ad = Serial.read();
    ad -= "0"; // ou code du 0 = 48 décimal = 0x30
    data = EEPROM.read (ad);
    Serial.print(data); Serial.print(" ");
  }
}