problème avec le "switchCase"

Salut

j’aimerais utiliser la routine switchcase dans mon code arduino pour deux taches

1- contrôler la luminosité de matrice led suivant la valeur donner par une photorésistance

const int LDRpin = A0;     // the number of the LDR pin
const int sensorMin = 0;      // sensor minimum, discovered through experiment
const int sensorMax = 600;    // sensor maximum, discovered through experiment

void setup() {
pinMode(LDRpin, INPUT);
}

void loop()  {
      int sensorReading = analogRead(LDRpin); // read the sensor:
      int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
      switch (range) {
    case 0:    
      lc.setIntensity(0,2);  // Set intensity levels
      lc.setIntensity(1,2);
      lc.setIntensity(2,2);
      lc.setIntensity(3,2);
      break;
    case 1:    
      lc.setIntensity(0,6);  // Set intensity levels
      lc.setIntensity(1,6);
      lc.setIntensity(2,6);
      lc.setIntensity(3,6);
      break;
    case 2:   
      lc.setIntensity(0,12);  // Set intensity levels
      lc.setIntensity(1,12);
      lc.setIntensity(2,12);
      lc.setIntensity(3,12);
      break;
    case 3:    
      lc.setIntensity(0,16);  // Set intensity levels
      lc.setIntensity(1,16);
      lc.setIntensity(2,16);
      lc.setIntensity(3,16);
      break;}
}

2- changer le type de police au niveau de mon affichage

const int buttonPinF = 5;    
int buttonStateF = 0;
varF = 0;      

