Ik zit momenteel op een schip richting Finland, dus kan weinig testen,  maar zal het allemaal eens bestuderen.  Ik ben van plan om zelf een keypad te maken (spullen besteld). Optie 4 lijkt mij ook het best,  al moet ik dat even in mn hoofd krijgen 😉 . Morgen met de laptop erbij kan ik even kijken naar het document.  Hopen dat ze wifi aan boord hebben 😎 

Geen haast - ik heb ook wat moeite om m'n hoofd boven water te houden met andere dingen 😉 

Ik ben even aan het zoeken geweest naar het zelf maken van een matrix. Daar zijn vele voorbeelden van alsook mogelijkheden! Ben nu even aan het testen geweest met een bordje van 6x5. Alles aangesloten op de ESP, en een voorbeeldcode erop gezet. Dat blijkt allemaal te werken.

Nu kan ik het mis hebben, maar als ik via de ESP 30 knoppen werkend krijg, dan zou dat toch voordelig (en misschien makkelijker) moeten zijn om in het scorebord te verwerken? Ik moet nog even exact bekijken hoeveel we er precies nodig hebben, maar met 30 komen we een heel eind denk ik 😉 .

Heb alleen geen idee of deze matrix fatsoenlijk te verwerken is in de code 🙄 . (let even niet op de rommel.... die is bij mij standaard...)

Het oplichten van de knoppen zit inbegrepen in de matrix, hoeft natuurlijk nergens voor!

Een reden dat ik voor deze gekozen heb, is dat er veel aan te passen is. Ook qua ontwerp en 3d printen.

De code die ik hiervoor gebruikt heb :

Hoe meer ik nadenk over de manier van invoeren, hoe lastiger het wordt...

Bezig met een workflow voor de knoppen, merk ik dat er eigenlijk meerdere reset-knoppen moeten komen voor tijd en score. Ik loop steeds vast op verschillende instellingen voor de wedstrijd. Ben ik even mee doende 🤨 

Vooral het werken met een rotary lijkt me wel wat, alleen is dit weer niet handig, als je snel wil schakelen naar periode, fouten of tijd. Dat is namelijk niet makkelijk zichtbaar te maken op het bord (welke weergave heb ik nu aanstaan?). Even mijn hoofd breken hierop 😉 

Is dit een mogelijkheid? Hier heb ik volgens mij alle acties naar knoppen vertaald. Int is voor de interval tussen 2 periodes in (klok gaat dan 2 minuten aftellen naar 0).

Tijd en scores hebben eigen resetknop.

Pre-game is voordat wedstrijd begint (20min op de klok en aftellend naar 0).

Alleen maar +, geen -. Scheelt knoppen, ook lijkt het me niet het grootste probleem om snel even 9 x op + te drukken.

Op deze manier is alles zonder rotary te doen, en is de layout van het keyboard hetzelfde als het scorebord. Voor mijn gevoel overzichtelijker...

Zoals in mijn eerdere post, kan ik tot 30 knoppen via een matrix aansturen, maar ik weet niet of jij hier hetzelfde over denkt... 😎 

Inmiddels de minknoppen van fouten en periode verwijderd, lijken me overbodig aangezien je maar 5x hoeft te drukken om weer op 0 uit te komen.

Blijven er nog 22 over. Even getest met de voorbeeldcode die ik eerder had geprobeerd en dat lukt (blijven dus 3 knoppen ongebruikt, maar daar gaat niets verkeerd).

Ga nu een deksel printen om te kijken of alles past, als dat lukt kan ik ook aan de slag met de kast zelf.

Denk je dat het haalbaar is om het zo op te lossen qua code?

Ik moet nog wel de spelregels vereenvoudigd uitleggen, maar dat is makkelijker gezegd dan gedaan (bang om wat over te slaan...)

Inmiddels de kast uitgeprint met de volgende aanpassingen aan de knoppen:

Dat ziet er voorlopig zo uit :

De verbinding met de ESP heb ik gemaakt via een SUB-D connector. Aangesloten op de serial monitor en dat werkt prima.

Als ik er een verlengkabel (10meter) tussen hang, dan krijg ik rare resultaten. Ik ga er van uit dat dit komt door voltage-drop, omdat het nu aangesloten is op de pc. Moeilijk te testen op de kast, daar de code nog niet klaar is uiteraard 😉 .

Voor wat betreft de knoppen en spelregels :

Reset Home/Guest : Resetten van score thuis en gast (dus niet de tijd).

Start/Stop Clock : Spreekt voor zich denk ik.

Reset Clock : Spreekt voor zich denk ik.

Countdown : Middels deze knop wordt 20 minuten op de klok gezet en automatisch gestart. Bij 3minuten en op eind klinkt er een signaal (nog niet geinstalleerd).

