Artnet-Node mit Keypad und Display //Watchdog Problem

Hallo Freunde,

ist schon eine Weile her, aber habe momentan ein anderes Projekt auf dem Plan stehen wobei ich gerade nicht weiter komme. Im Prinzip funktioniert der Node ohne das Keypad einwandfrei.
Es wandelt mir Artnet (DMX) um auf neo Pixel. Das funktioniert soweit auch. Ein I2C Dispplay läuft auch soweit, jedoch sobald ich das keypad einbinde bootet mein MCU Nude jedes mal neu. Über den Serial Monitor konnte ich herausfinden das er durch den Watchdog neugestartet wird bei google.

13:27:19.179 ->  ets Jan  8 2013,rst cause:4, boot mode:(3,6)
13:27:19.179 -> 
13:27:19.179 -> wdt reset
13:27:19.212 -> load 0x4010f000, len 3456, room 16 
13:27:19.212 -> tail 0
13:27:19.212 -> chksum 0x84
13:27:19.212 -> csum 0x84
13:27:19.212 -> va5432625
13:27:19.212 -> ~ld

Da meine Kenntnisse nicht ins detail reichen habe cih das Keypad und dessen program m text aus meinem Strom-/Wasserzähler projekt übernommen. Sobald ich diesen dann, aber hochlade auf das board wird dieser eben immer neugestartet. Deshalb wollte ich hier nochmal nachfragen ob jemand von euch eine Idee hat wieso der watchdog das board hier neustartet?

Zur Funktion wie es eig gedacht ist: Das node soll über einen Schalter für Gartenbeleuchtung eingeschaltet werden, wobei Artnet an das Netwerk konstant über einen Homeserver gesendet wird.
Das node dient dazu nur ein Universum 512 DMX Kanäle auf 170 Neo Pixel zu konvertieren.
Da später ca 5 meter Neopixel angeschlossen werden sollen (300 Pixel) habe ich von einem Freund die Funktion einbauen lassen das man die Pixel gruppieren kann sprich auf einem kanal dasselbe empfangen. In dem Sketch heir ist die Standardeinstellung 6 pixel. Das heißt sobald über DMX die 1 Led angesteuert wird werden auf dem Pixel streifen die ersten 6 angesteuert usw.

Beim starten soll das Node später den Wert aus dem EEprom abrufen und übernehmen. Das habe cih heir aber erstmal weggelassen. Wie gesagt es wird gestartet mit 6.
Das display soll anzeigen das 6 pixel als Gruppierung festgelegt ist und dann nach 3 Sekunden in den Main Loop starten. Ab da sollte dann über das keypad bei drücken von */# das Menü aufgerufen werden womit man sagen kann das man die pixel gruppe ändern möchte, aber heir scheitert es dann schon im programm. Auf jedenfall soll es dann am ende wenn man die neue Pixel anzahl eingegeben hat, als neue gruppeirung übernommen werden und dann natürlich acuh in den eeprom abgelegt werden.

Während das Menü aufgerufen ist, spielt es keine Rolle ob das node Artnet signale weiter verarbeitet.
Wichtig ist nur das es die signale weiter verarbeitet sobald das Menü wieder beendet wurde und das display dann nach x Sekunden wieder abschaltet.

Ich hoffe das der Sinn und Funktion ein wenig deutlich ist.
Untenstehend ist der Code. Den Artnet code habe ich so im Internet gefunden und von einem Freund verbessern lassen der die DMX gruppierung hinzugefügt hat. Dies funktioniert wie gesagt auch einwandfrei mit Display. Nur das Keypad will eben nicht.
Ich hoffe ihr habt da eine Idee wie ich das hinbekommen könnte.

Vielen Dank schonmal für einige Hilfen oder Anregungen.

Liebe Grüße Dennis.

Da Du ja nicht mehr ganz neu hier bist, solltest Du eigentlich wissen, dass das Stochern im Nebel ohne Code sehr selten zu Erfolgen führt.

Gruß Tommy

Hier is der Code da mein EIngangspost wohl zu lang war:

#define FASTLED_ALLOW_INTERRUPTS 0
#include <FastLED.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <Keypad.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"


