Go Down

Topic: led matrix (16x16) probleem (Read 805 times) previous topic - next topic

gjhubers

Hallo Allemaal, nieuwe Arduino gebruiker hier.
Na lang denken en veel filmpjes over Arduino en de vele mogelijkheden, ben ik toch in het diepe gesprongen en wil ik graag een arduino Project doen voor mijn Twitch stream. Namelijk een vanuit de Twitch chat gestuurde pixelmatrix.

Hiervoor voor heb ik:
- 1x Arduino uno board
- 1x WS2812B 16x16 matrix
- 5V 10A 50W voeding

- Twitch extensie (getintouch) om tussen Twitch en de matrix te communiceren.
- benodigde library's (getintouch, adafruit)



Het probleem:
Ik kan in de code niet vinden waar ik mijn led matrix kan configureren... Het moment dat ik een pixel tekening maak dan lichten er wel leds op maar niet op de plaats waar ze zouden moeten staan. Dit is volgens de simpele code welke geleverd wordt met getintouch.
Bijkomend probleem is dat wanneer ik in de sketch de 8x8 waarde verander naar 16x16 (mijn matrix afmetingen) dan werkt het niet meer. 10x10 werkt daarentegen weer wel.


Ik heb mijn led matrix getest met de adafruit library. alle pixels werken en ik weet dat mijn 1e led rechts boven is en in een zigzag patroon van rechts naar links loopt. Ik weet dus dat mijn led matrix correct werkt.


ook heb ik de code aangepast van "Adafruit_NeoPixel" naar "Adafruit_NeoMatrix"

Na het aanpassen krijg ik de error dat "  matrix.show(); " niet gedeclareerd is. Hier heb ik ook nog geen oplossing op gevonden.



Natuurlijk heb ik al enig Google werk gedaan en hier op het Arduino forum flink wezen speuren..... maar ik heb helaas niks kunnen vinden dat tot een oplossing leid.



verder vindt ik het ook lastig om er achter te komen welke commando's in de verschillende library's zitten en hoe ik ze toepas.. Hoe doen jullie dit?


Verder heb ik een technische achtergrond (electra) Ik heb weinig verstand van coderen maar met voorbeelden kom ik erg ver. (enige ervaring met het coderen van scripts voor de flightsimulator welke ik speel)



Als iemand hier mee zou kunnen helpen zou dat heel fijn zijn.

Mocht er nog meer info nodig zijn dan hoor ik het graag.



Vriendelijke groet, Gert-Jan



Ps. De code heb ik als een attachment bij gevoegd

shooter

je hebt dus een andere library gebruikt want in de neopixel zit wel een matrix show, maar in adafruit matrix zit deze niet of anders, zoek maar eens een voorbeeld met de matrix software.
verder kom je dus als je de matrix groter maakt in geheugenproblemen, dus of een mega gebruiken of slimmer coderen.
paul deelen
shooter@home.nl
making controls with codesys PLC and arduino

gjhubers

Hoi Shooter.

Bedankt voor je reactie.
Ik heb een andere library geprobeerd omdat ik daar wel de x en y coordinaten goed weet te krijgen. Maar dan loop ik verder in de software tegen problemen aan. Het liefst gebruik ik ook de meegeleverde library (neopixel) omdat deze al grotendeels voorbereid is en mee geleverd komt met de Twitch app.

Ik ben ondertussen wel van alles aan het proberen, maar twee problemen blijven. Wanneer ik de matrix van 8x8 naar 16x16 zet werkt er niks.... wanneer ik in de Twitch applicatie mijn opdracht verzend krijg ik ook een communicatie storing. zet ik de matrix naar 15x15 dan werkt het wel maar dan kloppen de x en y coördinaten niet.

#define MATRIX_COLS          8      //number of coloumns of the matrix (1-32 allowed)
#define MATRIX_ROWS        8      //number of rows of the matrix (1-32 allowed)

Ik neem aan dat ik ergens moet aangeven waar mijn led matrix begint en welk patroon het moet volgen. In mijn geval positie 0,0 is rechts boven en loopt van rechts naar links in een zigzag patroon.

in de Adafruit_NeoMatrix example ziet het er zo uit om mijn matrix juist in te stellen.

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(16, 16, PIN,
 NEO_MATRIX_TOP     + NEO_MATRIX_RIGHT +
 NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
 NEO_GRB            + NEO_KHZ800);

Ik vermoed dat ik in moet geven in de regel: " Adafruit_NeoPixel neoPixels = Adafruit_NeoPixel(MATRIX_COLS * MATRIX_ROWS, MATRIX_PIN, NEO_GRB + NEO_KHZ800); " Maar ik zou niet weten hoe.

Lijkt mij sterk dat dit niet mogelijk is....want deze schets komt met de Twitch app mee...

Als een andere library ook kan of beter is wil ik mij daar wel in verdiepen...maar aangezien dit mijn eerste project is en nog niet precies weet hoe ik de Getintouch code implementeer in een andere library zou ik hier graag mee verder gaan.

Suggesties zijn altijd welkom.

Mvg Gert-Jan

shooter

matrix is dus een functie om de matrix in te stellen, endie bestaat dus uit een aantal cijfers die je met een define in kunt stellen.
dan vooral goed kijken of het een + of een , moet zijn. lees vooral het commentaar van de library, een tiepvout is snel gemaakt.
begin vooral rustig aan, en kijk of het wel gaat in een kleine UNO., vaak heb je een MEGA nodig bij grotere matrices.
paul deelen
shooter@home.nl
making controls with codesys PLC and arduino

