/* Welcome to DmxSimple. This library allows you to control DMX stage and
** architectural lighting and visual effects easily from Arduino. DmxSimple
** is compatible with the Tinker.it! DMX shield and all known DIY Arduino
** DMX control circuits.
**
** DmxSimple is available from: http://code.google.com/p/tinkerit/
** Help and support: http://groups.google.com/group/dmxsimple       */
#include <DmxSimple.h>
#include <Bounce2.h>

/*TODO
 * De-Bouncing
  If Auto-Programs running skip read buttons and trims - release when ? any old value != new value ?
*/

/* Beisp1: https://create.arduino.cc/projecthub/marcozonca/dmx-rgb-mixer-for-lights-cd60f6?ref=tag&ref_id=dmx&offset=5  */
/* Beisp2: https://www.kreativekiste.de/arduino-dmxsimple-einfache-dmx-steuerung-selber-bauen-tutorial  */
/* Beisp3: https://duino4projects.com/small-arduino-dmx-controller/  */

/*Change from false to true if you like to see Serial monitor showing you what happen when you are playing with controls*/
bool IS_DEBUG  = true;

/*Eurolight led b 40 laser strahleneffekt - 10 Channel Mode 4 - 13
  CH: 4 0-255 red 0-100%
  CH: 4 0-255 green 0-100%
  CH: 4 0-255 blue 0-100%
  CH: 4 0-255 white 0-100%
  CH: 5
  CH: 6 0-255 Masterdimmer 0-100%
  CH: 7 0-005 no function
  CH: 7 006-250 strobe with increasing speed
  CH: 7 251-255 msuic controlled strobe
  CH: 8 0-005 no function
  CH: 8 006-046 Laser red
  CH: 8 047-087 Laser green
  CH: 8 088-128 Laser red + green
  CH: 8 129-169 Laser red strobe + green
  CH: 8 170-210 Laser red + green strobe
  CH: 8 211-255 Laser red + green - strobe changing
  CH: 9 0-005 no function
  CH: 9 005-250 strobe freq. with increasing speed
  CH: 9 251-255 music controlled strobe
  CH:10 0-0 no function
  CH:10 001-127 backward rotation with increasing speed
  CH:10 128-128 stopp
  CH:10 129-255 forward rotation with increasing speed
*/

byte MaxChannel = 10;
/*#########################################################################*/

//bool isSTROBO = false;
//bool ledStroboOn = false;

//Pult
bool isPultActivated = false;
/*das Pult soll beim Einschalten erst einen Blackout auf alle Lichter senden
  die Variable wird über einen Button auf true gesetzt
*/
bool isAutoPrograms = false;
bool isShiftPressed = false;/*Ermöglich eine Doppelte Tastenbelegung - hier für 8 Auto-Progranme*/

//######### TX/RX PINS ######################
const byte TTL485Pin = 1; /*TX1 This and other lines to declare all input and output Arduino pins used in this project*/

//######### DIGITAL PINS ######################
#define ButtonA 2 //const int ButtonA = 2;//D2
#define ButtonB 3 //const int ButtonB = 3;//D3
//B40 Pin Belegung
#define Button1 4 //const int ButtonB40blackoutLED = 4;//D4
#define Button2 5 //const int ButtonB40blackoutLaser = 5;//D5
#define Button3 6 //const int ButtonB40soundtolightLED = 6;//D6
#define Button4 7 //const int ButtonB40soundtolightLaser = 7;//D7
#define Button5 8 //const int ButtonB40colordown = 8;//D8
#define Button6 9 //const int ButtonB40colorup = 9;//D9
#define Button7 12 //const int ButtonB40laserdown = 12; //D12
#define Button8 13 //const int ButtonB40laserup = 13; //D13

//LED
const int LED_A = 10;//D10=PWM Pin // bei Analogansteuerung: 21; //A0
const int LED_B =  11;//D11=PWM Pin // bei Analogansteuerung: 22;//A1
const int LEDbrightness = 100; //Helligkeit der LED

