#include <SoftPWM.h>
#include <SoftPWM_timer.h>


#define AmpelGr 27
#define AmpelGe 25
#define AmpelRo 23

#define Hupe 29

#define eins_a 7
#define eins_b 3
#define eins_c 11
#define eins_d 12
#define eins_e 6
#define eins_f 9
#define eins_g 4

#define zwei_a 8
#define zwei_b 52
#define zwei_c 51
#define zwei_d 13
#define zwei_e 5
#define zwei_f 10
#define zwei_g 53

#define drei_a 48
#define drei_b 47
#define drei_c 43
#define drei_d 49
#define drei_e 46
#define drei_f 50
#define drei_g 45

#define A 41
#define B 39
#define C 35
#define D 37


void setup()
{
  // put your setup code here, to run once:
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);

  pinMode(Hupe, OUTPUT);
  digitalWrite(Hupe, LOW);

  pinMode(AmpelGr, OUTPUT);
  pinMode(AmpelGe, OUTPUT);
  pinMode(AmpelRo, OUTPUT);


  pinMode(zwei_a, OUTPUT);
  pinMode(zwei_d, OUTPUT);
  pinMode(zwei_e, OUTPUT);
  pinMode(zwei_g, OUTPUT);

  pinMode(drei_a, OUTPUT);
  pinMode(drei_b, OUTPUT);
  pinMode(drei_c, OUTPUT);
  pinMode(drei_d, OUTPUT);
  pinMode(drei_e, OUTPUT);
  pinMode(drei_f, OUTPUT);
  pinMode(drei_g, OUTPUT);

  SoftPWMBegin();

  SoftPWMSet(A, 0);
  SoftPWMSet(B, 0);
  SoftPWMSet(C, 0);
  SoftPWMSet(D, 0);

  SoftPWMSet(AmpelGr, 0);
  SoftPWMSet(AmpelGe, 0);
  SoftPWMSet(AmpelRo, 0);

  SoftPWMSet(eins_f, 0);

  SoftPWMSet(zwei_b, 0);
  SoftPWMSet(zwei_c, 0);
  SoftPWMSet(zwei_g, 0);
  SoftPWMSet(zwei_f, 0);
  

  SoftPWMSet(drei_a, 0);
  SoftPWMSet(drei_b, 0);
  SoftPWMSet(drei_c, 0);
  SoftPWMSet(drei_d, 0);
  SoftPWMSet(drei_e, 0);
  SoftPWMSet(drei_f, 0);
  SoftPWMSet(drei_g, 0);

  SoftPWMSetFadeTime(ALL, 0, 0);

  Serial1.begin(9600); //Funk!!!
  Serial.begin(9600);
  

  Helligkeit(0);

}
int i = 0;

void loop()
{
  SerialEvent();
}

int RxBytes[100];
int RxBytes_alt[10];
unsigned long lastTime = 0;
int ii = 0;

