Welkom bij de Tweaking4All gemeenschapsforums!
Voor je gaat deelnemen, bekijk de Forum Regels!
Specifieke onderwerpen: Start het onderwerp met de naam van het programma of systeem.
Bijvoorbeeld “MacOS X – Jouw vraag“, of bijvoorbeeld “MS Word – Jouw Tip of Truc“.
Merk op: Omschakelen naar een andere taal zal niet werken als je een post aan het lezen bent aangezien er waarschijnlijk geen vertaling beschikbaar is.
Dat ziet er goed uit! 👍 😊 🥳
Ook gaaf dat je zelf aan het prullen bent gegaan en daarmee een sprong naar voren hebt kunnen maken. Mooi!
De functie SetDigitDark zullen we straks echter wel nodig hebben.
Kijk maar eens wat er gebeurt als je dit doet:
void loop() {
SetFail(3,4); // zet de foutelling voor Home (3) en Guests (4)
SetTime(19,59,CRGB::Red);
SetPeriod(StartLEDPeriod, CRGB::Red, 3);
SetScore(189, CRGB::White, 124, CRGB::White);
// even wachten
SetScore(190, CRGB::White, 124, CRGB::White);
De score wordt nu een combo van 189 en 190 ... (188) omdat de segmenten niet gewist worden.
Wat gaat er fout als deze functie wel wordt aangeroepen?
We maken goede vooruitgang (ben ik zelf ook erg blij mee), maar we moeten niet vergeten dat de waarden steeds veranderen (op z'n minst de tijd al).
Het idee daarbij is dat we alleen de LEDs veranderen die veranderd moeten worden. Dus als de seconden tikken, dan hoeven fouls, score, enz niet mee te veranderen.
Ik wil wel, maar valt niet mee 🙄 😉 .
In jouw code worden er 2 segmenten groen van kleur ("F" van 10 en "G" van 1) , als ik echter SetScore (190......) verplaats boven SetScore(189....) wordt alleen "F" van 1 wit, de rest groen.... dat is er 1 om te onderzoeken ( voor mij dan 😉 ).
Even een tussenvraag.........: is er een mogelijkheid om via een potmeter de hele strip te kunnen dimmen? Ik ben er al wel mee bezig geweest, maar er gaan nog wat dingen fout. Het zou makkelijk zijn als dit via een potmeter aan te passen is, i.p.v. vooraf te moeten uploaden ( de ene basketbal-hal is de andere niet qua verlichting...).
Ik ben even overgestapt naar dit bordje :
Hier hoef ik niet steeds de boot knop in te drukken om te uploaden. Voor nu nog geen probleem, maar eens alles ingebouwd is, wordt dat wel lastig. Hij heeft geen wifi of bluetooth, maar de bedoeling is toch om alles via drukknoppen te laten werken.
We komen er wel uit 😉
Helderheid via pot-meter: Dat is zeker een optie.
Optie 1 (die waarschijnlijk niet werkt) is een pot-meter die het voltage omlaag brengt. Ik vermoed echter dat dit of niet werkt, of slecht werkt.
Optie 2 is een pot-meter die we via een analoge pin lezen. Enige uitdaging is wel dat we de Arduino moeten laten weten dat de waarde is veranderd als we aan de pot-meter draaien. Dat laatste is dan wel weer even een klein beetje lastig.
Voor optie 2 is de schakeling relatief eenvoudig: een pin naar 5V, een naar Aarde (GND) en de middelste naar een analoog input (A0 bijvoorbeeld).
Uitlezen van de code is niet zo moeilijk:
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(A0);
// print de waarde:
Serial.println(sensorValue);
delay(1); // delay voor stabiliteit
}
De analoog waarde van de potmeter ligt tussen de 0 en 1023 en voor de helderheid van de LED strip hebben we een waarde 0 tot 255 nodig.
Dit kunnen we omrekenen met de "map" functie.
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(A0);
int value = map(sensorValue, 0, 1023, 0, 255);
// print de waarde:
Serial.println(value);
delay(1); // delay voor stabiliteit
}
Met de gevonden waarde kunnen we nu helderheid aanpassen met:
FastLED.setBrightness(value);
Je voelt nu het probleem natuurlijk al: hoe weet de Arduino nu dat de waarde van de potentiometer is veranderd?
En dat is inderdaad een lastige ... we kunnen hiervoor een circuit maken, maar dat zou ik zelf willen vermijden om het e.e.a. zo eenvoudig mogelijk te houden.
Een niet zo nette aanpak zou kunnen zijn dat we een functie maken als vervanger voor FastLED.show() en die dus bij elke aanroep even de pot-meter uitleest en brightness aanpast.
bv.
void loop() {
...
// doe iets met de LEDs
...
// was: FastLED.show();
EigenShow();
...
}
void EigenShow() {
int sensorValue = analogRead(A0);
int value = map(sensorValue, 0, 1023, 0, 255);
FastLED.setBrightness(value);
FastLED.show();
}
Nadeel van deze minder elegante methode is dus wel dat we het effect van het draaien aan de pot-meter pas zien als we dus EigenShow() aanroepen.
Uiteraard kunnen we dat "forceren" door de druk knoppen die we straks willen gaan gebruiken.
Ik zou wel even met setBrightness experimenteren, met name omdat ik er zelf nooit echt iets mee heb gedaan op deze manier.
Ik heb een paar voorbeelden uitgeprobeerd, en inderdaad is optie 2 het best werkend. Al gaat dat, zoals je schrijft, niet helemaal goed.
Het zou misschien een beter idee zijn (waarom kom ik daar nu pas mee 😴 ) om dit via knoppen te regelen, die gaan er uiteindelijk toch genoeg aan zitten. Dus bijv. 5 knoppen (20, 40, 60, 80 en 100%), of via een rotary switch? Lijkt me misschien wat handiger en netter om in de code te verwerken. Let wel, ik ben de slimmerik niet als het om code gaat he.....
Ik heb een tijd geleden eens gewerkt met een matrix aan knoppen, zou dat een idee zijn? Minder kabels en toch veel functionaliteit.
Hardwarematig heb ik hem nu even in elkaar gezet om te testen, alleen nog een switch verzinnen, om te kunnen uploaden, zonder de kast uit elkaar te moeten halen. Voor de zekerheid ook een fan ingebouwd, kan nooit kwaad denk ik met al die elektronica!
De kast zit in elkaar, met een extra knop om te kunnen schakelen tussen een "werkende kast" en het kunnen uploaden van code, zonder alles uit elkaar te halen. De benamingen van tijd, score, fouten en periode wilde ik eigenlijk printen, maar dit wordt voor mij gedaan door alles via stickers uit te snijden. Sneller en vlakker, er komt uiteindelijk nog een plexiglas plaat overheen.
Ik zal binnenkort eens wat foto's maken van de aansluitingen, zodat e.e.a. voor een ander ook wat duidelijker wordt. Het is nog wel best een bende aan de binnenkant, maar dat gooi ik onder de noemer "afwerking" 😆 .
Is het een idee dat ik de werking van het bord, dus eigenlijk de spelregels, hier eens neerzet? Dan denk ik dat we (voornamelijk jij 🙄 ) eens kunnen kijken of we een werkend bord krijgen....
Ik ben nog wel zoekende naar een aansluiting voor de knoppenkast. Had zitten denken aan een printerkabel, maar ik wil alles wel netjes wegwerken en dat lukt me nog niet. Dat zal dus voorlopig met losse draden en knoppen gaan gebeuren 😉
We gaan straks met meerdere knoppen aan de slag, dus is het misschien een idee om naar de knoppen-strategie te kijken inderdaad.
In principe kunnen we een interrupt gebruiken voor een knop (bounce issues even niet over nadenken).
Het nadeel is dat ik denk dat we best wat knoppen nodig hebben (corrigeer me als ik hier te ver ga of wat over het hoofd zie):
- Reset alles (?)
- Periode + en -
- Fouls thuis + en -
- Fouls uit + en -
- Score thuis + en -
- Score uit + en -
- Helderheid + en -
Dus dat zijn dan al 13 schakelaars, en zo veel interrupts hebben we waarschijnlijk niet beschikbaar.
Een optie is om slechts 1 interrupt te gebruiken, maar de Arduino staat het niet toe die dan voor meerdere knoppen te gebruiken (lees: pinnen).
We zouden daarvoor een dubbele druk schakelaar kunnen gebruiken.
Dus een gewone drukschakelaar ziet er schematisch zo uit:
En een dubbele:
Hierbiju zouden we dan de pinnen 1 en 3 kunnen gebruiken, zoals een normale schakelaar zouden worden gebruikt (een kant aan een Arduino pin - of onderdeel van een matrix!). Pinnen 2 en 4 zetten we dan van alle schakelaars parallel, en die hangen we dan aan de pin waarbij we de interrupt gaan gebruiken, zodat als welke schakelaar dan ook ingedrukt wordt, die specifieke pin de interrupt triggered.
In de functie, die we via de interrupt aanroepen, kijken we dan welke schakelaar is ingedrukt (pin 1 en 3 van schakelaar X).
Stel we gebruiken Pin 2 als de interrupt knop (pinnen 2 en 4 van alle schakelaars), dan kunnen we dat in code als volgt vangen:
...
#define INTERRUPT_BUTTON 2
...
int Period = 0;
int ScoreHome = 0;
int ScoreGuests = 0;
int FouldsHome = 0;
int FoulsGuests = 0;
bool ButtonWasPressed = false;
...
void setup() {
...
pinMode(INTERRUPT_BUTTON, INPUT_PULLUP); // internal pull-up resistor
attachInterrupt (digitalPinToInterrupt (INTERRUPT_BUTTON), someButtonPressed, CHANGE); // pressed
...
// for debugging:
Serial.begin(9600);
...
}
void someButtonPressed() {
// lees alle pinnen om te kijken welke knop was ingedrukt
// eventueel waarden aanpassen
...
ButtonWasPressed = true;
}
void loop() {
// als ButtonWasPressed == true -> scherm aanpassen
}
Dus als pin 2 veranderd: de functie "someButtonPressed" aanroepen.
Deze functie moet wel zo kort mogelijk blijven om te voorkomen dat we de kans krijgen, meerdere keren op een knop te drukken tijdens het "afwerken" van een knop indrukken.
We zouden b.v. de score kunnen ophogen, helderheid verlagen etc. --> maar alleen voor de variabelen. Het werkelijke uitvoeren/weergeven kost te veel tijd en dat moeten we dus buiten de interrupt afhandeling doen.
Om buiten die functie te zien of een knop was ingedrukt, zetten we "ButtonWasPressed" op true.
Als we dan weer in de loop zijn, dan kunnen we zoiets doen als:
if(ButtonWasPressed) {
// weergave nummers en instellen helderheid
}
Klinkt dit logisch? 😊
Het maken van een matrix is overigens een uitstekend idee! 👍
b.v. een 3x4 matrix en een aparte voor de reset ... ik weet ook niet zeker of we genoeg knoppen hebben.
Wat spelregels betreft: Ik denk dat het handig is om de werk flow uit te schrijven.
In mijn hoofd:
1. Reset alles (dat kan ook door de stroom uit te zetten en weer aan te zetten natuurlijk).
Alles staat nu op nul. Ook de klok.
2. Start spel: druk op een knop om de klok te starten?
3. Elke seconde: klok updaten.
4. Druk op de knop bij punt score voor thuis, of uit.
-> optie om dat weer ongedaan te maken als we per ongeluk een punt verkeerd tellen (vandaar de "-" knop).
5. Druk op de knop bij Foul voor thuis, of uit.
-> optie om dat weer ongedaan te maken als we per ongeluk een foul verkeerd tellen (vandaar de "-" knop).
Nu komt er een stukje spelregels bij ... ik weet eerlijk gezegd niet veel van het spel. 😱
Dus: hebben we een pauze knop nodig? Moet de klok evt. gereset worden na een pauze? etc. 😊
Even om aan te geven hoeveel pinnen we beschikbaar hebben, ik heb onderstaand bord gebruikt :
Ik had een idee, maar weet niet of dat haalbaar is...
een knoppenkast maken waar je per knop een item selecteerd (1 voor score home, 1 voor score gast, 1 voor fout thuis, 1 voor periode, 1 voor fout gast, 1 voor totale tijd). Dat zijn dan 6 knoppen.
Vervolgens een keypad aansluiten, zodat je, als er een item geselecteerd is, je de waarde direct kunt intoetsen. Er komt dan nog een knop bij voor start, stop en reset.
Geen idee of dit gaat, maar ben al wel druk zoekende geweest om zelf een keypad te maken (custom knoppen). Dat werkt in ieder geval wel deels via matrix. Als je denkt dat dit veel te ingewikkeld wordt, zeg het maar, dan vergeten we het en doen we het met allemaal losse knoppen. Kan ik weer aan het tekenen en printen 🤣 .
Voor de spelregels heb ik een lijstje doorgekregen, maar die is overcompleet. Die moet ik even aanpassen zodat het klopt met ons bord.
Wat je uitlegt voor de interrupt is begrijpelijk en ingewikkeld tegelijk 😉
Ik laat hier even zien wat ik heb doorgekregen, onbewerkt. Wat je er zeker niet in moet meenemen, is de time-outs. Die zitten er uiteraard niet in, maar kunnen met een pauze-knop wel gesimuleerd worden....
Het is een stevig document, maar het gaat even om de instellingen 😯
Vóór aanvang van de wedstrijd:
Periode 1
Interval 1
Periode 2
Pauze
Periode 3
Interval 2
Periode 4
Einde wedstrijd?
Extra Interval
Extra Periode
Amai ...! Dat is een flink document inderdaad ... 😜
OK, dan kijk ik eerste even alleen naar de knoppen ... zoals gezegd: even kijken wat het plan gaat worden 😁
Het gebruik van een keypad is wel mooi natuurlijk, maar komt ook met wat complicaties.
Stel we willen een 3 cijferige score invoeren of bijvoorbeeld tijd, dan moet de Arduino wel het e.e.a. snel genoeg af kunnen werken. Ik weet ook niet of een interrupt dan een geschikte oplossing gaat zijn. Het lezen van een enkel cijfer is niet super complex (row vs column). Maar de uitdaging zit dan dus in het lezen van meerdere cijfers. Bij de invoer van cijfers hebben we dan natuurlijk ook nog de uitdaging hoe we nummers invoeren (1, 10 of 100).
In een moment van verstandsverbijstering bedacht ik even aan het feit dat een ESP32 2 cores heeft! Jawel: 2! En in Arduino mode gebruiken we er eigenlijk maar 1. Dus ik speelde even met het idee om 1 core voor het keypad en de knoppen te gebruiken, en de de andere core voor weergave enzo.
Maar helaas is mijn ervaring met meerdere cores gewoon nul ... haha. Ik ga proberen daar van de week me even in te verdiepen ... wie weet 😉
Ze kunnen met elkaar communiceren en misschien kunnen we de interrupt functie door de 2de core laten uitvoeren. 🤔
Wat keypad: Zelf had ik het idee om met Plus en Min knoppen te werken.
Voor alle nummers kunnen we omhoog en omlaag, en waar nodig een "reset" know (klok bijvoorbeeld).
Ik ga er dan vanuit dat een score, fouls, en periodes met kleine stapjes omhoog gaan. Of ... omlaag als we een foutje hebben gemaakt bij het instellen van een score.
We zouden dit ook met een rotary switch kunnen doen (kies de functie: score thuis, score uit, fouls thuis, fouls uit, periode, neutraal) en een Plus, Min en Reset drukknop ernaast.
Als een van de drie knoppen wordt ingedrukt (Plus, Min, Reset), dan kijken we meteen naar de positie van de rotary switch om te zien waar het betrekking op heeft. De rotary switch kunnen we dan zelfs uitrusten met weerstanden: dan hebben we daarvoor maar 1 [analoge] pin nodig, en 3 pinnen voor de knoppen (Plus, Min, Reset).
Maar goed, ik zie (zonder het 100% gelezen te hebben) dat we voor de tijden toch getallen moeten kunnen invoeren op de een of andere manier.
Ik moet dat even laten bezinken.
Ik vond het ook een stevig artikel 😉 .
Het probleem met knoppen per getal, is dat er dus een heel aantal extra knoppen bijkomen om alles in te stellen.
Stel, de scheidsrechter geeft aan, dat er nog 1,5 minuut bij de resterende tijd komt (zoals bijv. bij voetbal). Dat zou lastig zijn met het instellen van + en - per getal. Daarom dacht ik aan een keypad.
Maar met een rotary-knop zou dit uiteraard wel kunnen, al zou het enorm helpen als we via deze rotary kunnen "scrollen" van 0 seconde naar 10 min.
Wordt er allemaal niet makkelijker op, begrijp ik, maar tijdens een wedstrijd zou het wel helpen 😎
Klinkt logisch om nummers te kunnen intypen inderdaad,
Bij een rotary knop neem ik aan dat we omhoog en omlaag willen scrollen. Alleen is het wat lastig te bepalen of je naar links of naar rechts draait.
Wordt er allemaal niet makkelijker op, begrijp ik, maar tijdens een wedstrijd zou het wel helpen
Doel is toch om iets te maken wat handig is voor het spel? 😁
Ik volg altijd de regel dat het programma (Arduino) zich moet aanpassen aan de toepassing (Gebruiker en spel) en niet andersom.
Soms wil dat wel zeggen dat we even moeten rommelen om een goede en werkende oplossing te vinden natuurlijk.
Geen probleem toch? Dat maakt het juist leuker als het klaar is 😊
De aanpak met de rotary knop, waarbij we een functie kiezen: we zouden hier natuurlijk ook een "tijd invoer" functie bij kunnen zetten die dan een matrix keypad uitleest. Even over nadenken en even kijken of ik een keypad heb liggen om het e.e.a. te testen. We zouden er vanuit kunnen gaan dat elke druk op het keypad een nummer toevoegt ... 🤔
Nu ben je weer 2 stappen verder dan mij 😀 . Een matrix heb ik hier niet liggen, al wil ik die graag zelf maken en tekenen. Daar ben ik nu naar zoekende hoe en wat (zelfgemaakt is toch leuker).
we zouden hier natuurlijk ook een "tijd invoer" functie bij kunnen zetten die dan een matrix keypad uitleest.
Dat zou wel het mooiste zijn! Dan sla je 2 vliegen in 1 klap. Minder knoppen en toch resultaat.
Ik dacht zelf aan invoer van keypad : instellen van bijv. tijd 5 min 8 sec in te voeren als 0508 in zijn geheel. Dus niet per getal, maar via rotary het geheel selecteren. 50 seconden instellen als 0050.
Voor de score, periode en fouten zou misschien hetzelfde kunnen gelden? Ik ga me even druk maken om een keypad-matrix met custom knoppen in ieder geval 🤪
tijd 5 min 8 sec in te voeren als 0508
Invoer van het keypad: ja lijkt me inderdaad de beste methode, en dan inderdaad voor tijd als "1234" in toetsen (en indien wenselijk voor een score "123"?).
Heb je een specifiek numeriek pad voor ogen hiervoor? Of wil je zelf een matrix maken?
In alle gevallen hebben we iets nodig wat de interrupt triggered en we hebben maar een erg beperkt aantal pinnen hiervoor.
Met een rotary switch kunnen we dan kiezen welke functie we willen, maar niks triggered dan de interrupt.
Wat een optie zou kunnen zijn is gebruik maken van gewone drukknoppen - dus een drukknop per functie (het lange document gaat me even over het hoofd en de details negeer ik even - hopelijk vul jij dan aan waar ik tekort schiet 😉 ).
Het idee is dan een interrupt te triggeren, en daarbij kunnen we dat een aantal manieren doen (Plus, Min en keypad niet meegerekend).
Functie (er zijn 7 of 8 functies) kiezen:
Optie 4 is misschien een goede optie om te proberen.
Zoiets dus, slechts een ruwe schets (voor maar 4 schakelaars, maar het is maar voor het idee) getekend met circuit-diagram.org (ook niet echt het handigste programma/tooltje hiervoor):
Als dus een knop wordt ingedrukt (niet helemaal het juiste symbool voor een drukknop), dan wordt de trigger aangeroepen en lezen we de weerstand uit.
De weerstandswaarden zijn maar willekeurig, en er zit geen debounce in - dus het schema kan wat beter verfijnd worden 😉