Arduino (Nano), SerialDMX, Begrenzing te lezen DMX kanalen.

[Verwijderd]

Hallo allemaal !

Hopelijk vind ik hier wat hulp voor mijn projectje.Ik heb meerdere Arduino Nano's die ik ws2812 led-strips (per Arduino 3) laat aansturen. De Arduino's gebruiken SeriaDMX (https://github.com/mathertel/DMXSerial) voor het uitlezen van een DMX signaal op de serial poort. Zo gebruik ik bijvoorbeeld kanaal 1t/m12 voor Arduino 1, en kanaal 20t/m32 voor Arduino 2 etc. Ik loop helaas tegen wat problemen aan... zo storen de Arduino's behoorlijk als ik de kanalen zoals net beschreven gebruik; kanaal 100t/m112 voor Arduino 2 geeft veel minder problemen. Het zorgt er in ieder geval voor dat ik concreet de volgende vraag heb:

- ik zou graag de uit te lezen kanalen per Arduino begrenzen... het lukt me wel een 'bovengrens' te bepalen maar echt 'afschermen' van kanaal 20t/m 32 lukt me niet. Kan iemand me hierbij helpen ?

Bij aan Arduino die kanaal 500 t/m 512 uitleest ontstaan al helemaal problemen overigens... ik kan niet helemaal beredeneren waarom helaas.

Alvast heel erg bedankt voor het meedenken

Groetjes, Martijn

-----------------------------------------------------------

#include <Adafruit_NeoPixel.h>
#include "WS2812_Definitions.h"
#include "DMXSerial.h"

//----------------------------------------------------------------------------------------------------------------------------------------------


// Pattern types supported:
enum pattern { NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE };
// Patern directions supported:
enum direction { FORWARD, REVERSE };

// NeoPattern Class - derived from the Adafruit_NeoPixel class
class NeoPatterns : public Adafruit_NeoPixel
{
public:

// Member Variables:
pattern ActivePattern; // which pattern is running
direction Direction; // direction to run the pattern

unsigned long Interval; // milliseconds between updates
unsigned long lastUpdate; // last update of position

uint32_t Color1, Color2; // What colors are in use
uint16_t TotalSteps; // total number of steps in the pattern
uint16_t Index; // current step within the pattern


// Constructor - calls base-class constructor to initialize strip
NeoPatterns(uint16_t pixels, uint8_t pin, uint8_t type)
:Adafruit_NeoPixel(pixels, pin, type)
{
}

// Update the pattern
void Update()
{
if((millis() - lastUpdate) > Interval) // time to update
{
lastUpdate = millis();
switch(ActivePattern)
{
case RAINBOW_CYCLE:
RainbowCycleUpdate();
break;
case THEATER_CHASE:
TheaterChaseUpdate();
break;
case COLOR_WIPE:
ColorWipeUpdate();
break;
case SCANNER:
ScannerUpdate();
break;
case FADE:
FadeUpdate();
break;
default:
break;
}
}
}

// Increment the Index and reset at the end
void Increment()
{
if (Direction == FORWARD)
{
Index++;
if (Index >= TotalSteps)
{
Index = 0;
}
}
else // Direction == REVERSE
{
--Index;
if (Index <= 0)
{
Index = TotalSteps-1;
}
}
}

// Reverse pattern direction
void Reverse()
{
if (Direction == FORWARD)
{
Direction = REVERSE;
Index = TotalSteps-1;
}
else
{
Direction = FORWARD;
Index = 0;
}
}

// Initialize for a RainbowCycle
void RainbowCycle(uint8_t interval, direction dir = FORWARD)
{
ActivePattern = RAINBOW_CYCLE;
Interval = interval;
TotalSteps = 255;
Index = 0;
Direction = dir;
}

// Update the Rainbow Cycle Pattern
void RainbowCycleUpdate()
{
for(int i=0; i< numPixels(); i++)
{
setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255));
}
show();
Increment();
}


// Initialize for a Theater Chase
void TheaterChase(uint32_t color1, uint32_t color2, uint8_t interval, direction dir = FORWARD)
{
ActivePattern = THEATER_CHASE;
Interval = interval;
TotalSteps = numPixels();
Color1 = color1;
Color2 = color2;
Index = 0;
Direction = dir;
}

// Update the Theater Chase Pattern
void TheaterChaseUpdate()
{
for(int i=0; i< numPixels(); i++)
{
if ((i + Index) % 3 == 0)
{
setPixelColor(i, Color1);
}
else
{
setPixelColor(i, Color2);
}
}
show();
Increment();
}

// Initialize for a ColorWipe
void ColorWipe(uint32_t color, uint8_t interval, direction dir = FORWARD)
{
ActivePattern = COLOR_WIPE;
Interval = interval;
TotalSteps = numPixels();
Color1 = color;
Index = 0;
Direction = dir;
}

// Update the Color Wipe Pattern
void ColorWipeUpdate()
{
setPixelColor(Index, Color1);
show();
Increment();
}