void loop {
buttonStateF = digitalRead(buttonPinF);

if (buttonStateF == HIGH) {
      if (varF == 0) {
const byte font1[10][8] = {
  
};

const byte font2[10][8] = {
  
};

const byte sp1[2][8] = {  
  
};        
varF = 1;
}
      if (varF == 1) {
const byte font1[10][8] = {
  
};

const byte font2[10][8] = {
  
};

const byte sp1[2][8] = {  
 
};


varF = 0;
      }

mais marche pas :frowning:

C’est censé faire quoi ce truc là ?

if (varF == 0) {
const byte font1[10][8] = {
  
};

J-M-L:
C’est censé faire quoi ce truc là ?

if (varF == 0) {

const byte font1[10][8] = {
 
};

je m’excuse .. c'est pour ne pas alourdir le code affiché ... normalement c'est :

if (varF == 0) {
const byte font1[10][8] = {
  {B01110000, B10011000, B10011100, B10011000, B10011000, B10011100, B10011000, B01110000}, // 0
  {B00110000, B01110000, B10110100, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001100, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
  {B11111000, B11111000, B00001100, B01110000, B00001000, B00001100, B10001000, B01110000}, // 3
  {B00001000, B00010000, B00100100, B01000000, B10010000, B11111100, B11111000, B00010000}, // 4
  {B11111000, B11111000, B10000100, B11110000, B00001000, B00001100, B10001000, B01110000}, // 5
  {B00011000, B00110000, B01100100, B11000000, B11110000, B10001100, B10001000, B01110000}, // 6
  {B11111000, B11111000, B00001100, B00001000, B00010000, B00100100, B01000000, B10000000}, // 7
  {B01110000, B10011000, B10011100, B01100000, B10011000, B10011100, B10011000, B01110000}, // 8
  {B01110000, B10001000, B10001100, B01111000, B00011000, B00110100, B01100000, B11000000}, // 9
};

const byte font2[10][8] = {
  {B01110000, B10011000, B10011000, B10011000, B10011000, B10011100, B10011000, B01110000}, // 0
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
  {B11111000, B11111000, B00001000, B01110000, B00001000, B00001100, B10001000, B01110000}, // 3
  {B00001000, B00010000, B00100000, B01000000, B10010000, B11111100, B11111000, B00010000}, // 4
  {B11111000, B11111000, B10000000, B11110000, B00001000, B00001100, B10001000, B01110000}, // 5
  {B00011000, B00110000, B01100000, B11000000, B11110000, B10001100, B10001000, B01110000}, // 6
  {B11111000, B11111000, B00001000, B00001000, B00010000, B00100100, B01000000, B10000000}, // 7
  {B01110000, B10011000, B10011000, B01100000, B10011000, B10011100, B10011000, B01110000}, // 8
  {B01110000, B10001000, B10001000, B01111000, B00011000, B00110100, B01100000, B11000000}, // 9
};

const byte sp1[2][8] = {  
  {B01000000, B10100000, B01000000, B00010000, B00101000, B00100000, B00101000, B00010000}, // °C
  {B01000000, B10101000, B01011000, B00110000, B01100000, B11010000, B10101000, B00010000}, // %
};
  
};

Pour la première partie, il doit manquer du code. Tu utilises la bibliothèque LedControl ?

https://playground.arduino.cc/Main/LedControl

As-tu bien déclaré l’instance comme dans l’exemple :

#include "LedControl.h"
// Create a LedControl for 8 devices... 
LedControl lc=LedControl(12,11,10,8); // <-- à adapter à ton cas bien sûr

Qu’est-ce qui te fait dire que ça ne marche pas ? Pour débuguer un programme, affiche tes variables dans la console, tu pourras suivre le déroulement du programme et vérifier qu’il fait ce qu’il faut au bon moment.

Et selon vous quelle est la durée de vie de ces variables déclarées dans le if ?

bon
le problème c’est que mon code est assez long, j’essai de simplifier ma présentation …

disons que mon code affiche deux chiffres (le chiffre 1 et 2) sur deux matrices leds

#include <LedControl.h>
LedControl lc=LedControl(11,12,13,2);  // Pins: DIN,CLK,CS, # of Display connected
unsigned long delayTime=100;  // Delay between Frames

const byte font[2][8] = {
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}

void setup() {
  lc.shutdown(0,false);  // Wake up displays
  lc.shutdown(1,false);
  lc.setIntensity(0,3);  // Set intensity levels
  lc.setIntensity(1,3);
  lc.clearDisplay(0);  // Clear Displays
  lc.clearDisplay(1);
}

void loop()  {
for (int i = 0; i < 8; i++)  
  {
    lc.setRow(0,i,font[0][i]);
  }
delay(delayTime);

 for (int i = 0; i < 8; i++)  
  {
    lc.setRow(1,i,font[1][i]);
  }
delay(delayTime);
}

j’aimerais ajouter a ce code une partie qui permet de contrôler le changement de fonts des chiffres affiché via un bouton

donc je branche le bouton comme suit :

et mon code deviens :

#include <LedControl.h>
LedControl lc=LedControl(11,12,13,2);  // Pins: DIN,CLK,CS, # of Display connected
unsigned long delayTime=100;  // Delay between Frames

const byte font[2][8] = {
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}

const int buttonPinF = 2;     // the number of the pushbutton pin S
int buttonStateF = 0;         // variable for reading the pushbutton status
int varF = 0;                    //temporary variable

void setup() {
  lc.shutdown(0,false);  // Wake up displays
  lc.shutdown(1,false);
  lc.setIntensity(0,3);  // Set intensity levels
  lc.setIntensity(1,3);
  lc.clearDisplay(0);  // Clear Displays
  lc.clearDisplay(1);
}

void fonts {
  switch (varF) {
    case 1:
      const byte font[2][8] = {
  {B00110000, B01110000, B10110100, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001100, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}
varF = 2;
      break;
    case 2:
      const byte font[2][8] = {
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}
varF = 1;
      break;
  }
}

void loop()  {
buttonStateF = digitalRead(buttonPinF)
 if (buttonStateF == HIGH) {
      fonts();
    }
else {
for (int i = 0; i < 8; i++)  
  {
    lc.setRow(0,i,font[0][i]);
  }
delay(delayTime);

 for (int i = 0; i < 8; i++)  
  {
    lc.setRow(1,i,font[1][i]);
  }
delay(delayTime);
}

}

c’est correct ??

Bonjour,

Comme le dit J-M-L, il faut que tu déclares tes tables de constantes en global (ou en local hors d'une condition) pour qu'elles soient accessibles à la suite du programme.

Tu dois déclarer deux tables de constantes pour chaque type de font
par exemple
const byte font1_1[10][8] = {...};
const byte font1_2[10][8] = {...};

Ensuite tu utilises un pointeur sur ces fonts:
const byte (*font1)[8];

Et suivant ta variable varF tu l'initialises avec le tableau 1 ou le tableau 2
font1=font1_1;
ou
font1=font1_2;

Ensuite tu utilises font1 pour afficher.

Même chose avec les autres fonts.

Merci kamill ... je teste et je vous informe du résultat

bon j’ai un probléme … l’affichqge n’est plus correct du tous … il affiche n’importe quoi !

donc ce que j’ai fais (via un exemple réduit)

#include <LedControl.h>
LedControl lc=LedControl(11,12,13,2);  // Pins: DIN,CLK,CS, # of Display connected
unsigned long delayTime=100;  // Delay between Frames

const byte font_1[2][8] = {
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}
const byte font_2[2][8] = {
  {B00110000, B01110000, B10110100, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001100, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}

const byte (*font)[8];

const int buttonPinF = 2;     // the number of the pushbutton pin S
int buttonStateF = 0;         // variable for reading the pushbutton status
int varF = 0;                    //temporary variable

void setup() {
  lc.shutdown(0,false);  // Wake up displays
  lc.shutdown(1,false);
  lc.setIntensity(0,3);  // Set intensity levels
  lc.setIntensity(1,3);
  lc.clearDisplay(0);  // Clear Displays
  lc.clearDisplay(1);
}

void fonts {
  switch (varF) {
    case 1:
      font=font_1;
      varF = 2;
varF = 2;
      break;
    case 2:
      font=font_2;
      varF = 1;
      break;
  }
}

void loop()  {
buttonStateF = digitalRead(buttonPinF)
 if (buttonStateF == HIGH) {
      fonts();
    }
else {
for (int i = 0; i < 8; i++)  
  {
    lc.setRow(0,i,font[0][i]);
  }
delay(delayTime);

 for (int i = 0; i < 8; i++)  
  {
    lc.setRow(1,i,font[1][i]);
  }
delay(delayTime);
}

}

:frowning:

Ben oui.
Ta variable varF vaut 0 au départ, elle ne vaudra jamais 1 ou 2
Il faut en plus que tu initialises font à font_1 dans le setup (ou dans la définition) sinon elle ne sera pas initialisée avant d'appuyer sur le bouton.

noté … re-changement

#include <LedControl.h>
LedControl lc=LedControl(11,12,13,2);  // Pins: DIN,CLK,CS, # of Display connected
unsigned long delayTime=100;  // Delay between Frames

const byte font_1[2][8] = {
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}
const byte font_2[2][8] = {
  {B00110000, B01110000, B10110100, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001100, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}

const byte (*font)[8];

const int buttonPinF = 2;     // the number of the pushbutton pin S
int buttonStateF = 0;         // variable for reading the pushbutton status
int varF = 1;                    //temporary variable


void setup() {
  lc.shutdown(0,false);  // Wake up displays
  lc.shutdown(1,false);
  lc.setIntensity(0,3);  // Set intensity levels
  lc.setIntensity(1,3);
  lc.clearDisplay(0);  // Clear Displays
  lc.clearDisplay(1);

font=font_1;
}

void fonts {
  switch (varF) {
    case 1:
      font=font_1;
      varF = 2;
varF = 2;
      break;
    case 2:
      font=font_2;
      varF = 1;
      break;
  }
}

void loop()  {
buttonStateF = digitalRead(buttonPinF)
 if (buttonStateF == HIGH) {
      fonts();
    }
else {
for (int i = 0; i < 8; i++)  
  {
    lc.setRow(0,i,font[0][i]);
  }
delay(delayTime);

 for (int i = 0; i < 8; i++)  
  {
    lc.setRow(1,i,font[1][i]);
  }
delay(delayTime);
}

}

c’est bon … mais je ne remarque pas d’effet si j’appuie sur le bouton … je vérifie si j’ai pas d’erreur

bizarre

soit tu fait une initialisation à la déclaration.
const byte (*font)[8]=font_1;

soit tu fais une affectation dynamique
font=font1;
mais elle doit être obligatoirement à l'intérieur d'une fonction (setup() en ce cas).

esloch:
c'est bon ... mais je ne remarque pas d'effet si j’appuie sur le bouton ... je vérifie si j'ai pas d'erreur
bizarre

ce n'est pas bizarre, font1 et font2 sont quasiment les mêmes (à un bit près).

ca marche après replacement de la boucle "case" par une boucle "if else if" .. enfin .. j'aurais bien aimer utiliser la boucle avec case ...

c'est bon Merci

kamill:
ce n'est pas bizarre, font1 et font2 sont quasiment les mêmes (à un bit près).

ma sélection de fonts

ça devrait aussi fonctionner de la même façon avec switch case

dans le programme que tu as donné

const byte font_1[2][8] = {
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}
const byte font_2[2][8] = {
  {B00110000, B01110000, B10110100, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001100, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2}

les deux fonts sont identiques (sauf un bit)

j’ai un autre avec la boucle case … il s’agit de contrôler la luminosité des matrices leds avec une photorésistance … la méthode est simple … mais ca ne marche pas

aller je me concentre encore une fois … c’est surement une erreur de débutant

je reviens a vous si ca ne vous dérange pas en cas de problème

marche pas cette boucle “case” avec moi :confused:

donc : je veux contrôler la luminosité des matrices leds

montage :

#include <LedControl.h>
LedControl lc=LedControl(11,12,13,2);  // Pins: DIN,CLK,CS, # of Display connected
unsigned long delayTime=100;  // Delay between Frames

const byte font_1[2][8] = {
  {B00110000, B01110000, B10110000, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001000, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}
const byte font_2[2][8] = {
  {B00110000, B01110000, B10110100, B00110000, B00110000, B00110100, B00110000, B11111000}, // 1
  {B01110000, B10001000, B00001100, B00110000, B01000000, B10000100, B11111000, B11111000}, // 2
}

const byte (*font)[8];

const int buttonPinF = 2;     // the number of the pushbutton pin S
int buttonStateF = 0;         // variable for reading the pushbutton status
int varF = 1;                    //temporary variable

const int LDRpin = A0;     // the number of the LDR pin
const int sensorMin = 0;      // sensor minimum, discovered through experiment
const int sensorMax = 100;    // sensor maximum, discovered through experiment

void setup() {
  lc.shutdown(0,false);  // Wake up displays
  lc.shutdown(1,false);
  lc.setIntensity(0,3);  // Set intensity levels
  lc.setIntensity(1,3);
  lc.clearDisplay(0);  // Clear Displays
  lc.clearDisplay(1);

font=font_1;
}

void fonts() {
  

 if (varF==1) {
      font=font_1;
      varF = 2; }
 else if (varF == 2) {
      font=font_2;
      varF = 1; }
     
}

void loop()  {

      //---LDR
      int sensorReading = analogRead(LDRpin); // read the sensor:
      int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
      switch (range) {
    case 0:    
      lc.setIntensity(0,2);  // Set intensity levels
      lc.setIntensity(1,2);

      break;
    case 1:    
      lc.setIntensity(0,6);  // Set intensity levels
      lc.setIntensity(1,6);

      break;
    case 2:   
      lc.setIntensity(0,12);  // Set intensity levels
      lc.setIntensity(1,12);

      break;
    case 3:    
      lc.setIntensity(0,16);  // Set intensity levels
      lc.setIntensity(1,16);

      }
//---------------


buttonStateF = digitalRead(buttonPinF)
 if (buttonStateF == HIGH) {
      fonts();
    }
else {
for (int i = 0; i < 8; i++)  
  {
    lc.setRow(0,i,font[0][i]);
  }
delay(delayTime);

 for (int i = 0; i < 8; i++)  
  {
    lc.setRow(1,i,font[1][i]);
  }
delay(delayTime);
}

}

il y a t il un moyen de visualisé les valeurs de sensorMin et sensorMax ?
je ne remarque aucun changement de luminosité … malheureusement

esloch:
il y a t il un moyen de visualisé les valeurs de sensorMin et sensorMax ?1 ...

Ben oui, à l'aide du moniteur série.

Juste après le setup() vous ajoutez :

Serial.begin(9600); // établit la liaison avec le moniteur série

Puis, dans le loop(), avant l'instruction "switch(range);" vous ajoutez :

Serial.print("sensorReading : ");
Serial.println(sensorReading);
Serial.print("sensorMin : ");
Serial.println(sensorMin);
Serial.print("sensorMax : ");
Serial.println(sensorMax);
Serial.print("range : ";
Serial.println(range);

Vous verrez sur le moniteur les valeurs de ces différentes variables. Mais je suppose qu'on vous a dèjà dit de faire ça.

Cordialement.

Pierre

Merci Pierre