Go Down

Topic: Einfacher LCD Countdown Timer mit Schaltausgang (Read 12772 times) previous topic - next topic

squaremeter

Sep 05, 2011, 07:23 am Last Edit: Jul 01, 2014, 03:05 pm by squaremeter Reason: 1
Hallo Forum!

ich habe längere Zeit damit zugebracht im Internet einen schönen Countdown Timer für ein LCD zu finden, da ich mein Belichtungsgerät nicht immer mit der Stoppuhr vom Handy bedienen wollte.

Gefunden hab ich nichts, deswegen hab ich ihn mir selbst geschrieben. Und ich denke es könnte dem einen oder anderen mal behilflich sein.

Momentan kann der Code folgendes:
- 2 Zeiliges LC-Display mit 16 Zeichen ansteuern
- Eingabe der Zeit erfolgt über Variablen änderung im Code
- 1 Zeile : Beliebige beschriftung + Anzeige der voreingestellten Countdownsekunden in Minuten und Sekunden
- 2. Zeile : Anzeige der aktuell ablaufenden Countdownzeit.
- Resetbutton ( ohne Tasten entprellung ) an Pin 7 (überprüfung auf HIGH)

eingebunden ist lediglich die LiquidCrystal Library (keine Timer.h oder ähnliches)

Vorraussichtliche Verbesserungen:
- Eingabe der Zeit über Potentiometer und AnalogIN
- Pause Button
- Ansteuern eines Mosfet bei 00:00 (zur Ansteuerung der UV-Röhre)

Code: [Select]
#include <LiquidCrystal.h>

//----LCD-PINS---(rs, en,d4,d5,d6,d7)----------------------//
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

/***************Countdownzeit HIER eintragen****************/


int const inputtime = 180;               // in Sekunden    


//------------------------ Taster -------------------------//

int buttonstate;
int const buttonPin = 7;                 // Resetbutton Pin Deklarierung

//----------------Variablen für Countdown------------------//

int long countdowntime;                  // Countdown Variable bzw. Resetwert
int val;                                 // Variable für aktuellen Zustand
int lastval;                             // Variable für den vorherigen Zustand
int long minutes;                        // Countdown in Minuten
int long seconds;                        // Countdown in Sekunden
volatile unsigned char tick;             // Variable für den Timer


//--------------- Timer Überlauf auslesen ------------------//

ISR (TIMER2_OVF_vect)                    // Wenn Timer 1 Überläuft gib ein High über
{                
 -tick;                         // tick aus.    
}

void setup() {
 countdowntime = inputtime;
 int showminutes = inputtime/60;        // erstelle Variable für die anzuzeigenden Minuten
 int showseconds = inputtime%60;        // erstelle Variable für die anzuzeigenden Sekunden
 lcd.begin(16, 2);
 lcd.setCursor(0,0);
 lcd.print("Countdown: ");              // Beschriftung der ersten Zeile
 lcd.print(showminutes);                // Zeit wird automatisch eingetragen
 lcd.print(":");
 lcd.print(showseconds);
}

void loop()
{
 val = digitalRead(tick);               // Overflow des Timers auslesen

 buttonstate = digitalRead(buttonPin);  // auslesen des Digitalwertes an Pin 7
 
 if (buttonstate == HIGH)               // überprüfung auf Reset
 {
   countdowntime = inputtime;           // Resetbefehl
 }
 if (countdowntime>0)
 {
    if (val!= lastval)                  // wenn aktueller Zustand sich von Vorherigem unterscheidet dann
     {            
       countdowntime--;                 // inkrementiere die Variable "countdowntime"
     }  
     minutes = countdowntime/60;        // Aufteilung der "countdowntime" in Minuten
     seconds = countdowntime%60;        // und Sekunden
     lcd.setCursor(0,1);                // LCD ausgabe in Zeile 2 Zeichen 1
     if (minutes<10)
     {
       lcd.print('0');
     }
     lcd.print(minutes);                // gebe Minuten am LCD aus
     lcd.print(":");
     if (seconds<10)                    // wenn die Sekunden unter 10 kommen
     {
       lcd.print("0");                  // schreibe erst Null und dann
       lcd.print(seconds);              // die Sekunden
       lcd.write(' ');                  // entfernen der Null
     }
     else                               // ansonsten
     {
       lcd.print(seconds);              // schreibe die Sekunden normal
     }
     delay(1000);
     val = lastval;                     // Den aktuellen Zustand merken  
 }
 else
 {
   lcd.setCursor(0,1);          
   lcd.print("00:00");                  // Null anzeigen
   buttonstate = digitalRead(buttonPin);// Überprüfung des Digitalwertes an Pin 7

   if (buttonstate == HIGH)             // Überprüfung auf Reset Befehl
   {
     countdowntime = inputtime;         // Reset ausführen
   }
 }
}



