Wort Uhr. Minuten über Taster einstellen ? Aber wie ? Kann mir jemand sagen wie ich das machen kann

// Debugging
//#define DEBUG Serial // Diese Zeile als Kommentar, wenn keine Ausgabe auf dem seriellen Monitor gewünscht ist.
#ifdef DEBUG
#define debug(...) DEBUG.print(__VA_ARGS__)
#define debugln(...) DEBUG.println(__VA_ARGS__)
#define debugbegin(...) DEBUG.begin(__VA_ARGS__)
#else
#define debug(...)
#define debugln(...)
#define debugbegin(...)
#endif

#include <DS3232RTC.h> //https://github.com/JChristensen/DS3232RTC
#include <TimeLib.h> //https://github.com/PaulStoffregen/Time
#include <Wire.h>
#include <FastLED.h> //https://github.com/FastLED/FastLED

FASTLED_USING_NAMESPACE
#define DATA_PIN   7
#define LED_TYPE    WS2812B
#define COLOR_ORDER GRB
#define NUM_LEDS    114      // Gesamtanzahl der WS2812 LEDs
CRGB leds[NUM_LEDS];

uint8_t BRIGHTNESS = 120;    // Wenn kein Fotoresistor benutzt wird hier dauerhafte Helligkeit eintragen

uint8_t Stunde     = 0;
uint8_t Minute     = 15;
uint8_t Sekunde    = 0;
uint8_t Sek_alt    = 0;
uint8_t WochenTag  = 0;
uint8_t Tag        = 30;
uint8_t Monat      = 10;
boolean DST        = false;
uint32_t jetzt = 0;
uint8_t animation = 0;
bool start = true;           // damit nach Reset gleich etwas angezeigt wird

//***HIER LED POSITIONEN EINTRAGEN***//
const uint8_t Es[]        = {0, 1};
const uint8_t Ist[]       = {3, 4, 5};

const uint8_t Eins[]      = {62, 63, 64, 65};
const uint8_t Ein[]       = {63, 64, 65};
const uint8_t Zwei[]      = {55, 56, 57, 58};
const uint8_t Drei[]      = {66, 67, 68, 69};
const uint8_t Vier[]      = {73, 74, 75, 76};
const uint8_t Fuenf[]     = {51, 52, 53, 54};
const uint8_t Sechs[]     = {83, 84, 85, 86, 87};
const uint8_t Sieben[]    = {88, 89, 90, 91, 92, 93};
const uint8_t Acht[]      = {77, 78, 79, 80};
const uint8_t Neun[]      = {103, 104, 105, 106};
const uint8_t Zehn[]      = {106, 107, 108, 109};
const uint8_t Elf[]       = {49, 50, 51};
const uint8_t Zwoelf[]    = {94, 95, 96, 97, 98};
const uint8_t MZwanzig[]  = {11, 12, 13, 14, 15, 16, 17};
const uint8_t MFuenf[]    = {7, 8, 9, 10};
const uint8_t MZehn[]     = {18, 19, 20, 21};

const uint8_t Viertel[]   = {26, 27, 28, 29, 30, 31, 32};
const uint8_t Vor[]       = {41, 42, 43};
const uint8_t Nach[]      = {33, 34, 35, 36};
const uint8_t Halb[]      = {44, 45, 46, 47};
const uint8_t Uhr[]       = {99, 100, 101};


const uint8_t EinsM[]     = {110}; //Minuten Punkt 1
const uint8_t ZweiM[]     = {111}; //Minuten Punkt 2
const uint8_t DreiM[]     = {112}; //Minuten Punkt 3
const uint8_t VierM[]     = {113}; //Minuten Punkt 4
//**********************************//

//int Ambient, LastAmbient;

