Hilfe habe paar problem mit dem lcd keypad shield

Hallo,

es geht um folgendes, ich wollte eine sketch schreiben der mir mit dem taster vom keypad shield ermöglicht wird mit verschieden tasten verschieden Pins auf high zu setzen. das gelingt mir leider nicht. wenn ich serial.println eingebe dann wird die ganze zeit was ausgegeben, obwohl ich keine taste betätige! wollte auch eine zeitverzögerung einbauen wenn man eine andere taste betätigt die dazu deklariert wurde.
so sieht mein sketch bis jetzt aus. über hilfreiche tipps bin ich sehr dankbar

//#include <LCDKeypad.cpp>
#include <PWM.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd (8,9,4,5,6,7);

int NUM_KEYS = 5;
int key = -1;
int oldkey = -1;
int entprellzeit = 200;
int tasterstatus = LOW;
unsigned long tasterzeit =0; 

int tasterGedrueckt = 0;
int Pegel1=0;
int Pegel2=0;
int FehlerAusgabe=0;
int Versorgungsspannung=0;
// Zuweisung der Pins
const int Pwm1 = 22;           // Pegel 1
const int Pwm2 = 24;          //Pegel 2
const int Pwm3 = 26;          // Fehler Ausgabe
const int Pwm4 = 28;        //Versorgungsspannung
// Tasten zuweisen
int adc_key_in = 0;
int lcd_key = 0;

#define btnNONE 0            // Wenn kein Button gerdückt wird soll die Versorgungsspannung auf High gesetzt
#define btnSELECT 1            // Wenn die Button Select gedrückt wird soll Fehler ausgelöst werden
#define btnLEFT 2              // Wenn die Button Links gedrückt wird soll Pegel 2 auf High gesetzt werden
#define btnUP 3                // Wenn die Button Up gedrückt wird soll die Zeit um 1 µs erhöht werden
#define btnDOWN 4              // Wenn die Button Down gedrückt wird soll die Zeit um 1 µs verringert werden
#define btnRIGHT 5            // Wenn die Button Right gedrückt wird soll Pegel 1 auf High gesetzt werden



int read_LCD_buttons ()
{
  adc_key_in =  analogRead (0);  
  if (adc_key_in <20) return btnRIGHT;
  if (adc_key_in <180) return btnUP;
  if (adc_key_in <610) return btnDOWN;
  if (adc_key_in <890) return btnLEFT;
  if (adc_key_in <990) return btnSELECT;
  return btnNONE;
}

void setup() 
{
  Serial.begin (9600);


 lcd.clear(); 
 lcd.begin(16,2);     // Verfügung der Zeilen und Spalten des Displays
 lcd.setCursor(0,0);  //Ausgabe auf den Display Zeile und Spalte
 lcd.print ("  Right/Left    Up/Down  Select");
 lcd.setCursor(0,1); 
 lcd.print ("Level1/Level2   Time     Set  Fail");

    pinMode ( NUM_KEYS, INPUT); // Auslesen des Buttons 
    pinMode (Pwm4, OUTPUT);     // Wird als Ausgang deklariert
    digitalWrite (Pwm4, HIGH);  // Spannung Ausgabe
    pinMode (Pwm1, OUTPUT);
    digitalWrite (Pwm1, HIGH);
    pinMode (Pwm2, OUTPUT);
    digitalWrite (Pwm2, HIGH);
    pinMode (Pwm3, OUTPUT);
    digitalWrite (Pwm3, HIGH);
}  
  

 

void loop() 
 
