/*
  74HC595 (16 LEDS)
  https://github.com/leticia-pontes/74HC595-16LEDS/tree/main
  https://github.com/wilson3682/74HC595-16LEDS/tree/main
  https://wokwi.com/projects/409908916179596289
*/

int clockPin = 10;
int latchPin = 9;
int dataPin = 8;

#define numShiftRegs 5
#define numLeds numShiftRegs * 8
boolean leds[numLeds];

void setup() {
  Serial.begin(9600);
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  clearReg();
}

void loop() {
  Effect1(1, 10, LSBFIRST);
  Effect1(1, 10, MSBFIRST);

  Effect2(1, 25, LSBFIRST);
  Effect2(1, 25, MSBFIRST);

  Effect3(1, 5, LSBFIRST);
  Effect3(1, 5, MSBFIRST);

  Effect4(1, 20);
  Effect5(1, 20);

  Effect6(1, 3, LSBFIRST);
  Effect6(1, 3, MSBFIRST);

  Effect7(30, 150);
  Effect8(30, 350);
  Effect9(8, 300);

  Effect10(20, 100, LSBFIRST);
  Effect10(20, 100, MSBFIRST);

  Effect11(1, 2, LSBFIRST);
  Effect11(1, 2, MSBFIRST);

  Effect12(1, 100, LSBFIRST);
  Effect12(1, 100, MSBFIRST);

  Effect13(1, 8, LSBFIRST);
  Effect13(1, 8, MSBFIRST);
}

void updateReg(int bitOrder) {
  digitalWrite(latchPin, LOW);
  if (bitOrder == LSBFIRST) {
    for (int i = numLeds - 1; i >= 0; i--) {

      digitalWrite(clockPin, LOW);
      digitalWrite(dataPin, leds[i]);
      digitalWrite(clockPin, HIGH);
    }
  }
  else {
    for (int i = 0; i < numLeds; i++) {
      digitalWrite(clockPin, LOW);
      digitalWrite(dataPin, leds[i]);
      digitalWrite(clockPin, HIGH);
    }
  }
  digitalWrite(latchPin, HIGH);
}

void clearReg() {
  for (int i = 0; i < numLeds; i++) {
    leds[i] = LOW;
    updateReg(LSBFIRST);
  }
}

void printLabel(char* effect, int repeat, int bitOrder) {
  Serial.print(effect);
  Serial.print("\t");
  if (bitOrder == 0) {
    Serial.print("Running to the Right LSBFIRST");
  }
  else {
    Serial.print("Running to the Left MSBFIRST");
  }
  Serial.print("\t");
  //Serial.print("run");
  //Serial.print(" ");
  Serial.print(repeat);
  Serial.print(" ");
  if (repeat <= 1) {
    Serial.println("time");
  }
  else if (repeat > 1) {
    Serial.println("times");
  }
}

//Effect #1: Lights up one LED at a time from left to right.
void Effect1(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 1", repeat, bitOrder);
  clearReg();
  for (int t = 1; t <= repeat; t++) {
    for (int i = 0; i < numLeds; i++) {
      leds[i] = HIGH;
      updateReg(bitOrder);
      delay(Speed);
      leds[i] = LOW;
      updateReg(bitOrder);
      delay(Speed);
    }
  }
}

//Effect #2: Lights up all LEDs sequentially from left to right.
void Effect2(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 2", repeat, bitOrder);
  clearReg();
  for (int t = 1; t <= repeat; t++) {
    for (int i = 0; i < numLeds; i++) {
      leds[i] = HIGH;
      updateReg(bitOrder);
      delay(Speed);
    }
    for (int i = 0; i < numLeds; i++) {
      leds[i] = LOW;
      updateReg(bitOrder);
      delay(Speed);
    }
  }
}

//Effect #3: Combination of effects 1 and 4.
void Effect3(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 3", repeat, bitOrder);
  clearReg();
  int k = numLeds - 1;
  for (int t = 1; t <= repeat; t++) {
    for (int j = numLeds - 1; j >= 0; j--) {
      for (int i = 0; i < k; i++) {
        leds[i] = HIGH;
        updateReg(bitOrder);
        delay(Speed);
        leds[i] = LOW;
        updateReg(bitOrder);
        delay(Speed);
      }
      leds[j] = HIGH;
      updateReg(bitOrder);
      delay(Speed);
      k--;
    }
    //return;
  }
}