//######### ANALOG PINS ######################
const byte TrimB40dimmer = 22;//A2
const byte TrimB40strobeLEDfreq = 23;//A3
const byte TrimB40strobeLaserfreq = 24;//A4
const byte TrimB40rotate = 25;//A5
const byte TrimB40white = 26;//A6
const byte TrimB40blue = 27;//A7
const byte TrimB40green = 28;//A8
const byte TrimB40red = 29;//A9

//############################################

//Button On/Off
int lastButtonAstate = false;    // the previous state of button
int currentButtonAstate = false; // the current state of button
int lastButtonBstate = false;    // the previous state of button
int currentButtonBstate = false; // the current state of button

//B40
bool valB40blackoutLED = false;       bool prevvalB40blackoutLED = false;
bool valB40blackoutLaser = false;     bool prevvalB40blackoutLaser = false;
bool valB40soundtolightLED = false;   bool prevvalB40soundtolightLED = false;
bool valB40soundtolightLaser = false; bool prevvalB40soundtolightLaser = false;

const byte chOffsetB40 = 0;
const byte chB40red = 1 + chOffsetB40;          int valB40red = 0;                int prevvalB40red = 0;
const byte chB40green = 2 + chOffsetB40;        int valB40green = 0;              int prevvalB40green = 0;
const byte chB40blue = 3 + chOffsetB40;         int valB40blue = 0;               int prevvalB40blue = 0;
const byte chB40white = 4 + chOffsetB40;        int valB40white = 0;              int prevvalB40white = 0;
const byte chB40coloradjust = 5 + chOffsetB40;  int valB40coloradjust = 0;      int prevvalB40coloradjust = 0;
const byte chB40Masterdimmer = 6 + chOffsetB40; int valB40Masterdimmer = 0;     int prevvalB40Masterdimmer = 0;
const byte chB40StrobeLED = 7 + chOffsetB40;    int valB40StrobeLED = 0;        int prevvalB40StrobeLED = 0;
const byte chB40Laser = 8 + chOffsetB40;        int valB40Laser = 0;            int prevvalB40Laser = 0;
const byte chB40StrobeLaser = 9 + chOffsetB40;  int valB40StrobeLaser = 0;      int prevvalB40StrobeLaser = 0;
const byte chB40Rotation = 10 + chOffsetB40;    int valB40Rotation = 0;         int prevvalB40Rotation = 0;

const unsigned long refreshRate = 200;  // millis, lower this for a quicker response at changes
//const unsigned long ledStroboRate = 250;  // millis, change this for a different led blinking rate
const byte antiBouncing = 1;  // units, change this to 0 for a better granularity of changes
// but more rtx traffic, or increase to 2 if you experience jumping values

unsigned long lastRefresh = 0;  // millis
//unsigned long lastStrobo = 0;  // millis

Bounce debounceA = Bounce();
Bounce debounceB = Bounce();
Bounce debounce1 = Bounce();
Bounce debounce2 = Bounce();
Bounce debounce3 = Bounce();
Bounce debounce4 = Bounce();
Bounce debounce5 = Bounce();
Bounce debounce6 = Bounce();
Bounce debounce7 = Bounce();
Bounce debounce8 = Bounce();