LG M²


uwefed

Du kannst es auch mit dem Countdown-Timer des Handys machen, dann brauchst Du nicht dauernd draufschauen.
Ich bin ein Fan von Scrollrädern. Darum würde ich Dir solche für die Zeiteingabe vorschlagen. Du kannst das Programm ja so schreiben, daß bei langsamer Betätigung der Wert in 1-er Schritten incrementiert wird, bei schneller Betätigung in Zehnerschritten.
Viele Grüße Uwe

squaremeter

#2
Sep 05, 2011, 08:07 am Last Edit: Sep 05, 2011, 08:09 am by squaremeter Reason: 1
Sinn und Zweck von dem Countdown ist ja eigendlich das man die Platine in das Belichtungsgerät legt.
und Die UV lampe genau dann angeht wenn man den Knopf drückt und nach der vorgegebenen Zeit wieder ausgeht.

Ich will nicht nach 3 minuten sofort zu dem Teil rennen müssen wenn man gerade nebenher noch mit ner anderen Platine beschäftigt ist(was durchaus vorkommt) nur damit man das Belichten nicht verhunzt.(wenn zu lange belichtet funktionierts nicht. zu kurz reicht nicht aus)

LG M²

squaremeter

Fertig!

hier der Code, Schaltplan und Layout.

Code: [Select]
/*****************************Intro************************************
///Countdowntimer version 1.0
   
   Ein einfacher Timer der mit einem LC-Display, einem 100k Potentiometer,
   einem einfachen Taster als Eingang und einem schaltenden Ausgang
   ausgestattet ist.
   
   In dieser Konfiguration lässt sich die Zeit über den Poti an A0(PC0,Pin 23)
   von 00:00 min bis ca. 17:05 min einstellen.
   Die Konfiguration lässt sich in "void_readAin" umstellen.
   
   Ein (nicht entprellter) Highaktiver Taster an 8(PB0,Pin 14) dient als Eingang.
   Drücken = A/D Wert des Potis übernehmen und in den Timer schreiben
     -> negative Flanke : Timer starten/Ausgang 13(PB5,Pin 19)High setzen
   Drücken und Halten = A/D Wert einstellen
   nach ablauf des Timers = Ausgang 13(PB5,Pin 19) Low setzen

   Verdrahtung:
   
   Poti 100k (10Gang) = Schleifer=> A0/Pin 23; Anfang/Ende=>5V/GND
   Taster mit 10K Pulldown Widerstand => 8/Pin 14
   Ausgang => 13/Pin 19
   LCD => siehe Unten

**********************************************************************/

#include <LiquidCrystal.h>

//----LCD-PINS---(rs, en,d4,d5,d6,d7)----------------------//
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

//-------------------- Taster/Ausgänge --------------------//

int varpin = A0;
int buttonstate;
int const buttonPin = 8;                 // Resetbutton Pin Deklarierung
int uvout = 13;                          // Ausgang für UV-Licht

//----------------Variablen für Countdown------------------//

int long countdowntime;                  // Countdown Variable bzw. Resetwert
int val;                                 // Variable für aktuellen Zustand
int lastval;                             // Variable für den vorherigen Zustand
int long minutes;                        // Countdown in Minuten
int long seconds;                        // Countdown in Sekunden
volatile unsigned char tick;             // Variable für den Timer
int inputtime ;                          // Variable für analogeingang     


//--------------- Timer Überlauf auslesen ------------------//

ISR (TIMER2_OVF_vect)                    // Wenn Timer 1 Überläuft gib ein High über
{                  
  ++tick;                          // tick aus.    
}

void setup() {
  inputtime = analogRead(varpin);        // analogwert einlesen 
  countdowntime = 0;                     // Starte bei 00:00
  lcd.begin(16, 2);                      // initialisiere Display
  lcd.setCursor(0,0);                    // setze Cursor für 1. Zeile
  lcd.print("Time:");                    // Beschriftung der ersten Zeile
  readAin ();                            // Analogwert eintragen
}


