daily pastebin goal
1%
SHARE
TWEET

Treppenstufenbeleuchtung v0.4.1

iceananas Apr 1st, 2013 680 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //Treppenlicht v0.4.1
  2. //for private use only
  3. #include "Tlc5940.h"
  4.  
  5.  
  6. /**************************************************************************/
  7. //Einstellungen ab hier vornehmen
  8. #define MAX 11                            //Anzahl der Stufen [0-15]
  9. #define pot A7                            //Analogpin vom Potentiometer
  10. #define switch1 8                         //Pin vom Schalter
  11. //Teiler der Schrittweite des Fading,
  12. //entspricht c.a. Fadingzeit pro Stufe in Millisekunden
  13. #define divider 300                      
  14.  
  15.  
  16. //Freie digitale IO Ports: 0,1,2,4,5,6,7,8,12 sowie Analogpins
  17. uint8_t sensorPin1 = 7;
  18. uint8_t sensorPin2 = 6;                   //IO-Ports der Sensoren
  19. uint16_t brightness = 3333;               //Initialhelligkeit [0-4095]
  20. uint16_t walktime = 3000;                 //Zeit bis Verlassen der Treppe
  21. uint32_t timeout1 = 10000;                //Gesamttimeout in Millisekunden
  22. uint32_t timeout2 = 1500;                 //Timeout nach Verlassen der Treppe
  23. //Einstellunge bis hier vornehmen
  24. /**************************************************************************/
  25.  
  26.  
  27. //Globale Initialisierungen
  28. bool sensor[9] = {1,1,1,1,1,1,1,1,1};     //Array fuer Sensorwerten
  29. uint8_t semOn = 1;                        //Semaphore fuer das Einschalten
  30. uint8_t semOff = 0;                       //Semaphore fuer das Ausschalten
  31. int8_t direction = 0;                     //1: vorwaerts, -1: rueckwarts
  32. int8_t tempdirection = 0;                
  33. unsigned long timeStart = 0;              //Zaehlvariablen fuer Timeout
  34. unsigned long timeStart2 = 0;
  35. int8_t channel=0;                         //Laufvariable fuer Kanaele
  36.  
  37.  
  38.  
  39. //Initialisierungen
  40. void setup () {
  41.   Tlc.init();
  42.   pinMode (sensorPin1, INPUT_PULLUP);
  43.   pinMode (sensorPin2, INPUT_PULLUP);
  44.   pinMode (switch1, INPUT_PULLUP);
  45. }
  46.  
  47. void loop () {
  48.  
  49.   //Helligkeit wird durch das Potentiometer eingestellt und Sensorenwerte
  50.   //werden im Leerlauf c.a. 10x/sekunde aktualisiert
  51.   if(semOn==1&&!semOff) {
  52.  
  53.     setBrightness(pot);
  54.     readSensor();
  55.  
  56.     delay(25);    
  57.   }  
  58.  
  59.   //Wenn semOn vorhaben, Einfaden starten
  60.   if(semOn && direction!=0) {
  61.    
  62.     tempdirection = direction;
  63.     //Semaphore fuer Einschalten wird zu Beginn auf 0 gesetzt
  64.     semOn = 0;
  65.  
  66.     //Fadefunktion ausfuehren. Wenn beim Fading der Sensor auf der
  67.     //gegenueber liegenden Seite reagiert, leuchten alle Stufen gleichzeitig auf
  68.     if(fadein()!=tempdirection) {
  69.       fadeinall();
  70.       tempdirection = tempdirection * (-1);
  71.     }
  72.        
  73.     //Semaphore fuer Ausschalten wird hinzugefuegt
  74.     semOff = 1;
  75.    
  76.     //Zaehlen des Timeout startet
  77.     timeStart = millis();
  78.     timeStart2 = 0;
  79.    
  80.   }
  81.  
  82.   //Wenn die Treppe bereits leuchtet werden Sensoren abgefragt
  83.   if(semOff) {
  84.  
  85.     delay (25);
  86.    
  87.     //Abfrage Sensor 2
  88.     if(!digitalRead(sensorPin2))
  89.     {
  90.       if(tempdirection == 1) {
  91.         if ((millis()-timeStart)>walktime) {
  92.           timeStart2 = millis();
  93.           delay(timeout2);
  94.         }
  95.         else {
  96.           timeStart = millis();
  97.           tempdirection = -1;
  98.         }
  99.       }      
  100.      
  101.       else if (tempdirection == -1)
  102.         timeStart = millis();
  103.     }
  104.    
  105.     //Abfrage Sensor 1  
  106.     else if(!digitalRead(sensorPin1)) {
  107.    
  108.       if(tempdirection == -1) {
  109.         if((millis()-timeStart)>walktime) {
  110.           timeStart2 = millis();
  111.           delay(timeout2);
  112.         }
  113.         else {
  114.           timeStart = millis();
  115.           tempdirection = 1;
  116.         }
  117.       }
  118.      
  119.       else if (tempdirection == 1)
  120.         timeStart = millis();
  121.     }
  122.   }
  123.  
  124.    
  125.   //Wenn eins Timeout ueberschritten, wird Ausfaden ausgeloest
  126.   if((((millis()-timeStart)>=timeout1)||(timeStart2!=0&&(millis()-timeStart2)>=timeout2))&&semOff) {
  127.  
  128.     semOff = fadeout(tempdirection);
  129.  
  130.     //Durch Rueckgabewerte von fadeout() wird erkannt, ob Ausfaden unterbrochen wurde
  131.     switch (semOff) {
  132.       case 0:  semOn = 1;  break;
  133.       case 1:  semOn = 2;  direction = 1;  break;
  134.       case 2:  semOn = 2;  direction = -1;  break;
  135.     default:  break;
  136.     }
  137.     //Semaphor fuer Ausfaden wurd auf null gesetzt
  138.     semOff = 0;
  139.   }
  140.  
  141.   delay(5);
  142.  
  143. }  
  144.  
  145. //Einlesen der Sensorwerte
  146. void readSensor () {
  147.  
  148.   sensor[0] = digitalRead(sensorPin1);
  149.   sensor[1] = digitalRead(sensorPin2);
  150.  
  151.   //Laufrichtungen werden bestimmt
  152.   if((sensor[0]==0)&&(sensor[1]==1))
  153.     direction = 1;
  154.   else if((sensor[0]==1)&&(sensor[1]==0))
  155.     direction = -1;
  156.   else direction = 0;
  157. }
  158.  
  159. //Funktion zum Einstellen der Helligkeit
  160. void setBrightness (int pot) {
  161.  
  162.   //Wenn DIP Schalter 1 umgelegt wird,
  163.   //wird Helligkeit mit angeschlossenen LEDs als Balken angezeigt
  164.   while(!digitalRead(switch1)) {
  165.  
  166.     int tempBrightness = map(analogRead(pot),0,1023,1,4095);
  167.  
  168.     //"Zittern" des Analogeingangs wird entstoert
  169.     if (abs(tempBrightness-brightness)>10)
  170.       brightness = tempBrightness;
  171.  
  172.     Tlc.clear();
  173.  
  174.     int level = map(brightness, 0, 4095, 0, MAX);
  175.  
  176.     if(level != 0) {
  177.       for(int i = 0; i<level; i++)        
  178.         Tlc.set(i,brightness);
  179.     }
  180.     Tlc.update();
  181.   }  
  182.   delay(15);
  183.   Tlc.clear();
  184.   Tlc.update();
  185. }
  186.  
  187.  
  188. //Funktion fuer das Einfaden
  189. int fadein () {
  190.  
  191.   //Lokale Hilfsvariablen
  192.   int destination = 0;            
  193.   int stop = 0;  
  194.  
  195.   //Hilfsgroessen zur Einhaltung der Laufrichtungen
  196.   if (direction==1) {
  197.     channel=0;
  198.     destination = MAX;
  199.   }
  200.   else if (direction==-1) {
  201.     channel = MAX-1;
  202.     destination = -1;
  203.   }
  204.  
  205.   //Alle angeschlossene Kanarle werden durchgeschaltet
  206.   do{
  207.  
  208.     //Variable, um bereits leuchtende, kommende Stufen zu erkennen
  209.     int tempNextBrightness = Tlc.get(channel+direction);
  210.  
  211.     //Schrittweise Erhoehung der Helligkeit mit der Schrittweite 'brightness/divider'
  212.     for(unsigned int tempBrightness=Tlc.get(channel);tempBrightness<=brightness;tempBrightness+=brightness/divider)  {
  213.       Tlc.set(channel,tempBrightness);
  214.       Tlc.update();
  215.  
  216.       if(direction==-1&&!digitalRead(sensorPin1)) {
  217.         stop = 1;
  218.         break;
  219.       }
  220.  
  221.       else if (direction==1&&!digitalRead(sensorPin2)){
  222.         stop = 2;
  223.         break;
  224.       }  
  225.  
  226.       //Wenn die fadende LED die halbe Helligkeit erreicht, startet die naechste LED das Faden    
  227.       if(direction==1) {
  228.         if((tempBrightness>(brightness/2))&&(channel!=(MAX-1))&&(tempNextBrightness==0)) {
  229.           Tlc.set(channel+direction,tempBrightness-brightness/2);
  230.           Tlc.update();
  231.         }
  232.       }
  233.       else {
  234.         if((tempBrightness>(brightness/2))&&(channel!=0)&&(tempNextBrightness==0)) {
  235.           Tlc.set(channel+direction,tempBrightness-brightness/2);
  236.           Tlc.update();
  237.         }
  238.       }  
  239.       delay(1);
  240.     }
  241.     if(stop)
  242.     break;
  243.    
  244.     //Durch Integer-Division entstehen Ungenauigkeiten,
  245.     //so dass brightness nicht ganz erreicht wird.
  246.     Tlc.set(channel,brightness);
  247.     Tlc.update();
  248.    
  249.     if (channel == (destination - direction))
  250.       bounce (channel);
  251.  
  252.     channel += direction;
  253.        
  254.    }  while (channel!=destination);
  255.  
  256.   if (stop==1)
  257.     return 1;
  258.   else if (stop==2)
  259.     return -1;
  260.  
  261.   else return direction;
  262. }
  263.  
  264. //Funktion fuer gleichzeitiges Einfaden
  265. void fadeinall() {
  266.  
  267.   for(int tempBrightness=0;tempBrightness<=(brightness-brightness%divider);tempBrightness+=brightness/divider) {
  268.  
  269.     for(channel=0;channel<MAX;channel++) {
  270.       if(Tlc.get(channel)<tempBrightness)
  271.         Tlc.set(channel,tempBrightness);
  272.     }
  273.     Tlc.update();
  274.     delay(1);
  275.   }
  276.     for(channel=0;channel<MAX;channel++)
  277.       Tlc.set(channel,brightness);
  278.     Tlc.update();
  279. }
  280.  
  281.  
  282.  
  283. //Funktion fuer das Ausfaden, Funktion analog zu fadeon()
  284. //Rueckgabewert: 0, wenn vollstaendig ausgefuehrt,
  285. //1 wenn durch Sensor 1 unterbrochen, 2 wenn durch Sensor 2 unterbrochen
  286. int fadeout (int8_t direction_out) {
  287.  
  288.   int stop = 0;
  289.   int destination = 0;
  290.  
  291.   //Hilfsgroessen zur Einhaltung der Laufrichtungen
  292.   if (direction_out==1) {
  293.     channel=0;
  294.     destination = MAX;
  295.   }
  296.   else if (direction_out==-1) {
  297.     channel = MAX-1;
  298.     destination = -1;
  299.   }
  300.  
  301.   do{
  302.  
  303.     for(unsigned int tempBrightness=Tlc.get(channel);tempBrightness>=(brightness%divider);tempBrightness-=brightness/divider)  {
  304.  
  305.       Tlc.set(channel,tempBrightness);
  306.       Tlc.update();
  307.  
  308.       if(!digitalRead(sensorPin1)) {
  309.         stop = 1;
  310.         break;
  311.       }
  312.  
  313.       if(!digitalRead(sensorPin2)) {
  314.         stop = 2;
  315.         break;
  316.       }      
  317.  
  318.       if (direction_out==1) {
  319.         if((tempBrightness<=(brightness/2))&&(channel!=(MAX-1))) {
  320.           Tlc.set(channel+direction_out,brightness-(-tempBrightness+brightness/2));
  321.           Tlc.update();
  322.         }
  323.       }
  324.       else {
  325.         if((tempBrightness<=(brightness/2))&&channel!=(0)) {
  326.           Tlc.set(channel+direction_out,brightness-(-tempBrightness+brightness/2));
  327.           Tlc.update();
  328.         }
  329.       }
  330.       delay(1);
  331.     }
  332.     if (stop)
  333.       break;
  334.  
  335.     Tlc.set(channel,0);
  336.     Tlc.update();
  337.  
  338.     channel += direction_out;
  339.  
  340.   } while (channel!=destination);
  341.  
  342.   if (stop == 1)
  343.     return 1;
  344.   else if (stop == 2)
  345.     return 2;
  346.   else {
  347.     Tlc.clear();
  348.     Tlc.update();
  349.     return 0;
  350.   }
  351. }
  352.  
  353. //Bouncefunktion: Wenn ein Fading das Ende erreicht, leuchten die letzten zwei
  354. //Stufen kurz hell auf
  355. void bounce (int8_t channel) {
  356.  
  357.   uint16_t tempbrightness = Tlc.get(channel);
  358.   uint16_t tempfall = 0;
  359.   float bouncefactor = 2;
  360.  
  361.   for(int16_t temprise=tempbrightness;temprise<tempbrightness*bouncefactor;temprise+=tempbrightness*0.01) {
  362.    
  363.     if (temprise>4095)
  364.     break;
  365.    
  366.     Tlc.set(channel, temprise);
  367.     Tlc.set(channel-direction, temprise);
  368.     Tlc.update();
  369.    
  370.     tempfall = temprise;
  371.     delay(3);
  372.   }
  373.  
  374.    delay(100);
  375.  
  376.    for(tempfall;tempfall>tempbrightness;tempfall-=tempbrightness*0.01) {
  377.        
  378.     Tlc.set(channel, tempfall);
  379.     Tlc.set(channel-direction, tempfall);
  380.     Tlc.update();
  381.     delay(3);
  382.   }
  383.  
  384.   Tlc.set (channel, tempbrightness);
  385.   Tlc.set (channel-direction, tempbrightness);
  386.   Tlc.update();
  387.  
  388. }
RAW Paste Data
Top