//wifi connection
#define MY_SSID "artnet_box"
#define MY_PASS "artnettest"
#define LISTEN_PORT 6454
WiFiUDP Udp;

IPAddress multicastAddress(226, 1, 1, 1);
unsigned int multicastPort = 6454;

//local LEDs
int NUM_GROUPS = 170;
int LEDS_PER_GROUP = 6;
int NUM_LEDS = NUM_GROUPS * LEDS_PER_GROUP;
#define LED_PIN 3
CRGB leds[700];




//Keypad setting - Hier wird die größe des Keypads definiert
const byte COLS = 3; //3 Spalten
const byte ROWS = 3; //3 Zeilen
//Die Ziffern/Zeichen:
char hexaKeys[ROWS][COLS] = {
  {'#', '*', '7'},
  {'6', '5', '4'},
  {'3', '2', '1'}
};
byte colPins[COLS] = { 8, 7, 6 }; //Definition der Pins für die 3 Spalten
byte rowPins[ROWS] = { 5, 4, 0 };//Definition der Pins für die 3 Zeilen

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);


//Display Settings

#define I2C_ADDRESS 0x3C
SSD1306AsciiWire oled;


unsigned long displaytime;
int display_state = 1;
unsigned long pixel_auswahl_wert = 0;
int anzahl_digits = 0;
int test_state = 0;
int menu_auswahl_state = 0;
int pixel_auswahl_state = 0;
unsigned long menu_auswahl_wert = 0;
int confirm_state = 0;
unsigned long confirm_auswahl_wert = 0;
unsigned long menu_taste_wert = 0;


void setup()
{
  //cennect to WiFi network
  WiFi.begin(MY_SSID, MY_PASS);
  delay(500);
  // Udp.beginPacketMulticast(LISTEN_PORT);
  //Udp.beginPacketMulticast(ipMulti, portMulti,WiFi.localIP());
  Udp.beginMulticast(WiFi.localIP(), multicastAddress, multicastPort);

  //start LED port
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);

  //start serial port
  //Serial.begin(9600);


  //init Display
   Wire.begin();
  Wire.setClock(400000L);
  oled.begin(&Adafruit128x64, I2C_ADDRESS);
  oled.setFont(TimesNewRoman16_bold); // Auswahl der Schriftart
  oled.setCursor(0, 0);
  oled.println (F("Node started"));
  oled.println (F("Pixelgruppierung"));
  oled.println (F(""));
  oled.print (LEDS_PER_GROUP);
  oled.print (F(" Pixel"));
  delay(3000);
  oled.clear();
  /* Wert aus eeprom laden und aktualisieren */

}