{
  for (int positionCounter = 0 ; positionCounter <1; positionCounter++)
  {
    lcd.scrollDisplayRight();
    delay(400);
  }
   lcd_key = read_LCD_buttons ();
  switch (lcd_key)
  {
  case btnRIGHT:
  {
    lcd.clear ();
    lcd.begin(16,2);
    lcd.setCursor (3,0);
    lcd.print("Level1: 5-28v");
    digitalWrite (2,LOW);
    break;
  }
  { 
      case btnLEFT:
      lcd.clear ();
      lcd.print ("Level2: 1-25V");
      break;
    }
    { 
      case btnUP:
      lcd.clear();
      lcd.print("Increase Time");
      break;
    }
   {
    case btnDOWN:
    lcd.clear();
    lcd.print("Decrement Time");
    break;
  }
  { 
    case btnSELECT:
    lcd.clear();
    lcd.print("Set Fail");
    break;
  }
  }
         if ((millis()-tasterzeit> entprellzeit)&& tasterGedrueckt==0) //(btnNONE == HIGH && btnSELECT == LOW && btnUP == LOW && btnDOWN == LOW && btnLEFT == LOW && btnRIGHT == LOW)  // Kein Button betätigt
         {
            digitalWrite (Pwm4, HIGH);
            digitalWrite (Pwm1, LOW);
            digitalWrite (Pwm2, LOW);
            digitalWrite (Pwm3, LOW);
          }
   {
    tasterstatus = analogRead (adc_key_in);
    if (tasterstatus == HIGH)
  {
    tasterzeit= millis();
    tasterGedrueckt =1;
  }
    if ((millis()-tasterzeit> entprellzeit)&& tasterGedrueckt==1)// && btnRIGHT == HIGH && btnSELECT == LOW && btnUP == LOW && btnDOWN == LOW && btnLEFT == LOW && btnNONE == LOW) // Rechte Button betätigt
         { 
              Pegel1++;
              tasterGedrueckt =0;
          }
           if (Pegel1==0)
           {
            digitalWrite (Pwm1, HIGH);
            digitalWrite (Pwm4, LOW);
            digitalWrite (Pwm2, LOW);
            digitalWrite (Pwm3, LOW); 
           }
else if (Pegel1==1)
           {      
            digitalWrite (Pwm4, HIGH);
            digitalWrite (Pwm1, LOW);
            digitalWrite (Pwm2, LOW);
            digitalWrite (Pwm3, LOW);
           }
else
{
  Pegel1=0;
}
            tasterstatus = analogRead (adc_key_in);
            if (tasterstatus == HIGH)
  {
    tasterzeit= millis();
    tasterGedrueckt =1;
  }
  Serial.println(Pegel2);
    if ((millis()-tasterzeit> entprellzeit)&& tasterGedrueckt==1)// && btnLEFT == HIGH && btnSELECT == LOW && btnUP == LOW && btnDOWN == LOW && btnRIGHT == LOW btnNONE ==LOW) // linker button
           {  Pegel2++;
              tasterGedrueckt =0;
          }
           
           if (Pegel2==1)
               
           {
            digitalWrite (Pwm2, HIGH);
            digitalWrite (Pwm4, LOW);
            digitalWrite (Pwm1, LOW);
            digitalWrite (Pwm3, LOW); 
           }
            else if (Pegel2==2)
            {
            digitalWrite (Pwm4, HIGH);
            digitalWrite (Pwm2, LOW);
            digitalWrite (Pwm1, LOW);
            digitalWrite (Pwm3, LOW);
            }
else
{
  Pegel2 =0;
}
  tasterstatus = analogRead (adc_key_in);
            if (tasterstatus == HIGH)
  {
    tasterzeit= millis();
    tasterGedrueckt =1;
  }
            
   if ((millis()-tasterzeit> entprellzeit)&& tasterGedrueckt== 1)// &&btnSELECT == HIGH && btnLEFT == LOW && btnUP == LOW && btnDOWN == LOW && btnRIGHT == LOW && btnNONE == LOW)) // Select Button betätigt
           {
            FehlerAusgabe++;
            tasterGedrueckt =0;
           }
           if (FehlerAusgabe == 0)
           {
            digitalWrite (Pwm2, HIGH);
            digitalWrite (Pwm4, LOW);
            digitalWrite (Pwm1, LOW);
            digitalWrite (Pwm3, LOW);
            }
          else if (FehlerAusgabe == 1)
        {
            digitalWrite (Pwm4, HIGH);
            digitalWrite (Pwm2, LOW);
            digitalWrite (Pwm1, LOW);
            digitalWrite (Pwm3, LOW);
            
        }
        else
        {
          FehlerAusgabe =0;
          }
   }
}

