Treppenstufenbeleuchtung v0.4.1

//Treppenlicht v0.4.1
//for private use only
#include "Tlc5940.h"


/**************************************************************************/
//Einstellungen ab hier vornehmen
#define MAX 11                            //Anzahl der Stufen [0-15]
#define pot A7                            //Analogpin vom Potentiometer
#define switch1 8             //Pin vom Schalter
//Teiler der Schrittweite des Fading,
//entspricht c.a. Fadingzeit pro Stufe in Millisekunden
#define divider 300


//Freie digitale IO Ports: 0,1,2,4,5,6,7,8,12 sowie Analogpins
uint8_t sensorPin1 = 7;
uint8_t sensorPin2 = 6;                   //IO-Ports der Sensoren
uint16_t brightness = 3333;               //Initialhelligkeit [0-4095]
uint16_t walktime = 3000;                 //Zeit bis Verlassen der Treppe
uint32_t timeout1 = 10000;                //Gesamttimeout in Millisekunden
uint32_t timeout2 = 1500;                 //Timeout nach Verlassen der Treppe
//Einstellunge bis hier vornehmen
/**************************************************************************/


//Globale Initialisierungen
bool sensor[9] = {1,1,1,1,1,1,1,1,1};     //Array fuer Sensorwerten
uint8_t semOn = 1;                        //Semaphore fuer das Einschalten
uint8_t semOff = 0;                       //Semaphore fuer das Ausschalten
int8_t direction = 0;                     //1: vorwaerts, -1: rueckwarts
int8_t tempdirection = 0;
unsigned long timeStart = 0;              //Zaehlvariablen fuer Timeout
unsigned long timeStart2 = 0;
int8_t channel=0;                         //Laufvariable fuer Kanaele



//Initialisierungen
void setup () {
  Tlc.init();
  pinMode (sensorPin1, INPUT_PULLUP);
  pinMode (sensorPin2, INPUT_PULLUP);
  pinMode (switch1, INPUT_PULLUP);
}

void loop () {

  //Helligkeit wird durch das Potentiometer eingestellt und Sensorenwerte
  //werden im Leerlauf c.a. 10x/sekunde aktualisiert
  if(semOn==1&&!semOff) {

    setBrightness(pot);
    readSensor();

    delay(25);
  }

  //Wenn semOn vorhaben, Einfaden starten
  if(semOn && direction!=0) {

    tempdirection = direction;
    //Semaphore fuer Einschalten wird zu Beginn auf 0 gesetzt
    semOn = 0;

    //Fadefunktion ausfuehren. Wenn beim Fading der Sensor auf der
    //gegenueber liegenden Seite reagiert, leuchten alle Stufen gleichzeitig auf
    if(fadein()!=tempdirection) {
      fadeinall();
      tempdirection = tempdirection * (-1);
    }

    //Semaphore fuer Ausschalten wird hinzugefuegt
    semOff = 1;

    //Zaehlen des Timeout startet
    timeStart = millis();
    timeStart2 = 0;

  }

  //Wenn die Treppe bereits leuchtet werden Sensoren abgefragt
  if(semOff) {

    delay (25);

    //Abfrage Sensor 2
    if(!digitalRead(sensorPin2))
    {
      if(tempdirection == 1) {
        if ((millis()-timeStart)>walktime) {
          timeStart2 = millis();
          delay(timeout2);
        }
        else {
          timeStart = millis();
          tempdirection = -1;
        }
      }

      else if (tempdirection == -1)
        timeStart = millis();
    }

    //Abfrage Sensor 1
    else if(!digitalRead(sensorPin1)) {

      if(tempdirection == -1) {
        if((millis()-timeStart)>walktime) {
          timeStart2 = millis();
          delay(timeout2);
        }
        else {
          timeStart = millis();
          tempdirection = 1;
        }
      }

      else if (tempdirection == 1)
        timeStart = millis();
    }
  }


  //Wenn eins Timeout ueberschritten, wird Ausfaden ausgeloest
  if((((millis()-timeStart)>=timeout1)||(timeStart2!=0&&(millis()-timeStart2)>=timeout2))&&semOff) {

    semOff = fadeout(tempdirection);

    //Durch Rueckgabewerte von fadeout() wird erkannt, ob Ausfaden unterbrochen wurde
    switch (semOff) {
      case 0:  semOn = 1;  break;
      case 1:  semOn = 2;  direction = 1;  break;
      case 2:  semOn = 2;  direction = -1;  break;
    default:  break;
    }
    //Semaphor fuer Ausfaden wurd auf null gesetzt
    semOff = 0;
  }

  delay(5);

}

//Einlesen der Sensorwerte
void readSensor () {

  sensor[0] = digitalRead(sensorPin1);
  sensor[1] = digitalRead(sensorPin2);

  //Laufrichtungen werden bestimmt
  if((sensor[0]==0)&&(sensor[1]==1))
    direction = 1;
  else if((sensor[0]==1)&&(sensor[1]==0))
    direction = -1;
  else direction = 0;
}

//Funktion zum Einstellen der Helligkeit
void setBrightness (int pot) {

  //Wenn DIP Schalter 1 umgelegt wird,
  //wird Helligkeit mit angeschlossenen LEDs als Balken angezeigt
  while(!digitalRead(switch1)) {

    int tempBrightness = map(analogRead(pot),0,1023,1,4095);

    //"Zittern" des Analogeingangs wird entstoert
    if (abs(tempBrightness-brightness)>10)
      brightness = tempBrightness;

    Tlc.clear();

    int level = map(brightness, 0, 4095, 0, MAX);

    if(level != 0) {
      for(int i = 0; i<level; i++)
        Tlc.set(i,brightness);
    }
    Tlc.update();
  }
  delay(15);
  Tlc.clear();
  Tlc.update();
}


