Codevrije LCD-menugeneratie met XOD

Over dit project

De processors die de Arduino-ontwikkelborden aandrijven, zijn niet de microcontrollers van je grootvader - ze hebben een serieuze verwerkingskracht en kunnen worden gebruikt om veel soorten fysieke hardware en sensoren tegelijkertijd te bewaken en te besturen. De XOD grafische programmeer-IDE voor Arduino kan de taak van rapid-prototyping van hardwareontwerpen vereenvoudigen, maar naarmate een systeem steeds complexer wordt, is er de kwestie van gebruikerscontrole en informatiebeheer - hoe informatie over het gecontroleerde proces te ordenen voor weergave en de gebruiker te laten regel het op een logische manier. Speciale knoppen en schakelaars werken voor eenvoudige projecten, maar je hebt al snel geen logische manieren meer om ze te rangschikken (of plaatsen om ze op een behuizing te plaatsen). Veel ontwerpen gebruiken een of ander display om dit soort feedback te geven, zelfs een magnetron heeft meestal een klein scherm dat het mogelijk maakt instellingen te bewerken en kooktijden in te voeren, en hoewel te veel "menu duiken" om toegang te krijgen tot obscure instellingen de gebruikerservaring in gevaar kan brengen, zijn menugestuurde interfaces een feit van het leven voor allerlei soorten projecten.

Softwareframeworks voor het ontwikkelen van op menu's gebaseerde interfaces in C of C++ voor microcontrollers hebben vaak een steile leercurve en kunnen moeilijk zijn om snelle ontwerpwijzigingen door te voeren, omdat alles vaak samenwerkt met al het andere. Het doel van dit project was om de XOD grafische programmeeromgeving te gebruiken om snel prototypen van menugestuurde interfaces te bieden voor Arduino-compatibele microcontrollerprojecten met behulp van een interface in drag-and-drop/WYSIWYG-stijl. De uitgangs- en ingangsparameters van de gegenereerde menustructuur zijn modulair en generiek en moeten kunnen worden gebruikt met een grote verscheidenheid aan ingangsbronnen (schakelaars, knoppen, encoders) en produceren een reeks platte tekstuitgangen die naar een breed scala van verschillende XOD-ondersteunde weergavetypes, waaronder LCD-modules met meerdere regels, zoals gebruikt in dit voorbeeld.

Als je niet bekend bent met de XOD-omgeving die dit project gebruikt, bekijk dan eerst de tutorials voor dat project op xod.io.

Een screenshot van een eenvoudige motiverende voorbeeldschets volgt. We zullen dit XOD-patchdiagram sectie voor sectie doornemen om uit te leggen hoe alles in elkaar past.

• Het menu Sectie Controller-interface

Rechts van het patchbewerkingsscherm in XOD zijn vier knooppunten op een aflopende manier met elkaar verbonden. Van boven naar beneden is er eerst een knooppunt van het analoge ingangstype, dat is geselecteerd om te worden aangesloten op een van de analoge ingangspoorten van de Arduino. In mijn tests heb ik een Arduino Uno gebruikt met een ATMega328 8 bit processor, met een 16x2 LCD/toetsenbord schild erop aangesloten. Het toetsenbord op het schild is via de schildpinnen verbonden met de analoge ingang "A0" van de Arduino en de hardware genereert spanningen van verschillende niveaus om aan de Arduino te signaleren welke knoppen op de pad zijn ingedrukt.

Afgezien van de "reset"-knop op het toetsenbord die niet rechtstreeks met de Arduino-schets communiceert, biedt dit type schermschild vier richtingsknoppen - omhoog, omlaag, links en rechts, een "selecteer" -knop. Het tweede knooppunt dat wordt gevoed door het analoge ingangsknooppunt, bevat code die de verschillende spanningen decodeert die overeenkomen met afzonderlijke toetsen, en geeft pulsachtige triggers af, afhankelijk van welke knop wordt ingedrukt. Er is een "time-out"-invoer zodat een XOD-ontwikkelaar de debounce-time-out van het LCD-schildtoetsenbord kan aanpassen om valse triggering te voorkomen, aangepast aan de knop of het schakelaartype van een bepaalde toepassing.

