Arduino analoge(!) modelbaan sturing

[Timo]

Dat vind ik absoluut niet vervelend, mijn kennis van de de Arduino programmeertaal is nog niet ruim te noemen.
Ik begin er meer inzicht in te krijgen, van de programmeer voorbeelden kan ik veel leren.

Gelukkig Ik blijf het namelijk super leuk vinden om de vorderingen hier te lezen en hoop dat ik dan met de voorbeelden kan bijdragen.

Drie mini opmerkingen over de wisselsturing  Ik zou de volgende keer 1N4148 diodes pakken. Deze zijn goedkoper en ook nog eens meer geschikt (veel sneller). Ook zou ik nog even een pull-up weerstand opnemen in de lijnen die de transistoren aansturen. Als de ingang zweeft (niet aangesloten of Arduino heeft de pin nog als input) kan de transistor half in geleiding komen (wisselspoelen worden beide bekrachtigd, transistor wordt warm). En kon je niet af met twee transistoren? Dus één transistor beide relais laten schakelen.

@Peter, ben je ook van plan dat ergens te gaan documenteren?


Timo

[lok1614]

Timo,

Was wel van plan een en ander op mijn nog te bouwen site te gaan plaatsen, weet niet of dit forum daar de plek voor is, zowel dan misschien in de FCS sectie.
Is in iedergeval geen geheim :-)

Gr Peter

[smits66]

Hoi volgers,

@ peter

Bedankt voor je input.
Ik heb wel eens filmpjes over het programmeren van de Arduino op Youtube bekeken, de meeste filmpjes die interessant zijn, zijn in het Engels of het Italiaans, daarbij ben ik slecht horend en versta er meestal niets van , het volume omhoog draaien is ook niet de oplossing.

@Timo

Van dit type diode (1N4007) heb ik er nog een stuk of 400 liggen (gratis gekregen ) , eigenlijk dacht ik dat de 1N4148 te licht was om als blusdiode ingezet te worden (Weer wat geleerd ).

Bedankt voor de tip, voor het gebruik van een pull-up weerstand, zal ik in het volgende bouwproject (keerlus sturing) meenemen.

Ik heb geprobeerd om beide relais met 1 transistor te aansturen maar het bi-polaire relais kwam niet goed mee (soms wel/soms niet) vandaar de keuze voor twee transistoren type BC547B misschien de volgende keer een iets zwaardere type gebruiken en de weerstand aan de basis verlagen.

Mvg Paul

[Fritsprt]

@Peter,
je reactie maakt me nieuwsgierig. Mijn treinenhobby heb ik weer opgepakt nadat ik de Faller auto's een paar jaar geleden zag rijden. Ik heb inmiddels mijn eerste standmodel omgebouwd en van een dccar decoder voorzien. Ik heb nu alleen nog maar een testbaantje maar als de verbouwing van mijn huis klaar is wil ik een baan met auto's en treinen gaan maken. Daarbij gebruikmakend van Arduino's. Vandaar dat ik dit leuke draadje ook trouw volg.

Ik heb je filmpje bekeken en ben razend nieuwsgierig naar de manier hoe je dit gemaakt hebt. Wellicht een goed idee om een draadje te starten in de rubriek: Carsystem. Dan vervuilen we het draadje van Paul niet.

@Paul. Ga zo door. Ik reageer weinig maar lees trouw mee.

Gr. Frits

Verstuurd vanaf mijn HTC One X met Tapatalk

[Timo]

Als je ze gekregen hebt is het een ander verhaal Maar de stroom die gaat lopen is maar zeer kort en ook niet enorm hoog. 1N4148 doet het dus prima


Timo

[smits66]

Hoi volgers,

@Peter, Timo, Frits

Bedankt voor de input.

De Keerlus schakeling met een Arduino:

Op mijn modelbaan komen twee keerlussen, deze wil ik volledig automatische gestuurd hebben, daarvoor wil ik de Arduino Nano gebruiken.

Om een overzicht te krijgen hoe ik het wil gaan bouwen heb ik eerst een flowchart gemaakt en daar de functies in gezet zodat ik een overzicht heb van hoe de sturing in elkaar zit.

De Flowchart:



Deze flowchart geeft mij met het schrijven van het programma voor de Arduino inzicht welke poorten in voor wat gebruikt.

Deze keerlus schakeling bestaat uit 4 hoofdonderdelen nl., Arduino Nano, Motordriver L298, Wissel sturing en een sensor interface, op de Arduino en L298 motordriver na, wil ik de andere functies op een experiment-print (koperbanen)  bouwen.

Het schema van de wisselsturing:



Deze wisselsturing word toegepast voor de wissel in de keerlus sturing, de sensor interface moet ik nog maken/ontwerpen.

