Arduino Neopixel Problem

Hallo liebe Communtiy!

Vielleicht könnt ihr mir helfen, da ich mittlerweile anstehe.
Folgendes Problem:

Ich bin gerade dabei mit dem Arduino Uno + Ethenet Shield einen Art-Net Node zu bauen um so über Ethernet (300 Stück)) WS2812 Neopixel ansteuern zu können.
Dabei gibt es bereits einige Tutorials und einen Code, um dies zu realisieren (angepasster Code /*This example will receive multiple universes via Artnet and control a strip - Pastebin.com). Das Programm funktioniert super bis zu einer Anzahl Leds von 157. Darüber wird der Led Test nicht mehr ausgeführt und somit funktioniert nichts. Programmspeicher sind noch 30% (600kB) übrig. Denke aber trotzdem, dass es möglicherweise mit einem Überlauf zu tun hat...ich würde darauf tippen einen stärkeren Arduino zu benötigen, jedoch funktioniert genau dieses Programm bei vielen anderen, die es probiert haben (zB jene die die Tutorials geschrieben haben)

Vielen Dank für eure Hilfe!!

Setze Deinen Code bitte direkt ins Forum. Benutze dazu Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).
Das kannst Du auch noch nachträglich ändern.

300 LED * 3 * 20 mA = 18 A

Bringt das Dein Netzteil? Speist Du 5V und GND mehrfach im Stripe über genügend dicke Leitungen ein?

Gruß Tommy

valentin8809:
.....
Ich würde darauf tippen einen stärkeren Arduino zu benötigen, jedoch funktioniert genau dieses Programm bei vielen anderen, die es probiert haben (zB jene die die Tutorials geschrieben haben)

Vielen Dank für eure Hilfe!!

Und die verwenden auch die von dir eingesetzte Hardware ?
Ich tippe mal auf ein Problem mit deiner verwendeten Hardware.

"Anzahl Neopixel und Ethernet-Shield".

Hier mal der Code:

/*
This example will receive multiple universes via Artnet and control a strip of ws2811 leds via
Adafruit's NeoPixel library: https://github.com/adafruit/Adafruit_NeoPixel
This example may be copied under the terms of the MIT license, see the LICENSE file for details
*/

#include <Artnet.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>

// Neopixel settings
const int numLeds = 160; // change for your setup
const int channelsPerLed = 2;
const int numberOfChannels = numLeds * channelsPerLed; // Total number of channels you want to receive (1 led = 3 channels)
const byte dataPin = 2;
Adafruit_NeoPixel leds = Adafruit_NeoPixel(numLeds, dataPin, NEO_GRB + NEO_KHZ800);

// Artnet settings
Artnet artnet;
const int startUniverse = 0; // CHANGE FOR YOUR SETUP most software this is 1, some software send out artnet first universe as 0.

// Check if we got all universes
const int maxUniverses = numberOfChannels / 512 + ((numberOfChannels % 512) ? 1 : 0);
bool universesReceived[maxUniverses];
bool sendFrame = 1;
int previousDataLength = 0;

// Change ip and mac address for your setup
byte ip[] = {10, 10, 12, 199};
byte mac[] = {0x04, 0xE9, 0xE5, 0x00, 0x69, 0xEC};
byte broadcast[] = {255, 255, 255, 255};
void setup()
{
 //Serial.begin(115200);
 artnet.begin(mac, ip);
 leds.begin();
 artnet.setBroadcast(broadcast);
 initTest();

 // this will be called for each packet received
 artnet.setArtDmxCallback(onDmxFrame);
}

void loop()
{
 // we call the read function inside the loop
 artnet.read();
}

void onDmxFrame(uint16_t universe, uint16_t length, uint8_t sequence, uint8_t* data, IPAddress remoteIP)
{
 sendFrame = 1;
 // set brightness of the whole strip
 if (universe == 15)
 {
   leds.setBrightness(data[0]);
   leds.show();
 }

 // Store which universe has got in
 if ((universe - startUniverse) < maxUniverses)
   universesReceived[universe - startUniverse] = 1;

 for (int i = 0 ; i < maxUniverses ; i++)
 {
   if (universesReceived[i] == 0)
   {
     //Serial.println("Broke");
     sendFrame = 0;
     break;
   }
 }

 // read universe and put into the right part of the display buffer
 for (int i = 0; i < length / channelsPerLed; i++)
 {
   int led = i + (universe - startUniverse) * (previousDataLength / channelsPerLed);
   if (led < numLeds) {
     if (channelsPerLed == 4)
       leds.setPixelColor(led, data[i * channelsPerLed], data[i * channelsPerLed + 1], data[i * channelsPerLed + 2], data[i * channelsPerLed + 3]);
     if (channelsPerLed == 3)
       leds.setPixelColor(led, data[i * channelsPerLed], data[i * channelsPerLed + 1], data[i * channelsPerLed + 2]);
   }
 }
 previousDataLength = length;

 if (sendFrame)
 {
   leds.show();
   // Reset universeReceived to 0
   memset(universesReceived, 0, maxUniverses);
 }
}

void initTest()
{
 for (int i = 0 ; i < numLeds ; i++)
   leds.setPixelColor(i, 127, 0, 0);
 leds.show();
 delay(500);
 for (int i = 0 ; i < numLeds ; i++)
   leds.setPixelColor(i, 0, 127, 0);
 leds.show();
 delay(500);
 for (int i = 0 ; i < numLeds ; i++)
   leds.setPixelColor(i, 0, 0, 127);
 leds.show();
 delay(500);
 for (int i = 0 ; i < numLeds ; i++)
   leds.setPixelColor(i, 0, 0, 0);
 leds.show();
}

Die Stromversorgung passt mit Sicherheit, da ich ein 20A Netzteil verwende. Grundsätzlich funktioniert die Ansteuerung wunderbar, da die Beispielprogramme für die Neopixel kein Problem damit haben alle 300 LEDs anzusteuern. Ist es möglich die Auslastung des Arduinos auszulesen?

Programmspeicher sind noch 30% (600kB)

Das kann kein Arduino UNO sein. der hat nur 32k Flash.

ich tippe mal, daß Ethernet und 157 LED das gesamte RAM aufgebraucht haben.

Grüße Uwe

Hallo,

Doch ist definitiv ein Uno - sorry das K vor dem Byte ist mir ausgekommen.
Im Anhang habe ich nun einen Screenshot des “Hochladen” Fensters angehängt.

Ist es also möglich, dass der Rechner im Betrieb dann doch mehr Speicher benötigt als beim Hochladen berechnet und somit der Arduino überfordert ist?

Vielen Dank euch!

Woher ist dein Muster/Link auf das Tutorial im Internet?

ungetestet:

schau mal ganz genau auf deine ganzen int Definitionen, ob hier wirkich
a) ein (unsigned) int benötigt wird
b) du vieleicht mit einem byte oder uint8_t besser bedient wärst