void loop()
{
  buttonstate = digitalRead(buttonPin);    // auslesen des Digitalwertes an Pin 7
  val = digitalRead(tick);                 // Overflow des Timers auslesen
 
if (buttonstate != HIGH)                 
{
  lcd.setCursor(0, 0);                     // erste Zeile
  lcd.print("Time:");                      // Schreibe "Time:"
 
  if (countdowntime<=0);                   // wenn 'countdowntime 0
  {                                        //
    digitalWrite(uvout, LOW);              // schalte UV-Licht aus
  }                                        //

  if (countdowntime>0)
  {       
    if (val != lastval)                   // wenn sich 'val' von 'lastval' unterscheidet
    {                                     //
      countdowntime--;                    // inkrementiere 'countdowntime'
      digitalWrite(uvout, HIGH);          // schalte UV-Licht ein
    }                                     //
     
    lcd.setCursor(0,1);                   // Setze Cursor für Countdown
    printTime();                          // gebe Zeit aus 
       

    val = lastval;                        // aktuellen Zustand merken   
    delay(1000);                           // 1 sekunde Pause
  }
}

else

  lcd.setCursor(0,0);         
  lcd.print("SET : ");                     // "Time:" zu "Set :" ändern

  lcd.setCursor(5, 0);                     // Cursor hinter "Set :" setzen
  readAin();                               // Schreibe Set-Time
 
  countdowntime = inputtime;               // reset
   
}
}



void printTime ()
{
  minutes = countdowntime/60;           // Aufteilung von 'countdowntime' in Minuten
  seconds = countdowntime%60;           // und Sekunden
       
  if (minutes<10)                       // wenn minuten unter 10
  {                                     //   
    lcd.print('0');                     // schreibe "0" vor minuten
  }                                     //
         
  lcd.print(minutes);                   // gebe Minuten aus
  lcd.print(":");                       // schreibe ":"
     
  if (seconds<10)                       // wenn Sekunden unter 10
  {                                     // 
    lcd.print("0");                     // schreibe erst Null und dann
    lcd.print(seconds);                 // die Sekunden
    lcd.write(' ');                     // entferne Werte nach sekunden
  }                                     //
  else                                  //
  {                                     //
    lcd.print(seconds);                 // schreibe die Sekunden normal
    lcd.print(" ");                     //
  }                                     //
 
}

void readAin ()
{
inputtime = analogRead(varpin);           // Analogwert in 'inputtime' schreiben
int showminutes = inputtime /60;          // inputtime/60 = showminutes = Minuten ausrechnen
int showseconds = inputtime %60;          // inputtime%60 = showseconds = Sekunden ausrechnen

if (showminutes<10)                      // wenn 'showminutes' unter 10
{                                        //
   lcd.print('0');                        // schreibe erst "0"
}                                        //

lcd.print(showminutes);                   // schreibe 'showminutes'
   
lcd.print(":");                           // schreibe ":"
   
if (showseconds<10)                       // wenn 'showseconds' unter 10
{
   lcd.print("0");                        // schreibe erst Null
   lcd.print(showseconds);                // dann die Sekunden
   lcd.write(' ');                        // entferne letzte Ziffer
}
else                                     // wenn nicht
{                                        //
   lcd.print(showseconds);                // schreibe die Sekunden normal
   lcd.print(" ");                        // und lösche die Ziffer dahinter
}
delay(150);                              // Verlangsame den kompletten vorgang

}
 

Gollywog

squaremeter hat sich nächtig Mühe gegeben !

Vor allem ist es mächtig durch_dokumentiert ! Und das verdient Applaus !


squaremeter

danke vielmals

vielleicht mach ich auch noch ein Tutorial draus mit ein paar Bildern o.ä.


Gollywog

Vielleicht machst du aus deinem Count-Down-Timer auch einen mit 7-Segment-LEDs.

Zis64

#7
Feb 04, 2018, 07:57 am Last Edit: Feb 04, 2018, 11:25 pm by Zis64
Hallo squaremeter,

Tolles Project!
Bin auch gerade an einem UV-Belichter für das Maskien meiner PCB's dran
und auf der suche nach einem LCD count-down timer.
Da meine Codier Kenntnisse noch nicht ausreichen werde ich mal deinen Code (ausprobieren=auseinander nehmen), danke fürs posten, dein sehr gut dokumentierter Code wird mir sicherlich weiter helfen.
Die Lösung mit dem Poti finde ich persönlich nicht so gut, ich werde probieren den durch zwei Taster zu Ersätzen.
Schicker wäre aber ein Incremental geber, mal schauen was machbar ist.