void SerialEvent()
{

  while(Serial1.available() > 0)
  { 
    if((unsigned long)(millis() - lastTime) > 20)
    {
      ii = 0;
    }   
    delayMicroseconds(500);
    RxBytes[ii] = (int)Serial1.read();
    ii++; 
    lastTime = millis();
  }

  if(ii == 6)
  { 
    RxBytes[5] = RxBytes[5];  
    
    ii= 0;
    
    int Zeit = RxBytes[0] * 256 + RxBytes[1];
    int Zeit_alt = RxBytes_alt[0] * 256 + RxBytes_alt[1];
    
    if(Zeit <= 999)
    {   
      
      //Zeit Anzeige
      if(Zeit / 100 != Zeit_alt /100 || RxBytes[5] != RxBytes_alt[5])
      {
        Zahl_eins(0);
        Zahl(Zeit / 100, 1, RxBytes[5]);
      }
      
      if((Zeit % 100) / 10 != (Zeit_alt % 100) / 10 || RxBytes[5] != RxBytes_alt[5])
      {
        Zahl_zwei(0);
        Zahl((Zeit % 100) / 10, 2, RxBytes[5]);
      }
      if(Zeit % 10 != Zeit_alt % 10 || RxBytes[5] != RxBytes_alt[5])
      {
        Zahl_drei(0);
        Zahl(Zeit % 10, 3, RxBytes[5]);
      }
      
      //A B C D
      if(RxBytes[3] != RxBytes_alt[3] || RxBytes[5] != RxBytes_alt[5])
      {
        switch(RxBytes[3])
        {    
          case 1:
              SoftPWMSetPercent(A, RxBytes[5]);
              SoftPWMSetPercent(B, RxBytes[5]);
              SoftPWMSetPercent(C, 0);
              SoftPWMSetPercent(D, 0);
              break;
          case 2:
              SoftPWMSetPercent(A, 0);
              SoftPWMSetPercent(B, 0);
              SoftPWMSetPercent(C, RxBytes[5]);
              SoftPWMSetPercent(D, RxBytes[5]);
              break;
          case 3:
              SoftPWMSetPercent(A, RxBytes[5]);
              SoftPWMSetPercent(B, RxBytes[5]);
              SoftPWMSetPercent(C, RxBytes[5]);
              SoftPWMSetPercent(D, 0);
              break;
          default:
              SoftPWMSetPercent(A, 0);
              SoftPWMSetPercent(B, 0);
              SoftPWMSetPercent(C, 0);
              SoftPWMSetPercent(D, 0);
              break;
        }
      }

      Serial.println(RxBytes[4]);

      //Hupe
      switch(RxBytes[4])
      {
        case 1:
            digitalWrite(Hupe, HIGH);
            break;
        default:
            digitalWrite(Hupe, LOW);
            break;
      }
  
      //Ampel
      if(RxBytes[2] != RxBytes_alt[2] || RxBytes[5] != RxBytes_alt[5])
      {
        switch(RxBytes[2])
        {
          case 1:
              SoftPWMSetPercent(AmpelRo, RxBytes[5]);
              SoftPWMSetPercent(AmpelGe, 0);
              SoftPWMSetPercent(AmpelGr, 0);
              break;
          case 2:
              SoftPWMSetPercent(AmpelRo, 0);
              SoftPWMSetPercent(AmpelGe, 0);
              SoftPWMSetPercent(AmpelGr, RxBytes[5]);
              break;
          case 3:
              SoftPWMSetPercent(AmpelRo, 0);
              SoftPWMSetPercent(AmpelGe, RxBytes[5] * 0.75);
              SoftPWMSetPercent(AmpelGr, 0);
              break;
          case 254:
              Helligkeit(0);
              for(int f = 0; f < 6; f++)
              {
                RxBytes[f] = 0; 
              }
              break;
          case 255:
              Helligkeit(60);
              break;  
          default:
              SoftPWMSetPercent(AmpelRo, 0);
              SoftPWMSetPercent(AmpelGe, 0);
              SoftPWMSetPercent(AmpelGr, 0);
              break;                
        }
      }
      ii = 0;

      for(int j = 0; j < 6; j++)
      {
        RxBytes_alt[j] = RxBytes[j];
      }
    }
  }

}

void Zahl_eins(int Level)
{
    int LevelAnalog = Level * 255 / 100;
  
  analogWrite(eins_a, LevelAnalog); 
  analogWrite(eins_b, LevelAnalog); 
  analogWrite(eins_c, LevelAnalog);
  analogWrite(eins_d, LevelAnalog);
  analogWrite(eins_e, LevelAnalog);
  SoftPWMSetPercent(eins_f, Level);
  analogWrite(eins_g, LevelAnalog);
}

void Zahl_zwei(int Level)
{
  int LevelAnalog = Level * 255 / 100;
  
  analogWrite(zwei_a, LevelAnalog);
  SoftPWMSetPercent(zwei_b, Level);
  SoftPWMSetPercent(zwei_c, Level);
  analogWrite(zwei_d, LevelAnalog);
  analogWrite(zwei_e, LevelAnalog);;
  SoftPWMSetPercent(zwei_f, Level);
  SoftPWMSetPercent(zwei_g, Level);
}

void Zahl_drei(int Level)
{
  SoftPWMSetPercent(drei_a, Level);
  SoftPWMSetPercent(drei_b, Level);
  SoftPWMSetPercent(drei_c, Level);
  SoftPWMSetPercent(drei_d, Level);
  SoftPWMSetPercent(drei_e, Level);
  SoftPWMSetPercent(drei_f, Level);
  SoftPWMSetPercent(drei_g, Level);
}