void setup() {
  //delay(3000); // Sicherheits Delay
  debugbegin(9600);

  
  //LEDs werden eingefügt + Farbkorrektur und Farbtemperatur auf Wolfram (warmweiß)
  FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalPixelString);
  FastLED.setTemperature( Tungsten40W );
  debugln("Starte Wordclock ...");

  //Versuche auf RTC zu zugreifen
  setSyncProvider(RTC.get);
  if (timeStatus() != timeSet) {
    debugln("Unable to sync with the RTC");
  } else if (timeStatus() != timeNeedsSync) {
    debugln("RTC has set the system time");
  } else {
    debugln("RTC has set the system time but needs Sync");
  }
}

void SwitchLED(const uint8_t MyArray[], int n) {
  //Funktion zum Anschalten der LEDs in warmweiß (oder gewünschter Farbe)
  for (int i = 0; i < n; i++) {
    leds[MyArray[i]] = 0xFFC58F;                // HEX Warmweiß | Hier gewünschte LED Farbe (HEX) eintragen
    FastLED.setBrightness(BRIGHTNESS);
    //leds[i] = CHSV(140, 27, BRIGHTNESS);      // ODER hier gewünschte Farbe in HSV (  CHSV(FARBE, SÄTTIGUNG, BRIGHTNESS)  )
    //leds[i].setRGB(255, 68, 221);             // ODER hier gewünschte Farbe in RGB (  .setRGB(Rot,Grün,Blau)   )
  }
}