Du schreibst leider nicht, was ständig ausgegeben wird.
Du solltest evtl. mit weniger umfangreichem Sketch die Funktionen testen.
Dann kannst du auch alles besser durchspielen.

Vielleicht kommen die Ausgaben von
Serial.println(Pegel2);

Etwas übersichtlicher wäre es, wenn Du den Code vor dem Posten schön formatierst.

HotSystems:
Du schreibst leider nicht, was ständig ausgegeben wird.
Du solltest evtl. mit weniger umfangreichem Sketch die Funktionen testen.
Dann kannst du auch alles besser durchspielen.

der gibt auf den serial port die ganze zeit 0 aus, das passiert wenn ich nichts drücke und wenn ich eine taste drücke.

ich bin anfänger habe da noch nicht so viel ahung

DrDiettrich:
Vielleicht kommen die Ausgaben von
Serial.println(Pegel2);

Etwas übersichtlicher wäre es, wenn Du den Code vor dem Posten schön formatierst.

was meinst du mit schön formatieren?
kann der fehler beim serial print liegen? und wenn ich es aufbaue das es funktioniert?

besteht den überhaupt die möglichkeit mit zb der rechten taste Pin 22 auf high und low zu stellen ohne die taste gedrückt zu halten?

Mau85:
es geht um folgendes, ich wollte eine sketch schreiben der mir mit dem taster vom keypad shield ermöglicht wird mit verschieden tasten verschieden Pins auf high zu setzen. das gelingt mir leider nicht. wenn ich serial.println eingebe dann wird die ganze zeit was ausgegeben, obwohl ich keine taste betätige! wollte auch eine zeitverzögerung einbauen wenn man eine andere taste betätigt die dazu deklariert wurde.
so sieht mein sketch bis jetzt aus. über hilfreiche tipps bin ich sehr dankbar

Das LCD Keypad Shield ist ein sehr schönes Shield, mit dem man viel machen kann.

Leider gibt es nur völlig bescheuerte Programmbeispiele zum Abfragen der Buttons auf diesem Shield.

An Deinem Programm scheint mir auch vieles im Argen zu liegen. Nicht nur die völlig verwurstete Programmlogik, sondern schon bei der Buttonerkennung und selbst bei der Zuordnung von gelesenen Analogwerten zu ihren Buttons - da ist einfach nichts stimmig!

Vielleicht solltest Du erstmal eine Nummer kleiner anfangen.

Da eine State-Change-Detection für 5 Tasten mit verschiedenen Analogwerten nicht ganz trivial zu programmieren ist, habe ich Dir mal ein eher anfängergeignetes Programm gemacht, das die Tastencodes ausliest, indem bei gedrückter Taste ein "Busy Waiting" gemacht wird, bis der Button wieder losgelassen wurde.

Einfacher Button-Counter mit dreistelliger Anzeige für jeden Button:

#include <LiquidCrystal.h>
LiquidCrystal lcd (8,9,4,5,6,7);

enum {btnNONE, btnSELECT, btnLEFT, btnUP, btnDOWN, btnRIGHT, NUM_KEYS };
const byte ButtonsPin= A0;

int read_LCD_buttons()
{
  int returnValue;
  // Lies den Wert des Butttons
  int adc_key_in =  analogRead (ButtonsPin);
  // Und prüfe durch nochmaliges Lesen, ob der Spannungswert stabil ist
  // diese zweite ADC-Ablesung dient quasi der "Entprellung"
  if (abs(analogRead(ButtonsPin)-adc_key_in)>1) return btnNONE; // wenn der ADC-Wert nicht stabil ist ==> return mit btnNONE
  if (adc_key_in <50) returnValue= btnRIGHT;
  else if (adc_key_in <195) returnValue= btnUP;
  else if (adc_key_in <380) returnValue= btnDOWN;
  else if (adc_key_in <555) returnValue= btnLEFT;
  else if (adc_key_in <790) returnValue= btnSELECT;
  else returnValue=btnNONE;
  // Anfängercode: "Busy waiting", bis keine Taste mehr gedrückt ist
  while(adc_key_in<790) adc_key_in= analogRead(ButtonsPin);
  return returnValue;
}