Voor het Arduino programma heb ik een schematische tekening van de keerlus voorzien van evt. variablen die ik kan gebruiken voor het Arduino programma.

De schematische weergave van de keerlus:



Ik moet alleen nog een schema maken voor de sensor interface, maar dat komt morgen.

Ik sta altijd open voor tips/opmerkingen van deze sturing.

Mvg Paul 

[Peter Korsten]

Dat is geen flowchart (of in UML-termen, een activiteitendiagram) maar eerder een componentendiagram. Een flowchart geeft de voortgang (flow) van de programma weer.

- Peter

[gvandersel]

Wat het wel weergeeft is een goed library indeling:
- sensor
- sein
- uitgang blok
- wat losse dingen
Dus dat is ook wat.

Groet,

Gerard van der Sel.

[Timo]

Paul, ik schaam mij diep  Ik heb de vorige keer gezegd dat je een pull-up moest toevoegen maar dit moet natuurlijk een pull-down zijn! Bij een float aan de ingang gaat een uitgang nu juist schakelen ipv uit te blijven. Me versproken omdat een pull-up zo gebruikelijk is bij een Arduino  omdat deze er intern in zit. Maar aangezien je schakeling active high is (heeft 5V nodig om te werken) wil je hem dus juist low trekken, pull-down dus.

Verder nog wat vragen over de lus. Is deze lus echt zo groot dat je er nog een extra blok in wilt hebben? Kan het mis hebben maar blok W lijkt me niet heel groot.

Voor de seinen, wil je nog volgens een bepaald land gaan rijden of hou je het alleen bij rood-groen seinen? Overigens zou je ook nog een PWM poort kunnen gebruiken om een dim functie te kunnen maken voor de seinen. Gewoon alle seinen via 1 NPN die je PWM't naar GND. Of je het wil is aan jou :p

En dan de componentenlijst tegen het schema... Op de componentenlijst zie ik 5 sensors, in het schema zie ik er maar 4. In het schema zie in 3 seinen, bij de componenten zie ik er maar 2. En in het schema zie ik 3 blokken en bij de componenten ook maar 2. Hoe wil je dit dus gaan doen? Wat wil je wat laten doen?

Heb je verder al eens met de PWM frequentie gespeeld om treinen beter te laten rijden? (Ik weet niet meer of dat dit topic was...) Maar in ieder geval, nu heb je pinnen 3 en 6 gekozen voor de PWM van de motordriver. Dit kan wel maar dan heb je wel twee verschillende frequenties. Pin3 zit namelijk aan timer2 en heeft een frequentie van 490Hz. Maar pin6 hangt aan timer 0 en heeft een frequentie van 977Hz. Om treinen anders kunnen reageren op andere frequenties zou ik deze hetzelfde houden.

Goed, nu gaat even een hele uiteenzetting komen over wat dan te gebruiken. Wat het nu echt moet worden moet je zelf kiezen en zal je denk ik het beste met testen kunnen kiezen.

Optie 1, beide op timer 0
Pin 5 en 6
Zoals gezegd is timer 0 977Hz. Als ik ga kijken naar Weistra regelaar is dit wel een hele hoge frequentie. Aan de andere kant, moderne decoders werken vaak op een frequentie van 32kHz, dit is nog echt wel een stuk hoger en werken ook prima. Maar het grote nadeel van timer 0 is dat deze ook millis() voor zijn rekening neemt. Ga je dus met deze timer rommelen dan klopt millis() niet meer.

Optie 2, beide op timer 1
Pin 9 en 10
Timer loopt op 490Hz, is al wat lager. Nadeel van deze timer (zou kunnen zijn) dat deze gebruikt wordt door de Servo library. Voordeel van deze timer is, hij is 16-bit. Zelfs als je voor een eigen gekozen frequentie gaat is het makkelijk nog steeds 8-bit sturing te houden. Zelf een frequentie instellen kan je doen door de prescaler te veranderen maar dan is je keuze nog steeds beperkt. Je kan ook aanpassen tot waar de timer moet tellen (de top waarde) waardoor de timer sneller gaat lopen alleen moet de PWM waarde dan wel kleiner dan deze waarde zijn. Voordeel van 16-bit timer is dat je wat extra head room hebt, als je hem 256 keer zo snel laat gaan heb je nog steeds 8-bit over.  Of dit nodig is (eigen frequentie kiezen) is aan jou. Hoe dit moet is een kwestie van Google, weet ik ook niet uit me hoofd  Is in ieder geval dus wel wat meer de Atmega in duiken.

Optie 3, beide op timer 2
Pin 3 en 11
Eigenlijk zelfde verhaal als optie 2 alleen is deze timer maar 8-bit. Deze wordt gebruikt door de tone-library maar dat vormt denk ik nooit een probleem 

