Probleme mit „milis“ mehrmals nach der reihe

Hallo,

hab Problem mit milis. Will das mir wird angezeigt drei mal „ v v“ jedes mal mit 300 Millisekunden Pause.

„V V“

Pause

„V V“

Pause

„V V“

Pause

danach wird alles gelöscht

und von neu geschrieben / gezeichnet.

Mit delay funktioniert alles, ist ja kein Wunder, nur der „Wächter“ versteht mich nicht.

Wo ist mein Denkfehler?

 tft.setTextColor(0x0331);//sichtbar in farbe Grau

  tft.setCursor(Xpanel + 20, Ypanel + 130);
  tft.print("v  v"); //erste Zeile " v v "

  delay(300);

  tft.setCursor(Xpanel + 20, Ypanel + 150);
  tft.print("v  v");//zweite Zeile " v v " schreiben

  delay (300);
  tft.setCursor(Xpanel + 20, Ypanel + 170);
  tft.print("v  v");// drite

  delay (350);//Ales löschen
  tft.setTextColor(WHITE);
  tft.setCursor(Xpanel + 20, Ypanel + 130);
  tft.print("v  v");
  tft.setCursor(Xpanel + 20, Ypanel + 150);
  tft.print("v  v");
  tft.setCursor(Xpanel + 20, Ypanel + 170);
  tft.print("v  v");
  
  delay (150);//und loop



mit milis


  unsigned long currentMillis = millis();
  tft.setTextColor(0x0331);//Grau
  if (currentMillis - previousMillis >= intervall) // Falls mehr als 1000 ms vergangen sind
  {
    previousMillis = currentMillis;
    tft.setCursor(Xpanel + 20, Ypanel + 130);
    tft.print("v  v"); //erste Zeile " v v "
  }
  
  previousMillis = 0;// Ohne das wird die zweite Zeile " v v " nicht geschrieben
  //hier fehlt die 300 milis pause
  if (currentMillis - previousMillis >= intervall2) // Falls mehr als 1000 ms vergangen sind
  {
    previousMillis = currentMillis;
    // delay(300);
    tft.setTextColor(0x0331);//Grau
    tft.setCursor(Xpanel + 20, Ypanel + 150);
    tft.print("v  v");//zweite Zeile " v v " schreiben
  }

  delay (300);

  tft.setCursor(Xpanel + 20, Ypanel + 170);
  tft.print("v  v");//drite

  delay (350);//Ales löschen
  tft.setTextColor(WHITE);
  tft.setCursor(Xpanel + 20, Ypanel + 130);
  tft.print("v  v");
  tft.setCursor(Xpanel + 20, Ypanel + 150);
  tft.print("v  v");
  tft.setCursor(Xpanel + 20, Ypanel + 170);
  tft.print("v  v");

  delay (150);//und loop`

Danke und Grüße

Bernhard

dann mußt du aber auch alle delay()´s auslöten

Erst mall sol der erster gelöschter delay funktionieren danach wies ich wo der knoten im Gehirn ist. Habe sogar mit zählen der nanosekunden versucht = der Knoten im Gehirn will nicht weg.
Oder habe gar keinen mehr;)

Ja.

Denn:

so gehts nicht.

Hallo @combie
warum?

Hmm...

Ich erwarte nicht, das etwas gut funktioniert, wenn ich dieses entfernt habe.
Ok. vielleicht irre ich mich auch....

du willst zu viel auf einmal.

Mach mal einen minimalen Sketch der nur alle 300 millisekunden dein "v v" ausgibt.
Ganz ohne delay()
Sonst nichts.
Wenn du das mal hast stell deinen vollständigen Sketch hier rein und dann schauen wir uns den nächsten Schritt an.

also habe es alles abgeschniten

type or past  unsigned long currentMillis = millis();
  tft.setTextColor(0x0331);//Grau
  
  if (currentMillis - previousMillis >= intervall) 
  {
    previousMillis = currentMillis;
    tft.setCursor(Xpanel + 20, Ypanel + 130);
    tft.print("v  v"); //erste Zeile " v v "
  }
  
  previousMillis = 0;// Ohne das wird die zweite Zeile " v v " nicht geschrieben
 
  
  //hier fehlt die 300 milis pause
 
  if (currentMillis - previousMillis >= intervall2) 
  {
    previousMillis = currentMillis;
    
    tft.setTextColor(0x0331);//Grau
    tft.setCursor(Xpanel + 20, Ypanel + 150);
    tft.print("v  v");//zweite Zeile " v v " schreiben
  }

das Problemm ist das zwichen den zwei "if "keine pause wird gemacht .
die zwie "VV"
weden sofort geschrieben ochne pause zwischen den zeilen

"V V"
keine Pause
"V V"

Es ist bestimt ganz Simpler denk Fehler meiner seits

Ja!


so sol es werden

Die VV wandern navh unten und zeigen das der Akku wird geladen

ja und der Code beginnt damit dass du einfach mal alle 300ms die v ausgibst.
NUR DIE v v
ein KOMPLETTER KOMPILIEBARER SKETCH
immer wieder nur die v

alle 300 ms.

Mit delay (sketch im Wokwi simulation).

const int buttonPin = 8;

void setup()
{
  Serial.begin( 9600);
  Serial.println( "The sketch with delay has started");

  pinMode( buttonPin, INPUT_PULLUP);
}

void loop()
{
  if( digitalRead( buttonPin) == LOW)
  {
    Serial.println( "V V");
    delay( 500);
    Serial.println( "V V");
    delay( 500);
    Serial.println( "V V");
    delay( 500);
    Serial.println( "------------------");
  }
}

Mit millis (sketch im Wokwi simulation).

const int buttonPin = 8;

unsigned long previousMillis;
const unsigned long interval = 500UL;
bool enable = false;
int count;

void setup()
{
  Serial.begin( 9600);
  Serial.println( "The sketch with millis has started");

  pinMode( buttonPin, INPUT_PULLUP);
}

void loop()
{
  unsigned long currentMillis = millis();

  if( digitalRead( buttonPin) == LOW)
  {
    count = 0;
    previousMillis = currentMillis;
    enable = true;
  }

  if( enable)
  {
    if( currentMillis - previousMillis >= interval)
    {
      previousMillis = currentMillis;

      Serial.println( "V V");
      count++;
      if( count >= 3)
      {
        Serial.println( "----------------");
        enable = false;
      }
    }
  }
}

