// LedPad - By burnblazter
// Arduino project developed by burnblazter. This project allows users to control various LED light patterns through a keypad.

#include <Keypad.h>

// Boolean variables to track key states
bool key1 = false;
bool key2 = false;
bool key3 = false;
bool key4 = false;
bool key5 = false;
bool key6 = false;
bool key7 = false;
bool key8 = false;
bool key9 = false;

// Function to reset all key states to false
void resetKeys() {
  key1 = false;
  key2 = false;
  key3 = false;
  key4 = false;
  key5 = false;
  key6 = false;
  key7 = false;
  key8 = false;
  key9 = false;
}

// Define the number of rows and columns for the keypad
const byte ROWS = 4;
const byte COLS = 4;

// Define the key mappings for the keypad
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

// Define the row and column pins for the keypad
byte rowPins[ROWS] = {A5, A4, A3, A2}; // Analog pins A5, A4, A3, and A2
byte colPins[COLS] = {A1, A0, 12, 13}; // Analog pins 

// Create a Keypad object
Keypad kpd = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// Define the pin numbers for the LEDs
int redPin = 3; // Red LED
int yellowPin = 5; // Yellow LED
int greenPin = 6; // Green LED
int bluePin = 9; // Blue LED
int whitePin = 10; // White LED
int screenPin = 11; // Screen white pin