Optie 4, verspreiden over timer 1 en 2
Omdat je twee motordrivers hebt zou je ze kunnen spreiden. Voordeel hiervan is dat je, net als de Weistra regelaar, de frequentie kan veranderen met de snelheid. Zou je ze op dezelfde timer zetten en één trein moet snel en één moet langzaam, welke frequentie kies je dan? Door ze op twee drivers te zetten is dit wel los aan te passen.

Optie 5, op een timer + software PWM
Zoiets heb ik in het verleden gedaan. Op een timer heeft het voordeel dat je voor beide maar 1 timer gebruikt en eventueel zelf een frequentie kunt kiezen. Maar je kan natuurlijk ook voor de standaard frequentie gaan. (Ik had toen +-32kHz, zoals een decoder, gekozen.) Omdat op lage snelheden een loc wat last heeft van kleef (het niet op gang willen komen) werkt dat beter met een lage frequentie. (De Weistra regelaar begint op 20Hz.) Maar de grap van lage frequenties is dat deze voor een Arduino heeeeeeeeeeeeel langzaam zijn en dus ook prima in software kunnen. Om op gang te komen stuurde ik dus de uitgang met een lage frequentie en lage duty cycle ook even vol aan. "Nadeel" is dat je dus een software laag hebt moeten lopen maar als je het doet zoals met de optrek en aftrek vertraging in de library die ik eerder stuurde is dat geen probleem. Je hebt dan toch al een update functie. Een voorbeeld hiervan kan je onderaan vinden.

Zoals je ziet nogal wat mogelijkheden die misschien het overdenken wel waard zijn Dit alles voor het mooiste rijgedrag.


Timo




Voorbeeld van update() die ook een software PWM doet op lage snelheden. Nieuwe variabele is unsigned long lastBump en bool bumpFlag. setSnelheid() is ook aangepast om het makkelijker te houden. Instellingen zijn:
const byte MaxBumpSpeed = [iets]; //Snelheid tot waar er een bump gegeven moet worden
const byte BumpInterval = [iets]; //Aantal ms tussen de bumps -> 50ms voor 20Hz bijvoorbeeld
const byte BumpDuration = [iets]; //Aantal ms van de bump -> 2ms voor 4% @ 20Hz (50ms)

Natuurlijk is dit maar een voorbeeld, kan zo fancy mogelijk gemaakt worden als je zelf wil (bijvoorbeeld bumpInterval en bumpDuration laten afhangen van de snelheid). Update van de library in zijn geheel is hier te vinden.

Code: [Selecteer]

//Checkt of de snelheid aangepast moet worden (optrekken/afremmen) en doet dit
//Aanroepen in de loop
void AamsTrein::update(){
//Kijken of het tijd is om een update te doen
if(millis() - this->millisLast > this->vertraging) {
this->millisLast = millis(); //opslaan dat we nu een update doen

if(setSpeed > curSpeed){ //moeten dus sneller
this->curSpeed += 1;
}
else if(setSpeed < curSpeed){ //moeten langzamer
this->curSpeed -= 1;
}
}

//Als er een bup gaande is
if(this->bumpFlag){
//Bump afgelopen, terug naar normaal
if(millis() - this->lastBump >  BumpDuration){
this->setSnelheid(); //Zet de snelheid weer op curSpeed
this->bumpFlag = false;
}
}
//Er is geen bump gaande
else{
//Check of snelheid laag genoeg is dat er een bump (software PWM) nodig is tegen kleef
//en tijd is voor nieuwe bump
if(abs(this->curSpeed) < this->MaxBumpSpeed && this->curSpeed != 0 && (millis() - this->lastBump) > BumpInterval){
this->lastBump = millis();
this->setSnelheid((this->curSpeed < 0 ? -255 : 255)); //Zet snelheid op 255, zelfde richting als curSpeed
this->bumpFlag = true;
}
else{
this->setSnelheid();
}
}
}


[smits66]

Hoi volgers

@Timo

Bedankt voor je hulp met het schrijven van een library

@Allen

Er word al een tijd geen updates meer geplaatst in dit draadje, dit komt omdat ik de AAMS op de proefbaan goed werkend heb, ik kan de sturing niet uitgebreider testen voordat mijn modelbaan klaar is (railsen leggen)  de modelbaan is een stuk groter als mijn proefbaantje.

Ook ben ik bezig om met het programma Itrain te leren werken, ik heb twee digitale locomotieven (Selectrix) ik vind het zonde om deze locomotieven niet te gebruiken.
Ik heb een flink aantal selectrix sturingen liggen die ik graag zou willen gebruiken.