Das auf dem Bild ist nur teil was wird nacher umgeschrieben auf anderen display mit meu und so weiter
ist kein gecheimnis den sketch wo das eingefigt wird kann ich posten nur das er hat schon 700 zeilen

// 14.05.2021//
#include <Wire.h>

#include <LCDWIKI_GUI.h> //Core graphics library
#include <LCDWIKI_KBV.h> //Hardware-specific library
#include <LCDWIKI_TOUCH.h> //touch screen library
LCDWIKI_KBV lcd(ST7796S, 40, 38, 39, 43, 41); //model,cs,cd,wr,rd,reset 40
LCDWIKI_TOUCH mytouch(53, 52, 50, 51, 44); //tcs,tclk,tdout,tdin,tirq

#include "cactus_io_BME280_I2C.h"
BME280_I2C bme(0x76); // I2C  0x77

#include "ADS1X15.h"
ADS1115 ADS(0x48);


#define DS3231 0x68 //68
#include <RTClib.h>
#define DS3231_ADDRESSE 0x68
RTC_DS3231 rtc;

#include <IRremote.h>
IRrecv irrecv(7); // Ausgangs-Pin von TSOP4838 (IR)
decode_results results;

int msb = 0;//Für RTC Abfrage
int lsb = 0;

#define BLUE         0x001F
#define RED          0xF800
#define GREEN        0x07E0
#define MAGENTA      0xF81F
#define WHITE        0xFFFF
#define BLACK        0x0000
#define PINK         0xF81F
#define BROWN2       0x8888
#define CYAN         0x07FF
#define Wasser       0x07FF
#define YELLOW       0xFFE0


int x = 0; int y = 0; int r = 0;
int a = 0; int u = 0; int a1 = 0; int u1 = 0; int z1 = 0;
int auswahl = 0;

//*****************************************************//
// C-Programm von http://lexikon.astronomie.info/zeitgleichung/neu.html
// umgeschrieben auf Arduino by 'jurs' for German Arduino forum
//****   angepasst an meine Bedürfnisse*****
//*******************************************************//
double pi2 = 6.283185307179586476925286766559;
double pi = 3.1415926535897932384626433832795;
double RAD = 0.017453292519943295769236907684886;

double JulianischesDatum ( int Jahr, int Monat, int Tag, int Stunde, int Minuten, double Sekunden )
// Gregorianischer Kalender
{
  int   Gregor;
  if (Monat <= 2)
  {
    Monat = Monat + 12;
    Jahr = Jahr - 1;
  }
  Gregor = (Jahr / 400) - (Jahr / 100) + (Jahr / 4); // Gregorianischer Kalender
  return 2400000.5 + 365.0 * Jahr - 679004.0 + Gregor
         + int(30.6001 * (Monat + 1)) + Tag + Stunde / 24.0
         + Minuten / 1440.0 + Sekunden / 86400.0;
}

double InPi(double z)
{
  int n = (int)(z / pi2);
  z = z - n * pi2;
  if (z < 0) z += pi2;
  return z;
}

double eps(double T) // Neigung der Erdachse
{
  return RAD * (23.43929111 + (-46.8150 * T - 0.00059 * T * T + 0.001813 * T * T * T) / 3600.0);
}
double BerechneZeitgleichung(double &DK, double T)
{

  double RA_Mittel = 18.71506921
                     + 2400.0513369 * T + (2.5862e-5 - 1.72e-9 * T) * T * T;

  double M  = InPi(pi2 * (0.993133 + 99.997361 * T));
  double L  = InPi(pi2 * (  0.7859453 + M / pi2
                            + (6893.0 * sin(M) + 72.0 * sin(2.0 * M) + 6191.2 * T) / 1296.0e3));
  double e = eps(T);
  double RA = atan(tan(L) * cos(e));
  if (RA < 0.0) RA += pi;
  if (L > pi) RA += pi;

  RA = 24.0 * RA / pi2;

  DK = asin(sin(e) * sin(L));

  // Damit 0<=RA_Mittel<24
  RA_Mittel = 24.0 * InPi(pi2 * RA_Mittel / 24.0) / pi2;

  double dRA = RA_Mittel - RA;
  if (dRA < -12.0) dRA += 24.0;
  if (dRA > 12.0) dRA -= 24.0;

  dRA = dRA * 1.0027379;
  return dRA ;
}
///**** Ende Sonnen auf/unter Vorberechnung

void setup()
{
  //  Serial.begin(9600);
  ADS.begin();
  ADS.setGain(0);  // 6.144 volt
  !bme.begin();
  irrecv.enableIRIn();
  // TFT Start
  lcd.Init_LCD();
  lcd.Set_Rotation(1);
  mytouch.TP_Set_Rotation(3);
  mytouch.TP_Init(lcd.Get_Rotation(), lcd.Get_Display_Width(), lcd.Get_Display_Height());
  lcd.Fill_Screen(238, 227, 216);

  //  Vier Runderechtecke unten als auswall //
  // 1 Datum Uhr Wetter
  lcd.Fill_Round_Rectangle(15, 260, 125, 310, 14); // x, y, x1, y1, Rdius der Ecken
  lcd.Set_Text_Back_colour(RED);
  lcd.Set_Text_Size(2);
  lcd.Set_Text_colour(BLACK);
  lcd.Print_String("Wetter", 36, 278);
  // 2 Sonne
  lcd.Set_Draw_color(80, 139, 78);
  lcd.Fill_Round_Rectangle(135, 260, 235, 310, 14);
  lcd.Set_Text_Back_colour(80, 139, 78);
  lcd.Print_String("Sonne", 155, 278);
  // 3 PV
  lcd.Set_Draw_color(0x0410);
  lcd.Fill_Round_Rectangle(245, 260, 345, 310, 14);
  lcd.Set_Text_Back_colour(0x0410);
  lcd.Print_String("Solar", 268, 278);

  // 4 frei
  lcd.Set_Draw_color(BLUE);
  lcd.Fill_Round_Rectangle(355, 260, 455, 310, 14);
  //Ende mit zeichnen//

  //Serial.begin(9600);
}