// Initialize for a SCANNNER
void Scanner(uint32_t color1, uint8_t interval)
{
ActivePattern = SCANNER;
Interval = interval;
TotalSteps = (numPixels() - 1) * 2;
Color1 = color1;
Index = 0;
}

// Update the Scanner Pattern
void ScannerUpdate()
{
for (int i = 0; i < numPixels(); i++)
{
if (i == Index) // Scan Pixel to the right
{
setPixelColor(i, Color1);
}
else if (i == TotalSteps - Index) // Scan Pixel to the left
{
setPixelColor(i, Color1);
}
else // Fading tail
{
setPixelColor(i, DimColor(getPixelColor(i)));
}
}
show();
Increment();
}

// Initialize for a Fade
void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD)
{
ActivePattern = FADE;
Interval = interval;
TotalSteps = steps;
Color1 = color1;
Color2 = color2;
Index = 0;
Direction = dir;
}

// Update the Fade Pattern
void FadeUpdate()
{
// Calculate linear interpolation between Color1 and Color2
// Optimise order of operations to minimize truncation error
uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / TotalSteps;
uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps;
uint8_t blue = ((Blue(Color1) * (TotalSteps - Index)) + (Blue(Color2) * Index)) / TotalSteps;

ColorSet(Color(red, green, blue));
show();
Increment();
}

// Calculate 50% dimmed version of a color (used by ScannerUpdate)
uint32_t DimColor(uint32_t color)
{
// Shift R, G and B components one bit to the right
uint32_t dimColor = Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1);
return dimColor;
}

// Set all pixels to a color (synchronously)
void ColorSet(uint32_t color)
{
for (int i = 0; i < numPixels(); i++)
{
setPixelColor(i, color);
}
show();
}

// Returns the Red component of a 32-bit color
uint8_t Red(uint32_t color)
{
return (color >> 16) & 0xFF;
}

