Apprendre à piloter un bargraphe 12 segments bicolores

#include <SPI.h>

#define LOAD          10   /* Entrée LOAD du MAX72219 */

#define DISPLAY_TEST  0x0F /* Registre Display-Test */
#define SHUTDOWN      0x0C /* Registre Shutdown */
#define DECODE_MODE   0x09 /* Registre Decode-mode */
#define SCAN_LIMIT    0x0B /* Registre Scan-limit */
#define INTENSITY     0x0A /* Registre Intensity */
#define DIGIT0        0x01 /* Registre Digit 0 */
#define DIGIT1        0x02 /* Registre Digit 1 */
#define DIGIT2        0x03 /* Registre Digit 2 */

void setup() {
  pinMode(LOAD, OUTPUT);
  digitalWrite(LOAD, HIGH);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST); /* bits de poids fort en premier */

  writeRegister(DISPLAY_TEST, 0x00); /* Normal operation */
  writeRegister(DECODE_MODE, 0x00);  /* No decode */
  writeRegister(SCAN_LIMIT, 0x02);   /* Display digits 0, 1, 2 */
  writeRegister(INTENSITY, 0x08);    /* LED brightness, max=0x0F */
  writeRegister(SHUTDOWN, 0x01);     /* Normal operation */

  test(); /* Lancer le test */

  writeRegister(SHUTDOWN, 0x00);  /* Shutdown mode */
}

void test() {
  byte allRed = 0x0F;
  byte allGreen = allRed << 4;
  byte allYellow = allRed | allGreen; /* synthèse additive rouge+vert */

  for (int i = 0 ; i < 3 ; i++) {
    writeRegister(DIGIT0, allRed);
    writeRegister(DIGIT1, allRed);
    writeRegister(DIGIT2, allRed);

    delay(1000);

    writeRegister(DIGIT0, allGreen);
    writeRegister(DIGIT1, allGreen);
    writeRegister(DIGIT2, allGreen);

    delay(1000);

    writeRegister(DIGIT0, allYellow);
    writeRegister(DIGIT1, allYellow);
    writeRegister(DIGIT2, allYellow);

    delay(1000);
  }
}

void writeRegister(byte thisRegister, byte thisValue) // Écrire dans un registre du MAX7219
{
  // Mettre l'entrée LOAD à l'état bas
  digitalWrite(LOAD, LOW);

  SPI.transfer(thisRegister); // Adresse du registre
  SPI.transfer(thisValue); // Contenu du registre

  // Basculer l'entrée LOAD à l'état haut pour verrouiller et transférer les données
  digitalWrite(LOAD, HIGH);
}

void loop()
{
  //
}

enum color_t {NOCOLOR, RED, GREEN, YELLOW};

const byte nb_digits = 3;   /* nombre de digits du bargraph */
const byte nb_segments_digit = 4; /* nombre de segments par digit */

color_t bargraph[nb_digits * nb_segments_digit] = {
    GREEN, YELLOW, RED, RED, YELLOW, GREEN,
    GREEN, YELLOW, RED, RED, YELLOW, GREEN
};

bargraphDraw(bargraph);

void bargraphDraw(color_t const *mybargraph) {
  byte c;
  for (byte d = 0; d < nb_digits; d++) { /* pour chaque digit */
    c = 0;
    for (byte s = 0; s < nb_segments_digit; s++) { /* pour chaque segment du digit */
      switch (mybargraph[d * nb_segments_digit + s]) {
        case NOCOLOR : break;
        case RED : c |= (1 << s); break;
        case GREEN : c |= (1 << (s + 4)); break;
        case YELLOW :  c |= ((1 << s) | (1 << (s + 4))); break;
        default: break;
      }
    }
    writeRegister(d + 1, c);
  }
}

#include <SPI.h>

#define LOAD          10   /* Entrée LOAD du MAX72219 */

#define DISPLAY_TEST  0x0F /* Registre Display-Test */
#define SHUTDOWN      0x0C /* Registre Shutdown */
#define DECODE_MODE   0x09 /* Registre Decode-mode */
#define SCAN_LIMIT    0x0B /* Registre Scan-limit */
#define INTENSITY     0x0A /* Registre Intensity */

enum color_t {NOCOLOR, RED, GREEN, YELLOW};
void bargraphDraw(color_t const *mybargraph);

const byte nb_digits = 3;   /* nombre de digits du bargraph */
const byte nb_segments_digit = 4; /* nombre de segments par digit */

void setup() {
  pinMode(LOAD, OUTPUT);
  digitalWrite(LOAD, HIGH);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST); /* bits de poids fort en premier */

  writeRegister(DISPLAY_TEST, 0x00); /* Normal operation */
  writeRegister(DECODE_MODE, 0x00); /* No decode */
  writeRegister(SCAN_LIMIT, nb_digits - 1); /* Display digits 0, 1, 2 */
  writeRegister(INTENSITY, 0x08);   /* LED brightness, max=0x0F */
  writeRegister(SHUTDOWN, 0x01);    /* Normal operation */

  demo();  /* Lancer la démo */

  writeRegister(SHUTDOWN, 0x00);  /* Shutdown mode */
}