Een digitale sturing heeft zeker een voordeel ten opzichte van analoog, (oa, onafhankelijk rijden met meer locomotieven op de baan)

Zins kort is er ook een draadje op het forum "Arduino en Selectrix" , dit heeft zeker mijn interesse omdat een gedeelte van mijn baan digitaal word gestuurd (Selectrix)  en een gedeelte Analoog (AAMS).

Het zou mooi zijn als ik met de computer ook het analoge gedeelte (AAMS) van de baan kan sturen via Itrain, de locomotieven blijven analoog gestuurd maar de rest kan dan met Selectrix gestuurd worden.

Ik wil dit verder gaan uitwerken door het ontwikkelen van Selectrix sturingen met de Arduino, ik hoop een boel op te steken via het draadje "Arduino en Selectrix" de eerste opzet heb ik in dat draadje gezet, een wissel sturing gebaseerd op de Selectrix functiedecoder.

Hoewel de software nog ontwikkeld moet worden kan ik deze sturing wel al testen en een prototype, te bouwen om de werking te testen.

Het schema



Mvg Paul 

[Timo]

Het schema zal perfect werken alleen moet je op een ding letten. Als je de MOSFETs transistors niet aanstuurt (en dat is ook als de Arduino er dus niet aan zit of de Arduino de pin nog als input heeft/uit staat) ze gaan zweven. Ze kunnen dan zelf open gaan of deels open enz. Met warme MOSFETs transistors en wisselspoelen tot gevolg. Ik zou dus nog even een pulldown aan de Arduino stuurpoorten maken. Deze zorgen er dan voor dat de MOSFETs transistors dicht blijven. Zeker omdat de Arduino zijn voeding ergens anders van krijgt (SX-bus) kan het dus gebeuren dat je de spanning voor de wissels al aan hebt maar de SX-bus nog niet. Dan zweven je gates basis namelijk.


Timo

[gvandersel]

Timo,

SX-bus voeding is er meteen (230V ac --> trafo -> bruggelijkrichter -> SX-bus). Bij een Arduino zul je rekening moeten houden met de wachttijd van de bootloader. Dus zoals jij al zegt een pulldown bij de basis van de BD675 is zeker gewenst.

Groet,

Gerard van der Sel.

[Timo]

Daarom! Maar ik doelde er ook vooral op de de wissels niet uit dezelfde voeding komt als de SX-bus. Ook al is de voeding van de SX-bus straight forward is het nog steeds mogelijk deze niet ingeplugd te hebben als de voeding van de wissels al aan staat.

De tijd van de bootloader is bij de huidige Uno bij power on niet zo lang (slaat dan bootloader over na de power on check). Maar inderdaad, het is niet gelijk dus een pulldown zou deze beide problemen oplossen. 10k of 100k zou het al moeten doen.


Timo

[smits66]

Hoi volgers

Ik heb even geen tijd gehad om een update te maken.

@Gerard en Timo

Bedankt voor jullie input.
Ik was er als eerder op gewezen dat er beter pulldown weerstanden gebruikt kunnen worden. 


Ik heb de Selectrix Functie decoder 66821 bekeken en aan de hand van de koperbanen een schema gemaakt.

Een niet volledig schema van de functie decoder, ik mis nog een aansluiting op de SX-Bus (SX-Bus heeft 5 aansluitingen, er zijn er vier uitgezocht) en nog een paar aansluitingen bij de processor.

Al met al geeft het een goed beeld hoe de Selectrix functie-decoder gemaakt en ontworpen is.



De SX-bus word intern niet gekoppeld met de uitgangen van de functie decoder.
De uitgangen worden via een gelijkrichter op de print ( 1 en 2) verbonden.

De SX-bus word Alleen gebruikt voor de processor(80C48C)  in de Functie decoder, er is geen koppeling met de outputs 3 tm 14 met de SX-bus, dit loop via een eigen voeding (1 en 2).

Het schema van 1 van de uitgangen.



Er zijn nog wel een aantal Selectrix componenten die ik wil uitzoeken, hoe het werkt.

Mvg Paul 

[Timo]

De SX-bus wordt Alleen gebruikt voor de processor(80C48C)  in de Functie decoder, er is geen koppeling met de outputs 3 tm 14 met de SX-bus, dit loop via een eigen voeding (1 en 2).

Ik denk dat je daarmee bedoelt, alleen de microcontroller wordt gevoed uit de SX-bus. Voeding van de wissels geschiet via een eigen voeding (met gelijkrichter).

Wat de koppeling is er wel degelijk! Intern is de GND van de microcontroller (en dus de SX-bus) en de GND waarnaar de wissels schakelen dezelfde. Er is geen elektrische isolatie (door middel van een optocoupler ofzo) daartussen.


Timo