void setup() {
  if (IS_DEBUG) Serial.begin(38400);
  DmxSimple.usePin(TTL485Pin);
  DmxSimple.maxChannel(MaxChannel);
  
  pinMode(ButtonA, INPUT_PULLUP);
  debounceA.attach(ButtonA,INPUT_PULLUP);
  debounceA.interval(25);
  
  pinMode(ButtonB, INPUT_PULLUP);
  debounceB.attach(ButtonB,INPUT_PULLUP);
  debounceB.interval(25);
  
  pinMode(Button1, INPUT_PULLUP);
  debounce1.attach(Button1,INPUT_PULLUP);
  debounce1.interval(25);
    
  pinMode(Button2, INPUT_PULLUP);
  debounce2.attach(Button2,INPUT_PULLUP);
  debounce2.interval(25);
    
  pinMode(Button3, INPUT_PULLUP);
  debounce3.attach(Button3,INPUT_PULLUP);
  debounce3.interval(25);
    
  pinMode(Button4, INPUT_PULLUP);
  debounce4.attach(Button4,INPUT_PULLUP);
  debounce4.interval(25);
   
  pinMode(Button5, INPUT_PULLUP);
  debounce5.attach(Button5,INPUT_PULLUP);
  debounce5.interval(25);
    
  pinMode(Button6, INPUT_PULLUP);
  debounce6.attach(Button6,INPUT_PULLUP);
  debounce6.interval(25);
     
  pinMode(Button7, INPUT_PULLUP);
  debounce7.attach(Button7,INPUT_PULLUP);
  debounce7.interval(25);
  
  pinMode(Button8, INPUT_PULLUP);
  debounce8.attach(Button8,INPUT_PULLUP);
  debounce8.interval(25);

  pinMode(TrimB40red, INPUT);
  pinMode(TrimB40green, INPUT);
  pinMode(TrimB40blue, INPUT);
  pinMode(TrimB40white, INPUT);
  pinMode(TrimB40rotate, INPUT);
  pinMode(TrimB40strobeLEDfreq, INPUT);
  pinMode(TrimB40strobeLaserfreq, INPUT);
  
  pinMode(LED_A, OUTPUT);
  pinMode(LED_B, OUTPUT);

  currentButtonAstate = digitalRead(ButtonA);
  currentButtonBstate = digitalRead(ButtonB);
  digitalRead(Button1);
  digitalRead(Button2);
  digitalRead(Button3);
  digitalRead(Button4);
  digitalRead(Button5);
  digitalRead(Button6);
  digitalRead(Button7);
  digitalRead(Button8);
  doBlackoutB40All();
}//setup

