AIP1640 / TM1640 matrix Life

/*
 * AiP1640 / TM1640 (matrix) Life
 *
**/

#include <TM1640.h>
#include <TM16xxMatrix.h>

//TM1640 module(9, 10);    // DIN=9, CLK=10
TM1640 module(A4, A5);    // For ESP8266/WeMos D1-mini: DIN=D7/13/MOSI, CLK=D5/14/SCK
// Maximum number of generations until the screen is refreshed
#define MAX_GEN_COUNT 100

#define GRIDX 16  // nb colonnes
#define GRIDY 8   // nb lignes

#define GEN_DELAY 150

TM16xxMatrix matrix(&module, GRIDX, GRIDY);

uint8_t grid[GRIDX][GRIDY];
uint8_t newgrid[GRIDX][GRIDY];

void setup()
{

}

void loop()
{

  unsigned long cells = 0;
  unsigned long time_start = millis();

  // Un petit flash au demarrage
  module.setupDisplay(true, 0);
  matrix.setAll(true);
  for (int intensity = 0; intensity < 8; intensity++) {
    module.setupDisplay(true, intensity);
    delay(40);
  }
  for (int intensity = 7; intensity >= 0; intensity--) {
    module.setupDisplay(true, intensity);
    delay(40);
  }
  matrix.setAll(false);    // Note: module.clearDisplay() doesn't clear the offscreen bitmap!
  module.setupDisplay(true, 7);
  delay(500);

  initGrid();
  // MAX_GEN_COUNT générations
  for (int gen = 0; gen < MAX_GEN_COUNT; gen++) {
    if ( ! computeCA()) { // s'il n'y a plus de mouvement on reinit
      delay(1000);
      break;
    }
    drawGrid();
    cells+=(GRIDX-1)*(GRIDY - 1);
    delay(GEN_DELAY);
    for (int16_t x = 1; x < GRIDX-1; x++) {
      for (int16_t y = 1; y < GRIDY-1; y++) {
        grid[x][y] = newgrid[x][y];
      }
    }
  }

  float duree = (millis() - time_start) / 1000.0;
}

// Dessine la grille
void drawGrid(void) {

  bool color = true;
  for (int16_t x = 1; x < GRIDX - 1; x++) {
    for (int16_t y = 1; y < GRIDY - 1; y++) {
      if ((grid[x][y]) != (newgrid[x][y])) {
        if (newgrid[x][y] == 1) color = true;
        else color = false;
          matrix.setPixel(x, y, color);
      }
    }
  }
}

// Initialise la grille
void initGrid(void) {
  for (int16_t x = 0; x < GRIDX; x++) {
    for (int16_t y = 0; y < GRIDY; y++) {
      newgrid[x][y] = 0;

      if (x == 0 || x == GRIDX - 1 || y == 0 || y == GRIDY - 1) {
        grid[x][y] = 0;
      }
      else {
        if (random(5) <= 2)
          grid[x][y] = 1;
        else
          grid[x][y] = 0;
      }

    }
  }
}

// Calcule la prochaine generation
bool computeCA() {
  bool change_occured=false;

  for (int16_t x = 1; x < GRIDX; x++) {
    for (int16_t y = 1; y < GRIDY; y++) {
      int neighbors = getNumberOfNeighbors(x, y);
      if (grid[x][y] == 1 && (neighbors == 2 || neighbors == 3 ))
      {
        newgrid[x][y] = 1;
      }
      else {
        if (grid[x][y] == 1) {
          newgrid[x][y] = 0;
        }
      }
      if (grid[x][y] == 0 && (neighbors == 3))
      {
        newgrid[x][y] = 1;
      }
      else {
        if (grid[x][y] == 0) {
          newgrid[x][y] = 0;
        }
      }
      if (newgrid[x][y] != grid[x][y]) {
        change_occured = true;
      }
    }
  }
  return change_occured;
}

// entourage de la cellule
int getNumberOfNeighbors(int x, int y) {
  return grid[x - 1][y] + grid[x - 1][y - 1] + grid[x][y - 1] + grid[x + 1][y - 1] + grid[x + 1][y] + grid[x + 1][y + 1] + grid[x][y + 1] + grid[x - 1][y + 1];
}