Pauze Junior : Klok wordt ingesteld op 10minuten, automatisch gestart en er klinkt een signaal bij 3minuten en op eind.

Pauze Senior : Klok wordt ingesteld op 15minuten, automatisch gestart en er klinkt een signaal bij 3minuten en op eind.

Interval : Tijd wordt ingesteld op 2minuten en automatisch gestart. Bij 30seconden en op eind klinkt een signaal.

Extra Interval : Tijd wordt ingesteld op 2minuten en automatisch gestart. Bij 30seconden en op eind klinkt een signaal. Klok wordt daarna op 5minuten gezet (stilstaand).

Extra Period : Tijd wordt ingesteld op 5minuten (stilstaand) en bij Period staat E. Bij einde tijd klinkt een signaal.

De rest van de knoppen lijken me duidelijk. Reden voor alleen + is dat je alles kunt resetten en je, denk ik, snel genoeg 9x kan drukken om van 8 naar 7 te gaan. De "chef-knoppen-indrukken" moet ook wat te doen hebben he.... 😉 .

Klinkt dit alles wat begrijpelijk? Zal een beste uitdaging zijn, ben ik me van bewust!

Ik moet de laatste post nog even lezen, de spelregels zijn niet wat je noemt makkelijk en voor de handliggend (voor een leek) ...

Anyhoo -- voor het gebruik van knoppen kennen 2 "problemen";

1) Het uitlezen van wat de opdracht is

Hier ben je al mee bezig, door gebruik te maken van een matrix etc.
Dit kan dus een matrix coördinaat zijn, op een stand van den rotary switch, etc.
Niet het moeilijkste stuk zeg maar.

2) Het opvangen van een knop druk

Deze is lastiger. Als je kijkt naar jouw 5x6 matrix sketch, dan zie je dat de Arduino (ESP) steeds bezig is de toetsaanslag, en/of los laten, probeert op te vangen. Aan de hand daarvan worden dan bepaalde zaken uitgevoerd. Tijdens deze uitvoer van taken worden de toetsaanslagen echter niet geregistreerd, wanneer we een eenvoudige opstelling hebben.

Punt 2) is dus het meest lastig. 

Een manier om dit op te vangen is het gebruik maken van een interrupt. Als een pin hoog gaat (veranderd of laag gaat) dan wordt een stukje code snel tussendoor uitgevoerd en daarna weer doorgaan waar we waren gebleven.

Je moet dit zien als:

1. zet alles stil, en sla even op waar we nu stoppen
2. voor de interrupt-functie uit als een pin "veranderd"
3. ga weer verder waar we in 1 gestopt zijn.

Bijvoorbeeld: de toetsaanslag (de "opdracht") opslaan in een globale variable.

Omdat dit het programma even stop zet, willen we dus dat die interrupt functie zo kort mogelijk is om het te laten lijken alsof het programma nog gewoon door gaat. Als het programma dan weer verder gaat, zal deze moeten reageren op de nieuwe opdracht. 

Gelukkig is realtime niet een drama in onze toepassing, maar we willen natuurlijk wel dat de bediening goed loopt.

Helaas kunnen we niet al te veel interrupts hiervoor gebruiken.

Maar ... omdat we de ESP32 kunnen gebruiken, hebben 2 cores en na wat leeswerk zie ik dat we beiden in onze sketch kunnen gebruiken, waarbij ze informatie kunnen delen maar niet op elkaar hoeven te wachten. Het idee dus: 1 core gebruiken we om alle toetsen te lezen, en de andere core gebruiken we voor LED weergave. Communicatie tussen de 2 cores kan via globale variabelen (naar wat ik er er over gelezen heb).

Core 1 draait dus het uitlezen van het keypad of de matrix, en slaat steeds alleen maar op wat er veranderd. Dus als +10 seconden wordt ingedrukt dan zetten Core 1 de tijd op +10 seconden. Als we op reset tijd drukken, dan zet Core 1 de tijd op nul. etc.

Core 2 daarentegen loopt steeds door een lus die kijkt wat de waarden voor tijd, score, periode etc is, en zet de LEDs accordingly. 

Ik heb dit zelf nog niet getest, want ik komt er net achter dat mijn ESP32 niet op mijn breadboard past (ik kan niet meer bij de pinnen aan 1 kant 😜 ).

We kunnen dus met jouw matrix al een sketch maken die de globale variabelen aanpast op basis van de knop drukken - te volgen via de seriële monitor.

Als dat goed werkt, kunnen we kijken hoe we dat kunnen combineren met een 2de core, waarbij we dan de 2de core, via de seriële monitor, steeds de globale waarden even laat zien.

Als ook dat goed werkt, dan kunnen we de 2de core gebruiken om de LEDs aan te sturen.

