Go Down

Topic: Arduino Neopixel Problem  (Read 351 times) previous topic - next topic

valentin8809

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 https://pastebin.com/XKtGAWmx). 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!!

Tommy56

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
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

HotSystems

.....
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".

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

valentin8809

#3
Apr 23, 2019, 03:00 pm Last Edit: Apr 23, 2019, 03:04 pm by valentin8809
Hier mal der Code:

Code: [Select]
/*
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?


uwefed

Quote
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

valentin8809

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!

noiasca

#6
Apr 23, 2019, 04:51 pm Last Edit: Apr 23, 2019, 04:54 pm by noiasca
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

DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

uwefed

#7
Apr 23, 2019, 05:35 pm Last Edit: Apr 23, 2019, 05:36 pm by uwefed
Quote
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

postmaster-ino

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
anscheinend ist Es nicht erwünscht, einen Foren-internen Link als 'Homepage' einzubinden, damit JEDER nur einen Klick von combie's Liste zum Thema State-Maschine entfernt ist.
... dann eben nicht ...

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. Möglicherweise verstecken sich die Strings in den Librarys...


Code: [Select]
/*
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. https://mega-byte.nl/controlling-ws2812-led-matrix-ethernet-using-arduino/?unapproved=304&moderation-hash=727e76611c6ee26551e9f82f1fe3a5ba#comment-304).

Grüße

noiasca

#10
Apr 24, 2019, 12:03 am Last Edit: Apr 24, 2019, 01:08 am by noiasca
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 https://www.arduino.cc/reference/en/language/variables/data-types/byte/
oder uint8_t wie oben geschrieben versucht?

bei mir kompiliert das wie folgt
Code: [Select]

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:

Code: [Select]

/*
  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.
DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

valentin8809

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:

Code: [Select]
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


noiasca

aha, der Sketch läuft also.

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

Code: [Select]


 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

DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

valentin8809

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.
Code: [Select]
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):

Code: [Select]
#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.

Code: [Select]
#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.

Code: [Select]
#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!!!

uwefed

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

Go Up