und damit meine ich in erster Linie Variablen, die nicht const sind. Auch in den for Schleifen

Ist es also möglich, dass der Rechner im Betrieb dann doch mehr Speicher benötigt als beim Hochladen berechnet und somit der Arduino überfordert ist?

Ja, ist so. Der Compiler berechnet den RAMverbrauch für Variablen aber andere RAMerfordernisse kann er nicht berechnen.
Gibt einige Zeilen Code mit denen man den aktuellen RAM Verbrauch während des Ausführens des Sketch sich ausgeben lassen kann.
Grüße Uwe

Hi

300 Pixel a 3 Byte (R+G+B) = 900 Byte, Die der Kompiler beim Übersetzen NICHT in Seiner Rechnung drin hat.
Das deckt sich auch halbwegs mit Deinen 157 Pixeln, wo Das noch klappt - 471 Byte (wenn ich korrekt gerechnet habe) von 600, bleiben 128 Byte als Stack über - benutzt Du Strings? (großes S)

300 NeoPixel am sonst leeren Uno funktionieren - man muß halt bei dem 'Frei' immer bedenken, daß beim Start intern der RAM für die Pixel noch abgegriffen wird - 900 Byte mehr futsch.

MfG

Servus

Ich habe nun die Variablen durch “short” ersetzt - sollte ausreichend sein. Jedoch hat sich die Angabe bei dem Speicherverbrauch nicht um nur 1Byte geändert. Möglicherweise verstecken sich die Strings in den Librarys…

/*
This example will receive multiple universes via Artnet and control a strip of ws2811 leds via
Adafruit's NeoPixel library: https://github.com/adafruit/Adafruit_NeoPixel
This example may be copied under the terms of the MIT license, see the LICENSE file for details
*/

#include <Artnet.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>