void displaytime(void) {
  //zuerst setzten wir alle LEDs zurück
  fill_solid( leds, NUM_LEDS, CHSV(0, 0, 0));

  // Nun suchen wir die richtigen LEDs und übergeben sie an die Funktion zum Anschalten
  debug("Es ");
  SwitchLED(Es, (sizeof(Es)));
  debug("ist ");
  SwitchLED(Ist, (sizeof(Ist)));

  if (((Minute > 4) && (Minute < 10)) || (Minute > 54)) {
    SwitchLED(MFuenf, (sizeof(MFuenf)));
    debug("5 Minuten ");
  }
  if (((Minute > 9) && (Minute < 15)) || ((Minute > 49) && (Minute < 55))) {
    SwitchLED(MZehn, (sizeof(MZehn)));
    debug("10 Minuten ");
  }
  if (((Minute > 14) && (Minute < 20)) || ((Minute > 44) && (Minute < 50))) {
    SwitchLED(Viertel, (sizeof(Viertel)));
    debug("Viertel ");
  }
  if (((Minute > 19) && (Minute < 25)) || ((Minute > 39) && (Minute < 45))) {
    SwitchLED(MZwanzig, (sizeof(MZwanzig)));
    debug("20 Minuten ");
  }
  if (((Minute > 24) && (Minute < 30))) {
    SwitchLED(MFuenf, (sizeof(MFuenf)));
    SwitchLED(Vor, (sizeof(Vor)));
    SwitchLED(Halb, (sizeof(Halb)));
    debug("5 vor halb ");

  }
  if (((Minute > 34) && (Minute < 40))) {
    SwitchLED(MFuenf, (sizeof(MFuenf)));
    SwitchLED(Nach, (sizeof(Nach)));
    SwitchLED(Halb, (sizeof(Halb)));
    debug("5 nach halb ");
  }
  if ((Minute > 29) && (Minute < 35)) {
    SwitchLED(Halb, (sizeof(Halb)));
    debug("Halb ");
  }

  if (Minute < 5) {
    switch (Stunde) {
      case 1:
        SwitchLED(Ein, (sizeof(Ein)));
        debug("1 ");
        break;
      case 2:
        SwitchLED(Zwei, (sizeof(Zwei)));
        debug("2 ");
        break;
      case 3:
        SwitchLED(Drei, (sizeof(Drei)));
        debug("3 ");
        break;
      case 4:
        SwitchLED(Vier, (sizeof(Vier)));
        debug("4 ");
        break;
      case 5:
        SwitchLED(Fuenf, (sizeof(Fuenf)));
        debug("5 ");
        break;
      case 6:
        SwitchLED(Sechs, (sizeof(Sechs)));
        debug("6 ");
        break;
      case 7:
        SwitchLED(Sieben, (sizeof(Sieben)));
        debug("7 ");
        break;
      case 8:
        SwitchLED(Acht, (sizeof(Acht)));
        debug("8 ");
        break;
      case 9:
        SwitchLED(Neun, (sizeof(Neun)));
        debug("9 ");
        break;
      case 10:
        SwitchLED(Zehn, (sizeof(Zehn)));
        debug("10 ");
        break;
      case 11:
        SwitchLED(Elf, (sizeof(Elf)));
        debug("11 ");
        break;
      case 12:
        SwitchLED(Zwoelf, (sizeof(Zwoelf)));
        debug("12 ");
        break;
    }
    SwitchLED(Uhr, (sizeof(Uhr)));
    debugln("Uhr");
  }
  else if ((Minute < 24) && (Minute > 4)) {
    SwitchLED(Nach, (sizeof(Nach)));
    debug("nach ");
    switch (Stunde) {
      case 1:
        SwitchLED(Eins, (sizeof(Eins)));
        debugln("1 ");
        break;
      case 2:
        SwitchLED(Zwei, (sizeof(Zwei)));
        debugln("2 ");
        break;
      case 3:
        SwitchLED(Drei, (sizeof(Drei)));
        debugln("3 ");
        break;
      case 4:
        SwitchLED(Vier, (sizeof(Vier)));
        debugln("4 ");
        break;
      case 5:
        SwitchLED(Fuenf, (sizeof(Fuenf)));
        debugln("8 ");
        break;
      case 6:
        SwitchLED(Sechs, (sizeof(Sechs)));
        debugln("6 ");
        break;
      case 7:
        SwitchLED(Sieben, (sizeof(Sieben)));
        debugln("7 ");
        break;
      case 8:
        SwitchLED(Acht, (sizeof(Acht)));
        debugln("8 ");
        break;
      case 9:
        SwitchLED(Neun, (sizeof(Neun)));
        debugln("9 ");
        break;
      case 10:
        SwitchLED(Zehn, (sizeof(Zehn)));
        debugln("10 ");
        break;
      case 11:
        SwitchLED(Elf, (sizeof(Elf)));
        debugln("11 ");
        break;
      case 12:
        SwitchLED(Zwoelf, (sizeof(Zwoelf)));
        debugln("12 ");
        break;
    }
  }
  else {
    if ((Minute > 29) && (Minute < 40)) {
      switch (Stunde) {
        case 1:
          SwitchLED(Zwei, (sizeof(Zwei)));
          debugln("2 ");
          break;
        case 2:
          SwitchLED(Drei, (sizeof(Drei)));
          debugln("3");
          break;
        case 3:
          SwitchLED(Vier, (sizeof(Vier)));
          debugln("4 ");
          break;
        case 4:
          SwitchLED(Fuenf, (sizeof(Fuenf)));
          debugln("5 ");
          break;
        case 5:
          SwitchLED(Sechs, (sizeof(Sechs)));
          debugln("6 ");
          break;
        case 6:
          SwitchLED(Sieben, (sizeof(Sieben)));
          debugln("7 ");
          break;
        case 7:
          SwitchLED(Acht, (sizeof(Acht)));
          debugln("8 ");
          break;
        case 8:
          SwitchLED(Neun, (sizeof(Neun)));
          debugln("9 ");
          break;
        case 9:
          SwitchLED(Zehn, (sizeof(Zehn)));
          debugln("10 ");
          break;
        case 10:
          SwitchLED(Elf, (sizeof(Elf)));
          debugln("11 ");
          break;
        case 11:
          SwitchLED(Zwoelf, (sizeof(Zwoelf)));
          debugln("12 ");
          break;
        case 12:
          SwitchLED(Eins, (sizeof(Eins)));
          debugln("1 ");
          break;
      }
    }
    else {
      SwitchLED(Vor, (sizeof(Vor)));
      debug("vor ");
      switch (Stunde) {
        case 1:
          SwitchLED(Zwei, (sizeof(Zwei)));
          debugln("2 ");
          break;
        case 2:
          SwitchLED(Drei, (sizeof(Drei)));
          debugln("3");
          break;
        case 3:
          SwitchLED(Vier, (sizeof(Vier)));
          debugln("4 ");
          break;
        case 4:
          SwitchLED(Fuenf, (sizeof(Fuenf)));
          debugln("5 ");
          break;
        case 5:
          SwitchLED(Sechs, (sizeof(Sechs)));
          debugln("6 ");
          break;
        case 6:
          SwitchLED(Sieben, (sizeof(Sieben)));
          debugln("7 ");
          break;
        case 7:
          SwitchLED(Acht, (sizeof(Acht)));
          debugln("8 ");
          break;
        case 8:
          SwitchLED(Neun, (sizeof(Neun)));
          debugln("9 ");
          break;
        case 9:
          SwitchLED(Zehn, (sizeof(Zehn)));
          debugln("10 ");
          break;
        case 10:
          SwitchLED(Elf, (sizeof(Elf)));
          debugln("11 ");
          break;
        case 11:
          SwitchLED(Zwoelf, (sizeof(Zwoelf)));
          debugln("12 ");
          break;
        case 12:
          SwitchLED(Eins, (sizeof(Eins)));
          debugln("1 ");
          break;
      }
    }
  }
  // Minuten Zähler
  uint8_t MinCount = Minute - (floor(Minute / 10) * 10);
  if (MinCount > 5)
    MinCount = MinCount - 5;
  switch (MinCount) {
    case 4:
      SwitchLED(VierM, (sizeof(VierM)));
    case 3:
      SwitchLED(DreiM, (sizeof(DreiM)));
    case 2:
      SwitchLED(ZweiM, (sizeof(ZweiM)));
    case 1:
      SwitchLED(EinsM, (sizeof(EinsM)));
  }
  FastLED.show();
}

