Neopixel funktionieren bei längerem Programmcode nicht mehr

kone1992 · December 21, 2021, 9:38pm

Guten Abend zusammen,

ich bin ein SPS-Programmierer, der sich seit kurzem an Arduino versucht. Mit C+ habe ich bisher nicht viel Erfahrung. Mein aktuelles Projekt ist eine Buchstabenuhr - ähnlich einer "Qlocktwo" auf Bayrisch - da sich diese meine Freundin zu Weihnachten wünscht. Das ganze ist personalisiert und soll unter anderem Namen der Kinder usw. anzeigen können.

Für mein Projekt benutze ich einen Nano V3.0 mit Atmega328 CH340 von AZ-Delivery.
Das Projekt übertrage ich mit Arduino IDE, Board "Arduino Nano", Prozessor "Atmega 328P (Old Bootloader)"

Zu meinem Problem: Ich binde SK6812-Neopixel (ähnlich WS2812B) mithilfe der Bibliothek ein. Wenn ich den kompletten Code einfüge funktioniert zwar der serielle Monitor noch, der PWM-Pin 3 für die Neopixel arbeitet aber scheinbar nicht mehr.
Die Uhr hat soweit funktioniert, bis der Code mehr wurde. Laut Kompiler liege ich aber bloß bei 42% des Programmspeichers und 57% der Variablen. Wenn ich eine (oder mehrere, je nach Länge) Betriebsart aus dem Programm entferne klappt die Übertragung der angesteuerten LED einwandfrei. Dabei ist es nicht relevant, welche Betriebsart das genau ist. Es wirkt so, als würde der PWM-Pin aufgrund der Programmlänge abstürzen!?!
Liege ich da richtig?

Gibt es einen oder mehrere Performance-Programmfehler, den ich mir geleistet habe?

Kann ich irgendwo Programmlänge einsparen? Würden z. B. Sprünge statt If-Anweisungen helfen?

Vielen Dank für eure Zeit so kurz vor Weihnachten!

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// Released under the GPLv3 license to match the rest of the
// Adafruit NeoPixel library

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN        3 // On Trinket or Gemma, suggest changing this to 1

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 220 // Popular NeoPixel ring size

// When setting up the NeoPixel library, we tell it how many pixels,
// and which pin to use to send signals. Note that for older NeoPixel
// strips you might need to change the third parameter -- see the
// strandtest example for more information on possible values.
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRBW);