void loop()
{
  unsigned int menu_taste = customKeypad.getKey();
  if (menu_taste) {
    menu_taste_wert = menu_taste_wert * 10 + (menu_taste - 48) ;
    if (menu_taste == 65523 || menu_taste == 65530)
    {
      menu_taste_wert = 0;
      test_state = 1;
    }

    else

    {
      menu_taste_wert = 0;
    }

  }
 
  if (test_state == 1)

  {
    oled.setCursor(0, 0);
    oled.println(F("Hauptmenu"));
    oled.println(F(""));
    oled.println(F("1 = Pixelgruppierung"));
    oled.print(F("#/* = Verlassen"));
    menu_auswahl_state = 1;
    test_state = 0;
  }


  if (menu_auswahl_state == 1)

  {
    unsigned int menu_auswahl = customKeypad.getKey();
    if (menu_auswahl) {
      menu_auswahl_wert = menu_auswahl_wert * 10 + (menu_auswahl - 48) ;
      if (menu_auswahl_wert == 65523 || menu_auswahl_wert == 65530 || menu_auswahl_wert == 1 )

      {

        if (menu_auswahl_wert == 1)

        {
          oled.clear();
          oled.setCursor(0, 0);
          oled.println(F("Pixelgruppierung"));
          oled.println(F("Bitte Anzahl Pixel"));
          oled.println(F("eingeben"));
          oled.print(F("Max. Anzahl 172!"));
          pixel_auswahl_state = 1;
          menu_auswahl_wert = 0;
          menu_auswahl_state = 0;

        }



        else
        {
          oled.clear();
          oled.setCursor(0, 1);
          oled.println(F("Menu verlassen!"));
          oled.println(F("LED Gruppierung:"));
          oled.print(LEDS_PER_GROUP);
          oled.print(F(" Pixels"));
          delay(3000);
          menu_auswahl_wert = 0;
          menu_auswahl_state = 0;

        }
      }

      else

      {
        oled.clear();
        oled.setCursor(0, 1);
        oled.println(F("Ungueltige"));
        oled.println(F("Eingabe!!!"));
        delay(3000);
        oled.clear();
        menu_auswahl_wert = 0;
        test_state = 1;
      
      }


    }

  }
  if (pixel_auswahl_state == 1)

  { oled.clear();
    oled.setCursor(0, 1);
    oled.println(F("Amount Pixel:"));

    unsigned int pixel_auswahl = customKeypad.getKey();
    if (anzahl_digits < 3) {
      if (pixel_auswahl) {
        pixel_auswahl_wert = pixel_auswahl_wert * 10 + (pixel_auswahl - 48) ;
        anzahl_digits ++;
        oled.print(pixel_auswahl_wert);

        if (anzahl_digits == 3)
        {
          if (pixel_auswahl_wert <= 170)
          {
            oled.clear();
            oled.setCursor(0, 0);
            oled.print(pixel_auswahl_wert);
            oled.println(F(" Pixel als Gruppe"));
            oled.println(F("uebernehmen?"));
            oled.println(F("1=JA | 2=Nein"));
            confirm_state = 1;
            anzahl_digits = 0;
            pixel_auswahl_state = 0;
          }

          else
          {
            oled.clear();
            oled.setCursor(0, 0);
            oled.print(pixel_auswahl_wert);
            oled.println(F(" ungueltig!"));
            oled.println(F("Wert muss <170 sein!"));
            oled.print(F("Wert erneut eingeben!"));
            delay(3000);
            anzahl_digits = 0;
            pixel_auswahl_wert = 0;
          }
        }


      }
    }
  }
  if (confirm_state == 1)

  {

    unsigned int confirm_auswahl = customKeypad.getKey();
    if (confirm_auswahl) {
      confirm_auswahl_wert = confirm_auswahl_wert * 10 + (confirm_auswahl - 48) ;

      if (confirm_auswahl_wert == 1 || confirm_auswahl_wert == 2)
      {

        if (confirm_auswahl_wert == 1)
        {
          oled.clear();
          oled.setCursor(0, 0);
          oled.print(pixel_auswahl_wert);
          oled.println(F(" Pixel als Gruppe"));
          oled.println(F("uebernommen!"));
          oled.println(F("Wert in Speicher"));
          oled.print(F("geschrieben"));
          LEDS_PER_GROUP = pixel_auswahl_wert;
          pixel_auswahl_wert = 0;
          confirm_state = 0;

        }

        else

        {
          oled.clear();
          oled.setCursor(0, 0);
          oled.print(pixel_auswahl_wert);
          oled.println(F(" Pixel als Gruppe"));
          oled.println(F("abgelehnt!"));
          oled.println(F("Menu wird beendet"));
          oled.print(F("3.."));
          delay(1000);
          oled.print(F("2.."));
          delay(1000);
          oled.print(F("1.."));
          delay(1000);
          oled.clear();
          pixel_auswahl_wert = 0;
          confirm_state = 0;
        }
      }

      else
      {
        oled.clear();
        oled.setCursor(0, 1);
        oled.println(F("Ungueltige"));
        oled.println(F("Eingabe!!!"));
        delay(3000);
        oled.clear();
        oled.setCursor(0, 0);
        oled.print(pixel_auswahl_wert);
        oled.println(F(" Pixel als Gruppe"));
        oled.println(F("uebernehmen?"));
        oled.println(F("1=JA | 2=Nein"));
        confirm_auswahl_wert = 0;


      }

    }
  }

*/


  //get Art-Net
  RecieveUdp();

  //wait a spell
  delay(1);
}




