Arduino: Menü mit switch-methode, mein Codeschnipsel dabei, bitte ansehen und meckern :P

[Ardu (Gast)]

Hi,

ich versuche ein Display Menü zu basteln, nachdem ich  mir zich 
unterschiedliche Möglickeiten angesehen habe und mir keines richtig 
einleuchtete. Hab überlegt, dass es doch mit der switch methode gehen 
müsste, nun aber mittendrin frag ich mich, ob das zu "dirty" ist, obs 
überhaupt funktioniert und wie ich die Tasterfunktion mit rein bringe, 
sollen drei Taster dran, zwei Richtungen und Menü/Ok. Hier mal der 
bisherige Versuch.

Mfg

    //MENU
    switch (menu)
    {
      case mainPage: //Main page

        display.clearDisplay();

        //Display time
        display.setCursor(16, 1); //Position text cursor for time display
        if (t.hour < 10) {
          display.print(" "); //Add leading space if single-digit hour
        }
        display.print(t.hour); //Display retrieved hours
        display.print(":"); //Display hour-minute separator
        if (t.min < 10) {
          display.print("0"); //Add leading zero if single-digit minute
        }
        display.print(t.min); //Display retrieved minutes
        display.print(":"); //Display minute-seconds separator
        if (t.sec < 10) {
          display.print("0"); //Add leading zero for single-digit seconds
        }
        display.print(t.sec); //Display retrieved seconds

      break;

      case setup: //Main settings menu

        display.clearDisplay();

        display.setCursor(1, 1);
        display.print("    Setup    ");
        display.drawLine(1, 9, 82, 1);

        display.setCursor(1, 10);
        display.print("Timer/Clock");

        display.setCursor(1, 45);
        display.print("Back");

        //Submenu
        switch (submenu)
        {
          case timer_clock: //Timer/clock settings menu

            display.clearDisplay();

            //Display head
            display.setCursor(0, 0);
            display.print(" Timer/Clock  ");
            display.drawLine(1, 9, 82, 1);

            //Display alarm 1
            display.setCursor(0, 10);
            display.print("On:");

            display.setCursor(0, 19); //Position text cursor for alarm 1 display
            if (wake_HOUR_1 < 10) {
              display.print(" "); //Add leading space if single-digit hour
            }
            display.print(wake_HOUR_1); //Display retrieved wake hours
            display.print(":"); //Display hour-minute separator
            if (wake_MINUTE_1 < 10) {
              display.print("0"); //Add leading zero if single-digit minute
            }
            display.print(wake_MINUTE_1); //Display retrieved wake minutes

            //Display alarm 2
            display.setCursor(36, 10);
            display.print("Off:");

            display.setCursor(36, 19); //Position text cursor for alarm 2 display
            if (wake_HOUR_2 < 10) {
              display.print(" "); //Add leading space if single-digit hour
            }
            display.print(wake_HOUR_2);
            display.print(":"); //Display hour-minute separator
            if (wake_MINUTE_2 < 10) {
              display.print("0"); //Add leading zero if single-digit minute
            }
            display.print(wake_MINUTE_2); //Display retrieved minutes

            //Display time
            display.setCursor(0, 28);
            display.print("Set time:");

            display.setCursor(0, 37); //Position text cursor for time display
            if (t.hour < 10) {
              display.print(" "); //Add leading space if single-digit hour
            }
            display.print(t.hour); //Display retrieved hours
            display.print(":"); //Display hour-minute separator
            if (t.min < 10) {
              display.print("0"); //Add leading zero if single-digit minute
            }
            display.print(t.min); //Display retrieved minutes
            display.print(":"); //Display minute-seconds separator
            if (t.sec < 10) {
              display.print("0"); //Add leading zero for single-digit seconds
            }
            display.print(t.sec); //Display retrieved seconds

            display.setCursor(0, 46);
            display.print("Back");

          break;
        }
        break;
    }

[Ardu (Gast)]

huhu :)

[Falk B. (falk)]

@ Ardu (Gast)

>ich versuche ein Display Menü zu basteln, nachdem ich  mir zich
>unterschiedliche Möglickeiten angesehen habe und mir keines richtig
>einleuchtete. Hab überlegt, dass es doch mit der switch methode gehen
>müsste,

Kann man machen.

> nun aber mittendrin frag ich mich, ob das zu "dirty" ist,

Nein.

> obs
>überhaupt funktioniert

Man sollte KEIN display.clearDisplay(); machen, denn das flackert immer 
beim Neuaufbau. Deutlich besser und schneller ist ein ÜBERSCHREIBEN das 
aktuellen Displays, incl. Leerzeichen natürlich.

>und wie ich die Tasterfunktion mit rein bringe,
>sollen drei Taster dran, zwei Richtungen und Menü/Ok. Hier mal der
>bisherige Versuch.

Die Taster liest man per Timer und Entprellung in einem Interrupt ein, 
siehe Entprellung, der Codeschnipsel von Peter ist ja schon legendär 
;-)

https://www.mikrocontroller.net/articles/Entprellung#Timer-Verfahren_.28nach_Peter_Dannegger.29

Dann gibt es eine Funktion, welche die Tasten ausliest. Damit geht man 
dann in den switch und reagiert entsprechend. Etwa so.

uint8_t key;

key = get_key_press( (1<<KEY1) | (1<<KEY2) | (1<<KEY3) )

switch (menu) {
  case mainPage:
    if (key & (1<<KEY1) ) {
      menu = setup;
    }
  break;

[Ardu (Gast)]

Juhu, eine Antwort :D ...

Du meinst die Bereiche des alten Bildes mit Leerzeichen im neuen 
überschreiben?

Die Taster entprelle ich so:

  //Menu/set button open menu - outside time/display update processing for faster button response
  if (!digitalRead(8)) { //Read menu/set button
    delay(25); //25ms debounce time
    if (!digitalRead(8)) { //Activate setting mode change after 100ms button press
      menu = menu; //Increment the setting mode on each button press
      }
      while (!digitalRead(8)) {} //Wait for button release
    }

Naja, ich werds erstmal so versuchen...

Cool, so habe ich auch gedacht, die Taster-If's in die Switch-Ebenen 
einzubauen und darauf hoffen, dass sie dann entsprechen innerhalb der 
Switch-Ebenen funktionieren, d.h. dass der Menü-Button automatisch zum 
Ok-Button wird. Denke ich so richtig?

Vielen lieben Dank soweit, nur eine Antwort, aber absolut perfekt :)

[Ardu (Gast)]

Guten Morgen :)

Mal kurz den Fred aufwärmen...

[Leuchte, die (Gast)]

seehr wartbar, dieses eeeelllllenlaaaaange switch statement; aber sowas 
von.