Danke nochmals, tolle Sache!

Klaus_ww

Feine Sache wenn's funktioniert - Glückwunsch!

Ich halte die 3000 µF nach dem Gleichrichter aber für völlig übertrieben - hast Du dafür einen Grund oder sollen die Netzausfälle kurzfristig auffangen?
Freizeit-Programmierer mit moderatem Ehrgeiz besseren Code zu schreiben.

nordcap

Hallo squaremeter,

das Projekt hat mir sehr gut gefallen und ich habe es nachgebaut.
Auch ich suchte schon lange einen Timer mit Sekunden und Schaltausgang für meine Platinen.

Nun habe ich aber ein Problem.
Die Zeit wir im Display angezeigt und ich kann auch die Dauer verändern.
Aber ich weiß nicht wie ich den Timer starten soll.
Das mit der negativen Flanke habe ich nicht verstanden.
Ich würde mich freuen wenn ich eine Nachricht bekomme was ich falsch mache
bzw was ich machen muß damit der Timer startet.

Fertig!

hier der Code, Schaltplan und Layout.

Code: [Select]
/*****************************Intro************************************
///Countdowntimer version 1.0
  
   Ein einfacher Timer der mit einem LC-Display, einem 100k Potentiometer,
   einem einfachen Taster als Eingang und einem schaltenden Ausgang
   ausgestattet ist.
  
   In dieser Konfiguration lässt sich die Zeit über den Poti an A0(PC0,Pin 23)
   von 00:00 min bis ca. 17:05 min einstellen.
   Die Konfiguration lässt sich in "void_readAin" umstellen.
  
   Ein (nicht entprellter) Highaktiver Taster an 8(PB0,Pin 14) dient als Eingang.
   Drücken = A/D Wert des Potis übernehmen und in den Timer schreiben
     -> negative Flanke : Timer starten/Ausgang 13(PB5,Pin 19)High setzen
   Drücken und Halten = A/D Wert einstellen
   nach ablauf des Timers = Ausgang 13(PB5,Pin 19) Low setzen
 
   Verdrahtung:
  
   Poti 100k (10Gang) = Schleifer=> A0/Pin 23; Anfang/Ende=>5V/GND
   Taster mit 10K Pulldown Widerstand => 8/Pin 14
   Ausgang => 13/Pin 19
   LCD => siehe Unten

**********************************************************************/

#include <LiquidCrystal.h>

//----LCD-PINS---(rs, en,d4,d5,d6,d7)----------------------//
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

//-------------------- Taster/Ausgänge --------------------//

int varpin = A0;
int buttonstate;
int const buttonPin = 8;                 // Resetbutton Pin Deklarierung
int uvout = 13;                          // Ausgang für UV-Licht

//----------------Variablen für Countdown------------------//

int long countdowntime;                  // Countdown Variable bzw. Resetwert
int val;                                 // Variable für aktuellen Zustand
int lastval;                             // Variable für den vorherigen Zustand
int long minutes;                        // Countdown in Minuten
int long seconds;                        // Countdown in Sekunden
volatile unsigned char tick;             // Variable für den Timer
int inputtime ;                          // Variable für analogeingang    


//--------------- Timer Überlauf auslesen ------------------//

ISR (TIMER2_OVF_vect)                    // Wenn Timer 1 Überläuft gib ein High über
{                
  ++tick;                         // tick aus.    
}

void setup() {
  inputtime = analogRead(varpin);        // analogwert einlesen  
  countdowntime = 0;                     // Starte bei 00:00
  lcd.begin(16, 2);                      // initialisiere Display
  lcd.setCursor(0,0);                    // setze Cursor für 1. Zeile
  lcd.print("Time:");                    // Beschriftung der ersten Zeile
  readAin ();                            // Analogwert eintragen
}