//process incoming UDP message
void RecieveUdp()
{
  byte packet[18 + (NUM_GROUPS * 3)];

  //test if a packet has been recieved
  if (Udp.parsePacket() > 0)
  {
    //read-in packet and get length
    int len = Udp.read(packet, 18 + (NUM_GROUPS * 3));

    //discard unread bytes
    Udp.flush();

    //test for empty packet
    if (len < 1)
      return;

    //test for Art-Net DMX packet
    //(packet[14] & packet[15] are the low and high bytes for universe)
    if (packet[9] == 0x50)
    {
      int dmx = 18;

      //copy dmx data to leds
      for (int n = 0; n < NUM_GROUPS; n++) {
        int dmx1 = dmx++;
        int dmx2 = dmx++;
        int dmx3 = dmx++;
        for (int m = n * LEDS_PER_GROUP; m < n * LEDS_PER_GROUP + LEDS_PER_GROUP; m++) {
          leds[m] = CRGB(packet[dmx1], packet[dmx2], packet[dmx3]);
        }

      }


      //push led data
      FastLED.show();
    }
  }
}

Gruß Dennis.

Tommy56:
Da Du ja nicht mehr ganz neu hier bist, solltest Du eigentlich wissen, dass das Stochern im Nebel ohne Code sehr selten zu Erfolgen führt.

Gruß Tommy

Hi Tommy,

ja das weiß ich doch :slight_smile:
Nur war der Post zu lang und das System woltle nicht das ich innerhalb von 5 min, 2 mal was schreibe. Aber das weißt du ja sicherlich selber :stuck_out_tongue_winking_eye:

Gruß Dennis.

Ich vermute, du hast Probleme mit der Pinbelegung.
Du verwendest den Pin 0, der kein normaler I/O Pin ist.

Okay. Welche Pins könnte ich denn noch dafür nehmen? Da ich D1-D8 jetzt schon verwendet habe.
oder gibt es die Möglichket die SCL/SDA für I2C an anderen Pins anzuschließen?
Ich hatte die Pin belegung heirfür auch bei google herausgesucht.

Alternativ könnte ich sonst mal versuchen das Keypad kleiner zu konfigurieren, sodass ich pin 0 nicht belege.

Wenn Du sowieso I2C verwendest, könntest Du das Keypad auch über einen PCF8574 an I2C anschließen.

Gruß Tommy

Sieh dir mal diese Seite an, da sind die Pins alle beschireben.

Ich habe selber noch nicht mit dieser Tastatur am NodeMCU (so heißt der) gearbeitet.
Solltest du einfach mal testen.

Und Tommy hat die richtige Lösung dafür. :wink:

Hallo ihr beiden,

ersteinmal vielen Dank für die schnellen Tipps.

HotSystems:
Sieh dir mal diese Seite an, da sind die Pins alle beschireben.

Ich habe selber noch nicht mit dieser Tastatur am NodeMCU (so heißt der) gearbeitet.
Solltest du einfach mal testen.

Habe den Link mal gechecked und wenn cih es richtig verstehe hat der NodeMCU 6 Normale I/O Pins.
Wobei ich das LED signal am Pin 3 habe und dieser dafür acuh funktioniert. Demnach hätte ich dann 7 Pins die cih verwenden kann.

Testweise habe ich den sketch mal so abgeändert das nur die tasten des keypads 3,2,1 auf Pin 8, 7, 6 und 5 belegt sind, die Led's auf Pin 3 display Pin 2 und 1, aber der node startet trotzdem konstant neu.

Tommy56:
Wenn Du sowieso I2C verwendest, könntest Du das Keypad auch über einen PCF8574 an I2C anschließen.

Gruß Tommy

Wie würde die Anbindung und programmierung hier aussehen. Bleibt der Code dann an sich das selbe?
Das ist halt die Hardware die ich jetzt da habe und das würde ich gerne testen, sodass der programm code an sich erstmal funktioniert. Die komponenten die ich da habe sind von einem freund der ein starter Set gekauft hat, von daher werde ich mir die hardware dann noch besorgen.
Ich versuche halt einfach zuerst zu verstehen warum das board halt immer neu bootet und wenn möglich eine einfache Funktion hinzubekommen. Das keypad könnte ich mir theorethis später auch als I2C pad holen wenn cih dann weiß wie ich es einbinden muss. Sind halt auch alles Info's die ich mir durch google etc. zusammen gesucht habe :wink:

Lg Dennis.

Für mich hat der NodeMCU nur 5 normale I/O's, alle anderen sind mit "Vorsicht" zu genießen.

Warum-Wieso steht in der Beschreibung.

Was die I2C-Anbindung der Tasten betrifft, muss du natürlich noch den entsprechenden Code erweitern. Dazu gibt es genügend Beispiele, auch in dem Link von Tommy.

Wenn Du Dir den verlinkten Artikel zu Gemüte führst (incl. des Zip) siehst Du, wie das Keypad eingebunden wird. Nach dem Einlesen der Taste bleibt Dein Ablauf bestehen.

Gruß Tommy

Hallo Allerseits,

also ich habe in der zwischenzeit das Problem lösen können. Es lag an der PIN definierung.
So wie ich die Pins mit "D5 , D6, D7" etc. angesprochen habe, funktioniert das keypad und das Programm wie es soll. Jedoch habe ich jetzt das Problem das ich gerne einen Wert in den EEProm ablegen möchte, aber dies aus welchen Gründen auch immer nicht gelingt.

Hier ist nochmal der Code. Ich habe mit EEProm.get und EEPROM.put gearbeitet. Aber nichts klappt. Auch mit Write und Read bekomme ich es nicht hin. Ich weiß nicht ob ich irgendetwas falsch mache dabei, da in meinem anderen Projekt der Code eigentlich funktioniert hatte.

Eventuell hat jemand von euch eine Idee?
Es soll am Start im Void Setup der Wert eingelesen werden.
Sobald ich dann aber den Wert über Einstellungen anpasse soll dieser in den EEprom gespeichert werden.

Danke schonmal für eure Hilfe :slight_smile:

Code kommt gleich da der Text mal wieder zu lang ist :wink:

Hier sind die 2 Ausschnitte.
Ganze Code ist leider zu lang fürs Forum.

Aber der rest des codes ist ja in meinem Eingangscode schon zu sehen.
Oder gibt es eine andere Möglichkeit den Code in voller Länge zu posten?

void setup()
{
  //cennect to WiFi network
  WiFi.begin(MY_SSID, MY_PASS);
  delay(500);
  // Udp.beginPacketMulticast(LISTEN_PORT);
  //Udp.beginPacketMulticast(ipMulti, portMulti,WiFi.localIP());
  Udp.beginMulticast(WiFi.localIP(), multicastAddress, multicastPort);

  //start LED port
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);


  //Get Data from EEprom
   EEPROM.get(0, LEDS_PER_GROUP);
        if (confirm_auswahl_wert == 1)
        {
          oled.clear();
          oled.setCursor(0, 0);
          oled.print(pixel_auswahl_wert);
          oled.println(F(" Pixel als Gruppe"));
          oled.println(F("uebernommen!"));
          oled.println(F("Wert in Speicher"));
          oled.print(F("geschrieben"));
          delay(3000);
          oled.clear();
          oled.setCursor(0, 0);
          oled.println(F("Menu wird beendet"));
          oled.print(F("3.."));
          delay(1000);
          oled.print(F("2.."));
          delay(1000);
          oled.print(F("1.."));
          delay(1000);
          oled.clear();
          LEDS_PER_GROUP = pixel_auswahl_wert;
          EEPROM.put(0, LEDS_PER_GROUP);          
          confirm_auswahl_wert = 0;
          menu_taste_wert = 0;
          pixel_auswahl_wert = 0;
          menu_auswahl_wert = 0;
          confirm_state = 0;
          main_program = 1;

Wo sind die Includes?

Gruß Tommy

Tommy56:
Wo sind die Includes?

Gruß Tommy

Die sind da am Anfang des Codes
include Eeprom.h habe ich genommen bzw eingefügt.

Schicke nachher nochmal den Anfang vom Code. Irgendwie doof das ich den kompletten Code nicht posten kann. Bekomme immer die Fehlermeldung das mehr als 9000 Zeichen nicht gehen...

Gruß Dennis

#define FASTLED_ALLOW_INTERRUPTS 0
#include <EEPROM.h>
#include <FastLED.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <Keypad.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"


//wifi connection
#define MY_SSID "artnet_box"
#define MY_PASS "artnettest"
#define LISTEN_PORT 6454
WiFiUDP Udp;

IPAddress multicastAddress(226, 1, 1, 1);
unsigned int multicastPort = 6454;

//local LEDs
int NUM_GROUPS = 170;
int LEDS_PER_GROUP = 6  ;
int NUM_LEDS = NUM_GROUPS * LEDS_PER_GROUP;
#define LED_PIN 3
CRGB leds[2000];




//Keypad setting - Hier wird die größe des Keypads definiert
const byte COLS = 3; //3 Spalten
const byte ROWS = 3; //4 Zeilen
//Die Ziffern/Zeichen:
char hexaKeys[ROWS][COLS] = {
  {'#', '0', '7'},
  {'6', '5', '4'},
  {'3', '2', '1'}
};
byte colPins[COLS] = { D8, D7, D6 }; //Definition der Pins für die 3 Spalten
byte rowPins[ROWS] = { D5, D4, D0 };//Definition der Pins für die 4 Zeilen

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);