//Funktion fuer das Einfaden
int fadein () {

  //Lokale Hilfsvariablen
  int destination = 0;
  int stop = 0;

  //Hilfsgroessen zur Einhaltung der Laufrichtungen
  if (direction==1) {
    channel=0;
    destination = MAX;
  }
  else if (direction==-1) {
    channel = MAX-1;
    destination = -1;
  }

  //Alle angeschlossene Kanarle werden durchgeschaltet
  do{

    //Variable, um bereits leuchtende, kommende Stufen zu erkennen
    int tempNextBrightness = Tlc.get(channel+direction);

    //Schrittweise Erhoehung der Helligkeit mit der Schrittweite 'brightness/divider'
    for(unsigned int tempBrightness=Tlc.get(channel);tempBrightness<=brightness;tempBrightness+=brightness/divider)  {
      Tlc.set(channel,tempBrightness);
      Tlc.update();

      if(direction==-1&&!digitalRead(sensorPin1)) {
        stop = 1;
        break;
      }

      else if (direction==1&&!digitalRead(sensorPin2)){
        stop = 2;
        break;
      }

      //Wenn die fadende LED die halbe Helligkeit erreicht, startet die naechste LED das Faden
      if(direction==1) {
        if((tempBrightness>(brightness/2))&&(channel!=(MAX-1))&&(tempNextBrightness==0)) {
          Tlc.set(channel+direction,tempBrightness-brightness/2);
          Tlc.update();
        }
      }
      else {
        if((tempBrightness>(brightness/2))&&(channel!=0)&&(tempNextBrightness==0)) {
          Tlc.set(channel+direction,tempBrightness-brightness/2);
          Tlc.update();
        }
      }
      delay(1);
    }
    if(stop)
    break;

    //Durch Integer-Division entstehen Ungenauigkeiten,
    //so dass brightness nicht ganz erreicht wird.
    Tlc.set(channel,brightness);
    Tlc.update();

    if (channel == (destination - direction))
      bounce (channel);

    channel += direction;

   }  while (channel!=destination);

  if (stop==1)
    return 1;
  else if (stop==2)
    return -1;

  else return direction;
}

//Funktion fuer gleichzeitiges Einfaden
void fadeinall() {

  for(int tempBrightness=0;tempBrightness<=(brightness-brightness%divider);tempBrightness+=brightness/divider) {

    for(channel=0;channel<MAX;channel++) {
      if(Tlc.get(channel)<tempBrightness)
        Tlc.set(channel,tempBrightness);
    }
    Tlc.update();
    delay(1);
  }
    for(channel=0;channel<MAX;channel++)
      Tlc.set(channel,brightness);
    Tlc.update();
}



//Funktion fuer das Ausfaden, Funktion analog zu fadeon()
//Rueckgabewert: 0, wenn vollstaendig ausgefuehrt,
//1 wenn durch Sensor 1 unterbrochen, 2 wenn durch Sensor 2 unterbrochen
int fadeout (int8_t direction_out) {

  int stop = 0;
  int destination = 0;

  //Hilfsgroessen zur Einhaltung der Laufrichtungen
  if (direction_out==1) {
    channel=0;
    destination = MAX;
  }
  else if (direction_out==-1) {
    channel = MAX-1;
    destination = -1;
  }

  do{

    for(unsigned int tempBrightness=Tlc.get(channel);tempBrightness>=(brightness%divider);tempBrightness-=brightness/divider)  {

      Tlc.set(channel,tempBrightness);
      Tlc.update();

      if(!digitalRead(sensorPin1)) {
        stop = 1;
        break;
      }

      if(!digitalRead(sensorPin2)) {
        stop = 2;
        break;
      }

      if (direction_out==1) {
        if((tempBrightness<=(brightness/2))&&(channel!=(MAX-1))) {
          Tlc.set(channel+direction_out,brightness-(-tempBrightness+brightness/2));
          Tlc.update();
        }
      }
      else {
        if((tempBrightness<=(brightness/2))&&channel!=(0)) {
          Tlc.set(channel+direction_out,brightness-(-tempBrightness+brightness/2));
          Tlc.update();
        }
      }
      delay(1);
    }
    if (stop)
      break;

    Tlc.set(channel,0);
    Tlc.update();

    channel += direction_out;

  } while (channel!=destination);

  if (stop == 1)
    return 1;
  else if (stop == 2)
    return 2;
  else {
    Tlc.clear();
    Tlc.update();
    return 0;
  }
}

//Bouncefunktion: Wenn ein Fading das Ende erreicht, leuchten die letzten zwei
//Stufen kurz hell auf
void bounce (int8_t channel) {

  uint16_t tempbrightness = Tlc.get(channel);
  uint16_t tempfall = 0;
  float bouncefactor = 2;

  for(int16_t temprise=tempbrightness;temprise<tempbrightness*bouncefactor;temprise+=tempbrightness*0.01) {

    if (temprise>4095)
    break;

    Tlc.set(channel, temprise);
    Tlc.set(channel-direction, temprise);
    Tlc.update();

    tempfall = temprise;
    delay(3);
  }

   delay(100);

   for(tempfall;tempfall>tempbrightness;tempfall-=tempbrightness*0.01) {

    Tlc.set(channel, tempfall);
    Tlc.set(channel-direction, tempfall);
    Tlc.update();
    delay(3);
  }

  Tlc.set (channel, tempbrightness);
  Tlc.set (channel-direction, tempbrightness);
  Tlc.update();

}