void demo() {
  const byte nb_segments = nb_digits * nb_segments_digit;
  color_t bargraph[nb_segments] = {
    GREEN, YELLOW, RED, RED, YELLOW, GREEN,
    GREEN, YELLOW, RED, RED, YELLOW, GREEN
  };

  bargraphDraw(bargraph);
  delay(1000);

  for (int i = 0; i < 10 * nb_segments; i++) {
    /* décalage à gauche */
    color_t c = bargraph[0];
    for (int j = 0; j < nb_segments - 1; j++) {
      bargraph[j] = bargraph[j + 1];
    }
    bargraph[nb_segments - 1] = c;
    /* fin décalage à gauche */

    bargraphDraw(bargraph);
    delay(80);
  }

  delay(3000);
}

void bargraphDraw(color_t const *mybargraph) {
  byte c;
  for (byte d = 0; d < nb_digits; d++) { /* pour chaque digit */
    c = 0;
    for (byte s = 0; s < nb_segments_digit; s++) { /* pour chaque segment du digit */
      switch (mybargraph[d * nb_segments_digit + s]) {
        case NOCOLOR : break;
        case RED : c |= (1 << s); break;
        case GREEN : c |= (1 << (s + 4)); break;
        case YELLOW :  c |= ((1 << s) | (1 << (s + 4))); break;
        default: break;
      }
    }
    writeRegister(d + 1, c);
  }
}

void writeRegister(byte thisRegister, byte thisValue) // Écrire dans un registre du MAX7219
{
  // Mettre l'entrée LOAD à l'état bas
  digitalWrite(LOAD, LOW);

  SPI.transfer(thisRegister); // Adresse du registre
  SPI.transfer(thisValue); // Contenu du registre

  // Basculer l'entrée LOAD à l'état haut pour verrouiller et transférer les données
  digitalWrite(LOAD, HIGH);
}

void loop()
{
  //
}

levelGauge(50); /* niveau=50% */

#include <SPI.h>

#define LOAD          10   /* Entrée LOAD du MAX72219 */

#define DISPLAY_TEST  0x0F /* Registre Display-Test */
#define SHUTDOWN      0x0C /* Registre Shutdown */
#define DECODE_MODE   0x09 /* Registre Decode-mode */
#define SCAN_LIMIT    0x0B /* Registre Scan-limit */
#define INTENSITY     0x0A /* Registre Intensity */

enum color_t {NOCOLOR, RED, GREEN, YELLOW};
void bargraphDraw(color_t const *mybargraph);
void levelGauge(unsigned int percentage);

const byte nb_digits = 3;   /* nombre de digits du bargraph */
const byte nb_segments_digit = 4; /* nombre de segments par digit */

void setup() {
  pinMode(LOAD, OUTPUT);
  digitalWrite(LOAD, HIGH);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST); /* bits de poids fort en premier */

  writeRegister(DISPLAY_TEST, 0x00); /* Normal operation */
  writeRegister(DECODE_MODE, 0x00); /* No decode */
  writeRegister(SCAN_LIMIT, nb_digits - 1); /* Display digits 0, 1, 2 */
  writeRegister(INTENSITY, 0x08);   /* LED brightness, max=0x0F */
  writeRegister(SHUTDOWN, 0x01);    /* Normal operation */

  demo();  /* Lancer la démo */

  writeRegister(SHUTDOWN, 0x00);  /* Shutdown mode */
}

void demo() {
  for (int i = 0; i < 5; i++) {
    for (int percent = 0; percent <= 100; percent += 5) {
      levelGauge(percent);
      delay(20);
    }
    for (int percent = 100; percent >= 0; percent -= 5) {
      levelGauge(percent);
      delay(20);
    }
  }

  delay(3000);
}

void bargraphDraw(color_t const *mybargraph) {
  byte c;
  for (byte d = 0; d < nb_digits; d++) { /* pour chaque digit */
    c = 0;
    for (byte s = 0; s < nb_segments_digit; s++) { /* pour chaque segment du digit */
      switch (mybargraph[d * nb_segments_digit + s]) {
        case NOCOLOR : break;
        case RED : c |= (1 << s); break;
        case GREEN : c |= (1 << (s + 4)); break;
        case YELLOW :  c |= ((1 << s) | (1 << (s + 4))); break;
        default: break;
      }
    }
    writeRegister(d + 1, c);
  }
}