//Display Settings

#define I2C_ADDRESS 0x3C
SSD1306AsciiWire oled;


unsigned long displaytime;
int display_state = 1;
int anzahl_digits = 0;
int test_state = 0;
int menu_auswahl_state = 0;
int pixel_auswahl_state = 0;
int confirm_state = 0;
unsigned long confirm_auswahl_wert = 0;
unsigned long menu_taste_wert = 0;
unsigned long pixel_auswahl_wert = 0;
unsigned long menu_auswahl_wert = 0;
int main_program = 0;





void setup()
{
  //cennect to WiFi network
  WiFi.begin(MY_SSID, MY_PASS);
  delay(500);
  // Udp.beginPacketMulticast(LISTEN_PORT);
  //Udp.beginPacketMulticast(ipMulti, portMulti,WiFi.localIP());
  Udp.beginMulticast(WiFi.localIP(), multicastAddress, multicastPort);

  //start LED port
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);


  //Get Data from EEprom
   EEPROM.get(0, LEDS_PER_GROUP);


    //init Display
    Wire.begin();
    Wire.setClock(400000L);
    oled.begin(&Adafruit128x64, I2C_ADDRESS);
    oled.setFont(TimesNewRoman16_bold); // Auswahl der Schriftart
    oled.setCursor(0, 0);
    oled.println (F("Node started"));
    oled.println (F("Pixelgruppierung"));
    oled.println (F(""));
    oled.print (LEDS_PER_GROUP);
    oled.print (F(" Pixel"));
    delay(3000);
    oled.clear();

    main_program = 1;

}

