#define max_lines 8
#define max_ref 32
bool dump = false;

int cycle = 0;  // loop zyklus
int dly = 100;
int pot = 1000;
int sensor = A0; // potentiometer für speed
int onoff = 0;
int swtch = 2;   // digitaler port für switch
int ch = 0;      // aktueller kanal
bool active = true;

// LEDs
byte LED_Port[7] = {3,5,6,9,10,11,12};
// commands
char cmd[max_lines] = {'U','Y','D','Y','U','Y','D','B'};
// up, delay, down, blink, wait

// parameter für commands
byte prm[max_lines][6] = {{0,1,10,10,10,0}, 
                  {0,2,100,0,0,0}, 
                  {0,3,20,5,5,0},
                  {0,4,100,0,0,0},
                  {1,5,5,20,5,0}, 
                  {1,6,100,0,0,0}, 
                  {1,7,5,20,5,0},
                  {1,8,7, 30,70,5} };
//UP/DOWN: channel,task#,cycles,steps,delay
//BLINK: channel,task#,anzahl blinken, range low, range high, delay

// command reference
byte cmdref[max_ref][7]; // 32 lines, 7 kanäle

// active register (7 channels, copy of active program line)
byte reg[7][6]; // 7 kanäle, 6 parameter pro kanal
char reg_cmd[7] = {' ',' ',' ',' ',' ',' ',' '};    // 7 kanäle, aktive commands
int  reg_wrk[7][3]; // Arbeitsregister



// ---------------------------------------------
void fetch() {
  cmdref[0][ch] = cmdref[0][ch]+1;       // inc program counter
  int ptr = 0;           // pointer to prm
  int lpc = 0;           // local program counter (cmdref)   
  lpc = cmdref[0][ch];   // wird aus cmdref geladen
  if (cmdref[lpc][ch] != 255) {
    ptr = cmdref[lpc][ch];   // referenz zu prm
    if (dump) {}
      Serial.print("fetch channel ");
      Serial.print(ch);
      Serial.print(" pc ");
      Serial.print(lpc);
      Serial.print(" Ref ");
      Serial.print(ptr);}
    reg[ch][0] = prm[ptr][0];
    reg[ch][1] = prm[ptr][1];
    reg[ch][2] = prm[ptr][2];
    reg[ch][3] = prm[ptr][3]; 
    reg[ch][4] = prm[ptr][4];
    reg[ch][5] = prm[ptr][5];
    reg[ch][6] = prm[ptr][6];

    reg_cmd[ch] = cmd[ptr];
    if (dump) {Serial.println(reg_cmd[ch]);}
    switch (reg_cmd[ch]) {
      case 'U':  // up
         reg_wrk[ch][0] = 0; // laufender cycle, ende bei wert lt prm
         break;
      case 'D':  // down
         reg_wrk[ch][0] =reg[ch][2] ; // laufender cycle, ende bei wert 0
         break;
      case 'Y':  // delay
         break;
      case 'B':  // blink
         break;
      case 'W':  // wait
         break;


  } // end switch
  } // end ptr != 255
  else {
    cmdref[0][ch] = 0;  // pc auf 0 zurüccksetzen
    reg_cmd[ch] = ' ';  // command auf leer
    if (dump) {Serial.println("ELSE ...");}
  }
  Serial.println("END FETCH ****************");
  dump_reg(ch);
  delay(dly);
}
// ---------------------------------------------
void execute() {
int poi;
int pwm;
if (dump) { 
   dump_cmdref();
   dump_cmd();
   Serial.print("execute channel ");
   Serial.println(ch);
   Serial.print("port:"); Serial.println(LED_Port[ch]);

   Serial.print("cmd:");Serial.println(reg_cmd[ch]);}
 switch (reg_cmd[ch]) {
    case 'U':  // up
       reg_wrk[ch][0]++; // laufender cycle, ende bei wert lt prm
          pwm = reg_wrk[ch][0] * reg[ch][3];
          if (dump) {Serial.print("pwm=");Serial.println(pwm);}
          analogWrite(LED_Port[ch],pwm);
       if (reg_wrk[ch][0] >= reg[ch][2]) { // task beenden
          reg_cmd[ch] = ' ';
       }
       break;
    case 'D':  // down
       reg_wrk[ch][0]--; // laufender cycle, ende bei wert 0
          pwm = reg_wrk[ch][0] * reg[ch][3];
          analogWrite(LED_Port[ch],pwm);
       if (reg_wrk[ch][0] <= 0) { // task beenden
          reg_cmd[ch] = ' ';
       }
      
       break;
    case 'Y':  // delay
       reg_cmd[ch] = ' ';
       delay(3000);
       break;
    case 'B':  // blink
       break;
    case 'W':  // wait
       break;


  } // end switch

  
   delay(dly);
  // delay(2000);
}
// ---------------------------------------------
void dump_cmdref() {
int line = 0;
int sp = 0;

Serial.println("Dump CMDREF ");
for (line = 0; line < max_lines; line++) {
   for (sp = 0;sp < 7; sp++){
     Serial.print(cmdref[line][sp]);
     Serial.print("-");
   }  // For sp
   Serial.println();

   }  // for line
}  // void