void loop() {
  debounceA.update(); // Update the Bounce instance
  debounceB.update();
  debounce1.update();
  debounce2.update();
  debounce3.update();
  debounce4.update();
  debounce5.update();
  debounce6.update();
  debounce7.update();
  debounce8.update();

  lastButtonAstate = currentButtonAstate;
  currentButtonAstate = debounceA.read();
  lastButtonBstate = currentButtonBstate;
  currentButtonBstate = debounceB.read();

  if(lastButtonAstate == HIGH && currentButtonAstate == LOW) {
    isPultActivated = !isPultActivated;
  }
  if(lastButtonBstate == HIGH && currentButtonBstate == LOW) {
    //isShiftPressed = !isShiftPressed;
    isAutoPrograms = !isAutoPrograms;
  }
  if (isPultActivated == false) isAutoPrograms = false;

  if (IS_DEBUG) Serial.print("On/Auto: ");
  if (IS_DEBUG) Serial.print(isPultActivated);
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.println(isAutoPrograms);
  //if (IS_DEBUG) Serial.print("isPultActivated: ");
  //if (IS_DEBUG) Serial.println(isPultActivated);
  //if (IS_DEBUG) Serial.print("isAutoPrograms: ");
  //if (IS_DEBUG) Serial.println(isAutoPrograms);
  //if (IS_DEBUG) Serial.print("isShiftPressed: ");
  //if (IS_DEBUG) Serial.println(isShiftPressed);

  //if (IS_DEBUG) Serial.println("Hello Arduino\n");
  //if (IS_DEBUG) Serial.print("ButtonA/B: ");
  //if (IS_DEBUG) Serial.print(digitalRead(2));//ButtonA
  //if (IS_DEBUG) Serial.print("/");
  //if (IS_DEBUG) Serial.println(digitalRead(3));//ButtonB

/*
  if (IS_DEBUG) Serial.print("buttons 1-8: ");
  if (IS_DEBUG) Serial.print(digitalRead(4));//ButtonB40blackoutLED
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.print(digitalRead(5));//ButtonB40blackoutLaser
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.print(digitalRead(6));//ButtonB40soundtolightLED
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.print(digitalRead(7));//ButtonB40soundtolightLaser
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.print(digitalRead(8));//ButtonB40colordown
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.print(digitalRead(9));//ButtonB40colorup
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.print(digitalRead(12));//ButtonB40laserdown
  if (IS_DEBUG) Serial.print("-");
  if (IS_DEBUG) Serial.print(digitalRead(13));//ButtonB40laserup
  if (IS_DEBUG) Serial.println("");
*/
/*
  if (IS_DEBUG) Serial.print("poti1: ");
  if (IS_DEBUG) Serial.println(analogRead(22));//TrimB40dimmer
  if (IS_DEBUG) Serial.print("poti2: ");
  if (IS_DEBUG) Serial.println(analogRead(23));//TrimB40strobeLEDfreq
  if (IS_DEBUG) Serial.print("poti3: ");
  if (IS_DEBUG) Serial.println(analogRead(24));//TrimB40strobeLaserfreq
  if (IS_DEBUG) Serial.print("poti4: ");
  if (IS_DEBUG) Serial.println(analogRead(25));//TrimB40rotate
  if (IS_DEBUG) Serial.print("poti5: ");
  if (IS_DEBUG) Serial.println(analogRead(26));//TrimB40white
  if (IS_DEBUG) Serial.print("poti6: ");
  if (IS_DEBUG) Serial.println(analogRead(27));//TrimB40blue
  if (IS_DEBUG) Serial.print("poti7: ");
  if (IS_DEBUG) Serial.println(analogRead(28));//TrimB40green
  if (IS_DEBUG) Serial.print("poti8: ");
  if (IS_DEBUG) Serial.println(analogRead(29));//TrimB40red
*/
  
  //readButtonA();


  //isPultActivated = true;
  
  if (isPultActivated == false) {
    doBlackoutB40All();
    analogWrite(LED_A, 0);
    analogWrite(LED_B, 0);
    return;
  } else {
    analogWrite(LED_A, LEDbrightness);
  }

  /*Check läuft ein AutoProgram*/
  if (isAutoPrograms == true) {
    readButtonsAutoPrograms();
    readTrimmers();
    analogWrite(LED_B, LEDbrightness);
    readTrimmerMaster();
    if ((lastRefresh + refreshRate) < millis()) {
      if ((valB40Masterdimmer < (prevvalB40Masterdimmer - antiBouncing)) || (valB40Masterdimmer > (prevvalB40Masterdimmer + antiBouncing))) {
        writeDMX(chB40Masterdimmer, valB40Masterdimmer);
        //if (IS_DEBUG) Serial.print("valB40Masterdimmer=");
        //if (IS_DEBUG) Serial.println(valB40Masterdimmer);
        prevvalB40Masterdimmer = valB40Masterdimmer;
      }
    }
    lastRefresh = millis();
    /*Damit die aktuellen Werte der Buttons und Trimmers nicht gelesen
      und damit die Programme überschreiben werden - ausser MasterDimmer*/
    return;
  } else {
    analogWrite(LED_B, 0);
  }

  /*Manuelle Steuerung*/
  readButtons();
  readTrimmers();

  if ((lastRefresh + refreshRate) < millis()) {
    if ((valB40Masterdimmer < (prevvalB40Masterdimmer - antiBouncing)) || (valB40Masterdimmer > (prevvalB40Masterdimmer + antiBouncing))) {
      writeDMX(chB40Masterdimmer, valB40Masterdimmer);
      //if (IS_DEBUG) Serial.print("valB40Masterdimmer=");
      //if (IS_DEBUG) Serial.println(valB40Masterdimmer);
      prevvalB40Masterdimmer = valB40Masterdimmer;
    }
    if ((valB40Rotation < (prevvalB40Rotation - antiBouncing)) || (valB40Rotation > (prevvalB40Rotation + antiBouncing))) {
      writeDMX(chB40Rotation, valB40Rotation);
      //if (IS_DEBUG) Serial.print("valB40Rotation=");
      //if (IS_DEBUG) Serial.println(valB40Rotation);
      prevvalB40Rotation = valB40Rotation;
    }
    if ((valB40StrobeLED < (prevvalB40StrobeLED - antiBouncing)) || (valB40StrobeLED > (prevvalB40StrobeLED + antiBouncing))) {
      writeDMX(chB40StrobeLED, valB40StrobeLED);
      //if (IS_DEBUG) Serial.print("valB40StrobeLED=");
      //if (IS_DEBUG) Serial.println(valB40StrobeLED);
      prevvalB40StrobeLED = valB40StrobeLED;
    }
    if ((valB40StrobeLaser < (prevvalB40StrobeLaser - antiBouncing)) || (valB40StrobeLaser > (prevvalB40StrobeLaser + antiBouncing))) {
      writeDMX(chB40StrobeLaser, valB40StrobeLaser);
      //if (IS_DEBUG) Serial.print("valB40StrobeLaser=");
      //if (IS_DEBUG) Serial.println(valB40StrobeLaser);
      prevvalB40StrobeLaser = valB40StrobeLaser;
    }
    lastRefresh = millis();
  }
}//loop