void loop()
{

  //IR /////
  unsigned int IRwert = results.value;
  if (irrecv.decode(&results)) {
    irrecv.decode(&results);
    // Serial.println(IRwert);
    irrecv.resume();
  }
  // IR Ende

  mytouch.TP_Scan(0);

  ///**** Menuboxen abfragen und zuordnen ****///
  if (( mytouch.x >= 25 && mytouch.x <= 118) && (mytouch.y >= 276 && mytouch.y <= 315 ) || IRwert == 41565 || IRwert == 36975 || IRwert == 1 || IRwert == 2049 ) // Menubox abfragen
  {
    lcd.Set_Draw_color( 238, 227, 216);
    lcd.Fill_Rectangle(1, 1, 478, 250);
    auswahl = 1;
  }

  if (( mytouch.x >= 148 && mytouch.x <= 226) && (mytouch.y >= 276 && mytouch.y <= 315 ) || IRwert == 25245 || IRwert == 16758855) // Menubox abfragen
  { lcd.Set_Draw_color( BLUE);
    lcd.Draw_Rectangle(1, 1, 478, 250);
    lcd.Set_Draw_color(168, 210, 213);
    lcd.Fill_Rectangle(2, 2, 477, 249);
    auswahl = 2;
  }

  ///PV+Akku
  if (( mytouch.x >= 254 && mytouch.x <= 347) && (mytouch.y >= 276 && mytouch.y <= 315 ) || IRwert == 57885 || IRwert == 16709639) // Menubox abfragen
  {
    lcd.Set_Draw_color( 110, 110, 216);
  //  lcd.Draw_Rectangle(1, 1, 478, 250);
    lcd.Set_Draw_color( 255, 250, 205);
    lcd.Fill_Rectangle(2, 2, 477, 249);

    //PVpanell zeichnen///

    int txp = 16, typ = 45;
    lcd.Set_Draw_color( BLACK);
    lcd.Draw_Rectangle(txp - 1, typ - 1, txp + 75 + 1, typ + 90 + 1);
    lcd.Set_Draw_color(94, 104, 114);
    lcd.Fill_Rectangle(txp, typ, txp + 75, typ + 90  );
    lcd.Set_Draw_color( 0xffff);
  //  lcd.Draw_Rectangle(txp + 1, typ + 1, txp + 75 - 1, typ + 90 - 1 );
    lcd.Draw_Fast_HLine(txp, typ + 30, 75);
    lcd.Draw_Fast_HLine(txp, typ + 60, 75);
    lcd.Draw_Fast_VLine(txp + 25, typ + 1, 90);
    lcd.Draw_Fast_VLine(txp + 50, typ + 1, 90);

    //Akku zeichnen///

    int txb = 18, tyb = 47;

    //Akku zeichnen///
   // lcd.Draw_Rectangle(txb - 8 , tyb + 130, txb + 80 - 1, tyb + 190 );
    // lcd.Set_Draw_color(220, 101, 102);
    lcd.Set_Draw_color(RED);
    lcd.Fill_Rectangle(txb + 15, tyb + 131, txb + 20, tyb + 120  );//Klemmen
    lcd.Fill_Rectangle(txb + 55, tyb + 131, txb + 60, tyb + 120 ); //
    //lcd.Set_Draw_color(196,  126, 60);//
    lcd.Set_Draw_color(BLACK);
   // lcd.Draw_Rectangle(txb - 7, tyb + 131, txb + 80 - 2, tyb + 189 );
    lcd.Set_Text_colour(BLACK);
    lcd.Set_Text_Size(2);

    lcd.Print_String("+", txb + 1, tyb + 114);//133
    lcd.Print_String("-", txb + 64, tyb + 114);
    lcd.Set_Text_Back_colour(196,  130, 60);
    // lcd.Print_String("12V", txb + 16, tyb + 150);
    // lcd.Print_String("100Ah", txb + 7, tyb + 170);
    lcd.Set_Text_Back_colour(255, 250, 205);
    lcd.Set_Text_Size(3);
    lcd.Set_Text_colour(BLUE);



    /* *   lcd.Draw_Rectangle(txb - 8 , tyb + 130, txb + 80 - 1, tyb + 190 );
      // lcd.Set_Draw_color(220, 101, 102);
      lcd.Set_Draw_color(RED);
      lcd.Fill_Rectangle(txb + 15, tyb + 131, txb + 20, tyb + 119  );
      lcd.Fill_Rectangle(txb + 55, tyb + 131, txb + 60, tyb + 119  ); //
      lcd.Set_Draw_color(196,  126, 60);
      lcd.Fill_Rectangle(txb - 7, tyb + 131, txb + 80 - 2, tyb + 189 );
      lcd.Set_Text_colour(BLACK);
      lcd.Set_Text_Size(2);
      lcd.Set_Text_Back_colour(196,  130, 60);
      lcd.Print_String("+", txb + 14, tyb + 133);
      lcd.Print_String("-", txb + 53, tyb + 133);
      lcd.Print_String("12V", txb + 16, tyb + 150);
      lcd.Print_String("100Ah", txb + 7, tyb + 170);
    */
    auswahl = 3;
  }

  if (( mytouch.x >= 367 && mytouch.x <= 454) && (mytouch.y >= 276 && mytouch.y <= 315 ) || IRwert == 16720605 || IRwert == 16756815) // Menubox abfragen
  { lcd.Set_Draw_color( 238, 227, 216);
    lcd.Fill_Rectangle(1, 1, 478, 250);
    auswahl = 4;
  }

  ///**** Menubox abfragen Ende ****///
  switch (auswahl)
  {
    default: //Menu//
      Menu();
      break;

    case 1: // Datum - Uhrzeit - BME
      Wetter();
      break;

    case 2: // Sonnen auf/untergang
      Sonne();
      break;

    case 3: //PV+Akku
      pv();
      //Akku zeichnen///
      int tx = 16, ty = 37;
int txp = 16, typ = 37;
int txb = 16, tyb = 30;
  lcd.Draw_Rectangle(txb - 8 , tyb + 130, txb + 80 - 1, tyb + 190 );
  // lcd.Set_Draw_color(220, 101, 102);
  lcd.Set_Draw_color(RED);
  lcd.Fill_Rectangle(txb + 15, tyb + 131, txb + 20, tyb + 121  );//Klemmen
  lcd.Fill_Rectangle(txb + 55, tyb + 131, txb + 60, tyb + 121 ); //
  //lcd.Set_Draw_color(196,  126, 60);//
  lcd.Set_Draw_color(BLACK);
  lcd.Draw_Rectangle(txb - 7, tyb + 131, txb + 80 - 2, tyb + 189 );
  lcd.Set_Text_colour(BLACK);
  lcd.Set_Text_Size(2);

  lcd.Print_String("+", txb + 1, tyb + 114);//133
  lcd.Print_String("-", txb + 64, tyb + 114);
  lcd.Set_Text_Back_colour(196,  130, 60);
  lcd.Set_Text_Back_colour(255, 250, 205);
  lcd.Set_Text_Size(3);
  lcd.Set_Text_colour(BLUE);
      break;

    case 4: //RTC Inentemperatur
      RTC_Inentemperatur();
      break;
  }

} ////Loop Ende

