On veut calculer la moyenne des valeurs dans une table. On fait la somme et on divise.
En faisant la somme, il ne faut pas qu’il y ait dépassement de capacité. En divisant, il faut se souvenir que c’est une opération longue, sauf si on divise par 2,4,8,16,. . .
Dans le programme 3.31, on voit comment initialiser une table. Il n’est pas nécessaire de dire la taille; le compilateur peut la calculer (pratique pour des grandes tables).
Modifiez des valeurs, le nombre d’éléments.

On pourrait additionner combien d’éléments avant dépassement et erreur du résultat?

//A331.ino Moyenne
void setup() {
  Serial.begin(9600);
}
byte table [] = {23,43,66,51,11,24,92,7,33,15};
longTable = sizeof (table);
unsigned int total = 0;
unsigned int moyenne;
void loop () {
  for (int i=0; i<longTable; i++) {
    total += table [i] ;
  }
  moyenne = total/longTable ;
  if (total%longTable) >= longTable/2) { moyenne++}
  Serial.print (moyenne);
  while (1) {}
}
(Le programme sur le zip est plus bavard)

Dans une table similaire, on veut connaître le minimum et sa position (son index dans la table).

On part d’une valeur minimum la plus grande possible, selon le type. Si la première valeur est plus petite, on substitue et mémorise l’index.

Modifier ce programme pour afficher le maximum et son index.

//A332.ino Minimum et sa position
void setup() {
  Serial.begin(9600);
}
byte table [] = {23,43,66,51,11,24,92,7,33,15};
int longTable = sizeof (table);
byte minimum = 255;
byte indexMinimum ;
void loop() {
  for (byte i = 0; i<longTable); i++) {
    if (minimum > table [i]) {
      minimum = table [i];
      indexMinimum = i;
    }
  }
}

La carte Arduino/Diduino a un processeur AVR Atmega328 avec son quartz 16 MHz et son interface USB. Le processeur a trois ports:B,C,D, accédés comme des variables 8 bits.

Dans chaque port, les bits sont numérotés de 0 à 7, 0 à 5 pour les ports B et C, qui sont incomplets.

Arduino a numéroté ces pins de 0 à 19.

Le LCbot est câblé sur le port D. Sur ce port, les numéros de pins et de bit sont identiques.

Le PORTD mémorise l’information que l’on veut écrire sur un pin. Mais cette information ne vas pas nécessairement passer sur la pin.

La fonction Arduino digitalWrite() écrit dans le PORTD, mais pour que l’information passe sur la pin, il faut avoir fermé l’interrupteur en écrivant un “1” dans le registre de direction DDRD (Data Direction Register D).

La fonction Arduino pinMode() agit sur ce registre DDRD.

Pour lire une pin, on passe par le registre PIND, qui lit toutes les pins. La fonction Arduino digitalRead () lit la pin indiquée.

Donc pour allumer la Led de la pin 4 il faut mettre un 1 dans les bascules correspondantes des PORTD et DDRD. La lecture sur PIND doit relire un "1". Si on relit un "0", il y a court-circuit (cc)!

Pour lire la pin2 il faut mettre un 0 dans DDRD. Que se passe-il si on met un “1” ?

On veut vérifier qu’il n’y a pas de cc sur la sortie qui commande la led L1.
On écrit “1” – on doit relire “1”
On écrit “0” – doit relire “0”
Si c’est mauvais on allume la led13

Compléter l’exemple pour afficher sur le terminal ce que l’on écrit et ce que l’on relit.

Pour tester, il est permis d’utiliser un fil et de faire court-circuit avec le Gnd/0V ou le 5V pendant une seconde au plus.

//A341.ino Test court-circuit
#define Led13On digitalWrite (13,1)
#define L1 4
#define L1On digitalWrite (L1,1)
#define L1Off digitalWrite (L1,0)
#define L1Etat digitalRead(L1)
void setup() {
  pinMode (13,1); // Led13 sortie
  pinMode (L1,1); // sortie
  L1On;
  if (L1Etat != 1) { Led13On; }
  L1Off;
  if (L1Etat != 0) { Led13On; }
}
void loop () {
  L1On;
  if (L1Etat != 1) { Led13On; }
  L1Off;
  if (L1Etat != 0) { Led13On; }
  delay (100);
}