void setup() {
  // Set the LED pins as output
  pinMode(redPin, OUTPUT);
  pinMode(yellowPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  pinMode(whitePin, OUTPUT);
  pinMode(screenPin, OUTPUT);

  // Start the serial communication
  Serial.begin(9600);
}

void loop() {
  // Get the key pressed on the keypad
  char key = kpd.getKey();

  switch (key) {
    // Key Number 1
    // Static Lighting: Solid color (all LEDs on)
    case '1':
      resetKeys();
      key1 = true;
      break;

    // Key Number 2
    // Blinking: Blink all LEDs simultaneously
    case '2':
      resetKeys();
      key2 = true;
      break;

    // Key Number 3
    // Fading: Fade in and out all LEDs simultaneously
    case '3':
      resetKeys();
      key3 = true;
      break;

    // Key Number 4
    // Chasing: LEDs light up one by one in a sequential pattern
    case '4':
      resetKeys();
      key4 = true;
      break;

    // Key Number 5
    // Breathing: Fade in and out in a smooth, continuous pattern
    case '5':
      resetKeys();
      key5 = true;
      break;

    // Key Number 6
    // Strobing: Rapid blinking of all LEDs at a high frequency
    case '6':
      resetKeys();
      key6 = true;
      break;

    // Key Number 7
    // Twinkling: Random LEDs twinkle on and off
    case '7':
      resetKeys();
      key7 = true;
      break;

    // Key Number 8
    // Larson Scanner (Knight Rider): A sequence of LEDs that sweeps back and forth
    case '8':
      resetKeys();
      key8 = true;
      break;

    // Key Number 9
    // Wave: A wave-like pattern that moves across the LEDs
    case '9':
      resetKeys();
      key9 = true;
      break;

    // Key Number 0
    // Add functionality here
    case '0':
      break;

    // Key Letter A
    // Add functionality here
    case 'A':
      break;

    // Key Letter B
    // Add functionality here
    case 'B':
      break;

    // Key Letter C
    // Add functionality here
    case 'C':
      break;

    // Key Letter D
    // Add functionality here
    case 'D':
      break;

    // Key Hashtag
    // Add functionality here
    case '#':
      break;

    // Key Asterisk
    // Reset all patterns
    case '*':
      resetKeys();
      break;
  }

  // Key 1 to Key 9 Trigger

  // Key 1: Static Lighting - Solid color (all LEDs on)
  if (key1) {
    analogWrite(redPin, 255);
    analogWrite(yellowPin, 255);
    analogWrite(greenPin, 255);
    analogWrite(bluePin, 255);
    analogWrite(whitePin, 255);
  }

  // Key 2: Blinking - Blink all LEDs simultaneously
  if (key2) {
    analogWrite(redPin, 255);
    analogWrite(yellowPin, 255);
    analogWrite(greenPin, 255);
    analogWrite(bluePin, 255);
    analogWrite(whitePin, 255);
    delay(200); // Adjust the delay for the desired blinking rate
    analogWrite(redPin, 0);
    analogWrite(yellowPin, 0);
    analogWrite(greenPin, 0);
    analogWrite(bluePin, 0);
    analogWrite(whitePin, 0);
    delay(200); // Adjust the delay for the desired blinking rate
  }

  // Key 3: Fading - Fade in and out all LEDs simultaneously
  if (key3) {
    // Fade in
    for (int brightness = 0; brightness <= 255; brightness++) {
      analogWrite(redPin, brightness);
      analogWrite(yellowPin, brightness);
      analogWrite(greenPin, brightness);
      analogWrite(bluePin, brightness);
      analogWrite(whitePin, brightness);
      delay(10); // Adjust the delay for the desired fading speed
    }

    // Fade out
    for (int brightness = 255; brightness >= 0; brightness--) {
      analogWrite(redPin, brightness);
      analogWrite(yellowPin, brightness);
      analogWrite(greenPin, brightness);
      analogWrite(bluePin, brightness);
      analogWrite(whitePin, brightness);
      delay(10); // Adjust the delay for the desired fading speed
    }
  }

  // Key 4: Chasing - LEDs light up one by one in a sequential pattern
  if (key4) {
    // Implement the chasing pattern logic here
    // Example: Turn on each LED one by one, then turn them off in reverse order
    analogWrite(redPin, 255);
    delay(100);
    analogWrite(yellowPin, 255);
    delay(100);
    analogWrite(greenPin, 255);
    delay(100);
    analogWrite(bluePin, 255);
    delay(100);
    analogWrite(whitePin, 255);
    delay(100);
    analogWrite(whitePin, 0);
    delay(100);
    analogWrite(bluePin, 0);
    delay(100);
    analogWrite(greenPin, 0);
    delay(100);
    analogWrite(yellowPin, 0);
    delay(100);
    analogWrite(redPin, 0);
    delay(100);
  }

// Key 5: Breathing - Fade in and out in a smooth, continuous pattern
  if (key5) {
    // Fade in
    for (int brightness = 0; brightness <= 255; brightness++) {
      analogWrite(redPin, brightness);
      analogWrite(yellowPin, brightness);
      analogWrite(greenPin, brightness);
      analogWrite(bluePin, brightness);
      analogWrite(whitePin, brightness);
      delay(10); // Adjust the delay for the desired breathing speed
    }

    // Fade out
    for (int brightness = 255; brightness >= 0; brightness--) {
      analogWrite(redPin, brightness);
      analogWrite(yellowPin, brightness);
      analogWrite(greenPin, brightness);
      analogWrite(bluePin, brightness);
      analogWrite(whitePin, brightness);
      delay(10); // Adjust the delay for the desired breathing speed
    }
  }

  // Key 6: Strobing - Rapid blinking of all LEDs at a high frequency
  if (key6) {
    for (int i = 0; i < 10; i++) { // Adjust the number of strobe cycles
      analogWrite(redPin, 255);
      analogWrite(yellowPin, 255);
      analogWrite(greenPin, 255);
      analogWrite(bluePin, 255);
      analogWrite(whitePin, 255);
      delay(50); // Adjust the delay for the desired strobe rate
      analogWrite(redPin, 0);
      analogWrite(yellowPin, 0);
      analogWrite(greenPin, 0);
      analogWrite(bluePin, 0);
      analogWrite(whitePin, 0);
      delay(50); // Adjust the delay for the desired strobe rate
    }
  }

  // Key 7: Twinkling - Random LEDs twinkle on and off
  if (key7) {
    // Implement the twinkling effect logic here
    // Example: Randomly turn on and off individual LEDs with varying delays
    int randomLED = random(5); // Generate a random number between 0 and 4
    int randomDelay = random(100, 500); // Generate a random delay between 100 and 500 ms

    switch (randomLED) {
      case 0:
        analogWrite(redPin, 255);
        break;
      case 1:
        analogWrite(yellowPin, 255);
        break;
      case 2:
        analogWrite(greenPin, 255);
        break;
      case 3:
        analogWrite(bluePin, 255);
        break;
      case 4:
        analogWrite(whitePin, 255);
        break;
    }

    delay(randomDelay);

    analogWrite(redPin, 0);
    analogWrite(yellowPin, 0);
    analogWrite(greenPin, 0);
    analogWrite(bluePin, 0);
    analogWrite(whitePin, 0);
  }

  // Key 8: Larson Scanner (Knight Rider) - A sequence of LEDs that sweeps back and forth
  if (key8) {
    // Implement the Larson Scanner effect logic here
    // Example: Sweep a single LED back and forth across the LEDs
    analogWrite(redPin, 255);
    delay(100);
    analogWrite(redPin, 0);
    analogWrite(yellowPin, 255);
    delay(100);
    analogWrite(yellowPin, 0);
    analogWrite(greenPin, 255);
    delay(100);
    analogWrite(greenPin, 0);
    analogWrite(bluePin, 255);
    delay(100);
    analogWrite(bluePin, 0);
    analogWrite(whitePin, 255);
    delay(100);
    analogWrite(whitePin, 0);
    analogWrite(bluePin, 255);
    delay(100);
    analogWrite(bluePin, 0);
    analogWrite(greenPin, 255);
    delay(100);
    analogWrite(greenPin, 0);
    analogWrite(yellowPin, 255);
    delay(100);
    analogWrite(yellowPin, 0);
    analogWrite(redPin, 255);
    delay(100);
    analogWrite(redPin, 0);
  }

  // Key 9: Wave - A wave-like pattern that moves across the LEDs
  if (key9) {
    // Implement the wave effect logic here
    // Example: Create a wave pattern by fading in and out LEDs in a sequence
    analogWrite(redPin, 255);
    delay(100);
    analogWrite(yellowPin, 255);
    analogWrite(redPin, 0);
    delay(100);
    analogWrite(greenPin, 255);
    analogWrite(yellowPin, 0);
    delay(100);
    analogWrite(bluePin, 255);
    analogWrite(greenPin, 0);
    delay(100);
    analogWrite(whitePin, 255);
    analogWrite(bluePin, 0);
    delay(100);
    analogWrite(whitePin, 0);
    analogWrite(redPin, 255);
    delay(100);
  }
}