//LED_NR vorbelegen
byte Es[4] = {216, 217, 218, 219};
byte is[4] = {210, 211, 212, 213};
byte zehn[8] = {200, 201, 202, 203, 204, 205, 206, 207};
byte fuenf[8] = {180, 181, 182, 183, 184, 185, 186, 187};
byte zwanzg[12] = {188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199};
byte dreiviertl[8] = {172, 173, 174, 175, 176, 177, 178, 179};
byte viertl[12] = {160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171};
byte noch[8] = {150, 151, 152, 153, 154, 155, 156, 157};
byte kurz[8] = {140, 141, 142, 143, 144, 145, 146, 147};
byte vor[6] = {134, 135, 136, 137, 138, 139};
byte hoibe[10] = {122, 123, 124, 125, 126, 127, 128, 129, 130, 131};
byte zweife[12] = {100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111};
byte drei[8] = {112, 113, 114, 115, 116, 117, 118, 119};
byte eife[8] = {92, 93, 94, 95, 96, 97, 98, 99};
byte fuenfe[10] = {82, 83, 84, 85, 86, 87, 88, 89, 90, 91};
byte simme[10] = {70, 71, 72, 73, 74, 75, 76, 77, 78, 79};
byte viere[10] = {60, 61, 62, 63, 64, 65, 66, 67, 68, 69};
byte oans[8] = {52, 53, 54, 55, 56, 57, 58, 59};
byte achte[10] = {42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
byte zehne[10] = {24, 25, 26, 27, 28, 29, 30, 31, 32, 33};
byte neine[10] = {30, 31, 32, 33, 34, 35, 36, 37, 38, 39};
byte sechse[12] = {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
byte zwoa[8] = {0, 1, 2, 3, 4, 5, 6, 7};


byte lucia[10] = {158, 159, 160, 161, 118, 119, 120, 121, 80, 81};
byte baze[8] = {20, 21, 22, 23, 24, 25, 26, 27};
byte bier[8] = {132, 133, 106, 107, 92, 93, 66, 67};
byte franz[10] = {6, 7, 30, 31, 50, 51, 66, 67, 94, 95};

byte d1x[18] = {146, 147, 132, 133, 134, 135, 102, 103, 106, 107, 92, 93, 66, 67, 52, 53, 26, 27};
byte d2x[24] = {138, 139, 142, 143, 144, 145, 132, 133, 106, 107, 92, 93, 64, 65, 56, 57, 20, 21, 22, 23, 24, 25, 26, 27};
byte d3x[22] = {138, 139, 142, 143, 144, 145, 132, 133, 106, 107, 94, 95, 66, 67, 52, 53, 22, 23, 24, 25, 58, 59};
byte d4x[26] = {146, 147, 132, 133, 134, 135, 102, 103, 106, 107, 92, 93, 98, 99, 60, 61, 62, 63, 64, 65, 66, 67, 52, 53, 26, 27};
byte d5x[28] = {140, 141, 142, 143, 144, 145, 146, 147, 138, 139, 100, 101, 94, 95, 96, 97, 98, 99, 66, 67, 52, 53, 20, 21, 22, 23, 24, 25};
byte d6x[24] = {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 98, 99, 94, 95, 96, 97, 102, 103, 134, 135, 146, 147};
byte d7x[20] = {140, 141, 142, 143, 144, 145, 146, 147, 132, 133, 106, 107, 94, 95, 64, 65, 56, 52, 22, 23};
byte d8x[28] = {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 94, 95, 96, 97, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145};
byte d9x[28] = {22, 23, 24, 25, 52, 53, 66, 67, 92, 93, 94, 95, 96, 97, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145};
byte d0x[28] = {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 92, 93, 98, 99, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145};

byte dx1[18] = {156, 157, 122, 123, 124, 125, 112, 113, 116, 117, 82, 83, 76, 77, 42, 43, 36, 37};
byte dx2[24] = {128, 129, 152, 153, 154, 155, 122, 123, 116, 117, 82, 83, 74, 75, 46, 47, 30, 31, 32, 33, 34, 35, 36, 37};
byte dx3[22] = {128, 129, 152, 153, 154, 155, 122, 123, 116, 117, 84, 85, 76, 77, 42, 53, 32, 33, 34, 35, 58, 59};
byte dx4[26] = {156, 157, 122, 123, 124, 125, 112, 113, 116, 117, 82, 83, 88, 89, 70, 71, 72, 73, 74, 75, 76, 77, 52, 53, 36, 37};
byte dx5[28] = {150, 151, 152, 153, 154, 155, 156, 157, 128, 129, 110, 111, 84, 85, 86, 87, 88, 89, 76, 77, 42, 43, 30, 31, 32, 33, 34, 35};
byte dx6[24] = {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 88, 89, 84, 85, 86, 87, 112, 113, 124, 125, 156, 157};
byte dx7[20] = {150, 151, 152, 153, 154, 155, 156, 157, 122, 123, 116, 117, 84, 85, 74, 75, 46, 42, 32, 33};
byte dx8[28] = {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 84, 85, 86, 87, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155};
byte dx9[28] = {22, 33, 34, 35, 42, 43, 76, 77, 82, 83, 84, 85, 86, 87, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155};
byte dx0[28] = {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 82, 83, 88, 89, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155};

byte Digitalzahl;
byte Digitalzahlx10;
byte Digitalzahlx1;

//Farbe vorbelegen
byte rot = 0;
byte gruen = 53;
byte blau = 100;
byte weiss = 0;
byte TasterHellblau = 2;
byte TasterRotOben = 4;
byte TasterRotUnten = 5;
byte TasterGelbOben = 6;
byte TasterGelbUnten = 7;
byte TasterBlauOben = 8;
byte TasterBlauUnten = 9;
byte TasterWeisOben = 10;
byte TasterWeisUnten = 11;
byte TasterD12 = 12;
byte TasterD13 = 13;
byte AddierenSekunde;
byte AddierenMinute;
byte AddierenStunde;
byte AddierenTag;
byte AddierenMonat;
byte AddierenJahr;
byte SubtraierenSekunde;
byte SubtrahierenMinute;
byte SubtrahierenStunde;
byte SubtrahierenTag;
byte SubtrahierenMonat;
byte SubtrahierenJahr;
byte BetriebsartWechseln;
unsigned long aktuelleMillis;
unsigned long aktuelleSekunde;
unsigned long vorherigeSekunde;
byte Sekunde;
byte Minute;
byte Stunde;
byte Tag;
byte Monat;
byte Jahr;
byte Jahrhundert;
byte TageszeitSek;
byte Wochentag;
byte Sommerzeit;
int Betriebsart = 1;
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void setup() {
  // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
  // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  // END of Trinket-specific code.

  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)



  TageszeitSek = 0;
  Stunde = 17;
  Minute = 43;
  Sekunde = 20;
  Tag = 19;
  Monat = 12;
  Jahr = 21;
  Jahrhundert = 20;
  Sommerzeit = 0;


  pinMode (TasterHellblau, INPUT_PULLUP);
  pinMode (TasterRotOben, INPUT_PULLUP);
  pinMode (TasterRotUnten, INPUT_PULLUP);
  pinMode (TasterGelbOben, INPUT_PULLUP);
  pinMode (TasterGelbUnten, INPUT_PULLUP);
  pinMode (TasterBlauOben, INPUT_PULLUP);
  pinMode (TasterBlauUnten, INPUT_PULLUP);
  pinMode (TasterWeisOben, INPUT_PULLUP);
  pinMode (TasterWeisUnten, INPUT_PULLUP);
  pinMode (TasterD12, INPUT_PULLUP);
  pinMode (TasterD13, INPUT_PULLUP);
  Serial.begin(9600);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop() {
  //-----------------------------------------------
  // Spannung einlesen
  //-----------------------------------------------
  int Analog0 = analogRead(A0);
  float Spannung = Analog0 * (5 / 1023.00) * 3.159;



  aktuelleMillis = millis();
  aktuelleSekunde = aktuelleMillis / 1000;
  AddierenSekunde = (digitalRead(TasterWeisOben));
  AddierenMinute = (digitalRead(TasterWeisUnten));
  AddierenMonat = (digitalRead(TasterBlauUnten));
  BetriebsartWechseln = (digitalRead(TasterHellblau));

  //-------------------------------------------------------------------------------Sekunde
  if (aktuelleSekunde > vorherigeSekunde) {
    Minute = Minute + 1;
    if (BetriebsartWechseln) {
      Betriebsart = Betriebsart + 1;
    }
    if (Betriebsart > 13) {
      Betriebsart = 1;
    }
    pixels.clear(); // Set all pixel colors to 'off'
    Serial.print(Spannung);
    Serial.print(" ");
    Serial.print(aktuelleMillis);
    Serial.print(" Aktuelle Zeit: ");
    Serial.print(Stunde);
    Serial.print(":");
    Serial.print(Minute);
    Serial.print(":");
    Serial.print(Sekunde);
    Serial.print(" ");
    Serial.print(Tag);
    Serial.print(".");
    Serial.print(Monat);
    Serial.print(".");
    Serial.print(Jahr);
    Serial.print(" ");

    //------------------------Betriebsart Bayern/Oberpfälzer-Uhr-------------------------------------------------------
    if (Betriebsart == 1 || Betriebsart == 3) {  //Betriebsart1=Bayernuhr, Betriebsart2=Bieruhr, Betriebsart3=Oberpfälzeruhr, Betriebsart4=Franzuhr, Betriebsart5=BazeUhr; Betriebsart6=LuciaUhr; Betriebsart7=Sekunde, Betriebsart8=Minute; Betriebsart9=Stunde; Betriebsart10=Tag; Betriebsart11=Monat, Betriebsart12=Jahr
      Serial.print(" -   Es ist ");                                                                                                                             for (byte i = 0; i < 4; i = i + 1) {
        pixels.setPixelColor(Es[i], pixels.Color(rot, gruen, blau, weiss)); //Es ist
      } for (byte i = 0; i < 4; i = i + 1) {
        pixels.setPixelColor(is[i], pixels.Color(rot, gruen, blau, weiss));
      }
      if ((Minute > 2 && Minute <= 7) || (Minute > 52 && Minute <= 57) || (Minute > 22 && Minute <= 27) || (Minute > 32 && Minute <= 37))   {
        Serial.print("fünf ");  //fünf
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(fuenf[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Minute > 7 && Minute <= 12) || (Minute > 47 && Minute <= 52))  {
        Serial.print("zehn ");                                                                  //zehn
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(zehn[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Minute > 42 && Minute <= 47)                                   {
        Serial.print("drei");                                                                   //drei(viertl)
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(dreiviertl[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Minute > 12 && Minute <= 17) || (Minute > 42 && Minute <= 47)) {
        Serial.print("viertl ");                                                                //viertl
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(viertl[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Minute > 17 && Minute <= 22) || (Minute > 37 && Minute <= 42)) {
        Serial.print("zwanzg ");                                                                //zwanzg
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(zwanzg[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Minute > 2 && Minute <= 22) || (Minute > 32 && Minute <= 37)) {
        Serial.print("noch ");                                                                  //noch
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(noch[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Minute > 47 && Minute <= 57) || (Minute > 22 && Minute <= 27) || (Minute > 37 && Minute <= 42)) {
        Serial.print("vor ");                                   //vor
        for (byte i = 0; i < 6; i = i + 1) {
          pixels.setPixelColor(vor[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Minute > 22 && Minute <= 37)) {
        Serial.print("hoibe ");                                                                                                 //hoibe
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(hoibe[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }


      if ((Stunde == 1 || Stunde == 13)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 12) || Stunde == 13) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Oans");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(oans[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 2 || Stunde == 14)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 1) || Stunde == 14)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Zwoa");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(zwoa[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 3 || Stunde == 15)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 2) || Stunde == 15)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Drei");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(drei[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 4 || Stunde == 16)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 3) || Stunde == 16)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Viere");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(viere[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 5 || Stunde == 17)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 4) || Stunde == 17)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Fünfe");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(fuenfe[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 6 || Stunde == 18)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 5) || Stunde == 18)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Sechse");
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(sechse[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 7 || Stunde == 19)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 6) || Stunde == 19)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Simme");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(simme[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 8 || Stunde == 20)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 7) || Stunde == 20)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Achte");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(achte[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 9 || Stunde == 21)  && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 8) || Stunde == 21)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Neine");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(neine[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 10 || Stunde == 22) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 9) || Stunde == 22)  && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Zehne");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(zehne[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 11 || Stunde == 23) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 10) || Stunde == 23) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Elfe");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(eife[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if ((Stunde == 12 || Stunde == 24) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17))))  || ((Stunde == 11) || Stunde == 24) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
        Serial.print("Zweife");
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(zweife[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
    }

    //--------- Betriebsart Uhrzeit Einstellen----------------------------------------------------------------------
    if (Betriebsart > 6  && Betriebsart <= 13) {
      if (Betriebsart == 7) {
        if (AddierenSekunde) {
          Sekunde = Sekunde + 1;
        } Digitalzahl = Sekunde;
        pixels.setPixelColor(200, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(201, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 8) {
        if (AddierenMinute) {
          Minute = Minute + 1;
        }  Digitalzahl = Minute;
        pixels.setPixelColor(202, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(203, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 9) {
        if (AddierenStunde) {
          Stunde = Stunde + 1;
        }  Digitalzahl = Stunde;
        pixels.setPixelColor(204, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(205, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 10) {
        if (AddierenTag) {
          Tag = Tag + 1;
          Wochentag = Wochentag + 1;
        } Digitalzahl = Tag;
        pixels.setPixelColor(206, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(207, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 11) {
        if (AddierenMonat) {
          Monat = Monat + 1;
        } Digitalzahl = Monat;
        pixels.setPixelColor(208, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(209, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 12) {
        if (AddierenJahr) {
          Jahr = Jahr + 1;
        } Digitalzahl = Jahr;
        pixels.setPixelColor(210, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(211, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 13) {
        Digitalzahl = Jahrhundert;
        pixels.setPixelColor(212, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(213, pixels.Color(rot, gruen, blau, weiss));
      }

      Digitalzahlx10 = Digitalzahl / 10;
      Digitalzahlx1  = (Digitalzahl - (Digitalzahlx10 * 10));
      Serial.print (Digitalzahlx10);
      Serial.print (Digitalzahlx1);
      if (Digitalzahlx10 == 0) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(d0x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 1) {
        for (byte i = 0; i < 18; i = i + 1) {
          pixels.setPixelColor(d1x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 2) {
        for (byte i = 0; i < 24; i = i + 1) {
          pixels.setPixelColor(d2x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 3) {
        for (byte i = 0; i < 22; i = i + 1) {
          pixels.setPixelColor(d3x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 4) {
        for (byte i = 0; i < 26; i = i + 1) {
          pixels.setPixelColor(d4x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 5) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(d5x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 6) {
        for (byte i = 0; i < 24; i = i + 1) {
          pixels.setPixelColor(d6x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 7) {
        for (byte i = 0; i < 20; i = i + 1) {
          pixels.setPixelColor(d7x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 8) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(d8x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx10 == 9) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(d9x[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }

      if (Digitalzahlx1 == 0) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(dx0[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 1) {
        for (byte i = 0; i < 18; i = i + 1) {
          pixels.setPixelColor(dx1[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 2) {
        for (byte i = 0; i < 24; i = i + 1) {
          pixels.setPixelColor(dx2[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 3) {
        for (byte i = 0; i < 22; i = i + 1) {
          pixels.setPixelColor(dx3[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 4) {
        for (byte i = 0; i < 26; i = i + 1) {
          pixels.setPixelColor(dx4[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 5) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(dx5[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 6) {
        for (byte i = 0; i < 24; i = i + 1) {
          pixels.setPixelColor(dx6[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 7) {
        for (byte i = 0; i < 20; i = i + 1) {
          pixels.setPixelColor(dx7[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 8) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(dx8[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (Digitalzahlx1 == 9) {
        for (byte i = 0; i < 28; i = i + 1) {
          pixels.setPixelColor(dx9[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
    }


    //--------- Betriebsart Bieruhr----------------------------------------------------------------------
    if (Betriebsart == 2) {
      Serial.print(" -   Es ist kurz vor hoibe Bier");
      for (byte i = 0; i < 4; i = i + 1) {
        pixels.setPixelColor(Es[i], pixels.Color(rot, gruen, blau, weiss));
      }
      for (byte i = 0; i < 4; i = i + 1) {
        pixels.setPixelColor(is[i], pixels.Color(rot, gruen, blau, weiss)); //Es ist
      }
      for (byte i = 0; i < 8; i = i + 1) {
        pixels.setPixelColor(kurz[i], pixels.Color(rot, gruen, blau, weiss));
      }
      for (byte i = 0; i < 6; i = i + 1) {
        pixels.setPixelColor(vor[i], pixels.Color(rot, gruen, blau, weiss));
      }
      for (byte i = 0; i < 10; i = i + 1) {
        pixels.setPixelColor(hoibe[i], pixels.Color(rot, gruen, blau, weiss));
      }
      for (byte i = 0; i < 8; i = i + 1) {
        pixels.setPixelColor(bier[i], pixels.Color(rot, gruen, blau, weiss));
      }
    }

    //--------- Betriebsart Franzuhr----------------------------------------------------------------------
    if (Betriebsart == 4) {
      for (byte i = 0; i < 10; i = i + 1) {
        pixels.setPixelColor(franz[i], pixels.Color(rot, gruen, blau, weiss));
      }
      Serial.print ("Franz ");

      if (((Monat >= 2) && (Jahr - 21 == 1)) || ((Jahr - 21 == 2) && (Monat == 1))) {
        Serial.print("Oans");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(oans[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 2)) || ((Jahr - 21 == 3) && (Monat == 1))) {
        Serial.print("Zwoa");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(zwoa[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 3)) || ((Jahr - 21 == 4) && (Monat == 1))) {
        Serial.print("Drei");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(drei[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 4)) || ((Jahr - 21 == 5) && (Monat == 1))) {
        Serial.print("Viere");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(viere[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 5)) || ((Jahr - 21 == 6) && (Monat == 1))) {
        Serial.print("Fünfe");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(fuenfe[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 6)) || ((Jahr - 21 == 7) && (Monat == 1))) {
        Serial.print("Sechse");
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(sechse[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 7)) || ((Jahr - 21 == 8) && (Monat == 1))) {
        Serial.print("Simme");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(simme[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 8)) || ((Jahr - 21 == 9) && (Monat == 1))) {
        Serial.print("Achte");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(achte[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 9)) || ((Jahr - 21 == 10) && (Monat == 1))) {
        Serial.print("Neine");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(neine[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 10)) || ((Jahr - 21 == 11) && (Monat == 1))) {
        Serial.print("Zehne");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(zehne[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 11)) || ((Jahr - 21 == 12) && (Monat == 1))) {
        Serial.print("Elfe");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(eife[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 12)) || ((Jahr - 21 == 13) && (Monat == 1))) {
        Serial.print("Zweife");
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(zweife[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }


    }
    //--------- Betriebsart Bazeuhr----------------------------------------------------------------------
    if (Betriebsart == 5) {
      for (byte i = 0; i < 8; i = i + 1) {
        pixels.setPixelColor(baze[i], pixels.Color(rot, gruen, blau, weiss));
      }
      Serial.print ("Baze ");

      if (((Monat >= 2) && (Jahr - 21 == 1)) || ((Jahr - 21 == 2) && (Monat == 1))) {
        Serial.print("Oans");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(oans[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 2)) || ((Jahr - 21 == 3) && (Monat == 1))) {
        Serial.print("Zwoa");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(zwoa[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 3)) || ((Jahr - 21 == 4) && (Monat == 1))) {
        Serial.print("Drei");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(drei[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 4)) || ((Jahr - 21 == 5) && (Monat == 1))) {
        Serial.print("Viere");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(viere[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 5)) || ((Jahr - 21 == 6) && (Monat == 1))) {
        Serial.print("Fünfe");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(fuenfe[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 6)) || ((Jahr - 21 == 7) && (Monat == 1))) {
        Serial.print("Sechse");
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(sechse[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 7)) || ((Jahr - 21 == 8) && (Monat == 1))) {
        Serial.print("Simme");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(simme[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 8)) || ((Jahr - 21 == 9) && (Monat == 1))) {
        Serial.print("Achte");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(achte[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 9)) || ((Jahr - 21 == 10) && (Monat == 1))) {
        Serial.print("Neine");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(neine[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 10)) || ((Jahr - 21 == 11) && (Monat == 1))) {
        Serial.print("Zehne");
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(zehne[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 11)) || ((Jahr - 21 == 12) && (Monat == 1))) {
        Serial.print("Elfe");
        for (byte i = 0; i < 8; i = i + 1) {
          pixels.setPixelColor(eife[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }
      if (((Monat >= 2) && (Jahr - 21 == 12)) || ((Jahr - 21 == 13) && (Monat == 1))) {
        Serial.print("Zweife");
        for (byte i = 0; i < 12; i = i + 1) {
          pixels.setPixelColor(zweife[i], pixels.Color(rot, gruen, blau, weiss));
        }
      }


    }

    //--------- Betriebsart Luziauhr----------------------------------------------------------------------
    if (Betriebsart == 6) {
      Betriebsart = 7;

    }


    //--------- Ergebnisse ausgeben----------------------------------------------------------------------
    Serial.print(" ");
    Serial.print(Betriebsart);
    Serial.println();
    pixels.show();   // Send the updated pixel colors to the hardware.
    vorherigeSekunde = vorherigeSekunde + 1;
    Sekunde = Sekunde + 1;
  }
  //--------------------------------------------------------------------------------Minute
  if (Sekunde >= 60) {
    Sekunde = 0;
    Minute = Minute + 1;
  }
  //--------------------------------------------------------------------------------Tag
  if ((Minute >= 60) && (Sekunde >= 3)) {
    Minute = 0;
    Sekunde = 0;
    Stunde = Stunde + 1;
  }
  if (Minute >= 61) {
    Minute = 1;
  }
  if (((Stunde >= 24) && (Minute >= 59) && (Sekunde > 48)) || (Stunde < 1)) {
    Stunde = 1;
    Minute = 0;
    Sekunde = 0;
    Tag = Tag + 1;
    Wochentag = Wochentag + 1;
  }
  if (Stunde >= 25) {
    Stunde = 1;
  }
  if (Tag >= 32 && (Monat == 1 || Monat == 3  || Monat == 5  || Monat == 7  || Monat  == 8  || Monat == 10  || Monat == 12)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  if (Tag >= 31 && (Monat == 4 || Monat == 6  || Monat == 9  || Monat ==  11)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  if (Tag >= 29 && !(Jahr % 4 == 0) && (Monat == 2)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  if (Tag >= 30 && (Monat == 2)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  if (Monat >= 13) {
    Monat = 1;
    Jahr = Jahr + 1;
  }
  if (Jahr > 99) {
    Jahr = 0;
    Jahrhundert = Jahrhundert + 1;
  }

  //--------------------------------------------------------------------------------
  // Winterzeit & Sommerzeit
  //--------------------------------------------------------------------------------
  if (Monat >= 3) {
    Wochentag = ((Tag + (round((26 * (Monat - 2)) - 2) / 10) + Jahr + (round(Jahr / 4)) + (round(Jahrhundert / 4) - (2 * Jahrhundert))) % 7);
  }
  if ((((Monat == 3)  && (Wochentag == 0) && (Tag >= 25) && (Stunde >= 2)) || ((Monat > 3) && (Monat < 10))) && (Sommerzeit == 0)) {
    Stunde = Stunde + 1;
    Sommerzeit = 1;
  }
  if ((((Monat == 10) && (Wochentag == 0) && (Tag >= 25) && (Stunde >= 3)) || ((Monat < 3) || (Monat > 10))) && (Sommerzeit == 1)) {
    Stunde = Stunde - 1;
    Sommerzeit = 0;
  }
}

noiasca · December 21, 2021, 9:50pm

viel zu viele Codezeilen die fast das gleiche machen.

Arrays nutzen. Es gibt auch mehrdimensionale Arrays.
auf dem AVR ... PROGMEM nutzen
F-Makro nutzen
Konstanten mit const kennzeichen wenn sich die Werte nie ändern.

my_xy_projekt · December 21, 2021, 10:02pm

Was hast Du vor?

    //------------------------Betriebsart Bayern/Oberpfälzer-Uhr-------------------------------------------------------
    if (Betriebsart == 1 || Betriebsart == 3)    //Betriebsart1=Bayernuhr, Betriebsart2=Bieruhr, Betriebsart3=Oberpfälzeruhr, Betriebsart4=Franzuhr, Betriebsart5=BazeUhr; Betriebsart6=LuciaUhr; Betriebsart7=Sekunde, Betriebsart8=Minute; Betriebsart9=Stunde; Betriebsart10=Tag; Betriebsart11=Monat, Betriebsart12=Jahr
    {
      Serial.print(" -   Es ist ");                                                                                                                             for (byte i = 0; i < 4; i = i + 1)
      {

Schau mal, was Du da ganz rechts zu stehen hast!

Alles, was mehr als 5 leerzeichen sind, ersetze durch 5 leerzeichen!
STRG-F
sechs leerzeichen eingeben oben in die Zeile
fünf leerzeichen eingeben in die untere Zeile
Und so oft auf ALLE ERSETZEN klicken, bis es nicht mehr geht!
Drücke danach STRG-T!
Wenn Du dann den Fehler in Deinem Code nicht findest, dann sag Bescheid, wo es genau klemmt.

Du hast keine einzige ausgelagerte Funktion - das wird die nächsten 2 Tage ein schönes Projekt...

[Nachtrag]
Du hast Dich mit Deinen leerzeichen vollkommen verhauen und damit den Code vollständig vergeigt.

Mach mal STRG-F und oben 5 leerzeichen - unten 1 leerzeichen - alle ersetzen - das mehrfach, bis sich nichts mehr ändert.
dann oben ändern auf 4
dann auf 3
dann auf 2
Und das solange bis sich nichts mehr ändert.
Dann STRG-T
Und dann sieh zu, das nicht mehr sowas wie hier passiert:

 //------------------------Betriebsart Bayern/Oberpfälzer-Uhr-------------------------------------------------------
    if (Betriebsart == 1 || Betriebsart == 3) //Betriebsart1=Bayernuhr, Betriebsart2=Bieruhr, Betriebsart3=Oberpfälzeruhr, Betriebsart4=Franzuhr, Betriebsart5=BazeUhr; Betriebsart6=LuciaUhr; Betriebsart7=Sekunde, Betriebsart8=Minute; Betriebsart9=Stunde; Betriebsart10=Tag; Betriebsart11=Monat, Betriebsart12=Jahr
    {
      Serial.print(" - Es ist ");
      for (byte i = 0; i < 4; i = i + 1)
      {
        pixels.setPixelColor(Es[i], pixels.Color(rot, gruen, blau, weiss)); //Es ist
      }
      for (byte i = 0; i < 4; i = i + 1)
      {
        pixels.setPixelColor(is[i], pixels.Color(rot, gruen, blau, weiss));
      }

[/]

kone1992 · December 21, 2021, 10:58pm

Vielen Dank für die schnellen Antworten!

Mit dem Auslagern von Funktionen habe ich mich bisher überhaupt nicht befasst, das ist richtig. Ich wusste auch nicht, dass das hier sinnvoll ist.

Die angegebenen Arrays stehen bei mir jeweils für die LEDs, die pro Wort angesteuert werden sollen. Die Wort-Kombinationen ändern sich ca alle 3-5 Minuten. Zum testen werden aktuell die Minuten sekundlich erhöht.

Ich wollte schon probieren die Arrays zu "addieren" und statt in jeder Anweisung die LED-Farben am Ende gesamt für alle LEDs auf einmal zu schreiben. Das hat sich aber dann in den Foren so herausgelesen als müsste pro Addition ein neues Array geschaffen werden muss, was dann bei der Anzeige von "Es is fünf vor hoibe Viere" allein 5 zusätzliche Arrays entsprechen würden?

Mehrdimensionale Arrays kenne ich von den Siemens-CPUs, hatte ich aber hier nicht für zielführend angesehen.

Ich habe den Programmcode erstmal angepasst - so schnell und so gut es mein Verständnis der entsprechenden Anleitungen zu den von euch genannten Schlagworten zulässt. Ich vermute, dass es jetzt sogar schon wieder laufen würde (es reichte das löschen von ein paar wenigen, beliebigen Zeilen), testen kann ich das aber erst morgen.

Die For-Schleifen sind für das Setzen der Pixelfarben, entsprechend der Nummerierung im LED-Streifen. Da in der Uhr die Worte auch diagonal oder Vertikal stehen können, habe ich das mit Arrays gelöst.
Dabei fällt mir gerade selbst auch Verbesserungspotential auf: Ich könnte zumindest die Worte, die horizontal stehen auch mit einem Array aus 2 Byte ansteuern, indem ich den maximalen Wert und den Minimalen Wert als Start- und End-wert der For-Schleife definiere und den aktuellen Zählwert der For-Schleife dann als LED-Nummer verwende. ungefähr so für LED 172-179:


const byte dreiviertl[2] PROGMEM = {172, 180};
void loop() {
for (byte i = dreiviertel[0]; i < dreiviertel[1]; i = i + 1) {
 pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));

Das würde doch auch einiges bringen, oder?

Hier der vorläufig verbesserte Code:

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// Released under the GPLv3 license to match the rest of the
// Adafruit NeoPixel library

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN 3 // On Trinket or Gemma, suggest changing this to 1

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 220 // Popular NeoPixel ring size

// When setting up the NeoPixel library, we tell it how many pixels,
// and which pin to use to send signals. Note that for older NeoPixel
// strips you might need to change the third parameter -- see the
// strandtest example for more information on possible values.
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRBW);


//LED_NR vorbelegen
const byte Es[4] PROGMEM = {216, 217, 218, 219};
const byte is[4] PROGMEM = {210, 211, 212, 213};
const byte zehn[8] PROGMEM = {200, 201, 202, 203, 204, 205, 206, 207};
const byte fuenf[8] PROGMEM = {180, 181, 182, 183, 184, 185, 186, 187};
const byte zwanzg[12] PROGMEM = {188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199};
const byte dreiviertl[8] PROGMEM = {172, 173, 174, 175, 176, 177, 178, 179};
const byte viertl[12] PROGMEM = {160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171};
const byte noch[8] PROGMEM = {150, 151, 152, 153, 154, 155, 156, 157};
const byte kurz[8] PROGMEM = {140, 141, 142, 143, 144, 145, 146, 147};
const byte vor[6] PROGMEM = {134, 135, 136, 137, 138, 139};
const byte hoibe[10] PROGMEM = {122, 123, 124, 125, 126, 127, 128, 129, 130, 131};
const byte zweife[12] PROGMEM = {100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111};
const byte drei[8] PROGMEM = {112, 113, 114, 115, 116, 117, 118, 119};
const byte eife[8] PROGMEM = {92, 93, 94, 95, 96, 97, 98, 99};
const byte fuenfe[10] PROGMEM = {82, 83, 84, 85, 86, 87, 88, 89, 90, 91};
const byte simme[10] PROGMEM = {70, 71, 72, 73, 74, 75, 76, 77, 78, 79};
const byte viere[10] PROGMEM = {60, 61, 62, 63, 64, 65, 66, 67, 68, 69};
const byte oans[8] PROGMEM = {52, 53, 54, 55, 56, 57, 58, 59};
const byte achte[10] PROGMEM = {42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
const byte zehne[10] PROGMEM = {24, 25, 26, 27, 28, 29, 30, 31, 32, 33};
const byte neine[10] PROGMEM = {30, 31, 32, 33, 34, 35, 36, 37, 38, 39};
const byte sechse[12] PROGMEM = {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
const byte zwoa[8] PROGMEM = {0, 1, 2, 3, 4, 5, 6, 7};


const byte lucia[10] PROGMEM = {158, 159, 160, 161, 118, 119, 120, 121, 80, 81};
const byte baze[8] PROGMEM = {20, 21, 22, 23, 24, 25, 26, 27};
const byte bier[8] PROGMEM = {132, 133, 106, 107, 92, 93, 66, 67};
const byte franz[10] PROGMEM = {6, 7, 30, 31, 50, 51, 66, 67, 94, 95};

const byte d1x[18] PROGMEM = {146, 147, 132, 133, 134, 135, 102, 103, 106, 107, 92, 93, 66, 67, 52, 53, 26, 27};
const byte d2x[24] PROGMEM = {138, 139, 142, 143, 144, 145, 132, 133, 106, 107, 92, 93, 64, 65, 56, 57, 20, 21, 22, 23, 24, 25, 26, 27};
const byte d3x[22] PROGMEM = {138, 139, 142, 143, 144, 145, 132, 133, 106, 107, 94, 95, 66, 67, 52, 53, 22, 23, 24, 25, 58, 59};
const byte d4x[26] PROGMEM = {146, 147, 132, 133, 134, 135, 102, 103, 106, 107, 92, 93, 98, 99, 60, 61, 62, 63, 64, 65, 66, 67, 52, 53, 26, 27};
const byte d5x[28] PROGMEM = {140, 141, 142, 143, 144, 145, 146, 147, 138, 139, 100, 101, 94, 95, 96, 97, 98, 99, 66, 67, 52, 53, 20, 21, 22, 23, 24, 25};
const byte d6x[24] PROGMEM = {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 98, 99, 94, 95, 96, 97, 102, 103, 134, 135, 146, 147};
const byte d7x[20] PROGMEM = {140, 141, 142, 143, 144, 145, 146, 147, 132, 133, 106, 107, 94, 95, 64, 65, 56, 52, 22, 23};
const byte d8x[28] PROGMEM = {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 94, 95, 96, 97, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145};
const byte d9x[28] PROGMEM = {22, 23, 24, 25, 52, 53, 66, 67, 92, 93, 94, 95, 96, 97, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145};
const byte d0x[28] PROGMEM = {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 92, 93, 98, 99, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145};

const byte dx1[18] PROGMEM = {156, 157, 122, 123, 124, 125, 112, 113, 116, 117, 82, 83, 76, 77, 42, 43, 36, 37};
const byte dx2[24] PROGMEM = {128, 129, 152, 153, 154, 155, 122, 123, 116, 117, 82, 83, 74, 75, 46, 47, 30, 31, 32, 33, 34, 35, 36, 37};
const byte dx3[22] PROGMEM = {128, 129, 152, 153, 154, 155, 122, 123, 116, 117, 84, 85, 76, 77, 42, 53, 32, 33, 34, 35, 58, 59};
const byte dx4[26] PROGMEM = {156, 157, 122, 123, 124, 125, 112, 113, 116, 117, 82, 83, 88, 89, 70, 71, 72, 73, 74, 75, 76, 77, 52, 53, 36, 37};
const byte dx5[28] PROGMEM = {150, 151, 152, 153, 154, 155, 156, 157, 128, 129, 110, 111, 84, 85, 86, 87, 88, 89, 76, 77, 42, 43, 30, 31, 32, 33, 34, 35};
const byte dx6[24] PROGMEM = {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 88, 89, 84, 85, 86, 87, 112, 113, 124, 125, 156, 157};
const byte dx7[20] PROGMEM = {150, 151, 152, 153, 154, 155, 156, 157, 122, 123, 116, 117, 84, 85, 74, 75, 46, 42, 32, 33};
const byte dx8[28] PROGMEM = {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 84, 85, 86, 87, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155};
const byte dx9[28] PROGMEM = {22, 33, 34, 35, 42, 43, 76, 77, 82, 83, 84, 85, 86, 87, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155};
const byte dx0[28] PROGMEM = {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 82, 83, 88, 89, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155};

byte Digitalzahl;
byte Digitalzahlx10;
byte Digitalzahlx1;

//Farbe vorbelegen
byte rot = 0;
byte gruen = 53;
byte blau = 100;
byte weiss = 0;
const byte TasterHellblau = 2;
const byte TasterRotOben = 4;
const byte TasterRotUnten = 5;
const byte TasterGelbOben = 6;
const byte TasterGelbUnten = 7;
const byte TasterBlauOben = 8;
const byte TasterBlauUnten = 9;
const byte TasterWeisOben = 10;
const byte TasterWeisUnten = 11;
const byte TasterD12 = 12;
const byte TasterD13 = 13;
byte AddierenSekunde;
byte AddierenMinute;
byte AddierenStunde;
byte AddierenTag;
byte AddierenMonat;
byte AddierenJahr;
byte SubtrahierenSekunde;
byte SubtrahierenMinute;
byte SubtrahierenStunde;
byte SubtrahierenTag;
byte SubtrahierenMonat;
byte SubtrahierenJahr;
byte BetriebsartWechseln;
unsigned long aktuelleMillis;
unsigned long aktuelleSekunde;
unsigned long vorherigeSekunde;
byte Sekunde;
byte Minute;
byte Stunde;
byte Tag;
byte Monat;
byte Jahr;
byte Jahrhundert;
byte TageszeitSek;
byte Wochentag;
byte Sommerzeit;
int Betriebsart = 1;
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void setup() {
 // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
 // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
 clock_prescale_set(clock_div_1);
#endif
 // END of Trinket-specific code.

 pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)



 TageszeitSek = 0;
 Stunde = 17;
 Minute = 43;
 Sekunde = 20;
 Tag = 19;
 Monat = 12;
 Jahr = 21;
 Jahrhundert = 20;
 Sommerzeit = 0;


 pinMode (TasterHellblau, INPUT_PULLUP);
 pinMode (TasterRotOben, INPUT_PULLUP);
 pinMode (TasterRotUnten, INPUT_PULLUP);
 pinMode (TasterGelbOben, INPUT_PULLUP);
 pinMode (TasterGelbUnten, INPUT_PULLUP);
 pinMode (TasterBlauOben, INPUT_PULLUP);
 pinMode (TasterBlauUnten, INPUT_PULLUP);
 pinMode (TasterWeisOben, INPUT_PULLUP);
 pinMode (TasterWeisUnten, INPUT_PULLUP);
 pinMode (TasterD12, INPUT_PULLUP);
 pinMode (TasterD13, INPUT_PULLUP);
 Serial.begin(9600);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop() {
 //-----------------------------------------------
 // Spannung einlesen
 //-----------------------------------------------
 int Analog0 = analogRead(A0);
 float Spannung = Analog0 * (5 / 1023.00) * 3.159;



 aktuelleMillis = millis();
 aktuelleSekunde = aktuelleMillis / 1000;
 AddierenSekunde = (digitalRead(TasterWeisOben));
 AddierenMinute = (digitalRead(TasterWeisUnten));
 AddierenMonat = (digitalRead(TasterBlauUnten));
 BetriebsartWechseln = (digitalRead(TasterHellblau));

 //-------------------------------------------------------------------------------Sekunde
 if (aktuelleSekunde > vorherigeSekunde) {
 Minute = Minute + 1;
 if (BetriebsartWechseln) {
 Betriebsart = Betriebsart + 1;
 }
 if (Betriebsart > 13) {
 Betriebsart = 1;
 }
 pixels.clear(); // Set all pixel colors to 'off'
 Serial.print(Spannung);
 Serial.print(" ");
 Serial.print(aktuelleMillis);
 Serial.print(" Aktuelle Zeit: ");
 Serial.print(Stunde);
 Serial.print(":");
 Serial.print(Minute);
 Serial.print(":");
 Serial.print(Sekunde);
 Serial.print(" ");
 Serial.print(Tag);
 Serial.print(".");
 Serial.print(Monat);
 Serial.print(".");
 Serial.print(Jahr);
 Serial.print(" ");

 //------------------------Betriebsart Bayern/Oberpfälzer-Uhr-------------------------------------------------------
 if (Betriebsart == 1 || Betriebsart == 3) { //Betriebsart1=Bayernuhr, Betriebsart2=Bieruhr, Betriebsart3=Oberpfälzeruhr, Betriebsart4=Franzuhr, Betriebsart5=BazeUhr; Betriebsart6=LuciaUhr; Betriebsart7=Sekunde, Betriebsart8=Minute; Betriebsart9=Stunde; Betriebsart10=Tag; Betriebsart11=Monat, Betriebsart12=Jahr
 Serial.print(" - Es ist "); for (byte i = 0; i < 4; i = i + 1) {
 pixels.setPixelColor(Es[i], pixels.Color(rot, gruen, blau, weiss));
  pixels.setPixelColor(is[i], pixels.Color(rot, gruen, blau, weiss)); //Es ist
 }
 
 if ((Minute > 2 && Minute <= 7) || (Minute > 52 && Minute <= 57) || (Minute > 22 && Minute <= 27) || (Minute > 32 && Minute <= 37)) {
 Serial.print("fünf "); //fünf
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(fuenf[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Minute > 7 && Minute <= 12) || (Minute > 47 && Minute <= 52)) {
 Serial.print("zehn "); //zehn
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(zehn[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Minute > 42 && Minute <= 47) {
 Serial.print("drei"); //drei(viertl)
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(dreiviertl[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Minute > 12 && Minute <= 17) || (Minute > 42 && Minute <= 47)) {
 Serial.print("viertl "); //viertl
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(viertl[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Minute > 17 && Minute <= 22) || (Minute > 37 && Minute <= 42)) {
 Serial.print("zwanzg "); //zwanzg
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(zwanzg[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Minute > 2 && Minute <= 22) || (Minute > 32 && Minute <= 37)) {
 Serial.print("noch "); //noch
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(noch[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Minute > 47 && Minute <= 57) || (Minute > 22 && Minute <= 27) || (Minute > 37 && Minute <= 42)) {
 Serial.print("vor "); //vor
 for (byte i = 0; i < 6; i = i + 1) {
 pixels.setPixelColor(vor[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Minute > 22 && Minute <= 37)) {
 Serial.print("hoibe "); //hoibe
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(hoibe[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }


 if ((Stunde == 1 || Stunde == 13) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 12) || Stunde == 13) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Oans");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(oans[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 2 || Stunde == 14) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 1) || Stunde == 14) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Zwoa");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(zwoa[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 3 || Stunde == 15) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 2) || Stunde == 15) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Drei");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(drei[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 4 || Stunde == 16) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 3) || Stunde == 16) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Viere");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(viere[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 5 || Stunde == 17) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 4) || Stunde == 17) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Fünfe");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(fuenfe[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 6 || Stunde == 18) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 5) || Stunde == 18) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Sechse");
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(sechse[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 7 || Stunde == 19) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 6) || Stunde == 19) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Simme");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(simme[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 8 || Stunde == 20) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 7) || Stunde == 20) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Achte");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(achte[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 9 || Stunde == 21) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 8) || Stunde == 21) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Neine");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(neine[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 10 || Stunde == 22) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 9) || Stunde == 22) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Zehne");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(zehne[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 11 || Stunde == 23) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 10) || Stunde == 23) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Elfe");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(eife[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if ((Stunde == 12 || Stunde == 24) && (!(Minute > 22 || (Betriebsart == 1 && (Minute > 12 && Minute <= 17)))) || ((Stunde == 11) || Stunde == 24) && (Minute > 22 || (Betriebsart == 3 && (Minute > 12 && Minute <= 17)))) {
 Serial.print("Zweife");
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(zweife[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 }

 //--------- Betriebsart Uhrzeit Einstellen----------------------------------------------------------------------
 if (Betriebsart > 6 && Betriebsart <= 13) {
 if (Betriebsart == 7) {
 if (AddierenSekunde) {
 Sekunde = Sekunde + 1;
 } Digitalzahl = Sekunde;
 pixels.setPixelColor(200, pixels.Color(rot, gruen, blau, weiss));
 pixels.setPixelColor(201, pixels.Color(rot, gruen, blau, weiss));
 }
 if (Betriebsart == 8) {
 if (AddierenMinute) {
 Minute = Minute + 1;
 } Digitalzahl = Minute;
 pixels.setPixelColor(202, pixels.Color(rot, gruen, blau, weiss));
 pixels.setPixelColor(203, pixels.Color(rot, gruen, blau, weiss));
 }
 if (Betriebsart == 9) {
 if (AddierenStunde) {
 Stunde = Stunde + 1;
 } Digitalzahl = Stunde;
 pixels.setPixelColor(204, pixels.Color(rot, gruen, blau, weiss));
 pixels.setPixelColor(205, pixels.Color(rot, gruen, blau, weiss));
 }
 if (Betriebsart == 10) {
 if (AddierenTag) {
 Tag = Tag + 1;
 Wochentag = Wochentag + 1;
 } Digitalzahl = Tag;
 pixels.setPixelColor(206, pixels.Color(rot, gruen, blau, weiss));
 pixels.setPixelColor(207, pixels.Color(rot, gruen, blau, weiss));
 }
 if (Betriebsart == 11) {
 if (AddierenMonat) {
 Monat = Monat + 1;
 } Digitalzahl = Monat;
 pixels.setPixelColor(208, pixels.Color(rot, gruen, blau, weiss));
 pixels.setPixelColor(209, pixels.Color(rot, gruen, blau, weiss));
 }
 if (Betriebsart == 12) {
 if (AddierenJahr) {
 Jahr = Jahr + 1;
 } Digitalzahl = Jahr;
 pixels.setPixelColor(210, pixels.Color(rot, gruen, blau, weiss));
 pixels.setPixelColor(211, pixels.Color(rot, gruen, blau, weiss));
 }
 if (Betriebsart == 13) {
 Digitalzahl = Jahrhundert;
 pixels.setPixelColor(212, pixels.Color(rot, gruen, blau, weiss));
 pixels.setPixelColor(213, pixels.Color(rot, gruen, blau, weiss));
 }

 Digitalzahlx10 = Digitalzahl / 10;
 Digitalzahlx1 = (Digitalzahl - (Digitalzahlx10 * 10));
 Serial.print (Digitalzahlx10);
 Serial.print (Digitalzahlx1);
 if (Digitalzahlx10 == 0) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(d0x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 1) {
 for (byte i = 0; i < 18; i = i + 1) {
 pixels.setPixelColor(d1x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 2) {
 for (byte i = 0; i < 24; i = i + 1) {
 pixels.setPixelColor(d2x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 3) {
 for (byte i = 0; i < 22; i = i + 1) {
 pixels.setPixelColor(d3x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 4) {
 for (byte i = 0; i < 26; i = i + 1) {
 pixels.setPixelColor(d4x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 5) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(d5x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 6) {
 for (byte i = 0; i < 24; i = i + 1) {
 pixels.setPixelColor(d6x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 7) {
 for (byte i = 0; i < 20; i = i + 1) {
 pixels.setPixelColor(d7x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 8) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(d8x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx10 == 9) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(d9x[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }

 if (Digitalzahlx1 == 0) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(dx0[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 1) {
 for (byte i = 0; i < 18; i = i + 1) {
 pixels.setPixelColor(dx1[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 2) {
 for (byte i = 0; i < 24; i = i + 1) {
 pixels.setPixelColor(dx2[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 3) {
 for (byte i = 0; i < 22; i = i + 1) {
 pixels.setPixelColor(dx3[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 4) {
 for (byte i = 0; i < 26; i = i + 1) {
 pixels.setPixelColor(dx4[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 5) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(dx5[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 6) {
 for (byte i = 0; i < 24; i = i + 1) {
 pixels.setPixelColor(dx6[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 7) {
 for (byte i = 0; i < 20; i = i + 1) {
 pixels.setPixelColor(dx7[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 8) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(dx8[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (Digitalzahlx1 == 9) {
 for (byte i = 0; i < 28; i = i + 1) {
 pixels.setPixelColor(dx9[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 }


 //--------- Betriebsart Bieruhr----------------------------------------------------------------------
 if (Betriebsart == 2) {
 Serial.print(" - Es ist kurz vor hoibe Bier");
 for (byte i = 0; i < 4; i = i + 1) {
 pixels.setPixelColor(Es[i], pixels.Color(rot, gruen, blau, weiss));
  pixels.setPixelColor(is[i], pixels.Color(rot, gruen, blau, weiss)); //Es ist
 }
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(kurz[i], pixels.Color(rot, gruen, blau, weiss));
 }
 for (byte i = 0; i < 6; i = i + 1) {
 pixels.setPixelColor(vor[i], pixels.Color(rot, gruen, blau, weiss));
 }
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(hoibe[i], pixels.Color(rot, gruen, blau, weiss));
 }
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(bier[i], pixels.Color(rot + 150, gruen, blau, weiss)); //Bier soll in einer anderen Farbe leuchten, da das Wort Senkrecht wie im Kreuzworträtsel zu den anderen Worten verläuft
 }
 }

 //--------- Betriebsart Franzuhr----------------------------------------------------------------------
 if (Betriebsart == 4) {
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(franz[i], pixels.Color(rot, gruen, blau, weiss));
 }
 Serial.print ("Franz ");

 if (((Monat >= 2) && (Jahr - 21 == 1)) || ((Jahr - 21 == 2) && (Monat == 1))) {
 Serial.print("Oans");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(oans[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 2)) || ((Jahr - 21 == 3) && (Monat == 1))) {
 Serial.print("Zwoa");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(zwoa[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 3)) || ((Jahr - 21 == 4) && (Monat == 1))) {
 Serial.print("Drei");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(drei[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 4)) || ((Jahr - 21 == 5) && (Monat == 1))) {
 Serial.print("Viere");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(viere[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 5)) || ((Jahr - 21 == 6) && (Monat == 1))) {
 Serial.print("Fünfe");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(fuenfe[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 6)) || ((Jahr - 21 == 7) && (Monat == 1))) {
 Serial.print("Sechse");
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(sechse[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 7)) || ((Jahr - 21 == 8) && (Monat == 1))) {
 Serial.print("Simme");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(simme[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 8)) || ((Jahr - 21 == 9) && (Monat == 1))) {
 Serial.print("Achte");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(achte[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 9)) || ((Jahr - 21 == 10) && (Monat == 1))) {
 Serial.print("Neine");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(neine[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 10)) || ((Jahr - 21 == 11) && (Monat == 1))) {
 Serial.print("Zehne");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(zehne[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 11)) || ((Jahr - 21 == 12) && (Monat == 1))) {
 Serial.print("Elfe");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(eife[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 12)) || ((Jahr - 21 == 13) && (Monat == 1))) {
 Serial.print("Zweife");
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(zweife[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }


 }
 //--------- Betriebsart Bazeuhr----------------------------------------------------------------------
 if (Betriebsart == 5) {
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(baze[i], pixels.Color(rot, gruen, blau, weiss));
 }
 Serial.print ("Baze ");

 if (((Monat >= 2) && (Jahr - 21 == 1)) || ((Jahr - 21 == 2) && (Monat == 1))) {
 Serial.print("Oans");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(oans[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 2)) || ((Jahr - 21 == 3) && (Monat == 1))) {
 Serial.print("Zwoa");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(zwoa[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 3)) || ((Jahr - 21 == 4) && (Monat == 1))) {
 Serial.print("Drei");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(drei[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 4)) || ((Jahr - 21 == 5) && (Monat == 1))) {
 Serial.print("Viere");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(viere[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 5)) || ((Jahr - 21 == 6) && (Monat == 1))) {
 Serial.print("Fünfe");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(fuenfe[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 6)) || ((Jahr - 21 == 7) && (Monat == 1))) {
 Serial.print("Sechse");
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(sechse[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 7)) || ((Jahr - 21 == 8) && (Monat == 1))) {
 Serial.print("Simme");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(simme[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 8)) || ((Jahr - 21 == 9) && (Monat == 1))) {
 Serial.print("Achte");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(achte[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 9)) || ((Jahr - 21 == 10) && (Monat == 1))) {
 Serial.print("Neine");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(neine[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 10)) || ((Jahr - 21 == 11) && (Monat == 1))) {
 Serial.print("Zehne");
 for (byte i = 0; i < 10; i = i + 1) {
 pixels.setPixelColor(zehne[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 11)) || ((Jahr - 21 == 12) && (Monat == 1))) {
 Serial.print("Elfe");
 for (byte i = 0; i < 8; i = i + 1) {
 pixels.setPixelColor(eife[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }
 if (((Monat >= 2) && (Jahr - 21 == 12)) || ((Jahr - 21 == 13) && (Monat == 1))) {
 Serial.print("Zweife");
 for (byte i = 0; i < 12; i = i + 1) {
 pixels.setPixelColor(zweife[i], pixels.Color(rot, gruen, blau, weiss));
 }
 }


 }

 //--------- Betriebsart Luziauhr----------------------------------------------------------------------
 if (Betriebsart == 6) {
 Betriebsart = 7;

 }


 //--------- Ergebnisse ausgeben----------------------------------------------------------------------
 Serial.print(" ");
 Serial.print(Betriebsart);
 Serial.println();
 pixels.show(); // Send the updated pixel colors to the hardware.
 vorherigeSekunde = vorherigeSekunde + 1;
 Sekunde = Sekunde + 1;
 }
 //--------------------------------------------------------------------------------Minute
 if (Sekunde >= 60) {
 Sekunde = 0;
 Minute = Minute + 1;
 }
 //--------------------------------------------------------------------------------Tag
 if ((Minute >= 60) && (Sekunde >= 3)) {
 Minute = 0;
 Sekunde = 0;
 Stunde = Stunde + 1;
 }
 if (Minute >= 61) {
 Minute = 1;
 }
 if (((Stunde >= 24) && (Minute >= 59) && (Sekunde > 48)) || (Stunde < 1)) {
 Stunde = 1;
 Minute = 0;
 Sekunde = 0;
 Tag = Tag + 1;
 Wochentag = Wochentag + 1;
 }
 if (Stunde >= 25) {
 Stunde = 1;
 }
 if (Tag >= 32 && (Monat == 1 || Monat == 3 || Monat == 5 || Monat == 7 || Monat == 8 || Monat == 10 || Monat == 12)) {
 Tag = 1;
 Monat = Monat + 1;
 }
 if (Tag >= 31 && (Monat == 4 || Monat == 6 || Monat == 9 || Monat == 11)) {
 Tag = 1;
 Monat = Monat + 1;
 }
 if (Tag >= 29 && !(Jahr % 4 == 0) && (Monat == 2)) {
 Tag = 1;
 Monat = Monat + 1;
 }
 if (Tag >= 30 && (Monat == 2)) {
 Tag = 1;
 Monat = Monat + 1;
 }
 if (Monat >= 13) {
 Monat = 1;
 Jahr = Jahr + 1;
 }
 if (Jahr > 99) {
 Jahr = 0;
 Jahrhundert = Jahrhundert + 1;
 }

 //--------------------------------------------------------------------------------
 // Winterzeit & Sommerzeit
 //--------------------------------------------------------------------------------
 if (Monat >= 3) {
 Wochentag = ((Tag + (round((26 * (Monat - 2)) - 2) / 10) + Jahr + (round(Jahr / 4)) + (round(Jahrhundert / 4) - (2 * Jahrhundert))) % 7);
 }
 if ((((Monat == 3) && (Wochentag == 0) && (Tag >= 25) && (Stunde >= 2)) || ((Monat > 3) && (Monat < 10))) && (Sommerzeit == 0)) {
 Stunde = Stunde + 1;
 Sommerzeit = 1;
 }
 if ((((Monat == 10) && (Wochentag == 0) && (Tag >= 25) && (Stunde >= 3)) || ((Monat < 3) || (Monat > 10))) && (Sommerzeit == 1)) {
 Stunde = Stunde - 1;
 Sommerzeit = 0;
 }
}

Rentner · December 21, 2021, 11:23pm

Hallo,
bei einer Sienems SPS schreibst Du doch auch nicht alles in den OB1.
Mit den kleinen Controllern bist Du schnell am Ende. Die Arrays hast Du ja jetzt schon mal aus dem Speicher raus. Wenn Du constante Texte seriell aus geben willst, oder auf ein Display dann nutze das F Macro dann liegt der Text ausch nicht im ram

Serial.print(F(" - Es ist "));

alles was sich nicht mehr ändert mit const verwenden , z.B pins

const byte TasterHellblau = 2;

String Objekte nicht verwenden , C Zeichenketten sind für die kleinen besser geeignet.

dann mal probieren, wird schon gut gehen. Ansonsten S7-315 CPU raus S7-317 rein mit den neuen S7-1200 /1500 kenne ich mich nicht mehr so aus

kone1992 · December 22, 2021, 11:48pm

So, heute ist viel passiert. Der code sieht mitlerweile viel kompakter aus. Funktioniert auch mitlerweile wieder

Hatte mich bei den zweidimensionalen Arrays an PROGMEM versucht, bin aber dann beim Auslesen gescheitert. Habe mich dann aus zeitlichen Gründen erstmal dagegen entschieden.

Vielen Dank für die Hilfe
Hier mein aktueller Code, für Kritik bin ich gerne offen.

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// Released under the GPLv3 license to match the rest of the
// Adafruit NeoPixel library

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN 3 // On Trinket or Gemma, suggest changing this to 1

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 220 // Popular NeoPixel ring size
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRBW);


//LED_NR vorbelegen
const byte Es[2] = {216, 220};
const byte is[2] = {210, 214};
const byte zehn[2] = {200, 208};
const byte fuenf[2] = {180, 188};
const byte zwanzg[2] = {188, 200};
const byte dreiviertl[2] = {172, 180};
const byte viertl[2] = {160, 172};
const byte noch[2] = {150, 158};
const byte kurz[2] = {140, 148};
const byte vor[2] = {134, 140};
const byte hoibe[2] = {122, 132};

const byte Stundenzeiger [24][2] = {{100, 112}, {52, 60}, {0, 8}, {112, 120}, {60, 70}, {82, 92}, {8, 20}, {70, 80}, {42, 52}, {30, 40}, {24, 34}, {92, 100}, {100, 112}, {52, 60}, {0, 8}, {112, 120}, {60, 70}, {82, 92}, {8, 20}, {70, 80}, {42, 52}, {30, 40}, {24, 34}, {92, 100}};
int Temp;

const byte lucia[10] = {158, 159, 160, 161, 118, 119, 120, 121, 80, 81};
const byte baze[8] = {20, 27};
byte bier[8] = {132, 133, 106, 107, 92, 93, 66, 67};
const byte franz[10] = {6, 7, 30, 31, 50, 51, 66, 67, 94, 95};

//Das nachfolgende Array bezeichnet die LEDs, welche auf der Uhr die Pixel für die jeweiligen Ziffern der Zehnerstelle bilden
const byte Zehnerstelle[10][28] = {
  {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 92, 93, 98, 99, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145},//0#
  {146, 147, 132, 133, 134, 135, 102, 103, 106, 107, 92, 93, 66, 67, 52, 53, 26, 27},//1#
  {138, 139, 142, 143, 144, 145, 132, 133, 106, 107, 92, 93, 64, 65, 56, 57, 20, 21, 22, 23, 24, 25, 26, 27},//2#
  {138, 139, 142, 143, 144, 145, 132, 133, 106, 107, 94, 95, 66, 67, 52, 53, 22, 23, 24, 25, 58, 59},//3#
  {146, 147, 132, 133, 134, 135, 102, 103, 106, 107, 92, 93, 98, 99, 60, 61, 62, 63, 64, 65, 66, 67, 52, 53, 26, 27},//4#
  {140, 141, 142, 143, 144, 145, 146, 147, 138, 139, 100, 101, 94, 95, 96, 97, 98, 99, 66, 67, 52, 53, 20, 21, 22, 23, 24, 25},//5#
  {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 98, 99, 94, 95, 96, 97, 102, 103, 134, 135, 146, 147},//6#
  {140, 141, 142, 143, 144, 145, 146, 147, 132, 133, 106, 107, 94, 95, 64, 65, 56, 57, 22, 23},//7#
  {60, 61, 66, 67, 52, 53, 58, 59, 22, 23, 24, 25, 94, 95, 96, 97, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145},//8#
  {22, 23, 24, 25, 52, 53, 66, 67, 92, 93, 94, 95, 96, 97, 100, 101, 106, 107, 132, 133, 138, 139, 142, 143, 144, 145}
};//9#

//Das nachfolgende Array bezeichnet die LEDs, welche auf der Uhr die Pixel für die jeweiligen Ziffern bilden
const byte Ziffer[10][28] = {
  {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 82, 83, 88, 89, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155},//#0
  {156, 157, 122, 123, 124, 125, 112, 113, 116, 117, 82, 83, 76, 77, 42, 43, 36, 37},//#1
  {128, 129, 152, 153, 154, 155, 122, 123, 116, 117, 82, 83, 74, 75, 46, 47, 30, 31, 32, 33, 34, 35, 36, 37},//2
  {128, 129, 152, 153, 154, 155, 122, 123, 116, 117, 84, 85, 76, 77, 42, 43, 32, 33, 34, 35, 48, 49},//3
  {156, 157, 122, 123, 124, 125, 112, 113, 116, 117, 82, 83, 88, 89, 70, 71, 72, 73, 74, 75, 76, 77, 42, 43, 36, 37},//4
  {150, 151, 152, 153, 154, 155, 156, 157, 128, 129, 110, 111, 84, 85, 86, 87, 88, 89, 76, 77, 42, 43, 30, 31, 32, 33, 34, 35},//5
  {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 88, 89, 84, 85, 86, 87, 112, 113, 124, 125, 156, 157},//6
  {150, 151, 152, 153, 154, 155, 156, 157, 122, 123, 116, 117, 84, 85, 74, 75, 44, 45, 32, 33},//7
  {70, 71, 76, 77, 42, 43, 48, 49, 32, 33, 34, 35, 84, 85, 86, 87, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155},//8
  {32, 33, 34, 35, 42, 43, 76, 77, 82, 83, 84, 85, 86, 87, 110, 111, 116, 117, 122, 123, 128, 129, 152, 153, 154, 155}
};//9

byte Digitalzahl;
byte Digitalzahlx10;
byte Digitalzahlx1;

//Farbe vorbelegen
byte rot = 0;
byte gruen = 53;
byte blau = 100;
byte weiss = 0;
const byte TasterHellblau = 2;
const byte TasterRotOben = 4;
const byte TasterRotUnten = 5;
const byte TasterGelbOben = 6;
const byte TasterGelbUnten = 7;
const byte TasterBlauOben = 8;
const byte TasterBlauUnten = 9;
const byte TasterWeisOben = 10;
const byte TasterWeisUnten = 11;
const byte TasterD12 = 12;
const byte TasterD13 = 13;
byte AddierenSekunde;
byte AddierenMinute;
byte AddierenStunde;
byte AddierenTag;
byte AddierenMonat;
byte AddierenJahr;
byte SubtrahierenSekunde;
byte SubtrahierenMinute;
byte SubtrahierenStunde;
byte SubtrahierenTag;
byte SubtrahierenMonat;
byte SubtrahierenJahr;
byte BetriebsartWechseln;
unsigned long aktuelleMillis;
unsigned long aktuelleSekunde;
unsigned long vorherigeSekunde;
byte Sekunde;
byte Minute;
byte Stunde;
byte Tag;
byte Monat;
byte Jahr;
byte Jahrhundert;
byte TageszeitSek;
byte Wochentag;
byte Sommerzeit;
int Betriebsart = 1;
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void setup() {
  // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
  // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  // END of Trinket-specific code.

  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)



  TageszeitSek = 0;
  Stunde = 17;
  Minute = 43;
  Sekunde = 20;
  Tag = 19;
  Monat = 12;
  Jahr = 21;
  Jahrhundert = 20;
  Sommerzeit = 0;


  pinMode (TasterHellblau, INPUT_PULLUP);
  pinMode (TasterRotOben, INPUT_PULLUP);
  pinMode (TasterRotUnten, INPUT_PULLUP);
  pinMode (TasterGelbOben, INPUT_PULLUP);
  pinMode (TasterGelbUnten, INPUT_PULLUP);
  pinMode (TasterBlauOben, INPUT_PULLUP);
  pinMode (TasterBlauUnten, INPUT_PULLUP);
  pinMode (TasterWeisOben, INPUT_PULLUP);
  pinMode (TasterWeisUnten, INPUT_PULLUP);
  pinMode (TasterD12, INPUT_PULLUP);
  pinMode (TasterD13, INPUT_PULLUP);
  Serial.begin(9600);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop() {
  //-----------------------------------------------
  // Spannung einlesen
  //-----------------------------------------------
  int Analog0 = analogRead(A0);
  float Spannung = Analog0 * (5 / 1023.00) * 3.159;



  aktuelleMillis = millis();
  aktuelleSekunde = aktuelleMillis / 1000;
  AddierenSekunde = !(digitalRead(TasterWeisOben));
  AddierenMinute = !(digitalRead(TasterWeisUnten));
  AddierenMonat = !(digitalRead(TasterBlauUnten));
  BetriebsartWechseln = !(digitalRead(TasterHellblau));

  //-------------------------------------------------------------------------------Sekunde
  if (aktuelleSekunde > vorherigeSekunde) {
    Stunde = Stunde + 1;
    if (BetriebsartWechseln) {
      Betriebsart = Betriebsart + 1;
    }
    if (Betriebsart > 13) {
      Betriebsart = 1;
    }
    pixels.clear(); // Set all pixel colors to 'off'
    Serial.print(Spannung);
    Serial.print(" ");
    Serial.print(aktuelleMillis);
    Serial.print(" Aktuelle Zeit: ");
    Serial.print(Stunde);
    Serial.print(":");
    Serial.print(Minute);
    Serial.print(":");
    Serial.print(Sekunde);
    Serial.print(" ");
    Serial.print(Tag);
    Serial.print(".");
    Serial.print(Monat);
    Serial.print(".");
    Serial.print(Jahr);
    Serial.print(" ");

    //------------------------Betriebsart Bayern/Oberpfälzer-Uhr-------------------------------------------------------
    if (Betriebsart == 1 || Betriebsart == 3) { //Betriebsart1=Bayernuhr, Betriebsart2=Bieruhr, Betriebsart3=Oberpfälzeruhr, Betriebsart4=Franzuhr, Betriebsart5=bazeUhr; Betriebsart6=LuciaUhr; Betriebsart7=Sekunde, Betriebsart8=Minute; Betriebsart9=Stunde; Betriebsart10=Tag; Betriebsart11=Monat, Betriebsart12=Jahr
      SetLed_Es();
      SetLed_is();

      if ((Minute > 2 && Minute <= 7) || (Minute > 52 && Minute <= 57) || (Minute > 22 && Minute <= 27) || (Minute > 32 && Minute <= 37)) {
        SetLed_fuenf();
      }

      if ((Minute > 7 && Minute <= 12) || (Minute > 47 && Minute <= 52)) {
        SetLed_zehn();
      }

      if (Minute > 42 && Minute <= 47) {
        SetLed_dreiviertl();
      }

      if ((Minute > 12 && Minute <= 17) || (Minute > 42 && Minute <= 47)) {
        SetLed_viertl();
      }

      if ((Minute > 17 && Minute <= 22) || (Minute > 37 && Minute <= 42)) {
        SetLed_zwanzg();
      }

      if ((Minute > 2 && Minute <= 22) || (Minute > 32 && Minute <= 37)) {
        SetLed_noch();
      }

      if ((Minute > 47 && Minute <= 57) || (Minute > 22 && Minute <= 27) || (Minute > 37 && Minute <= 42)) {
        SetLed_vor();
      }

      if ((Minute > 22 && Minute <= 37)) {
        SetLed_hoibe();
      }

      if (!(Minute > 22) || ((Betriebsart == 3) && (Minute > 12) && (Minute <= 17))) {
        Temp = Stunde + 1;
      }
      else {
        Temp = Stunde;
      }
      Serial.print(Temp); //Stundenanzeige gesprochen
      for (byte i = Stundenzeiger[Temp][0]; i < Stundenzeiger[Temp][1]; i = i + 1) {
        pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
      }
    }


    //--------- Betriebsart Bieruhr----------------------------------------------------------------------
    if (Betriebsart == 2) {
      Serial.print(" - Es ist kurz vor hoibe Bier");
      SetLed_Es();
      SetLed_is();
      SetLed_kurz();
      SetLed_vor();
      SetLed_hoibe();
      for (byte i = 0; i < 8; i = i + 1) {
        pixels.setPixelColor(bier[i], pixels.Color(rot + 100, gruen, blau, weiss));
      }
    }

    //--------- Betriebsart Franzuhr/Bazeuhr----------------------------------------------------------------------
    if ((Betriebsart == 4) || (Betriebsart == 5)) {
      if (Betriebsart == 4) {
        //LED-Name anzeigen
        for (byte i = 0; i < 10; i = i + 1) {
          pixels.setPixelColor(franz[i], pixels.Color(rot, gruen, blau, weiss));
        }
        Serial.print ("Franz ");
      }
      //LED-Spitzname anzeigen
      if (Betriebsart == 5) {
        for (byte i = baze[0]; i < baze[1]; i = i + 1) {
          pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
        }
        Serial.print ("baze ");
      }

      //Alter anzeigen
      Temp = Jahr - 21;
      if ((Temp <= 12) && (Temp > 0)) {
        if (Monat < 2) {
          Temp = Jahr - 22; //Alter errechnen
        }
        if (Temp > 0) { //Anzeige von 0 Jahren ist nicht möglich
          for (byte i = Stundenzeiger[Temp][0]; i < Stundenzeiger[Temp][1]; i = i + 1) {
            pixels.setPixelColor(Stundenzeiger[Temp][i], pixels.Color(rot, gruen, blau, weiss));
          }
        }
      }
    }

    //--------- Betriebsart Luziauhr----------------------------------------------------------------------
    if (Betriebsart == 6) { //Das dauert noch etwas ;-)
      Betriebsart = 7;

    }
    
    //--------- Betriebsart Uhrzeit Einstellen----------------------------------------------------------------------
    if (Betriebsart > 6 && Betriebsart <= 13) {
      if (Betriebsart == 7) {
        if (AddierenSekunde) {
          Sekunde = Sekunde + 1;
        } Digitalzahl = Sekunde;
        pixels.setPixelColor(200, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(201, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 8) {
        if (AddierenMinute) {
          Minute = Minute + 1;
        } Digitalzahl = Minute;
        pixels.setPixelColor(202, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(203, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 9) {
        if (AddierenStunde) {
          Stunde = Stunde + 1;
        } Digitalzahl = Stunde;
        pixels.setPixelColor(204, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(205, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 10) {
        if (AddierenTag) {
          Tag = Tag + 1;
          Wochentag = Wochentag + 1;
        } Digitalzahl = Tag;
        pixels.setPixelColor(206, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(207, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 11) {
        if (AddierenMonat) {
          Monat = Monat + 1;
        } Digitalzahl = Monat;
        pixels.setPixelColor(208, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(209, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 12) {
        if (AddierenJahr) {
          Jahr = Jahr + 1;
        } Digitalzahl = Jahr;
        pixels.setPixelColor(210, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(211, pixels.Color(rot, gruen, blau, weiss));
      }
      if (Betriebsart == 13) {
        Digitalzahl = Jahrhundert;
        pixels.setPixelColor(212, pixels.Color(rot, gruen, blau, weiss));
        pixels.setPixelColor(213, pixels.Color(rot, gruen, blau, weiss));
      }

      Digitalzahlx10 = Digitalzahl / 10;
      Digitalzahlx1 = (Digitalzahl - (Digitalzahlx10 * 10));
      Serial.print (Digitalzahlx10);
      Serial.print (Digitalzahlx1);



      for (byte i = 0; i < (sizeof(Zehnerstelle[Digitalzahlx10])); i = i + 1) {
        pixels.setPixelColor(Zehnerstelle[Digitalzahlx10][i], pixels.Color(rot, gruen, blau, weiss));
      }

      for (byte i = 0; i < (sizeof(Ziffer[Digitalzahlx1])); i = i + 1) {
        pixels.setPixelColor(Ziffer[Digitalzahlx1][i], pixels.Color(rot, gruen, blau, weiss));
      }
      pixels.setPixelColor(0, pixels.Color(0, 0, 0, 0));


    }



    //--------- Ergebnisse ausgeben----------------------------------------------------------------------
    Serial.print(" ");
    Serial.print(Betriebsart);
    Serial.println();
    pixels.show(); // Send the updated pixel colors to the hardware.
    vorherigeSekunde = vorherigeSekunde + 1;
    Sekunde = Sekunde + 1;
  }

  //Überlauf der Zeiteinheiten
  //Minute
  if (Sekunde >= 60) {
    Sekunde = 0;
    Minute = Minute + 1;
  }
  //Stunde
  if ((Minute >= 60) && (Sekunde >= 3)) {
    Minute = 0;
    Sekunde = 0;
    Stunde = Stunde + 1;
  }
  if (Minute >= 61) {
    Minute = 1;
  }
  //Tag
  if ((Stunde >= 23) && (Minute >= 59) && (Sekunde > 48)) {
    Stunde = 0;
    Minute = 0;
    Sekunde = 0;
    Tag = Tag + 1;
    Wochentag = Wochentag + 1;
  }
  if (Stunde >= 24) {
    Stunde = 0;
  }
  //Monat
  if (Tag >= 32 && (Monat == 1 || Monat == 3 || Monat == 5 || Monat == 7 || Monat == 8 || Monat == 10 || Monat == 12)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  if (Tag >= 31 && (Monat == 4 || Monat == 6 || Monat == 9 || Monat == 11)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  if (Tag >= 29 && !(Jahr % 4 == 0) && (Monat == 2)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  if (Tag >= 30 && (Monat == 2)) {
    Tag = 1;
    Monat = Monat + 1;
  }
  //Jahr
  if (Monat >= 13) {
    Monat = 1;
    Jahr = Jahr + 1;
  }
  //Jahrhundert
  if (Jahr > 99) {
    Jahr = 0;
    Jahrhundert = Jahrhundert + 1;
  }

  //--------------------------------------------------------------------------------
  // Winterzeit & Sommerzeit
  //--------------------------------------------------------------------------------
  if (Monat >= 3) {
    Wochentag = ((Tag + (round((26 * (Monat - 2)) - 2) / 10) + Jahr + (round(Jahr / 4)) + (round(Jahrhundert / 4) - (2 * Jahrhundert))) % 7); //Formel für Wochentagsberechnung
  }
  if ((((Monat == 3) && (Wochentag == 0) && (Tag >= 25) && (Stunde >= 2)) || ((Monat > 3) && (Monat < 10))) && (Sommerzeit == 0)) { //am letzten Sonntag im Monat März wird die Uhr vorgestellt
    Stunde = Stunde + 1;
    Sommerzeit = 1;
  }
  if ((((Monat == 10) && (Wochentag == 0) && (Tag >= 25) && (Stunde >= 3)) || ((Monat < 3) || (Monat > 10))) && (Sommerzeit == 1)) {//am letzten Sonntag im Monat Oktober wird die Uhr zurückgestellt
    Stunde = Stunde - 1;
    Sommerzeit = 0;
  }
}





void SetLed_Es() {
  Serial.print("Es "); //es
  for (byte i = Es[0]; i < Es[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss)); //Es ist
  }
}

void SetLed_is() {
  Serial.print("is "); //is
  for (byte i = is[0]; i < is[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss)); //Es ist
  }
}

void SetLed_fuenf() {
  Serial.print("fünf "); //fünf
  for (byte i = fuenf[0]; i < fuenf[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_zehn() {
  Serial.print("zehn "); //zehn
  for (byte i = zehn[0]; i < zehn[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_dreiviertl() {
  Serial.print("dreiviertl"); //drei(viertl)
  for (byte i = dreiviertl[0]; i < dreiviertl[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_viertl() {
  Serial.print("viertl "); //viertl
  for (byte i = viertl[0]; i < viertl[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_zwanzg() {
  Serial.print("zwanzg "); //zwanzg
  for (byte i = zwanzg[0]; i < zwanzg[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_noch() {
  Serial.print("noch "); //noch
  for (byte i = noch[0]; i < noch[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_vor() {
  Serial.print("vor "); //vor
  for (byte i = vor[0]; i < vor[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_hoibe() {
  Serial.print("hoibe "); //hoibe
  for (byte i = hoibe[0]; i < hoibe[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

void SetLed_kurz() {
  Serial.print("kurz "); //hoibe
  for (byte i = kurz[0]; i < kurz[1]; i = i + 1) {
    pixels.setPixelColor(i, pixels.Color(rot, gruen, blau, weiss));
  }
}

system · June 20, 2022, 11:49pm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Anfänger_LED UHR Deutsch	17	2932	May 6, 2021
Wörteruhr Deutsch	39	3382	May 6, 2021
WordClock - SK6812 - NeoPixel Deutsch	7	1931	May 6, 2021
2 sketche in 1 Deutsch	18	3619	May 6, 2021
problema visualizzazione minuti su adafruit neopixel16x Software	10	2207	May 7, 2021

Neopixel funktionieren bei längerem Programmcode nicht mehr

Related topics