void loop()
{
  if (main_program == 1)

  {

    unsigned int menu_taste = customKeypad.getKey();
    if (menu_taste) {
      menu_taste_wert = menu_taste_wert * 10 + (menu_taste - 48) ;
      Serial.println(menu_taste_wert);
      if (menu_taste_wert == 1 || menu_taste_wert > 9)
      {
        menu_taste_wert = 0;
        test_state = 1;
        main_program = 0;
      }

      else

      {
        menu_taste_wert = 0;
      }

    }
  }


  if (test_state == 1)

  {
    oled.setCursor(0, 0);
    oled.println(F("Hauptmenu"));
    oled.println(F("1 = Pixelgruppierung"));
    oled.println(F("2 = IP/Mac Addr."));
    oled.print(F("#/* = Verlassen"));
    menu_auswahl_state = 1;
    test_state = 0;
  }


  if (menu_auswahl_state == 1)

  {
    unsigned int menu_auswahl = customKeypad.getKey();
    if (menu_auswahl) {
      menu_auswahl_wert = menu_auswahl_wert * 10 + (menu_auswahl - 48) ;
      Serial.println(menu_auswahl_wert);
      if (menu_auswahl_wert > 9 || menu_auswahl_wert == 1 || menu_auswahl_wert == 2)

      {

        if (menu_auswahl_wert == 1 || menu_auswahl_wert == 2)

        {
          if (menu_auswahl_wert == 1)

          {
            oled.clear();
            oled.setCursor(0, 0);
            oled.println(F("Pixelgruppierung"));
            oled.println(F("Bitte Anzahl Pixel"));
            oled.println(F("eingeben"));
            oled.print(F("Max. Anzahl 172!"));
            delay(3000);
            oled.clear();
            pixel_auswahl_state = 1;
            menu_auswahl_wert = 0;
            menu_auswahl_state = 0;

          }

          else

          {
            oled.clear();
            oled.setCursor(0, 0);
            oled.println(F("IP Address:"));
            oled.println(WiFi.localIP());
            oled.println(F("MAC Address:"));
            oled.print(WiFi.macAddress());
            oled.setCursor(110, 0);
            oled.print(F("10"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  9"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  8"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  7"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  6"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  5"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  4"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  3"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  2"));
            delay(1000);
            oled.setCursor(110, 0);
            oled.print(F("  1"));
            delay(1000);
            // delay(6000);
            oled.clear();
            menu_auswahl_wert = 0;
            menu_auswahl_state = 0;
            main_program = 1;
          }
        }

Teil 1

 else
        {
          oled.clear();
          oled.setCursor(0, 1);
          oled.println(F("Menu verlassen!"));
          oled.println(F("LED Gruppierung:"));
          oled.print(LEDS_PER_GROUP);
          oled.print(F(" Pixels"));
          delay(3000);
          oled.clear();
          menu_auswahl_wert = 0;
          menu_auswahl_state = 0;
          main_program = 1;

        }
      }

      else

      {
        oled.clear();
        oled.setCursor(0, 1);
        oled.println(F("Ungueltige"));
        oled.println(F("Eingabe!!!"));
        delay(3000);
        oled.clear();
        menu_auswahl_wert = 0;
        test_state = 1;

      }


    }



  }


  if (pixel_auswahl_state == 1)

  { oled.setCursor(0, 0);
    oled.println(F("Amount Pixel:"));
    //oled.println("");

    if (anzahl_digits + 1 == 1)
    {
      oled.setCursor(0, 4);
      oled.println("x--");
      oled.print("100er stelle");
    }

    else

    {
      if (anzahl_digits + 1 == 2)
      {
        oled.setCursor(0, 4);
        oled.println("-x-");
        oled.print("   10er stelle");
      }

      else
      {
        oled.setCursor(0, 4);
        oled.println("--x");
        oled.print("     1er stelle");

      }
    }




    unsigned int pixel_auswahl = customKeypad.getKey();
    if (anzahl_digits < 3) {
      if (pixel_auswahl) {
        pixel_auswahl_wert = pixel_auswahl_wert * 10 + (pixel_auswahl - 48) ;

        Serial.println(pixel_auswahl_wert);
        oled.setCursor(0, 2);
        oled.println(pixel_auswahl_wert);
        anzahl_digits ++;

        if (anzahl_digits == 3)
        {
          if (pixel_auswahl_wert <= 170)
          {
            oled.clear();
            oled.setCursor(0, 0);
            oled.print(pixel_auswahl_wert);
            oled.println(F(" Pixel als Gruppe"));
            oled.println(F("uebernehmen?"));
            oled.println(F("1=JA | 2=Nein"));
            confirm_state = 1;
            anzahl_digits = 0;
            pixel_auswahl_state = 0;
          }

          else
          {
            oled.clear();
            oled.setCursor(0, 0);
            oled.print(pixel_auswahl_wert);
            oled.println(F(" ungueltig!"));
            oled.println(F("Wert muss <170 sein!"));
            oled.print(F("Wert erneut eingeben!"));
            delay(3000);
            oled.clear();
            anzahl_digits = 0;
            pixel_auswahl_wert = 0;
          }
        }


      }
    }
  }
  if (confirm_state == 1)

  {

    unsigned int confirm_auswahl = customKeypad.getKey();
    if (confirm_auswahl) {
      confirm_auswahl_wert = confirm_auswahl_wert * 10 + (confirm_auswahl - 48) ;
      Serial.print("confirm asuwahl ");
      Serial.println(confirm_auswahl_wert);

      if (confirm_auswahl_wert == 1 || confirm_auswahl_wert == 2)
      {

        if (confirm_auswahl_wert == 1)
        {
          oled.clear();
          oled.setCursor(0, 0);
          oled.print(pixel_auswahl_wert);
          oled.println(F(" Pixel als Gruppe"));
          oled.println(F("uebernommen!"));
          oled.println(F("Wert in Speicher"));
          oled.print(F("geschrieben"));
          delay(3000);
          oled.clear();
          oled.setCursor(0, 0);
          oled.println(F("Menu wird beendet"));
          oled.print(F("3.."));
          delay(1000);
          oled.print(F("2.."));
          delay(1000);
          oled.print(F("1.."));
          delay(1000);
          oled.clear();
          LEDS_PER_GROUP = pixel_auswahl_wert;
          EEPROM.put(0, LEDS_PER_GROUP);          
          confirm_auswahl_wert = 0;
          menu_taste_wert = 0;
          pixel_auswahl_wert = 0;
          menu_auswahl_wert = 0;
          confirm_state = 0;
          main_program = 1;

        }

        else

        {
          oled.clear();
          oled.setCursor(0, 0);
          oled.print(pixel_auswahl_wert);
          oled.println(F(" Pixel als Gruppe"));
          oled.println(F("abgelehnt!"));
          oled.println(F("Menu wird beendet"));
          oled.print(F("3.."));
          delay(1000);
          oled.print(F("2.."));
          delay(1000);
          oled.print(F("1.."));
          delay(1000);
          oled.clear();
          confirm_auswahl_wert = 0;
          menu_taste_wert = 0;
          pixel_auswahl_wert = 0;
          menu_auswahl_wert = 0;
          confirm_state = 0;
          main_program = 1;
        }
      }

      else
      {
        oled.clear();
        oled.setCursor(0, 1);
        oled.println(F("Ungueltige"));
        oled.println(F("Eingabe!!!"));
        delay(3000);
        oled.clear();
        oled.setCursor(0, 0);
        oled.print(pixel_auswahl_wert);
        oled.println(F(" Pixel als Gruppe"));
        oled.println(F("uebernehmen?"));
        oled.println(F("1=JA | 2=Nein"));
        confirm_auswahl_wert = 0;


      }

    }
  }



  //get Art-Net
  RecieveUdp();

  //wait a spell
  delay(1);
}