Merk op: in mijn eerdere verhaal keek ik naar een sketch voor een normale Arduino (die maar 1 core heeft). De dubbele schakelaar zou daarbij gebruikt worden om de opdracht door te geven (b.v. tijd +10 seconden), en het tweede deel van de schakelaar (in parallel met alle andere schakelaar) zou dan de interrupt triggeren. Op die manier zouden we dus maar 1 interrupt nodig hebben. Bij de dubbele core aanpak hebben we waarschijnlijk helemaal geen interrupt nodig.

Chapeau dat je out of the box denkt! Vind het toch knap dat je dit alles uitlegt, zonder de kast en bord voor je neus te hebben liggen.

Duidelijk verhaal (in zoverre dat ik ook al wat gelezen had over 2 cores).

Geplaatst door: @hans

want ik komt er net achter dat mijn ESP32 niet op mijn breadboard past (ik kan niet meer bij de pinnen aan 1 kant ).

Ik heb dit probleem opgelost door 2 breadboards langs elkaar te leggen (zie eerdere foto). Je zou ook 1 breadboard doormidden kunnen knippen (in het midden zitten geen verbindingen) maar ik had er toch 2 liggen.

Op mijn ESP heb ik trouwens een WIFI antenne gesoldeerd, zodat ik een sketch kan versturen zonder de kast te openen. Geeft een iets beter bereik, maar uiteraard geen tientallen meters 😉 .

Als we dus gebruik kunnen maken van 2 cores, komt dat de snelheid van "tellen" en "realtime" ten goede? Da's goed nieuws.

Kan ik daar al wat aan voorbereiden evt?

Ik begrijp dat de spelregels en de uitwerking op de kast een lastig verhaal zijn. Ik denk ook dat we dat 1 voor 1 moeten bekijken om het overzicht te behouden.

Geplaatst door: @fredrossi

Vind het toch knap dat je dit alles uitlegt

Dank je wel - Ach ... zo hebben we allemaal onze skills - toch?
Ik zie dat jij zo cirkeltjes om me rent voor wat betreft het bouwen van de hardware 😁 

Breadboard: ik moet nog even kijken of mijn andere breadboard het wel OK zal doen - vereist nog wat zoek werk in m'n rommel.
Na meerdere verhuizingen zit veel nog in dozen. 

Werken met 2 cores gaat zeker ten gunste van snelheid bij de bediening.

Wat voorbereiding betreft:
In eerdere sketches hebben we wat globale variabelen geïntroduceerd. Het wordt nu zaak dat we met jouw knoppen opstelling die variabelen kunnen aanpassen. Dus nog zonder iets met de LEDs doen, de waarden veranderen (en voor debuggen even via de seriële monitor in de gaten houden).

Als we dat onder controle hebben, dan lijkt het me goed dat we de communicatie tussen de 2 cores gaan testen.
Hiervoor willen we de ene core de waarden laten veranderen dmv de knoppen, en de andere core de waarden via de seriele monitor laten zien.

Als ook dat werkt, dan kunnen we die 2de core gaan ombouwen zodat het de LEDs aanstuurt op basis van de globale variabelen.

Zelf denk ik dat dit het beste werkt:

  De hoofd core (ik geloof dat ze dat "core 0" (nul) noemen, heeft dus de variabelen en de LED aansturing.
  De tweede core (als ik me niet vergis "core 1") gebruiken we voor de toetsen registratie.

Ik denk dat ik met wat rommelen m'n breadboard niet hoef aan te passen ... ik kan hier helaas toch niet de hele opstelling testen, maar ik kan wel knop drukken uitproberen door b.v. simpelweg 2 drukknoppen te testen. 😀 

Inmiddels ben ik aan het lezen geslagen in boekwerken om het e.e.a. onder de knie te krijgen qua programmeren. Ik ga je nooit in kunnen halen (of bijhouden), maar het kan nooit kwaad denk ik...

Waar ik ook mee bezig ben, is het vinden van een manier om alles te kunnen monteren (aansluitingen van ESP naar stekker naar knoppenkast), zonder dat het een rommeltje wordt aan de binnenkant. Het wordt daar best druk met kabeltjes nu 🤣 . Op die manier kan ik meteen testen of een lange verlengkabel wel werkt met de voeding die er nu in zit. Testen met die kabel op laptop-voeding is niet ideaal!

Programmeren is leuk en soms kost het wat moeite wat taal betreft, maar uiteindelijk is het een manier van denken. Ik geloof best dat jou dat wel ligt, dus een kwestie van wennen aan de taal/syntax en de "middelen" die in een programmeertaal beschikbaar zijn ... 
Heb ooit een kleine cursus voor beginners voor de Arduino geschreven, maar die had je al gezien misschien.

Inbouwen, en dan vooral netjes, is altijd een (leuke) uitdaging 😊