Der Übersicht halber, sollte so eine Verzweigungsleiter doch +/- 
innerhalb 1 Bildschirmseite Platz finden, auch nach künftigen 
Erweiterungen.

Also vllt. Funktionen schreiben:

:
  switch(menuContext->wahl) {
  case MENU1: f_MENU1(menuContext); break;
  case MENU2: f_MENU2(menuContext); break;
  case MENU3: f_MENU3(menuContext); break;
  default: implVersemmelt(menuContext);
  }

  Der aufmerksame Codeleser sieht aber dass sowas nach Funktionstabellen 
riecht, usw...

[Falk B. (falk)]

@Ardu (Gast)

>Du meinst die Bereiche des alten Bildes mit Leerzeichen im neuen
>überschreiben?

Ja.

>Die Taster entprelle ich so:

Nicht wirklich gut, vor allem weil du auf das Loslassen des Tasters 
wartest. Das ist unnötig und kontraproduktiv. Denn wenn der Anwender, 
warum auch immer, die Taste gedrückt hält, steht dein Programm!

Wichtig ist die logische Trennung von Tastenentprellung und 
Weiterverarbeitung in deiner Statemachine. Die ist in deinem 
Beispiel NICHT drin, das ist unbrauchbar. Wie es richtig geht habe ich 
dir schon gesagt.

Für den ersten schnellen Test kann man es so machen, später ist ein 
Timer DRINGEND zu empfehlen.

#define KEY_MENU_UP 1
#define KEY_MENU_DOWN 2
#define KEY_MENU_OK 4
#define KEY_MENU_ESCAPE 8


uint8_t get_key(void) {
  static uint8_t key_old;
  uint8_t key, press;

  key = 0;

  // sample multiple keys
  if (digital_read(8)) key |= KEY_MENU_UP;
  if (digital_read(9)) key |= KEY_MENU_DOWN;
  if (digital_read(10)) key |= KEY_MENU_OK;
  if (digital_read(11)) key |= KEY_MENU_ESCAPE;

  press = key & ~old_key;   // active edge of keys
  delay(10);   //10ms debounce time
  key_old = key;
  return press;
}

//....

menu_key = get_key();

if (menu_key & KEY_MENU_UP) { // mach was bei Taste MENU_UP
}

if (menu_key & KEY_MENU_OK) { // mach was bei Taste MENU_OK
}

// etc.

>Cool, so habe ich auch gedacht, die Taster-If's in die Switch-Ebenen
>einzubauen und darauf hoffen, dass sie dann entsprechen innerhalb der
>Switch-Ebenen funktionieren, d.h. dass der Menü-Button automatisch zum
>Ok-Button wird. Denke ich so richtig?

Ja.

[Ardu (Gast)]

Ahaaa, super, das sind mal super Wegweiser, so ergibt sich auch mehr ein 
Sinn aus den Beispielen, die ich so ergoogelt habe, und zwar eure beiden 
Antworten. Das mit den Funktionen, also "void menu", "void submenu" 
etc., die dann über die Tasten-Switches abgerufen werden, und in diesem 
Zusammenhang auch das Tasterbeispiel, welches sich ebenso in den 
Beispielen findet, aber komplizierter und mit timer, aber da das jetzt 
mehr Sinn für mich ergibt, werden ich die noch einige Male lesen, bis 
ich wieder "ahaa" denke ;P

Hab mit folgendem Code angefangen zu lernen, bin noch Anfänger, verstehe 
aber schon recht viel, bin erstaunt darüber, wie verhätnismäßig einfach 
Arduino ist, liegt zwar auch daran, dass ich Visual Basic, HTML und Java 
gelernt habe, da bin ich  etwa fortschrittlicher Anfänger, aber 
dennoch...

Jedenfalls ist da eine "flash"-Funktion eingebaut, die den Timer 
darstellt, verstehe diese aber erstens nicht ganz und zweitens gefällt 
mir auch nicht, dass das Blinke des Rechtecks, (display.drawRect), 
ungleichmäßig ist, etwa vier Mal und dann kurzer Hänger, so reagieren 
auch die I/O, also Taster und LED, diese Blinken exakt im selben Takt, 
ist zwar nur einen Software-Bastelei zum Üben, aber wenn ich weiter gehe 
und über Transistoren schalten will, ist das wohl sehr unvorteilhaft. 
Andereseits sorgt das "flash"en für eine saubere Aktualisierung des 
Displays, die Sekunden fangen an bei einer Verzögerung von 250ms zu 
stocken. Weiss also nicht so konkret wie ich da vorgehen soll.

Ich merke aufgrund der langen Antwortzeiten und weiss, dass das Thema 
nicht so reizvoll ist und vielleicht sogar nervt, aber als Anfänger 
braucht man eben diese Denkanstöße, daher bin ich euch sehr dankbar 
dafür und für weitere Hilfe.

Wünsche euch noch ein schönes Wochenende und vielen lieben Dank nochmals 
:)

Code:

#include <SPI.h> //Library for Adafruit communication to OLED display
#include <Wire.h> //I2C communication library
#include "ds3231.h" //Real Time Clock library
#include <Adafruit_GFX.h> //Graphics library
#include <Adafruit_SSD1306.h> //OLED display library

uint8_t secset = 0; //Index for second RTC setting
uint8_t minset = 1; //Index for minute RTC setting
uint8_t hourset = 2; //Index for hour RTC setting
uint8_t wdayset = 3; //Index for weekday RTC setting
uint8_t mdayset = 4; //Index for date RTC setting
uint8_t monset = 5; //Index for month RTC setting
uint8_t yearset = 6; //Index for year RTC setting

//Alarm time variables
uint8_t wake_HOUR = 0;
uint8_t wake_MINUTE = 0;
uint8_t wake_SECOND = 0;
uint8_t wake_SET = 1; //Default alarm to ON in case of power failure or reset

#define OLED_RESET 4 //Define reset for OLED display
Adafruit_SSD1306 display(OLED_RESET); //Reset OLED display

//Check for proper display size - required
#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

unsigned long prev, interval = 100; //Variables for display/clock update rate
byte flash = 0; //Flag for display flashing - toggle once per update interval
byte mode = 0; //Mode for time and date setting
int tempset; //Temporary variable for setting time/date
int beepcount = 0; //Variable for number of 100ms intervals since alarm started sounding


void setup()
{
Serial.begin(9600); //Initialize serial port, if needed (not used)
Wire.begin(); //Initialize I2C communication library
DS3231_init(0x00); //Initialize Real Time Clock for 1Hz square wave output (no RTC alarms on output pin)

pinMode(8, INPUT); //Set pin for time/date mode button to input
digitalWrite(8, HIGH); //Turn on pullup resistors

pinMode(9, INPUT); //Set pin for time/date set button to input
digitalWrite(9, HIGH); //Turn on pullup resistors

pinMode(10, OUTPUT); //Set pin for external alarm indicator output
digitalWrite(10, LOW); //Initialize external alarm to off state
    
    
// by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3D (for the 128x64 OLED display)
display.setTextSize(1); //Set default font size to the smalles
display.setTextColor(WHITE); //Set font to display color on black background
// init done
}

