const byte PinBut1 = A1; // Button 1 pin
const byte PinBut2 = A2; // Button 2 pin
const byte PinBut3 = A3; // Button 3 pin
const byte PinBut4 = A4; // Button 4 pin

const byte PinLed1 = 10; // LED 1 pin
const byte PinLed2 = 11; // LED 2 pin
const byte PinLed3 = 6; // LED 3 pin
const byte PinLed4 = 9; // LED 4 pin

byte butLst1; // Last state of Button 1
byte butLst2; // Last state of Button 2
byte butLst3; // Last state of Button 3
byte butLst4; // Last state of Button 4

const unsigned long MsecPeriod0 = 1000;
const unsigned long MsecPeriod1 = 100;
unsigned long msecPeriod1; // Period for LED 1
unsigned long msecPeriod2; // Period for LED 2
unsigned long msecPeriod3; // Period for LED 3
unsigned long msecPeriod4; // Period for LED 4
unsigned long msecLst1; // Last time LED 1 was updated
unsigned long msecLst2; // Last time LED 2 was updated
unsigned long msecLst3; // Last time LED 3 was updated
unsigned long msecLst4; // Last time LED 4 was updated

const int MaxLevel = 255;
int ledInc = 4; // Increment level (slower)
int ledLevel1 = 0; // Level for LED 1
int ledLevel2 = 0; // Level for LED 2
int ledLevel3 = 0; // Level for LED 3
int ledLevel4 = 0; // Level for LED 4
int ledDir1 = -1; // Direction for LED 1
int ledDir2 = -1; // Direction for LED 2
int ledDir3 = -1; // Direction for LED 3
int ledDir4 = -1; // Direction for LED 4

bool led1Timed; // Flag for LED 1 timer
bool led2Timed; // Flag for LED 2 timer
bool led3Timed; // Flag for LED 3 timer
bool led4Timed; // Flag for LED 4 timer

