//***************************************************************//
//  Name    : Stagevalot, kirkkaat takavalot                     //
//  Author  : Jussi Kemppinen                                    //
//  Date    : 26.3.2015                                          //
//  Version : 0.2                                                //
//  Notes   : 74HC595 siirtorekisteriohjaus valoille             //
//                                                               //
//***************************************************************//

//Kirjastot//
#include <TrueRandom.h>
//Kirjastot//

//LatchPin//
int latchPin = 8;
//ClockPin//
int clockPin = 12;
//DataPin//
int dataPin = 11;

//Pinnien määritys//
int flashPin = 6;
int stroboPin = 5;
int chaosPin = 4;
int kittPin = 3;
int shiftPin = 7;
int snakePin = 9;
int sensorPin = A2;
//Pinnien määritys//

//Säätömuuttujat//
int sensorValue = 0;
int outputValue = 0;
//Säätömuuttujat//


byte data = 0;

//Knight Rider -array//
int ledOn2[]={1,2,4,8,16,32,64,128,0,0,0,0, 0, 0, 0,  0, 0, 0, 0,0,0,0,0,128,64,32,16,8,4,2,1};
int ledOn1[]={0,0,0,0, 0, 0, 0,  0,1,2,4,8,16,32,64,128,64,32,16,8,4,2,1,  0, 0, 0, 0,0,0,0,0};
//Knight Rider-array//

byte randomByte2;
byte randomByte1;
byte snake2 = B00000000;
byte snake = B00000011;

void setup() {

//Pinnikonfiguraatiot//
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(flashPin, INPUT_PULLUP);
  pinMode(stroboPin, INPUT_PULLUP);
  pinMode(chaosPin, INPUT_PULLUP);
  pinMode(kittPin, INPUT_PULLUP);
  pinMode(shiftPin, INPUT_PULLUP);
  pinMode(snakePin, INPUT_PULLUP);
  pinMode(A2, INPUT);
//Pinnikonfiguraatiot//

//Aloita sarjayhteys debuggausta varten//
  Serial.begin(9600);
//Aloita sarjayhteys debuggausta varten//

}

void loop() {

//Kaikki LEDit päälle nappia painettaessa//
 if (digitalRead(flashPin) == LOW)
   {
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, B11111111);
    shiftOut(dataPin, clockPin, B11111111);
    digitalWrite(latchPin, 1);
   }
//Kaikki LEDit päälle nappia painettaessa//

//Puolet LEDeistä päälle ==> shift//
 else if (digitalRead(shiftPin) == LOW)
   {
     speed();
     digitalWrite(latchPin, 0);
     shiftOut(dataPin, clockPin, B10101010);
     shiftOut(dataPin, clockPin, B10101010);
     digitalWrite(latchPin, 1);
     delay(outputValue);
     digitalWrite(latchPin, 0);
     shiftOut(dataPin, clockPin, B01010101);
     shiftOut(dataPin, clockPin, B01010101);
     digitalWrite(latchPin, 1);
     delay(outputValue);
   }
//Puolet LEDeistä päälle ==> shift//

//Vilkuta kaikkia LEDejä halutulla nopeudella//
 else if (digitalRead(stroboPin) == LOW)
  {
    speed();
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, 255);
    shiftOut(dataPin, clockPin, 255);
    digitalWrite(latchPin, 1);
    delay(outputValue);
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, 0);
    shiftOut(dataPin, clockPin, 0);
    digitalWrite(latchPin, 1);
    delay(outputValue);
  }
//Vilkuta kaikkia LEDejä halutulla nopeudella//

//Knight Rider -animaatio halutulla nopeudella/säädöllä//
 else if (digitalRead(kittPin) == LOW)
 {
  for (int i = 0; i < 31; i++)
  {
    speed();
    digitalWrite(latchPin, LOW);
    shiftOut(ledOn2[i]);
    shiftOut(ledOn1[i]);
    digitalWrite(latchPin, HIGH);
    delay(outputValue);
  }
 }
//Knight Rider -animaatio halutulla nopeudella/säädöllä//

//Snake, säädettävä//
  else if (digitalRead(snakePin) == LOW)
  {
    speed();
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, snake2);
    shiftOut(dataPin, clockPin, snake);
    digitalWrite(latchPin, HIGH);
    delay(outputValue);
  }