void blinkLed() {  // led blinking
  /* delay(250);
    if (ledStroboOn == false) {
    analogWrite(LedRPin, ValRed / 4);
    analogWrite(LedGPin, ValGreen / 4);
    analogWrite(LedBPin, ValBlue / 4);
    ledStroboOn = true;
    } else {
    analogWrite(LedRPin, 0);
    analogWrite(LedGPin, 0);
    analogWrite(LedBPin, 0);
    ledStroboOn = false;
    }
    lastStrobo = millis();
  */
}//blinkLed()

void readButtonsAutoPrograms() {
  //Special Auto-Programs Shift active
  if (debounce1.read() == LOW && isAutoPrograms == true) {
    doProgram01();
    if (IS_DEBUG) Serial.println("doProgram01");
  }
  if (debounce2.read() == LOW && isAutoPrograms == true) {
    doProgram02();
    if (IS_DEBUG) Serial.println("doProgram02");
  }
  if (debounce3.read() == LOW && isAutoPrograms == true) {
    doProgram03();
    if (IS_DEBUG) Serial.println("doProgram03");
  }
  if (debounce4.read() == LOW && isAutoPrograms == true) {
    doProgram04();
    if (IS_DEBUG) Serial.println("doProgram04");
  }
  if (debounce5.read() == LOW && isAutoPrograms == true) {
    doProgram05();
    if (IS_DEBUG) Serial.println("doProgram05");
  }
  if (debounce6.read() == LOW && isAutoPrograms == true) {
    doProgram06();
    if (IS_DEBUG) Serial.println("doProgram06");
  }
  if (debounce7.read() == LOW && isAutoPrograms == true) {
    doProgram07();
    if (IS_DEBUG) Serial.println("doProgram07");
  }
  if (debounce8.read() == LOW && isAutoPrograms == true) {
    doProgram08();
    if (IS_DEBUG) Serial.println("doProgram08");
  }
  //with Shift pressed
}