void CheckDST(void) {
  //Funktion zum Überprüfen ob Sommer oder Winterzeit
  Tag = day();
  Monat = month();

  WochenTag = (weekday() - 1);
  int Hilf = Tag - WochenTag;
  if (Monat <= 2 || Monat >= 11)
    DST = false;                                 // Winterzeit

  if (Monat >= 4 && Monat <= 9)
    DST = true;                                  // Sommerzeit

  if ((Monat == 3) && (Hilf >= 25))
    DST = true;                                 // Beginn der Sommerzeit

  if ((Monat == 10) && (Hilf >= 25))
    DST = false;                                 // Beginn der Winterzeit

  if (DST == true) {
    if (Stunde <= 11)
      Stunde = Stunde + 1;
    else if (Stunde > 12)
      Stunde = Stunde - 12 + 1;
    else if (Stunde == 12)
      Stunde = 1;
    else if (Stunde == 24)
      Stunde = 1;
    //Stunde += 1;
  }
}

void stundenanimation() {
  static uint32_t vorhin = 0, intervall = 200;
  static byte schritt = 0;

  if (jetzt - vorhin >= intervall) {
    vorhin = jetzt;
    switch (schritt) {
      case 0:
      case 2:
        Police_faerben(CRGB::Blue, CRGB::Black);
        schritt++;
        break;
      case 4:
      case 6:
        Police_faerben(CRGB::Black, CRGB::Red);
        schritt++;
        break;
      case 7:
        animation = (1 + animation) % 5;
      case 1:
      case 3:
      case 5:
        if (animation) {
          Police_faerben(CRGB::Black, CRGB::Black);
        } else {
          displaytime();
        }
        schritt++;
        break;
      default:
        schritt = 0;
    }
    FastLED.show();
  }
}