//Effect #4: Lights up the LEDs from the outside to the inside.
void Effect4(int repeat, int Speed) {
  printLabel("Effect 4", repeat, LSBFIRST);
  clearReg();
  int j = 0;
  int k = numLeds - 1;
  for (int t = 1; t <= repeat; t++) {
    for (int i = j; i < k; i++) {
      leds[j] = HIGH;
      delay(Speed);
      updateReg(LSBFIRST);
      leds[k] = HIGH;
      delay(Speed);
      updateReg(LSBFIRST);
      j++;
      k--;
    }
    j = 0;
    k = numLeds - 1;
    for (int i = j; i < k; i++) {
      leds[j] = LOW;
      delay(Speed);
      updateReg(LSBFIRST);
      leds[k] = LOW;
      delay(Speed);
      updateReg(LSBFIRST);
      j++;
      k--;
    }
  }
}

//Effect #5: Lights up the LEDs from the inside to the outside.
void Effect5(int repeat, int Speed) {
  printLabel("Effect 5", repeat, LSBFIRST);
  clearReg();
  int j = (numLeds / 2) - 1;
  int k = numLeds / 2;
  for (int t = 1; t <= repeat; t++) {
    for (int i = 0; i < numLeds / 2; i++) {
      leds[j] = HIGH;
      delay(Speed);
      updateReg(LSBFIRST);
      leds[k] = HIGH;
      delay(Speed);
      updateReg(LSBFIRST);
      j--;
      k++;
    }
    j = (numLeds / 2) - 1;
    k = numLeds / 2;

    for (int i = 0; i < numLeds / 2; i++) {
      leds[j] = LOW;
      delay(Speed);
      updateReg(LSBFIRST);
      leds[k] = LOW;
      delay(Speed);
      updateReg(LSBFIRST);
      j--;
      k++;
    }
  }
}

//Effect #6: Inverse version of effect 5.
void Effect6(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 6", repeat, bitOrder);
  clearReg();
  int j = 0;
  for (int t = 1; t <= repeat; t++) {
    for (j = 0; j < numLeds; j++) {
      leds[j] = HIGH;
      delay(Speed);
      updateReg(bitOrder);

      for (int i = j + 1; i < numLeds; i++) {
        leds[i] = HIGH;
        delay(Speed);
        updateReg(bitOrder);
        leds[i] = LOW;
        delay(Speed);
        updateReg(bitOrder);
      }
    }
  }
}

//Effect #7: Lights up a random LED.
void Effect7(int repeat, int Speed) {
  printLabel("Effect 7", repeat, LSBFIRST);
  clearReg();
  for (int t = 1; t <= repeat; t++) {
    int num = random(1, numLeds + 1);
    leds[num] = HIGH;
    delay(Speed);
    updateReg(LSBFIRST);
    leds[num] = LOW;
    delay(Speed);
    updateReg(LSBFIRST);
  }
}

//Effect #8: Lights up two random LEDs.
void Effect8(int repeat, int Speed) {
  printLabel("Effect 8", repeat, LSBFIRST);
  clearReg();
  for (int t = 1; t <= repeat; t++) {
    int num1 = random(1, numLeds + 1);
    int num2 = random(1, numLeds + 1);
    if (num1 == num2) {
      leds[num1] = HIGH;
      delay(Speed);
      updateReg;
    }
    else if (num1 != num2) {
      leds[num1] = HIGH;
      updateReg(LSBFIRST);
      leds[num2] = HIGH;
      updateReg(LSBFIRST);
      delay(Speed);
      leds[num1] = LOW;
      updateReg(LSBFIRST);
      leds[num2] = LOW;
      updateReg(LSBFIRST);
    }
  }
}