void setup() 
{
  Serial.begin (9600);
  lcd.begin(16,2);     // Verfügung der Zeilen und Spalten des Displays
  lcd.clear(); 
  lcd.print ("Button Counter");
}  

  
int pressCount[NUM_KEYS];

void loop() 
{
  int key= read_LCD_buttons();
  if (key> btnNONE) // es wurde eine Taste gedrückt
  {
    pressCount[key]++;
    char buf[17];
    snprintf(buf,sizeof(buf), "%3d%3d%3d%3d%3d", pressCount[1],pressCount[2],pressCount[3],pressCount[4],pressCount[5]);
    lcd.setCursor(0,1);
    lcd.print(buf);
    Serial.println(buf);
  }
}

Bei Veränderungen irgendeines Zählerstands werden die geänderten Werte sowohl auf LCD als auch auf Serial ausgegeben.

Ausgewertet werden nur Tastendrücke, es passiert im Programm nur dann etwas, wenn vorher

  • eine Taste gedrückt
  • und die gedrückte Taste auch wieder losgelassen wird

Achtung Anfängercode: Das Programm läuft nur dann blockierungsfrei durch die loop() Funktion, wenn keine Taste gedrückt ist, und solange eine Taste gedrückt ist, ist das Programm mit "Busy Waiting" so lange mit Warten beschäftigt, bis die Taste wieder losgelassen wurde.

Und was ganz wichtig ist, die Basics lernen.
Ohne die Grundlagen kommst du nicht weiter.
Siehe dir die Beispiele in der IDE an und übe damit. Danach kannst du auch mit dem Shield weiter machen und deine Frage hier gezielt stellen.

ok, ich schau mir die IDE an

danke für die hilfe und für den sketch

@ jurs, ich habe den Code getestet aber wenn ich den button Select drücke da passiert nichts.

@hotsystems wo finde ich die IDE?

Mau85:
@ jurs, ich habe den Code getestet aber wenn ich den button Select drücke da passiert nichts.

Diese Shields gibt es von unterschiedlichen Herstellern, die teilweise unterschiedliche Widerstandswerte in der Schaltung verwenden.

Teste mal mit diesem Sketch:

#include <LiquidCrystal.h>
LiquidCrystal lcd (8,9,4,5,6,7);

void setup() 
{
  lcd.begin(16,2);
}  

void loop() 
{
  int value= analogRead(A0);
  char buf[17];
  snprintf(buf,sizeof(buf), "%4d", value);
  lcd.setCursor(0,0);
  lcd.print(buf);
}

Und schreibe dann mal auf, welcher Button bei Deinem Shield welchen analogRead() Wert anzeigt!

Right = 0
Left = 613-614
Up=150
Down =385
Select = 960-961

Mau85:
Right = 0
Left = 613-614
Up=150
Down =385
Select = 960-961

Das sieht ja deutlich anders aus als bei meinem Shield, ich sehe hier:
kein - 1023
Right - 0
Left - 503
Up - 142
Down - 326
Select - 741

Insbesondere Dein Wert beim Drücken von "Select" liegt so hoch, wie ich es bei noch keinem solchen Shield gesehen habe.

Ich habe die Auslesefunktion mal so abgeändert, dass sowohl Dein als auch mein Shield beim Auslesen innerhalb der Toleranz liegen sollte und die richtigen Buttons als gedrückt zählt:

#include <LiquidCrystal.h>
LiquidCrystal lcd (8,9,4,5,6,7);