Het derde knooppunt is een knooppunt van het type menucontroller, dat code bevat om pulsachtige triggers van het bedieningspaneel te accepteren en de logica van de gebruiker af te handelen die door de menustructuur navigeert en selecties maakt die statusupdates van de menustructuur genereren.

Zoals momenteel geïmplementeerd, accepteert het een enkele invoer van het nummertype die elke parameter kan zijn die de gebruiker kan wijzigen vanaf een externe besturing, bijvoorbeeld een potentiometer of draaiknop op een bedieningspaneel die een parameter vertegenwoordigt die kan worden gewijzigd. Wanneer een bepaald bladtype menu wordt geselecteerd door de menu-controller die een puls ontvangt voor zijn "Invoke" -ingang, zal in de menuboom aan de linkerkant het knooppunt van het scherm waar de gebruiker momenteel naar kijkt zelf een puls uitvoeren output, en zend ook een parameterverandering uit. Er zijn ook twee String-ingangen die kunnen worden gebruikt om een ​​opstartscherm op het display te genereren wanneer de Arduino opstart.

Na dat knooppunt volgt een voorraad 16x2 LCD-controllermodule uit de standaardbibliotheek van de XOD-omgeving, maar elk type weergave waarvoor een module beschikbaar is, kan worden gebruikt om de uitvoertekst hier weer te geven.

• De sectie Menustructuur

Bovenaan de schets-screenshot is een boomachtige structuur die, wanneer gecompileerd en de uiteindelijke output "root" van de boom wordt gerouteerd naar de menu-controller input die het accepteert, automatisch een navigeerbaar menu zal genereren, net zoals afgebeeld in de grafisch vormgever. Momenteel geïmplementeerd zijn drie soorten menuboom-knooppunten, een "blad"-type menu - een laatste submenu, zonder oranje gekleurde invoerpoorten - dit vertegenwoordigt een actie of parameter die de gebruiker kan besturen, een "vertakkings"-type menu met zowel een invoer als een uitvoer, waar de gebruiker kan kiezen uit verschillende onderliggende submenu's, en een "concat"-type menu waar submenu's worden gegroepeerd en ingevoerd in de invoer van een vertakkingsmenu, om een ​​groep te maken van opties. Het zou hopelijk enigszins duidelijk moeten zijn uit het diagram hoe deze set knooppunten moet worden aangesloten.

Door "aanroepen" te selecteren wanneer een menu van het "branch"-type wordt weergegeven, daalt u af naar de bijbehorende submenugroep, in plaats van een uitvoer te genereren zoals een menu van het bladtype doet. Sub-submenu's, sub-sub-submenu's, etc. zijn mogelijk! Complexe structuren kunnen worden geïmplementeerd, voornamelijk beperkt door de beschikbare RAM- en Flash-geheugenbronnen van de processor van een bepaald Arduino-model.

• Uitvoer sectie

In dit voorbeeld is het uitvoergedeelte waar de menu's van het bladtype communiceren met externe hardware via de uitgangspinnen van de Arduino. Elk menu van het bladtype heeft een uitgang van het pulstype die via een bus wordt aangesloten op een respectieve flip-flop om de bijbehorende digitale uitgangspen in en uit te schakelen. Dit soort opstelling kan worden gebruikt om externe relais of LED's te besturen, maar pulsuitgangen zijn erg algemeen, en de uitgangspuls die wordt gegenereerd bij het selecteren van "Invoke" bij het openen van een bladachtig menuscherm kan worden gebruikt om veel taken uit te voeren, zoals bijwerken van een intern XOD-buffertype knooppunt waar parametergegevens van de parameterinvoerpoort van de menucontroller worden bewaard voor toekomstig gebruik.

• Huidige bekende problemen

Deze set knooppunten is getest en zou goed moeten werken met de Arduino Uno zoals het is, maar er zijn nog een paar problemen die niet zijn opgelost door de deadline van dit project. Momenteel moet er ergens een menu van het vertakkingstype in de boomstructuur zijn om een ​​schets te compileren, hoewel de meeste projecten er waarschijnlijk minstens één willen hebben. De "top" menu-invoer naar de menu-controller, bedoeld om helemaal terug te keren naar het titelscherm van de interface, is momenteel niet geïmplementeerd, maar zou een gemakkelijke functie moeten zijn voor de volgende revisie.