void readButtons() {
  //Standard without Shift pressed
  if (debounce1.read() == HIGH && isAutoPrograms == false) {
    if (valB40blackoutLED == false) {
      valB40blackoutLED = true;
      doBlackoutB40LED();
    } else {
      valB40blackoutLED = false;
      undoBlackoutB40LED();
    }
    //if (IS_DEBUG) Serial.print("valB40blackoutLED=");
    //if (IS_DEBUG) Serial.println(valB40blackoutLED);
  }
  if (debounce2.read() == HIGH && isAutoPrograms == false) {
    if (valB40blackoutLaser == false) {
      valB40blackoutLaser = true;
      doBlackoutB40Laser();
    } else {
      valB40blackoutLaser = false;
      undoBlackoutB40Laser();
    }
    //if (IS_DEBUG) Serial.print("valB40blackoutLaser=");
    //if (IS_DEBUG) Serial.println(valB40blackoutLaser);
  }
  if (debounce3.read() == HIGH && isAutoPrograms == false) {
    if (valB40soundtolightLED == false) {
      valB40soundtolightLED = true;
      writeDMX(chB40StrobeLED, 255);
    } else {
      valB40soundtolightLED = false;
      writeDMX(chB40StrobeLED, 0);
    }
    //if (IS_DEBUG) Serial.print("valB40soundtolightLED=");
    //if (IS_DEBUG) Serial.println(valB40soundtolightLED);
  }
  if (debounce4.read() == HIGH && isAutoPrograms == false) {
    if (valB40soundtolightLaser == false) {
      valB40soundtolightLaser = true;
      writeDMX(chB40StrobeLaser, 255);
    } else {
      valB40soundtolightLaser = false;
      writeDMX(chB40StrobeLaser, 0);
    }
    //if (IS_DEBUG) Serial.print("valB40soundtolightLaser=");
    //if (IS_DEBUG) Serial.println(valB40soundtolightLaser);
  }
  if (debounce5.read() == HIGH && isAutoPrograms == false) {
    if (valB40coloradjust > 15) {
      valB40coloradjust = valB40coloradjust - 10;
    }
    prevvalB40coloradjust = valB40coloradjust;
    writeDMX(chB40coloradjust, valB40coloradjust);
    //if (IS_DEBUG) Serial.print("valB40coloradjust=");
    //if (IS_DEBUG) Serial.println(valB40coloradjust);
  }
  if (debounce6.read() == HIGH && isAutoPrograms == false) {
    if (valB40coloradjust < 245) {
      valB40coloradjust = valB40coloradjust + 10;
    }
    prevvalB40coloradjust = valB40coloradjust;
    writeDMX(chB40coloradjust, valB40coloradjust);
    //if (IS_DEBUG) Serial.print("valB40coloradjust=");
    //if (IS_DEBUG) Serial.println(valB40coloradjust);
  }
  if (debounce7.read() == HIGH && isAutoPrograms == false) {
    if (valB40Laser > 25) {
      valB40Laser = valB40Laser - 20;
    }
    prevvalB40Laser = valB40Laser;
    writeDMX(chB40Laser, valB40Laser);
    //if (IS_DEBUG) Serial.print("valB40Laser=");
    //if (IS_DEBUG) Serial.println(valB40Laser);
  }
  if (debounce8.read() == HIGH && isAutoPrograms == false) {
    if (valB40Laser < 211) {
      valB40Laser = valB40Laser + 20;
    }
    prevvalB40Laser = valB40Laser;
    writeDMX(chB40Laser, valB40Laser);
    //if (IS_DEBUG) Serial.print("valB40Laser=");
    //if (IS_DEBUG) Serial.println(valB40Laser);
  }
  delay(250);
}//readButtons()

void readTrimmerMaster () {
  valB40Masterdimmer = map(analogRead(TrimB40dimmer), 10, 1013, 0, 255);;
}//readTrimmerMaster

void readTrimmers() {
  // instead of mapping 0-1023 I use 10-1013 to reach limits 0-255 easily
  valB40red = map(analogRead(TrimB40red), 10, 1013, 0, 255);
  valB40green = map(analogRead(TrimB40green), 10, 1013, 0, 255);
  valB40blue = map(analogRead(TrimB40blue), 10, 1013, 0, 255);
  valB40white = map(analogRead(TrimB40white), 10, 1013, 0, 255);

  valB40Rotation = map(analogRead(TrimB40rotate), 1, 1013, 0, 255);
  if (valB40Rotation < 6) valB40Rotation = 128;//otherwise value can become minus
  valB40StrobeLED = map(analogRead(TrimB40strobeLEDfreq), 10, 1013, 0, 255);
  if (valB40StrobeLED > 250) valB40StrobeLED = 250;//otherwise value can become more than 255
  valB40StrobeLaser = map(analogRead(TrimB40strobeLaserfreq), 10, 1013, 0, 255);
  if (valB40StrobeLaser > 250) valB40StrobeLaser = 250;//otherwise value can become more than 255

  valB40Masterdimmer = map(analogRead(TrimB40dimmer), 10, 1013, 0, 255);
}//readTrimmers()

void writeDMX(const byte ch, const byte val) {
  if (ch > 0 && ch <= MaxChannel ) DmxSimple.write(ch, val);
  if (IS_DEBUG) Serial.print("sent ");
  if (IS_DEBUG) Serial.print(ch);
  if (IS_DEBUG) Serial.print(" ");
  if (IS_DEBUG) Serial.println(val);
}//writeDMX()

void doBlackoutB40All () {
  writeDMX (chB40red, 0);
  writeDMX (chB40green, 0);
  writeDMX (chB40blue, 0);
  writeDMX (chB40white, 0);

  writeDMX (chB40coloradjust, valB40coloradjust);
  writeDMX (chB40StrobeLED, 0);
  writeDMX (chB40Laser, 0);
  writeDMX (chB40StrobeLaser, 0);
  writeDMX (chB40Rotation, 0);
  writeDMX (chB40Masterdimmer, 0);
}//doBlackoutB40All