//Effect #9: Lights up even and odd LEDs alternately.
void Effect9(int repeat, int Speed) {
  printLabel("Effect 9", repeat, LSBFIRST);
  clearReg();
  for (int t = 1; t <= repeat; t++) {
    for (int i = 0; i < numLeds; i++) {
      if (i % 2 == 0 || i == 0) {
        leds[i] = HIGH;
        updateReg(LSBFIRST);
      }
    }
    delay(Speed);
    for (int i = 0; i < numLeds; i++) {
      if (i % 2 == 0 || i == 0) {
        leds[i] = LOW;
        updateReg(LSBFIRST);
      }
    }
    for (int i = 0; i < numLeds; i++)  {
      if (i % 2 != 0) {
        leds[i] = HIGH;
        updateReg(LSBFIRST);
      }
    }
    delay(Speed);
  }
}

//Effect #10: Lights up LEDs in groups of 4.
void Effect10(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 10", repeat, bitOrder);
  clearReg();
  int a = 0;
  int b = 4;
  int c = 8;
  int d = 12;
  for (int t = 1; t <= repeat; t++) {
    for (int i = 0; i < 4; i++) {
      clearReg();
      leds[a] = HIGH;
      updateReg(bitOrder);
      leds[b] = HIGH;
      updateReg(bitOrder);
      leds[c] = HIGH;
      updateReg(bitOrder);
      leds[d] = HIGH;
      updateReg(bitOrder);

      delay(Speed);

      leds[a] = LOW;
      updateReg(bitOrder);
      leds[b] = LOW;
      updateReg(bitOrder);
      leds[c] = LOW;
      updateReg(bitOrder);
      leds[d] = LOW;
      updateReg(bitOrder);

      a++;
      b++;
      c++;
      d++;

      if (a == numLeds) {
        a = 0;
      }
      else if (b == numLeds) {
        b = 0;
      }
      else if (c == numLeds) {
        c = 0;
      }
      else if (d == numLeds) {
        d = 0;
      }
    }
  }
}

//Effect #11: LEDs go back and forth until the sequence is complete.
void Effect11(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 11", repeat, bitOrder);
  clearReg();
  for (int t = 1; t <= repeat; t++) {
    for (int count = 0; count <= numLeds; count++)  {
      for (int i = 0; i < count; i++) {
        leds[i] = HIGH;
        delay(Speed);
        updateReg(bitOrder);
      }
      delay(Speed * 10);
      for (int i = count; i >= 0; i--) {
        leds[i] = LOW;
        delay(Speed);
        updateReg(bitOrder);
      }
      delay(Speed * 5);
    }
    return;
  }
}

//Effect #12: Sequence in alternating pairs.
void Effect12(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 12", repeat, bitOrder);
  clearReg();
  int a = 0;
  int b = 2;
  for (int t = 1; t <= repeat; t++) {
    for (int i = 0; i < numLeds; i++) {
      a++;
      b++;
      leds[a] = HIGH;
      updateReg(bitOrder);
      delay(Speed);
      leds[b] = HIGH;
      updateReg(bitOrder);
      delay(Speed);
      leds[a] = LOW;
      updateReg(bitOrder);
      leds[b] = LOW;
      updateReg(bitOrder);
      if (a == numLeds) a = 0;
      if (b == numLeds + 2) b = 2;

    }
    //return;
  }
}

//Effect #13: LEDs go back and forth until the sequence is complete.
void Effect13(int repeat, int Speed, int bitOrder) {
  printLabel("Effect 13", repeat, bitOrder);
  clearReg();
  for (int t = 1; t <= repeat; t++) {
    //for (int count = 0; count <= numLeds; count++)  {
    for (int count = numLeds; count >= 0; count--)  {
      //for (int i = 0; i < count; i++) {
      for (int i = count - 1; i >= 0; i--) {
        //leds[i] = HIGH;
        leds[i] = LOW;
        updateReg(bitOrder);
        delay(Speed);
      }
      delay(Speed * 10);
      // for (int i = count; i >= 0; i--) {
      for (int i = 0; i < count; i++) {
        //leds[i] = LOW;
        leds[i] = HIGH;
        updateReg(bitOrder);
        delay(Speed);
      }
      delay(Speed * 5);
    }
    //return;
  }
}