Displays met vier regels worden ondersteund door het knooppunt van de menucontroller, maar de menu-interface van het bladtype met vier regels tekstinvoer is nog niet geschreven. Er is veel energie gestoken in het verminderen van de geheugenoverhead van dit hulpprogramma, maar de manier waarop de XOD-transpiler momenteel constante strings opslaat, is niet optimaal voor zeer lage RAM-overhead, en menugebaseerde interfaces hebben vaak veel tekst. Voor dit project is een work-around ontwikkeld en een set flash-string-type nodes toegevoegd in de patch om ervoor te zorgen dat langere strings geen kostbaar programma-RAM verbruiken. Hopelijk wordt dit aangepakt in een update van de XOD-omgeving, maar de work-around is voorlopig OK.

Het gebruik van knooppunten van het flash-string-type is niet al te pijnlijk, maar vereist wel het dupliceren van de patch en code voor elke nieuwe string die is opgeslagen in het programmageheugen, en klikken op de C++-code in het knooppunt zelf om de uitvoerstring te bewerken:

De "ID"-invoer van blad- en vertakkingsknooppunten heeft nog geen functie. De gedachte is dat het goed zou zijn voor elke set submenu's om de bijbehorende ID-nummers op volgorde te hebben, zodat de gebruiker hun positie in een set displays kan volgen, maar er zal wat meer aandacht nodig zijn over hoe dit in C ++ moet worden gecodeerd automatisch gebeuren.

• Voortzetting van het werk

Verdere bugtesten en testen op andere Arduino-apparaten naast AVR/ATmega-apparaten zoals ARM moeten worden gedaan. De huidige reeks menu-knooppunttypen is enigszins beperkend, er zou meer variatie in invoer en uitvoer moeten zijn. Voortzetting van het werk aan het verminderen van de RAM-overhead, misschien door meer metaprogrammering tijdens het compileren te gebruiken en zoveel mogelijk gegevens in Flash-geheugen op te slaan in plaats van de boomcomponenten tijdens runtime met elkaar te verbinden/aaneen te schakelen.

19-2-19 - Een tweede voorbeeld.

Deze tweede voorbeeldschets-screenshot laat zien hoe u de menucontroller gebruikt om een ​​externe of interne waarde als invoer voor de controller te nemen, de huidige en vorige waarden op een gewenste menupagina weer te geven en een nieuwe waarde te selecteren en op te slaan in een buffer.

Rechts wordt de menu-controller node gevoed met de output van een teller, gevoed door een "clock" node. Maar dit kan elke interne gegevenswaarde zijn, of een externe waarde van bijvoorbeeld een potentiometer die is aangesloten op een analoge ingang. De uitvoer van de teller wordt ook naar een knooppunt voor het formatteren van strings gestuurd en samengevoegd met wat tekst op het scherm om de huidige waarde weer te geven die door de controller wordt ontvangen op de tweede regel van het LCD-scherm, wanneer die menupagina wordt geopend.

De "aangeroepen" en "param"-uitgangen van bladmenu "A" worden verzonden naar een "buffer"-knooppunt van de XOD-standaardbibliotheek. De uitvoer van de buffer wordt vervolgens teruggestuurd naar een vergelijkbare opstelling als voorheen, behalve het "defer" -knooppunt, dat nodig is om eventuele feedbacklussen in XOD-schetsen te verbreken. De waarde die in de buffer is opgeslagen, wordt weergegeven op de eerste regel van het LCD-scherm.

Wanneer het menu-controllerknooppunt een "invoke"-triggerpuls van de toetsenbordcontroller ontvangt, voert het A-out-knooppunt de parameterinvoerwaarde uit van de menu-controller daar, in dit geval de tegenstroomwaarde, en een "aangeroepen" trigger puls die de update-routine van de buffer activeert en de nieuwe parameter de buffer opslaat. Het display wordt vervolgens automatisch bijgewerkt om de nieuw opgeslagen waarde weer te geven.

De uitvoerpoort van de buffer kan dan ook naar een willekeurig aantal andere knooppunten worden gerouteerd om hun gedrag te wijzigen om de nieuwe gegevenswaarde weer te geven die de gebruiker heeft geselecteerd:

Geen voorbeeld (alleen downloaden).