enum {btnNONE, btnSELECT, btnLEFT, btnUP, btnDOWN, btnRIGHT, NUM_KEYS };
const byte ButtonsPin= A0;

int read_LCD_buttons()
{
  int returnValue;
  // Lies den Wert des Butttons
  int adc_key_in =  analogRead (ButtonsPin);
  // Und prüfe durch nochmaliges Lesen, ob der Spannungswert stabil ist
  // diese zweite ADC-Ablesung dient quasi der "Entprellung"
  if (abs(analogRead(ButtonsPin)-adc_key_in)>1) return btnNONE; // wenn der ADC-Wert nicht stabil ist ==> return mit btnNONE
  if (adc_key_in <50) returnValue= btnRIGHT;
  else if (adc_key_in <195) returnValue= btnUP;
  else if (adc_key_in <410) returnValue= btnDOWN;
  else if (adc_key_in <650) returnValue= btnLEFT;
  else if (adc_key_in <999) returnValue= btnSELECT;
  else returnValue=btnNONE;
  // Anfängercode: "Busy waiting", bis keine Taste mehr gedrückt ist
  while(adc_key_in<999) adc_key_in= analogRead(ButtonsPin);
  return returnValue;
}

void setup() 
{
  Serial.begin (9600);
  lcd.begin(16,2);     // Verfügung der Zeilen und Spalten des Displays
  lcd.clear(); 
  lcd.print ("Button Counter");
}  

  
int pressCount[NUM_KEYS];

void loop() 
{
  int key= read_LCD_buttons();
  if (key> btnNONE) // es wurde eine Taste gedrückt
  {
    pressCount[key]++;
    char buf[17];
    snprintf(buf,sizeof(buf), "%3d%3d%3d%3d%3d", pressCount[1],pressCount[2],pressCount[3],pressCount[4],pressCount[5]);
    lcd.setCursor(0,1);
    lcd.print(buf);
    Serial.println(buf);
  }
}

Wenn das dann soweit funktioniert, kannst Du auf diese read_LCD_buttons() Funktion aufbauen.

Mau85:
@hotsystems wo finde ich die IDE?

Womit programmierst du den Arduino?
Wenn das die Software von Arduino ist, dann ist es die IDE.

ok, ich versuchs mal ich, danke dir schon mal recht herzlichst.

@hotsystems ja ich programmiere mit der software von arduino

Mau85:
ok, ich versuchs mal ich, danke dir schon mal recht herzlichst.

@hotsystems ja ich programmiere mit der software von arduino

Ja, das ist die IDE, schau mal unter "Datei/Beispiele". Die kannst du alle durchprobieren. :wink:

Mau85:
@hotsystems ja ich programmiere mit der software von arduino

"IDE" ist eine Abkürzung und steht für "Integrated Development Environment", also eine integrierte Plattform zur Softwareentwicklung wie es die Arduino-Software ist, bestehend aus, Editor, Compiler, mitgelieferten Libraries, Linker, Uploader, seriellem Monitor ...

Also "Arduino-Software" und "Arduino-IDE" ist quasi synonym zu gebrauchen.

jurs:
"IDE" ist eine Abkürzung und steht für "Integrated Development Environment", also eine integrierte Plattform zur Softwareentwicklung wie es die Arduino-Software ist, bestehend aus, Editor, Compiler, mitgelieferten Libraries, Linker, Uploader, seriellem Monitor ...

Also "Arduino-Software" und "Arduino-IDE" ist quasi synonym zu gebrauchen.

Und nicht zu vergessen, den vielen Beispielen. :wink: :wink:

wenn ich jetzt mit zb button rechts was anderes bewirken will als mit button links ändere ich dann etwas an key=read_LCD_Buttons? der müsste es selbst erkennen wegen den speicherzustände oder?

kann ich dann einfach sagen if (key == btnRIGHT)
dann tue das?

Mau85:
wenn ich jetzt mit zb button rechts was anderes bewirken will als mit button links ändere ich dann etwas an key=read_LCD_Buttons? der müsste es selbst erkennen wegen den speicherzustände oder?