void undoBlackoutB40All () {
  writeDMX (chB40red, valB40red);
  writeDMX (chB40green, valB40green);
  writeDMX (chB40blue, valB40blue);
  writeDMX (chB40white, valB40white);

  writeDMX (chB40coloradjust, valB40coloradjust);
  writeDMX (chB40StrobeLED, valB40coloradjust);
  writeDMX (chB40Laser, valB40Laser);
  writeDMX (chB40StrobeLaser, valB40StrobeLaser);
  writeDMX (chB40Rotation, valB40Rotation);
  writeDMX (chB40Masterdimmer, valB40Masterdimmer);
}//undoBlackoutB40All

void doBlackoutB40LED () {
  writeDMX (chB40red, 0);
  writeDMX (chB40green, 0);
  writeDMX (chB40blue, 0);
  writeDMX (chB40white, 0);
  writeDMX (chB40StrobeLED, 0);
}//doBlackoutB40LED

void doBlackoutB40Laser () {
  writeDMX (chB40Laser, 0);
  writeDMX (chB40StrobeLaser, 0);
}//doBlackoutB40Laser

void undoBlackoutB40LED () {
  writeDMX (chB40red, valB40red);
  writeDMX (chB40green, valB40green);
  writeDMX (chB40blue, valB40blue);
  writeDMX (chB40white, valB40white);
  writeDMX (chB40StrobeLED, valB40coloradjust);
}//undoBlackoutB40LED

void undoBlackoutB40Laser () {
  writeDMX (chB40Laser, valB40Laser);
  writeDMX (chB40StrobeLaser, valB40StrobeLaser);
}//undoBlackoutB40Laser

//#######################################################
//Autoprogramme
void doProgram01 () {
  //Discokugel traditionell - weisses Licht - langsame Rotation
  writeDMX (chB40red, 0);
  writeDMX (chB40green, 0);
  writeDMX (chB40blue, 0);
  writeDMX (chB40white, 80);

  writeDMX (chB40coloradjust, 38);
  writeDMX (chB40StrobeLED, 0);
  writeDMX (chB40Laser, 0);
  writeDMX (chB40StrobeLaser, 0);
  writeDMX (chB40Rotation, 129);
}
void doProgram02 () {
  //Discokugel bunt ohne weiss - langsame Rotation
  writeDMX (chB40red, 255);
  writeDMX (chB40green, 255);
  writeDMX (chB40blue, 255);
  writeDMX (chB40white, 0);

  writeDMX (chB40coloradjust, 203);
  writeDMX (chB40StrobeLED, 0);
  writeDMX (chB40Laser, 0);
  writeDMX (chB40StrobeLaser, 0);
  writeDMX (chB40Rotation, 129);
}
void doProgram03 () {
  //Laser Rot/Grün - langsame Rotation
  writeDMX (chB40red, 0);
  writeDMX (chB40green, 0);
  writeDMX (chB40blue, 0);
  writeDMX (chB40white, 0);

  writeDMX (chB40coloradjust, 0);
  writeDMX (chB40StrobeLED, 0);
  writeDMX (chB40Laser, 129);
  writeDMX (chB40StrobeLaser, 0);
  writeDMX (chB40Rotation, 129);
}
void doProgram04 () {
  //Discokugel bunt ohne weiss + Laser Rot/Grün - langsame Rotation
  writeDMX (chB40red, 255);
  writeDMX (chB40green, 255);
  writeDMX (chB40blue, 255);
  writeDMX (chB40white, 0);

  writeDMX (chB40coloradjust, 203);
  writeDMX (chB40StrobeLED, 0);
  writeDMX (chB40Laser, 129);
  writeDMX (chB40StrobeLaser, 0);
  writeDMX (chB40Rotation, 129);
}
void doProgram05 () {
  //

}
void doProgram06 () {
  //

}
void doProgram07 () {
  //

}
void doProgram08 () {
  //

}