Een sketch in Processing: zelf geschreven grafische weergave met Arduino

[bask185]

Toen ik me had bedacht dat ik een volledig arduino gestuurde trein baan wilde hebben, bedacht ik me ook dat het leuk zou zijn om er een grafische laagje op een computer toe te voegen aan het geheel. Toen zei ik: "ik ga dat niet zelf maken niet, er bestaat al goede software voor, het kost veel tijd blabla "

Nu 2 weekjes later ben ik toch eventjes aan het spelen geweest op mijn computer. Ik had namelijk twee argumenten om het toch zelf te doen. Ik hoef A geen bestaand protocol uit te pluizen en te implementeren en B het is rete leuk om te maken.

Dus zo doende heb ik gemaakt in Processing:

Een zelf geschreven trein programma!!!

Processing is een op java gebasseerd taaltje waarmee je grafische dingetjes kan doen op de computer. Je kan van alles doen van beeldbewerkingssoftware tot pacman en space invader tot trein programma's. De IDE lijkt heel sterk op de Arduino IDE. Het is ook door dezelfde mensen gemaakt. Veel functies van arduino werken ook in processing zoals millis(), print(), println(), write() etc. Ik vind het zelf een erg fijne taal omdat het object georiënteerd is en niet alleen event-based is zoals meeste GUI software zoals C# of Qt. In processing kan je gemakkelijk gebruik maken van je muis en toetsenbord. Daar zijn allemaal bestaande functies voor met een makkelijke syntax.

Wat het programma kan:
Op het moment niet zo veel. Ik kan op 1 van de 5 objecten aan de rechter zijde klikken en slepen naar een locatie. Met de pijltjes toetsen kan ik het object dan draaien en met delete kan ik het object verwijderen. Eenmaal geplaatst kan ik hem nog verslepen of verwijderen. Met de wasd toetsen kan ik alle object verplaatsen met 1 vakje. Ik was ook nog bezig met het in en uit zoomen maar de objecten wilden nog niet helemaal meewerken.....

Wat het programma moet gaan kunnen:
Processing is in staat om onder andere serieel te communiceren met USB apparaten zoals bijvoorbeeld een arduino. Het programma zal o.a. dienen als terminal. Ik kan op een wissel klikken of op een nog te maken knop die gelinkt is aan een geheugen object en zo kan ik dan 1 wissel of een hele straat schakelen. Bezetmelders (de groene bollen) krijgen een andere kleur als arduino's informatie opsturen. Met een zelf ontworpen protocol (zo simpel als mogelijk) kan ik samengevat de baan aansturen en displayen wat er gebeurt. Als ik een wissel met de hand schakel dan zal ook dit te zien zijn in het programma.

Om niet telkens je getekende baan kwijt te raken, komt er een 'save' en een 'load' knop. Bij het starten van het programma kunnen dan alle gegevens opgehaald worden uit een tekst bestandje en je bent klaar om te rijden.

Als deze basis af is, volgen de meer geavanceerde functionaliteiten zoals een rijregelaar voor treinen, een menu om instructielijsten aan te maken waarmee je bijvoorbeeld een trein kan laten pendelen of een wagonstam kan weg rangeren en de aller grootste uitdaging iets van een route planner en trein begeleiding maken zodat treinen niet op elkaar kunnen botsen.

Het leek me leuk voor degene die dit wel interessant lijken om van de ontwikkeling van dit programma af en toe een update te geven. Doordeweeks kan ik altijd wel een paar uurtjes in de avonden vinden om er aan te werken dus ik verwacht frequente updates te posten.

Bas

[TrixExpress]

Hallo Bas,

Is inderdaad heel er leuk om je eigen treinbesturings programma te maken. Ik ben daar ongeveer al 12 jaar mee bezig. Af en toe de baan weer veranderen en het treinbesturings programma aanpassen.
https://forum.beneluxspoor.net/index.php?topic=87055.0

Groet, Fred

[bask185]

Het ziet er wel leuk wat je gemaakt heb, Fred. Ik ben programmeur van beroep maar ik heb nog nooit van clipper gehoord. Moet wel voor mijn tijd zijn 


Ik ben zelf een heleboel opgeschoten met mijn programma.
Ik kan nu:
- layout opslaan en laden bij start up
- wissels toevoegen aan de (rode) geheugen cellen (wordt ook onthouden)
- wissels en geheugen cellen schakelen.
- ID's toekennen aan memory cellen, wissels en detectoren (<- deze laatste worden echter nog niet getoond)