kann ich dann einfach sagen if (key == btnRIGHT)
dann tue das?

Ja, Du liest in der Funktion aus, welcher Button gedrückt wurde und kannst dann je nachdem auf jeden Button anders reagieren:

void loop() 
{
  int key= read_LCD_buttons(); // gedrückte Taste auslesen
  if (key== btnLEFT) tueDies();
  if (key== btnRIGHT) tueDas();
  if (key== btnSELECT) tueGanzWasAnderes();
  // und ansonsten tue nichts
}

Es ist eben nur eine Abfrage, bei der gedrückte Tasten das Programm blockieren bis die Taste wieder losgelassen wird. D.h. wenn Du diese Funktion so verwendest, dann passiert die Aktion nicht dann, wenn die Taste runtergedrückt wird, sondern erst wenn sie wieder losgelassen wird.

ich hab es jetzt so versucht : denke aber das es nicht so klappen wird wie ich es mir gedacht habe. bezweifle dass, der program zurückspringt wenn ich zb wieder auf taste Right drücke oder andere tasten.

hier ist der Code

#include <LiquidCrystal.h>
LiquidCrystal lcd (8,9,4,5,6,7);

enum {btnNONE, btnSELECT, btnLEFT, btnUP, btnDOWN, btnRIGHT, NUM_KEYS };
const byte ButtonsPin= A0;

 // Pins vergabe
const int Pegel1= 22;
const int Pegel2= 24;
const int FehlerAusgabe = 26;
const int VersorgungsSpannung= 28;


int read_LCD_buttons()
{
  int returnValue;
  // Lies den Wert des Butttons
  int adc_key_in =  analogRead (ButtonsPin);
  // Und prüfe durch nochmaliges Lesen, ob der Spannungswert stabil ist
  // diese zweite ADC-Ablesung dient quasi der "Entprellung"
  if (abs(analogRead(ButtonsPin)-adc_key_in)>1) return btnNONE; // wenn der ADC-Wert nicht stabil ist ==> return mit btnNONE
  if (adc_key_in <50) returnValue= btnRIGHT;
  else if (adc_key_in <195) returnValue= btnUP;
  else if (adc_key_in <410) returnValue= btnDOWN;
  else if (adc_key_in <650) returnValue= btnLEFT;
  else if (adc_key_in <999) returnValue= btnSELECT;
  else returnValue=btnNONE;
  // Anfängercode: "Busy waiting", bis keine Taste mehr gedrückt ist
  while(adc_key_in<999) adc_key_in= analogRead(ButtonsPin);
  return returnValue;
}

void setup()
{
 // Pins mit High und Low 

 pinMode( ButtonsPin,INPUT);
 pinMode(Pegel1,OUTPUT);
 digitalWrite (Pegel1, HIGH);
 pinMode(Pegel2, OUTPUT);
 digitalWrite (Pegel2, HIGH);
 pinMode(FehlerAusgabe, OUTPUT);
 digitalWrite (FehlerAusgabe, HIGH);
 pinMode(VersorgungsSpannung, OUTPUT);
 digitalWrite (VersorgungsSpannung, HIGH);
 
 // LCD 
  
  Serial.begin (9600);
  lcd.begin(16,20);     // Verfügung der Zeilen und Spalten des Displays
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print ("  Right/Left    Up/Down  Select");
  lcd.setCursor(0,1); 
  lcd.print ("Level1/Level2   Time     Set  Fail");
} 

 
int pressCount[NUM_KEYS];