//Snake, säädettävä//

//Kaaos-efekti. Random seed otetaan potikasta/kohinasta portissa//
  else if (digitalRead(chaosPin) == LOW)
  {
    speed();
    randomByte2 = TrueRandom.randomByte();
    randomByte1 = TrueRandom.randomByte();
    digitalWrite(latchPin, LOW);
    shiftOut(randomByte2);
    shiftOut(randomByte1);
    digitalWrite(latchPin, HIGH);
    delay(outputValue);
  }
//Kaaos-efekti. Random seed otetaan potikasta/kohinasta portissa//


//Jos nappeja ei paineta, sammutetaan kaikki LEDit//
 else
 {
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin, 0);
   shiftOut(dataPin, clockPin, 0);
   digitalWrite(latchPin, 1);
  }
//Jos nappeja ei paineta, sammutetaan kaikki LEDit//

}

void shiftOut(byte dataOut)
{
  // Shift out 8 bits LSB first,
  // on rising edge of clock
  boolean pinState;
  //clear shift register ready for sending data
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, LOW);
  // for each bit in dataOut send out a bit
  for (int i=0; i<=7; i++)
  {
    //set clockPin to LOW prior to sending bit
    digitalWrite(clockPin, LOW);
    // if the value of DataOut and (logical AND) a bitmask
    // are true, set pinState to 1 (HIGH)
    if ( dataOut & (1<<i) )
      {
        pinState = HIGH;
      }
    else
      {
        pinState = LOW;
      }
  //sets dataPin to HIGH or LOW depending on pinState
  digitalWrite(dataPin, pinState);
  //send bit out on rising edge of clock
  digitalWrite(clockPin, HIGH);
  }

//stop shifting out data
digitalWrite(clockPin, LOW);
}

// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
  // This shifts 8 bits out MSB first,
  //on the rising edge of the clock,
  //clock idles low

  //internal function setup
  int i=0;
  int pinState;
  pinMode(myClockPin, OUTPUT);
  pinMode(myDataPin, OUTPUT);

  //clear everything out just in case to
  //prepare shift register for bit shifting
  digitalWrite(myDataPin, 0);
  digitalWrite(myClockPin, 0);

  //for each bit in the byte myDataOut�
  //NOTICE THAT WE ARE COUNTING DOWN in our for loop
  //This means that %00000001 or "1" will go through such
  //that it will be pin Q0 that lights.
  for (i=7; i>=0; i--)  {
    digitalWrite(myClockPin, 0);

    //if the value passed to myDataOut and a bitmask result
    // true then... so if we are at i=6 and our value is
    // %11010100 it would the code compares it to %01000000
    // and proceeds to set pinState to 1.
    if ( myDataOut & (1<<i) ) {
      pinState= 1;
    }
    else {
      pinState= 0;
    }

    //Sets the pin to HIGH or LOW depending on pinState
    digitalWrite(myDataPin, pinState);
    //register shifts bits on upstroke of clock pin
    digitalWrite(myClockPin, 1);
    //zero the data pin after shift to prevent bleed through
    digitalWrite(myDataPin, 0);
  }

  //stop shifting
  digitalWrite(myClockPin, 0);
}


//blinks both registers based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
  digitalWrite(latchPin, 0);
  shiftOut(dataPin, clockPin, 0);
  shiftOut(dataPin, clockPin, 0);
  digitalWrite(latchPin, 1);
  delay(200);
  for (int x = 0; x < n; x++) {
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, 255);
    shiftOut(dataPin, clockPin, 255);
    digitalWrite(latchPin, 1);
    delay(d);
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, 0);
    shiftOut(dataPin, clockPin, 0);
    digitalWrite(latchPin, 1);
    delay(d);
  }
}

// SÄÄTÖNUPPIEN FUNKTIOT //

void speed()
{
  sensorValue = analogRead(sensorPin);
  outputValue = map(sensorValue, 0, 1023, 0, 500);

  // Debuggaukseen //
  Serial.print("Sensor = " );
  Serial.print(sensorValue);
  Serial.print("\t Output =");
  Serial.println(outputValue);

  // Jos liikaa, vaihda //
  delay(2);
}