// Neopixel settings
const short numLeds = 157; // change for your setup
const byte channelsPerLed = 3;
const short numberOfChannels = numLeds * channelsPerLed; // Total number of channels you want to receive (1 led = 3 channels)
const byte dataPin = 2;
Adafruit_NeoPixel leds = Adafruit_NeoPixel(numLeds, dataPin, NEO_GRB + NEO_KHZ800);

// Artnet settings
Artnet artnet;
const byte startUniverse = 0; // CHANGE FOR YOUR SETUP most software this is 1, some software send out artnet first universe as 0.

// Check if we got all universes
const short maxUniverses = numberOfChannels / 512 + ((numberOfChannels % 512) ? 1 : 0);
bool universesReceived[maxUniverses];
bool sendFrame = 1;
short previousDataLength = 0;

// Change ip and mac address for your setup
byte ip[] = {10, 10, 12, 199};
byte mac[] = {0x04, 0xE9, 0xE5, 0x00, 0x69, 0xEC};
byte broadcast[] = {255, 255, 255, 255};
void setup()
{
  //Serial.begin(115200);
  artnet.begin(mac, ip);
  leds.begin();
  artnet.setBroadcast(broadcast);
  initTest();

  // this will be called for each packet received
  artnet.setArtDmxCallback(onDmxFrame);
}

void loop()
{
  // we call the read function inside the loop
  artnet.read();
}

void onDmxFrame(uint16_t universe, uint16_t length, uint8_t sequence, uint8_t* data, IPAddress remoteIP)
{
  sendFrame = 1;
  // set brightness of the whole strip
  if (universe == 15)
  {
    leds.setBrightness(data[0]);
    leds.show();
  }

  // Store which universe has got in
  if ((universe - startUniverse) < maxUniverses)
    universesReceived[universe - startUniverse] = 1;

  for (short i = 0 ; i < maxUniverses ; i++)
  {
    if (universesReceived[i] == 0)
    {
      //Serial.println("Broke");
      sendFrame = 0;
      break;
    }
  }

  // read universe and put into the right part of the display buffer
  for (  short i = 0; i < length / channelsPerLed; i++)
  {
    short led = i + (universe - startUniverse) * (previousDataLength / channelsPerLed);
    if (led < numLeds) {
      if (channelsPerLed == 4)
        leds.setPixelColor(led, data[i * channelsPerLed], data[i * channelsPerLed + 1], data[i * channelsPerLed + 2], data[i * channelsPerLed + 3]);
      if (channelsPerLed == 3)
        leds.setPixelColor(led, data[i * channelsPerLed], data[i * channelsPerLed + 1], data[i * channelsPerLed + 2]);
    }
  }
  previousDataLength = length;

  if (sendFrame)
  {
    leds.show();
    // Reset universeReceived to 0
    memset(universesReceived, 0, maxUniverses);
  }
}



void initTest()
{
  for (short i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 127, 0, 0);
  leds.show();
  delay(500);
  for (short i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 0, 127, 0);
  leds.show();
  delay(500);
  for (short i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 0, 0, 127);
  leds.show();
  delay(500);
  for (short i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 0, 0, 0);
  leds.show();
}