void Helligkeit(int Level)
{
  int LevelAnalog = Level * 255 / 100;
  
  SoftPWMSetPercent(A, Level);
  SoftPWMSetPercent(B, Level);
  SoftPWMSetPercent(C, Level);
  SoftPWMSetPercent(D, Level);

  SoftPWMSetPercent(AmpelGr, Level);
  SoftPWMSetPercent(AmpelGe, Level * 0.75);
  SoftPWMSetPercent(AmpelRo, Level);

  analogWrite(eins_a, LevelAnalog); 
  analogWrite(eins_b, LevelAnalog); 
  analogWrite(eins_c, LevelAnalog);
  analogWrite(eins_d, LevelAnalog);
  analogWrite(eins_e, LevelAnalog);
  SoftPWMSetPercent(eins_f, Level);
  analogWrite(eins_g, LevelAnalog);

  analogWrite(zwei_a, LevelAnalog);
  SoftPWMSetPercent(zwei_b, Level);
  SoftPWMSetPercent(zwei_c, Level);
  analogWrite(zwei_d, LevelAnalog);
  analogWrite(zwei_e, LevelAnalog);;
  SoftPWMSetPercent(zwei_f, Level);
  SoftPWMSetPercent(zwei_g, Level);

  SoftPWMSetPercent(drei_a, Level);
  SoftPWMSetPercent(drei_b, Level);
  SoftPWMSetPercent(drei_c, Level);
  SoftPWMSetPercent(drei_d, Level);
  SoftPWMSetPercent(drei_e, Level);
  SoftPWMSetPercent(drei_f, Level);
  SoftPWMSetPercent(drei_g, Level);
}