void loop()
{
  buttonstate = digitalRead(buttonPin);    // auslesen des Digitalwertes an Pin 7
  val = digitalRead(tick);                 // Overflow des Timers auslesen
  
if (buttonstate != HIGH)                
{
  lcd.setCursor(0, 0);                     // erste Zeile
  lcd.print("Time:");                      // Schreibe "Time:"
  
  if (countdowntime<=0);                   // wenn 'countdowntime 0
  {                                        //
    digitalWrite(uvout, LOW);              // schalte UV-Licht aus
  }                                        //
 
  if (countdowntime>0)
  {      
    if (val != lastval)                   // wenn sich 'val' von 'lastval' unterscheidet
    {                                     //
      countdowntime--;                    // inkrementiere 'countdowntime'
      digitalWrite(uvout, HIGH);          // schalte UV-Licht ein
    }                                     //
    
    lcd.setCursor(0,1);                   // Setze Cursor für Countdown
    printTime();                          // gebe Zeit aus  
        

    val = lastval;                        // aktuellen Zustand merken  
    delay(1000);                           // 1 sekunde Pause
  }
}

else
{  
  lcd.setCursor(0,0);          
  lcd.print("SET : ");                     // "Time:" zu "Set :" ändern

  lcd.setCursor(5, 0);                     // Cursor hinter "Set :" setzen
  readAin();                               // Schreibe Set-Time
  
  countdowntime = inputtime;               // reset
    
}
}



void printTime ()
{
  minutes = countdowntime/60;           // Aufteilung von 'countdowntime' in Minuten
  seconds = countdowntime%60;           // und Sekunden
        
  if (minutes<10)                       // wenn minuten unter 10
  {                                     //  
    lcd.print('0');                     // schreibe "0" vor minuten
  }                                     //
        
  lcd.print(minutes);                   // gebe Minuten aus
  lcd.print(":");                       // schreibe ":"
      
  if (seconds<10)                       // wenn Sekunden unter 10
  {                                     //  
    lcd.print("0");                     // schreibe erst Null und dann
    lcd.print(seconds);                 // die Sekunden
    lcd.write(' ');                     // entferne Werte nach sekunden
  }                                     //
  else                                  //
  {                                     //
    lcd.print(seconds);                 // schreibe die Sekunden normal
    lcd.print(" ");                     //
  }                                     //
  
}

void readAin ()
{
inputtime = analogRead(varpin);           // Analogwert in 'inputtime' schreiben
int showminutes = inputtime /60;          // inputtime/60 = showminutes = Minuten ausrechnen
int showseconds = inputtime %60;          // inputtime%60 = showseconds = Sekunden ausrechnen

 if (showminutes<10)                      // wenn 'showminutes' unter 10
 {                                        //
   lcd.print('0');                        // schreibe erst "0"
 }                                        //
 
lcd.print(showminutes);                   // schreibe 'showminutes'
  
lcd.print(":");                           // schreibe ":"
    
if (showseconds<10)                       // wenn 'showseconds' unter 10
 {
   lcd.print("0");                        // schreibe erst Null
   lcd.print(showseconds);                // dann die Sekunden
   lcd.write(' ');                        // entferne letzte Ziffer
 }
 else                                     // wenn nicht
 {                                        //
   lcd.print(showseconds);                // schreibe die Sekunden normal
   lcd.print(" ");                        // und lösche die Ziffer dahinter
 }
 delay(150);                              // Verlangsame den kompletten vorgang
 
}
  


rpt007

Ihr wisst, dass der thread schon ein paar Jährchen auf dem Buckel hat?
Before you ask:
Did you really read and understand How to use this forum ?
AND:
Do you have already some solution or is a part of the problem sitting in front of the screen?  :)

uxomm

#11
Sep 23, 2018, 02:39 am Last Edit: Sep 23, 2018, 04:11 am by uxomm
Hallo squaremeter,

das Projekt hat mir sehr gut gefallen und ich habe es nachgebaut.
Auch ich suchte schon lange einen Timer mit Sekunden und Schaltausgang für meine Platinen.

Nun habe ich aber ein Problem.
Die Zeit wir im Display angezeigt und ich kann auch die Dauer verändern.
Aber ich weiß nicht wie ich den Timer starten soll.
Das mit der negativen Flanke habe ich nicht verstanden.
Ich würde mich freuen wenn ich eine Nachricht bekomme was ich falsch mache
bzw was ich machen muß damit der Timer startet.
Ich bin zwar nicht squaremeter, aber dessen letztes Post ist schon ein paar Jahre her. Wer weiß, ob er hier noch mitliest.

Im Code gibt es ein paar Fehler, die dazu führen, dass das Programm (zumindest mit einem Arduino) nicht optimal funktioniert:

a) Der wesentlichste: der Ausgang "uvout" ist nicht als Output deklariert.
Es fehlt also in Setup folgendes:
Code: [Select]
pinMode(uvout, OUTPUT);

b) Hier muss das Semikolon in der ersten Zeile gelöscht werden:
Code: [Select]
if (countdowntime <= 0);                 // wenn 'countdowntime 0
  {
    digitalWrite(uvout, LOW);              // schalte UV-Licht aus
  }

denn sonst bleibt die Bedingung ohne Auswirkungen und uvout wird immer LOW.
Das hat zwar auf den ersten Blick keine gravierenden Auswirkungen, denn ein paar Programmzeilen später wird uvout gleich wieder HIGH, aber der Ausgang wird dadurch in schneller Folge ein- und wieder ausgeschalten, je nachdem was da dran hängt kann das möglicherweise Probleme machen.

c) Arduino Pin D13 für den Schalt-Ausgang zu verwenden - wie hier der Fall - ist keine sehr gute Idee. Der Bootloader des Arduinos sorgt dafür, dass D13 beim "Einschalten" des Ardino mehrmals blinkt. Eine hier angeschlossene UV-Lampe (oder was auch immer) wird dann ebenfalls mehrmals ein- und ausgeschalten. Da würde ich also auf jeden Fall einen anderen Pin verwenden.

d) Was das soll erschließt sich mir nicht:
Code: [Select]
val = digitalRead(tick);                 // Overflow des Timers auslesen
aber es richtet wohl auch keinen Schaden an :)

Zu deiner Frage, wie du den Timer starten sollst:
Es steht eigentlich in der Beschreibung, ist aber möglicherweise etwas missverständlich.
So ist es jedenfalls gedacht:
Du drückst und hältst den Tasters gedrückt: Die gewünschte Zeit kannst du jetzt am Poti einstellen - falls du möchtest. Die Anzeige der gewählten Zeit erfolgt am LCD.

Sobald du den Taster loslässt (das ist mit "negativer Flanke" gemeint), startet der Countdown und der Ausgang "uvout" wird HIGH. Am LCD wird die Zeit heruntergezählt, beim Erreichen von 0 wird "uvout" wieder LOW.

Wichtig ist auch, dass du den Schaltplan beachtest. Der Taster braucht einen "Pulldown-Widerstand" (im Schaltplan: R1, 10 Kiloohm) und tastet gegen 5 Volt: beim Betätigen des Tasters liegt also 5 Volt am "buttonPin".
Always decouple electronic circuitry.

nordcap

Hallo UXOMM,

danke für Deine Antwort.
Ich hatte kaum damit gerechnet das noch jemand nach so langer Zeit antwortet.
Die Änderung im Code hab ich gemacht.
Das mit dem Starten hatte ich auch so gedacht wie Du geschrieben hast.
Bei mir ist das Problem das ich die Zeit mit dem Potentiometer einstellen kann
aber es wird nicht heruntergezählt.
In der ersten Zeile steht z.b. TIME 3:15 dann drücke ich den Taster und die Aufforderung SET kommt.
Ich lasse den Taster los und habe in der zweiten Zeile auch die 3:15 stehen mehr tut sich nicht.-
Die Schaltung habe ich 3x aufgebaut einmal mit dem Layout von squaremeter einmal hab ich selbst eine Platine geätzt und einmal auf dem Breadboard immer mit dem gleichen Ergebnis.

Vielen Dank nochmal
nordcap
 

postmaster-ino

#13
Sep 24, 2018, 09:01 pm Last Edit: Sep 24, 2018, 09:01 pm by postmaster-ino
Hi
Code: [Select]
val = digitalRead(tick);
Sicher, daß Das SO im Original steht?
(okok ... habe nachgeschaut, steht tatsächlich SO da drin ... ist aber trotzdem falsch)
Das würde, wenn tick==1 ist, den Pin 1 abfragen, bei tick==2, den Pin 2, ... kann mir nur schwer vorstellen, daß Das so gewollt ist.

Da der Timer tick alle Sekunde (denke ich jetzt Mal) um 1 hoch zählt, soll Da wohl eher val=tick; stehen, oder?

Hast Du Mal, spaßeshalber, diverse
Serial.print("Zeile ");Serial.println(__LINE__);
in Deinem Sketch verteilt, damit Du siehst, wo sich Dein Sketch rum drückt/wo Er hängen bleibt?

MfG

Go Up