void loop()
{
  for (int positionCounter = 0 ; positionCounter <1; positionCounter++)
  {
    lcd.scrollDisplayRight();
    delay(400);
  }
  int key= read_LCD_buttons();
  if (key== btnNONE) // es wurde keine Taste gedrückt
  {
            // Versorgungsspannung soll aktiv sein

            digitalWrite (VersorgungsSpannung, HIGH);
            digitalWrite (Pegel1, LOW);
            digitalWrite (Pegel2, LOW);
            digitalWrite (FehlerAusgabe, LOW);
  }
  if (key== btnRIGHT) // es wurde die Rechte Taste gedrückt
  {
            digitalWrite (VersorgungsSpannung, LOW);
            digitalWrite (Pegel1, HIGH);
            digitalWrite (Pegel2, LOW);
            digitalWrite (FehlerAusgabe, LOW);
            
            // LCD ausgabe 
            lcd.clear();
            lcd.setCursor (0,0);
            lcd.print("Pegel1");
  }
   else if (key== btnNONE) 
   {
            // Versorgungsspannung soll wieder Aktiv sein nach wiederholten drücken der rechten Taste
            digitalWrite (VersorgungsSpannung, HIGH);
            digitalWrite (Pegel1, LOW);
            digitalWrite (Pegel2, LOW);
            digitalWrite (FehlerAusgabe, LOW);
   }
   if (key== btnLEFT) // es wurde die Linke Taste gedrückt
   {
            digitalWrite (VersorgungsSpannung, LOW);
            digitalWrite (Pegel1, LOW);
            digitalWrite (Pegel2, HIGH);
            digitalWrite (FehlerAusgabe, LOW);
            
            // LCD ausgabe 
            lcd.clear();
            lcd.setCursor (0,0);
            lcd.print("Pegel2");
   
   }
   else if (key== btnNONE) 
   {
            // Versorgungsspannung soll wieder Aktiv sein nach wiederholten drücken der linken Taste
            digitalWrite (VersorgungsSpannung, HIGH);
            digitalWrite (Pegel1, LOW);
            digitalWrite (Pegel2, LOW);
            digitalWrite (FehlerAusgabe, LOW);

   }
   if (key== btnSELECT)  // es wurde die Select Taste gedrückt
   {
            digitalWrite (VersorgungsSpannung, LOW);
            digitalWrite (Pegel1, LOW);
            digitalWrite (Pegel2, LOW);
            digitalWrite (FehlerAusgabe, HIGH);

            // LCD ausgabe 
            lcd.clear();
            lcd.setCursor (0,0);
            lcd.print("Fehlerausgabe");
   }

   else if (key== btnNONE) 
   {
            // Versorgungsspannung soll wieder Aktiv sein nach wiederholten drücken der select Taste
            digitalWrite (VersorgungsSpannung, HIGH);
            digitalWrite (Pegel1, LOW);
            digitalWrite (Pegel2, LOW);
            digitalWrite (FehlerAusgabe, LOW);
   }



   
  /*  pressCount[key]++;
    char buf[17];
    snprintf(buf,sizeof(buf), "%3d%3d%3d%3d%3d", pressCount[1],pressCount[2],pressCount[3],pressCount[4],pressCount[5]);
    lcd.setCursor(0,1);
    lcd.print(buf);
    Serial.println(buf);*/
  }

muss noch UP und DOWN bestimmen dafür muss ich mich noch rum lesen wie ich mit den tasten die Zeit inkrementieren bzw dekremntieren kann

danke

Mau85:
ich hab es jetzt so versucht : denke aber das es nicht so klappen wird wie ich es mir gedacht habe. bezweifle dass, der program zurückspringt wenn ich zb wieder auf taste Right drücke oder andere tasten.

Interaktive Einstelldialoge auf einem Mikrocontroller mit angeschlossener Hardware zu realisieren ist natürlich keine einfache Aufgabe für Programmieranfänger. Das ist eher etwas für erfahrene Programmierer und für Anfänger schon sehr anspruchsvoll.

Was soll denn das insgesamt werden:

  • auf dem LCD soll eine Zeit laufen, die intern im Controller gezählt wird (also ohne Echtzeit-RTC Modul)
  • und genau diese eine Zeit soll mit den Buttons einstellbar sein
  • zusätzlich sollen ein paar Pins HIGH und LOW einstellbar sein
    So ungefähr?

Oder vielleicht noch irgendwas ganz anderes?