// -----------------------------------------------------------------------------
void loop(void)
{
    unsigned long msec = millis();

    // Check timer if active (msecPeriod set) for LED 1
    if (msecPeriod1 && msec - msecLst1 >= msecPeriod1)
    {
        // Reverse direction if initial timeout (MsecPeriod0)
        if (MsecPeriod0 == msecPeriod1)
            ledDir1 = -ledDir1;

        // Reset timer
        msecLst1 = msec;
        msecPeriod1 = MsecPeriod1;

        // Update level
        ledLevel1 += ledDir1 * ledInc;

        // Check if endpoints reached
        if (0 > ledLevel1)
        {
            ledLevel1 = 0;
            msecPeriod1 = 0;
        }
        else if (MaxLevel < ledLevel1)
        {
            ledLevel1 = MaxLevel;
            msecPeriod1 = 0;
        }

        // Update LED 1
        analogWrite(PinLed1, ledLevel1);

        // Set flag indicating timer active
        led1Timed = true;

        Serial.print("LED 1 Level: ");
        Serial.println(ledLevel1);
    }

    // Check timer if active (msecPeriod set) for LED 2
    if (msecPeriod2 && msec - msecLst2 >= msecPeriod2)
    {
        // Reverse direction if initial timeout (MsecPeriod0)
        if (MsecPeriod0 == msecPeriod2)
            ledDir2 = -ledDir2;

        // Reset timer
        msecLst2 = msec;
        msecPeriod2 = MsecPeriod1;

        // Update level
        ledLevel2 += ledDir2 * ledInc;

        // Check if endpoints reached
        if (0 > ledLevel2)
        {
            ledLevel2 = 0;
            msecPeriod2 = 0;
        }
        else if (MaxLevel < ledLevel2)
        {
            ledLevel2 = MaxLevel;
            msecPeriod2 = 0;
        }

        // Update LED 2
        analogWrite(PinLed2, ledLevel2);

        // Set flag indicating timer active
        led2Timed = true;

        Serial.print("LED 2 Level: ");
        Serial.println(ledLevel2);
    }

    // Check timer if active (msecPeriod set) for LED 3
    if (msecPeriod3 && msec - msecLst3 >= msecPeriod3)
    {
        // Reverse direction if initial timeout (MsecPeriod0)
        if (MsecPeriod0 == msecPeriod3)
            ledDir3 = -ledDir3;

        // Reset timer
        msecLst3 = msec;
        msecPeriod3 = MsecPeriod1;

        // Update level
        ledLevel3 += ledDir3 * ledInc;

        // Check if endpoints reached
        if (0 > ledLevel3)
        {
            ledLevel3 = 0;
            msecPeriod3 = 0;
        }
        else if (MaxLevel < ledLevel3)
        {
            ledLevel3 = MaxLevel;
            msecPeriod3 = 0;
        }

        // Update LED 3
        analogWrite(PinLed3, ledLevel3);

        // Set flag indicating timer active
        led3Timed = true;

        Serial.print("LED 3 Level: ");
        Serial.println(ledLevel3);
    }

    // Check timer if active (msecPeriod set) for LED 4
    if (msecPeriod4 && msec - msecLst4 >= msecPeriod4)
    {
        // Reverse direction if initial timeout (MsecPeriod0)
        if (MsecPeriod0 == msecPeriod4)
            ledDir4 = -ledDir4;

        // Reset timer
        msecLst4 = msec;
        msecPeriod4 = MsecPeriod1;

        // Update level
        ledLevel4 += ledDir4 * ledInc;

        // Check if endpoints reached
        if (0 > ledLevel4)
        {
            ledLevel4 = 0;
            msecPeriod4 = 0;
        }
        else if (MaxLevel < ledLevel4)
        {
            ledLevel4 = MaxLevel;
            msecPeriod4 = 0;
        }

        // Update LED 4
        analogWrite(PinLed4, ledLevel4);

        // Set flag indicating timer active
        led4Timed = true;

        Serial.print("LED 4 Level: ");
        Serial.println(ledLevel4);
    }

    // Check for button 1 press/release
    byte but1 = digitalRead(PinBut1);
    if (butLst1 != but1)
    {
        butLst1 = but1;
        delay(20); // Debounce

        if (LOW == but1)
        { // Button 1 pressed
            Serial.println("Button 1 pressed");
            msecPeriod1 = MsecPeriod0;
            msecLst1 = msec;
        }
        else if (!led1Timed)
        { // Before timer expired
            msecPeriod1 = 0; // Disable timer
            if (0 < ledLevel1)
            {
                Serial.println("Button 1 released, turning off LED 1");
                ledLevel1 = 0;
                ledDir1 = -1; // Timer will reverse direction
            }
            else
            {
                Serial.println("Button 1 released, turning on LED 1");
                ledLevel1 = MaxLevel;
                ledDir1 = 1;
            }
            analogWrite(PinLed1, ledLevel1);
        }
        else
        { // Disable timer
            Serial.println("Button 1 released");
            msecPeriod1 = 0;
            led1Timed = false;
        }
    }

    // Check for button 2 press/release
    byte but2 = digitalRead(PinBut2);
    if (butLst2 != but2)
    {
        butLst2 = but2;
        delay(20); // Debounce

        if (LOW == but2)
        { // Button 2 pressed
            Serial.println("Button 2 pressed");
            msecPeriod2 = MsecPeriod0;
            msecLst2 = msec;
        }
        else if (!led2Timed)
        { // Before timer expired
            msecPeriod2 = 0; // Disable timer
            if (0 < ledLevel2)
            {
                Serial.println("Button 2 released, turning off LED 2");
                ledLevel2 = 0;
                ledDir2 = -1; // Timer will reverse direction
            }
            else
            {
                Serial.println("Button 2 released, turning on LED 2");
                ledLevel2 = MaxLevel;
                ledDir2 = 1;
            }
            analogWrite(PinLed2, ledLevel2);
        }
        else
        { // Disable timer
            Serial.println("Button 2 released");
            msecPeriod2 = 0;
            led2Timed = false;
        }
    }

    // Check for button 3 press/release
    byte but3 = digitalRead(PinBut3);
    if (butLst3 != but3)
    {
        butLst3 = but3;
        delay(20); // Debounce

        if (LOW == but3)
        { // Button 3 pressed
            Serial.println("Button 3 pressed");
            msecPeriod3 = MsecPeriod0;
            msecLst3 = msec;
        }
        else if (!led3Timed)
        { // Before timer expired
            msecPeriod3 = 0; // Disable timer
            if (0 < ledLevel3)
            {
                Serial.println("Button 3 released, turning off LED 3");
                ledLevel3 = 0;
                ledDir3 = -1; // Timer will reverse direction
            }
            else
            {
                Serial.println("Button 3 released, turning on LED 3");
                ledLevel3 = MaxLevel;
                ledDir3 = 1;
            }
            analogWrite(PinLed3, ledLevel3);
        }
        else
        { // Disable timer
            Serial.println("Button 3 released");
            msecPeriod3 = 0;
            led3Timed = false;
        }
    }

    // Check for button 4 press/release
    byte but4 = digitalRead(PinBut4);
    if (butLst4 != but4)
    {
        butLst4 = but4;
        delay(20); // Debounce

        if (LOW == but4)
        { // Button 4 pressed
            Serial.println("Button 4 pressed");
            msecPeriod4 = MsecPeriod0;
            msecLst4 = msec;
        }
        else if (!led4Timed)
        { // Before timer expired
            msecPeriod4 = 0; // Disable timer
            if (0 < ledLevel4)
            {
                Serial.println("Button 4 released, turning off LED 4");
                ledLevel4 = 0;
                ledDir4 = -1; // Timer will reverse direction
            }
            else
            {
                Serial.println("Button 4 released, turning on LED 4");
                ledLevel4 = MaxLevel;
                ledDir4 = 1;
            }
            analogWrite(PinLed4, ledLevel4);
        }
        else
        { // Disable timer
            Serial.println("Button 4 released");
            msecPeriod4 = 0;
            led4Timed = false;
        }
    }
}

void setup(void)
{
    Serial.begin(9600);

    pinMode(PinBut1, INPUT_PULLUP);
    butLst1 = digitalRead(PinBut1);

    pinMode(PinBut2, INPUT_PULLUP);
    butLst2 = digitalRead(PinBut2);

    pinMode(PinBut3, INPUT_PULLUP);
    butLst3 = digitalRead(PinBut3);

    pinMode(PinBut4, INPUT_PULLUP);
    butLst4 = digitalRead(PinBut4);

    pinMode(PinLed1, OUTPUT);
    analogWrite(PinLed1, ledLevel1);

    pinMode(PinLed2, OUTPUT);
    analogWrite(PinLed2, ledLevel2);

    pinMode(PinLed3, OUTPUT);
    analogWrite(PinLed3, ledLevel3);

    pinMode(PinLed4, OUTPUT);
    analogWrite(PinLed4, ledLevel4);
}