(Originalcode von https://github.com/natcl/Artnet/blob/master/examples/NeoPixel/ArtnetNeoPixel/ArtnetNeoPixel.ino)

Danke für die Veranschaulichung der Berechnung des RAMs - sehr aufschlussreich…theoretisch jedoch müsste dies durch reduzieren des Speicherverbrauchs gut zum Austesten sein , sodass durch Einsparungen zumindest 158 Pixel betrieben werden können. Oder wo würde es möglich sein den Speicherverbrauch auszulesen (habe online keine Lösung gefunden)?

ps. habe schon mal einen Arduino Mega bestellt, jedoch würde trotzdem gerne verstehen, warum dieses Phänomen genau bei dieser Zahl auftritt und es gibt eben Tutorials, die mit einem Uno und dem gleichen Code mehr LEDs schaffen (z.B. Controlling a WS2812 led matrix over ethernet using Arduino - Mega-Byte blog).

Grüße

valentin8809:
Servus

Ich habe nun die Variablen durch “short” ersetzt - sollte ausreichend sein. Jedoch hat sich die Angabe bei dem Speicherverbrauch nicht um nur 1Byte geändert.

das ist klar,

https://www.arduino.cc/reference/en/language/variables/data-types/short/
das ist wieder eine 2-Byte Variable.

Warum hast du nicht byte - Arduino Reference
oder uint8_t wie oben geschrieben versucht?

bei mir kompiliert das wie folgt

Der Sketch verwendet 12500 Bytes (38%) des Programmspeicherplatzes. Das Maximum sind 32256 Bytes.
Globale Variablen verwenden 1396 Bytes (68%) des dynamischen Speichers, 652 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.

Paar Bytes RAM könnte man noch in der Artnet.cpp rausholen, aber ob es wirklich daran liegt glaube ich schön langsam nicht mehr.

Was heißt "Darüber wird der Led Test nicht mehr ausgeführt und somit funktioniert nichts. "
Funktioniert nicht ist keine Fehlerbeschreibung.

Hab mal ein paar Serial-Ausgaben ergänzt:

/*
  This example will receive multiple universes via Artnet and control a strip of ws2811 leds via
  Adafruit's NeoPixel library: https://github.com/adafruit/Adafruit_NeoPixel
  This example may be copied under the terms of the MIT license, see the LICENSE file for details
*/

#include <Artnet.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>

// Neopixel settings
const byte numLeds = 160; // change for your setup
const byte channelsPerLed = 3;
const uint16_t numberOfChannels = numLeds * channelsPerLed; // Total number of channels you want to receive (1 led = 3 channels)
const byte dataPin = 2;
Adafruit_NeoPixel leds = Adafruit_NeoPixel(numLeds, dataPin, NEO_GRB + NEO_KHZ800);

// Artnet settings
Artnet artnet;
const int startUniverse = 0; // CHANGE FOR YOUR SETUP most software this is 1, some software send out artnet first universe as 0.

// Check if we got all universes
const byte maxUniverses = numberOfChannels / 512 + ((numberOfChannels % 512) ? 1 : 0);  // noiasca: bei 160*3 = 480 kommt man wohl mit einem Universum aus, ergo byte
bool universesReceived[maxUniverses];
bool sendFrame = 1;
int previousDataLength = 0;  // noiasca:Missing to be checked

// Change ip and mac address for your setup
byte ip[] = {10, 0, 1, 199};
byte mac[] = {0x04, 0xE9, 0xE5, 0x00, 0x69, 0xEC};
byte broadcast[] = {10, 0, 1, 255};
void setup()
{
  Serial.begin(115200);
  artnet.begin(mac, ip);
  Serial.println(F("D38"));
  leds.begin();
  Serial.println(F("D40"));
  artnet.setBroadcast(broadcast);
  Serial.println(F("D42"));
  initTest();
  Serial.println(F("D44"));
  // this will be called for each packet received
  artnet.setArtDmxCallback(onDmxFrame);
  Serial.println(F("D47"));
}

void loop()
{
  // we call the read function inside the loop
  artnet.read();
  
}

void onDmxFrame(uint16_t universe, uint16_t length, uint8_t sequence, uint8_t* data, IPAddress remoteIP)
{
  sendFrame = 1;
  // set brightness of the whole strip
  if (universe == 15)
  {
    leds.setBrightness(data[0]);
    leds.show();
  }

  // Store which universe has got in
  if ((universe - startUniverse) < maxUniverses)
    universesReceived[universe - startUniverse] = 1;

  for (byte i = 0 ; i < maxUniverses ; i++)
  {
    if (universesReceived[i] == 0)
    {
      //Serial.println("Broke");
      sendFrame = 0;
      break;
    }
  }

  // read universe and put into the right part of the display buffer
  for (uint16_t i = 0; i < length / channelsPerLed; i++)
  {
    byte led = i + (universe - startUniverse) * (previousDataLength / channelsPerLed);
    if (led < numLeds) {
      if (channelsPerLed == 4)
        leds.setPixelColor(led, data[i * channelsPerLed], data[i * channelsPerLed + 1], data[i * channelsPerLed + 2], data[i * channelsPerLed + 3]);
      if (channelsPerLed == 3)
        leds.setPixelColor(led, data[i * channelsPerLed], data[i * channelsPerLed + 1], data[i * channelsPerLed + 2]);
    }
  }
  previousDataLength = length;

  if (sendFrame)
  {
    leds.show();
    // Reset universeReceived to 0
    memset(universesReceived, 0, maxUniverses);
  }
}

void initTest()
{
  for (byte i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 127, 0, 0);
  leds.show();
  delay(500);
  for (byte i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 0, 127, 0);
  leds.show();
  delay(500);
  for (byte i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 0, 0, 127);
  leds.show();
  delay(500);
  for (byte i = 0 ; i < numLeds ; i++)
    leds.setPixelColor(i, 0, 0, 0);
  leds.show();
}

das läuft bei mir durch bis ans Ende vom Setup (D47) und ist dann im Loop.

Stimmt, theoretisch läuft das Programm einwandfrei - deswegen ist es mir noch unverständlicher warum es praktisch nicht läuft. Ich meinte mit "funktionieren", dass bis 157 der initTest() auch tatsächlich ausgeführt wird
-> die LEDs leuchten 3x mal auf und der Arduino empfängt Daten (laut LEDs am Ethernet Shield).

Ab 158 leuchten keine Leds durch den initTest auf - Daten werden aber (wieder laut Ethernet Shield) empfangen, jedoch nicht an die LEDs ausgegeben.

Was ich komisch finde, ist dass bei mir die Byte Anzahl unverändert bleibt - unabhängig vom verwendeten Datentyp

Mit nun deinem Code kompiliert:

Der Sketch verwendet 14106 Bytes (43%) des Programmspeicherplatzes. Das Maximum sind 32256 Bytes.
Globale Variablen verwenden 1434 Bytes (70%) des dynamischen Speichers, 614 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.

Schreibe ich die Variablen auf "long" um, so hat sich der Speicherbedarf um 2Byte erhöht - müsste doch mehr sein, da es mehr als zwei veränderte Variablen sind.
Bei meinem anderen Rechner kommen die gleichen Werte raus - also versteh nicht ganz wie dein Rechner auf weniger verbrauchten Speicher kommen kann.

Mal sehen ob der Mega das Problem lösen kann...denn nachvollziehen kann ich das Problem hier nicht mehr

aha, der Sketch läuft also.

gib die Serial. wieder raus und ergänze mal am Ende vom Loop

 leds.setPixelColor(156, 50, 50, 50);
 leds.setPixelColor(157, 50, 0, 0);
 leds.setPixelColor(158, 0, 50, 0);
 leds.setPixelColor(159, 0, 0, 50);

delay(4000); 
 leds.setPixelColor(156, 0, 0, 0);
 leds.setPixelColor(157, 0, 0, 0);
 leds.setPixelColor(158, 0, 0, 0);
 leds.setPixelColor(159, 0, 0, 0);

delay(4000);

Was passiert bei den letzten 4 LEDs im Direktaufruf? Beschreibe jede der 4 LEDs

Das habe ich nun probiert:

fügt man den Code im Loop hinzu, so funktioniert dies weiterhin nur bis zu 157 LEDs. Klar - denn vorerst muss der LedStripe initialisiert werden und dort darf keine höhere Zahl eingegeben werden. Im Code unten wird die Länge des Stripes festgelegt.

Adafruit_NeoPixel pixels(numLeds, PIN, NEO_GRB + NEO_KHZ800);

jedoch treten durch die Eingabe im Loop eigenartige Fehler auf → auch nicht angesprochene LEDS im Bereich (150-156) leuchten in zufälligen Farben.

Ich habe nun das Programm von Null weg aufgebaut um die Zeile zu finden wo der Fehler liegt.Bis ich draufgekommen bin, dass der Fehler in der Artnet library liegen dürfte. Denn bei folgendem Code funktionieren alle Leds (Librarys sind alle im Programm und die LEDs werden erfolgreich angesteuert):

#include <Artnet.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>


const byte PIN  =      2 ;
const short numLeds = 300; // Popular NeoPixel ring size
const byte channelsPerLed = 3;
const short numberOfChannels = numLeds * channelsPerLed;
Adafruit_NeoPixel pixels(numLeds, PIN, NEO_GRB + NEO_KHZ800);




void setup() {

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

void loop() {
  pixels.clear(); // Set all pixel colors to 'off'

    pixels.setPixelColor(150, pixels.Color(0, 150, 0));
    pixels.show();   
    delay(300);
    pixels.setPixelColor(150,pixels.Color(0,0,150));
    pixels.show();
    delay(300);
    
  }

Also gehe ich einen Schritt weiter und füge zum Code “Artnet artnet;” hinzu

Dann tritt das Phänomen wieder auf → jedoch werden die LEDs bis zu einer Zahl von einschließlich 211 angesteuert.

#include <Artnet.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>


const byte PIN  =      2 ;
const short numLeds = 212; 
const byte channelsPerLed = 3;
const short numberOfChannels = numLeds * channelsPerLed;
Adafruit_NeoPixel pixels(numLeds, PIN, NEO_GRB + NEO_KHZ800);

Artnet artnet;


void setup() {

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

void loop() {
  pixels.clear(); // Set all pixel colors to 'off'

  
    pixels.setPixelColor(150, pixels.Color(0, 150, 0));
    pixels.show();   
    delay(300);
    pixels.setPixelColor(150,pixels.Color(0,0,150));
    pixels.show();
    delay(300);
  }

Geht man nun wieder einen Schritt weiter, und definiert die Variablen und fügt im Setup auch “artnet.beginn(mac, ip);” ,so geht die Zahl, bei der die LEDs funktionieren auf 202 herunter.

#include <Artnet.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>


const byte PIN  =      2 ;
const short numLeds = 202; 
const byte channelsPerLed = 3;
const short numberOfChannels = numLeds * channelsPerLed;
Adafruit_NeoPixel pixels(numLeds, PIN, NEO_GRB + NEO_KHZ800);

Artnet artnet;
const int startUniverse = 0;
const int maxUniverses = numberOfChannels / 512 + ((numberOfChannels % 512) ? 1 : 0);
bool universesReceived[maxUniverses];
bool sendFrame = 1;
int previousDataLength = 0;

// Change ip and mac address for your setup
byte ip[] = {10, 0, 1, 199};
byte mac[] = {0x04, 0xE9, 0xE5, 0x00, 0x69, 0xEC};
byte broadcast[] = {10, 0, 1, 255};

void setup() {
  artnet.begin(mac, ip);
  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
}

void loop() {
  pixels.clear(); // Set all pixel colors to 'off'

  
    pixels.setPixelColor(150, pixels.Color(0, 150, 0));
    pixels.show();   
    delay(300);
    pixels.setPixelColor(150,pixels.Color(0,0,150));
    pixels.show();
    delay(300);
  }

Also liegt das Problem direkt in der Artnet Library denke ich. Ich habe mir diese angesehen, jedoch bin ich nicht in der Lage (mangels Kenntnissen) dort ein Problem zu finden.
Ich habe diese im Anhang beigefügt, vielleicht kannst du etwas finden…

Ps. Vielen Dank für deine Hilfe - bin echt dankbar!!!

Artnet.cpp (5.77 KB)

Artnet.h (4.03 KB)

Die Bibiothek braucht für ihre funktion RAM.
Ohne Artnet.h und die anderen Ethernet Bibliotheken hast Du einfach mehr RAM und kannst darum das Datenarray für die NEOPIXEL größer haben.
Grüße Uwe

Alles klar, dann fahr ich wohl am Besten, wenn ich ein stärkeres Bord verwende.
Dies sollte ich morgen bekommen und ich sag bescheid ob dies die Lösung war.

Grüße

Artnet.cpp:

Suche nach Fixtexten der Serial Ausgabe, und verwende so oft wie möglich das F-Makro.

Z.B.:

  Serial.print(F("packet size = "));
  Serial.print(packetSize);
  Serial.print(F("\topcode = "));
  Serial.print(opcode, HEX);
  Serial.print(F("\tuniverse number = "));

paar Bytes müsstest da schon rausholen können. Sind mind. 8 Zeilen :wink:
Dann im eigenen Sketch die ganzen Serial.prints entfernen, vieleicht klappen dann deine drei letzten LEDs .

Geschafft!

Es liegt also tatsächlich am RAM. Einerseits gut, da das Problem nun behoben ist, andererseits hätte ich da auch früher draufkommen können :smiley:

Kurz zur Info: Es werden 1435 Bytes RAM im compiler angezeigt + die Anzahl an LEDs (157*3 Bytes) = 1906 Bytes...der restliche Speicher (142 Bytes )dürfte wohl für andere Variablen benötigt werden...

Mit dem MEGA Board ist es nun möglich bis zu 2189 LEDs anzusteuern - also bei weitem ausreichend für mich

Danke euch nochmal!

Hatte Dich schon jemand auf die Möglichkeit hingewiesen, das freie RAM berechnen zu lassen? Das macht eine Funktion, die Du an geeigneter Stelle in loop abfragen kannst:

// Quelle: http://jeelabs.org/2011/05/22/atmega-memory-use/
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

Das habe ich dann gemacht und er geht soweit, dass er bei 157 30Bytes frei hat...was mit dem freien Speicher passiert weis ich nicht - vielleicht reserviert er diese!?