void levelGauge(unsigned int percentage) { /* indicateur de niveau, percentage entre 0 et 100 */
  unsigned int level ,
               levelRed = nb_digits * nb_segments_digit - 2,
               levelYellow = levelRed - 2;
      
  color_t bargraph[nb_digits * nb_segments_digit] = {NOCOLOR}; /* parce que NOCOLOR=0, toutes les autres valeurs non indiquées prendront la valeur 0 */

  if (percentage > 100)
    return;

  if (percentage > 0) {
    level = map(percentage, 0, 100, 0, nb_digits * nb_segments_digit - 1);

    if (level >= levelRed) { /* niveau dans le rouge */
      for (int i = levelRed; i <= level; i++) {
        bargraph[i] = RED;
      }
    }
    if (level >= levelYellow) { /* niveau dans le orange */
      for (int i = levelYellow; i <= min(level, levelRed - 1); i++) {
        bargraph[i] = YELLOW;
      }
    }
    for (int i = 0; i <= min(level, levelYellow - 1); i++) {
      bargraph[i] = GREEN;
    }
  }
  bargraphDraw(bargraph);
}

void writeRegister(byte thisRegister, byte thisValue) // Écrire dans un registre du MAX7219
{
  // Mettre l'entrée LOAD à l'état bas
  digitalWrite(LOAD, LOW);

  SPI.transfer(thisRegister); // Adresse du registre
  SPI.transfer(thisValue); // Contenu du registre

  // Basculer l'entrée LOAD à l'état haut pour verrouiller et transférer les données
  digitalWrite(LOAD, HIGH);
}

void loop()
{
  //
}

#include <SPI.h>

#define LOAD          10   /* Entrée LOAD du MAX72219 */

#define DISPLAY_TEST  0x0F /* Registre Display-Test */
#define SHUTDOWN      0x0C /* Registre Shutdown */
#define DECODE_MODE   0x09 /* Registre Decode-mode */
#define SCAN_LIMIT    0x0B /* Registre Scan-limit */
#define INTENSITY     0x0A /* Registre Intensity */

#define SENSOR_ANALOG_PIN      A0  /* capteur analogique sur A0 */

enum color_t {NOCOLOR, RED, GREEN, YELLOW};
void bargraphDraw(color_t const *mybargraph);
void levelGauge(unsigned int percentage);

const byte nb_digits = 3;   /* nombre de digits du bargraph */
const byte nb_segments_digit = 4; /* nombre de segments par digit */

void setup() {
  pinMode(LOAD, OUTPUT);
  digitalWrite(LOAD, HIGH);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST); /* bits de poids fort en premier */

  writeRegister(DISPLAY_TEST, 0x00); /* Normal operation */
  writeRegister(DECODE_MODE, 0x00); /* No decode */
  writeRegister(SCAN_LIMIT, nb_digits - 1); /* Display digits 0, 1, 2 */
  writeRegister(INTENSITY, 0x08);   /* LED brightness, max=0x0F */
  writeRegister(SHUTDOWN, 0x01);    /* Normal operation */
}

void loop()
{
  unsigned int analogLevel = map(analogRead(SENSOR_ANALOG_PIN), 0, 1023, 0, 100);
  levelGauge(analogLevel);
  delay(50);
}

void bargraphDraw(color_t const *mybargraph) {
  byte c;
  for (byte d = 0; d < nb_digits; d++) { /* pour chaque digit */
    c = 0;
    for (byte s = 0; s < nb_segments_digit; s++) { /* pour chaque segment du digit */
      switch (mybargraph[d * nb_segments_digit + s]) {
        case NOCOLOR : break;
        case RED : c |= (1 << s); break;
        case GREEN : c |= (1 << (s + 4)); break;
        case YELLOW :  c |= ((1 << s) | (1 << (s + 4))); break;
        default: break;
      }
    }
    writeRegister(d + 1, c);
  }
}


void levelGauge(unsigned int percentage) { /* indicateur de niveau, percentage entre 0 et 100 */
  unsigned int level ,
               levelRed = nb_digits * nb_segments_digit - 2,
               levelYellow = levelRed - 2;
      
  color_t bargraph[nb_digits * nb_segments_digit] = {NOCOLOR}; /* parce que NOCOLOR=0, toutes les autres valeurs non indiquées prendront la valeur 0 */

  if (percentage > 100)
    return;

  if (percentage > 0) {
    level = map(percentage, 0, 100, 0, nb_digits * nb_segments_digit - 1);

    if (level >= levelRed) { /* niveau dans le rouge */
      for (int i = levelRed; i <= level; i++) {
        bargraph[i] = RED;
      }
    }
    if (level >= levelYellow) { /* niveau dans le orange */
      for (int i = levelYellow; i <= min(level, levelRed - 1); i++) {
        bargraph[i] = YELLOW;
      }
    }
    for (int i = 0; i <= min(level, levelYellow - 1); i++) {
      bargraph[i] = GREEN;
    }
  }
  bargraphDraw(bargraph);
}

void writeRegister(byte thisRegister, byte thisValue) // Écrire dans un registre du MAX7219
{
  // Mettre l'entrée LOAD à l'état bas
  digitalWrite(LOAD, LOW);

  SPI.transfer(thisRegister); // Adresse du registre
  SPI.transfer(thisValue); // Contenu du registre

  // Basculer l'entrée LOAD à l'état haut pour verrouiller et transférer les données
  digitalWrite(LOAD, HIGH);
}