///AUSWAL
void Menu()
{
  lcd.Draw_Rectangle(1, 1, 478, 250);
  lcd.Set_Text_Mode(0);
  lcd.Set_Text_colour(0x001F);
  lcd.Set_Text_Back_colour(238, 227, 216);
  lcd.Set_Text_Size(3);
  lcd.Print_String("Men\201auswahl", CENTER, 10);
  lcd.Set_Draw_color(RED);
  lcd.Set_Text_Size(2);
  lcd.Print_String(" 1- Datum, Uhrzeit, Wetterdaten", 3, 98);
  lcd.Print_String(" 2- Sonnen auf / untergang", 3, 138);
  lcd.Print_String(" 3- Solar Daten", 3, 178);
  lcd.Print_String(" 4- Nicht belegt", 3, 218);
  // links kleinere boxen zeichnen
  lcd.Fill_Round_Rectangle(382, 90, 470, 120, 10); // x, y, x1, y1, Rdius der Ecken
  lcd.Set_Draw_color(80, 139, 78);
  lcd.Fill_Round_Rectangle(382, 130, 470, 160, 10); // x, y, x1, y1, Rdius der Ecken
  lcd.Set_Draw_color(0x0410);
  lcd.Fill_Round_Rectangle(382, 170, 470, 200, 10); // x, y, x1, y1, Rdius der Ecken
  lcd.Set_Draw_color(BLUE);
  lcd.Fill_Round_Rectangle(382, 210, 470, 240, 10); // x, y,
}