void loop()
{
char tempF[6]; //Local variable to store converted temperature reading from Real Time Clock module
float temperature; //Intermediate temperature variable to convert Celsius to Farenheit
unsigned long now = millis(); //Local variable set to current value of Arduino internal millisecond run-time timer
struct ts t; //Structure for retrieving and storing time and date data from real time clock

//Draw and update display every refresh period (100ms)
if ((now - prev > interval)) { //Determine whether to start a time and screen update
  if(flash == 0){flash = 1;}else{flash = 0;} //Toggle flash flag for cursor blinking later
  DS3231_get(&t); //Get time and date and save in t structure
  
  get_alarm(); //Retrieve current alarm setting
  digitalWrite(10, LOW); //Turn off external alarm for flashing
  
  //Force a temperature conversion if one is not in progress for rapid update and better clock accuracy
  //Maintain 1Hz square wave output
  if((DS3231_get_addr(0x0E) & 0x20) == 0){DS3231_init(0x20);} //Check for CONV flag to see if conversion is in progress first, else start conversion
  temperature = DS3231_get_treg(); //Get temperature from real time clock
  temperature = (temperature * 1.8) + 32.0; // Convert Celsius to Fahrenheit
  dtostrf(temperature, 5, 1, tempF); //Convert temperature to string for display

  display.clearDisplay(); //Clear display buffer from last refresh
  
//NOTE: Alarm indicators are overwritten in display buffer if full-screen animation is displayed, so no check for that  
  if (mode <= 7){ //Alarm indicators and actions in normal and time set display mode only
  if (wake_SET){ //Display alarm on indicator if alarm turned on
    display.setCursor(43, 55); //Position text cursor for alarm on indicator
    display.print("*"); //Print character inside lower left corner of analog clock if alarm on
  }
  }

  if(wake_SET && DS3231_triggered_a1()){ //Display/sound alarm if enabled and triggered
      beepcount = beepcount + 1;
      if(beepcount <= 600){ //Sound alarm for 60 seconds
        if(!flash){ //Flash display and sound interrupted beeper
        if(mode <= 7){display.setCursor(81, 55); display.print("*");} //Flash alarm triggered indicator in lower right corner of analog clock, if displayed
        digitalWrite(10, HIGH); //Flash external alarm if alarm triggered, regardless of mode
        }
      }
      else{beepcount = 0; DS3231_clear_a1f();} //If alarm has sounded for 1 minute, reset alarm timer counter and alarm flag
  }

  if (mode <=7){      
  display.setCursor(92,8); //Set cursor for temperature display
  display.print(tempF); //Send temperature to display buffer
  display.drawCircle(124,8,2,WHITE); //Draw degree symbol after temperature

//DO NOT CHANGE CURSOR POSITIONING OF TIME AND DATE TEXT FIELDS OR TIME/DATE SET CURSOR WON'T MATCH!!!     
  display.setCursor(0,0); //Position cursor for day-of-week display
  printDay(t.wday); //Lookup day of week string from retrieved RTC data and write to display buffer
        
  printMonth(t.mon); //Lookup month string from retrieved RTC data and write to display buffer
        
  if(t.mday<10){display.print("0");} //Add leading zero to date display if date is single-digit
  display.print(t.mday); //Write date to display buffer
  display.print(", "); //Write spaces and comma between date and year
        
  display.print(t.year); //Write year to display buffer
        
  display.setCursor(0, 8); //Position text cursor for time display
        
  //RTC is operated in 24-hour mode and conversion to 12-hour mode done here, in software
  if(t.hour == 0){display.print("12");} //Convert zero hour for 12-hour display
    else if(t.hour < 13 && t.hour >= 10){display.print(t.hour);} //Just display hour if double digit hour
        else if(t.hour < 10){display.print(" "); display.print(t.hour);} //If single digit hour, add leading space
        else if(t.hour >= 13 && t.hour >= 22){display.print(t.hour-12);} //If double digit and PM, convert 24 to 12 hour
        else{display.print(" "); display.print(t.hour-12);} //If single digit and PM, convert to 12 hour and add leading space
        
        display.print(":"); //Display hour-minute separator
        if(t.min<10){display.print("0");} //Add leading zero if single-digit minute
        display.print(t.min); //Display retrieved minutes
        
        display.print(":"); //Display minute-seconds separator
        if(t.sec<10){display.print("0");} //Add leading zero for single-digit seconds
        display.print(t.sec); //Display retrieved seconds
        
        if(t.hour < 12){display.print(" AM");} //Display AM indicator, as needed
        else{display.print(" PM");} //Display PM indicator, as needed
              

    // Now draw the clock face
    display.drawCircle(display.width()/2, display.height()/2 + 8, 20, WHITE); //Draw and position clock outer circle
    //display.fillCircle(display.width()/2+25, display.height()/2 + 8, 20, WHITE); //Fill circle only if displaying inverted colors
    if(flash){display.drawCircle(display.width()/2, display.height()/2 + 8, 2, WHITE);} //Draw, position and blink tiny inner circle
    display.drawRect(41,17,47,47,WHITE); //Draw box around clock

    //Position and draw hour tick marks
    for( int z=0; z < 360;z= z + 30 ){
    //Begin at 0° and stop at 360°
      float angle = z ;
      angle=(angle/57.29577951) ; //Convert degrees to radians
      int x2=(64+(sin(angle)*20));
      int y2=(40-(cos(angle)*20));
      int x3=(64+(sin(angle)*(20-5)));
      int y3=(40-(cos(angle)*(20-5)));
      display.drawLine(x2,y2,x3,y3,WHITE);
    }
  
    //Position and display second hand
    float angle = t.sec * 6 ; //Retrieve stored seconds and apply
    angle=(angle/57.29577951) ; //Convert degrees to radians  
    int x3=(64+(sin(angle)*(20)));
    int y3=(40-(cos(angle)*(20)));
    display.drawLine(64,40,x3,y3,WHITE);

   //Position and display minute hand
    angle = t.min * 6; //Retrieve stored minutes and apply
    angle=(angle/57.29577951) ; //Convert degrees to radians  
    x3=(64+(sin(angle)*(20-3)));
    y3=(40-(cos(angle)*(20-3)));
    display.drawLine(64,40,x3,y3,WHITE);

    //Position and display hour hand
    angle = t.hour * 30 + int((t.min / 12) * 6); //Retrieve stored hour and minutes and apply
    angle=(angle/57.29577951) ; //Convert degrees to radians  
    x3=(64+(sin(angle)*(20-11)));
    y3=(40-(cos(angle)*(20-11)));
    display.drawLine(64,40,x3,y3,WHITE);
  }
  
    if (mode > 7){ 
      display.setCursor(0, 0); //Position text cursor
      display.print("Alarm Set: ");
      if(wake_SET){display.print("ON");}else{display.print("OFF");}
      display.setCursor(0, 8); //Position text cursor for time display
        
      //RTC is operated in 24-hour mode and conversion to 12-hour mode done here, in software
      if(wake_HOUR == 0){display.print("12");} //Convert zero hour for 12-hour display
        else if(wake_HOUR < 13 && wake_HOUR >= 10){display.print(wake_HOUR);} //Just display hour if double digit hour
            else if(wake_HOUR < 10){display.print(" "); display.print(wake_HOUR);} //If single digit hour, add leading space
            else if(wake_HOUR >= 13 && wake_HOUR >= 22){display.print(wake_HOUR-12);} //If double digit and PM, convert 24 to 12 hour
            else{display.print(" "); display.print(wake_HOUR-12);} //If single digit and PM, convert to 12 hour and add leading space
        
            display.print(":"); //Display hour-minute separator
            if(wake_MINUTE<10){display.print("0");} //Add leading zero if single-digit minute
            display.print(wake_MINUTE); //Display retrieved minutes
        
            display.print(":"); //Display minute-seconds separator
            if(wake_SECOND<10){display.print("0");} //Add leading zero for single-digit seconds
            display.print(wake_SECOND); //Display retrieved seconds
        
            if(wake_HOUR < 12){display.print(" AM");} //Display AM indicator, as needed
            else{display.print(" PM");} //Display PM indicator, as needed
    }

 
//Time/Date setting button processing and cursor flashing
//CURSOR COORDINATES ARE SET TO MATCH TIME/DATE FIELD - DO NOT CHANGE!!
//Digital and analog time/date display updates with new settings at 5Hz as settings are changed
  switch(mode)
  {
    case 0: break;
    case 1: //Day-of-week setting
      if(flash){display.drawRect(0,0,18,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = t.wday; //Get the current weekday and save in temporary variable
        tempset = tempset + 1; //Increment the day at 5Hz rate
        if(tempset > 7){tempset = 1;} //Roll over after 7 days
        t.wday = tempset; //After each update, write the day back to the time structure
        set_rtc_field(t, wdayset); //Write the set field only back to the real time clock module after each update
      }
      break;
    case 2: //Month setting
      if(flash){display.drawRect(24,0,18,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = t.mon; //Get the current month and save in temporary variable
        tempset = tempset + 1; //Increment the month at 5Hz rate
        if(tempset > 12){tempset = 1;} //Roll over after 12 months
        t.mon = tempset; //After each update, write the month back to the time structure
        set_rtc_field(t, monset); //Write the set field only back to the real time clock module after each update
      }
      break;
    case 3: //Date setting
      if(flash){display.drawRect(48,0,12,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = t.mday; //Get the current date and save in temporary variable
        tempset = tempset + 1; //Increment the date at 5Hz rate
        //(RTC allows incorrect date setting for months < 31 days, but will use correct date rollover for subsequent months.
        if(tempset > 31){tempset = 1;} //Roll over after 31 days
        t.mday = tempset; //After each update, write the date back to the time structure 
        set_rtc_field(t, mdayset); //Write the set field only back to the real time clock module after each update
      }
      break;
    case 4: //Year setting
      if(flash){display.drawRect(72,0,24,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = t.year; //Get the current year and save in temporary variable
        tempset = tempset + 1; //Increment the year at 5Hz rate
        //RTC allows setting from 1900, but range limited here to 2000 to 2099
        if(tempset > 2099){tempset = 2000;} //Roll over after 2099 to 2000
        t.year = tempset; //After each update, write the year back to the time structure
        set_rtc_field(t, yearset); //Write the set field only back to the real time clock module after each update
      } 
      break;
    case 5: //Hour setting
      if(flash){display.drawRect(0,8,12,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = t.hour; //Get the current hour and save in temporary variable
        tempset = tempset + 1; //Increment the hour at 5Hz rate
        if(tempset > 23){tempset = 0;} //Roll over hour after 23rd hour (setting done in 24-hour mode)
        t.hour = tempset; //After each update, write the hour back to the time structure
        set_rtc_field(t, hourset); //Write the set field only back to the real time clock module after each update
      }
      break;
    case 6: //Minute setting
      if(flash){display.drawRect(18,8,12,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = t.min; //Get the current minute and save in temporary variable
        tempset = tempset + 1; //Increment the minute at 5Hz rate
        if(tempset > 59){tempset = 0;} //Roll over minute to zero after 59th minute
        t.min = tempset; //After each update, write the minute back to the time structure
        set_rtc_field(t, minset); //Write the set field only back to the real time clock module after each update
      }
      break;
      
     //Set clock + 1 minute, then press and hold to freeze second setting.
     //Release button at 00 seconds to synchronize clock to external time source.
    case 7: //Second synchronization
      if(flash){display.drawRect(36,8,12,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Reset second to zero at 5Hz rate if button held down
        t.sec = 0; //After each update, write the zeroed second back to the time structure
        set_rtc_field(t, secset); //Write the set field only back to the real time clock module after each update
      }
      break;
      
      
    case 8: //Alarm hour setting
      if(flash){display.drawRect(0,8,12,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = wake_HOUR; //Get the current hour and save in temporary variable
        tempset = tempset + 1; //Increment the hour at 5Hz rate
        if(tempset > 23){tempset = 0;} //Roll over hour after 23rd hour (setting done in 24-hour mode)
        wake_HOUR = tempset; //After each update, write the hour back to the alarm variable
        set_alarm(); //Write the alarm setting back to the RTC after each update
      }
    break;
    
    
    case 9: //Alarm minute setting
      if(flash){display.drawRect(18,8,12,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        tempset = wake_MINUTE; //Get the current minute and save in temporary variable
        tempset = tempset + 1; //Increment the minute at 5Hz rate
        if(tempset > 59){tempset = 0;} //Roll over minute to zero after 59th minute
        wake_MINUTE = tempset; //After each update, write the minute back to the alarm variable
        set_alarm(); //Write the alarm setting back to the RTC after each update
      }
    break;
    
     case 10: //Alarm enable/disable
      if(flash){display.drawRect(66,0,18,8,WHITE);} //Display rectangle cursor every other display update (5Hz blink)
      if(!digitalRead(9) && (!flash)){ //Update setting at 5Hz rate if button held down
        if(wake_SET){wake_SET = 0;}else{wake_SET = 1;} //Toggle alarm on/of variable at 5 Hz
      }
    break;
  }
        
prev = now; //Reset variable for display and time update rate
display.display(); //Display the constructed frame buffer for this framecount
    }
    
//Clock setting mode set - outside time/display update processing for faster button response
if(!digitalRead(8)){ //Read setting mode button
  delay(25); //25ms debounce time
  if(!digitalRead(8)){ //Activate setting mode change after 100ms button press
    mode = mode + 1; //Increment the time setting mode on each button press
    if(mode > 10){mode = 0;} //Roll the mode setting after 7th mode
    while(!digitalRead(8)){} //Wait for button release (freezes all display processing and time updates while button held, but RTC continues to keep time)
  }
 }
 
 if(!digitalRead(9)){ //Reset alarm flag if set button pressed
   delay(25); //25ms debounce time
   if(!digitalRead(9)){DS3231_clear_a1f();} //Clear alarm flag if set button pressed - insures alarm reset when turning alarm on
 }
}



//Function to display month string from numerical month argument
void printMonth(int month)
{
  switch(month)
  {
    case 1: display.print("Jan ");break;
    case 2: display.print("Feb ");break;
    case 3: display.print("Mar ");break;
    case 4: display.print("Apr ");break;
    case 5: display.print("May ");break;
    case 6: display.print("Jun ");break;
    case 7: display.print("Jul ");break;
    case 8: display.print("Aug ");break;
    case 9: display.print("Sep ");break;
    case 10: display.print("Oct ");break;
    case 11: display.print("Nov ");break;
    case 12: display.print("Dec ");break;
    default: display.print("--- ");break; //Display dashes if error - avoids scrambling display
  } 
}


//Function to display day-of-week string from numerical day-of-week argument
void printDay(int day)
{
  switch(day)
  {
    case 1: display.print("Mon ");break;
    case 2: display.print("Tue ");break;
    case 3: display.print("Wed ");break;
    case 4: display.print("Thu ");break;
    case 5: display.print("Fri ");break;
    case 6: display.print("Sat ");break;
    case 7: display.print("Sun ");break;
    default: display.print("--- ");break; //Display dashes if error - avoids scrambling display
  } 
}

//Subroutine to adjust a single date/time field in the RTC
void set_rtc_field(struct ts t,  uint8_t index)
{
    uint8_t century;

    if (t.year > 2000) {
        century = 0x80;
        t.year_s = t.year - 2000;
    } else {
        century = 0;
        t.year_s = t.year - 1900;
    }

    uint8_t TimeDate[7] = { t.sec, t.min, t.hour, t.wday, t.mday, t.mon, t.year_s };

    Wire.beginTransmission(DS3231_I2C_ADDR);
    Wire.write(index);
        TimeDate[index] = dectobcd(TimeDate[index]);
        if (index == 5){TimeDate[5] += century;}
        Wire.write(TimeDate[index]);
    Wire.endTransmission();
    
    //Adjust the month setting, per data sheet, if the year is changed
    if (index == 6){
      Wire.beginTransmission(DS3231_I2C_ADDR);
      Wire.write(5);
      TimeDate[5] = dectobcd(TimeDate[5]);
      TimeDate[5] += century;
      Wire.write(TimeDate[5]);
      Wire.endTransmission();
    } 
}


//Subroutine to set alarm 1
void set_alarm()
{

    // flags define what calendar component to be checked against the current time in order
    // to trigger the alarm - see datasheet
    // A1M1 (seconds) (0 to enable, 1 to disable)
    // A1M2 (minutes) (0 to enable, 1 to disable)
    // A1M3 (hour)    (0 to enable, 1 to disable) 
    // A1M4 (day)     (0 to enable, 1 to disable)
    // DY/DT          (dayofweek == 1/dayofmonth == 0)
    boolean flags[5] = { 0, 0, 0, 1, 1 }; //Set alarm to trigger every 24 hours on time match

    // set Alarm1
    DS3231_set_a1(0, wake_MINUTE, wake_HOUR, 0, flags); //Set alarm 1 RTC registers

}

//Subroutine to get alarm 1
void get_alarm()
{
    uint8_t n[4];
    uint8_t t[4];               //second,minute,hour,day
    uint8_t f[5];               // flags
    uint8_t i;

    Wire.beginTransmission(DS3231_I2C_ADDR);
    Wire.write(DS3231_ALARM1_ADDR);
    Wire.endTransmission();

    Wire.requestFrom(DS3231_I2C_ADDR, 4);

    for (i = 0; i <= 3; i++) {
        n[i] = Wire.read();
        f[i] = (n[i] & 0x80) >> 7;
        t[i] = bcdtodec(n[i] & 0x7F);
    }

    f[4] = (n[3] & 0x40) >> 6;
    t[3] = bcdtodec(n[3] & 0x3F);
    
    wake_SECOND = t[0];
    wake_MINUTE = t[1];
    wake_HOUR = t[2];
}

[Falk B. (falk)]

@ Ardu (Gast)

>Jedenfalls ist da eine "flash"-Funktion eingebaut, die den Timer
>darstellt, verstehe diese aber erstens nicht ganz

Das ist eine ganz normale Variable, welche als bool-Wert genutzt wird. 
Bei jedem Aufruf deines Riesenkonstrukts

>if ((now - prev > interval)) { //Determine whether to start a time and screen 
update

wird flash invertiert.

>  if(flash == 0){flash = 1;}else{flash = 0;} //Toggle flash flag for cursor 
blinking later

Das kann man auch deutlich einfacher schreiben.

flash = !flash;

Damit wechselt (eng. toggle) der Wert bei jedem Durchlauf des 
Konstrukts, damit kann man ein Blinken eines Cursors steuern. Und genau 
das wird auch gemacht.


>und zweitens gefällt
>mir auch nicht, dass das Blinke des Rechtecks, (display.drawRect),
>ungleichmäßig ist, etwa vier Mal und dann kurzer Hänger, so reagieren
>auch die I/O, also Taster und LED, diese Blinken exakt im selben Takt,

Tja, das ist das Problem der blockierenden Programmierweise. Sagte ich 
bereits. Es gibt KEINEN Grund, auf das Loslassen der Taste zu warten. 
Man muss den Zustandswechsel der Taste erkennen und auswerten. Siehe 
mein Beispiel!
Weiterhin sind an einigen Stellen ein paar eher aufwändige Rechnungen 
drin, die dauern eine Weile, das könnte der Grund für das ungleichmäßige 
Anzeigen sein, denn diese Anzeigen sind von der Variablen flash 
abhängig.
Das hier z.B.

    //Position and draw hour tick marks
    for( int z=0; z < 360;z= z + 30 ){
    //Begin at 0° and stop at 360°
      float angle = z ;
      angle=(angle/57.29577951) ; //Convert degrees to radians
      int x2=(64+(sin(angle)*20));
      int y2=(40-(cos(angle)*20));
      int x3=(64+(sin(angle)*(20-5)));
      int y3=(40-(cos(angle)*(20-5)));
      display.drawLine(x2,y2,x3,y3,WHITE);
    }

>ist zwar nur einen Software-Bastelei zum Üben, aber wenn ich weiter gehe
>und über Transistoren schalten will, ist das wohl sehr unvorteilhaft.
>Andereseits sorgt das "flash"en für eine saubere Aktualisierung des
>Displays, die Sekunden fangen an bei einer Verzögerung von 250ms zu
>stocken.

Wie meinst du das? Welche Verzögerung und wo?

Noch ein Tipp. Die Formatierung deines Quelltextes ist 
verbesserungsfähig. Sowas macht man nicht!

if(t.hour == 0){display.print("12");} //Convert zero hour for 12-hour display
    else if(t.hour < 13 && t.hour >= 10){display.print(t.hour);} //Just display hour if double digit hour
        else if(t.hour < 10){display.print(" "); display.print(t.hour);} //If single digit hour, add leading space
        else if(t.hour >= 13 && t.hour >= 22){display.print(t.hour-12);} //If double digit and PM, convert 24 to 12 hour
        else{display.print(" "); display.print(t.hour-12);} //If single digit and PM, convert to 12 hour and add leading space
        
        display.print(":"); //Display hour-minute separator
        if(t.min<10){display.print("0");} //Add leading zero if single-digit minute
        display.print(t.min); //Display retrieved minutes
        
        display.print(":"); //Display minute-seconds separator
        if(t.sec<10){display.print("0");} //Add leading zero for single-digit seconds
        display.print(t.sec); //Display retrieved seconds
        
        if(t.hour < 12){display.print(" AM");} //Display AM indicator, as needed
        else{display.print(" PM");} //Display PM indicator, as needed

Das ist maximal irreführend und man sieht nicht, in welchen Block was 
reingehört!

Strukturierte Programmierung auf Mikrocontrollern

Besser so.

if(t.hour == 0) {//Convert zero hour for 12-hour display
  display.print("12");
} else if(t.hour < 13 && t.hour >= 10) { //Just display hour if double digit hour
  display.print(t.hour);
} else if(t.hour < 10) { //If single digit hour, add leading space
  display.print(" "); display.print(t.hour);
} else if(t.hour >= 13 && t.hour >= 22) { //If double digit and PM, convert 24 to 12 hour
  display.print(t.hour-12);
} else { //If single digit and PM, convert to 12 hour and add leading space
  display.print(" "); display.print(t.hour-12);
}       
display.print(":"); //Display hour-minute separator
if(t.min<10) { //Add leading zero if single-digit minute
  display.print("0");
} 
display.print(t.min); //Display retrieved minutes

display.print(":"); //Display minute-seconds separator
if (t.sec<10) { //Add leading zero for single-digit seconds
  display.print("0");
}
display.print(t.sec); //Display retrieved seconds

if(t.hour < 12) {  //Display AM indicator, as needed
  display.print(" AM");
} else {           //Display PM indicator, as needed
 
  display.print(" PM");
}

Last but not least solltest auch du dich mit dem Thema Netiquette 
beschäftigen. Lange Quelltexte gehören in den Anhang!

[Ardu (Gast)]

Ok, ja, ich hatte überlegt, ob ich die .ino dranhängen soll oder den 
Code komplett so, das ist auch der Ursprungscode, den habe ich stark 
abgeändert, ging ja erstmal hauptsächlich um die flash funktion und 
damit das klarer ist und meine Veränderungen nicht verwirren, habe ich 
den originalen gepostet. die RTC_Clock.ino habe ich auf dem Handy meinen 
Code auf dem PC, kann ich ja posten, wenn ich später am PC bin.

Ich entschuldige mich erstmal für die fehlende Nettiquette und für meine 
langen und teils schwer verständlichen Texte, aber das ist ein Problem, 
das ich so nicht lösen kann.

Die von dir angemerkten Fehler habe ich nicht mehr in meinem Code, die 
meisten Spielereien sind draussen. Das Konstrukt ist jetzt nicht mehr 
ganz so riesig, aber für meinen Geschmack immer noch zu groß. Ich nutze 
ein anderes Display, das PCD8544, und will auch nicht, dass der Cursor 
blinkt, das soll eigentlich garnichts blinken, will aber eine Markierung 
des ausgewählten Menüpunktes, so wie es bei z.B. einem Nokia 3310 ist, 
denke auch einfach die Farbe des gewählten zu invertieren, anstatt des 
Rechtecks, aber das ist im Moment total irrelevant, eine spitze Klammer 
reicht auch zum Basteln.

Ich meine diese Verzögerung:

unsigned long prev, interval = 100; //Variables for display/clock update rate
byte flash = 0; //Flag for display flashing - toggle once per update interval

Habe in meinem Code auch eine Strukturierung rein gebracht und viele 
Anmerkungen und Überschriften geändert und ergänzt, habs nur englisch 
gehalten. Auch lasse ich den Code regelmäßig von der Arduino IDE 
automatisch formatieren. Grad als Anfänger finden ich das ist die 
absolute Basis, dass man es auch richtig lernen kann, deswegen brauche 
ich ja immer wieder eure Hilfe, weil viele der Beispiele nach dem Motto 
"hauptsache Speichesparend und funktional" geschrieben sind und aus der 
Sicht von Leuten, die es einfach drauf haben, ich weiss aus anderen 
Bereichen, dass dann einem die Sicht des Anfängers verloren gehen kann, 
die Anmerkungen sind meist nicht gleich schlüssig, deswgen ist es gut, 
dass du konkrete Beispiele postest und sie kurz erläuterst, ich kenne 
sie aus Beispielen und kann sie eben durch unschlüssige Anmerkungen 
nicht verstehen, so aber klickts ;)

[Falk B. (falk)]

@ Ardu (Gast)

>Ich meine diese Verzögerung:

>unsigned long prev, interval = 100; //Variables for display/clock update >rate

Wie ich bereits sagte. Die Funktion loop() wird beim Arduino in einer 
Endlosschleife aufgerufen. Im "echten" C würde das so aussehen.

main () {

setup();

while(1) loop();

}

In deiner loop() Funktion wird geprüft, ob die Differenz zwischen now 
und prev > intervall ist. Wenn ja, wird dein Konstrukt ausgeführt, 
sprich, ein Menuupdate. now ist eine Variable aus dem Arduino-Framework, 
sie wird mittles Timer-Interrupt im 1ms Takt hochgezählt. Siehe 
Arduino-Doku.

https://www.arduino.cc/en/Reference/Millis

if ((now - prev > interval)) { //Determine whether to start a time and screen update

[Ardu (Gast)]

Das habe ich ja verstanden, aber du hattest gefragt welche Verzögerung 
und wo, wenn ich da den Wert höher setze, stocken wie erwähnt die 
Sekunden, aber eigentlich müssten die Sekunden auch so im Loop immer im 
richtigen Takt angezeigt werden, oder?
Bin auch nicht sicher, ob diese kurze Verzögerung nach allen ca. 4 
"flash"es irgendwas mit dem Kodensator am PCD8544 zutun hat, dass es auf 
das Loslassen des Tasters wartet klingt für mich schon logischer. 
Ansonsten will ich ja das flashen komplett weg haben und nur einen Timer 
zum Entprellen der Taster, es ist nur wegen den Sekunden und dem Display 
noch drin, weil dieses damit auch etwas besser läuft, in meinen ersten 
Versuchen mit der PCD8544 Library von carlosefr blinkt das Display auch 
bei jedem Loop-Beginn, das Flackern ist also so ein grundsätzliches 
Problem, könnte auch, wie du es erwähnt hast, am display.clearDisplay() 
liegen, muss ich auch mal ausprobieren.
Das Menü-Update müsste doch eigentlich ebenso wie die Sekunden im Loop 
aktualisiert werden, oder?
Was ein Loop ansich ist, ist mir schon klar, aber noch nicht genau der 
Zusammenhang und der Einfluss den ich nehmen muss, damit das alles 
ordentlich angezeigt wird und auch die I/O's nicht flackern.

Setzt mich später wenn ich Zeit hab vor den Rechner, ergänze und 
verändere meinen Code dann soweit und hänge ihn hier mit dran, hoffe 
du bist dann noch/wieder da :)

Last but not least, thanks again a lot :)

[Falk B. (falk)]

@ Ardu (Gast)

>Das habe ich ja verstanden, aber du hattest gefragt welche Verzögerung
>und wo, wenn ich da den Wert höher setze, stocken wie erwähnt die
>Sekunden,

Das sollte man aber auch so sagen, ich kann nicht hellsehen (weil ich ja 
in Dunkeldeutschland wohne . . .)
Siehe Netiquette.

> aber eigentlich müssten die Sekunden auch so im Loop immer im
>richtigen Takt angezeigt werden, oder?

Ja. Aber nur dann, wenn der Durchlauf deiner Anzeige nicht länger als 
ein Timerzyklus ist, hier dein interval.

>Bin auch nicht sicher, ob diese kurze Verzögerung nach allen ca. 4
>"flash"es irgendwas mit dem Kodensator am PCD8544 zutun hat,

HALLLOOOOO!!!! Ist dir auch schon mal EINE Sekunde in den Sinn gekommen, 
daß ich NICHT neben dir sitze und nicht mal ANSATZWEISE sehe was du 
siehst, geschweige denn was in deinem Kopf vorgeht?

https://www.mikrocontroller.net/articles/Netiquette#Klare_Beschreibung_des_Problems

Wenn du ein Problem des Schaltplans diskutieren willst, mußt du den 
mitliefern!

> dass es auf
>das Loslassen des Tasters wartet klingt für mich schon logischer.

Na dan mach den Unsinn doch endlich mal raus! Wie man es gescheit macht, 
hab ich dir doch schon gezeigt!!!

>Ansonsten will ich ja das flashen komplett weg haben

Auch hier solltest du dich um eine klarere Sprache bemühen. "Flashen" 
ist im Umfeld von Mikrocontrollern der Vorgang zum Programmieren der 
Firmware. Du redest von der Variable flash in deinem Programm zum 
Blinken.

Ausserdem, wo ist das Problem? Mach die Variable weg und alle Abfragen 
darauf auch. Flashen weg.

> und nur einen Timer
>zum Entprellen der Taster,

> es ist nur wegen den Sekunden und dem Display
>noch drin, weil dieses damit auch etwas besser läuft, in meinen ersten
>Versuchen mit der PCD8544 Library von carlosefr blinkt das Display auch
>bei jedem Loop-Beginn, das Flackern ist also so ein grundsätzliches
>Problem, könnte auch, wie du es erwähnt hast, am display.clearDisplay()
>liegen, muss ich auch mal ausprobieren.

Dann tu das doch einfach!

>Das Menü-Update müsste doch eigentlich ebenso wie die Sekunden im Loop
>aktualisiert werden, oder?

Ja.

[Ardu (Gast)]

Wie geschrieben fällt es mir schwer mich schriftlich auszudrücken, 
entschuldigung nochmals dafür.
Ich habe ja soweit alles verstanden und weiss wie ich das "flash"en 
entferne, nur war mir bislang nicht klar wie wichtig das ist wegen der 
Zeitanzeige und der Menü-Aktualisierungund, das geht doch aber aus 
meinem Text klar hervor, du kannst ja einfach fragen, wenn Informationen 
fehlen.
Das Display ist standartmäßig angeschlossen, wie in angehängter Grafik.

Ich will dir hier nicht dein Wochenende schlecht machen, sondern auch 
ein Feedback geben, um dir eben auch zu schildern was und wie ich denke 
und was ich vorhabe, bei den Fragen ist ein Fragezeichen am Ende und bei 
den Aussagen nicht, diese kannst du natürlich gerne kommentieren, eben 
in dem Fall, dass ich falsch denke, aber es sind keine wiederholten 
Fragen, die beantwortest du perfekt, wie schon erwäht. Da verstehe ich 
dein Problem nicht, denke da liegt ein Missverständnis vor. Kritik ist 
immer gerne willkommen, aber bitte gerechtfertigt.

[Falk B. (falk)]

@ Ardu (Gast)

>Das Display ist standartmäßig angeschlossen, wie in angehängter Grafik.

Ist OK, der Kondensator hat mit dem Flackern nichts zu tun. Es ist ein 
Entkoppelkondensator für das LCD.

https://www.mikrocontroller.net/articles/Kondensator#Entkoppelkondensator

>dein Problem nicht, denke da liegt ein Missverständnis vor.

Scheint wohl so.

Also dann, viel Spaß noch beim Programmieren.

[Joachim B. (jar)]

Ardu schrieb:
> Kritik ist
> immer gerne willkommen, aber bitte gerechtfertigt.

OK

Ardu schrieb:
> standartmäßig

weil der Spruch so toll ist zitier ich mal:

In Africa gibt es einen Stamm dort stehen sie gerne auf einem Bein, weil 
das ihre Standart ist ist das bei denen Standard

[peter (Gast)]

Ardu ...au weia.....

Las es erstmal sein hier. Du verzettelst dich immer mehr.
Die Ausdrücke werden hier immer derber.

[Ardu (Gast)]

Danke Falk, geniess dein Wochenende, soweit es möglich ist :) Komme erst 
heute Abend dazu das alles in die Tat umzusetzen, wenn ich nach der 
Spätschicht noch die Energie dazu hab.

@ Joachim

Na das kriegste aber gleich zurück: Afrika schreibt man in der deutschen 
Sprache mit "k". Nach "Stamm" muss ein Komma hin und danach "bei 
dem...", "...Standart ist" Komma "ist...". Und selbstverständlich gehört 
an das Ende eines Satzes ein Punkt. ;PPPP Das haste davon! Und nu zähl 
mal meine Fehler auf... wir schreiben uns in ein paar Tagen ;P

Das Display wird eben so in den meisten Fällen angeschlossen, egal, ob 
am LPT-Port oder am Mikrocontroller, da muss ein 
10müh-Fahrrad-Kondensator hin, daher ist es die Standart-Beschaltung.

[chris (Gast)]

Hat das was damit zu tun?
https://de.wikipedia.org/wiki/Standart_%28Zeitung%29

[Leuchte, die (Gast)]

> liegt zwar auch daran, dass ich Visual Basic, HTML und Java
> gelernt habe,

  Aber weder Strukturierte/Modulare Programmierung noch sowas wie 
"Algorithmen & Datenstrukturen", wie an deinem Code ersichtlich.

  Erweiterungen wie z.B. Anzeigetexte in wählbarer Sprache verbockst Du 
Dir so.

const char[12][5] MONATE = {
    "Jan ",
    "Feb ",
    :
    "Dez "
};

void printMonth(const int month, const char[] lang)
{
      if((0 <= month) or (month <12))
         display.print(lang[month]);
      else
         display.print("--- ");
}


const char[7][5] WOCHENTAGE = {
    "Mon ",
    "Die ",
    :
    "Son "
};

void printDay(const int dayofweek, const char[] lang)
{
      if((0 <= dayofweek) or (dayofweek <7))
         display.print(lang[dayofweek]);
      else
         display.print("--- ");
}

  Legst Du dein Code beiseite und entdeckst z.B zum Jahresende (in 10 
Mte.) eine Fehlanzeige: wie findest Du anhand der Anzeige die passende 
Codestelle?

  Bisher ist Dein Code unwartbar.


  Du weisst dass deine Anzeige entweder 2x pro s (":" flasht In der 
Zeitanzeige, Sek.Zeiger springt) oder 6x pro s beim einstellen.
  --> schreibe eine möglichst einfache zeitgesteuerte Schleife welche 
EXAKT alle 1/6tel s durchläuft und nix anderes tut als:
 - entscheidet ob dieser Durchlauf übersprungen werden kann oder 
folgendes zu tun ist:
    - einen Buffer char[2][16] (oder wie gross auch immer dein Dosplay 
ist) zum LCD screibt
    - den Buffer m. " " (Leerschlag) kompl. füllt
    - neuen Bufferinhalt f. nächsten Durchlauf berechnet

  Erstmal ist nicht so wichtig wie und mit welcher genauigkeit die 
1/6tel s eingehalten werden (trödeln und Ticks zählen).
  Dies kann spaeter per zeitbasierten Interrupt geschehen. Noch spaeter 
kann auch Schalfmodus/Aufwecken dazukommen (wg. Stromsparen)

  Mach Dir ne Übersicht, welche Muster an Text char[2][16] (resp. Deine 
Displaygrösse) vorkommen:

//      0....5...10...15.
//  [0]"time  hh:mm WWW "
//  [1]"date  YYYY-MM-DD"

  In diesen "Masken" jeweils die Platzhalter durch die veränderlichen 
Werte ersetzen.
  Beim neubefüllen des Buffer, in einem Schlonz das Zeugs rüberkopieren 
(memcpy() oder so).

  Tritt nun ein Anzeigefehler auf, lässt sich die zugehörige Codestelle 
mit der ähnlichsten Maske/Muster sehr direkt auffinden.


PS: man verzeihe mir ev. C-Syntaxverletzungen, es geht mir um bessere 
Programmarchitektur. Syntax wird vom Compiler geschiedsrichtert.

[Leuchte, die (Gast)]

PPS: ja, das lässt sich auch mit Arduino machen (google findet auch 
Beispiele f. einfache Echtzeitaudioeffekte auf Arduino basis)

[Ardu (Gast)]

Leuchte: Wie erwähnt ist das nicht mein Code, sondern die Basis von 
meinem, der mittlerweile stark abgeändert ist. U.A. ist da nichts mehr 
mit Datum, hab alles so weit abgespeckt, dass ich im Grunde eine Uhr mit 
zwei Weckern und einem Menü habe, das ist kein Projekt, sondern Lernen, 
bis auf das erwähnte "flash"en ist nichts mehr in dem Code, das ich 
nicht verstehe, bzw. verstehe ich das jetzt dank Falk, aber es wird 
ebenso entfernt und die empfohlene Methode angewendet. Mir ist klar, 
dass solche Dinge wie Datum schon deutlich komplexer sind, daher ist das 
alles weg, auch Zeichnungen mit der Adafruit_GFX Bibliothek, wobei diese 
leicht zu verstehen ist, aber einfach im Moment unnötig.

[Joachim B. (jar)]

Ardu schrieb:
> @ Joachim
>
> Na das kriegste aber gleich zurück: Afrika....

hast du Zitat verstanden? :p

[Ardu (Gast)]

Entschuldige Leuchte, hab den Rest erst garnicht wahr genommen, hatte 
den originalen Code eigentlich gepostet, weil ich Verwirrungen vermeiden 
wollte, hab sie aber erst dadurch ausgelöst. Am besten ist, wenn ich 
meinen vervollständige und dann hier anhänge. Ich nutze die 
Adafruit_PCD8544 Bibliothek, die hat einen Buffer,hab mich noch nicht 
damit beschäftigt wie ich den nutzen soll, wenn es besser ist, hänge ich 
das ganze Projekt dran, mit allen Bibliotheken, da bitte bescheid sagen. 
Wenn mein Code hier steht, kannst du mir ja auszugsweise Beispiele 
zeigen, wie genau du das meinst, da würde ich mir überaus freuen.

Finde es auch super, dass du die Wartbarkeit so in den Fordergrund 
stellst, weil das auf jeden Fall gegeben sein muss, so will ich das auch 
von Anfang an umsetzen, egal, ob Basteleien oder ernste Projekte.

LG

[Ardu (Gast)]

@Joachim

Ja xD Muss aber zugeben, nen Moment hats gebraucht Stand-Art, die Art zu 
stehen