BeneluxSpoor.net forum
Vraag en antwoord => Digitaal => Topic gestart door: GP20 op 02 oktober 2018, 23:57:06
-
Hallo,
Na een aantal jaren en de verkoop van al mijn modeltreinspullen ben ik voorzichtig aan het herstarten.
Ik kan over een paar jaar pas beginnen, er komt dan een kamer vrij in huis, met het daadwerkelijk bouwen van een layout maar voor nu is het maken van een DCC++ base station en een draadloze throttle de invulling van de hobby. Ik heb nu 2x flexrail, een EMD GP20 en 2 wagons als materieel, schaal H0.
Ik moet zeggen dat ik er nu al veel lol aan beleef, ik pas de code voor de throttle aan en probeer die helemaal te doorgronden.
Zijn hier meer mensen op het forum die zich bezighouden met DCC++ en het programmeren met Arduino?
Dit is voorlopig mijn "layout".
(http://i67.tinypic.com/jqhz5k.jpg)
mvg,
Leo
-
Precies dit wil ik ook nog gaan doen. Aanvullend wil ik de Arduino ook gebruiken om Servo's aan te sturen voor wissels. Dan maak ik een paneel met mn opstelsporen met knoppen er in, en dan kan ik een spoor selecteren en worden de wissels geschakeld. Ik had ontdekt dat je met een decade counter 10 servo's met 1 I/O kan aansturen. http://rcarduino.blogspot.com/2012/08/arduino-serial-servos.html Of je koopt een aparte DCC servo module, hoef je het niet zelf te doen ;)
Wat misschien wel beter is, is om een encoder te gebruiken ipv een potmeter. Vroegah kon je met een marklin control unit 6021 een adres in tikken dan moest je een paar seconde wachten en pas daarna kon je je loc bedienen. Deze unit had dan ook een 120 graden knop. En dat was nodig om te voorkomen dat de loc meteen zou reageren op de huidige stand van de knop. Dan had je eerst tijd om een snelheid te kiezen.
Als je een encoder gebruikt, kan je na het adres invoeren meteen aan de knop zitten om de snelheid aan te passen. Deze encoders kan je vaak ook indrukken en gebruiken voor een noodstop of de lichten of een toeter of een telex koppeling .... of wat jij programmeert. Ook om door menuutjes op je LCD scherm te scrollen en getallen in te voeren of de cursor verplaatsen etc, is een encoder erg handig. https://hackerstore.nl/Artikel/609
Maaarrrrr aan de andere kant. Als je wel een potmeter gebruikt, kan je een mooie wijzer knop er op zetten en dan kan je het zo doen dat knop links -> trein naar achter en knop rechts -> trein naar voren. Maar het is net wat je wilt doen.
Ik weet dat je met zo'n toetsenmatrix best wel wat I/O nodig heb. Daar kan je een I2C I/O expander voor gebruiken, maaarrr... Je kan hem ook analoog inlezen. Door weerstandjes in de kolommen en rijen te plaatsen, kan je door je waardes slim te kiezen, elke knop een andere spanning laten afgeven. https://www.youtube.com/watch?v=N39EXI_F8uA. Werkt als een zonnetje.
Zoals je weet hangen veel mensen hun DCC ding aan een computer en dan kan je rijden met je computer en die computer kan dan je hele bloksysteem regelen. Natuurlijk kan je met een arduino ook dat allemaal zelf doen. Ik heb dit nooit uitgedacht, maar je kan dmv schakelrails, IR lichtsluisjes en diodes + weerstanden + condenstators (weerstandsdeling voor spanning onder de 5V, diode om enkelzijdig gelijk te richten en condensator om het een beetje af te vlakken) de treindetectie realiseren. Je moet alleen handmatig invullen waar welke trein is op het moment van inschakelen. Bij het wisselen van baanvlak van een trein, zou je een eeprom oid kunnen gebruiken om continu in je geheugen vast te leggen waar welke trein is, hoe hard deze trein rijdt en welke functies er geschakeld zijn (en ook hoe de wissels stonden ;) ). Ik zelf rij nog steeds met relaisschakelingen, maar als ik ooit baanvlakken zou willen.... dan of arduino of Rpi.
Ik kon niet goed zien wat voor H brug shield ding je hebt. Maar je moet ongeveer 1A~1.5A per trein rekenen. Je kan H-bruggen parallel zetten en er is ook ergens een 43A H brug op de markt. https://hackerstore.nl/Artikel/1144 of als je baanvlakken heb, gebruik je deze https://hackerstore.nl/Artikel/816 per baanvlak. Reden dat je een H-brug per baanvlak wilt hebben is dat je dan tevens ook current sensing beschikbaar heb op de H brug.
En als je slim bent en je programmeert je arduinootje een beetje proper, dan kan je ook analoge treinen op je baan zetten. Je arduino moet natuurlijk weten dat de trein in kwestie analoog is, maar arduino kan dan ipv DCC signalen op een baanvlak, een PWM signaal op het baanvlak zetten en een analoog treintje aansturen. Maar dat is allemaal optioneel ;) zo doen ze het wel bij mij op de club.
Maar 1 ding wat zeker is. Zelfbouw arduino > Uhlenbrock > CS3 > elke andere digitale trein controller
-
Bedankt voor je enthousiaste reactie ;)!
Wat je op de foto ziet is eigenlijk wel wat ik heb op het moment dus ik kan nog alle kanten op.
Ik heb voor een potmeter gekozen vanwege de absolute stand en dus idd een pijltje op de (toekomstige) knop om te zien hoe het spul staat ingesteld.
Met de * toets kun je het locadres instellen en met de # toets kun je de loc selecteren, max 4 locs in te stellen.
De volgende stap is om een bediening voor een wissel of 10-15 te maken, ook met Arduino dus ik ga je links zeker doornemen!
Verder wil ik een branch line maken met een graansilo en een loods/brouwerij dus baanvakken, detectie, seinen etc allemaal niet van toepassing.
Gewoon lekker rondtuffen met snelheid 15-25 met een paar wagons (3-5) erachter en rangeren bij de silo en de loods/brouwerij.
Het wordt een end to end layout met dus silo en loods/brouwerij en staging naar zogenaamd de main track.
Er komen 2 throttles uiteindelijk dus max. 2 locos in beweging.
Ook moet er nog een oplossing komen voor een keerdriehoek, deze zal zonder kortsluiting moeten werken ivm digitaal en omdat ik sowieso geen kortsluiting wil ivm slijtage van rails en wielen en misschien wel elektronica.
Er zit nog 1 bekende bug in de software, niet desastreus maar wel hinderlijk, die er hopelijk nog uit geprogrammeerd kan worden.
Als ik een functie kies dan hoor je de luchthorn. Als je de luchthorn kiest en die tijdens het geluid weer uitzet dan kun je andere functies kiezen zonder dat je de luchthorn hoort. Ik heb nog geen idee hoe dat komt, het keypad gedeelte van de code heb ik nog niet echt goed bekeken.
Tot nu toe heb ik een instelbare dead band gemaakt (potmeter was wel heel gevoelig tussen voor- en achteruit) een instelbare topsnelheid met gebruik van de hele potmeterslag en een noodstopfunctie.
Er moeten nog in:
zender voor draadloze communicatie naar het DCC++ station. (HC-12 modules, aliexpress)
batterij (aliexpress)
kast (er omheen) (zelf uit triplex maken, 3D printen is zo duur)
Ik dacht zelf aan een shift register (misschien is dat wel een decade counter, ben geen elektronicus) om de wissels aan te sturen. Dan schrijf je iedere keer het register vol hoe je het spul wilt hebben staan en dan schiet je ineens de stand aan alle wissels door. Ik denk nu aan het het gebruik van modelbouw servos om de wissels te bedienen. Maar ik heb nog niets met shift registers gedaan anders dan er een paar te bestellen om te testen. Ik vermoed dat dit een beetje hetzelfde is als wat jij voorstelde.
Ik denk dat ik een loop schrijf in de "wisselarduino" die in de gaten houdt of er een knop ingedrukt wordt en zo ja dan in een aparte functie het register volschrijft en dan laat aansturen. Maar dat moet ik allemaal nog uitzoeken.
-
Zijn hier meer mensen op het forum die zich bezighouden met DCC++ en het programmeren met Arduino?
Ja, ik ben ook begonnen met DCC++ op een Arduino met motorcontroller (http://www.clubncaldes.com/2016/02/build-your-own-dcc-command-station-for-8.html) te zetten en de programma's Decoderpro en Panelpro van JMRI (http://www.clubncaldes.com/2016/02/build-your-own-dcc-command-station-for-8.html) op een laptop. Dat ging allemaal goed, maar veel verder ben ik nog niet gekomen. De programma's hiervoor bestaan allemaal al, dat wiel hoef je niet meer uit te vinden.
Mijn 'probleem' is dat ik al vanaf de jaren '80 bezig ben met mijn eigen systeem (https://forum.beneluxspoor.net/index.php?topic=70904.0) en om dat nu allemaal aan de kant te zetten vind ik een grote stap, maar ik zit nu wel met een naar huidige normen achterhaald systeem. Noem het maar de wet van remmende voorsprong...
Ik heb overigens ook nog geen locs met decoder om het uit te proberen, binnenkort maar eens een goedkope decoder ergens inbouwen.
-
Hoi,
Ja dat is waar maar ik heb graag een zo'n eenvoudig mogelijke regelaar die een beetje naar mijn zin gemaakt is en waarmee ik kan lopen tussen de baan op de kamer en de staging op de overloop van de zolder.
Het is fijner om naar de baan te kijken en dan aan een knop te draaien dan op een scherm een slider te moeten bewegen die het niet doet als de cursor niet precies op de juiste plek op het scherm staat. Dat is nu al lastig op een flexrail die naast me ligt.
JMRI is geprobeerd, is een erg mooi pakket maar een overkill voor mijn wensen en er is vast een externe controller te gebruiken of te maken maar niet voor mij.
Decoder wordt hier geprogrammeerd met controller 1.1.0 dat via processing loopt. (hoe het werkt is me onbekend maar ik kan het gebruiken)
EDIT: Controller kan ook de decoder values uitlezen.
In de layoutkamer komt geen PC of laptop, dit scheelt veel ruimte en vooral een hoop geld. Het programmeren gebeurt dan bij de huis pc op een testbaantje/flexrail.
(Ik gebruik overigens een Deek-robot motorshield, was volgens mij een vraag van bask185)
Dit is mijn eerste digitale loc en ik zou niet meer anders willen. Het geluid (motor, bell en horn) vind ik ook erg leuk maar dat bepaalt ieder voor zich natuurlijk.
Dit zijn de uitgangspunten geweest bij het maken van de throttle:
http://trainelectronics.com/DCC_Arduino/DCC++/Throttle/#Rotary_Encoder_in_place_of_Potentiometer
https://www.youtube.com/watch?v=SCenXWQqbtU
Dave Bodnar is heel benaderbaar en reageert ook op mails.
De DCC++ code is ongewijzigd en er zijn geen plannen om deze te wijzigen.
-
Hoi,
... draaien dan op een scherm een slider te moeten bewegen die het niet doet als de cursor niet precies op de juiste plek op het scherm staat.
Dit is de samenvatting van een M* CS 2. Touch screen pakte nooit bij een noodstop...
...1.1.0 dat via processing loopt. (hoe het werkt is me onbekend maar ik kan het gebruiken)
Decoder kan ook de decoder values uitlezen.
Processing is leuk. Als je arduino kan, kan je ook processing. Als je eenmaal de classes snapt, super fijn programma.
Dit is mijn eerste digitale loc en ik zou niet meer anders willen. Het geluid (motor, bell en horn) vind ik ook erg leuk maar dat bepaalt ieder voor zich natuurlijk.
Ik herinner mijn eerste loc met sound, M* 37460 :angel: Ik had ontdekt als je 3 locs met geluid heb, je er niet meer wilt. Erg veel herrie. Toen ik traxxen ging kopen ging mijn voorkeur uit naar kwantiteit boven kwaliteit. Traxx kost rond de €100,- en ik heb er nu iets van 20.
Dit zijn de uitgangspunten geweest bij het maken van de throttle:
http://trainelectronics.com/DCC_Arduino/DCC++/Throttle/#Rotary_Encoder_in_place_of_Potentiometer
https://www.youtube.com/watch?v=SCenXWQqbtU
Dave Bodnar is heel benaderbaar en reageert ook op mails.
De DCC++ code is ongewijzigd en er zijn geen plannen om deze te wijzigen.
Ziet er wel leuk uit. Je hebt als alternatief voor je keypad: https://hackerstore.nl/Artikel/515 Deze is gevoeliger dan de membraan versie en je kan hem uitlezen over de I2C bus. Mijn arduino wekker heeft ook een membraan keypad en ik vind het net ff te onpraktisch. Ik moet de hele wekker vastpakken anders duw ik hem weg. Maar als je je controller al vast heb, maakte het weinig uit.
Als je je handcontroller ontwerpt, let dan heel erg goed op de layout en de praktische werking. En ga echt de werking na in je hoofd. Zorg er voor dat je makkelijk van trein kan wisselen en 1 hand besturing is ook erg fijn. Ik weet nog dat ik een M* MS1 een kwartslag moest draaien dan kon ik hem precies goed met mn duim bedienen (y). Iets wat roco wel redelijk goed heeft gedaan https://www.youtube.com/watch?v=5PFe1sxSjTg
-
... een zo'n eenvoudig mogelijke regelaar die een beetje naar mijn zin gemaakt is en waarmee ik kan lopen tussen de baan op de kamer en ...
JMRI heeft een 'Engine Driver' app (https://enginedriver.mstevetodd.com/) op een mobiele telefoon, draadloos, via wifi, ook voor iphone (http://www.withrottle.com/html/home.html).
-
Random Smartphone valt niet onder het kopje: "Naar mijn zin gemaakt" :police:
-
Random Smartphone valt niet onder het kopje: "Naar mijn zin gemaakt" :police:
Dat is belangrijkste reden, bovendien heb ik een iPhone. (Dat is met dit soort zaken vaak een nadeel) Ow, niet goed gelezen, staat ook voor iPhone :)!
-
Ooit heb ik een Arduino library gemaakt en ben ik zelf een aansturing gaan maken. Draadloos moet het zijn en heb toen dit gemaakt:
https://youtu.be/QuUVnX9iCq8
https://youtu.be/2jR-PLJi_-A
https://youtu.be/UV_wnTEDIMw
Gemaakt op basis van twee Arduino pro mini's met communicatie via een stel nrf24 nog iets 2,4Ghz module voor draadloos communiceren. Verder een Rotary encoder voor de bediening, een 1,8 inch kleuren display voor weergave en een accu met omvormer en laad circuit. Helaas nooit helemaal afgemaakt, maar het heeft wel gewerkt.
-
Ziet er mooi uit.
Ik bedacht vanavond nog een functie die ik graag zou willen toevoegen t.w. een drukknop die de snelheid direct naar nul brengt als ik bij het rangeren op het juiste punt ben beland met de loc, dan heb ik ook niet het risico dat ik per ongeluk de andere kant op draai. Daarvoor alleen al zou een encoder ook makkelijker zijn wat betreft de code en ik wil ook geen gedonder met denderen (haha) met de weerstand.
-
Ooit heb ik een Arduino library gemaakt en ben ik zelf een aansturing gaan maken. Draadloos moet het zijn en heb toen dit gemaakt:
https://youtu.be/QuUVnX9iCq8
https://youtu.be/2jR-PLJi_-A
https://youtu.be/UV_wnTEDIMw
Gemaakt op basis van twee Arduino pro mini's met communicatie via een stel nrf24 nog iets 2,4Ghz module voor draadloos communiceren. Verder een Rotary encoder voor de bediening, een 1,8 inch kleuren display voor weergave en een accu met omvormer en laad circuit. Helaas nooit helemaal afgemaakt, maar het heeft wel gewerkt.
Ziet er leuk uit. Je moet naar mijn mening wel veel halen met je vinger doen om een trein op volle snelheid te krijgen, zelfs met hoge snelheid is het nog 6 haaltjes. Dat is ook #1 reden waarom ik anti CS-2 ben geworden. Maar da's ook maar een fine-tuning ding. Je hebt wel een mooi scherm gekozen. Ik zit dit wel eens uitgevoerd met een 16x2 LCD scherm, maar dat vind ik dan net niks.
Het leek me ook wel interessant om een soort afneembaar of remote display te nemen. Display heb je eigenlijk voornamelijk nodig om CV's in te stellen en nieuwe locs in te voeren. Maar buiten dat om hoef je alleen maar het loc adres te kunnen zien, geschakelde functies kan je met led knoppen aantonen.
Het lijkt mij echt leuk om dan een rangeerterrein te automatiseren, en om locs automatisch naar de andere kant van de trein de laten rijden over een terugloop spoor. (y)
-
Omdat je dingen zelf programmeert kan je natuurlijk ervoor zorgen dat een langere draai grotere stappen gaat maken en zo er dus voor zorgen dat je met één draai naar volle snelheid kunt gaan.
-
Beste Bask 185,
Zijn hier meer mensen op het forum die zich bezighouden met DCC++ en het programmeren met Arduino?
Ik hed je reactie met veel intresse gelezen en was blij verrast met de de link naar de motorcontroller.
Deze controller heb ik overgehouden uit een ander project, maar krijg deze in DCC++ niet goed aan de gang.
Heb jij mogelijk een schema ervan hoe de Arduino aan de controller is veronden?
Alvast bedankt.
-
Deze site legt een hele boel uit: http://www.trainelectronics.com/DCC_Arduino/controller.htm Hier gebruikt hij een andere H brug IC, werking is wel hetzelfde.
Op deze site wordt er die 43A versie gebruikt: http://www.trainelectronics.com/DCC_Arduino/DCC++/index.htm
Hij gebruikt een iets andere IC maar de werking is het zelfde. Het helpt ook als je snapt hoe het DCC protocol er elektrisch gezien uitziet, dan snap je namelijk hoe je je H-brug moet aansturen. Gelukkig hebben we ook nog DCC wiki: https://dccwiki.com/Introduction_to_DCC#Electrically.2C_How_Does_DCC_Work.3F
De samenvatting: de spanning tussen linker en rechter rail wisselt tussen 0 en +18V. Als de linker rail 0V is dan is de rechter rail 18V. En als links 18V wordt, dan wordt rechts 0V. Als je dit gaat doen met een H-brug dan zet je op Vin 18V voor de spanning. De rails sluit je op 1 van de 2 motor uitgangen aan (een H-brug kan typisch 2 motoren aansturen, maar we gebruiken er dus 1). Op het pwm signaal zet je een logische '1' (dus geen pwm signaal) van je arduino. Dan gaat een rail op 0 volt en de andere rail op 18V. Door de direction pin hoog te maken, wordt de polariteit (blijft wel tussen 0 en +18v, dus niet -18V zoals bij M*) gewisseld. Dan wordt de ene rail 18V en de andere 0V.
Door met de juiste intervallen deze motor direction pin van staat te wisselen, kan je dus de digitale signalen op de baan zetten. Een lange tijd is een '0' en een korte tijd is een '1'.
Als je meer 'sap' nodig heb (je H brug wordt te heet), kan je meerdere H-bruggen parallel zetten. Of je gebuikt de 43A H brug. Er moet ook een current sense pin op de H brug zitten. Deze moet je gebruiken om kortsluiting of overbelasting te detecteren.
toevoeging: als je kortsluiting heb, zet dan een logische '0' op de pwm pin op de H-brug, dan staat 0V op beide rails
-
Update:
Heb inmiddels de potmeter vervangen door een encoder, heeft wat moeite gekost. De encoder code werkte bij mij niet. Ik heb daarom een code van de Arduino pagina afgehaald en die in een nieuwe DCC++ Throttle sketch verwerkt.
Noodstop werkt ook voor zover mogelijk, loc wordt stilgezet en ingestelde snelheid op 0. De baanspanning gaat ook op 0. Door het laatste zullen de locs direct stilstaan, dat is nodig want een eventuele 2e Throttle kan ik niet direct beinvloeden vanuit de andere Throttle. (of ze moeten heen en weer kunnen praten maar da's een ander project)
Ik wil nog een functie inbouwen dat als ik rangeer ik een knop kan induwen om de loc direct stil te zetten (niet de noodstop maar meer een "rangeerstop").
Daarom zou ik graag het DCC commando weten van de STOP knop in de rijregelaar van JMRI.
Kan iemand me daaraan helpen?
Het zou een dergelijk commando moeten zijn <t1 3 0 1> Het is alleen zo dat met letterlijk dit commando de loc uitrolt en niet direct stopt.
EDIT:
Denk dat ik hem heb: <t1 3 -1 0of1>
morgen testen, vanavond geen tijd helaas.
-
Ik kan weinig informatie over precies dit puntje vinden. Ik heb deze doorgelezen
http://www.modelspoorh0.nl/downloads/ESU%20Lokprogrammer%20Versie%20271.pdf
http://www.esu.eu/uploads/tx_esudownloads/51982_LokPilot_V40_Family_ESUKG_EN_User-manual_Edition_3_eBook.pdf
Er is ook een universeel E-stop commando waar alle locs op reageren maar dat willen we natuurlijk niet. En dit kon ik ook ff niet vinden
Ik weet dat ik bij mijn M* een trein meteen kan stoppen als ik van rijrichting wissel. Ik weet niet of daarvoor ook nog een aparte E-stop instructie wordt gestuurd.
Voor zover ik weet, hebben nagenoeg alle decoders die optrek- en remvertraging, ook een schakelbare functie die dit uit zet. Deze is, dacht ik, standaard actief. Dan luistert je loc direct naar je regelaar. Bij esu lopi V4 is het F4. Ik weet niet of dit uitkomst voor je biedt?
(https://i.imgur.com/eTbwp8t.png)
-
O.o ik heb iets gevonden:
http://web.archive.org/web/20091027154943/http://www.geocities.com/OzDCC/dcctut02.htm
Baseline Packets
There are many types of packets used in a DCC system but for the moment we will only look at what are called the Baseline Packets. Compliance with these packets is mandatory in a DCC system which means that all Command Stations and Decoders must use or recognise them. There are many other optional packets and these are described in the Extended Packet and the Service Mode Recommended Practices. The optional packets will be discussed in future articles. In the packet examples given below the bit values 1 and 0 are mandatory for that type of packet whilst bit values such as A, D, E etc are alterable values for that packet which are defined in the text.
Speed & Direction Packet for Mobile Receivers
1111111111 0 0AAAAAAA 0 01DUSSSS 0 EEEEEEEE 1
Preamble Address Byte Data Byte Error Byte
The address byte contains the binary address that can be from 0 to 127depending on the value of "AAAAAAA". It is permissible for command stations to address a reduced range of addresses, some have as little as eight addresses but more commonly ninety-nine. The zero at the start of the byte allows address space for other non compulsory packets such as those for accessory control.
The data byte starts with the bits "01" again to allow space for non compulsory packets such as function control (lights, bells, couplers etc). The next bit (bit 5 labelled D) provides for direction, "1" indicates move forward, "0" reverse. Bit 4, called the "U bit", is undefined in the baseline standard and was originally used by Lenz for headlights but is now used as the least significant bit for 28 speed control.
The speed control, bits 0 - 4 and labelled SSSS, allow for sixteen values. The first, "0000", is a Stop command. Emergency stop has the value "0001" while the rest of the values from "0010" to "1111" are the speed steps 1 to 14. Hence the fourteen speeds of the baseline DCC system.
A Stop command utilises any programmed inertia whereas the Emergency Stop brings the loco to an immediate undignified halt
-
Bedankt voor het meedenken.
De emergencystop heb ik zo gemaakt: hier worden alle aanwezige locadressen aangestuurd.
void emergencyStop(){
// int xxx = 0;
for (int xyz = 0; xyz <= maxLocos - 1; xyz++) { // do this to make sure every loco keeps stationary after restarting the layout
LocoAddress[xyz] = EEPROM.read(xyz * 2) * 256;
LocoAddress[xyz] = LocoAddress[xyz] + EEPROM.read(xyz * 2 + 1);
Serial.print("<t1 ");
Serial.print(LocoAddress[xyz] ); // locoID);
Serial.print(" ");
Serial.print(LocoSpeed[LocoAddress[xyz]] = -1 );
Serial.print(" ");
Serial.print(LocoDirection[LocoAddress[xyz]] );
Serial.write(">");
}
LocoSpeed[ActiveAddress] = 0;
rotaryHalfSteps = 0;
actualRotaryTicks = 0;
doMainLCD();
delay(50); // give some time to write the DCC command to the base station before shutting off the power
//Serial.print("<0>");
}
De rangeerstop werkt alleen voor de actieve loc en ziet er zo uit: (Omdat de digitale pinnen allemaal gebruikt zijn deze functie op een analoge ingang gezet)
switchValue = analogRead(switchPin);
if (switchValue > 512) {
Serial.print("<t1 ");
Serial.print(LocoAddress[ActiveAddress] ); // locoID);
Serial.print(" ");
Serial.print(LocoSpeed[ActiveAddress] = -1 );
Serial.print(" ");
Serial.print(LocoDirection[ActiveAddress] );
Serial.write(">");
LocoSpeed[ActiveAddress] = 0;
rotaryHalfSteps = 0;
actualRotaryTicks = 0;
doMainLCD();
delay(50); // give some time to write the DCC command to the base station before doing something else
-
Als je alle locs wilt aansturen was het geloof ik ook mogelijk om dcc adres 0 te gebruiken. Dit werkt enkel voor snelheid commando's.
-
Ik spot per toeval een foutje in je code.
Je wilt een digitaal signaal (5V) inlezen in een analoge pin. Dat kan, maar je moet wel digitalRead(switchPin) gebruiken. analogRead() stuurt namelijk een 10 bits getal teurg. Bij 5V houdt dat in dat het getal 1023 in switchValue wordt geladen, terwijl je hier een 1 in wilt hebben.
Als je switchValue declareert (aanmaakt) als een 'bool' ipv een 'int' of een 'byte' dan geeft de compiler misschien een foutmelding omdat je geen 1023 in een boolean zou moeten kunnen stoppen.
-
Daarom staat er bij if > 512 (dus 1023 en dat is groter dan 512, had bijna ieder ander getal kunnen zijn maar ligt lekker in het midden), kleiner dan 512 is 0.
Het werkt nu goed maar ik kan het misschien verfraaien met een digitalRead. Ook wil ik het nog in een aparte functie gieten, dan is het consistent met de rest van de code. Alles in de void loop behalve dit roept nu een functie aan.
Bedankt voor de check.
Ik kan overigens de fout met de horn in de code niet ontdekken (F2 op de keypad).
Ik denk erover om een timer in de code te zetten die binnen de standaard tijd van een seconde of 10 denk ik, nogmaals het commande geeft en het dan "geforceerd" stopt. Hopelijk blijven de andere commando's dan zuiver.
Als je alle locs wilt aansturen was het geloof ik ook mogelijk om dcc adres 0 te gebruiken. Dit werkt enkel voor snelheid commando's.
Die ga ik ook testen!
Kan je hier trouwens een filmpje direct op het forum plaatsen? of moet dat via YT?
-
Je kan alleen een YouTube filmpje hier delen.
-
Ok.
Ik heb nog een vraag over de wisselaansturing.
Als ik via de Throttle de wissels ga aansturen, dan heb ik denk ik per wissel een decoder nodig die net zoals een loc zijn signaal en energie van de rails haalt.
Als dit zo is is mijn vraag wat een wisseldecoder ongeveer kost en kun je met een wisseldecoder een servo aansturen of moet je dan een "standaard" spoeltje hebben?
Het zou fijn zijn om ook draadloos de wissels op de layout te kunnen bedienen, anders moet je steeds naar de plek toe lopen.
-
Daar zijn verschillende oplossingen voor. Zelfs op de Arduino gebaseerd: https://arduino-dcc-stationary-decoder.readthedocs.io/en/master/
Hier op het forum zijn ook wat van dit soort initiatieven geweest. Ik geloof dat één daarvan de mardec is: https://forum.beneluxspoor.net/index.php?topic=68257.15
-
En verder staat dergelijke basale informatie meestal wel in de encyclopedie.
https://encyclopedie.beneluxspoor.net/index.php?title=Wissels_digitaliseren (https://encyclopedie.beneluxspoor.net/index.php?title=Wissels_digitaliseren)
-
Hallo
aangezien je al met een Arduino aan de gang bent, zou ik in plaats van een wissel decoder hier ook een Arduino voor gebruiken. Die kan met een bibliotheek ook als decoder werken. Het voordeel is dat die dan op meerdere wissel adressen kan reageren, zodat je met een Arduino meerdere wissels kunt aansturen. Afhankelijk hoe je de wissels zelf aanstuurt, voor servo's via een PWM output, voor reguliere wisselaandrijving via een relais, bepaal je of een UNO of een Mega nodig is.
Ik kan je wel een schets hiervoor toesturen.
Groet Meino
-
Hoi @GP20 / Leo,
Welkom op het forum! Had het draadje tussen neus en lippen al gezien maar was helaas eerder te druk om te gaan zitten voor een reactie :-\
Maar ja, er zijn er wel meer met DCC bezig hier ;D Ik heb alleen zelf nog nooit met DCC++ gewerkt. Ook staat DCC op dit moment op een laag pitje. Iets met de te veel andere (microcontroller) projecten ::) Maar het blijft leuk (y)
Wat punten die ik tegen kwam in het draadje:
@bask185, een 4017 gebruiken is best slim (y) maar ik betwijfel of het de moeite waard is. Naast dat de Arduino clones al super goedkoop zijn ga je met 10 servo's makkelijk voorbij de specificatie van een 20ms verversings-cyclus. Ook is het daarmee lastig een servo af te koppelen (geen puls te sturen) wat je naar mijn idee zou willen tegen het brommen. En ze vaak heb je ook geen tien servo's bij elkaar op de baan. Want lange draden zijn echt af te raden. En waar er wel tien liggen kosten 2/3 Arduino's ook geen drol ;D Met andere woorden, geen commentaar maar denk er nog eens over voor je het maakt.
Wat betreft H-bruggen, de L298 is nog steeds de meest gangbare in de hobby wereld op dit moment. Goedkoop en een booster van 4A mee te maken. Ik wilde zeggen dat de "43A" BTS7960 wel een beetje duur en overpowered is maar ik zie dat de prijs aardig gedaald is. Zelf was ik daarom aan het kijken naar de LMD18200. Voordeel van de LMD18200 en BTS7960, ze zijn een stuk nieuwer en efficiënter (= minder verlies = minder hitte). Maar met de huidige prijs van de BTS7960 bestel ik er ook eens één ;D Dank je!
En misschien ten overvloede, digitaal hoeft niet per se 18V te zijn. 16V of 18V zijn vaak wel de spanningen die mensen/bedrijven vaak noemen maar het mag alles tussen de 7V en 22V zijn.
wordt de polariteit (blijft wel tussen 0 en +18v, dus niet -18V zoals bij M*) gewisseld.
Ligt er maar net aan waar je de referentie legt ;D Voor de loc wissels de spanning wel degelijk tussen xV en -xV. Maar vergeleken met een referentie voor de sturing (bijvoorbeeld de GND) zal je inderdaad geen 18V hebben. Maar niet alleen Marklin doet dat overigens en heet een common ground (gemeenschappelijke "aarde"*) booster waar dit H-brug booster is. Misschien was dit gesneden koek maar voor de mensen die mee lezen :angel:
En wat betreft rotary encoder, daar ben ik zelf ook een fan van! Vind een MultiMaus een fijn apparaat maar had daar zo graag een rotary encoder gezien! En vergeleken met een scherm is er geen vergelijking, op een scherm heb je geen haptische waarneming. (Ook al zijn de grote jongens er wel mee bezig) Voor encoders heb ik zelf wel eens Click Encoder (https://github.com/0xPIT/encoder/tree/arduino) gebruikt. Voordeel van deze library boven een hele hoop andere is dat de meeste overdreven de interrupt pinnen gebruiken ::) Ook ondersteund de library "acceleration/versnelling" ofwel sneller door waardes stappen als je sneller draait. Nadeel van de library, ik vind hem nogal lelijk geschreven... En het click deel is gewoon nutteloos. ::)
En analoog zo'n membraan toetsenbordje inlezen kan inderdaad mooi. Maar op zich is 8 pinnen voor 12 toetsen natuurlijk al best okay. :angel: En als je een schakelaar/drukknop matrix maakt met diodes (http://pcbheaven.com/wikipages/How_Key_Matrices_Works/) kan je ook meerdere knoppen indrukken (en dus ook schakelaars gebruiken) en ze goed lezen. Via de analoog-lezen methode is dat een stuk lastiger.
Voor wissels zou ik gewoon aanraden om wisseldecoders te maken. Grote fout van veel beginners is alles in één systeem te willen proppen. Het sleutelwoord is modulair. Maakt het geheel makkelijker te bouwen en uit te breiden. Zeker als je aan de "centrale" kant voor voor een bus gaat voor meerdere inputs. Dit kan iets als LocoNet of XpressNet wat meer gebruikt wordt maar je zou ook simpel I2C kunnen zijn als de modules naast elkaar zitten. Immers is (TTL) I2C absoluut niet geschikt voor lengte maar prima voor twee naast elkaar geplaatste Arduino's.
Ik wil nog een functie inbouwen dat als ik rangeer ik een knop kan induwen om de loc direct stil te zetten (niet de noodstop maar meer een "rangeerstop").
Veel centrales (en ook decoders dit optrek/afrem vertraging gebruiken!) doen dit als je van rijrichting wisselt. Misschien hier ook een idee? Je zou zelfs kunnen doen dat als je de encoder in drukt dat de snelheid 0 maakt. Druk je hem in als de snelheid 0 is dan wissel je van richting. Richting omwisselen op snelheid (maar goed, wanneer wil je dit afgezien van loc "noodstop" optrek/afrem vertraging) is dan twee keer klikken.
Als ik via de Throttle de wissels ga aansturen, dan heb ik denk ik per wissel een decoder nodig die net zoals een loc zijn signaal en energie van de rails haalt.
Neuh, niet per se. Je kan ook meerdere aan één decoder hangen. Een DR4018 doet er bijvoorbeeld 8. Bij gebruik van servo's wil je de kabels tussen servo en decoder wel kort houden! En bijna alle gebruikelijke decoders hebben losse ingang voor de voeding om geen "digitale stroom" op te snoepen voor wissels.
En probleem van de hoorn snap ik alleen niet helemaal. Ligt waarschijnlijk aan mij ;D Je kunt geen andere functies aansturen als je de hoorn gebruikt?
voor servo's via een PWM output
Nee hoor ;) Servo's kunnen aan elke pin. Hardnekkig misverstand maar voor servo's wordt alleen Timer1 gebruikt waardoor de PWM van pin 9 en 10 niet meer werkt. Maar heeft verder niets met de hardware PWM te maken.
Timo
* De Nederlandse term aarde is nogal verwarrend omdat wij niet zo'n mooi onderscheid maken tussen "Ground/GND" (V- referentie) en "(Protective) Earth/PE (randaarde) zoals in het Engels.
-
@timo
Nee hoor ;) Servo's kunnen aan elke pin. Hardnekkig misverstand maar voor servo's wordt alleen Timer1 gebruikt waardoor de PWM van pin 9 en 10 niet meer werkt. Maar heeft verder niets met de hardware PWM te maken.
Hoe codeer je dat in de Arduino, dat zou ik wel willen weten, want dat kan ik wel gebruiken?
Groet Meino
-
Servo myServo;
myServo.attach(A2);Met andere woorden, je kunt gewoon elke pin opgeven. De Servo library gebruikt gewoon digitalWrite().
Nu is de Servo library wel een hardware afhankelijke library dus op de niet-AVR platformen kan de implementatie dus anders zijn.
Timo
-
Bedankt voor de reacties zo ver :)!!!
Ik zou graag de wissels aansturen met de Throttle omdat ik dan onafhankelijk van waar ik sta de wissels kan bedienen, het is gewoon lekker flexibel.
Misschien luisteren naar je advies en het niet doen maar daar moet ik nog even over nadenken.
Dit omdat ik dan echt alles wat ik ga gebruiken, ik ga tenslotte een branch line uitbeelden zonder seinen en blokken en wie weet wat nog meer, in 1 bediening heb.
De staging wil ik wel met een vaste kast gaan doen maar daar sta je denk ik ook op een centraal punt en hoeft het allemaal niet zo "schaal" te zijn zeg maar, op de staging komt ook helemaal geen scenery.
Ik zou dan de void loop willen opdelen in:
void loop () {
function = digitalRead(functionPin); // dit wordt dan bediend door een bi-stabiele schakelaar
if (function == HIGH) { // edit, = naar ==
huidige code voor rijden en cab functies
}
else {
code om wissels te bedienen via hetzelfde keypad // hoe dit te coderen heb ik nog geen idee van maar is uit te zoeken
}
}
Ik zou graag 1 wisseldecoder (Uno) hebben en die met lange draden (er loopt nauwelijks stroom) een attiny45 die bij elke wissel zit aan te sturen, pin hoog of laag. De attiny stuurt op zijn buurt een kleine modelbouwservo aan. (groot nadeel is wel dat iedere wisselpositie zijn eigen stroomvoorziening van +5V moet hebben, ik kan hier niets meer doen met het DCC signaal of ik moet met een gelijkrichter en een spanningregelaar van de baan kunnen aftappen???)
Of dit wijs is hoor ik uiteraard graag, nu is er nog niets dat fout kan zijn/gaan.
-
Nouwja, het is niet gek om dat vanaf je handregelaar te doen maar doelde er meer op om de wissels niet vast (als in hardware) te maken aan de "centrale" maar dit door DCC te doen. Dat je de DCC commando's via je handregelaar geeft kan prima. Ook al heb ik zelf de voorkeur aan een tableau (of meerdere kleine op de juiste positie langs de baan). En dan heeft sturen met DCC minder meerwaarde.
Voor de code, eerst klein tipje, als je er [code][/code] omheen zet dan is het wat leesbaarder.
Daarnaast, houdt er rekening mee dat ook een schakelaar bounce kent. Hoeft niet altijd erg te zijn maar weet dat in je voorbeeld tijdens/na het schakelen je een paar keer heen en weer gaat tussen het if en de else blok. Vandaar dat ik graag gebruik maak van Bounce2 die zowel de debounce als de state change mooi en overzichtelijk voor zijn rekening neemt.
En een iets duidelijkere naam zou zijn turnoutFunction. Dan zie je gelijk wat het gewenste effect is waar je nu moet gokken.
En dan laat ik even je bug weg ;D
if (function = HIGH) {
Ik zou graag 1 wisseldecoder (Uno) hebben en die met lange draden (er loopt nauwelijks stroom) een attiny45 die bij elke wissel zit aan te sturen,
Dat is minder eenvoudig dan je misschien denkt. :police: Juist het feit dat er nauwelijks stroom loopt maakt het erg storingsgevoelig. Ook al zou je dat wel voor een groot deel in software kunnen opvangen. Voor adServo hier ook wel voor gegaan maar ter bescherming heeft iedere ingang 1k in serie. En in software negeer ik kleine pulsen. Dit lijkt wel goed te werken.
Maar dan ook de vraag heb je het nodig? Als je gewone (spoel) wisselaandrijvingen gebruikt kun je die makkelijk verlengen naar een centrale module/decoder. Gebruik je servo's is het wel een ander verhaal.
Maar ook daar, modulariteit! Vaak stuk makkelijker / overzichtelijker om twee modules te hebben met 4/8 wissels dan één met 16 door de bijbehorende chaos aan draden. En 5V mooi op elke module reguleren om storing buiten de deur te houden. Dit zou je (via een gelijkrichter) van het DCC signaal kunnen houden maar ook van de externe voeding wat überhaupt aan te raden is voor de wissels.
Maar goed, de eerste vraag is dus of je het zinvol vind dit via DCC te doen of niet. DCC is denk ik zinvol als je het vanaf je centrale / regelaar wilt doen maar heeft minder meerwaarde als je toch een tableau maakt.
En begrijp ik het goed dat je twee handregelaars wilt maken? En dan één centrale? Of hoe had je dit in je gedachten? Kan maar mij liggen dat ik het gemist heb :angel:
Timo
-
Ik wil idd uiteindelijk 2 handregelaars maken.
De bug ontgaat me nog steeds???? :)
-
De bug is het subtiele verschil tussen function = HIGH en function == HIGH ;)
En al een idee hoe je de handregelaars met elkaar / een centrale / de baan wilt verbinden?
Timo
-
Ben nu niet thuis maar volgens mij is het binnen in if statement toch een enkele =. (gecheckt, stond idd == in mijn code)
Ik heb een drietal HC-12 modules besteld voor de draadloze communicatie.
Deze rakkers, zijn inmiddels onderweg.
https://nl.aliexpress.com/item/1pcs-433Mhz-HC-12-SI4463-Wireless-Serial-Port-Module-1000m-Replace-Bluetooth-NEW/32717804563.html?spm=a2g0s.9042311.0.0.3b2d4c4dQVBFzb
En deze om de HC-12's te kunnen instellen:
https://nl.aliexpress.com/item/1PCS-CP2102-USB-2-0-to-TTL-UART-Module-6Pin-Serial-Converter-STC-Replace-FT232/32786777167.html?spm=a2g0s.9042311.0.0.3b2d4c4dmx36Ks
Nog twee stuks tweecellige lipo en een lader die via de balaceerdraden kan laden bestellen via aliexpress
-
Nee, binnen C/C++ is het eenduidig.
= voor toewijzen (assign)
== voor controleren op gelijkheid (equal to)
function = HIGH maakt function dus altijd HIGH. De uitkomst van de operatie function = HIGH is ook HIGH. HIGH != 0 en dat is het enige dat als 'false' beschouwd wordt dus het if() blok zal altijd uitgevoerd worden.
Zou je dus schrijven
if(function = LOW){
}
else{
}Zal function altijd LOW worden en daarmee 0 en zal altijd het else() blok aangeroepen worden.
Timo
-
Hoi @GP20 / Leo,
En misschien ten overvloede, digitaal hoeft niet per se 18V te zijn. 16V of 18V zijn vaak wel de spanningen die mensen/bedrijven vaak noemen maar het mag alles tussen de 7V en 22V zijn.Ligt er maar net aan waar je de referentie legt ;D Voor de loc wissels de spanning wel degelijk tussen xV en -xV. Maar vergeleken met een referentie voor de sturing (bijvoorbeeld de GND) zal je inderdaad geen 18V hebben. Maar niet alleen Marklin doet dat overigens en heet een common ground (gemeenschappelijke "aarde"*) booster waar dit H-brug booster is. Misschien was dit gesneden koek maar voor de mensen die mee lezen :angel:
Ik mag max. 15V op de baan zetten volgens MRC (leverancier/fabrikant Mantua) dus ik hou het braaf bij 15V, anders geeft de decoder de moed op.
Voor wissels zou ik gewoon aanraden om wisseldecoders te maken. Grote fout van veel beginners is alles in één systeem te willen proppen. Het sleutelwoord is modulair. Maakt het geheel makkelijker te bouwen en uit te breiden. Zeker als je aan de "centrale" kant voor voor een bus gaat voor meerdere inputs. Dit kan iets als LocoNet of XpressNet wat meer gebruikt wordt maar je zou ook simpel I2C kunnen zijn als de modules naast elkaar zitten. Immers is (TTL) I2C absoluut niet geschikt voor lengte maar prima voor twee naast elkaar geplaatste Arduino's.
Veel centrales (en ook decoders dit optrek/afrem vertraging gebruiken!) doen dit als je van rijrichting wisselt. Misschien hier ook een idee? Je zou zelfs kunnen doen dat als je de encoder in drukt dat de snelheid 0 maakt. Druk je hem in als de snelheid 0 is dan wissel je van richting. Richting omwisselen op snelheid (maar goed, wanneer wil je dit afgezien van loc "noodstop" optrek/afrem vertraging) is dan twee keer klikken.
Neuh, niet per se. Je kan ook meerdere aan één decoder hangen. Een DR4018 doet er bijvoorbeeld 8. Bij gebruik van servo's wil je de kabels tussen servo en decoder wel kort houden! En bijna alle gebruikelijke decoders hebben losse ingang voor de voeding om geen "digitale stroom" op te snoepen voor wissels.
Dit stukje moet ik nog een paar keer lezen voor ik het echt begrijp maar ik was idd van plan om de decoder knop als switchStop te gaan gebruiken, dan hou ik de functies bij elkaar en mijn hand zit toch al bij de encoderknop. Veranderen rijrichting seperate knop op de controller.
En probleem van de hoorn snap ik alleen niet helemaal. Ligt waarschijnlijk aan mij ;D Je kunt geen andere functies aansturen als je de hoorn gebruikt?
Als de hoorn klinkt kan ik wel andere functies kiezen.
Als ik de hoorn selecteer en vervolgens helemaal laat uitklinken, seconde of 8-10 schat ik, dan klinkt de hoorn daarna ook bij bijna ieder andere gekozen functie, bijv. als je de bell aanzet.
Als ik de hoorn selecteer en vervolgens binnen de 8-10 seconden weer uitzet door nogmaals te selecteren dan klinkt hij niet als ik een andere functie kies.
Ik kan in de code niet vinden waar dat aan kan liggen, ik begrijp het stukje bitread en bitwrite en key = 0 of 1 sowieso nog niet.
En de eeprom, zit die in mijn Uno of zit die in de locdecoder? (moet in Uno zijn omdat locdecoder niet kan terugpraten volgens mij)
-
15v :o Dat is erg weinig en ver te laag om binnen DCC specificatie te vallen ::) Dan moet een decoder minimaal 24V aan kunnen. Maar goed, rail voltage is een ander onderwerp 8)
Als je toch al vanaf je handregelaar wilt sturen zou ik zelf het via DCC niet zo gek vinden. Maar goed, dat hangt ook samen met hoe je meerdere regelaars wilt gaan combineren. Al enig idee hoe je dat wilt doen?
Of je probleem van de hoorn echt aan je code licht weet ik niet. Normaal zet je namelijk een geluid na de tijd ook weer uit. En nu zou het best eens de decoder kunnen zijn die het geluid opnieuw activeert als er weer een pakket langs komt waarin de hoorn aan staat ook al trigger je dat pakket door een andere functie. Functie Fl/F0 t/m F4 zitten in één pakket, F5 t/m F8, F9 t/m F12, F13 t/m F20 en F21 t/m F28 zijn elk gezamenlijke pakketten. Deze worden alleen naar de baan gestuurd als de Fx aangepast wordt.
Zo kan het dus zijn dat je F1 aan zet, pakket wordt gestuurd met de status van F0 t/m F4, hoorn gaat. En als je later nu F4 aan zet dat nu weer de het pakket van F0 t/m F4 de baan gezet wordt waar nu in staat dat zowel F1 als F4 aan is waardoor de decoder de hoorn dus ook opnieuw in gang zet.
Maar nu weet ik niet of DCC++ misschien meerdere pakketgroepen stuurt bij het aanpassen van een Fx dus het zou niet tot de groepen beperkt hoeven te blijven.
Dus misschien dat je dit eens moet testen op een bestaande centrale voordat je de code onder een vergrootglas legt. :angel:
Timo
-
Er is voor mij zoveel nieuw op dit moment dat ik er af en toe een beetje van tol.
De DCC++ centrale zet volgens mij alleen maar de bijv. <t1 3 20 1> code om in een pulstreintje op de rails. ??
Als ik de hoorn wil laten klinken dan komt commando <f 3 130> als pulstreintje op de rails. Als ik dan daarna de bel wil aanzetten zou het commando <f 3 129> moeten zijn maar blijkbaar wordt het dan <f 3 131> op een of andere manier, (128 + 1(bel) + 2(horn)).
Als het 129 is zou iedere andere functie naast de bel die aanstaat uit moeten gaan of blijven. de bel moet aan gaan. Hoe het in de code werkt als de bel al aanstaat weet ik niet, de code zou dan 128 moeten zijn als alle andere functies op dat moment ook uitstaan. Dit moet ergens in het stuk bitread en bitwrite en key moeten zitten.
Hierin staat trouwens iets over de track voltage:
http://www.modelrectifier.com/v/vspfiles/resources/modelpower/414_GP-20_DCC-Loco_Genie_Instruction_Sheet.pdf
-
Misschien is het leuk om eens te kijken wat er op de rails komt te staan? http://www.mynabay.com/dcc_monitor/ deze heb ik al eens gebruikt om een dcc accessoires decoder te maken. Ze geven ook een monitor programma die laat zien welke commando's er over de rails gaan.
-
Ow da's zeker ook een leuk project.
**** There have been several users reporting that this doesn’t work on Chinese made Arduinos ****
Hmm, mijn Chinese Uno onder het motorshield las de Rx pin niet uit, nu zit er een originele onder het DCC station en werkt het wel.
Voortaan toch maar echte kopen.
-
Mijn Chinese Arduino had er geen moeite mee om dcc te kunnen lezen via die library.
-
Gezien je een Arduino hebt die dcc praat kan je waarschijnlijk ook een Arduino aan diezelfde dcc pratende io koppelen om zo zonder verdere electronica mee te kunnen lezen ;)
-
Ah, volgens mij komt mijn gebrek aan ervaring met DCC++ om de hoek kijken ::) Ik zag op één van de links al dingen over bluethooth etc voorbij vliegen. Ik heb het niet allemaal gelezen dus wat betreft DCC++ specifieke dingen weet ik dus niets :angel:
Vandaar dat ik denk ik ook niet snap wat iets als <t1 3 20 1> is. Daar dat zeker niet op de rails staat (of dat geen standaard notatie daarvan is) maar dat het de tekst is die over de BlueTooth gestuurd wordt om de centrale bepaalde DCC commando's te laten opwekken.
Wat betekenen de delen van "<f 3 130>"? En begrijp ik het goed dat je daarmee F1 aan zet? En wat moet je sturen om F1 uit te zetten?
Wat betreft China Arduino's, deze zijn prima maar het zou kunnen dat sommige Uno's geen weerstand tussen de ATmega Rx en USB Tx hebben. (Op originele schema RN4B). Daardoor kan iets op de Arduino Rx niet over de USB chip heen schreeuwen. De Nano clones die toevallig voor me neus liggen hebben ze wel. En een Pro Mini heeft geen USB dus kan er nooit last van hebben ;D Maaruh, motorshild met Rx? ???
En over track voltage, die Loco Genie is wel een gekke eend in de bijt. Als ze volledig in spec zijn met DCC (zoals ze zeggen) moeten ze hier (https://www.nmra.org/sites/default/files/standards/sandrp/pdf/s-9.1_electrical_standards_2006.pdf) ook wel aan voldoen ::) Beetje raar dus. Maar goed, zullen niet de eerste zijn helaas.
Timo
-
... Vandaar dat ik denk ik ook niet snap wat iets als <t1 3 20 1> is. ... Wat betekenen de delen van "<f 3 130>"?
Dat is het commando dat je serieel naar het Arduino basisstation stuurt, de Arduino vertaalt dat naar de DCC pulsen op de rails, via de motor controller.
Die command string kan op veel manieren naar de Arduino: intypen in een terminalprogramma, van een (Arduino)DCC++ controller evt met Bluetooth, van JMRI's decoderPro via USB kabel, of ...
Zie hier (https://github.com/DccPlusPlus/BaseStation/wiki/Commands-for-DCCpp-BaseStation) voor de commandoset.
<t1 3 20 1>
< = start commando
t = voor locdecoder
1 = register
3 = decoderadres
20 = snelheid (0..126)
1 = richting
> = einde commando
<f 3 130>
f = voor locfunctie
3 = decoderadres
130 = byte om per bit functies F0..F4 aan/uit te zetten (128 + F1*1 + F2*2 + F3*4 + F4*8 + F0*16)
-
Gezien je een Arduino hebt die dcc praat kan je waarschijnlijk ook een Arduino aan diezelfde dcc pratende io koppelen om zo zonder verdere electronica mee te kunnen lezen ;)
Je bedoeld dat die dan via Rx de wisselcommando's ontvangt en niet via de rail? Dan hoef ik er ook geen DCC decoder van te maken.
Dan kan ik serieel bijv <01> gaan sturen om wissel 1 om te gooien. Hier reageert de DCC++ centrale dan niet op en de wisselUno wel.?
Motorshild met Rx, nee maar die pin is wel doorgekoppeld naar de Uno eronder.
-
Ahh, kijk, naar dat laatste was ik op zoek. Eerste had ik al gegokt :angel:
Ik zie zo niets geks. Een commando als "<f 3 130>" lijkt direct de te zenden pakketten te maken en dus vorige te verwijderen.
"<f 3 129>" na een "<f 3 130>" zou dus F1 moeten aanzetten en F2 uit. Maar tussen de verschillende functie groepen in ieder geval dus niet! "<f 3 161>" zet dus F9 wel aan maar beïnvloed de staat van F2 niet.
Serieel is niet geschikt voor afstand. Dus moeten de centrale en decoder wel naast elkaar. Daar Serieel ook aan de PC hangt (of in ieder geval gebruikt wordt voor programmeren) en geen start/stop en adres laag heeft zou ik dan voor I2C gaan die dat wel heeft. Maar nogmaals, printen moeten dan naast elkaar zitten wil je geen betrouwbaarheids-problemen hebben. Door hoe DCC werkt is dat wel robuust voor afstand.
En voor Rx, als het motorschild er niets mee doet heeft het ook geen invloed op de Arduino. ::) Of mis ik iets :angel:
Timo
-
Die "Rx" pin op het motorshield steek je in de header van de Uno, dus draadje dat je in de "Rx" van het motorshield steekt staat in contact met de Rx van de Uno eronder.
Het DCC++ base station bestaat uit een Uno met een motorshield.
(http://i67.tinypic.com/2rhodfo.jpg)
(http://i66.tinypic.com/2ih2z52.jpg)
Dus als ik de communicatiedraad in de Rx van het shield steekt praat hij feitelijk tegen de Uno eronder.
-
Dat klopt. En dan blijft wat ik zei in reactie #43, waarschijnlijk ontbreken de weerstanden...
Timo
-
Maar ik gebruik de USB alleen om de code te uploaden en daarna trek ik die eruit omdat het uiteindelijk toch een stand-alone geval moet worden.
Het DCC++ heeft, omdat ik die code niet aanpas, eigenlijk per definitie geen USB kabel, hij heeft een adapter en de track power komt van een labvoeding.
-
Wat ik bedoelde was de dcc monitor die ik deelde op een Arduino zetten en dan de pinnen die normaal naar het dcc luister printje/electronica gaan aan te sluiten op de pinnen van de dcc++ centrale die de motordriver aansturen. Zo kan je zonder veel extra componenten meekijken wat er de baan op gaat.
-
@timo
Servo myServo;
myServo.attach(A2);Met andere woorden, je kunt gewoon elke pin opgeven. De Servo library gebruikt gewoon digitalWrite().
Ik realiseer me net dat ik iets vergeten was. Mijn Arduino's zitten vol met code om interrupts af te handelen. Tot nu toe gebruik ik de servo's alleen om armseinen aan te sturen. Een klein probleem daarmee is dat de positie die de armen innemen behoorlijk variabel was, daarom ben ik overgestapt op een andere bibliotheek, nl PWMservo. om deze reden.
PWMServo uses PWM signals for immunity to interrupts, which can corrupt the signals generated by the standard Servo library.
Sorry voor de verwarring.
Groet Meino
-
Maar ik gebruik de USB alleen om de code te uploaden en daarna trek ik die eruit
Dat maakt niet uit. Dat koppelt de USB naar serial chip niet los van de Tx en Rx van de ATmega :) Die blijft dus gewoon de ATmega Rx aansturen. De originele Arduino (en meeste clones volgens mij ook netjes*) hebben daarom een 1k weerstand tussen de ATmega Rx en de USB-Serial Tx en de ATmega Rx loopt direct naar de Rx pin van de Arduino. Op die manier kan de Rx pin dus over de Tx pin van de USB-Serial praten. Zonder zou zowel wat op Rx is aangesloten als de USB-Serial chip tegen elkaar in kunnen praten en dus eigenlijk een kortsluiting vormen. Stroom is dan beperkt dus Arduino zal niet uit gaan maar de data zal niet aan komen en je kunt zowel het aangesloten apparaat als de USB-Serial chp beschadigen.
En @dimo1_dimo1 heeft gelijk, je kunt het opbouwen zonder de H-brug en de opto om mee te luisteren. Niet vergeten de GND van beide Arduino te verbinden als ze niet gevoed worden uit dezelfde voeding.
[off topic]
@meino wat handel je allemaal in interrupts af dan :o Interrupts zouden in ieder geval kort genoeg moeten zijn om niet met de Servo library te storen. Immers zijn pulsen van 1-2ms voor de Arduino heeeeeeeel eeerrgggggggg traaaaagggggg. ;D
Timo
* Maar ik heb niet zo heel veel Uno's daar ik 99% van de gevallen een Pro Mini gebruik. Kleiner en goedkoper.
-
[off topic]
@meino wat handel je allemaal in interrupts af dan :o Interrupts zouden in ieder geval kort genoeg moeten zijn om niet met de Servo library te storen. Immers zijn pulsen van 1-2ms voor de Arduino heeeeeeeel eeerrgggggggg traaaaagggggg. ;D
Interupts van I2C, helaas handel ik in die interrupt code heel veel af (bericht lezen, analiseren en verwerken), dus dat kan best lang lopen. Verder de DCC library die ik gebruik genereert een interrupt op iedere opgaande en neergaande flank van het DCC signaal. Maar daar staat tegenover dat in deze interrupt code weinig gebeurt, er worden timers gezet en opgehaald om te kijken of er een 0 of een 1 langs komt. Verder probeer ik met timers spikes op het signaal uit te filteren.
Groet Meino
-
Dan zal het hem in het eerste zitten. I2C is niet echt snel. De DCC library gebruikt interrupts wel goed dus daar zal de servo library geen last van hebben. Maar goed, als het werkt dan werkt het (never change a winning team) ;D Maar goed om te onthouden voor de toekomst.
En weer nieuwsgierigheid
Verder probeer ik met timers spikes op het signaal uit te filteren.
Wat is "het signaal"? :angel:
Timo
-
@Timo
Het signaal is de blokgolf van het DCC signaal. De bibliotheek meet de tijdsduur van ieder blok. Maar dat is vrij primitief, als er storing op het signaal komt, bijv een slecht ontstoorde lok, dan gebeurde het dat er extra 1 bits herkend werden. Dus als er erg kleine blokovergangen zijn (bijv kleiner dan 40ms) dan vergeet ik die. Dat is als het ware een soort software filter.
Groet Meino
-
Ahh, zo :) (y) Volgens de spec zou >= 52us een geldige één moeten zijn (mits de tweede puls maximaal 6us afwijkt van de eerste). Dus als dat niet in de library zit zou je dat aan kunnen dragen al verbetering (pull request als het Git is).
Timo
PS Gelukkig werkt DCC wel een paar orders sneller dan dat ;) ;D
-
Serieel is niet geschikt voor afstand.
No offense maar dit is wel een beetje BS. CAN bus is ook serieel.
Tussen computer en arduino wordt er al gebruik gemaakt van USB spanningniveaus. Daarbij kan je prima wat meters afleggen.
Ik heb nooit getest hoever je komt als je 2 setjes Tx/Rx pinnen aansluit en op 9600BPS ga werken. Maar dat is een best lage frequentie. Dus op 5V kom je ook best ver. Je moet bedenken dat alles boven de 2.8V als een '1' wordt gezien. Dus spanningsverval is ook niet echt een issue
En zelfs als dat mis gaat, kan je altijd nog max485 ICs er tussen stoppen. https://www.hobbyelectronica.nl/product/max485-module-voor-rs485-communicatie (https://www.hobbyelectronica.nl/product/max485-module-voor-rs485-communicatie). Die kosten geen drol en ze werken op differentieel spanning. Je raakt alleen je full-duplex capaciteit kwijt. Dus je moet wel een master slave systeem programmeren, waarbij je masters bij slaves gaat pollen of ze iets te melden hebben of niet. Maar als je communicatie toch maar 1 kant op is, hoeft dit niet eens.
@GP20
ik weet niet of ik het gemist heb, maar ga je nu gebruik maken van servo's of conventionele wisselaandrijvingen? Je hebt voor DCC al decoders die meer dan 10 servo's kunnen aansturen. Had ik volgens mij al in het begin vermeld. Die kan je dus via DCC aansturen op afstand. Je kan die ook nog per servo instellen tot hoever die servo moeten draaien. Als je perse aruino wilt gebruiken, zou ik wel een extra 5V en 0V aansluiting gebruiken met een eigen voeding. Je kan baanspanning aftappen maar daar komt wat meer elektronica bij kijken. Die servo's trekken best hoge piekstromen, dus een servo driver die op je baanspanning zit, moet een goede schakelende Dc-Dc converter hebben en een dikke elco. En zo'n pre-build DCC servo driver... die is al klaar die heeft dat al en is getest en werkt goed.
Ik zag ook een opmerking over dat 15V een erg lage spanning is voor DCC? Dat is ook een soort van nonsens. Die decoders hebben allemaal iets van een spanningsregulater. Zijnde schakelend of lineair, werken doen ze al waarschijnlijk al als je 3V3 aanbiedt. En in de treinen draaien ze volgens mij altijd op 5V. De baanspanning komt vooral op de randapparatuur te staan. Telex koppelingen, motoren en rookgenerators. Met 12V zal je trein langzamer gaan rijden en misschien wel te langzaam (maar onwaarschijnlijk, ik rij zelf ook op minder dan de max speed). De decoders zullen blijven werken op 15V.
-
No offense maar dit is wel een beetje BS. CAN bus is ook serieel.
Daar heb je gelijk (y) Ik had TTL serieel moeten schrijven. Zoals ik dat eerder bij I2C wel gedaan heb. Excuses!
Maar je maakt wel de fout door geen onderscheid te maken tussen "het werkt" en "het werkt betrouwbaar" te maken. Ja, je kan het rekken met wat lagere bitrate en zeer zeker met CRC. Maar dat verandert niet dat TTL serieel niet gemaakt is voor afstand. Probleem is ook absoluut niet de spanningsval. Maar juist het inkoppelen van storing en in mindere mate dispersie. Dus als zo zonder kennis gaat toepassen voor lengte dan is dat vragen om problemen / gekke storingen. :-\
Dus ja, 485 serieel is daarvoor een hele goede oplossing (y) En full duplex is prima mogelijk. Heb je alleen 2 extra draden voor nodig.
En ja, een goede DCDC converter is aan te raden voor servo's. Distributie van 5V onder de baan niet. Net als lange draden aan de servo. Probeer onder de 20 a 30cm verlengen te blijven. En ook hier geldt, ja, er zijn er genoeg die het prima werkend hebben met langere draden maar er zijn er ook die opeens rare storingen hadden. En die hoeven niet direct of altijd op te treden.
En 15V is wat aan de lage kant voor DCC. En dat heeft niets met de benodigde spanning van de decoder te maken ::) Maar puur wat gebruikelijk is. Wat ja, de meeste decoders zullen gewoon een LDO naar 5V of zelfs waarschijnlijker naar 3V3 hebben. Dus de microcontroller zal werken vanaf een volt of 5 op de baan. Maar naast dat dit niet in spec is (minimaal 7V) zal je vooral moment missen in je motor. Dat de meeste locs op de volle spanning te snel lopen speelt geen rol. Bij 15V zal het moment prima zijn maar 15V als maximum is laag en zelfs te laag volgens de specificatie. ::) En dat is wat ik vooral bedoelde. Verschil tussen of "15V DCC" of "maximaal 15V DCC" laag is. Eerste een klein beetje vergeleken met de grote merken, tweede volledig buiten spec.
Timo
-
Inmiddels is het spul aan de praat met een Arduino Nano.
Origineel is met een pro mini maar de Nano heeft een USB poort dus kan er altijd makkelijk code geüpdate worden.
(http://i65.tinypic.com/11kb5hl.jpg)
De Nano kan makkelijker in de controller gebouwd worden dan een Uno.
Ik heb voor nu besloten de wisselaansturing niet in de controller te steken, dat wordt iets te ingewikkeld voor me.
De wisselaansturing gaat voor nu apart gemaakt worden en misschien wel op verschillende plekken langs de layout.
Net een zwik componenten besteld op aliexpress dus paar weken wachten en dan beginnen met bouwen.
-
Leuk, dit draadje! Ik ben zelf een beginner (wel met stevige technische achtergrond) en ben momenteel ook bezig om een DCC++ verhaal op de Arduino in te zetten. Het idee is als volgt:
- Arduino UNO met 43A (20 Nederlandse amperes...) voor het aandrijven van het treinen gebeuren (en evt. een paar wissels aansturen)
- Arduino Mega als 2e controller voor het uitlezen van de terugmelders vanwege de snelheid en de hoeveelheid ingangen
Status:
Besturing werkt uitstekend via RocRail. RocRail vind ik echt briljant omdat er een goede scheiding tussen controle en aansturing zit. Het doel is om uiteindelijk het zwikkie op een Pi aan te sluiten en die onder de baan te hangen. Op een losse PC/laptop verbind ik dan de RocView interface met de Pi via een netwerk (WiFi, bedraad, whatever)
Terugmelders doen het in principe ook. Ik heb zelf op basis van stroomdetectie terugmelders gebouwd. Hiervoor heb ik zelf een printje ontworpen van 5x5cm ongeveer met daarop http://www.circuitous.ca/DccBOD339393.html deze schakeling
Het aansturen van wissels is dan nog de volgende uitdaging. Ik had al gezien dat daar best veel mogelijkheden voor zijn en ik heb een Servo bordje liggen, maar dat is I2C, dus ik weet niet of dat in de combinatie DCC++/RocRail gaat werken.
Enfin, er moet nu een tafel en een testopstelling gemaakt gaan worden zodat ik een rondje zonder wissels kan leggen om de terugmelding en het automatisch rijden in RocRail te kunnen testen. Daarna komt de wisselaansturing.
Tot nu toe bevalt het prima. Ik heb drie digitale loc's, dus rijden kan met een aantal treinen tegelijk, wordt sowieso vervolgd, zeker nu het weer tijd wordt voor de winterprojects in huis!
-
Het aansturen van wissels is dan nog de volgende uitdaging. Ik had al gezien dat daar best veel mogelijkheden voor zijn en ik heb een Servo bordje liggen, maar dat is I2C, dus ik weet niet of dat in de combinatie DCC++/RocRail gaat werken.
arduino kan gewoon I2C aansturen. Dat stelt allemaal niet zo veel voor. De aansluitingen zitten op A4 en A5. Je kan bijvoorbeeld nog een arduinootje pakken als DCC slave die met I2C die servos aanstuurt, of je hangt het ding aan je uno of je mega.
Je wilt rocrail op je Pi zetten en met je laptop wil je dan draadloos je Pi aansturen? Ik ken rocrail niet dus ik weet niet hoe goed zich dat laat verbinden tussen 2 computers.
Mij persoonlijk lijkt het overkill om een mobiele laptop te gebruiken voor het aansturen van je baan. Je kan ook een mooie handregelaar bouwen die je met BT of Wifi met je arduino of met je Pi kan verdienen. Maar om eerlijk te zijn, ik ken rocrail niet goed genoeg.
Wat mij het mooiste lijkt is om een bluetooth connectie op te zetten tussen arduino en laptop en dan heb je die hele pi niet nodig, maar kan rocrail serieel communiceren met een arduino?
-
arduino kan gewoon I2C aansturen. Dat stelt allemaal niet zo veel voor. De aansluitingen zitten op A4 en A5. Je kan bijvoorbeeld nog een arduinootje pakken als DCC slave die met I2C die servos aanstuurt, of je hangt het ding aan je uno of je mega.
Klopt, maar dan moet je alsnog iets in elkaar fröbelen en ik weet (nog) niet goed hoe ik een DCC accesoire decoder aan kan sturen.
Je wilt rocrail op je Pi zetten en met je laptop wil je dan draadloos je Pi aansturen? Ik ken rocrail niet dus ik weet niet hoe goed zich dat laat verbinden tussen 2 computers.
Mij persoonlijk lijkt het overkill om een mobiele laptop te gebruiken voor het aansturen van je baan. Je kan ook een mooie handregelaar bouwen die je met BT of Wifi met je arduino of met je Pi kan verdienen. Maar om eerlijk te zijn, ik ken rocrail niet goed genoeg.
RocRail is opgebouwd uit een Front-end en een back-end stuk. Het back-end deel zorgt voor de aansturing van je centrales. Dit kan je "headless" draaien zoals dat zo mooi heet, dus zonder grafische interface. De grafische interface is toch vrij zwaar, dus op die manier kan je een deel van de last ergens anders heen brengen. Handregelaars zie ik absoluut niet zitten. Ik ga alles met de computer doen :)
Die scheiding is overigens wat mij zo aantrekt aan RocRail. Opsommend:
Spoorbaan <DCC> Arduino <USB-Serieel> Pi (met RocRail Headless dus) <via netwerk bedraad/wifi> Laptop
Als je mij nog volgt... ;) Het idee hier achter is dat je dus een baan of module mee kan nemen en deze zelfstandig kan rijden. Om te rijden heb je laptop in feitte niet nodig omdat de logica door de Pi wordt aangestuurd. Het wijzigen van zaken dient natuurlijk wel via de computer gedaan te worden.
Wat mij het mooiste lijkt is om een bluetooth connectie op te zetten tussen arduino en laptop en dan heb je die hele pi niet nodig, maar kan rocrail serieel communiceren met een arduino?
RocRail communiceert sowieso serieel met je computer (via de USB kabel). Het kan ook via het netwerk trouwens, maar Bluetooth wil niet omdat een standaard Arduino geen Bluetooth aan boord heeft. Vermoedelijk moet daarvoor behoorlijk geherprogrammeerd worden aan DCC++ als ik dat zo eens moet inschatten, ondanks het feit dat Bluetooth onder water ook een serieel protocol is.
-
Hoi Bastiaan,
Ik heb een aantal transceivers gekocht op aliexpress. Hiermee ga ik de controller die ik nog moet bouwen, maar al wel aan de praat heb, draadloos laten praten tegen het DCC++ base station. Het werkt nu bedraad met een draadje tussen de Tx pin van de controller en de Rx pin van het base station. De HC-12 transceivers zorgen voor de draadloze overdracht van het signaal tussen de Tx en Rx pin, verder niets. Er hoeft geen code of hardware aangepast te worden anders dan het inbouwen van de transceivers. Deze werken op 433MHz, geen idee of dat WiFi, bluetooth of wat dan ook is als het maar werkt. Zelfs twee controllers blijken te werken op 1 base station, dus je/een medespeler kan tegelijk een andere loc bedienen.
Ik moet even zin maken om de frontjes van het base station uit pertinax te maken en het huis van de controller uit laagjes triplex.
Ik ben wel benieuwd naar jouw bezetmelders, ik wil er zelf 1 hebben voor een overweg, de flange squeel module laat ik even varen voor nu.
-
Is de Okkie niet iets voor je? Die heeft bezetmelding voor 8 secties.
https://www.arcomora.com/arloco/
-
Klopt, maar dan moet je alsnog iets in elkaar fröbelen en ik weet (nog) niet goed hoe ik een DCC accesoire decoder aan kan sturen.
RocRail is opgebouwd uit een Front-end en een back-end stuk. Het back-end deel zorgt voor de aansturing van je centrales. Dit kan je "headless" draaien zoals dat zo mooi heet, dus zonder grafische interface. De grafische interface is toch vrij zwaar, dus op die manier kan je een deel van de last ergens anders heen brengen. Handregelaars zie ik absoluut niet zitten. Ik ga alles met de computer doen :)
Die scheiding is overigens wat mij zo aantrekt aan RocRail. Opsommend:
Spoorbaan <DCC> Arduino <USB-Serieel> Pi (met RocRail Headless dus) <via netwerk bedraad/wifi> Laptop
Als je mij nog volgt... ;) Het idee hier achter is dat je dus een baan of module mee kan nemen en deze zelfstandig kan rijden. Om te rijden heb je laptop in feitte niet nodig omdat de logica door de Pi wordt aangestuurd. Het wijzigen van zaken dient natuurlijk wel via de computer gedaan te worden.
RocRail communiceert sowieso serieel met je computer (via de USB kabel). Het kan ook via het netwerk trouwens, maar Bluetooth wil niet omdat een standaard Arduino geen Bluetooth aan boord heeft. Vermoedelijk moet daarvoor behoorlijk geherprogrammeerd worden aan DCC++ als ik dat zo eens moet inschatten, ondanks het feit dat Bluetooth onder water ook een serieel protocol is.
Een bluetooth hc05 of hc06 kan je aan je tx/rx hangen van je arduino. Dan selecteer bij je latop de COM port voor je bluetooth module en klaar is kees. Je software heeft 0 wijzigingen nodig. Bluetooth is serieel.
Die HC12 transceivers van GP20 werken ook maar ik weet niet of die werken met een ingebouwde bluetooth module van een laptop en een HC 05 doet dat wel.
Maar ik snap wel dat je je pi nodig heb voor headless gebruik. Dus je zal weinig behoefte hebben aan BT. Maar wat niet snap is waarom je geen handregelaar wilt. Als je headless werkt zonder laptop, dan wil/moet je toch een treintje kunnen besturen??
Wat betreft het inelkaar frobelen van je I2C servo driver. Daar hoef je niet echt iets voor te 'frobelen'. Het zijn 4 draadverbingen tussen arduino en servo driver en met de interne pull-up weerstanden werkt I2C vaak ook al. Ook hebben I2C modules soms zelf pull-up weerstanden.. en anders soldeer je er 2 in. Als je geen arduino DCC slave wilt, doe je het niet, daar komt idd wat werk bij kijken. Maar je servodriver kan je nu aansluiten op de uno of de mega.
-
Hoi Bastiaan,
Ik heb een aantal transceivers gekocht op aliexpress. Hiermee ga ik de controller die ik nog moet bouwen, maar al wel aan de praat heb, draadloos laten praten tegen het DCC++ base station. Het werkt nu bedraad met een draadje tussen de Tx pin van de controller en de Rx pin van het base station. De HC-12 transceivers zorgen voor de draadloze overdracht van het signaal tussen de Tx en Rx pin, verder niets. Er hoeft geen code of hardware aangepast te worden anders dan het inbouwen van de transceivers. Deze werken op 433MHz, geen idee of dat WiFi, bluetooth of wat dan ook is als het maar werkt. Zelfs twee controllers blijken te werken op 1 base station, dus je/een medespeler kan tegelijk een andere loc bedienen.
Ik moet even zin maken om de frontjes van het base station uit pertinax te maken en het huis van de controller uit laagjes triplex.
Ik ben wel benieuwd naar jouw bezetmelders, ik wil er zelf 1 hebben voor een overweg, de flange squeel module laat ik even varen voor nu.
Die opmerking over de HC-12 klopt volgens mij wel, ik ben er zelf nog totaal niet mee bezig geweest. In het dagelijkse leven ben ik netwerkbeheerder en doe ik ook Wifi. Mijn voorkeur gaat per definitie uit naar bekabelde oplossing, want ik weet hoe brak het kan werken, haha ;D
En ik wil graag alles met de computer voor elkaar krijgen, handbediening is m.i. overbodig met al die slimme software tegenwoordig :)
Overigens is 433mhz een beetje de domotica standaard. Alle schakelaars en stopcontacten die je remote kan bedienen van de Action en de bouwmarkten zitten ook op die frequentie, dat zou dus kunnen storen :)
Dat kan :) De link naar het schema staat hier als het goed is al en dit is het resultaat:
(http://lichtsignaal.nl/rommel/terugmelder.jpg)
Is de Okkie niet iets voor je? Die heeft bezetmelding voor 8 secties.
https://www.arcomora.com/arloco/
Ja, die kreeg ik ook al van een collega door. Voor mij zit de lol ook een beetje in het zelf ontdekken en uitdokteren van hoe alles precies werkt, dus kant en klaar is mooi, maar ik ga liever voor de moeilijke weg :P
Een bluetooth hc05 of hc06 kan je aan je tx/rx hangen van je arduino. Dan selecteer bij je latop de COM port voor je bluetooth module en klaar is kees. Je software heeft 0 wijzigingen nodig. Bluetooth is serieel.
Die HC12 transceivers van GP20 werken ook maar ik weet niet of die werken met een ingebouwde bluetooth module van een laptop en een HC 05 doet dat wel.
Maar ik snap wel dat je je pi nodig heb voor headless gebruik. Dus je zal weinig behoefte hebben aan BT. Maar wat niet snap is waarom je geen handregelaar wilt. Als je headless werkt zonder laptop, dan wil/moet je toch een treintje kunnen besturen??
Wat betreft het inelkaar frobelen van je I2C servo driver. Daar hoef je niet echt iets voor te 'frobelen'. Het zijn 4 draadverbingen tussen arduino en servo driver en met de interne pull-up weerstanden werkt I2C vaak ook al. Ook hebben I2C modules soms zelf pull-up weerstanden.. en anders soldeer je er 2 in. Als je geen arduino DCC slave wilt, doe je het niet, daar komt idd wat werk bij kijken. Maar je servodriver kan je nu aansluiten op de uno of de mega.
HC-05 heb ik geloof ik zelfs nog wel liggen ... wist niet dat het zo simpel was eigenlijk :)
Handregelaar zou kunnen, maar als ik iets wil besturen zal ik dat via een laptop doen. Of het rijdt altijd autonoom, of via de laptop. Dat is nou eenmaal wat ik wil :)
Die Arduino DCC slave is iets wat ik nog niet helemaal snap, maar dat komt vast nog wel. Als ik het uit zou leggen, is het in feitte gewoon een DCC decoder, maar dan stationair, dus die kan gewoon op de DCC aansluiting van mijn DCC++ centrale, adres er in en hopsakee? Dan zal ik zeker nog wel moeten programmeren dat bepaalde functies bepaalde commando's naar de I2C bus sturen? Naar wat ik gezien heb zou dat toch gewoon met de NMRA library kunnen?
-edit-
Ik was overigens van plan om voor wissels/seinen de MARdec te gaan inzetten, lijkt mij wel een leuk ding om eens mee te pielen :)
-
nou de handregelaar is ook bedoeld voor autonoom gebruik. Klinkt tegenstrijdig. Als je je baan autonoom aanzet, dan moeten de treintjes wel beginnen met rijden. Nu kan je een 'verborgen' knop inbouwen die alle locs aanstuurt te rijden...of je zet ze aan dmv je handregelaar.
-
Die Arduino DCC slave is iets wat ik nog niet helemaal snap, maar dat komt vast nog wel. Als ik het uit zou leggen, is het in feitte gewoon een DCC decoder, maar dan stationair, dus die kan gewoon op de DCC aansluiting van mijn DCC++ centrale, adres er in en hopsakee? Dan zal ik zeker nog wel moeten programmeren dat bepaalde functies bepaalde commando's naar de I2C bus sturen? Naar wat ik gezien heb zou dat toch gewoon met de NMRA library kunnen?
Ik ga een controller bouwen welke DCC++ commando's geeft naar de Tx pin zeg maar.
Deze code ziet er als volgt uit:
<t 1 03 20 1>
Hierin is:
< begin DCC++ commando
t het gaat om een opdracht aan een decoder
1 registerwaarde
03 decoderadres
20 hoogte snelheid
1 vooruit (0 is achteruit)
> einde DCC++ commando
zie:
https://github.com/DccPlusPlus/BaseStation/wiki/Commands-for-DCCpp-BaseStation maar die ken je vast al
Het DCC++ base station (Arduino Uno met motorshield) ontvang de DCC++ commando's via de Rx pin.
Vervolgens vertaalt het base station dit naar DCC commando's en zet deze op de rails, als ik het goed heb begrepen dan dient de "commando"spanning tevens als voedingsspanning. Het is een wisselstroomachtige blokspanning waarbij de duur van de pulsen positief of negatief de informatie bevatten en de pulsen op zich de energie om te rijden, lampje te laten branden etc.
Met alleen de controller en het DCC++ base station (en externe voeding) kun je dus al stand alone rondcrossen met je treinen.
Als je wilt programmeren dan steek je simpelweg je USB kabel in de DCC++ Arduino Uno en je kunt met een programma van je eigen keuze de decoders programmeren.
Ook kun je via de USB met je programma de treinen aansturen maar dat hoeft dus niet als je een controller hebt.
Ik hoop dat ik het zo goed uitleg anders word ik zeker wel gecorrigeerd :).
Heb je trouwens zo'n printje te koop, dan wordt het nog netjes ook!!
-
nou de handregelaar is ook bedoeld voor autonoom gebruik. Klinkt tegenstrijdig. Als je je baan autonoom aanzet, dan moeten de treintjes wel beginnen met rijden. Nu kan je een 'verborgen' knop inbouwen die alle locs aanstuurt te rijden...of je zet ze aan dmv je handregelaar.
Ik snap wat je bedoelt ja. RocRail heeft ook een webinterface en mobiele client geloof ik. Dus een Wifi stickie in de Pi en het kan ook met de telefoon. Dus het eind apparaat waarop je bestuurd zou ook een telefoontje of tablet kunnen zijn. Nu heb ik een kleine lichte laptop, dus dat scheelt :)
Daarnaast kan ik een App gebruiken die Blynk heet. Hiermee kan je ook IOT doen. In principe zou je daar ook commando's mee naar RocRail of de DCC++ centrale kunnen sturen en kan je je eigen interface bouwen, maar dat is iets voor veeeeel later ;D
Ik hoop dat ik het zo goed uitleg anders word ik zeker wel gecorrigeerd :).
Heb je trouwens zo'n printje te koop, dan wordt het nog netjes ook!!
Je uitleg is vrij duidelijk. Met bovengenoemde Blynk App zou je dat vrij simpel kunnen oplossen. Evt. in combinatie met bluetooth op de Pi of de Arduino. De mogelijkheden zijn schier eindeloos. Het aantrekkelijke van de hobby, voor mij, is dat ik lekker alles zelf kan prutsen en uit vinden. Dat is waar ik het nu voor doe. Is wel mijn ding zeg maar, lekker pielen tot het goed werkt.
Wat dat printje betreft, ik kan je evt. ook de files opsturen zodat je hem zelf kan laten maken, maar ik heb nog 2 lege die ik je wel tegen kostprijs kan opsturen. Wat er niet bij in zit, dat is wel even iets om bij stil te staan, is voeding voor het niet gedetecteerde stuk met een diodeschakeling zoals die hier op de Wiki staan. Dus dat moet er nog wel bij. In een volgende versie ga ik die er ook wel bij in prutten omdat je met de spanningsval zit als je van de detectie af rijdt (als ik dat goed begrepen heb van diverse andere topics over secties). Je kan natuurlijk wel 1 groot gedetecteerd stuk maken en direct daarna een eind detectie voor het remmen, dat zou denk ik wel goed moeten werken.
Printjes kosten om te maken/versturen bij Seeed volgens mij 16 dollar voor 10 stuks, dus zeg maar 1,30 per stuk. Tilburg ben ik helaas niet in de buurt (Groningen...). Past wel in een envelopje natuurlijk. Stuur maar PB voor naar welke optie je voorkeur uit gaat. Als je de prints zelf wil laten maken zal ik ze wel hier online zetten :)
-edit-
Print heeft dus 2 pinnen om een Arduino ingang over te jagen (via Optocouper) en vier DCC in/uit voor detectie en spanningsvoorziening.
1 naar de detectie sectie, 2x DCC in natuurlijk (hier komt ook de spanning voor de print vandaan) en 1 optionele output naar de rest van het spoor, de doorgaande DCC railstaaf vanuit de centrale, dus die kan ook via de ringleiding.
Let wel: ik heb ze nog niet in de praktijk getest, zo ver was ik nog niet. Detectie gaat prima overigens, maar het aansturen op een baantje moet ik nog proberen :)
-
Hoi Bastiaan,
ik ben ook nog op zoek naar stroomdetectors. Ik had mijn hoop gezet op okkies, maar die zijn maar 2A continue.
Ik rij met grootspoor, 3A continue op de sectie nodig, zoals het door jouw gebruikte schema.
Zijn de railaansluitingen (B+C in het schema) en de sporen daartussen op jouw printje daar geschikt voor ?
Zo nee, dan soldeer ik daar desnoods wel een koperdraad parallel aan.
Dus ik wil ik graag de files hebben zodat ik een aantal van die printjes kan bestellen (y).
Dat wordt voor mij dan ook een first - heb nog nooit een pcb laten maken, dus als je nog tips heb zijn die ook welkom.
Remco.
-
Hey, leuk! Ik heb geen idee of ze voor 3A geschikt zijn om eerlijk te zijn en of de banen breed genoeg zijn. Ik vermoed van wel.
http://lichtsignaal.nl/rommel/TerugmelderDCC.zip (http://lichtsignaal.nl/rommel/TerugmelderDCC.zip)
Daar zijn de Gerber files te downloaden. Deze kan je opsturen naar b.v. https://www.seeedstudio.com/ (https://www.seeedstudio.com/) Goeie ervaring mee tot nu toe. Je kan gewoon de hele zip file opsturen. Ik ben nu bekaf van de hele week. Ik zal later even het schema en de componenten lijst hier ook plaatsen, wel zo makkelijk. Er zitten een aantal SMD componenten op (op basis van 1206, maar kleiner wil ook wel), maar ik ga er vanuit dat mensen die in dit draadje zitten handig met een soldeerbout zijn :)
(http://lichtsignaal.nl/rommel/terugmelderlist.jpg)
(http://lichtsignaal.nl/rommel/terugmelderpcb.jpg)
Kleine moeite ook eigenlijk ...
-
Dank je wel - ik ga het bestuderen.
-
Ik gebruik de stroomtransformatoren op de printjes van Hans Deloof. Deze zijn ook direkt aan een Arduino te gebruiken.
Er zijn twee uitvoeringen, n.l. voor 3 a 4 Ampere en 1 voor veel hoger, b.v. 12 Amp.
Ik heb tot nu toe de kleinere versie gebruikt. Hierbij is zelfs 10 mA al een bezetmelding, maar ook 4 Amp.
Groet,
Bert
-
Heb je daar meer informatie over? Dat klinkt wel interessant, vooral voor de grootspoorders onder ons. Mijn bezetmelders reageren overigens ook op zulke kleine spanningen.
-
Gaat lekker Bastiaan. ;D ;D (y)
-
Nou, toch maar de moed opgezocht om gister van alles en nog wat in elkaar te zetten en tot nu toe vrij tevreden! Zelfs met 1 melder per blok en 4 blokken in een ovaaltje, jaja, niet te ingewikkeld, rijden er twee locs best okay.
Dus, RocRail samen met een DCC++ centrale en mijn eigen gefabriekte terugmelders werken best leuk!
Linkje: https://youtu.be/XrCHa7LuDzI (https://youtu.be/XrCHa7LuDzI)
-
(y) (y)
-
Langzaam maar zeker krijgt de digitale besturing vorm.
Ik heb een oude behuizing gestript en ben die nu aan het opbouwen tot base station:
(http://i64.tinypic.com/makjmr.jpg)
voorzijde
(http://i63.tinypic.com/esq8hg.jpg)
achterzijde
(http://i63.tinypic.com/34s15w4.jpg)
binnenwerk
De usb kabel komt in de Uno gestoken om een eventuele softwareupdate (verwacht dat het niet nodig is) te kunnen doen zonder alles open te moeten maken en te demonteren.
Behalve de Uno (met motorshield) en de voeding komt er nog een lineaire spanningsregelaar in om de Uno te voeden met 12V en de ontvangstmodule.
Ik ga uit een oud soepblik een afscherming om de voeding heen maken zodat deze de ontvanger zeker niet kan storen.
De controller is het volgende project, eerst wil ik dit af hebben.
-
Ziet er goed uit, mooie kast. (y)
Ik heb nog een ingeving die misschien wel of niet handig is voor jou. Zoals je misschien weet heeft arduino een library om een viruele comport er bij te maken met willekeurige I/O pinnen. Het werkt niet zo goed als de echte Rx Tx pinnen, maar op 9600BPS werkt het prima. Je kan er voor kiezen om een max 485 module in te bouwen en aan te sluiten op een virtuele I/O port.
Dit geeft je de mogelijk om in de toekomst met andere arduino's of uControllers te communiceren over afstand. Als aansluiting kan je dan 1 of 2 RJ45 (internet connectoren) te gebruiken. Dan kan je met een simpele netwerk kabel 2 of meer modules met elkaar verbinden. Ik heb modelbanen gezien waarbij ze handcontrollers hadden gebouwd die je op meerdere plaatsen in de baan konden prikken, dat wordt dan ook een mogelijkheid hoewel dat zwaar overkill is voor een klein baantje ;D
-
Ok, da's een goed idee. :D
Het is wel zo dat de code in de base station nu volledig de code van de maker ervan is, ik heb daar niets aan gewijzigd.
De code van de controller is wel voor 80% aangepast. De opzet is om tenminste 1 controller te maken met de eerder genoemde 433 MHz transceivers.
Als de base station code uit te breiden is (het kan natuurlijk altijd maar of mij dat lukt) met de genoemde library dan zijn de kosten van de 485 module geen argument om het niet te doen. (net opgezocht) Het is sowieso altijd later nog toe te voegen.
Het wachten is nu een lading standofs/spacers die van aliexpress hiernaar toe onderweg zijn. Dan kunnen de Uno en zo op de basisplaat vast gemaakt worden. Moet ook even de moed verzamelen om de transceivers te solderen, die zijn nog kleiner dan ik al dacht.
Het wordt een kleine baan maar wel verdeeld over 2 ruimten dus als de draadloze versie niet naar behoren werkt dan is dit mogelijk een mooie oplossing.
-
Als je tijdens normaal gebruik geen serieel met de pc nodig hebt kan je de 485 ook gewoon op pin 1 en 2 aansluiten. Alleen de !RE voorzien van een pull up zodat de max485 niets doet tijdens starten en dus het eventueel uploaden van code. De DE pin kan je dan aan !RE hangen maar dan zal er dus ook data over de 485 gaan tijdens programmeren. Dus beter om die aan een losse Arduino pin te maken met een pull down[. Dan blijven zowel de Receive Output als de Drive Output stil tijdens programmeren.
Nadeel is dat als je de 485 ook werkelijk wilt gebruiken in je programma je geen makkelijke debug methode meer hebt. Maar aan de andere kant, in mijn opinie is het beter de hardware serial te gebruiken voor de kerntaak en eventueel een software serial voor debuggen. Deze zal je dan alleen via een losse Serial<->USB converter moeten aansluiten. Voor de prijs (https://www.aliexpress.com/item/1pcs-USB-to-TTL-converter-UART-module-CH340G-CH340-3-3V-5V-switch/32668180966.html) hoef je het niet te laten ;D
Maar aan de andere kant, als je voor iets als handregelaars wilt gaan zou ik eerder kijken of je een LocoNet implementatie toe kunt voegen.
@GP20, werkt de 433Mhz een beetje? Zijn ervaringen zijn namelijk nooit zo heel geweldig met die 433Mhz dingetjes, de band is aardig vol. Zelf meer fan van de nRF24L01+ modules voor draadloos.
Timo
-
Ik weet nog niet of de 433 MHz hier lekker werkt, moet de dingen nog in elkaar solderen en wachten totdat alles klaar is.
Ik heb in ieder geval net 2 stuks NRF24L01+PA+LNA besteld op ali.
-
Als je tijdens normaal gebruik geen serieel met de pc nodig hebt kan je de 485 ook gewoon op pin 1 en 2 aansluiten.
De rede waarom ik software serial aanraadde is omdat het uploaden van programma's vaak niet goed werkt indien er iets is aangesloten op de Rx en Tx pinnen
-
Snap ik, maar daarom heb ik vertelt hoe het wel probleemloos kan ;)
Timo
-
Inspirerend draadje.
Al wat langer loopt mijn zoektocht voor het aansturen van mijn treintje. Hierbij verandert de zoektocht meer en meer naar zelfknutselarij in plaats van folie verwijderen. In het verlengde van in deze periode in te vullen iijstjes van verlangens, heb ik daar zomaar een arduino startset opgezet.
Hoop de de goedheiligman dit draadje ook leest ;)
Groeten Ad
-
@Ad,
Ga je ook richting DCC++ met een draadloze controller?
Ik ga voor stand alone, de USB aansluiting zou ervoor moeten zorgen dat ik met een PC/laptop ook locs kan programmeren, vandaar de dubbele uitgang. In de praktijk ga ik denk ik een plankje maken met een eigen Uno, motorshield en stukje spoor welke naast de PC komt te liggen (laptop heb ik niet).
-
Leuk om te zien GP20 :)
Ik heb niet veel tijd gehad om te spenderen, maar ik kan nu wel met meerdere treinen digitaal rijden met mijn Chinacrappie 43A shield (20 echte ampere's denk ik). Ik heb helaas nog niet genoeg terugmelders en moet nog een servo onder een wissel plakken.
Ben heel benieuwd of het allemaal goed gaat werken op 433mzh. Normaal gesproken moet het bereik zeker beter zijn dan 2.4Ghz van Wifi of NRF modules (die ik ook wel ken). NRF is prima, maar zit op de Wifi band en dat levert over het algemeen meer verstoring op dan 433mzh (hogere frequentie, minder bereik, meer bandbraadte, gaat altijd drie kanten op). NRF modules heb ik trouwens voor mijn Lego treinen ooit es gebruikt (zie alhier https://www.youtube.com/watch?v=RiZZz38yhHg ). Samen met Blynk App. Deze kan ook HTTP dingen doen met REST, JSON etc. Zou in principe prima te combineren zijn.
Uiteindelijk ga ik in mijn centrale ook de OrangePi plaatsen waar de RocRail backend op draait, althans, dat is het plan ... ben voorlopig meer aan het modelbouwen dan treinbaan bouwen (iets met ruimte en bureau :D ).
-
Je hebt gelijk dat de NRF modules de band met WiFi delen en dat het dus wat druk is. Maar de 433MHz band is ook echt niet rustig. Zeker omdat de zenders die daar actief zijn vaak een stuk "lelijker" zenden en mede daardoor een slechter bereik hebben. Mijn ervaring is toch echt beter dan de meeste 433MHz zenders doordat de modulatie beter en netter is. Zeker omdat je ook makkelijk CRC en acknowledgment toe te passen is.
En je kan de NRF24L01+ instellen op een hogere frequentie dan WiFi. WiFi loopt tot 2,492Mhz (2,472MHz center frequentie) en je kan de NRF instellen tot 2,525MHz. Nu kan ik alleen zo snel niet vinden wat de wettelijke beperkingen in Nederland zijn maar goed. In Duitsland mag je namelijk maar tot 2,4835MHz maar die zijn wel vaker wat strikter :angel:
Met de NRF24L01+ scanner sketch kan je makkelijk uitvinden rond welke kanalen het rustiger is :)
Timo
PS Absoluut geen persoonlijke kritiek! (y) Als de 433MHz band voor je werkt, lekker zo laten 8)
-
@Bastiaan,
Leuk zo'n Legotrein, ik moet me inhouden maar ik heb me voorgenomen om het bij 1 systeem te houden :).
@all,
Gaat het wel een issue worden?
Ik sta nooit verder dan een paar (ca. 7) meter van de ontvanger (base station) vandaan. Ik heb de modules ook nog eens op 100mW ingesteld, het maximum vermogen.
Ik heb alleen geen idee of de zender en ontvanger elkaar kennen zeg maar omdat je ze niet hoeft te binden. Is dat bij een NRF module wel het geval?
-
neej joh, 7 meter stelt niks voor.
Met 433Mhz kan je theoretisch een kilometer halen, met die dingen die jij hebt althans
Edit:
Ik weet eigenlijk niet of dat wel legaal is om met zoveel mWatt te stralen op die frequentie, misschien interessant om ff op te zoeken.
-
7 meter is qua afstand inderdaad niet zo veel, ook omnidirectioneel niet. En dat geld eigenlijk voor de meeste beschikbare frequenties. De verstoring omdat de frequenties vrij zijn is erger.
En als je gaat opzoeken met hoeveel mW je mag zenden, zoek dan gelijk op hoeveel procent van de tijd je mag zenden. Hier zitten vaak ook limitaties op. Voor LoRa is dat bijvoorbeeld een belangrijk aspect om het geheel te laten werken.
En over het verbinden van NRF, ze moeten wel op hetzelfde kanaal zitten. Ook zijn er via libraries als RF24 pipes te maken maar of dat puur in software zit of niet durf ik niet te zeggen. ::) Zelfde voor CRC en ack's, geen idee hoeveel daarvan werkelijk in de NRF24L01+ zit. Daarvoor ze nooit diep genoeg bekeken. Ik kan zo 123 niet meer vinden welke transceiver jij nu gebruikt maar de meeste op de 433MHz zijn redelijke domme dingen en vormen geen enkele tussenlaag. Data die je er in stopt komt er direct gemoduleerd uit. Bij de NRF24L01+ zit er nog het een en ander tussen.
Timo
-
Ik weet eigenlijk niet of dat wel legaal is om met zoveel mWatt te stralen op die frequentie, misschien interessant om ff op te zoeken.
Goeie, opgezocht en aangepast!
-
Weinig tot geen activiteiten in dit draadje.
Ben inmiddels zelf bezig geweest met de bouw van DCC++ centrale en handregelaar.
Als werkt naar tevredenheid.
De bouw is te volgen in mijn eigen draadje.
https://forum.beneluxspoor.net/index.php?topic=83612.msg3222052677#msg3222052677
Hier wat foto's
(https://images.beneluxspoor.net/bnls/70510197_1321861451314309_3824842503652114432_o.jpg) (https://images.beneluxspoor.net/bnls/70510197_1321861451314309_3824842503652114432_o.jpg)
(https://images.beneluxspoor.net/bnls/70302296_1321861834647604_2873205066574069760_o.jpg) (https://images.beneluxspoor.net/bnls/70302296_1321861834647604_2873205066574069760_o.jpg)
(https://images.beneluxspoor.net/bnls/70885903_1321861534647634_1986930344477065216_o.jpg) (https://images.beneluxspoor.net/bnls/70885903_1321861534647634_1986930344477065216_o.jpg)
-
Dat ziet er mooi uit Ronald! Ik zal je eigen draad in de gaten houden.
Het is zo te zien helaas niet gelukt dit draadje weer in de lucht te houden. Dan zal ik het even proberen.
Ik had van 'vroeger' (10-15 jaar terug) nog een simpele oval + 2 wissels, met een enkele trein in HO. En het digitaal maken leek mij een goed excuus om hem er weer bij te halen en een eigen tafel te geven.
Die DCC++ base station is me toch wel een mooie uitvinding zeg. De instap in DCC is wel echt klein op deze manier, zonder dat je gelijk de hoge prijs voor een commercieel te verkrijgen apparaat neer hoeft te leggen. En het heeft als voordeel dat je er lekker aan kan sleutelen!
-
Ik volg Ronalds draadje ook en ik heb hem een beetje nageaapt.
Dit is de handcontroller van mij (versie 2):
(https://i.imgur.com/aoEW4aB.jpg)
(https://i.imgur.com/bbxzRut.jpg)
Versie 1 was niet erg geslaagd, en toen ik die van Ronald tegenkwam, wilde ik toch ook een mooie en werkende handregelaar...
Versie 1:
(https://i.imgur.com/BTLB5Hn.jpg?1)
:'( :'( :'( Dit doe ik dus nooit meer.
Die van mij werkt met bluetooth en heeft een 3.7V lipo batterij met oplaadprintje.
De software van mijn DCC centrale is ook af. Ik kan alleen de basis functies doen. Ik kan (nog) geen locs programmeren of uitlezen of DCC randapparatuur aansturen. Ik heb dan ook geen behoefte aan deze features.
De bluetooth module van m'n dcc centrale is echter gesneuveld... iets met kortsluiting en los bungelende draadjes.... De centrale zelf is net als versie 1 handcontroller een plaatje hout met wat printjes er op geschroefd... En het was mijn laatste HC-05 BT module. Ik heb bij mijn ouders per toeval nog een perfect apparaatje liggen die nog op mijn robotautootje gemonteerd zit. Volgens mij heet het ding een "Mduino. Het is een arduino board met ingebouwde H brug en hij heeft een Hc05 bluetooth "bee" op een socket gestoken. Dat board heeft alles in huis wat ik nodig heb, behalve een max485 printje. Ik ga deze eerst in een mooi kastje stoppen, dan ga ik weer Ronald nadoen en zo'n DB9 connector met breakout ding aanschaffen en dan kan ik draadloos rijden :-D
-
Zo. Dat ziet er ook echt super goed uit! Daar heeft vast ook veel werk ingezeten. En die ingebouwde accu is erg handig. Gewoon 's nachts in de lader, overdag gebruiken. Nooit lege batterijen.
Ik ben wel benieuwd naar de software hoe je dat hebt gedaan. Heb je nog wijzigingen aan de DCC++ Base Station moeten maken?
-
Zo. Dat ziet er ook echt super goed uit! Daar heeft vast ook veel werk ingezeten. En die ingebouwde accu is erg handig. Gewoon 's nachts in de lader, overdag gebruiken. Nooit lege batterijen.
Ik ben wel benieuwd naar de software hoe je dat hebt gedaan. Heb je nog wijzigingen aan de DCC++ Base Station moeten maken?
Ik heb mijn eigen DCC software (https://forum.beneluxspoor.net/index.php?topic=88482.0) vanuit scratch geschreven. Dat vond ik A. leuk om te doen en B. ik ben nooit zo'n fan van een of andere library te includen en dan gewoon te gaan. Zo'n library heeft ongetwijfeld allerlei extra functies ingebouwd die ik niet nodig heb. En je moet dingen er in gaan wijzigen. Dat is niet al te moeilijkk, maar ik vind het dan leuker om dan het hele programma te maken.
Ik hou erg van vrijheid en simpelheid. Ik gebruik ook mijn eigen communciatie bus voor randapparatuur en een eigen computer programma. Dus ik heb geen DCC accesoires meer en ook heb ik geen S88 bus oid. Ik heb straks, seinen, controle panelen, dcc centrale, raspberry pi met een computer programma, terug melders en servo's over 1 communicatie bus lopen. Misschien maak ik er ooit een commerciele versie van, maar misschien ook niet.
Bluetooth en arduino is echt ontzettend simpel. Je kan serieel AT-commando's sturen. En zo kan je bijvoorbeeld 2 BT modules aan elkaar pairen en binden. Zodra ze elkaar dan kunnen vinden, zetten ze meteen een verbinding op en kan je serieel communiceren. Ik wil in de toekomst een keer upgraden naar een wemos d1. Dat is een arduino board met een ingebouwde Wifi module. Dan kan je makkelijk meerdere verbindingen opzetten.
Ik ben nu het bestand van mijn DCC centrale aan het opdelen in meerdere files voor de leesbaarheid. Als dat af is, ga ik maar eens een github pagina nemen om al m'n software te delen. Ik heb ook op werk mijn eigen theorien gemaakt over state machines en een script gemaakt waarmee ik hele state machines structuren kan genereren adhv een bollen diagram. Dat wil ik ook graag delen met de buiten wereld.
-
Heb je nog wijzigingen aan de DCC++ Base Station moeten maken?
Het is maar net waar je je tijd in wil steken en hoe diep je wil verdiepen in de materie.
De Code van de Basis Station is vrij simpel en doet wat die moet doen.
Kan altijd later nog de code gaan aanpassen om er dingen uit te halen die niet nodig zijn !
Voor het programmeren van de decoders gebruik ik JMRI Decoder Pro dit werkt perfect.
Voor het rijden gebruik ik de zelf gebouwde handregelaar met eigen code.
Verder is communicatie heel simpel serieel via kabel Tx naar Rx maar kan ook via radio module draad loos.
<0> prog en main spanning uit.
<1> prog en main spanning aan.
<t1 2218 34 1> <t1 stuurt gegevens naar decoder via register 1 , 2218 het loc/decoder adres, 34 de rij stap, 1 de rijrichting voor uit.
als voorbeeld een stukje code if (AUT == 1) {
Serial.print("<t1 ");
Serial.print(LocAd);
Serial.print(" ");
Serial.print(RS);
Serial.print(" ");
Serial.print(RRS);
Serial.write(">");
Serial.println(" ");
}
Voor de functies het volgende.
<f 2218 144> <f stuurt functie , 2218 het loc/decoder adres, 144 = 128 + 16 (f0) zet f0 aan.
als voorbeeld een stukje code if (AUT == 1) {
Serial.print("<f ");
Serial.print(LocAd);
Serial.print(" ");
Serial.print(Func);
Serial.write(" >");
Serial.println();
}
}
Zie hier de link naar de Commands voor het communiceren met de DCC++ Basis station.
https://github.com/DccPlusPlus/BaseStation/wiki/Commands-for-DCCpp-BaseStation
De hand regelaar werkt perfect voor wat ik wilde hebben.
Ben nu bezig met het toevoegen van menu's voor het verbeteren van selecteren locomotieven in multi tractie of consist rijden.
Maar ook meerdere treinen te gelijk.
M.v.g. Ronald Hofmeester.
-
Ik heb mijn eigen DCC software (https://forum.beneluxspoor.net/index.php?topic=88482.0) vanuit scratch geschreven. Dat vond ik A. leuk om te doen en B. ik ben nooit zo'n fan van een of andere library te includen en dan gewoon te gaan. Zo'n library heeft ongetwijfeld allerlei extra functies ingebouwd die ik niet nodig heb. En je moet dingen er in gaan wijzigen. Dat is niet al te moeilijkk, maar ik vind het dan leuker om dan het hele programma te maken.
Dat klinkt erg leuk! Ik begrijp je ook volkomen dat het voldoening geeft om zelf iets te maken wat simpel werkt. Dank voor de link, ik ga je topic even lezen.
Bluetooth is inderdaad een leuke optie om zelf ook toe te passen. Ik heb nu ik er over nadenken nog een paar (precies 2) ESP8266'en liggen, WiFi-modules, waartegen je ook via AT commando's kan praten. Dat scheelt weer bluetooth modules kopen ha.
Zelf gebruik ik wel de DCC++ Base Station firmware. Ik ben bezig om software te schrijven om dat aan te sturen, wat gewoon op een computer draait. Op termijn lijkt het mij leuk om IR-sensoren in de baan te stoppen zodat de software bij kan houden waar de treinen zijn. Toekomstmuziek, maar de sensors liggen al in de kast.
En dank voor de uitleg Ronald!