void Wetter()
{
  ///// BME///
  bme.readSensor();
  float temp = 0; temp = bme.getTemperature_C() - 0.6;
  float hum = 0; hum = bme.getHumidity();
  float pres = 0; pres = bme.getPressure_MB() + 7.4, 1;
  // int auswahl = 0;
  int x = 0; int y = 0; int r = 0;
  int a = 0; int u = 0; int a1 = 0; int u1 = 0; int z1 = 0;
  int tx, ty, tr, i;
  float einGrad = 2.4;   // einGrad = 2,4 pixel / 40 Grad Temp Diff

  DateTime now = rtc.now();//RTC Start

  lcd.Set_Draw_color( 110, 110, 216);
  lcd.Draw_Rectangle(1, 1, 478, 250);
  lcd.Set_Text_Mode(0);
  lcd.Set_Text_colour(0x001F);
  lcd.Set_Text_Back_colour(238, 227, 216);
  // lcd.Set_Text_Size(3);
  // lcd.Print_String("Wetter * Uhr", CENTER, 10);
  //  Datum - Uhrzeit - BME
  lcd.Set_Draw_color( 110, 110, 216);
  lcd.Draw_Rectangle(1, 1, 478, 250);
  lcd.Set_Text_Mode(0);

  lcd.Set_Text_colour(BROWN2);
  lcd.Set_Text_Back_colour(238, 227, 216);
  lcd.Set_Text_Size(3);
  lcd.Print_String("Datum * Uhrzeit * Wetter", CENTER, 10);
  lcd.Set_Text_Size(2);
  lcd.Set_Text_colour(0x001F);
  // Datum + Uhrzeit
  if (now.dayOfTheWeek() == 0) {
    lcd.Print_String ("So.", 14, 60);
  }
  if (now.dayOfTheWeek() == 1) {
    lcd.Print_String ("Mo.", 14, 60);
  }
  if (now.dayOfTheWeek() == 2) {
    lcd.Print_String ("Di.", 14, 60);
  }
  if (now.dayOfTheWeek() == 3) {
    lcd.Print_String ("Mi.", 14, 60);
  }
  if (now.dayOfTheWeek() == 4) {
    lcd.Print_String ("Do.", 14, 60);
  }
  if (now.dayOfTheWeek() == 5) {
    lcd.Print_String ("Fr.", 14, 60);
  }
  if (now.dayOfTheWeek() == 6) {
    lcd.Print_String ("Sa.", 14, 60);
  }
  if (now.day() < 10) {
    lcd.Print_String("0", 58, 60);
    lcd.Print_Number_Int((now.day()), 70, 60, 2, ' ', 10);
  }
  else {
    lcd.Print_Number_Int((now.day()), 58, 60, 2, ' ', 10);
  }
  lcd.Print_String(".", 82, 60);//

  if (now.month() == 1) {
    lcd.Print_String("Jan.", 97, 60);
  }
  if (now.month() == 2) {
    lcd.Print_String("Feb.", 97, 60);
  }
  if (now.month() == 3) {
    lcd.Print_String("M\204rz", 97, 60);
  }
  if (now.month() == 4) {
    lcd.Print_String("Apr.", 97, 60);
  }
  if (now.month() == 5) {
    lcd.Print_String("Mai", 97, 60);
  }
  if (now.month() == 6) {
    lcd.Print_String("Jun.", 97, 60);
  }
  if (now.month() == 7) {
    lcd.Print_String("Jul.", 97, 60);
  }
  if (now.month() == 8) {
    lcd.Print_String("Aug.", 97, 60);
  }
  if (now.month() == 9) {
    lcd.Print_String("Sep.", 97, 60);
  }
  if (now.month() == 10) {
    lcd.Print_String("Okt.", 97, 60);
  }
  if (now.month() == 11) {
    lcd.Print_String("Nov.", 97, 60);
  }
  if (now.month() == 12) {
    lcd.Print_String("Dez.", 97, 60);
  }
  lcd.Print_Number_Int((now.year()), 153, 60, 2, ' ', 10);

  if (now.hour() < 10) {
    lcd.Print_String((" "), 220, 60);//+40
    lcd.Print_Number_Int(now.hour(), 246, 60, 2, ' ', 10);
  }
  else  {
    lcd.Print_Number_Int(now.hour(), 235, 60, 2, ' ', 10);
  }

  lcd.Set_Text_Size(4);
  lcd.Print_String(":", 258, 53);
  lcd.Set_Text_Size(2);

  if (now.minute() < 10) {
    lcd.Print_String("0", 278, 60);
    lcd.Print_Number_Int((now.minute()), 291, 60, 2, ' ', 10);
  }
  else {
    lcd.Print_Number_Int((now.minute()), 278, 60, 2, ' ', 10);
  }
  lcd.Set_Text_Size(4);
  lcd.Print_String(":", 302, 53);
  lcd.Set_Text_Size(2);

  if (now.second() < 10)
  {
    lcd.Print_String("0", 324, 60);
    lcd.Print_Number_Int((now.second()), 337, 60, 2, ' ', 10);
  }
  else {
    lcd.Print_Number_Int((now.second()), 324, 60, 2, ' ', 10);
  }

  //
  lcd.Set_Text_colour(0x001F);//800
  lcd.Set_Text_Back_colour(238, 227, 216);

  lcd.Print_String("Temp.", 10, 125);
  if (temp >= 15.00 && temp <= 24.99)//Farbwechsel je nach Temp
  {
    lcd.Set_Text_colour(MAGENTA);
  }
  if (temp >= 25.00 && temp <= 30.00)
  {
    lcd.Set_Text_colour(RED);
  }
  if (temp >= 30.0 )
  {
    lcd.Set_Text_colour(189, 47,  53 );
  }
  if (temp <= 14.99 )
  {
    lcd.Set_Text_colour(0, 191, 255 );//helblau
  }
  lcd.Print_Number_Float(temp, 1, 200, 125, '.', 4, ' ');
  lcd.Set_Text_colour(0x001F);
  lcd.Set_Draw_color( 0x001F);
  lcd.Draw_Circle(258, 129, 3); // Gradzeichen //
  lcd.Draw_Circle(258, 129, 4);
  lcd.Print_String("C", 265, 125);
  if (pres  <= 1013)  {
    lcd.Set_Text_colour(48, 135, 167);
    lcd.Print_String("Tiefdruck", 10, 160);
    lcd.Set_Text_colour(80, 139, 78);
  }
  else  {
    lcd.Set_Text_colour(103, 178, 31);
    lcd.Print_String("Hochdruck", 10, 160);
    lcd.Set_Text_colour(0x001F);
  }
  lcd.Set_Text_colour(0x001F);
  lcd.Print_Number_Float(pres, 1, 158, 160, '.', 4, ' ');
  lcd.Print_String("hPa", 239, 160);
  lcd.Print_String("Feuchtigkeit", 10, 190);
  lcd.Print_Number_Float(hum, 1, 200, 190, '.', 4, ' ');
  lcd.Print_String("%", 260, 190);

  // Thermometer zeichnen
  tx = 390, ty = 214, tr = 20;//214
  lcd.Set_Draw_color(BLACK);
  //lcd.Draw_Circle(tx + 3, ty + 3, tr);
  //lcd.Draw_Circle(tx + 2, ty + 2, tr);
  lcd.Draw_Line(tx - 8, ty + 2 - tr + 1, tx - 8, ty - 150);
  lcd.Draw_Line(tx + 8, ty + 2 - tr + 1, tx + 8, ty - 150);
  lcd.Draw_Line(tx - 8 - 1, ty + 2 - tr + 1, tx - 8 - 1, ty - 150);
  lcd.Draw_Line(tx + 8 + 1, ty + 2 - tr + 1, tx + 8 + 1, ty - 150);
  for (int i = 1; i <= 6; i++) {
    lcd.Draw_Fast_HLine(tx + 8, ty - 24 * i, 20); // Linien für 0,10,20...
  }
  for (int i = 1; i <= 10; i++) {
    lcd.Draw_Fast_HLine(tx + 8, ty - 24 - 12 * i, 10); //Kurze Linien Horizontal
  }
  lcd.Print_String(" -10", tx + 28, ty - 30);
  lcd.Print_String("  0", tx + 28, ty - 54);
  lcd.Print_String(" 10", tx + 28, ty - 78);
  lcd.Print_String(" 20", tx + 28, ty - 102);
  lcd.Print_String(" 30", tx + 28, ty - 126);
  lcd.Print_String(" 40", tx + 28 , ty - 150);
  float yhoch;//rQ- Rot
  float yrunter;//Loeschen Rot mit  Blau bei sinkender Temp.
  lcd.Set_Draw_color(RED);
  lcd.Fill_Round_Rectangle(tx - 13, ty - 14, tx + 15, ty + 27, 16);
  lcd.Set_Draw_color(BLACK);
  lcd.Draw_Round_Rectangle(tx - 15, ty - 17, tx + 17, ty + 29, 17);
  lcd.Draw_Round_Rectangle(tx - 16, ty - 16, tx + 18, ty + 30, 18);
  lcd.Draw_Round_Rectangle(tx - 17, ty - 18, tx + 19, ty + 31, 18);

  float dif = temp + 10;
  if (temp >= 40) {
    temp = 40; //Kein Überlauf mehr ;)
  }
  // Plusgrade//
  if (temp >= 0) {
    // y-Höhe des Quecksilbers = einGrad * Temperatur (190Pixel)
    yhoch = einGrad * temp;// Temperatur zu Pixel
    int ty0 = ty - 24 * 2;//0 Grad
    lcd.Fill_Rect(tx - 3, ty0, 7, -yhoch, RED);// Ab 0 Grad bis +40
    lcd.Fill_Rect(tx - 3, ty, 7, -48, RED); //Bereich -10 bis 0 Grad
  }
  // Minusgrade//
  if (temp < -0.01) {
    yhoch = einGrad * dif;
    int ty0 =  - 48 * 2;
    // Serial.println(yhoch);
    lcd.Fill_Rect(tx - 3, ty - 24, 7, -yhoch, RED);
    lcd.Fill_Rect(tx - 3, ty - 18, 7, -24, RED);
  }
  yrunter = (40 - temp) * einGrad - 1;
  lcd.Fill_Rect(tx - 3, 70, 7, yrunter, BLUE); // Löschen

}//Ende Wetter