gjhubers

Hoi Shooter.
Ik begrijp wat de matrix functie doet. Ik krijg hem alleen niet juist geïnterpreteerd.

In de onderstaande regel moet ik de matrix instellen. Zoals ik het nu zie stel ik alleen een rij en een kolom in. Aangezien led matrixen op verschillende manieren geschakeld kunnen worden (zigzag, van rechts naar links, van onder naar boven, enz.) lijkt het mij logisch dat je die parameters ook kan instellen. Ik ben al dagen aan het zoeken voor de commando's hier voor maar kan deze niet vinden.

regel: Adafruit_NeoPixel neoPixels = Adafruit_NeoPixel(MATRIX_COLS * MATRIX_ROWS, MATRIX_PIN, NEO_GRB + NEO_KHZ800);

De sketch werk verder goed, alleen lichten de pixel op de verkeerde plaats op.
Ik gebruik de Adafruit_NeoPixel library.

Of zou de sketch niet werken omdat mijn UNO te klein is?
Als het goed is komt er morgen een MEGA samen met het boek Arduino voor dummies in de brievenbus.

Zo frustrerend....zo dichtbij en toch zo ver weg.

Groet Gert-Jan


MAS3

Quote from: gjhubers
Aangezien led matrixen op verschillende manieren geschakeld kunnen worden (zigzag, van rechts naar links, van onder naar boven, enz.) lijkt het mij logisch dat je die parameters ook kan instellen.
Dit is dus het probleem.
Een matrix is een raster die uit rijen en kolommen bestaat.
Maar dat is niet hoe Neopixels werken; die moeten in serie staan en dus niet parallel x parallel.
Om praktische redenen heeft een fabrikant besloten dat er dan een zigzag patroon moet worden gebruikt voor een display dat er verder wel uitziet als een matrix, maar het feitelijk dus helemaal niet is.

Quote from: gjhubers
regel: Adafruit_NeoPixel neoPixels = Adafruit_NeoPixel(MATRIX_COLS * MATRIX_ROWS, MATRIX_PIN, NEO_GRB + NEO_KHZ800);
Zie je dat het eerste argument (MATRIX_COLS * MATRIX_ROWS) een stukje wiskunde is ?
In jouw geval staat daar 16 maal 16, en kun je dus ook 256 invullen.
Even voor de duidelijkheid, daar ga je 256 maal 3 kleuren maal 256 helderheidsstappen bijhouden, dat zijn 196608 bits.
Das wel een dingetje om rekening mee te houden.
Natuurlijk zijn er wel toepassingen te bedenken waar je niet alles wat je uitstuurt hoeft op te slaan, maar over het algemeen moet je dat wel doen.

Quote from: gjhubers
De sketch werk verder goed, alleen lichten de pixel op de verkeerde plaats op.
Ik gebruik de Adafruit_NeoPixel library.

Of zou de sketch niet werken omdat mijn UNO te klein is?
Als het goed is komt er morgen een MEGA samen met het boek Arduino voor dummies in de brievenbus.

Zo frustrerend....zo dichtbij en toch zo ver weg.

Groet Gert-Jan


Ik heb tot nog toe alleen maar gehoord dat pixels op de verkeerde plaats oplichten.
Is dat omdat je geen rekening houd met het zigzag patroon ?
Vertel eens wat meer dan alleen dat het niet klopt.
Ik verwacht dat je 1 kloppende lijn, dan een lijn achterstevoren, en dan weer een kloppende lijn enzovoorts hebt.
Maar daar kan ik alleen naar raden.

Wanneer je de pixels wel gaat opslaan (en je daar dus de ruimte voor hebt), bouw je dus een raster op van 16 x 16 (x 3 (x 2 bytes)).
Vervolgens bouw je een teller die optelt tot 16, dan een 2e teller die altijd optelt wanneer de 1e teller klaar is met 1 regel, en ga je de 1e teller weer aftellen van 16 naar 1, en zo voorts.

Maar ik heb het donkerbruine vermoeden dat Adafruit dat al helemaal voor je geregeld heeft in een passende library.
En die library is dan ook goed gedocumenteerd (klik!), want die juffrouw (Limor Fried, aka Lady Ada) begrijpt heel goed hoe belangrijk dat is.
Maar ik denk ook dat dat niet de library is die je nu gebruikt behalve voor de test die je hebt gedaan.
Dus raad ik je aan om eens de informatie uit bovenstaande link een aantal malen goed te lezen, en van daar uit verder te gaan.
Dat is even wat werk / studeren, maar het wiel is allang uitgevonden en dat hoef jij helemaal niet opnieuw te doen.

Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

gjhubers

Hoi MAS3, bedankt voor je reply.
Ik zal proberen duidelijker te zijn ik wat ik zou willen bereiken.