De afbeelding is de layout van mijn baan. Ik heb de geheugen cellen dusdanig ingesteld dat alle relevante wissels altijd naar dat spoor wijzen. Omdat ik me absoluut niet ga wennen tot een route calculator en omdat ik ook niet werk met bloksystemen gebruik ik mijn memory cellen om gehele routes met 1 klik te schakelen.

De ID's van wissels, memory cellen en Detectors komen overeen met fysieke componenten van de baan. De memory cellen en detectoren zijn aanwezig op de schakel panelen die ik maak. Detectors bestaan uit een led en een memory bestaat uit een druk schakelaar. Ik kan dus in zowel programma als op schakelpanelen, hele wisselstraten schakelen en ik zie de status van de detectors. Het programma heeft als extra feature dat ik individuele wissels ook kan schakelen, maar ik verwacht dat eigenlijk nooit nodig te hebben.

Voor de treinregeling had ik bedacht om een truukje van m'n werk toe te passen. Op de HMI's hebben we op het hoofd programma een zogenaamde SSP feature. Dat staat voor serial step programming. Operators kunnen dan zelf een lijst van instructies met parameters instellen en de machine de instructies sequentieel laten uitvoeren. Op soort gelijke wijze wil ik de treinen aan sturen. Dat komt er ongeveer zo uit te zien:

     activate(M1)                         (activeer memory cel 1 en daarmee wordt een hele wissel straat geschakeled
-> trainX drive(200, forward)      (laat 'trainX' naar voren rijden met snelheid 200)
     wait(D25)                             (wacht tot Detector 25 is getriggered)
     trainX drive(100, forward)      (reduceer snelheid naar 100)
     wait(D26)                             (wacht tot detector 26 is getriggered)
     trainX stop                            (stopt 'trainX')
     trigger(C1)                           (activeert ontkoppelrail voor korte tijd)
     delay(2s)                              (wacht 2s)               
     trainX drive(reverse,50)         ( rij achteruit met snelheid 50)
     trainX stop                            (stopt 'trainX')
     trainX(F1)                             (toeter)

     delay(15s)                            (wacht 15 seconde)
     trainY drive(200, reverse)      (laat 'trainY' achteruit rijden met snelheid 200)
     ...
     ... etc
     ...
     goto line #1                          (begin opnieuw)

Ik wil dan ook de mogelijkheid inbouwen om de routine te onderbreken zodat ik zelf even een goederen trein kan verplaatsen. Alle trein functies zullen ook bedienbaar blijven. Ik wacht op het moment op mijn arduino's en onderdelen zodat ik alle componenten kan aansluiten op de baan zelf.

De volgende stap is om het Arduino programma te schrijven en de seriele communicatie op te zetten. Gelukkig is de syntax van Processing 1 op 1 met die van Arduino. De arduino's wil ik de optie geven om de componenten in te leren. Informatie over de geheugen cellen, wissels en detectoren kan ik via mijn Processing programma opsturen, maar ik dan nog extra informatie toevoegen. Ik moet weten aan welke I/O pin een component is aangesloten en of het een I2C extender I/O pin is.

De arduino's moeten slechts 2 dingen doen. Toetsaanslagen aan railbezetmeldingen doorgeven aan de centrale en ze moeten luisteren naar instructies om wissels aan te sturen. Het oorspronkelijke idee was om de wisselstraten e.d. vast te leggen in het EEPROM van de arduino's opdat ze dan zonder de centrale zelf wissels kunnen schakelen, maar omdat de centrale voor de weergave toch informatie moet hebben over alles en omdat een schakelpaneel ook invloed heeft op wissels elders in het systeem. Is het makkelijk om de centrale te laten bepalen welke wissels er geschakeld moeten worden.

Ik heb verder nog een paar kleine details af te handelen waaronder:
- Einde van rail component aan maken voor een mooiere weergave bij doodlopende sporen
- kruiswissel component maken (een normale wissel is niet nodig omdat ik per toeval 2 lijnen over elkaar kan laten tekenen)
- optionele lijntjes toe voegen aan de Memory blokken zodat ze netjes in de rails passen.
- ontkoppelrail componenten maken.

Tot zover mijn Processing sketch

Bas

[TrixExpress]

Het ziet er wel leuk wat je gemaakt heb, Fred. Ik ben programmeur van beroep maar ik heb nog nooit van clipper gehoord. Moet wel voor mijn tijd zijn 

Nog nooit van Clipper gehoord? Kijk even hier http://www.alaska-software.com/products/overview.cxp
Bringing the power of native code and no-limits to the Clipper and Visual FoxPro xBase language dialects.

Groet, Fred