void Sonne() {
  // Sonnen auf/untergang
  DateTime now = rtc.now();//RTC Start
  //lcd.Set_Draw_color( BLUE);
  //lcd.Draw_Rectangle(1, 1, 478, 250);
  // lcd.Set_Draw_color( 110, 110, 216);
  //  lcd.Set_Draw_color( 168,  210, 213);
  // lcd.Draw_Rectangle(1, 1, 478, 250);
  lcd.Set_Text_Mode(0);
  lcd.Set_Text_colour(209, 154, 0);
  lcd.Set_Text_Back_colour(168,  210, 213);
  lcd.Set_Text_Size(3);
  lcd.Print_String("Sonnen auf / untergang ", CENTER, 10);
  lcd.Set_Text_Size(2);
  lcd.Set_Text_colour(0x001F);
  lcd.Print_String("Heute bei sch\224nem Wetter\54 haben wir", 31, 40);
  lcd.Set_Text_Size(2);

  //  Sonnenschein dauer Heute Gestern //
  double JD2000 = 2451545.0;
  double JD;
  double JD1;  //**********Ales mit 1 am ende = gestern

  JD = JulianischesDatum(now.year(), now.month(), now.day(), 12, 0, 0); // Heutiges Datum
  JD1 = JulianischesDatum(now.year(), now.month(), now.day() - 1, 12, 0, 0); //******
  double T = (JD - JD2000) / 36525.0;
  double DK;
  double h = -50.0 / 60.0 * RAD;
  double B = 50.941278 * RAD; // geographische Breite
  double GeographischeLaenge = 6.958281;

  //double Zeitzone = 1; //Winterzeit
  double Zeitzone = 2.0;   //Sommerzeit 2

  double Zeitgleichung = BerechneZeitgleichung(DK, T);
  double Minuten = Zeitgleichung * 60.0;
  double Zeitdifferenz = 12.0 * acos((sin(h) - sin(B) * sin(DK)) / (cos(B) * cos(DK))) / pi;
  double AufgangOrtszeit = 12.0 - Zeitdifferenz - Zeitgleichung;
  double UntergangOrtszeit = 12.0 + Zeitdifferenz - Zeitgleichung;
  double AufgangWeltzeit = AufgangOrtszeit - GeographischeLaenge / 15.0;
  double UntergangWeltzeit = UntergangOrtszeit - GeographischeLaenge / 15.0;

  double Aufgang = AufgangWeltzeit + Zeitzone;         // In Stunden
  if (Aufgang < 0.0) Aufgang += 24.0;
  else if (Aufgang >= 24.0) Aufgang -= 24.0;

  double Untergang = UntergangWeltzeit + Zeitzone;
  if (Untergang < 0.0) Untergang += 24.0;
  else if (Untergang >= 24.0) Untergang -= 24.0;

  int AufgangMinuten   = int(60.0 * (Aufgang - (int)Aufgang) + 0.5);
  int AufgangStunden   = (int)Aufgang;
  if (AufgangMinuten >= 60.0) {
    AufgangMinuten -= 60.0;
    AufgangStunden++;
  }
  else if (AufgangMinuten < 0.0) {
    AufgangMinuten += 60.0; AufgangStunden--;
    if (AufgangStunden < 0.0) AufgangStunden += 24.0;
  }

  int UntergangMinuten = int(60.0 * (Untergang - (int)Untergang) + 0.5);
  int UntergangStunden = (int)Untergang;
  if (UntergangMinuten >= 60.0) {
    UntergangMinuten -= 60.0;
    UntergangStunden++;
  }
  else if (UntergangMinuten < 0) {
    UntergangMinuten += 60.0; UntergangStunden--;
    if (UntergangStunden < 0.0) UntergangStunden += 24.0;
  }
  /************** Tag Voher *****/
  double T1 = (JD1 - JD2000) / 36525.0;
  double Zeitgleichung1 = BerechneZeitgleichung(DK, T1);
  double Minuten1 = Zeitgleichung1 * 60.0;
  double Zeitdifferenz1 = 12.0 * acos((sin(h) - sin(B) * sin(DK)) / (cos(B) * cos(DK))) / pi;
  double AufgangOrtszeit1 = 12.0 - Zeitdifferenz1 - Zeitgleichung1;
  double UntergangOrtszeit1 = 12.0 + Zeitdifferenz1 - Zeitgleichung1;
  double AufgangWeltzeit1 = AufgangOrtszeit1 - GeographischeLaenge / 15.0;
  double UntergangWeltzeit1 = UntergangOrtszeit1 - GeographischeLaenge / 15.0;

  double Aufgang1 = AufgangWeltzeit1 + Zeitzone;         // In Stunden
  if (Aufgang1 < 0.0) Aufgang1 += 24.0;
  else if (Aufgang1 >= 24.0) Aufgang1 -= 24.0;

  double Untergang1 = UntergangWeltzeit1 + Zeitzone;
  if (Untergang1 < 0.0) Untergang1 += 24.0;
  else if (Untergang1 >= 24.0) Untergang1 -= 24.0;

  int AufgangMinuten1   = int(60.0 * (Aufgang1 - (int)Aufgang1) + 0.5);
  int AufgangStunden1   = (int)Aufgang1;
  if (AufgangMinuten1 >= 60.0) {
    AufgangMinuten1 -= 60.0;
    AufgangStunden1++;
  }
  else if (AufgangMinuten1 < 0.0) {
    AufgangMinuten1 += 60.0; AufgangStunden1--;
    if (AufgangStunden1 < 0.0) AufgangStunden1 += 24.0;
  }

  int UntergangMinuten1 = int(60.0 * (Untergang1 - (int)Untergang1) + 0.5);
  int UntergangStunden1 = (int)Untergang1;
  if (UntergangMinuten1 >= 60.0) {
    UntergangMinuten1 -= 60.0;
    UntergangStunden1++;
  }
  else if (UntergangMinuten1 < 0) {
    UntergangMinuten1 += 60.0; UntergangStunden1--;
    if (UntergangStunden1 < 0.0) UntergangStunden1 += 24.0;
  }

  //**** Sonnauf / untergang Malen****///
  lcd.Set_Text_Size(2);
  lcd.Print_String("Sonnenaufgang", 10, 210);
  lcd.Print_Number_Int((AufgangStunden), 220, 210, 2, ' ', 10);
  lcd.Print_Number_Int((AufgangStunden1), 315, 210, 2, ' ', 10);
  lcd.Print_String(":", 235, 210);
  lcd.Print_String(":", 330, 210);

  if (AufgangMinuten < 10) {
    lcd.Print_String("0", 252, 210);
    lcd.Print_Number_Int((AufgangMinuten), 265, 210, 2, ' ', 10);
  }
  else  {
    lcd.Print_Number_Int((AufgangMinuten), 252, 210, 2, ' ', 10);
  }

  if (AufgangMinuten1 < 10) {
    lcd.Print_String("0", 342, 210);
    lcd.Print_Number_Int((AufgangMinuten1), 355, 210, 2, ' ', 10);
  }
  else  {
    lcd.Print_Number_Int((AufgangMinuten1), 345, 210, 2, ' ', 10);
  }

  lcd.Print_String("Sonnenutergang", 10, 232);
  lcd.Print_Number_Int((UntergangStunden), 210, 232, 2, ' ', 10);
  lcd.Print_Number_Int((UntergangStunden1), 305, 232, 2, ' ', 10);
  lcd.Print_String(":", 235, 232);
  lcd.Print_String(":", 330, 232);

  if (UntergangMinuten < 10) {
    lcd.Print_String("0", 252, 232);
    lcd.Print_Number_Int((UntergangMinuten), 265, 232, 2, ' ', 10);// Vergleich mit CalSky.com
  }
  else {
    lcd.Print_Number_Int((UntergangMinuten), 252, 232, 2, ' ', 10);
  }

  if (UntergangMinuten1 < 10) {
    lcd.Print_String("0", 344, 232);
    lcd.Print_Number_Int((UntergangMinuten1), 357, 232, 2, ' ', 10);// Vergleich mit CalSky.com
  }
  else {
    lcd.Print_Number_Int((UntergangMinuten1), 345, 232, 2, ' ', 10);
  }
  lcd.Print_String(" Heute ", 200, 188);
  lcd.Print_String("Gestern", 300, 188);
  float astd = 0; float ustd = 0; float amin = 0; float umin = 0;
  float dif = 0; int ndif = 0; float zeitmin = 0; float neumin = 0;
  int zeigemin = 0; int Sonne = 0; int z = 0;
  amin = AufgangMinuten;
  astd = (AufgangStunden  * 60) + amin; //umrechnen min zu Dezimal
  umin = UntergangMinuten;
  ustd = (UntergangStunden * 60) + umin;
  dif = ( ustd - astd) / 60; //diferenz zw untergang und aufgang
  ndif = (int)dif;
  zeitmin = (dif - ndif);
  neumin = 60.2 * zeitmin ;//Dezimal zu minute  60.2
  zeigemin = (int)neumin;
  //Serial.println( dif);
  lcd.Print_Number_Int((ndif), 18, 63, 2, ' ', 10);
  lcd.Print_String("Std.", 47, 63);
  lcd.Print_Number_Int((zeigemin), 110, 63, 2, ' ', 10);
  lcd.Print_String("Min.", 145, 63);
  lcd.Print_String("Sonnenschein", 215, 63); // \42 =

  //*****Sonne mit Wolke wird gezeichnet *******//
  //*****und wandert nach Uhrziet *****/////
  lcd.Set_Draw_color( 168,  210, 213);
  z = (480 / dif) ; // x Display "-" Aufand stunde

  z1 = ( now.hour()) - (int)astd / 60;//1 +
  x = (z * z1);  //Aktuele Punkt der Sonne auf LCD zu Uhrzeit

  y = 128; r = 22; //Ausgang Koordinaten
  lcd.Set_Draw_color( 255, 255, 255);
  lcd.Fill_Circle(x - 40, y + 20, 22);
  lcd.Fill_Circle (x - 5, y + 37, 15);
  lcd.Draw_Line(x - 46, y + 39, x - 2, y + 49);
  lcd.Draw_Line(x - 46, y + 40, x - 2, y + 50);
  lcd.Draw_Line(x - 46, y + 41, x - 2, y + 51);
  lcd.Draw_Line(x - 46, y + 42, x - 1, y + 52);
  lcd.Fill_Circle(x - 21, y + 32, 12);
  lcd.Set_Draw_color(243, 224, 22);
  lcd.Fill_Circle (x, y, r);
  lcd.Draw_Line(x - 1, y - 37, x - 1, y - 20);
  lcd.Draw_Line(x - (-38), y - (-1), x - (-24), y - (-1));
  lcd.Draw_Line(x - (-25), y - 26, x - (-15), y - 16);
  lcd.Draw_Line(x - (-18), y - (-31), x - (-13), y - (-17) );
  lcd.Draw_Line(x - (-15), y - 35, x - (-10), y - 20);
  lcd.Draw_Line(x - (-35), y - 16, x - (-22), y - 9);
  lcd.Draw_Line(x - (-20), y - (-11), x - (-33), y - (-17));
  lcd.Draw_Line(x - 25, y - 26, x - 17, y - 16);
  lcd.Draw_Line(x - 35, y - 15, x - 20, y - 7);
  lcd.Draw_Line(x - 16, y - 34, x - 9, y - 18);

  //Alten Sonnenstand löschen//
  lcd.Set_Draw_color( 168,  210, 213);
  if ( now.second() == 1) {
    lcd.Fill_Rectangle(x = -100, 80, x + 55, 182);//x=0

  }
}
void RTC_Inentemperatur() {
  lcd.Set_Draw_color( 110, 110, 216);
  lcd.Draw_Rectangle(1, 1, 478, 250);
  lcd.Set_Text_Mode(0);
  lcd.Set_Text_colour(0x0000);
  lcd.Set_Text_Back_colour(238, 227, 216);
  lcd.Set_Text_Size(3);
  //RTC nach Temp fragen ;)//
  lcd.Print_Number_Float(getTempFromRTC() - 0.3, 1, 260, 220, '.', 4, ' ');
  lcd.Print_String("C", 355, 220);
  lcd.Set_Draw_color( 0x0000);
  lcd.Draw_Circle(345, 224, 4); // Gradzeichen //
  lcd.Draw_Circle(345, 224, 5);
  lcd.Draw_Circle(345, 224, 6);
  lcd.Print_String("Systemtemp. ", 10, 220);
}
////PV
void pv() {
  lcd.Set_Text_colour(BROWN2);
  int tx = 30, ty = 37;

  lcd.Set_Text_Size(3);
  lcd.Set_Text_Back_colour(255, 250, 205);
  lcd.Print_String("Solardaten * Akku", CENTER, 8);
  lcd.Set_Text_Back_colour(255, 250, 205);
  lcd.Set_Text_Size(3);

  lcd.Set_Text_colour(BLUE);
  // lcd.Print_String("Solarpanele", tx + 92, ty + 5);
  lcd.Print_String("Solarpanel", CENTER, ty + 5);
  lcd.Set_Text_Size(4);
 // lcd.Print_String("18V ", tx + 102, ty + 50);

  int16_t raw = ADS.readADC(0);
  int16_t raw1 = ADS.readADC(1);
  int16_t raw2 = ADS.readADC(2);
  int16_t raw3 = ADS.readADC(3);
  float vb = 0;//Akku Spannung
  float vb1 = 0;
  //int tx = 16, ty = 37;
  int txp = 16, typ = 37;
  int txb = 16, tyb = 30;

  float h = 0;
  float hmax = (tyb + 188) - (tyb + 129); //=56
  float h1 = hmax / 100;//%
 //float vbab = 0;
  vb = ADS.toVoltage(raw) * 11.1;//*Spannungsteiler ADS Kanal "0"
  float vbo = vb; //

  lcd.Set_Text_Size(3);
  lcd.Set_Draw_color(196,  126, 60);
  lcd.Print_String("18V 10A", tx + 92, ty + 40);
  if (vb >= 13.8) {
    vb = 13.68;
  }
  if (vb <= 10.5) {
    vb1 = 10.5;
  }
  else {
    vb1 = vb;
  }
  //  int vb2 = (vb1 - 10.5) * 32.5 ;
  // int vbab = (13.38 - vb1) * 32.5;
  float vb2 = (vb1 - 10.5) * 32.5 ;
float vbab = (13.38 - vb1) * 32.5;
  lcd.Fill_Rectangle(txb - 6, tyb + 188 - (vb2 * h1) + 5, txb + 79 - 2, tyb + 188 );
  lcd.Set_Draw_color(255, 250, 205);
  lcd.Fill_Rectangle(txb - 6 , tyb + 131, txb + 79 - 2, tyb + 131 + (vbab * h1 ) + 2 );
  if (vbo <= 11.01) {
    lcd.Set_Text_colour(RED );
    lcd.Print_Number_Float(vbo, 1, txb + 134, tyb + 135, '.', 4, ' ');
    lcd.Print_String("V", txb + 210, tyb + 135);
  }
  else {
    lcd.Set_Text_colour(BLUE );
    lcd.Print_Number_Float(vbo, 1, txb + 134, tyb + 135, '.', 4, ' ');
    lcd.Print_String("V", txb + 210, tyb + 135);
  }
  float amper = ADS.toVoltage(raw1) * 1.4;
  lcd.Print_Number_Float(amper, 1 , txb + 134, tyb + 169, '.', 4, ' ');
  lcd.Print_String("A", txb + 210, tyb + 169);
  lcd.Set_Text_colour(BROWN2);
  if (amper >= 0.01) {
    lcd.Set_Text_colour(GREEN );
    lcd.Print_String("  Lade Akku  ", tx + 86, ty + 90);
  }
  else {
    lcd.Set_Text_colour(BROWN2);
    lcd.Print_String("Akkuspannung  ", tx + 86, ty + 90);
  }
  lcd.Set_Text_colour(BLUE);
  lcd.Set_Draw_color(196,  126, 60);//
  lcd.Set_Draw_color(BLACK);//

 // lcd.Draw_Rectangle(txb - 8 , tyb + 130, txb + 80 - 1, tyb + 190 );




  /*
    lcd.Set_Text_Size(3);
    lcd.Print_String("Akkumulator", CENTER, ty + 105);

    //ACS 30//
    int Sensor = A0; // Der Stromstärkesensor wird am Pin A0 (Analog "0") angeschlossen.
    int VpA = 66; // Millivolt pro Ampere (100 für 20A Modul und 66 für 30A Modul)
    int sensorwert = 0;
    int Nullpunkt = 2500; // Spannung in mV bei dem keine Stromstärke vorhanden ist
    double SensorSpannung = 0;
    double Ampere = 0;
    sensorwert = analogRead(Sensor);
    SensorSpannung = (sensorwert / 1024.0) * 5000; // Hier wird der Messwert in den Spannungswert am Sensor umgewandelt.
    Ampere = ((SensorSpannung - Nullpunkt) / VpA); // Im zweiten Schritt wird hier die Stromstärke berechnet.

    Serial.println(Ampere, 1);
    //Akku messen

    float REF_VOLTAGE = 4.84;

    int analogInput = 1;
    float vout = 0.0;
    float vin = 0.0;
    float R1 = 99000.0; // Widerstandswert R1 (100K)
    float R2 = 9900.0; // Widerstandswert R2 (10K)
    int values = 0;
    values = analogRead(analogInput); //Messwerte am analogen Pin als "values" definieren
    delay(5);
    vout = (values * REF_VOLTAGE) / 1023.0; // Messwerte in Volt umrechnen = Spannung am Ausgang des
    // Spannungsteilers mit Zuleitung zu Pin A0
    vin = vout / (R2 / (R1 + R2)); // Berechnen, welche Spannung am Eingang des Spannungsteilers
    lcd.Print_String("V", 240, 190);
    lcd.Print_Number_Float(vin , 1, 160, 190, '.', 4, ' ');
  */
}