//process incoming UDP message
void RecieveUdp()
{
  byte packet[18 + (NUM_GROUPS * 3)];

  //test if a packet has been recieved
  if (Udp.parsePacket() > 0)
  {
    //read-in packet and get length
    int len = Udp.read(packet, 18 + (NUM_GROUPS * 3));

    //discard unread bytes
    Udp.flush();

    //test for empty packet
    if (len < 1)
      return;

    //test for Art-Net DMX packet
    //(packet[14] & packet[15] are the low and high bytes for universe)
    if (packet[9] == 0x50)
    {
      int dmx = 18;

      //copy dmx data to leds
      for (int n = 0; n < NUM_GROUPS; n++) {
        int dmx1 = dmx++;
        int dmx2 = dmx++;
        int dmx3 = dmx++;
        for (int m = n * LEDS_PER_GROUP; m < n * LEDS_PER_GROUP + LEDS_PER_GROUP; m++) {
          leds[m] = CRGB(packet[dmx1], packet[dmx2], packet[dmx3]);
        }

      }


      //push led data
      FastLED.show();
    }
  }
}

Teil 2

Sorry, dass ich erst so spät antworte, ich war unterwegs.

Der ESP8266 hat keinen echten EEPROM. Dieser wird bei ihm im Flash emuliert.
Deshalb muss ins setup noch EEPROM.begin(size); mit rein, bevor eine Nutzung erfolgen kann.
Infos hier, dort wird auch auf Beispiele verlinkt.

Gruß Tommy

Wo ist das EEPROM.commit() oder EEPROM.end() ?