void Police_faerben(uint32_t farbeunten, uint32_t farbeoben) {
  for (uint16_t led = 0; led < (NUM_LEDS / 2); led++) {
    leds[led] = farbeunten;
    leds[(NUM_LEDS - 1) - led] = farbeoben;
  }
}

void loop() {
  static uint32_t vorhin = -999; // damit es gleich losgeht
  jetzt = millis();
  if (jetzt - vorhin >= 999) {
    Sek_alt = Sekunde;
    Sekunde = second();
    if (((Sekunde != Sek_alt) && (Sekunde == 0))|| start) {
      vorhin = jetzt;
      start = false;
      Minute = minute();
      int Std = hour();
      if (Std > 12)
        Stunde = Std - 12;
      else if (Std == 0)
        Stunde = 12;
      else
        Stunde = Std;

      CheckDST();
      if (Minute == 0) animation = 1;
      if (!animation) displaytime();
      debugln(Stunde);
      debugln(Minute);
    }
  }
  if (animation) stundenanimation();
}

Warum machst Du sowas?

Warum benutzt Du die DS3232RTC lib?

Ansonsten ist die Frage: Du sprichst von Tasten (Mehrzahl) - kannst Du beschreiben, was Du Dir vorstellst?

my_xy_projekt Danke für deine Antwort. Das Programm wurde so übernommen . Da meine programmier kenttnisse nicht so gut sind habe ich das Programm so übernommen.
Möchte aber 2 Taster einsetzen um die Minuten zu stellen ( Min1+ uind Min1-)

woher?
Allein Minuten stellen auf und ab, ist nicht schlimm.
Sagst Du mir noch, auf welchen zwei Pins Du die Tasten legen möchtest?
(Nachtrag: Nimm mal das gelöst zurück - das Herzchen daneben reicht :wink: - sonst muss ich jedes Mal das Fenster "Es ist doch gelöst - willst Du wirklich antworten" wegklicken)

Ach das kann man weg klicken?

Gruß Tommy

ESC mit der Tastatur - oder das x mit der Maus....

Nervig ist, das es ständig während des Schreiben kommt.

Ok, danke. Das ist nicht das einzige nervige am neuen Forum. Auch die Änderungsverfolgung ist manchmal nicht ideal, wenn man Passworte gepostet hat.
Aber man sollte dann ja sowieso das Passwort ändern.

Gruß Tommy

Ja.
Darum schreibe ich die User mit einer PM an und erkläre das. Und hoffe, das sie meinem Rat folgen den Post zu löschen und nicht zu bearbeiten.
Dann ist wenigstens nach 24 Stunden Erledigung möglich.
Natürlich mit dem Hinweis das das Netz nie vergisst....

...

Deshalb bleibt nur die Änderung, auch wenn es nervig ist.

Gruß Tommy

Nein.
Es bleibt nur das löschen und neu schreiben, um hier das Fail zu "verbergen".
Was die ForenSoftware im Hintergrund macht las ich mal aussen vor.

Wenn Du nur änderst, ist die Änderung auch noch Jahre später in der Forensoftware als "Änderungshistorie" erhalten.

Beides schützt nicht z.B. vor der WayBackMachine.

Generell finde ich die Änderungverfolgung nett. Da sieht man was User mit einer Löschmanie geschrieben hatten.
Aber für fahrlässig unbewußt veröffentlichte Passwörter ist es wirklich nicht ideal.

Grüße Uwe

Wenigstens scheinen sofort (innerhalb 5 Minuten? ) gemachte Korrekturen nicht als Modifikation des Posts auf.

grüße Uwe

Doch.
Hatte ich gerade in meinem Offtopic
Gestern habe ich in einem Post den Codeblock verändert. Da auch.
Nach welchen Kriterien da ne Änderung gekennzeichnet wird, ist mir nur noch nicht klar...