// Returns the Green component of a 32-bit color
uint8_t Green(uint32_t color)
{
return (color >> & 0xFF;
}

// Returns the Blue component of a 32-bit color
uint8_t Blue(uint32_t color)
{
return color & 0xFF;
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos)
{
WheelPos = 255 - WheelPos;
if(WheelPos < 85)
{
return Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
else if(WheelPos < 170)
{
WheelPos -= 85;
return Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
else
{
WheelPos -= 170;
return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
}
};


// --------------------------------------------------------------------------------------------------------------------------------------------------


NeoPatterns O (18, 5, NEO_GRB + NEO_KHZ800);
NeoPatterns N (11, 10, NEO_GRB + NEO_KHZ800);
NeoPatterns L (78, 6, NEO_GRB + NEO_KHZ800);


// first DMX start address
#define DMXSTART 100 // Doet helaas niets...

// number of DMX channels used
#define DMXLENGTH 112 // Bepaalt de kanaal 'bovengrens' wat wel lijkt te werken...


void setup () {
DMXSerial.init(DMXReceiver);
DMXSerial.maxChannel(DMXLENGTH);


O.begin();
N.begin();
L.begin();


O.setBrightness(10);
N.setBrightness(10);
L.setBrightness(10);


O.setPixelColor(14, GREEN);
O.setPixelColor(15, GREEN);
O.setPixelColor(6, RED);

N.setPixelColor(10, RED);
N.setPixelColor(0, RED);

L.setPixelColor(77, WHITE);

O.show();
N.show();
L.show();
}


//------------------------------------------------------------------------------------------------------------------------------------

void loop() {

unsigned long lastPacket = DMXSerial.noDataSince();


if ((DMXSerial.read(112)) == 1)
{
O.setBrightness(0);
N.setBrightness(0);
L.setBrightness(0);

O.ActivePattern = NONE;
N.ActivePattern = NONE;
L.ActivePattern = NONE;

for (int i=0; i<18; i++) {
O.setPixelColor(i, 0); }

for (int i=0; i<11; i++) {
N.setPixelColor(i, 0); }

for (int i=0; i<78; i++) {
L.setPixelColor(i, 0); }

O.Update();
O.show();
N.Update();
N.show();
L.Update();
L.show();

delay(1);
}


else if ((DMXSerial.read(112)) == 2)
{

O.setBrightness(DMXSerial.read(111));
N.setBrightness(DMXSerial.read(107));
L.setBrightness(DMXSerial.read(103));


O.ActivePattern = NONE;
for (int i=0; i<18; i++) {
O.setPixelColor(i, 0); }
O.setPixelColor(14, GREEN);
O.setPixelColor(6, RED);

N.ActivePattern = NONE;
for (int i=0; i<11; i++) {
N.setPixelColor(i, 0); }
N.setPixelColor(10, RED);
N.setPixelColor(0, RED);

L.ActivePattern = NONE;
for (int i=0; i<78; i++) {
L.setPixelColor(i, 0); }
L.setPixelColor(77, WHITE);
L.setPixelColor(71, RED);

O.Update();
O.show();
N.Update();
N.show();
L.Update();
L.show();

delay(9);

}


else if ((DMXSerial.read(112)) == 4)
{

O.setBrightness(DMXSerial.read(111));
N.setBrightness(DMXSerial.read(107));
L.setBrightness(DMXSerial.read(103));

O.ActivePattern = RAINBOW_CYCLE;
O.TotalSteps = 255;
O.Interval = min(10, O.Interval);

N.ActivePattern = SCANNER;
N.TotalSteps = 34;
N.Interval = 150;
N.Color1 = N.Color((DMXSerial.read(104)),(DMXSerial.read(105)),(DMXSerial.read(106)) );

L.ActivePattern = SCANNER;
L.TotalSteps = 112;
L.Interval = 40;
L.Color1 = L.Color((DMXSerial.read(100)),(DMXSerial.read(101)),(DMXSerial.read(102)) );


O.Update();
O.show();
N.Update();
N.show();
L.Update();
L.show();

delay(9);

}


else if ((DMXSerial.read(112)) ==
{

O.setBrightness(DMXSerial.read(111));
N.setBrightness(DMXSerial.read(107));
L.setBrightness(DMXSerial.read(103));


O.ActivePattern = SCANNER;
O.TotalSteps = 18;
O.Interval = 150;
O.Color1 = O.Color((DMXSerial.read(108)),(DMXSerial.read(109)),(DMXSerial.read(110)) );

N.ActivePattern = SCANNER;
N.TotalSteps = 22;
N.Interval = 125;
N.Color1 = N.Color((DMXSerial.read(104)),(DMXSerial.read(105)),(DMXSerial.read(106)) );

L.ActivePattern = SCANNER;
L.TotalSteps = 78;
L.Interval = 100;
L.Color1 = L.Color((DMXSerial.read(100)),(DMXSerial.read(101)),(DMXSerial.read(102)) );


O.Update();
O.show();
N.Update();
N.show();
L.Update();
L.show();

delay(9);

}


} // END QUOTE

[SA007]

Ik verwacht dat het probleem is dat de WS2812 en DMX beide vrij hoge datasnelheden hebben.

De processor kan maar met 1 ding tegelijk bezig zijn en kan zijn dat de 2 door elkaar bezig zijn en elkaar teveel in de weg zitten.

Je zou eens kunnen proberen de daadwerkelijke ws2812 output uit te zetten en op basis van je dmx signaal wat ledjes direct aan de i/o's aan en uit schakelen, dan kan je kijken of je tegen dezelfde problemen aanloopt.

[ThinkPad]

Tip: gebruik [code=c++] [ /code] tags voor betere leesbaarheid

[Verwijderd]

Bedankt voor de reacties !

Dat er een timingsprobleem is had ik me ook al bedacht... en is zeker ook waarheid: ik moet niet voor niets een delay toevoegen aan elke 'modus' om storingen te voorkomen.

Evengoed is dat niet mijn vraag: ik zou de Arduino slecht willen laten luisteren naar een aantal DMX kanalen, en niet het gehele pakket met 512 kanalen. Iemand een idee ?

Voortbordurend op hetgeen jij zegt SA007... zou het ook mogelijk zijn de taken op te splitsen in 2 Arduino's waarbij 1 het DMX signaal leest, en de andere Arduino de led-strips aanstuurt ? Zo ja.. hoe ? Dat al typende denk ik dan.. die eerste Arduino moet dan nog altijd 2 taken uitvoeren.. immers een signaal doorgeven aan Arduino 2 is ook een taak (wellicht net zo belastend als het aansturen van de led's).

[ Voor 15% gewijzigd door Verwijderd op 27-03-2018 16:54 ]

[Kaalus]

Verwijderd schreef op dinsdag 27 maart 2018 @ 16:51:
Bedankt voor de reacties !

Dat er een timingsprobleem is had ik me ook al bedacht... en is zeker ook waarheid: ik moet niet voor niets een delay toevoegen aan elke 'modus' om storingen te voorkomen.

Evengoed is dat niet mijn vraag: ik zou de Arduino slecht willen laten luisteren naar een aantal DMX kanalen, en niet het gehele pakket met 512 kanalen. Iemand een idee ?

Voortbordurend op hetgeen jij zegt SA007... zou het ook mogelijk zijn de taken op te splitsen in 2 Arduino's waarbij 1 het DMX signaal leest, en de andere Arduino de led-strips aanstuurt ? Zo ja.. hoe ?

Ja dat kan, maar die moeten toch met elkaar communiceren. Daar kun je dus wellicht wat winnen, maar alleen als de serial library minder vraagt dan beide anderen die je nu gebruikt. Anders kom je op dezelfde belasting of wellicht nog hoger uit.
Je kan ook de libraries proberen te minimaliseren, maar dat is best veel werk. Je eigen code minimaliseren is uiteraard ook een goed idee, maar moet net gaan.
Als alternatief kun je ook gaan voor een Arduino Mega, deze heeft een snellere microcontroller.