void Zahl(int Zahl, int Display , int Helligkeit)
{
   int Level = Helligkeit * 255 / 100; 
   
  if(Display == 1)
  {
    switch(Zahl)
    {
      case 0:
        analogWrite(eins_a, Level);
        analogWrite(eins_b, Level);
        analogWrite(eins_c, Level);
        analogWrite(eins_d, Level);
        analogWrite(eins_e, Level);
        SoftPWMSetPercent(eins_f, Helligkeit);
        break;

      case 1:
        analogWrite(eins_b, Level);
        analogWrite(eins_c, Level);    
        break;  

      case 2:
        analogWrite(eins_a, Level);
        analogWrite(eins_b, Level);
        analogWrite(eins_d, Level);
        analogWrite(eins_e, Level);
        analogWrite(eins_g, Level);
        break;

      case 3:
        analogWrite(eins_a, Level);
        analogWrite(eins_b, Level);
        analogWrite(eins_c, Level);
        analogWrite(eins_d, Level);
        analogWrite(eins_g, Level);
        break;

      case 4:
        analogWrite(eins_b, Level);
        analogWrite(eins_c, Level);
        analogWrite(eins_g, Level);
        SoftPWMSetPercent(eins_f, Helligkeit);
        break;

      case 5: 
        analogWrite(eins_a, Level);
        analogWrite(eins_c, Level);
        analogWrite(eins_d, Level);
        analogWrite(eins_g, Level);
        SoftPWMSetPercent(eins_f, Helligkeit);
        break;

      case 6:
        analogWrite(eins_a, Level);
        analogWrite(eins_g, Level);
        analogWrite(eins_c, Level);
        analogWrite(eins_d, Level);
        analogWrite(eins_e, Level);
        SoftPWMSetPercent(eins_f, Helligkeit);
        break;

      case 7:
        analogWrite(eins_a, Level);
        analogWrite(eins_b, Level);
        analogWrite(eins_c, Level);
        break;

      case 8:
        analogWrite(eins_a, Level);
        analogWrite(eins_b, Level);
        analogWrite(eins_c, Level);
        analogWrite(eins_d, Level);
        analogWrite(eins_e, Level);
        SoftPWMSetPercent(eins_f, Helligkeit);
        analogWrite(eins_g, Level);
        break;

      case 9:
        analogWrite(eins_a, Level);
        analogWrite(eins_b, Level);
        analogWrite(eins_c, Level);
        analogWrite(eins_d, Level);
        SoftPWMSetPercent(eins_f, Helligkeit);
        analogWrite(eins_g, Level);
        break;
    }
  }

  if(Display == 2)
  {
    switch(Zahl)
    {
      case 0:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_b, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        analogWrite(zwei_d, Level);
        analogWrite(zwei_e, Level);
        SoftPWMSetPercent(zwei_f, Helligkeit);
        break;

      case 1:
        SoftPWMSetPercent(zwei_b, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        break;  

      case 2:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_b, Helligkeit);
        analogWrite(zwei_d, Level);
        analogWrite(zwei_e, Level);
        SoftPWMSetPercent(zwei_g, Helligkeit);
        break;

      case 3:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_b, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        analogWrite(zwei_d, Level);
        SoftPWMSetPercent(zwei_g, Helligkeit);
        break;

      case 4:
        SoftPWMSetPercent(zwei_b, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        SoftPWMSetPercent(zwei_g, Helligkeit);
        SoftPWMSetPercent(zwei_f, Helligkeit);
        break;

      case 5:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        analogWrite(zwei_d, Level);
        SoftPWMSetPercent(zwei_g, Helligkeit);
        SoftPWMSetPercent(zwei_f, Helligkeit);
        break;

      case 6:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_g, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        analogWrite(zwei_d, Level);
        analogWrite(zwei_e, Level);
        SoftPWMSetPercent(zwei_f, Helligkeit);
        break;

      case 7:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_b, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        break;

      case 8:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_b, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        analogWrite(zwei_d, Level);
        analogWrite(zwei_e, Level);
        SoftPWMSetPercent(zwei_f, Helligkeit);
        SoftPWMSetPercent(zwei_g, Helligkeit);
        break;

      case 9:
        analogWrite(zwei_a, Level);
        SoftPWMSetPercent(zwei_b, Helligkeit);
        SoftPWMSetPercent(zwei_c, Helligkeit);
        analogWrite(zwei_d, Level);
        SoftPWMSetPercent(zwei_g, Helligkeit);
        SoftPWMSetPercent(zwei_f, Helligkeit);
        break;
    }
    
  }

  if(Display == 3)
  {
    switch(Zahl)
    {
      case 0:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
          SoftPWMSetPercent(drei_d, Helligkeit);
          SoftPWMSetPercent(drei_e, Helligkeit);
          SoftPWMSetPercent(drei_f, Helligkeit);
        break;

      case 1:
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
        break;  

      case 2:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_d, Helligkeit);
          SoftPWMSetPercent(drei_e, Helligkeit);
          SoftPWMSetPercent(drei_g, Helligkeit);
        break;

      case 3:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
          SoftPWMSetPercent(drei_d, Helligkeit);
          SoftPWMSetPercent(drei_g, Helligkeit);
        break;

      case 4:
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
          SoftPWMSetPercent(drei_f, Helligkeit);
          SoftPWMSetPercent(drei_g, Helligkeit);
        break;

      case 5:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
          SoftPWMSetPercent(drei_d, Helligkeit);
          SoftPWMSetPercent(drei_f, Helligkeit);
          SoftPWMSetPercent(drei_g, Helligkeit);
        break;

      case 6:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
          SoftPWMSetPercent(drei_d, Helligkeit);
          SoftPWMSetPercent(drei_e, Helligkeit);
          SoftPWMSetPercent(drei_f, Helligkeit);
          SoftPWMSetPercent(drei_g, Helligkeit);
        break;

      case 7:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
        break;

      case 8:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
          SoftPWMSetPercent(drei_d, Helligkeit);
          SoftPWMSetPercent(drei_e, Helligkeit);
          SoftPWMSetPercent(drei_f, Helligkeit);
          SoftPWMSetPercent(drei_g, Helligkeit);
        break;

      case 9:
          SoftPWMSetPercent(drei_a, Helligkeit);
          SoftPWMSetPercent(drei_b, Helligkeit);
          SoftPWMSetPercent(drei_c, Helligkeit);
          SoftPWMSetPercent(drei_d, Helligkeit);
          SoftPWMSetPercent(drei_f, Helligkeit);
          SoftPWMSetPercent(drei_g, Helligkeit);
        break;
    }
  }
}