// Chenillard 8 sorties - Philippe Desloges - 04-2023

int ledPin[8] = {2,3,4,5,6,7,8,9};  // LED pins
int ledState = LOW;                 // état des LED
int count = 0;

void setup() {
  for (int pin=0; pin<8; pin++) {
    pinMode(ledPin[pin], OUTPUT);
    digitalWrite(ledPin[pin], LOW);
  }
  randomSeed(analogRead(0));
  Serial.begin(9600);
}

void loop() {
  count++;
  Serial.print("Cycle ");
  Serial.println(count);
  prog_1(0, 100);
  prog_1(1, 100);
  prog_2(B01010101, 250);
  prog_3(B10000000, 1, 100);
  prog_3(B00000001, 0, 100);
  prog_4(250);
  prog_1(1, 100);
  prog_1(0, 100);
  prog_5(150);
  prog_5(150);
  prog_3(B10000000, 1, 100);
  prog_3(B00000001, 0, 100);
}

// chenille gauche droite
void prog_1(byte sens, long lapse) {
  ledState = (ledState == LOW) ? HIGH : LOW;
  if (sens == 0) {
    for (int pin=0; pin<8; pin++) {
      digitalWrite(ledPin[pin], ledState);
      delay(lapse);
    }
  } else {
    for (int pin=8; pin>=0; pin--) {
      digitalWrite(ledPin[pin], ledState);
      delay(lapse);
    }
  }
}

// clignotant alterné
void prog_2(byte num, long lapse) {
  for (int i=0; i<4; i++) {          // la valeur maxi doit être paire
    for (int pin=0; pin<8; pin++)
      digitalWrite(ledPin[pin], bitRead(num, pin) == 1 ?  HIGH : LOW );
    delay(lapse);
    for (int pin=0; pin<8; pin++)
      digitalWrite(ledPin[pin], LOW);
    delay(lapse);
    num = num ^ 255;    
  }
}

// décalage gauche droite
void prog_3(byte num, byte sens, long lapse) {
  for (int i=0; i<8; i++) {
    if (sens == 0) {
      for (int pin=0; pin<8; pin++)
          digitalWrite(ledPin[pin], bitRead(num, pin) == 1 ?  HIGH : LOW );
      num = num << 1;
    } else {
      for (int pin=0; pin<8; pin++)
          digitalWrite(ledPin[pin], bitRead(num, pin) == 1 ?  HIGH : LOW );
      num = num >> 1;
    }
    delay(lapse);
  }
}

// aléatoire
void prog_4(long lapse) {
  for (int i=0; i<4; i++) {            // la valeur maxi doit être paire
    byte num = random(0,255);
    for (int pin=0; pin<8; pin++)
        digitalWrite(ledPin[pin], bitRead(num, pin) == 1 ?  HIGH : LOW );
    delay(lapse);
    for (int pin=0; pin<8; pin++)
        digitalWrite(ledPin[pin], bitRead(num, pin) == 0 ?  HIGH : LOW );
    delay(lapse);
  }
  for (int pin=0; pin<8; pin++)
      digitalWrite(ledPin[pin], LOW);
}

// décalage séparé gauche droite
void prog_5(long lapse) {
  byte num1 = B00000001;
  byte num2 = B10000000;
  for (int i=0; i<4; i++) {             // la valeur maxi doit être paire
    for (int pin=0; pin<4; pin++)
        digitalWrite(ledPin[pin], bitRead(num1, pin) == 1 ?  HIGH : LOW );
    for (int pin=4; pin<8; pin++)
        digitalWrite(ledPin[pin], bitRead(num2, pin) == 1 ?  HIGH : LOW );
    num1 = num1 << 1;
    num2 = num2 >> 1;
    delay(lapse);
  }
  for (int i=0; i<4; i++) {             // la valeur maxi doit être paire
    num1 = num1 >> 1;
    num2 = num2 << 1;
    for (int pin=0; pin<4; pin++)
        digitalWrite(ledPin[pin], bitRead(num1, pin) == 1 ?  HIGH : LOW );
    for (int pin=4; pin<8; pin++)
        digitalWrite(ledPin[pin], bitRead(num2, pin) == 1 ?  HIGH : LOW );
    delay(lapse);
  }
}