// ---------------------------------------------
void dump_cmd() {
int line = 0;
int sp = 0;

Serial.println("Dump CMD ");
for (line = 0; line < max_lines; line++) {

     Serial.println(cmd[line]);

   }  // for line
}  // void


// ---------------------------------------------
void dump_reg(int line) {
int i;
 
     Serial.print("Dump Line ");
     Serial.print(line);
     Serial.print(": ");
     Serial.print(reg_cmd[line]);
     Serial.print(":");
   for (i=0;i<7;i++){

      Serial.print(reg[line][i]);
      Serial.print("-");
   }
   Serial.println();
delay(dly);
}
// ---------------------------------------------
void dump_regcmd() {
int i = 0;
for (i=0;i<=6;i++){
  Serial.print("commands:");
  Serial.print(reg_cmd[i]);
  Serial.println();

}
}

// ---------------------------------------------
void loop_alt()
{
  Serial.println("LOOP");
  active = digitalRead(swtch);
  
  if (active) {Serial.print("HIGH");}
  pot = analogRead(sensor);
//  if (pot > 100) { active = true;}
//  if (pot <= 100) { active = false;}
  if (active) {
    LEDBlinken();}
}

// ---------------------------------------------
void LEDBlinken()  
{ 
  int i;
  int j;
  Serial.println("LED-Blinken");
  for (i=1; i<=7;i++) {
    for (j=1;j<=7;j++) {
      digitalWrite(j+1, LOW);
   }    
    digitalWrite(i+1, HIGH);
    pot = analogRead(sensor);
//    Serial.println(pot);
    delay(pot); 
    digitalWrite(8, LOW);

  } 
}

// ----------------------------------------
void init_xref() {
int line = 0;
int ch = 0;
int pc = 0;

if (dump) {Serial.println("init_xref");}
for (int i=0;i <=6; i++) {
//  Serial.print(".");
  cmdref[0][i]=0;  // alle PC auf 0 setzen
} // for
  if (dump) {Serial.println("init_xref cmdref auf 0");}
for (int i=1; i < max_ref; i++) {
   for (int j = 0; j < 7; j++) {
     cmdref[i][j] = 255;
     if (dump) {Serial.print(i);Serial.print("*");Serial.println(j);}
    }
  }

if (dump) {Serial.println("init_xref XREF erstellen");}

for (int x=0;x < max_lines;x++) { // xref schleife
  ch = prm[x][0];
  if (dump) {
    Serial.print(ch);
    Serial.print(".");
    Serial.print(x);
    Serial.println(); }
  
  if (ch != 255) {
      if (dump) {Serial.println("x-ref");}
    pc = cmdref[0][ch] + 1;
    cmdref[0][ch] = pc;
    cmdref[pc][ch] = x; 
  } // if
}  // for  
   for (int i=0; i<=6; i++) {
     cmdref[0][i] = 0; }
  if (dump) {Serial.println("init_xref ENDE");}
  dump_cmd();
delay(dly);
}


// ---------------------------------------------
void setup()
{
  Serial.begin(9600);
  for (int i=0;i<=6;i++) { // 7 LED 
    pinMode(LED_Port[i], OUTPUT); 
    analogWrite(LED_Port[i],0);
    reg_wrk[i][0] = 0;
    reg_wrk[i][1] = 0;
    reg_wrk[i][2] = 0; 
    reg_wrk[i][3] = 0;
    reg_cmd[i] = ' ';
  }
  pinMode(swtch, INPUT);

  init_xref();   // crossreferenz von prm nach cmdref

  active = digitalRead(swtch);


}

// ---------------------------------------------
void loop()
{
  cycle++;
  dump_cmdref();
  
  if (dump) {
    Serial.println("********* CYCLE ***************");
    Serial.println(cycle);
    Serial.println("********* CYCLE ***************");
  }
  
  if (dump) {dump_cmdref();}
  if (active){
     dump_regcmd();
     for (ch=0; ch<=6; ch++) {  // alle 7 channels bearbeiten
       if (dump) {dump_reg(0);
          Serial.print(ch);
          Serial.print("command:");
          Serial.println(reg_cmd[ch]);}
       if (reg_cmd[ch] == ' ') {
         fetch();                 
        }
        else {
          execute();               // execute channel ch
        }
     } // for
     Serial.println("*********** END LOOP ********************");
  } // if
  active = digitalRead(swtch);
} // loop