//****RTC Temp.auslesen***///
float getTempFromRTC() {
  Wire.beginTransmission(DS3231);
  int writtenBytes = Wire.write(0x11);
  Wire.endTransmission();
  Wire.requestFrom(DS3231, writtenBytes); // 2 Byte Daten vom DS3231 holen
  int msb = Wire.read();
  int lsb = Wire.read();
  return ((msb << 2) + (lsb >> 6) ) / 4.0;
}

ud das ist nur ein teil was ich vorhabe

deschalb mach ich imme in teilen und baue zusammen

Leider mein "großer" display ist defekt deshalb mache das teil am einen 2.4 " , ende Mai kommt der neuer 4" dan mach ich video wie das alles funktioniert

Ich wollte einen kleinen Sketch von dir sehen. Dann hätte ich dir weitergeholfen.
Vermutlich hat es aber keinen Sinn. Also musst du nun alleine weiter machen.

Hallo Fony,

leg doch mal eine Pause mit deinem Projekt ein. Nimm #15 und dir den "millis Sketch" zur Brust und versuche jede Zeile davon zu verstehen. Erst wenn du das gerafft hast kannste weitermachen. Vorher hat alles weitere keinen Sinn.

Also Danke
werde ersmall auf die "animation" verzichten. nur wie ich mich kenne wen der anderer display kommt wird mich die blöde sache nicht in ruche lassen
3 mall milis nicht in die rehie krigen ist schlimer als im Garten im Regen und Donner stehen

Grüße
Bernhard

Ein millis-timer gehört in die hauptebene in der loop(). @noiasca und ich haben das. Haben Sie den link zur Wokwi-simulation ausprobiert?