// Ramps 1.4 - Arduino Mega 2560
// Programme procédural de test des 5 sorties PAP
// Philippe Desloges - 05-2023

// Moteurs NEMA17 200 pas/tour (1.8°/pas)
// 4 drivers DRV8825 + 1 driver A4988
// Alimentation 12V 4A

// Modes et position des jumpers   MS1 MS2 MS3
// 1/1  pas,      200 pas/tour,     0   0   0
// 1/2  pas,      400 pas/tour,     1   0   0
// 1/4  pas,      800 pas/tour,     0   1   0
// 1/8  pas,     1600 pas/tour,     1   1   0
// 1/16 pas,     3200 pas/tour,     0   0   1
// 1/32 pas,     6400 pas/tour,     1   0   1     (sauf driver A4988)

#define E0_pinEnable  24  // activation
#define E0_pinStep    26  // steps
#define E0_pinDir     28  // direction
 
#define E1_pinEnable  30  // activation
#define E1_pinStep    36  // steps
#define E1_pinDir     34  // direction
 
#define X_pinEnable   38   // activation
#define X_pinStep     A0   // steps
#define X_pinDir      A1   // direction
 
#define Y_pinEnable   A2   // activation
#define Y_pinStep     A6   // steps
#define Y_pinDir      A7   // direction 

#define Z_pinEnable   A8   // activation
#define Z_pinStep     46   // steps
#define Z_pinDir      48   // direction 

const int nSteps  = 1600;  // pas par tour
const int forward = HIGH;  // marche avant
const int reverse = LOW;   // marche arrière
const int pause   = 0;     // pause en ms entre séquences
int tempo;                 // délai en µs entre impulsions

// sélection des axes
bool E0 = false;
bool E1 = true;
bool X  = true;
bool Y  = true;
bool Z  = true;

void setup() {
  // paramétrage des sorties
  pinMode(E0_pinEnable, OUTPUT);
  pinMode(E0_pinDir   , OUTPUT);
  pinMode(E0_pinStep  , OUTPUT);
  
  pinMode(E1_pinEnable, OUTPUT);
  pinMode(E1_pinDir   , OUTPUT);
  pinMode(E1_pinStep  , OUTPUT);

  pinMode(X_pinEnable,  OUTPUT);
  pinMode(X_pinDir   ,  OUTPUT);
  pinMode(X_pinStep  ,  OUTPUT);

  pinMode(Y_pinEnable,  OUTPUT);
  pinMode(Y_pinDir   ,  OUTPUT);
  pinMode(Y_pinStep  ,  OUTPUT);

  pinMode(Z_pinEnable,  OUTPUT);
  pinMode(Z_pinDir   ,  OUTPUT);
  pinMode(Z_pinStep  ,  OUTPUT);

  // initialisation des moteurs
  digitalWrite(E0_pinStep, LOW);
  digitalWrite(E1_pinStep, LOW);
  digitalWrite(X_pinStep,  LOW);
  digitalWrite(Y_pinStep,  LOW);
  digitalWrite(Z_pinStep,  LOW);

  // délai en µs entre impulsions sous 12V
  switch(nSteps) {
    case  200: tempo = 1200; break;
    case  400: tempo =  800; break;
    case  800: tempo =  400; break;
    case 1600: tempo =  200; break;
    case 3200: tempo =  100; break;
    case 6400: tempo =   50; break;
  }

  // lancement des sequences
  enable_motors();
  synchro(forward, nSteps*2);
  if (E0) onlyOne(E0_pinDir, E0_pinStep, reverse, nSteps);
  if (E1) onlyOne(E1_pinDir, E1_pinStep, reverse, nSteps);
  if (X)  onlyOne(X_pinDir,  X_pinStep,  reverse, nSteps);
  if (Y)  onlyOne(Y_pinDir,  Y_pinStep,  reverse, nSteps);
  if (Z)  onlyOne(Z_pinDir,  Z_pinStep,  reverse, nSteps);
  synchro(reverse, nSteps);
  if (E0) onlyOne(E0_pinDir, E0_pinStep, forward, nSteps);
  if (E1) onlyOne(E1_pinDir, E1_pinStep, forward, nSteps);
  if (X)  onlyOne(X_pinDir,  X_pinStep,  forward, nSteps);
  if (Y)  onlyOne(Y_pinDir,  Y_pinStep,  forward, nSteps);
  if (Z)  onlyOne(Z_pinDir,  Z_pinStep,  forward, nSteps);
  synchro(reverse, nSteps*2);
  release_motors();
}

