Hoi,
Als laatste wil ik de leds veranderen in een led ring (ws8212)
Nu heb ik 2 voorbeelden gevonden.
met fastled : https://wokwi.com/projects/364328699927598081
met adafruit : https://wokwi.com/projects/404752420303294465
is er een reden om het met de ene of de andere library te doen ?
Nee in principe werken ze allebei. Het verschil zit 'm vooral in de manier waarop de pixel data wordt opgeslagen.
FastLED maakt gebruik van een array (CRGB) die door de gebruiker zelf gedeclareerd wordt (op de stack) en waarbij het object een referentie daarna krijgt. Wat beginners vaak fout doen is dat ze schrijven voorbij de grens van de array, wat een crash to gevolg heeft.
Adafruit declareert de pixel buffer intern (op de heap) en gebruikt member functies om er naar toe te schrijven. Deze functies checken of de pixel binnen de buffer valt. Doordat de buffer op de heap wordt gedeclareerd wordt deze niet meegenomen in het geheugen gebruikt tijdens het compileren, waardoor het 'lijkt' alsof er nog geheugen ruimte is, terwijl dat soms niet zo blijkt te zijn.
Beide komen met een aantal voorbeeld / ingebouwde effecten, en ondersteuning voor meerdere boards.
Er zijn nog meer libraries (ik hou graag bibliotheek apart voor dat gebouw met die boeken) zoals bv. Makuna Neopixelbus Wat vooral voor ESP8266 & ESP32 de beste keuze is.
Voor een AVR (eg UNO, Nano, Mega etc.) maakt het allemaal niet zo veel uit en is het meestal een keuze gebaseerd op persoonlijke voorkeur.
Dank je voor je antwoord.
Misschien om te leren is het mooi om ze alletwee eens te proberen.
Zolang je ze maar niet gaat combineren in dezelfde sketch.
Ik was verrast om te horen dat de twee bibliotheken, en aanroepen van hun functies, in één schets kunnen bestaan, maar het is een verspilling van geheugen.
Alleen als je met beiden een array creëert voor de NeoPixels en in het programma beide arrays gebruikt.
was ik niet van plan.
Ik zat te denken aan een project voor adafruit en een project voor fastled met een simple effect.
Hopelijk botsen ze dan niet met LiquidCrystal die ik nu gebruik om de lcd te besturen.
Oh das fijn.
Nee dat komt wel goed. Er zijn wel bekende conflicten met andere dingen (IR, Servo, swSerial bv) maar met de LCD moet alles gewoon blijven werken.
Toch moet me 1 ding even van het hart. Voor mij is Arduino ook vooral om met fysieke dingetjes te spelen, en niet alleen voor met wokwi.
Voor mij ook
Alleen mijn werkplek is nog steeds niet klaar na een verhuizing en daarom speel ik nu met wokwiki om wel bij te blijven en niet teveel kennis te verliezen.
En heb ik dit met fastled goed gedaan : https://wokwi.com/projects/438711277844768769
als dat zo is dan kan ik adafruit eens proberen.
Is dat een vraag? Het knippert dus ik denk dat dat wel goed zit.
Twee dingen om lering van te trekken:
1
Verander setup() naar het volgende
FastLED.addLeds<WS2812B, DATA_PIN>(leds, NUM_LEDS);
En kijk wat het effect is.
Verander de regel vervolgens naar
FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
Niet alle NeoPixels zijn hetzelfde, de volgorde van de kleuren in het echte leven kan anders zijn dan RGB en de laatste GRB vertelt de FastLED bibliotheek welke volgorde gehanteerd moet worden.
2
Compileer je FastLED programma zoals je het nu in de wokwi hebt op je PC en maak een aantekening van het geheugen gebruik (speciaal het dynamisch geheugen gebruik).
Herhaal met een groter aantal LEDS (bv 160); weer even een aantekening maken.
Schrijf hetzelfde programma (16 LEDs) voor de Adafruit NeoPixel bibliotheek en maak na het compileren op de PC weer een aantekening van het geheugen gebruik.
Herhaal met een groter aantal LEDs (160) en maak weer een aantekening.
Kijk nu naar de verschillen in je aantekeningen. Bij de Adafruit bibliotheek zal het geheugen gebruik zoals gerapporteerd in de IDE niet veranderen en je moet het het aantal bytes dat gebruikt wordt voor de pixels door de bibliotheek er nog bij optellen (3 x 16 of 3 x 160). Je zou niet de eerste zijn die onverwachte problemen krijgt ("het werkt niet").
Oude code is de led groen
Dan is de led rood
Dan is de led ook rood
Met 16 leds kom ik op deze gegevens :
Sketch uses 3784 bytes (12%) of program storage space. Maximum is 30720 bytes.
Global variables use 180 bytes (8%) of dynamic memory, leaving 1868 bytes for local variables. Maximum is 2048 bytes.
met 160 kom ik op deze gegevens :
Sketch uses 3784 bytes (12%) of program storage space. Maximum is 30720 bytes.
Global variables use 612 bytes (29%) of dynamic memory, leaving 1436 bytes for local variables. Maximum is 2048 bytes.
dus het klopt dat hoe meer leds je gebruikt. hoe groter het geheugen gebruikt wordt.
De adafruit kan ik nog even niet controleren omdat ik die nog moet schrijven.
Vraagje : Hoe weet ik welke neopixel wokwiki of in het echt een ring nodig hebt.
Hanteerde dus RGB, terwijl WS2812B (waarmee de meeste ledringen gemaakt worden, GRB zijn.
Dat weet FastLED dus ook.
Maar zoals al gezegd zal je daar waarschijnlijk geen verschil opmerken omdat het geheugen anders gedeclareerd wordt.
Dat hangt van de gebruikte ring / strip af en het gebruikte chipje (bij een WS2812B zit dat er al in)
Vaak zit er bij de verkoop een specificatie waarmee je dan via het datasheet kan achterhalen wat de volgorde is.
Of gewoon trial & error. laat een ledje circuleren van Wit naar Rood naar Groen naar Blauw en pas aan totdat het klopt.
oke
Dank je
Ik heb de ada fruit neopixel ook even gemaakt : https://wokwi.com/projects/438718699155804161
Vindt de code wat moeilijker dan de fastled.
Geheugen gegevens
met 16 leds :
Sketch uses 2414 bytes (7%) of program storage space. Maximum is 30720 bytes.
Global variables use 41 bytes (2%) of dynamic memory, leaving 2007 bytes for local variables. Maximum is 2048 bytes.
met 160 leds :
Sketch uses 2420 bytes (7%) of program storage space. Maximum is 30720 bytes.
Global variables use 41 bytes (2%) of dynamic memory, leaving 2007 bytes for local variables. Maximum is 2048 bytes.
dus het klopt dat de adafruit niet het geheugen meetelt, en bij de fastled wel.
Mijn conclusie als ik nu allebeide in een heel klein testje hebt gebruikt , mijn voorkeur uitgaat naar fastled omdat de code wat simpeler is en het geheugen gebruik werkelijk weer geeft
@sterretje @Deva_Rishi als jullie vinden dat ik hier genoeg heb geleerd , is het denk ik tijd om alle effecten te herschrijven zodat ze werken met de ring.
En dan alles weer in 1 project zetten.
zoiets.
Probeer ze zodanig te herschrijven dat zie de code niet blokkeren zoals in het 'blink without delay()' voorbeeld.
Zodat je ook tijdens de effecten controle behoud over het menu enzo.
probeer dat eerst in een aparte sketch.
natuurlijk
De effecten zijn ook zo geschreven toen ik ze probeerde met 6 aparte leds
Waarom? Er is echt geen groot verschil tussen de Adafruit bibliotheek en de FastLED bibliotheek
FastLED
// zet de kleur van een LED (met index 0)
leds[0] = CRGB::Red;
// update de strip
FastLED.show();
AdaFruiit
// zet de kleur van een LED (met index i)
pixels.setPixelColor(i, pixels.Color(0, 150, 0));
// update de strip
pixels.show();
Nee, ik denk niet dat je genoeg geleerd hebt. Kun je beschrijven wat je verwacht dat de Adafruit versie moet doen? Hoe verschilt het met wat de wokwi simulatie daadwerkelijk doet?
Dit is de wokwi versie die je gegeven hebt:
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN 6
#define NUMPIXELS 16
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
#define DELAYVAL 500
void setup() {
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
}
void loop() {
pixels.clear();
for(int i=0; i<NUMPIXELS; i++) {
pixels.setPixelColor(i, pixels.Color(0, 150, 0));
pixels.show();
delay(DELAYVAL);
}
}
En kun je uitleggen wat dit stukje in je Adafruit programma doet?
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
Ik stel voor dat je pins.h, output.h en output.cpp van je andere project in een nieuw project zet en die aanpast voor gebruik met één van de twee bibliotheken. Herschrijf eerst het voorbeeld dat je in dit onderwerp gemaakt hebt met de aangepaste versies van de hierboven genoemde bestanden.
Voor @Deva_Rishi's informatie
pins.h
#pragma once
#include "Arduino.h"
// inputs
const byte potPin = A1;
const uint8_t ledPins[] = {6, 10, 11, 9, 5, 3};
const uint8_t lcdRS = 12;
const uint8_t lcdE = 8;
const uint8_t lcdD4 = A5;
const uint8_t lcdD5 = A4;
const uint8_t lcdD6 = A3;
const uint8_t lcdD7 = A2;
// outputs
#define NUMLEDS 6
output.h
/*
Configure outputs
*/
void setupOutputs();
bool pwmAll(uint8_t *values, uint8_t size);
bool pwmLed(uint8_t idx, uint8_t value);
Opmerking
Ik zie net dat je hier een #pragma once lijkt te missen.
output.cpp
#include "Arduino.h"
#include "pins.h"
void setupOutputs() {
for (uint8_t cnt = 0; cnt < sizeof(ledPins); cnt++) {
// Zet alle leds uit
analogWrite(ledPins[cnt], 0);
// Zet de pin mode op output
pinMode(ledPins[cnt], OUTPUT);
}
}
bool pwmAll(uint8_t *values, uint8_t size) {
for (uint8_t cnt=0; cnt < size; cnt++) {
analogWrite(ledPins[cnt], values[cnt]);
}
return true;
}
bool pwmLed(uint8_t idx, uint8_t value){
analogWrite(ledPins[idx], value);
return true;
}
Jawel, ik controleert of je een bepaalde processor hebt die op 16MHZ kan werken.
Als dat zo is, wordt de processor ook op 16MHZ gezet in plaats van 8MHZ.