@my_xy_projekt
Würde gerne das gelöst zurücknehmen....aber wo ????? Mein Englisch ist noch schlimmer wie meine Arduino Programmier Kennntniss.
Taster Ports stehen genügend zur verfügung D2-D6
Danke im vorraus

Im Post #2 hast Du "Solution" gedrückt. Wenn Du dort nochmal draufdrückst geht es weg.

Grüße Uwe

G

@uwefed DANKEEEEEEEEEEE

Dann hab ich noch einen für Dich:
https://forum.arduino.cc/u/Dirkbeyer/preferences/interface
Dort kannst Du die Sprache auf Deutsch stellen :wink:
Über den Rest schau ich nacher...

Soo...
Ich hab mal was gebaut - ohne zu wissen, ob das geht.
Vollkommen ungetestet; Auch syntaktisch vielleicht falsch, aber es soll ein Ansatz sein.

Neue Funktionen:

void setMinute()
{
  tmElements_t tm;
  time_t t;
  if (tasteAuf)
  {
    tm.Minute = Minute++;
  }
  if (tasteAb)
  {
    tm.Minute = Minute--;
  }
  tm.Year = 2021;  // Das muss noch ausgelesen werden...
  tm.Month = Monat;
  tm.Day = Tag;
  tm.Hour = Stunde;
  tm.Second = Sekunde;
  t = makeTime(tm);
  RTC.set(t);
  setTime(t);
}
bool tasteAuf()
{
  constexpr unsigned bouncetime = 50;
  unsigned long lastmillis = 0;
  static bool isRead = false;
  bool isSet = false;
  if (digitalRead(!tasterAuf)
  {
    if (!isRead)
    {
      lastmillis = millis();
      isRead = true;
      isSet = true;
    }
  }
  else if (isRead)
  {
    if (millis() - lastmillis > bouncetime)
    {
      isRead = false;
    }
  }
  return isSet;
}

bool tasteAb()
{
  constexpr unsigned bouncetime = 50;
  unsigned long lastmillis = 0;
  static bool isRead = false;
  bool isSet = false;
  if (digitalRead(!tasterAb))
  {
    if (!isRead)
    {
      lastmillis = millis();
      isRead = true;
      isSet = true;
    }
  }
  else if (isRead)
  {
    if (millis() - lastmillis > bouncetime)
    {
      isRead = false;
    }
  }
  return isSet;
}

Im loop() nur eine neuen Zeile am Ende einfügen:

setMinute();

Wenn mich nicht alles täuscht, kommt es zum Überlauf - Wenn Du also bei 59 bist, geht mit dem nächsten Tastendruck zwar 00 - aber dei Stunde zählt hoch....

Mach was draus. Bau Dir Serielle Ausgaben ein.

Danke dir erst mal. Fragen über Fragen ???? Mir fehlt einfach das Grundwissen um deinen Scetch zum laufen zu bringen. Es kommen nachdem einbinden viele Fehlermeldungen. Bin ein bischen überfordert. Hardware ist eher mein Gebiet. Nach welchem Prinzip definiere ich meine Taster ???

Also. ganz oben im Sketch zwei Pins definieren.
Dann ein CodeGrundgerüst...

const byte tasterAuf=xx; // xx sind die Pin-Nummern!
const byte tasterAb=xx;

void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
  pinMode(tasterAuf, INPUT_PULLUP); // Der Taster ist ungedrückt HIGH
  pinMode(tasterAb, INPUT_PULLUP); // und verbunden nach GND
}

void loop()
{
}

Möchtest Du nicht besser das drei Tage liegen lassen und eine gute Einführung lesen?
Hier einfach das pdf runterladen: ArduinoForum.de - Das deutschsprachige Forum rund um den Arduino - Arduino Code-Referenz (deutsch) und abends ein paar Seiten lesen - nicht auswendig lernen, nur wissen, was drin steht.