Dit is dus het probleem.
Een matrix is een raster die uit rijen en kolommen bestaat.
Maar dat is niet hoe Neopixels werken; die moeten in serie staan en dus niet parallel x parallel.
Om praktische redenen heeft een fabrikant besloten dat er dan een zigzag patroon moet worden gebruikt voor een display dat er verder wel uitziet als een matrix, maar het feitelijk dus helemaal niet is.
Ik begrijp het stukje vam de kolommen en rijen, in feite zijn dit je lengte en breedte van het aantal led's (in mijn geval 16x16).
Begrijp ik het goed dat je eigenlijk zegt dat de Neopixels library niet geschikt is voor wat ik er mee wil doen?
Zoals ik dit lees dan maak ik er op uit dat de Neopixels library eigenlijk alleen een lange strip (led's in serie achter elkaar) kan sturen. Klopt dit?

Als dit juist is dan vindt ik het vreemd dat bij de twitch app de voorbeeld sketch geleverd wordt met een Neopixel library. (zie attachment van mijn 1e post), en dan zou het dus beter zijn om de Neopixel Matrix library te gebruiken waarin ik wel alles kan instellen. zoals bijv top right als 1e pixel en zigzag patroon enz, enz.
Even voor de duidelijkheid, daar ga je 256 maal 3 kleuren maal 256 helderheidsstappen bijhouden, dat zijn 196608 bits.
Das wel een dingetje om rekening mee te houden.
Natuurlijk zijn er wel toepassingen te bedenken waar je niet alles wat je uitstuurt hoeft op te slaan, maar over het algemeen moet je dat wel doen.
Vandaag heb ik mijn Arduino mega 2560 ontvangen en zal deze er tussen plaatsen. Dus ik zal er flink op vooruit gaan. Al zegt de twitch app informatie dat het geschikt is voor de uno. (waarschijnlijk voor dan alleen voor een matrix van 8x8 ofzo).
Ik heb tot nog toe alleen maar gehoord dat pixels op de verkeerde plaats oplichten.
Is dat omdat je geen rekening houd met het zigzag patroon ?
Ik wil wel rekening houden met het zigzag patroon....maar ik heb geen idee hoe of waar ik deze moet instellen. Ik kan hier ook niks over vinden als alleen ROWS * COLS (neopixels library)
De neopixels matrix library heeft wel alle opties om de matrix in te stellen en deze krijg ik dan ook werkend. (test waarbij het woord 'howdy' over het paneel scrolt.
Mijn probleem is dat ik momenteel te weinig kennis heb om app code om te zetten naar neopixel naar de neopixel matrix library. Deze library heeft ook andere commando's zodat 1 op 1 overzetten niet werkt. Boek arduino voor dummies is vandaag ook binnen gekomen zodat ik ook werkelijk leer de code te begrijpen ipv alleen copy paste van sketches.

Vertel eens wat meer dan alleen dat het niet klopt.
Ik verwacht dat je 1 kloppende lijn, dan een lijn achterstevoren, en dan weer een kloppende lijn enzovoorts hebt.Maar daar kan ik alleen naar raden.
Wat het moet doen:
In de twitch chat heb je de mogelijkheid om een pixel tekening te maken en deze weer te geven op de led matrix.
Stel dat ik een vierkant van rode led's maak dan komen die niet als een vierkant op mijn led matrix maar 'random' op  mijn led matrix. (zeer waarschijnlijk om dat ik dus niet weet hoe het zigzag patroon in te stellen.)
De geslecteerde kleur licht wel op. (dus geen random kleuren).

Wanneer je de pixels wel gaat opslaan (en je daar dus de ruimte voor hebt), bouw je dus een raster op van 16 x 16 (x 3 (x 2 bytes)).
Vervolgens bouw je een teller die optelt tot 16, dan een 2e teller die altijd optelt wanneer de 1e teller klaar is met 1 regel, en ga je de 1e teller weer aftellen van 16 naar 1, en zo voorts.
Zoals boven vermeld zou de mega 2560 welke ik ga gebruiken meer moge;ijkheden gaan geven.
Maar ik heb op dit moment geen idee hoe ik deze teller moet maken en toepassen...

Maar ik heb het donkerbruine vermoeden dat Adafruit dat al helemaal voor je geregeld heeft in een passende library.
En die library is dan ook goed gedocumenteerd (klik!), want die juffrouw (Limor Fried, aka Lady Ada) begrijpt heel goed hoe belangrijk dat is.
Maar ik denk ook dat dat niet de library is die je nu gebruikt behalve voor de test die je hebt gedaan.
Dus raad ik je aan om eens de informatie uit bovenstaande link een aantal malen goed te lezen, en van daar uit verder te gaan.
Dat is even wat werk / studeren, maar het wiel is allang uitgevonden en dat hoef jij helemaal niet opnieuw te doen.
Deze documentatie had al gevonden en bevat idd zeer veel bruikbare info. Het klopt dat daar al een passende library voor is, namelijk neo pixelmatrix. Deze krijg ik dan ook goed werkend. Alleen betekend dit dat ik de code voor de twitch app in deze library moet gaan plaatsen. Hier ben ik al wel mee begonnen en het een en ander al omgezet.... maar ik loop met het compileren van de sketch tegen problemen aan omdat bepaalde commando's in beide library's anders heten. en hier kan ik nog niet omheen komen.
Ik hoop dat ik zo een stuk duidelijker ben in wat ik hoop te bereiken. Dit project is voor mij een starter en zou deze willen uitbreiden, maar dan wil ik eerst dit werkend krijgen.

Nogmaals bedankt en ik zou graag je mening/advies hier over horen.

Mvg Gert-Jan




MAS3

#7
Jan 06, 2021, 11:52 pm Last Edit: Jan 07, 2021, 07:27 am by MAS3 Reason: Aanvulling en typos hersteld
Hoi.

Die foto is neem ik aan het resultaat van de sketch die je probeert.
Daar is een patroon in te herkennen.
En dat betekent dat het niet om random oplichtende LEDs gaat.
Wanneer dit telkens de afbeelding is die je krijgt, is het ook geen random resultaat.

Het patroon ziet er voor mij uit als een telfout.
Dat begint al met het aantal pixels in het online tooltje (15 x 15) en dat van jouw matrix (16 x 16).
Begin je links boven op die foto ?
En ga je dan naar rechts of naar beneden ?
De eerste positie van zo'n matrix is normalerwijze niet 1,1.
Het is gebruikelijk dat je bij nul begint en dan is de eerste pixel dus 0,0.
Wanneer het online tooltje dezelfde oriëntatie heeft, dan is de eerste pixel op 0,0 dus groen.
En dat is in je afbeelding ook zo.
Je 2e pixel op 0,1 is ineens rood (dat kan ik nog niet verklaren).
De 3e pixel op 0,2 is geel (denk ik), dat klopt dan weer en de volgende 12 pixels op rij 1 kloppen dan ook.
In je tooltje zijn ook 13 gele pixels achtereen van links naar rechts, dus dat stukje klopt ook
Ik zie ook 15 groene pixels, de enige kleur die 1 volle lijn in beslag neemt, rood en blauw hebben er 14 en geel komt er met 13 een beetje bekaaid vanaf.

Zo, na een half uurtje analyseren en typen ga ik nu een poging wagen te verklaren wat er mis zou kunnen gaan:

Wanneer het patroon in het tootlje van linksboven naar rechts loopt en dan doorgaat op de volgende lijn naar rechtsonder, dan doet jouw matrix dat niet.

De eerste lijn van 15 pixels klopt.
Die lijn begint met groen RECHTS boven en loopt dan naar links.
Vervolgens komt er weer een groene op positie 15 (nu dus links) van de eerste lijn, gevolgd door 14 lege pixels en dan de rode.
De 2e lijn loopt dus wel van links naar rechts, en maakt zo dus het zigzag patroon.
Daarmee word het patroon beschreven en word het gehele plaatje ook verklaard tot en met de laatste oplichtende  blauwe pixel rechtsonder.

Wanneer je een geheugen probleem met de Uno hebt, moet je eens proberen een patroon op een enkele lijn te tekenen, waarbij je niet telkens een nieuwe kleur maakt maar de hoeveelheid kleuren ook afwisselt.
Daarna doe je hetzelfde met bijvoorbeeld 3 lijnen.
Voor je matrix maakt het niets uit hoeveel pixels je in je sketch reserveert, maar in je sketch moet je mogelijk oppassen dat het totaal niet te hoog word.
Maar met 48 pixels maak je 3 volle lijnen en kom je dan dus zeker niet in de problemen.
Zet je het tooltje op 16 x 16 en vul je vervolgens niet meer dan de 3 lijnen die je gereserveerd hebt, zul je ook goed uitkomen.
Als je niet goed uitkomt, is het tooltje dus niet geschikt voor een zizag patroon, en kun je de lering trekken dat je niet alles wat je op het internet vind ook kunt vertrouwen.
Maar ik denk dat het wel klopt en dat alleen het aantal pixels en de oriëntatie niet juist is.
Vertrouw daarom vooral ook niet wat ik hier heb neergezet, maar controleer het aan de hand van de simpele gereedschapjes die ik je hier geboden heb.
Een display (zoals je matrix) is een heel sterk debug middel.

Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

MAS3

#8
Jan 07, 2021, 12:42 am Last Edit: Jan 07, 2021, 04:07 pm by MAS3 Reason: Late night typos
Het klopt dat neopixels alleen als 1 lange rij LEDs achter elkaar geschakeld kunnen worden.
Dat is niet helemaal waar want je kunt ook meerdere rijen op meerdere pinnen van je Arduino aansluiten en bedienen.
Maar met jouw 'matrix' is dit zeer zeker het geval.

Inderdaad is de NeoMatrix library passend, want daar kun je tegen de library vertellen dat je een zigzag patroon gebruikt, en waar de eerste Neopixel zich bevindt .
Maar als je geen zin hebt in de library, moet je zelf aan de slag gaan met het berekenen van de coördinaten van een LED in je matrix.
Ik zie niet zo goed waarom je je die moeite zou nemen tenzij je het juist leuk vind dit uit te zoeken (en het wellicht beter te doen, wie weet).

Wanneer je geen problemen hebt net de NeoMatrix library, is het ook niet waarschijnlijk dat het geheugen een probleem vormt, maar het kan wel door de rest van je sketch die ook ruimte nodig heeft.


Quote
regel: Adafruit_NeoPixel neoPixels = Adafruit_NeoPixel(MATRIX_COLS * MATRIX_ROWS, MATRIX_PIN, NEO_GRB + NEO_KHZ800);
Hier geef je argumenten  aan de library zodat die weet waar ie mee moet werken.
Er zijn meerdere argumenten, gescheiden door een komma.
Het eerste argument vertelt 'm over hoeveel Neopixels we het hebben.
Als je dan ziet "MATRIX_COLS * MATRIX_ROWS, " en daar eens een keer of 2 over nadenkt wat daar nu eigenlijk staat, dan blijkt dat een formule te zijn en niet 2 aparte waarden.
Een * in een formule staat voor vermenigvuldigen, en jij had eerder al tegen je sketch gezegd dat MATRIX_COLS de waarde 16 heeft, en MATRIX _ROWS ook.
Dan kom je dus uit op 16 maal 16 pixels, is 256, tel ze maar na.

MATRIX_PIN is dus de pin waarop je de display hebt aangesloten.

NEO_GRB vertelt dat het hier gaat over pixels die zijn opgebouwd in de volgorde Groen, Rood , Blauw (bij monitoren is het meestal Rood, Groen, Blauw).
Dus als je die verkeerd zou hebben ingevuld, krijg je verkeerde kleuren op de juiste pixels.
NEO_KHZ800 betekent dat de data er met 800 kilohertz uitgeklokt (sorry, uitgestuurd) word (das best vlot).
Die wil je zo hoog mogelijk hebben voor een vlotte weergave, maar moet natuurlijk wel overeen komen met wat je pixels nog kunnen bijhouden.


Als dit je 1e project met Arduino of vergelijkbaar is, dan is het nogal ambitieus en daarom petje af dat je al zover gekomen bent.
Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

gjhubers

Hoi MAS3

Als eerste, bedankt voor je compliment! Dat doet mij goed.

Ik heb nog geen tijd gehad om verder te kijken in de sketch. Ik zal eerst je reply eens laten bezinken en kijken wat ik dmv je adviezen kan vinden. Hopelijk kan ik het komende weekend nog wat tijd vinden om verder te komen. Ik ga denk ik ook proberen om de sketch van neopixels over te zetten naar neopixels matrix. Volgens mij is dit veel makkelijker en geeft mij meer opties in de toekomst.... Ja ik ben nog veel meer van plan.... maar eerst dit goed zien te krijgen en dan stapje voor stapje verder. Ook ben ik aan het arduino boek voor dummies begonnen. Dit is goed geschreven en heb er al een aantal tips uitgehaald welke ik wil gaan proberen.
Verder zal ik je nog wat antwoorden uit je vorige post geven.

Die foto is neem ik aan het resultaat van de sketch die je probeert.
Daar is een patroon in te herkennen.
En dat betekent dat het niet om random oplichtende LEDs gaat.
Wanneer dit telkens de afbeelding is die je krijgt, is het ook geen random resultaat.
Inderdaad, dit is de sketch welke ik graag werkend zie, iets tekenen in het teken programma en dan laten visualiseren op mijn matrix.

Je hebt helemaal gelijk. De pixels worden niet random geplaatst maar door de verkeerde tel som op de verkeerde plek. Random is een verkeerde woord keuze van mij. want als ik deze tekening weer krijg ik dezelfde led's.
Het patroon ziet er voor mij uit als een telfout.
Dat begint al met het aantal pixels in het online tooltje (15 x 15) en dat van jouw matrix (16 x 16).
Begin je links boven op die foto ?
En ga je dan naar rechts of naar beneden ?
De eerste positie van zo'n matrix is normalerwijze niet 1,1.
Het is gebruikelijk dat je bij nul begint en dan is de eerste pixel dus 0,0.
Wanneer het online tooltje dezelfde oriëntatie heeft, dan is de eerste pixel op 0,0 dus groen.
En dat is in je afbeelding ook zo.
Je 2e pixel op 0,1 is ineens rood (dat kan ik nog niet verklaren).
De 3e pixel op 0,2 is geel (denk ik), dat klopt dan weer en de volgende 12 pixels op rij 1 kloppen dan ook.
In je tooltje zijn ook 13 gele pixels achtereen van links naar rechts, dus dat stukje klopt ook
Ik zie ook 15 groene pixels, de enige kleur die 1 volle lijn in beslag neemt, rood en blauw hebben er 14 en geel komt er met 13 een beetje bekaaid vanaf.
Het moet wel een telfout zijn omdat het met de neopixel matrix library wel werkt.
Als ik 16x16 als matrix instel dan werkt mijn matrix niet meer, en wanneer ik in de getintouch debug kijk zie ik ook dat ik geen communicatie heb tussen de arduino en het teken programma. zet ik in mijn sketch de matrix naar 15x15 dan werkt het wel. Ik heb dan niets anders dan de matrix veranderd. Het tekentooltje hoort ook bij de sketch. deze veranderd naar de matrix grootte welke ik in sketch op geef.

Maar dit zet mij nu aan het denken...ik kan wel een lagere matrix instellen.... maar dan wordt het effect nog vreemder omdat hij natuurlijk wel hardware matig de leds ziet en zou dus tellen van "rij 0- pos. 0.0 tm 14" dan zou rij 2 daaronder moeten beginnen maar dit is dan nog "rij-0 pos 15" daarna begin ik pas aan rij 1. klopt mijn beredenering? (sorry lastig uit te leggen via tekst)

De 0.0 positie van mijn matrix is rechts boven, en loopt dan van rechts naar links in een zizag patroon naar beneden. De kleur van mijn 0.0 led zou dus rood moeten zijn.... maar deze is op mijn matrix groen.

Ps mijn matrix op de foto ligt net zoals het teken veld van het tekenprogramma. Daar bedoel ik mee, dat de 0.0 positie van mijn matrix is rechts boven, en loopt dan van rechts naar links in een zizag patroon naar beneden.
Zo, na een half uurtje analyseren en typen ga ik nu een poging wagen te verklaren wat er mis zou kunnen gaan:

Wanneer het patroon in het tootlje van linksboven naar rechts loopt en dan doorgaat op de volgende lijn naar rechtsonder, dan doet jouw matrix dat niet.

De eerste lijn van 15 pixels klopt.
Die lijn begint met groen RECHTS boven en loopt dan naar links.
Vervolgens komt er weer een groene op positie 15 (nu dus links) van de eerste lijn, gevolgd door 14 lege pixels en dan de rode.
De 2e lijn loopt dus wel van links naar rechts, en maakt zo dus het zigzag patroon.
Daarmee word het patroon beschreven en word het gehele plaatje ook verklaard tot en met de laatste oplichtende  blauwe pixel rechtsonder.

Wanneer je een geheugen probleem met de Uno hebt, moet je eens proberen een patroon op een enkele lijn te tekenen, waarbij je niet telkens een nieuwe kleur maakt maar de hoeveelheid kleuren ook afwisselt.
Daarna doe je hetzelfde met bijvoorbeeld 3 lijnen.
Voor je matrix maakt het niets uit hoeveel pixels je in je sketch reserveert, maar in je sketch moet je mogelijk oppassen dat het totaal niet te hoog word.
Maar met 48 pixels maak je 3 volle lijnen en kom je dan dus zeker niet in de problemen.
Zet je het tooltje op 16 x 16 en vul je vervolgens niet meer dan de 3 lijnen die je gereserveerd hebt, zul je ook goed uitkomen.
Als je niet goed uitkomt, is het tooltje dus niet geschikt voor een zizag patroon, en kun je de lering trekken dat je niet alles wat je op het internet vind ook kunt vertrouwen.
Maar ik denk dat het wel klopt en dat alleen het aantal pixels en de oriëntatie niet juist is.
Vertrouw daarom vooral ook niet wat ik hier heb neergezet, maar controleer het aan de hand van de simpele gereedschapjes die ik je hier geboden heb.
Een display (zoals je matrix) is een heel sterk debug middel.
Ik laat dit stukje even bezinken en ga je tips proberen.
Het gekke is wel dat er vanuit de app ontwikkelaar geen forum is en minimaal support in de trend van: dit is de code en redt je er mee....
De bijgevoegde sketch in mijn 1e post is dan ook de welke er bij geleverd wordt. Hierin heb ik alleen de pin aanduiding van 3 naar 6 gezet en de matrix van 8x8 naar 16x16.

Ik zie niet zo goed waarom je je die moeite zou nemen tenzij je het juist leuk vind dit uit te zoeken (en het wellicht beter te doen, wie weet).

Wanneer je geen problemen hebt net de NeoMatrix library, is het ook niet waarschijnlijk dat het geheugen een probleem vormt, maar het kan wel door de rest van je sketch die ook ruimte nodig heeft.


Hier geef je argumenten  aan de library zodat die weet waar ie mee moet werken.
Er zijn meerdere argumenten, gescheiden door een komma.
Het eerste argument vertelt 'm over hoeveel Neopixels we het hebben.
Als je dan ziet "MATRIX_COLS * MATRIX_ROWS, " en daar eens een keer of 2 over nadenkt wat daar nu eigenlijk staat, dan blijkt dat een formule te zijn en niet 2 aparte waarden.
Een * in een formule staat voor vermenigvuldigen, en jij had eerder al tegen je sketch gezegd dat MATRIX_COLS de waarde 16 heeft, en MATRIX _ROWS ook.
Dan kom je dus uit op 16 maal 16 pixels, is 256, tel ze maar na.

MATRIX_PIN is dus de pin waarop je de display hebt aangesloten.

NEO_GRB vertelt dat het hier gaat over pixels die zijn opgebouwd in de volgorde Groen, Rood , Blauw (bij monitoren is het meestal Rood, Groen, Blauw).
Dus als je die verkeerd zou hebben ingevuld, krijg je verkeerde kleuren op de juiste pixels.
NEO_KHZ800 betekent dat de data er met 800 kilohertz uitgeklokt (sorry, uitgestuurd) word (das best vlot).
Die wil je zo hoog mogelijk hebben voor een vlotte weergave, maar moet natuurlijk wel overeen komen met wat je pixels nog kunnen bijhouden.


Als dit je 1e project met Arduino of vergelijkbaar is, dan is het nogal ambitieus en daarom petje af dat je al zover gekomen bent.
Ik wil heel graag de matrix library toepassen...maar dan kom ik met de rest van de sketch in de knoop...of te wel hoe ik de sturing van het tekentooltje (de app getintouch) werkend krijg. Hier ga ik wel een poging aan wagen.
Zoals al eerder vermeld kom ik met de neo matrix library wel op de juiste instellingen en krijg met de bijgeleverde test sketch "howdy" correct scrollend op mijn matrix.
Ik hoop dat het een beetje duidelijk is wat ik probeer te vertellen....dit is soms best lastig omdat via tekst te doen.
Nogmaals bedankt voor je hulp!
Voor nu zeg ik goed weekend allemaal!
I'll keep you updated!
Groet Gert-Jan

MAS3

In het stukje waar ik het patroon op jouw display vergelijk met het getekende patroon in het tooltje, kom ik tot een 100 % overeenkomst wanneer het tooltje links boven en jouw display rechtsboven in een zigzag patroon begint.

Ga je met je muis cursor over jouw display-foto heen in het zigzag patroon en begin je dan rechts boven, dan heb je dus op 0,0 de groene LED van links boven in het tooltje.
Beweeg je de muis nu volgens het patroon, dan heb je altijd eerst rood, en meteen daarna een groene LED.
Iedere regel houd je 1 pixel over, dus daarom kom je uiteindelijk op dat rood-groene kruis uit.



Het probleem waar je nu tegen aan loopt, is dat je een library gebruikt van die twitch toestand.
Die haalt iets op, ik heb geen idee waar die dat vandaan haalt.
Maar wel hoe dat er uit ziet.
Want het zijn in jouw geval 256 waardes tussen 0 en 6.
Waarde 0 is niet gedefinieerd en waarde 7 of hoger ook niet.
Maar alle andere waardes zijn wel gedefinieerd, dus alles anders dan 1 tot en met 6 is een LED die uit staat (zwart).
Waarom 256 waardes tot problemen leidt, weet ik niet maar schijnbaar is dat wel zo.

Als je wat verder kijkt op de site waar wat word beschreven over dit ding, dan kun je wel meer info over het functioneren vinden.

Ik zie dit stukje tekst:
Quote
Pixel Matrix Value

If you use a pixel matrix input, the string which will be returned from the getParameter function contains a representative number for each color due to this list:

    0: black (off)
    1: red
    2: green
    3: blue
    4: white
    5: yellow
    6: orange

The order begins on the top left corner and goes through each row from left to right, top to bottom.

So the following drawn matrix will result in the following string:

 "2220133516650444"
Het plaatje dat daarbij hoort is dit:


Dit bevestigt mijn opmerkingen over het beginpunt in jouw matrix en dat van het tooltje.
Het vertelt ook dat er wel degelijk een raster patroon word gevolgd, en geen zigzag patroon.
Dus de rode en de groene LED zijn bij elke volgende lijn geïnverteerd.
Dat had ik zo dus niet herkend.
Wanneer je dus in het midden van je zwarte veld ook nog wat kleur zou hebben kom je nog vreemder uit.
Ik denk dat je dit toch moet gaan oplossen met de andere library van Adafruit.
De twitch magie (inclusief void.ShowOnMatrix) kan er dan wel in blijven, maar alles wat met de Adafruit te maken heeft moet dan dus aangepast worden.
Zou je dan nog steeds een probleem hebben met het op de juiste plaats uitkomen van de LEDs, moet het ook nog mogelijk zijn om juist void.ShowOnMatrix aan te passen zodat de juiste pixels er uit gepikt, en naar de pixels verzonden worden.
En dan maakt het ook niet uit welke Adafruit library je gebruikt, omdat je dan dus het rekenwerk alsnog zelf doet.
Overigens is dat niet enorm moeilijk, maar je moet goed nadenken over hoe tellen eigenlijk werkt.

Ik ga nu mijn ogen even dichtdoen.
Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

gjhubers

Ik heb vanavond flink tijd door gebracht in mijn sketch, en ik ben nu zover dat ik de hele sketch over heb van de neopixels library naar de neomatrix library  Ook ben ik verder in de sturing van de matrix. Ik ben zelfs zover dat ik nu weet hoe het verloop is en rechte lijnen kan tekenen in de tool. Maar nu komt het vervelende.....ergens in de settings van de tekentool (deze stel je maak je ook in de sketch) gaat er nog iets mis. ik stel mijn matrix in op 16x16.
maar ik heb een teken veld van 12x33. Dit heeft ongetwijfeld te maken met de regel:

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix( 16, 16, PIN,
  NEO_MATRIX_TOP           + NEO_MATRIX_LEFT +
  NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG ,
  NEO_GRB                       + NEO_KHZ800);

Waarschijnlijk moet ik hier iets uithalen of een andere instelling in geven. (dit is iets voor morgen)

Het probleem waar ik nu tegen aan loop is dat: wanneer ik een horizontale lijn teken deze tot 12 pixels gaat. Wanneer ik een 2e lijn er onder teken dan verschijnen er 4 pixels op de bovenste rij (pixel 12 tm 15 van rij 1.) Daarna verschijnen de resterende pixels er onder volgens het zigzag patroon van de matrix. Dit patroon herhaald zich tot het einde.

Morgen ga ik verder in de settings. Eindelijk een stukje progressie.

Als je wat verder kijkt op de site waar wat word beschreven over dit ding, dan kun je wel meer info over het functioneren vinden.
Deze had ik al gevonden. Maar ik heb geen idee hoe je dat van scratch moet opstellen. Is niet echt beginner vriendelijk zo. Vooral niet omdat de gemiddelde twitch gebruiker zeker geen programmeur is. Het zou mooi geweest zijn als ze met iets meer voor of uitgebreidere voorbeelden kwamen.
Langzaam komen we er wel.
Groet Gert-Jan

MAS3


Code: [Select]
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix( 16, 16, PIN,
  NEO_MATRIX_TOP           + NEO_MATRIX_LEFT +
  NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG ,
  NEO_GRB                       + NEO_KHZ800);


Volgens mij (ik heb t niet opgezocht), moet je kiezen tussen "NEO_MATRIX_TOP" en "NEO_MATRIX_LEFT", en ook tussen "NEO_MATRIX_COLUMNS" en "NEO_MATRIX_ZIGZAG".
Met de eerste geef je aan of de eerste pixel rechtsboven zit of linksboven (90 graden gedraaid, alhoewel linksonder bij 180 gedraaid ook mogelijk zou zijn).
En met de 2e of je kolommen en rijen of een zigzag patroon gebruikt.
Maar dat is ongetwijfeld allemaal terug te vinden op de Adafruit site.

Ik heb geen idee hoe het tekenveld op die site relateert met de instellingen van je sketch (andersom wel).
Moet je die site niet zelf vertellen dat je 16 x 16 wil doen ?
12 x 33 is ook een heel vreemd veld dat in de praktijk erg weinig voor zal komen.


Dit hele verhaal is zeker geen beginner nivo.
Dat had ik al aangegeven.
Het is eigenlijk slimmer om eerst eens de voorbeelden die met de Arduino IDE worden meegeleverd een eind door te lopen.
Het is de bedoeling dat je op die manier een beetje een basis legt voor de toekomst.
Maar die voorbeelden spreken vaak niet enorm aan (na 2 minuten ben je wel klaar met het knipperende LEDje).
De echte uitdagingen en lering komt pas als je eens gaat spelen met die voorbeelden en dingen er in gaat veranderen.
Dan zie je wat dat doet, en hopelijk ook waarom het niet precies doet wat jij dacht (want dan leer je er van).
Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

gjhubers

Sorry voor de late reply. De vakantie is voorbij en gelukkig voor mij kan ik nog gewoon werken. Dit betekend dat ik minder tijd hier voor heb. Ik ben in de tussentijd nog wel aan het testen geweest met de neo matrix library. Probleem is... Hoe ik ook de matrix instellingen ook doe....
(  NEO_MATRIX_TOP           + NEO_MATRIX_LEFT +
  NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG ,
  NEO_GRB                       + NEO_KHZ800);   )

Ik krijg de pixels telkens op dezelfde manier op mijn led matrix. Ook blijf ik rare afmetingen houden in mijn tekentool in de twitch app.

In de neopixel library krijg ik de tekentool wel juist ingesteld....maar hier krijg ik mijn matrix settings niet juist ( top right, en zigzag )

Ik heb geen idee hoe het tekenveld op die site relateert met de instellingen van je sketch (andersom wel).
Moet je die site niet zelf vertellen dat je 16 x 16 wil doen ?
12 x 33 is ook een heel vreemd veld dat in de praktijk erg weinig voor zal komen.
De instellingen van de tekentool veranderen mee in de sketch. Alleen met de adafruit matrix library krijg ik een vreemd tekenveld in de tool.


Dit hele verhaal is zeker geen beginner nivo.
Dat had ik al aangegeven.
Het is eigenlijk slimmer om eerst eens de voorbeelden die met de Arduino IDE worden meegeleverd een eind door te lopen.
Het is de bedoeling dat je op die manier een beetje een basis legt voor de toekomst.
Maar die voorbeelden spreken vaak niet enorm aan (na 2 minuten ben je wel klaar met het knipperende LEDje).
De echte uitdagingen en lering komt pas als je eens gaat spelen met die voorbeelden en dingen er in gaat veranderen.
Dan zie je wat dat doet, en hopelijk ook waarom het niet precies doet wat jij dacht (want dan leer je er van).
Ik ben al lekker op weg in het arduino voor dummies boek. Welke goed en leuk geschreven is. Ik ben elektricien van beroep dus idd knipperende lampjes zijn al snel saai voor mij  :smiley-wink: programmeren daar in tegen is een heel ander verhaal...



Als het prettiger is om een keer via discord of iets dergelijk te spreken dan sta ik daar voor open. Dit is wel makkelijker om het een en ander te verklaren en of uit te leggen.


Prettig weekend.
Groet Gert-Jan

MAS3

Hoi.

Ik snap dat je liever directe of 1 op 1 hulp krijgt, maar daar ben jij dan alleen mee geholpen (hoop ik).
Door het op het forum te bespreken, is de informatie over jaren nog steeds beschikbaar voor anderen die er wellicht naar op zoek zijn.

Voor wat betreft de voorbeelden en het spelen er mee:
In de welkomstthread hiet in het Nederlandstalige gedeelte vertel ik over mijn eerste Arduino stappen.
Ik had wel wat ervaring met Commodore Basic, toen dik 20 jaar terug.


Quote
NEO_MATRIX_TOP           + NEO_MATRIX_LEFT +
  NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG ,
  NEO_GRB                       + NEO_KHZ800
Ik kan je niet vertellen wat je precies vertelt aan de library.
Maar ik kan je wel vertellen dat wat daar staat, niet allemaal klopt met jouw display met wat ik vermoed dat het voorstelt.
Jouw 1e pixel zit wel bovenaan (top), maar niet links.
En je gebruikt geen kolommen en rijen, maar je gebruikt een zigzag patroon.

Daarom heb ik nog maar eens gespeurd op de Adafruit site.
Daar staat precies verteld hoe je dit moet instellen voor die library.
Jouw display begint rechtsboven met de eerste pixel, en maakt dan eerst een rij vol (geen kolom), en volgt een zigzag patroon.
Dus voor jouw display zou dat dit worden:
Code: [Select]
NEO_MATRIX_TOP + NEO_MATRIX_RIGHT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG

Hiermee los je het probleem op dat je display nu gespiegeld word weergegeven.
Je lost er niet mee op dat je 1 kolom te kort komt, en ook niet dat dat online tooltje eigenwijs is.

Maar na het uitzoeken zie ik dat je dit zelf ook al had uitgevonden met die Adafruit library.

De code die je had en die gebruik maakt van die site, werkt in ieder geval niet met de NeoMatrix library.
Dat hele twitch ding staat me steeds meer tegen, want het is schijnbaar niet gemaakt om er van te leren en er gebeurt allerlei duistere magie ergens op een geheime locatie.
Dus jij kunt niet beïnvloeden hoe de twitch toestand de data invult.
Nou ja dat kun je wel maar het is maar de vraag of je ooit het plaatje op de site kunt laten overeen komen met dat van jouw display.
Dat ding is alleen geinteresseerd in hoeveel rijen en kolommen er zijn, en niet hoe die dan verder verbonden zijn.
Dus om het dan daar te tekenen en op jouw display goed weer te geven is de uitdaging waar je nu al een tijd mee bezig bent.
Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

Go Up