void onlyOne(int pinDir, int pinStep, int dir, int steps) {
  // direction
  digitalWrite(pinDir, dir);
  // rotation
  for(int i=0; i<steps; i++) {
    digitalWrite(pinStep, HIGH);
    delayMicroseconds(tempo);
    digitalWrite(pinStep, LOW);
    delayMicroseconds(tempo);
  } 
  delay(pause);
}

void synchro(int dir, int steps) {
  // direction
  digitalWrite(E0_pinDir, dir);
  digitalWrite(E1_pinDir, dir);
  digitalWrite(X_pinDir,  dir);
  digitalWrite(Y_pinDir,  dir);
  digitalWrite(Z_pinDir,  dir);

  // rotation
  for(int i=0; i<steps; i++) {
    if (E0) digitalWrite(E0_pinStep, HIGH);
    if (E1) digitalWrite(E1_pinStep, HIGH);
    if (X)  digitalWrite(X_pinStep, HIGH);
    if (Y)  digitalWrite(Y_pinStep, HIGH);
    if (Z)  digitalWrite(Z_pinStep, HIGH);
    delayMicroseconds(tempo);
    if (E0) digitalWrite(E0_pinStep, LOW);
    if (E1) digitalWrite(E1_pinStep, LOW);
    if (X)  digitalWrite(X_pinStep, LOW);
    if (Y)  digitalWrite(Y_pinStep, LOW);
    if (Z)  digitalWrite(Z_pinStep, LOW);
    delayMicroseconds(tempo);
  } 
  delay(pause);
}

void enable_motors() {
  // verrouillage des moteurs
  digitalWrite(E0_pinEnable, LOW);
  digitalWrite(E1_pinEnable, LOW);
  digitalWrite(X_pinEnable, LOW);
  digitalWrite(Y_pinEnable, LOW);
  digitalWrite(Z_pinEnable, LOW);
}

void release_motors() {
  // libération des moteurs
  digitalWrite(E0_pinEnable, HIGH);
  digitalWrite(E1_pinEnable, HIGH);
  digitalWrite(X_pinEnable, HIGH);
  digitalWrite(Y_pinEnable, HIGH);
  digitalWrite(Z_pinEnable, HIGH);
}

void loop() {
}

// Jeu de dés avec 2 matrices LED 8x8 - Philippe Desloges - 04-2023

#include <LedControl.h>

// faces 1 à 6 et logo
byte face[][8] = {
  { B00000000, B00000000, B00000000, B00011000, B00011000, B00000000, B00000000, B00000000 },
  { B00000011, B00000011, B00000000, B00000000, B00000000, B00000000, B11000000, B11000000 },
  { B00000011, B00000011, B00000000, B00011000, B00011000, B00000000, B11000000, B11000000 },
  { B11000011, B11000011, B00000000, B00000000, B00000000, B00000000, B11000011, B11000011 },
  { B11000011, B11000011, B00000000, B00011000, B00011000, B00000000, B11000011, B11000011 },
  { B11000011, B11000011, B00000000, B11000011, B11000011, B00000000, B11000011, B11000011 },
  { B11100111, B10000001, B10111101, B00100100, B00100100, B10111101, B10000001, B11100111 }
};