Clignoter les 4 leds est facile et garanti la simultanéité.

Modifier ce programme pour faire clignoter alternativement les Leds vertes et rouge.

//A342.ino Clignote les 4 leds
void setup() {
  DDRD = 0b11110000; // bits 7..4 en sortie
}
void loop () {
  PORTD = 0b11110000; delay (500);
  PORTD = 0b00000000; delay (500);
}

On a vu que pour inverser une pin, il faut écrire digitalWrite (pin,!digitalRead(pin).

La figure montre ce que fait le processeur: lire, inverser, écrire.

Si on veut inverser tout le port, on code PORTD = ~PIND;

On verra plus loin comment agir sur une seule pin.

On remarque la différence de notation entre l’inversion booleenne, signe !, et l’inversion bit à bit, complément d’un mot binaire (variable ou constante) qui utilise le signe ~. Ne pas confondre !

Not !

Le résultat a la valeur inverse de l’entrée.

And &&

Le résultat vaut 1 si les deux entrées sont à 1

Or ||

Le résultat vaut 1 si l’une des deux entrées est à 1

Xor (^^ pas dispo)

Le résultat vaut 1 si les deux entrées sont différentes

L’exemple A292.ino compte et décompte. On veut que la Led1 s’allume seulement si on pèse sur P2 quand on se bloque à zéro.

Le programme ci-contre est faux! L’idée est juste, mais on s’est bloqué dans le précédent if avec le while (PousOn). Vérifiez ce qui se passe.

C’est dans cette attente qu’il faut intervenir.

A vous de corriger et tester le programme

//A351.ino P1 compte, P2 décompte saturé
. . . définitions et set-up
short int compteur;
void loop () { (ce programme doit être corrigé)
  if (Pous1On) {
    delay (10); compteur++;
    if (compteur > 5) {
      compteur--;
    }
    Serial.println (compteur);
    while (Pous1On) {delay (10); }
  }
  if (Pous2On) {
    delay (10); compteur--;
    Serial.println (compteur);
    while (Pous2On) { delay (10); }
  }
  if (Pous2On && (compteur==0)) {
    Led1On;
  }
  else {
    Led1Off
  }
}

On veut faire le Xor de deux mots de 8 bits sans utiliser le Xor. L’opération c’est pour chaque bit l’un ou l’autre, pas les deux. Exemple en 4 bits:

1100 1100
1001 1001
OR 1101 AND 1000

Le AND du 1er résultat avec l’inverse du 2e donne

1101
0111
AND 0101

Modifier le programme pour ne pas utiliser la variable xor, puis ne pas utiliser la variable and, puis aucune variables (cela fait plusieurs parenthèses imbriquées!).

//A361.ino Xor sans Xor
. . . définitions et set-up
#define Mot1 0b10100101
#define Mot2 0b11110000

byte vAnd,vOr,vXor;

void loop () {
Serial.println (Mot1,BIN);
Serial.println (Mot2,BIN);
vOr = Mot1 | Mot2;
vAnd = Mot1 & Mot2;
vXor = vOr & ~vAnd;
Serial.println (vXor,BIN);
for (;;);
}

! serial.Print enlève les zéros non significatifs

a = 0b10110101

a>>3 = 0b00011010

a = 0b10110101

a<<4 = 0b01010000

a = 0b10110101

a>>1 = 0b01101010

a = 0b10110101

a>>10 = 0b00000000

Ce programme décale à droite de 4, puis à gauche de 4. Quel est le résultat?

Ecrire le programme plus simplement avec une seule opération logique.

//A371.ino Décalages
void setup () {
Serial.begin (9600);
}
#define Mot 0b10100101
byte var = Mot;
void loop () {
Serial.println (var,BIN);
var >>= 4; // idem à var = var>>4;
var <<= 4;
Serial.println (var,BIN);
while {};
}

On veut allumer les Leds L1 .. L2 dans l’ordres en agissant directement sur le PORTD, sans faire une boucle for avec réinitialisation tous les 4 décalages.

Ici, la boucle test après chaque décalage si la partie Leds du PORTD est vide, et effectue la réinitialisation.

Ecrire PORTD = etatLed; fonctionne ici,

mais cela forcerait les 4 bits de poids faibles à zéro sans se préoccuper si cela a une conséquence sur ces pins.

La nécessité de ces deux instructions de masquage est bien expliquée dans .www.didel.com/C/OperationsLogiques.pdf

//A372.ino Chenillard L1 .. L4

void setup () {
DDRD = 0b11110000;
}
#define MaskLeds 0b11110000
#define EtatInitial 0b00010000 //L1 allumé
byte etatLeds = EtatInitial;
void loop () {
delay (500);
PORTD |= (etatLeds&MaskLeds); // force les "1"
PORTD &= (etatLeds&~MaskLeds); // force les "0"
etatLeds <<= 1; // décale à droite de 1 position
if ((etatLeds & MaskLeds) == 0) {
etatLeds = EtatInitial ;
}
}

Comprenons avec des nombres de 4 bits, qui peuvent représenter des nombres de 0 à 15, 0 à 0xF en hexadécimal.

Décaler à gauche multiplie par 2, mais il y a rapidement dépassement de capacité puis résultat nul.

Décaler à droite divise par 2, mais il y a rapidement un résultat nul

La compréhension est plus délicate pour les nombres signés, lorsqu’ils sont négatifs.

Le bit de poids fort (MSB Most Significant Bit) est le bit de signe, toujours 0 si le nombre est positif, 1 si négatif..

Avec 4 bits, on peut représenter des nombres signés de –8 à +7.

Décaler à gauche multiplie par 2, mais pour les nombres négatifs, il y a extension du signe.

Décaler à droite divise par 2, pour les nombres négatifs, il y a conservation du signe.

Reprenons l’exemple simple qui copie P1 sur L1, mais en utilisant des définitions C.

On remarque la notation bP1 pour nommer le bit 2 dans le PORTD. On avait nommé P1 la pin Arduino, qui “par hasard” a le même no.

Ajouter les définitions pour P2 et utiliser P1 pour allumer, P2 pour éteindre.

Recharger le programme A223.ino qui fait la même chose et comparer les tailles mémoire.

//A391.ino Copie P1 sur L1 478 octets
#define bP1 2
#define bL1 4
#define Pous1On PIND & (1<<bP1)
#define Led1On PORTD |= (1<<bL1)
#define Led1Off PORTD &= ~(1<<bL1)
void setup () {
DDRD |= (1<<bL1) ; // led en sortie
}
void loop () {
if (Pous1On) { Led1On; }
else { Led1Off; }
}

La variable prevPous mémorise l’état des 2 poussoirs. Un masque ne garde que les 2 bits qui nous intéresse. Il faut initialiser prevPous dans le setup, autrement le premier passage dans le programme pourrait signaler un changement.

Il faut immédiatement copier le nouvel l’état dans l’ancien, mais il faut aussi les comparer avant mise à jour. Cela oblige à créer une variable pour ne pas relire deux fois l’état des poussoirs, qui peut changer chaque microseconde.

S’il y a changement, on clignote une autre led en modifiant le masque qui sélectionne la led – admirez l’élégance de la solution !

.Au démarrage, clignotez L1 et L4.

//A3111.ino Surveille 2 poussoirs
#define bP1 2 // bit 2 sur PORTD
#define bP2 3
#define MaskPous ((1<<bP1) | (1<<bP2))
. . . #define bL1 bL2 bL3 bL4 (pas la place!)
byte maskLedOn =(1<<bL1); // masque initial, on le changera
void setup () {
DDRD = (1<<bL1)|(1<<bL2)|(1<<bL1)|(1<<bL2);
prevPous = PIND & MaskPous;
}
byte nowPous, prevPous, diffPous; // variables globales
byte cntCli=10; //demi-periode clignotement 10x20ms
void loop () {
delay (20);
if (cntCli-- == 0) {
cntCli=10;
PORTD ^= maskLedOn; // inverse les leds sélectionnées
}
nowPous = PIND & MaskPous;
diffPous = nowPous ^ prevPous ; // bits différents?
prevPous = nowPous; //mise à jour pour le prochain cycle
if (diffPous != 0) { // si différence
if (diffPous & (1<<bP1)) {
maskLedOn =(1<<bL2);
}
if (diffPous & (1<<bP2)) {
maskLedOn = (1<<bL3);
}
PORTD = 0; // pourquoi?
}
}

//LCArduiDef.h LearnCbot definitions *Arduino*
#include <*Arduino*.h>
#define Led13 13
#define Led13On digitalWrite (Led13,1)
#define Led13Off digitalWrite (Led13,0)
#define Led13Toggle digitalWrite (Led13, !digitalRead(Led13))
#define HP 1
#define HPOn digitalWrite (HP,1)
#define HPOff digitalWrite (HP,0)
#define HPToggle digitalWrite (HP,!digitalRead(HP))
#define L1 4
#define L2 5
#define L3 6
#define L4 7
#define Led1On digitalWrite (L1,1)
#define Led1Off digitalWrite (L1,0)
#define Led1Toggle digitalWrite (L1,!digitalRead(L1))
#define Led2On digitalWrite (L2,1)
#define Led2Off digitalWrite (L2,0)
#define Led2Toggle digitalWrite (L2,!digitalRead(L2))
#define Led3On digitalWrite (L3,1)
#define Led3Off digitalWrite (L3,0)
#define Led3Toggle digitalWrite (L3,!digitalRead(L3))
#define Led4On digitalWrite (L4,1)
#define Led4Off digitalWrite (L4,0)
#define Led4Toggle digitalWrite (L4,!digitalRead(L4))
#define P1 2
#define P2 3
#define Pous1On (!digitalRead(P1))
#define Pous2On (!digitalRead(P2))

void LcSetup () {
pinMode (1,1); pinMode (2,0); pinMode (3,0);
pinMode (4,1); pinMode (5,1);
pinMode (6,1); pinMode (7,1);
}

//LCDef.h LearnCbot definitions C
#include <*Arduino*.h>
#define bLed13 5 // bit 5 PORTB (pin 13)
#define Led13On bitSet (PORTB,bLed)
#define Led13Off bitClear (PORTB,bLed)
#define Led13Toggle PORTB ^= 1<<bLed
#define bHP 1 // PORTD
#define HPOn bitSet (PORTD,bL1)
#define HPOff bitSet (PORTD,bL1)
#define HPToggle PORTD ^= 1<<bL1
#define bL1 4 // PORTD actifs à 1
#define bL2 5
#define bL3 6
#define bL4 7
#define Led1On bitSet (PORTD,bL1)
#define Led1Off bitClear (PORTD,bL1)
#define Led1Toggle PORTD ^= 1<<bL1
#define Led2On bitSet (PORTD,bL2)
#define Led2Off bitClear (PORTD,bL2)
#define Led2Toggle PORTD ^= 1<<bL2
#define Led3On bitSet (PORTD,bL3)
#define Led3Off bitClear (PORTD,bL3)
#define Led3Toggle PORTD ^= 1<<bL3
#define Led4On bitSet (PORTD,bL4)
#define Led4Off bitClear (PORTD,bL4)
#define Led4Toggle PORTD ^= 1<<bL4
#define bP1 2 // PORTD
#define bP2 3
#define Pous1On (!digitalRead(bP2))
#define Pous2On (!digitalRead(bP2))

void LcSetup () {
DDRD |= 0b11110010; //HP L1 L2 L3 L4 out
}