const byte playPin = 8;                                 // pin digital du bouton de lancé
byte nChips = 2;                                        // nombre de matrices montées en série

LedControl lc = LedControl(12, 11, 10, nChips);
// MAX7219 pin din => pin 12
// MAX7219 pin clk => pin 11
// MAX7219 pin cs  => pin 10

void setup() {
  pinMode(playPin, INPUT);
  randomSeed(analogRead(0));
  for (int chip=0; chip<nChips; chip++) {
    lc.shutdown(chip, false);                           // veille désactivée
    lc.setIntensity(chip, 2);                           // intensité 0 à 15
    lc.clearDisplay(chip);                              // éteind les leds
  }
  for (int chip=0; chip<nChips; chip++)                 // affiche le logo
      displayFace(chip, face[6], 0);
  digitalWrite(playPin, HIGH);                          // initialise le switch
}

void slideRight1(byte state, byte lapse) {              // slide aller full
  for (int chip=0; chip<nChips; chip++) {
    for (int row=8; row>=0; row--) {
      for (int col=8; col>=0; col--)
        lc.setLed(chip, col, row, state);
      delay(lapse);
    }
  }
}

void slideLeft1(byte state, byte lapse) {               // slide retour full
  for (int chip=nChips-1; chip>=0; chip--) {
    for (int row=0; row<8; row++) {
      for (int col=0; col<8; col++)
        lc.setLed(chip, col, row, state);
      delay(lapse);
    }
  }
}

void slideRight2(byte state, byte lapse) {               // slide aller damier
  byte pattern = B01010101;
  for (int chip=0; chip<nChips; chip++) {
    for (int row=8; row>=0; row--) {
      for (int col=8; col>=0; col--)
        lc.setLed(chip, col, row, pattern & (1 << col));
      pattern = pattern ^ B11111111;
      delay(lapse);
    }
  }
}

void slideLeft2(byte state, byte lapse) {               // slide retour damier
  byte pattern = B01010101;
  for (int chip=nChips-1; chip>=0; chip--) {
    for (int row=0; row<8; row++) {
      for (int col=0; col<8; col++)
        lc.setLed(chip, col, row, pattern & (1 << col));
      pattern = pattern ^ B11111111;
      delay(lapse);
    }
  }
}

void displayFace(byte chip, byte val[8], int lapse) {   // affiche une face
  for (int row=0; row<8; row++) {
    for (int col=0; col<8; col++) {
      byte state = val[row] & (1 << col);
      lc.setLed(chip, col, row, state);
      delay(lapse);
    }
  }
}

void play(int lapse) {                                  // lance les dés
  slideRight1(HIGH, lapse*8);
  slideLeft1(LOW, lapse*8);
  slideRight2(HIGH, lapse*8);
  delay(lapse);
  byte number[nChips];
  for (int chip=nChips-1; chip>=0; chip--) {            // affiche les faces
    number[chip] = random(1, 7);
    displayFace(chip, face[number[chip]-1], lapse);
  }
  if ((nChips == 2) && (number[0] == number[1]))        // clignotement si double
    for (byte i=1; i<4; i++) {
      delay(250);
      for (int chip=nChips-1; chip>=0; chip--)
        lc.clearDisplay(chip);
      delay(250);
      for (int chip=nChips-1; chip>=0; chip--)
        displayFace(chip, face[number[chip]-1], 0);
  }
}

void loop() {
  if (digitalRead(playPin) == LOW)                      // attend une action sur le switch
    play(3);                                            // lance les dés avec délai de slide en ms
  digitalWrite(playPin, HIGH);                          // réinitialise le switch
}