H0 Modelspoor Forum
Onderhoud, reparatie en ombouwtechniek => Mechanische techniek => Topic gestart door: Rob op 17 juli 2017, 22:42:32
-
Hier een projectje dat ik al een tijdje geleden heb gedaan: een Fleischmann handdraaischijf aandrijven met een stappenmotor, besturing met een Arduino.
Het geheel heeft ongeveer 25 euro gekost (inclusief de 12,50 voor de draaischijf op Marktplaats), dus voor de prijs hoef je het niet te laten. De draaischijf wordt als segmentdraaischijf later in een kopstation ingebouwd. Maar met de stappenmotor is de draaischijf ook helemaal rond te draaien, dus deze ombouw is ook te gebruiken voor 'echte' draaischijven. (ik had op enig moment bijna spijt om er een segmentdraaischijf van te maken).
Benodigdheden:
- Een handdraaischijf van Fleishmann
- Een Arduino microcontroller
- Een stappenmotor (ik heb de stappenmotor gebruikt die in het Arduino assortiment zit)
- Een beetje programmeerkennis (voor het programmeren van de Arduino)
- en wat schroefjes, boutjes, draadjes enzo.
Dit is de basis
(http://www.xs4all.nl/~robvd/Forum/draaischijf01.jpg)
De mechanische kant eerst maar eens aangepakt. De brug van de draaischijf zit met een soort popnageltje vast aan de basis (de kuil). Die voorzichtig los gemaakt.
(http://www.xs4all.nl/~robvd/Forum/draaischijf02.jpg)
(http://www.xs4all.nl/~robvd/Forum/draaischijf03.jpg)
Op de stappenmotor (met 1:64 vertraging) zit een as met platte kanten. Het gat in de brug heb ik voorzichtig uitgevijld tot deze klem over de as van de motor gaat.
(http://www.xs4all.nl/~robvd/Forum/draaischijf04.jpg)
Daarna provisorisch de boel gemonteerd, en de brug loopt af en toe vast. Dat kan geen kwaad voor de stappenmotor zelf, maar nauwkeurig draaien en stoppen voor de sporen wordt zo wel een probleem. Na wat onderzoek zijn het de railcontacten die af en toe haken of stroef lopen. Die contacten zijn niet echt nodig, want de sporen worden apart van stroom voorzien en de brug heeft 2 glij contacten om stroom op te nemen. Dus de rail contacten zo verbogen dat ze nauwelijks nog tegen de randen veren.
(http://www.xs4all.nl/~robvd/Forum/draaischijf06.jpg)
Ook zitten er een soort van nokjes onder de rails. Hier klikt de brug enigszins in vast. Handig bij bij handbediening, maar ook niet meer nodig. Die vijlen we ook maar weg.
(http://www.xs4all.nl/~robvd/Forum/draaischijf07.jpg)
Tijd om de motor goed te bevestigen. Het gat in het midden groter geboord, zodat de as van de motor er doorheen kan. Ook 2 gaatjes geboord voor de bouten waar de motor mee wordt vast gezet. Twee M4 boutjes en moeren volstaan.
(http://www.xs4all.nl/~robvd/Forum/draaischijf08.jpg)
(http://www.xs4all.nl/~robvd/Forum/draaischijf09.jpg)
Een sensor is met name nodig bij het starten van draaischijf als de stroom weer aan gaat om te weten waar de beginstand is. De sensor is de verbinding een van de buitenste rails en een rail van brug geworden. Ik heb de contactjes weer iets teruggebogen.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf11.jpg)
Daarna bleek het erg moeilijk de brug zuiver te laten bewegen en op de goede plek te laten stoppen. Het bleek dat de draaischijf constructie niet erg stabiel is ( de bodem tordeert makkelijk). Maar er zitten 3 schroefgaten onder de afdekplaatjes, dus eerst maar eens een stabiele ondergrond gemaakt uit een stevige spaanplaat van een afgedankte IKEA koffietafel.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf12.jpg).
De ondergrond helpt, dus klaar voor een uitgebreidere test. De bewegingen voor:
- V60: soepel
- BR64: soepel
- BR78: soepel
- V160: stroef en onnauwkeurig
- V100: stroef en onnauwkeurig
Wat blijkt: locs met een goede gewichtsverdeling in het midden of over de hele lengte draaien heel sopel op de brug, maar locs met het gewicht op de uiteinden (draaistellen), geven veel druk op de plastic wieltjes en rails. De wrijving wordt te groot....
Uiteindelijk bleek dit op te lossen door de hoogte van de brug op de as nauwkeurig af te stellen. Een ringetje zorgt voor de juiste afstand.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf14.jpg)
Nu doen zowel de V60 als V160 het goed.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf15.jpg)
(http://www.xs4all.nl/~robvd/Forum/Draaischijf16.jpg)
De test van het oprijden, draaien en afrijden met de BR64 is vastgelegd op film:
Dus klaar voor de definitieve aansturing met de Arduino Nano (veel goedkoper dan zijn grote broer).
Om het een en ander in te kunnen bouwen in een compact schroeven-doosje van de bouwmarkt, zijn er andere pinnen gebruikt dan op de grote Nano, maar met wat andere definities in het stuurprogramma is dat snel op te lossen. Verder is de controller van de stappenmotor hier ingebouwd en is een 7-polige platte kabel voor het bedieningspaneel aangesloten: massa, plus, sensor en 4 draadjes voor de terugmeldings-LEDs.
De mini-USB aansluiting wordt straks ook gebruikt als voedingskabel. Het geheel trekt minder dan 500mA, dus kan makkelijk op een telefoonlader draaien.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf18.jpg)
Het bedieningspaneel is nog even los opgezet, zodat de knoppen en de LEDs later in het paneel van het station kunnen worden ingebouwd. Spanningsverdeler met 4 knoppen , 1 voor elk spoor, en 4 LEDs, ook voor elk spoor. Als je een knop indrukt, gaat de LED erbij knipperen zolang de draaischijf naar het spoor aan het draaien is. Eenmaal op de plek aangekomen brandt de led continue.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf19.jpg)
Nog even een overzicht van de gehele constructie.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf20.jpg)
En @mark mms , zal ik de Arduino sketch ook nog ergens neerzetten?
Rob
-
Dat is een mooie duidelijke uitleg van een interessant project.
-
En mark mms, zal ik de Arduino sketch ook nog ergens neerzetten?
Niet dat ik Mark ben, maar ik vind dat wel een goed idee. Mooi project, en mooi om na te bouwen!
-
Mooie beschrijving.
Blijf ons verrassen.
Ik ben natuurlijk zo analoog als een spaarvarken, maar dat principe van die stappenmotor verdient bij mij ook nog wel enige uitleg.
Ik heb ooit een draaischijfje voor H0e gemaakt...
(http://www.mijnalbum.nl/Foto-WAYXPGOM-D.jpg)
....maar daar zat een servo onder omdat die draaischijf niet helemaal rond hoefde te draaien. ::)
-
Voor de Arduino ingewijden, hier de 'sketch' waarmee de draaischijf wordt bestuurd.
Belangrijkste zaken:
- op de as zit speling ('slack'), die vooral opspeelt bij het veranderen van draairichting. Daar compenseert de software voor
- de knoppen zitten op een spanningsdeler (rijtje weerstanden tussen + en -) op een analoge input. Daarmee heb ik minder draden nodig (3) om de vier knoppen uit te lezen dan dat elke knop op een input pin zou zitten (5). De spanningsverdeler werkt niet precies in stappen van 1 volt, maar dat maakt niet uit, zolang het verschil maar groot genoeg is om de ingedrukte knop nauwkeurig te kunnen lezen.
- Bij het opstarten wordt de brug een beetje een kant op bewogen, om vervolgens weer terug te draaien naar de 'sensor' rail, Dit is dan het nulpunt waar vanuit alle bewegingen naar de andere sporen worden uitgeteld in stappen.
- De stappenmotor bediening is gedaan me Accelstepper. Daarmee kun je eenvoudig van een punt naar een andere draaien met een ooie versnelling en vertraging.
- Commentaar in de sketch is in het Engels... Voormalige beroepsdeformatie.
Daar gaat-ie dan:
/*
* Turntable control
* (partial turntable. 4 tracks at 15 degrees angle)
*/
/*-----( Import needed libraries )-----*/
#include <AccelStepper.h>
/***** Declare Constants and Pin Numbers *******/
#define FULLSTEP 4
#define HALFSTEP 8
// motor pins
#define motorPin1 12 // Blue - 28BYJ48 pin 1
#define motorPin2 11 // Pink - 28BYJ48 pin 2
#define motorPin3 10 // Yellow - 28BYJ48 pin 3
#define motorPin4 9 // Orange - 28BYJ48 pin 4
// sensor pins (analog)
#define startPin A0 // pin to detect turntable start position
#define buttonsPin A1 // analog pin to read buttons
# define trackled1 5 // led for track 1
# define trackled2 4 // led for track 2
# define trackled3 3 // led for track 3
# define trackled4 2 // led for track 4
const int ledpin = 13; // LED on Arduino
// Turntable
const int slack = 11; // steps of slack in stepper motor axel from middle
const int startcorr = 16; // steps to move further after sensor active
const int initMove = -70; // steps to move at initialisation before sensor read
// Led display
unsigned long prevms = 0; // blinking led milisecs last on/off
unsigned long curms = millis(); // blinking led milisecs now
const long blnkint = 250; // blink interval
/******* Global variables ******/
// Turntable variables
int currentTrack = 0; // position after initialisation
int newTrack = 2; // 1st position to move to after initialisation
int prevTurnDirection = 0; // prev direction in Turntable = calculate for slack in movement
int curTurnDirection = 0; // current direction in Turntable = calculate for slack in movement
int button = -1; // button pressed (0, 1 2 or 3, -1 is no button)
int track[] {0, -174, -343, -514}; //positions for 4 turntable tracks (motor steps from 0)
// Led display variables
int ledPins[] {trackled1 ,trackled2, trackled3, trackled4}; // array to light op track moving to or pointing at
int blnk = HIGH;
/****** Objects *******/
// NOTE: The sequence 1-3-2-4 is required for proper sequencing of 28BYJ48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
/****** Functions ******/
// ---- initialiation ----
// Turntable initialisation after starting/resetting Arduino.
// It moves turntable clockwise untill last track is sensed and then
// positions turntable exactly in front of the last track.
// When last track sensed directly, it assumes turntable is positioned
// precisely in front this track already and no movement is done.
// maximum steps is 700. When last track not sensed, error is returned.
bool initTurntable () {
bool succesfull = true; // return parameter
int x = 0; // step counter
digitalWrite (ledpin,LOW); // show initialisation ongoing on Arduino board
// move turntable into start / reset position
stepper1.setMaxSpeed(500.0);
stepper1.setAcceleration(500.0);
stepper1.setSpeed(500);
// start with a move counterclockwise in case just beyond sensor...
x = initMove;
// now keep turning the table slowly until start point sensed
do {
stepper1.runToNewPosition(x);
x++;
} while ( (digitalRead (startPin) == HIGH) && (x<700) ); //run until sensor active, max 700 positions (error)
if (x < 700) { // start position sensed. Intialise stepper position
stepper1.setCurrentPosition(startcorr);
digitalWrite (ledpin,HIGH); // end of initialisation
} else { //initialisation error
succesfull = false;
}
stepper1.disableOutputs(); // Turn off stepper motor power
return succesfull;
}
// ---- read button sensor ----
// function to get button from analog pin
// returns button 0-3 pressed.
// returns -1 if no button pressed
int getButtonPressed () {
int r = analogRead (buttonsPin);
int b = -1;
if (r < 900) { // a button was pressed
b = 3 ;
if ( r < 750) {
b = 2;
}
if (r < 600) {
b = 1;
}
if (r < 300) {
b = 0;
}
}
return b;
}
// ---- turntable movement calculation ----
// function to calculate new position for turntable to move to
// input: new track number
// output: new stepper position with corrections mechanical inaccuracies
int calcNewPosition (int trk) {
int pos = 0;
// consider slack when change in direction
if ( newTrack > currentTrack ) {
prevTurnDirection = -1;
} else {
prevTurnDirection = 1;
}
currentTrack = newTrack;
newTrack = trk;
// Init new move
// check direction for additional slack movement.
//calculate new stepper position
if ( newTrack > currentTrack ) {
curTurnDirection = -1; //clockwise
} else {
curTurnDirection = 1; //counter clockwise
}
// calculate position to move to
pos = track[newTrack]; //bare track position
pos = pos + (- slack * (prevTurnDirection - curTurnDirection)); // slack correction in case direction changes
if (abs(abs(newTrack) - abs(currentTrack)) == 1 && (prevTurnDirection == curTurnDirection) ) { // adjecent tracks and same direction
pos = pos + (curTurnDirection*18);
}
return pos;
}
// led on / of / blink function
// input: led number
// func: 0 = off, 1=blink, 2 = on
void setLed (int led, int func) {
if (func == 0) {
digitalWrite(ledPins[led], LOW);
}
if (func == 2) {
digitalWrite(ledPins[led], HIGH);
}
if (func == 1) {
curms = millis();
if (curms - prevms >= blnkint) {
prevms = curms;
if (blnk == HIGH) {
blnk = LOW;
} else {
blnk = HIGH;
}
digitalWrite(ledPins[led], blnk);
}
}
}
/****** SETUP: RUNS ONCE ******/
void setup()
{
bool init = false; // turntable intialisation status
int x = 0;
// set the digital led pins as output and initialise values
while (x<4) {
pinMode(ledPins[ x ], OUTPUT);
analogWrite (ledPins[ x ], 255);
digitalWrite (ledPins[ x ], HIGH); // show: initializing: all track leds on
x++;
}
pinMode (ledpin, OUTPUT);
digitalWrite (startPin,HIGH); // initialise startpin high
digitalWrite (buttonsPin,HIGH); // initialise button read
// turntable initialisation
init = initTurntable() ; // initialise turntable.
while (not init) { // Blink led indefenitely if initialisation returns an error
digitalWrite(ledpin,HIGH);
delay(100);
digitalWrite(ledpin,LOW);
delay(100);
}
x=0;
while (x<4) { // switch of track leds
digitalWrite (ledPins[ x ], LOW);
x++;
}
// Setings for speed and accelaration during normal operation
stepper1.setMaxSpeed(65.0);
stepper1.setAcceleration(100.0);
stepper1.setSpeed(20);
// move to initial track
stepper1.moveTo(track[newTrack] - 2* slack);
stepper1.runSpeed();
}//--(end setup )---
/****** LOOP: RUNS CONSTANTLY ******/
void loop()
{
stepper1.run(); // operate the stepper motor
if (stepper1.distanceToGo() == 0) { // turntable at desired position
stepper1.disableOutputs(); // turn stepper motor off (all pins low)
setLed (newTrack,2); //turn on led for track positioned to/
button = getButtonPressed (); // check if a button was pressed
if (button > -1 && button != newTrack) { // button pressed for another track than positioned on
setLed (newTrack,0); //turn off led for this track, we're moving away from it.
stepper1.moveTo(calcNewPosition(button)); // ca;culate new stepper position and move to it.
}
}
else { // turntable turning (moving to desired position)
setLed (newTrack,1) ; // blink the led for the track where is moving to
}
}//--(end main loop )---
//*********( THE END )***********
groeten,
Rob
-
Ik ben natuurlijk zo analoog als een spaarvarken, maar dat principe van die stappenmotor verdient bij mij ook nog wel enige uitleg.
Hoi Wim,
Oefff... Even een stappenmotor uitleggen gaat misschien een beetje ver.
Maar in het kort komt het er op neer dat je een rotor hebt met vaste magneten heel veel N-polen en vlak erbij heel veel Z-polen. Daaromheen zitten ook heel veel spoelen, vaak in 2 groepen. Door de groepen met spoelen om de beurt aan te zetten, maakt de rotor steeds een stapje.
Anders ff googlen voor een duidelijker uitleg.
In ieder geval kun je met een stappenmotor heel nauwkeurig bewegingen maken, al is de aansturing wel wat complex.Maar daar komt de Arduino in beeld. Hoe de stappenmotor beweging precies tot stand komt hoef je ook niet te weten. Anderen hebben daar al iets op verzonnen, in dit geval de Accelstepper 'bibliotheek' die je kunt downloaden en gebruiken.
Ik heb eens rondgelezen op de site van de snuiters die deze bibliotheek in elkaar gezet hebben, en dan kom je allemaal wetenschappelijke verhandelingen tegen hoe je de versnelling en vertraging en constante beweging van een stappenmotor moet berekenen.
Dat heb ik verder allemaal niet gelezen, maar geeft wel aan dat er goed over is nagedacht.... En dat blijkt ook wel, het werkt allemaal goed.
groeten,
Rob
-
Top werk
Sta zelf op het punt om een dergelijke schijf zelf te printen
de aansturing had ik ook in mijn hoofd om op deze manier aan te sturen, alleen was ik van plan om per spoor een microsensor in te bouwen
ben er nog niet (eerst maar eens printen...)
nog tips waar ik rekening mee moet houden ?
verder echt super uitvoering
-
The Breeze,
Gaaf dat je een draaischijf gaat printen.
De beste tip die ik nu heb is: zorg voor een stabiele constructie. Mijn ervaring met dit project en andere aandrijvingen is dat buigen en torderen van de constructie de wrijving onvoorspelbaar maken. En dan wordt elke aandrijving onbetrouwbaar.
En verder is een stappenmotor met vertraging nodig (al geeft dit meer speling op de as).
Ook kun je alvast nadenken of de draaischijf helemaal rond moet gaan en hoe je de rails dan van stroom voorziet. Op zich zijn sleepcontacten niet nodig: met een microcontroller is het vrij eenvoudig te voorkomen dat de draaischijf te veel rondes één kant op draait. Ook de polariteit wisselen na een halve draai kun je vanuit de microcontroller regelen (even ervan uitgaande dat je 2 rail gelijkstroom rijdt). Op dit draajschijfje wisselt de polariteit met de sleepcontacten in het midden.
We zijn natuurlijk benieuwd naar de vorderingen van een geprinte draaischijf!
Rob
-
Rob bedankt!
Weer een sketch om uit te pluizen.
Dit moet een hele klus zijn geweest om deze uit te werken.
Top dat je hem wilt delen.
-
Weer een sketch om uit te pluizen.
Dit moet een hele klus zijn geweest om deze uit te werken.
Top dat je hem wilt delen.
Ja, zo'n sketch maken is wel een klusje. Maar meestal doe ik het in delen en voeg de boel dan later samen. Ongeveer in deze stappen:
Zo heb ik eerst een programmatje gemaakt om de brug heen en weer te bewegen;
Daarna een standaard beweging van de ene naar de andere positie (15 graden in stappen uitgerekend);
Vervolgens de 'nul 'positie bepaling bij het opstarten;
Dan 'random' naar 1 van de vier posities;
Gevolgd door de knoppen en hun bediening;
Vervolgens empirisch bepaald hoe groot de speling is en net zo lang de posities met stapje erbij, stapje eraf precies uitlijnen op elk van de sporen;
Daarna de leds toegevoegd (knipperen en aan).
En maar testen tussendoor...
Als je het in stukjes doet valt het wel mee...
En als je ergens niet uit komt bij het uitpluizen: laat maar even weten.
Rob
-
Gaaf dat je een draaischijf gaat printen.
We zijn natuurlijk benieuwd naar de vorderingen van een geprinte draaischijf!
Rob
Ben nu op zoek naar de exacte maten, heb al iets gevonden maar een echte duidelijke maatgeving heb ik helaas nog niet gevonden)
is wel de bedoeling dat de schijf 360 gaat draaien (dus omkeren loc moet mogelijk zijn)
stabiliteit uiteraard
als de 1e print uit de printer komt zal ik de vorderingen hier plaatsen, maar eerst het ontwerp
Fred
-
Hoi Fred, ik heb nog wel een Fleischmann draaischijf kuil voor je, als je hem wil hebben stuur me een pb met je adres, tegen de verzendkosten stuur ik hem op.
-
Sorry weinig tijd gehad
Top aanbod maar niet nodig, heb de maten al gevonden en de kuil is het minste probleem
ontwerpen gaat nog wel even duren maar heb al een file gevonden (ook een draaischijf om te printen) en die kan ik aanpassen naar mijn wensen
komt goed mits er tijd te vinden is (das meestal een probleem....)
-
De draaischijf is ondertussen ingebouwd in het station.
Na nog wat aanpassingen (zoals een grotere hoek tussen 2 sporen om ruimte te maken voor een lokloods) is het tijd om ook de visuele afwerking te gaan doen.
De inspiratie is deze segmentdraaischijf.
(http://www.xs4all.nl/~robvd/Forum/kluutzdraaischijf1.jpg)
Hij wordt bij mij iets minder vervallen, maar wat hier (mij) aan opvalt:
Lekker veel roest op het loopvlak
De kleur is de befaamde grijs-groen
De bodem van de kuil is grind of zand (met begroeiing)
De rand springt in
Goed eerst die rand dan maar. In eerste instantie dacht ik deze recht te maken.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf1.jpg)
Maar dan lopen de beide kanten niet helemaal parallel (vanwege de uitbouw voor de bediening aan een kant) en dat vond ik er raar uit zien.
Dus dan toch maar rond. Ik heb een klei-muurtje opgetrokken op het randje waar de rails op ligt.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf2.jpg)
Dat oogt beter.
Dan de bodem: er zitten een soort van randjes om staal- of betonplaten te imiteren. Die schraap ik weg. Ik wil hier straks zand in strooien.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf3.jpg)
Maar voor er gestrooid wordt wil ik eerst het verfwerk een beetje af hebben. De betonrand krijgt een grijze kleur (dicht tegen de oorspronkelijke kleur aan, ik wil niet verven waar de draaischijf brug over de bodem glijdt).
Vervolgens met bruintinten al het 'staal' roestig gemaakt. De putjes in de bodem van de kuil heb ik laten zitten. Dat vond ik wel een leuk detail.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf4.jpg)
Ik gebruik een donker bruin, die ik wat vlekkerig maak met nat-in-nat beige. Daarna nog een dry-brush met beige. Links is die dry-brush al gedaan, rechts nog niet.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf5.jpg)
Ik kan nog niet gaan strooien zolang de verf niet droog is, dus dan eerst de brug maar aangepakt.
Eerst een hekwerkje plaatsen.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf6.jpg)
Dan lekker met de kwast er tegenaan met bruin en een zelf gemengde grijs/groen.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf7.jpg)
En als laatste nog wat dry-brush met bruin en beige.
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf8.jpg)
En ja, de hekjes staan inderdaad iets schuin naar buiten. Anders schuren de loks er langs.
Nu de hele boel laten drogen en dan kan de bodem van de kuil worden afgewerkt.
groeten,
Rob
-
Mooi gedaan Rob. ;)
Ik vind het wel een beetje jammer van die naar buitenstaande hekjes. Kan je niet gewoon een stripje tegen de brug plakken waar je het hekje tegenaan plakt? Ik weet het ... een beetje mosterd na de maaltijd maar nu kan het nog.
-
Ik vind het wel een beetje jammer van die naar buitenstaande hekjes. Kan je niet gewoon een stripje tegen de brug plakken waar je het hekje tegenaan plakt? Ik weet het ... een beetje mosterd na de maaltijd maar nu kan het nog.
Hoi Pierre,
Ik hou het even in gedachten. Ik vind de neigende hekjes nog wel plausibel te praten: zuinig gebruik van materiaal, ook in het grootbedrijf. Maar ik kan de brug altijd vrij eenvoudig demonteren en aanpassen.
Rob
-
...zuinig gebruik van materiaal, ook in het grootbedrijf.
Mooie uitleg, die ga ik een keer van je lenen. ;D
Maar ik kan de brug altijd vrij eenvoudig demonteren en aanpassen.
Dat zou ik doen. Dat haalt het hele project naar een hoger level.
Komt er nog een huisje op die draaibrug?
-
Maar ik kan de brug altijd vrij eenvoudig demonteren en aanpassen.
Dat zou ik doen. Dat haalt het hele project naar een hoger level.
Komt er nog een huisje op die draaibrug?
De groepsdruk neemt weer toe :o Ik ga er dan toch nog eens naar kijken.
Nee, geen huisje op de draaibrug. Er is te weinig bedrijf om vast personeel op de draaischijf te zetten. Misschien moet de stoker zelfs wel even uitstappen om de brug te draaien.
Rob
-
Gewoon de hekjes rechtop gebogen en....
Het past net!
(http://www.xs4all.nl/~robvd/Forum/08_Draaischijf9.jpg)
En er is zelfs nog een beetje ruimte voor de speling op de assen.
Dank voor de pressie heren. Dit was wel een heel simpele fix.
Rob
-
Veel beter zo Rob. Top! ;)
-
De groepsdruk neemt weer toe :o
“Groepsdruk” mooie uitdrukking! Groepsdruk houdt voor mij de stoom op de ketel en zonder die eigenwijze mierenneukers hier op dit forum zou ik nooit zover zijn gekomen. :)
-
Mooie draaibrug Rob! Vind het een interessant station worden, ik kijk uit naar het eind resultaat!
-
Groepsdruk houdt voor mij de stoom op de ketel en zonder die eigenwijze mierenneukers hier op dit forum zou ik nooit zover zijn gekomen. :)
Klopt, Wim. Dat geldt voor mij ook (zowel het eigenwijs zijn als het verder komen onder druk).
-
Hallo Rob,
Hoe staat het met de draaischijf?
Doet hij het zoals verwacht, of zou je nog dingen aanpassen als je het nogmaals zou doen?
Mijn neefje wilt graag een modelbaan bouwen met een draaischijf.
Aangezien hij alles zelf moet betalen is een draaischijf een dure grap.
Wellicht kan ik iets voor hem maken.
-
Hoi Mark,
De draaischijf doet het goed. Hij is niu regelmatig in bedrijf en geeft eigenlijk weinig problemen. Heel soms is de uitlijning met de sporen niet helemaal goed, en dan is een reset van de Aruino voldoende.
Ik heb na het inbouwen nog wel wat uren zitten pielen om alles goed en betrouwbaar te krijgen. Vooral ook omdat, zoals later bleek, de brug niet meer goed klem zat op de as van de motor en daarmee een onvoorspelbare speling gaf. Dit kwam met name door vele tests en/of haperingen tijdens de provisorische aansluitingen waardoor de stappenmotor wel eens bleef lopen als de brug al op een eindpunt zat.... Toen ik daar achter was en de brug heb vastgezet (eerst natuurlijk ook alles optisch afgewerkt) ,was het draaien goed in te stellen en sindsdien werkt het allemaal betrouwbaar.
De constructie hier, met de brug direct op de as van de stappenmotor, werkt wel, maar vereist wel het nodige geduld en afstellen, zowel mechanisch als in de software.
Dus misschien niet helemaal geschikt voor neefjes.
Achteraf gezien zou ik een volgende keer werken met een groot tandwiel onder de brug en een klein tandwieltje op de stappenmotor. Dat is mechanisch wat ingewikkelder te maken, maar minder kritisch in het afstellen, denk ik. Wellicht zoiets als dit.
Kortom: het resultaat is als verwacht, maar de weg er naar toe was moeizamer dan voorzien.
Misschien kun je hier iets mee.
Rob
-
PS:
Leuk dat je je neefje helpt bij de modelspoorbaan.
En hier nog een filmpje van de draaischijf in werking (nog van voor mijn ATF experimenten)
Rob
-
Bedankt voor de info.
Ga toch nog eens kijken of ik een stappenmotor kan aansturen met Arduino.
Daarna zien we wel verder.
-
Mark,
Die stappenmotor aansturing heb je sowieso nodig, dus dat is een goed begin.
Succes!
Rob
-
Hallo Rob,
Ik heb zojuist een poging gedaan om een stappenmotor aan te sturen.
Ten eerste gebeurde er helemaal niets, bleek dat ik niet de juiste bibliotheek had.
Na het downloaden van "accel.stepper" kon ik de sketch wel gebruiken.
Als ik de sketch goed lees dan,
moet de motor op 9+10+11+12 (naar printplaatje van 1N1+1N2+1N3+1N4)
leds op 2+3+4+5 (en dan aan de GND???)
push button op A0 (en dan aan de GND???)
push button op A1 (en dan aan de GND???)
Op de foto's heb je verschillende weerstanden bij de leds enz.
Ik ben bang dat ik het helemaal verkeerd doe.
Heb je toevallig een schets van de aansluitingen?
Bvd Mark
-
Hoi, Misschien is dit ook bruikbaar, ik heb zelf de stappenmotor (28BYJ-48) aangestuurd in JALedit.
Deze taal is erg makkelijk.
Ik heb hem bij de workshop PIC programmeren gezet.
Misschien kan je er wat mee.
Theo
-
Hee Mark,
Je bent goed op weg. ik heb geen aansluitschema bij de hand, maar laat ik proberen antwoord te geven op je vragen.
moet de motor op 9+10+11+12 (naar printplaatje van 1N1+1N2+1N3+1N4)
Klopt
leds op 2+3+4+5 en dan aan de GND
inderdaad, maar met een weerstand van 100 ohm er tussen (Ik heb 1 weerstand genomen van de ground naar alle leds. Dat voldoet omdat in normaal gebruik slechts een led aan is).
push button op A0 (en dan aan de GND???)
push button op A1 (en dan aan de GND???)
De input pinnen werken een beetje anders.
A0 is de beginpositie sensor. Je weet bij het aanzetten van de Arduino niet waar de stappenmotor is gestopt voor de Arduino uit ging. Je moet dus een beginpositie 'voelen', waarvandaan alle andere standen uitgeteld worden (aantal stappen vanaf beginpositie).
Op pin A0 zit een schakelaar die wordt ingedrukt als de draaischijf de beginpositie inneemt. Ik gebruik hiervoor een van de spoorstaven maar je kunt ook een microswitch gebruiken. A0 wordt via de schakelaar (of rail) met de ground verbonden (maak contact).
In het programma gaat de stappenmotor eerst 70 stappen tegen de klok in (zodat-ie altijd weg is van de beginpositie), en gaat dan kleine stapjes met de klok mee, totdat de beginpositie wordt gedetecteerd. Van daaruit start het gewone programma, en draait de brug naar een eerste spoor.
Om eindeloos zoeken (en potentieel kapot draaien) te voorkomen, stopt dit zoeken naar de beginpositie na 700 stappen met een foutmelding (snel knipperende led op de Arduino). Dit is vooral handig bij het bouwen en testen.
Om te testen kun je na het starten van de Arduino pin A0 even verbinden met de GND.
Op A1 heb ik vier knoppen zitten (één voor elk spoor) in een zogenaamde spanningsdeler. Hiermee heb ik slechts 1 pin nodig, en wat minder draden dan elke knop op een afzonderlijke pin. Omdat dit een analoge pin is, kan ik uit de waarde opmaken welke knop is ingedrukt.
Het werkt als volgt: er zijn 4 weerstanden van 10 k-ohm in serie geschakeld tussen de +5V en de GND. Hier loopt dan een kleine stroom door en de spanning wordt in 4 stappen 'gedeeld' Afhankelijk van welke knop wordt ingedrukt leest de pin (ruwweg) 0 - 1,25 - 2,5 - 3,75 Volt uit (geen knop is 5 Volt).
Klinkt misschien wat ingewikkeld (ik had bij het ontwerp geen rekening gehouden met gebruik door anderen), maar op een foto ziet dat er zo uit.
(http://www.xs4all.nl/~robvd/Forum/Draaischijf21.jpg)
Aan de rechterkant de aansluiting van de Arduino: rood = 5V, bruin = pin A1, zwart = GND
Op elk knooppunt van de weerstandjes zit een drukknop, die aan de andere kant verbonden is met de input pin. De meest linkse knop is direct verbonden met de GND. Elke knop geeft daarmee een andere spanning op de pin, die als waarde tussen 0 en 1024 met analogRead wordt uitgelezen.
Op zich werkt dit goed, maar je kunt natuurlijk ook gewoon 4 pinnen gebruiken, elk met een knopje. Dan hoef je alleen de functie "getButtonpressed" aan te passen. Deze geeft waarde 0, 1, 2 of 3 terug als er een knop is ingedrukt (en -1 als geen knop is ingedrukt)
Ook zie je aan de onderkant van de foto de ledjes, met de gezamenlijke weerstand naar de GND.
Hoop dat dit helpt. Blijf anders gewoon vragen, hoor.
Rob
-
Rob, bedankt.
Vanavond of morgen avond ga ik weer proberen.
Als alternatief voor een draaischijf, was ik aan een rolbrug aan het denken.
Basis een lineaire stappenmotor van tante Ali.
https://nl.aliexpress.com/item/3D-Printer-guide-rail-sets-T8-Lead-screw-length-400mm-linear-shaft-8-400mm-KP08-SK8/32826927275.html?spm=a2g0z.search0104.3.47.5c4f2485dVFUuU&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10084_10083_10618_10630_10304_10307_10301_5722316_5711211_10313_10059_10534_100031_10629_10103_10626_10625_10624_10623_10622_10621_10620_10142,searchweb201603_25,ppcSwitch_5&algo_expid=adda698d-bfec-4a7d-ab3a-d89a6cc531ef-7&algo_pvid=adda698d-bfec-4a7d-ab3a-d89a6cc531ef&priceBeautifyAB=0 (https://nl.aliexpress.com/item/3D-Printer-guide-rail-sets-T8-Lead-screw-length-400mm-linear-shaft-8-400mm-KP08-SK8/32826927275.html?spm=a2g0z.search0104.3.47.5c4f2485dVFUuU&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10084_10083_10618_10630_10304_10307_10301_5722316_5711211_10313_10059_10534_100031_10629_10103_10626_10625_10624_10623_10622_10621_10620_10142,searchweb201603_25,ppcSwitch_5&algo_expid=adda698d-bfec-4a7d-ab3a-d89a6cc531ef-7&algo_pvid=adda698d-bfec-4a7d-ab3a-d89a6cc531ef&priceBeautifyAB=0)
-
Als ik dat zo bekijk kun je daar ook een portaalkraan mee aandrijven. @Pierre heeft dat ook een keer gedaan, maar dan natuurlijk zonder hulp van Tante Ali.
-
Hoi mark,
Als alternatief voor een draaischijf, was ik aan een rolbrug aan het denken.
Basis een lineaire stappenmotor van tante Ali.
Dat kan natuurlijk ook. Principe blijft hetzelfde: Een kant kiezen als "0"positie en daar een schakelaar (sensor) zetten. De andere sporen zijn dan gewoon uit te tellen. En met zo'n lineaire stappenmotor ben je ook heel nauwkeurig. De constructie van Ali ziet er stabiel uit en met 40cm lengte kun je ook wel wat sporen aansluiten.
En met de levertijd van tante Ali heb je ook nog even tijd om het stappenmotor gebeuren onder de knie te krijgen :)
Ook kun je alvast kijken wat je over de stappenmotor 17HS2408S te weten kunt komen (spanning en stroomsterkte), zodat je de juiste motorcontroller erbij kunt vinden.
Maar alles stap voor stap, hè!
Rob
-
Hallo Rob,
Ik heb hem aangesloten zoals je hebt uitgelegd, maar er gebeurt zeer weinig.
De sketch heb ik niet aangepast.
De motor draait heel klein beetje en heel erg langzaam.
De LEDs branden alle vier constant.
Na enige tijd gaat stopt de motor met draaien en begint er een ledje te knipperen op de arduino.
Motorshield 1N1+1N2+1N3+1N4 op arduino 9+10+11+12
Motorshield voeding op GND en 5V van de arduino (dat zijn zwart (-) en wit (+))
De LEDs rechtstreeks in 2+3+4+5 en dan op het board daaraan een weerstand 100 ohm en door naar GND van het board
Dan van de arduino met geel naar de drukknoppen.
Aan de andere zijde van de drukknoppen bruggetjes gemaakt van 10k Ohm.
Een zijde, direct aan de drukknop en het eerste bruggetje, is verbonden aan GND.
De andere zijde aan de 5V, rode draad via board naar de arduino.
(https://myalbum.com/photo/un9rOmrrIEI6_5jnOZZ/1k0.jpg)
Wat doe ik fout?
Chinese arduino zou het toch ook moeten doen?
-
Hee Mark,
Alles is goed aangesloten en het werkt, hoor!
Wat je ziet gebeuren is het bepalen van de 0-positie. Dat is het opstart gedeelte.
Het enige wat je moet doen is pin A0 even met de ground verbinden als de motor kleine stapjes maakt en de vier ledjes branden.
Dat is het signaal dat de 0-positie is gevonden. De motor draait daarna de andere kant op en een van de ledjes gaat knipperen.
Als de motor stopt brand het ledje continue, en dan ben je bij het 'spoor' aangekomen.
Vanaf dat moment moeten de knopjes het doen!
Als de A0 niet even met de ground wordt verbonden, dan stopt de motor na 700 stappen en knippert de Arduino LED snel. Dat is de 'foutmelding' dat de 0-positie niet is gevonden. Deze voorkomt dat er eindeloos naar de 0 positie wordt gezocht.
Rob
-
Joepie!
Het werkt!
Die A0 had ik over het hoofd gezien.
Maar hoe kan ik meer sporen aansluiten.
Ik heb het een en ander geprobeerd.
Hij gaat wel naar die positie, maar direct weer terug naar de uiterst rechtste positie.
Kun je aangeven welke regel(s) veranderd moeten worden om 1-2-3 sporen toe te voegen?
-
Hee Mark,
Gefeliciteerd!
Je werkt nu nog met een oude versie van de sketch. Sinds de inbouw van de draaischijf heb ik wat verbeteringen toegevoegd.
Zo was de het uitlezen van de knoppen niet helemaal betrouwbaar.
En was het uitrekenen van de motorpositie ingewikkeld (en niet helemaal juist).
Verder heb ik de sketch wat opgeschoond en geprobeerd alles in definities onder te brengen, zoals de snelheden, afstanden (ik denk dat je met een spindelmotor eerder duizenden dan honderden stappen moet maken) en het aantal sporen instellen.
Verder branden bij het begin nu alleen led 1 en 4.
Voor meer sporen zul je ook meer knopjes en meer leds nodig hebben.
Voor de knoppen kun je de spanningsdeler uitbreiden: gewoon meer weerstanden op een rijtje. Je moet dan wel even uitvogelen wat de analoge waarden worden.je kunt daar eventueel even een korte sketch voor schrijven die de waarde op print (serial print).
Precies tussen deze waarden zet je de grenzen op in (zie de nieuwe versie van de sketch hier onder, werkt niet in de oude versie):
int buttonBoundary[] {900, 750, 600, 300}; // voltage divider boundary values between buttons on buttonsPin
Let op: dit moet van hoog naar laag.
Verder kun je het aantal ledjes uitbreiden. Dat doe je met de pindefinities en in deze array:
int ledPins[] {trackled1 ,trackled2, trackled3, trackled4}; // array for light track moving to or pointing at
Het aantal sporen en de stappen naar elk spoor zet je dan hier op:
#define numberOfTracks 4 // number of tracks on turntable
// arrays below must correspond with number of tracks:
int track[] {-9, -185, -454, -624}; // positions for 4 turntable tracks (motor steps from 0)
Ik heb het meer sporen niet uitgeprobeerd, maar dat kun jij dan mooi testen...
Ook als je de ledjes niet hebt aangesloten, moet je toch net zovel leds definiëren als er sporen zijn. Je kunt natuurlijk ook de bestaande Leds hergebruiken, led 1 = spoor 1 en 5, led 2 = spoor 2 en 6, etc. Dat doe je bijvoorbeeld zo voor 8 sporen:
int ledPins[] {trackled1 ,trackled2, trackled3, trackled4, trackled1 ,trackled2, trackled3, trackled4}; // array for light track moving to or pointing at
Affijn, hier is de nieuwe versie:
/* Turntable control
* =================
* For a partial turntable. 4 tracks at angles of 15, 20 and 15 degrees
*
* Beschrijving (NL)
* Besturing voor eeen modelspoor segmentdraaischijf met 4 sporen.
* De draaischijf wordt aangedreven met een stappenmotor.
* Bediening met een '0-positie' sensor en 4 drukknoppen op een spanningsdeler
* Terugmelding over 4 LEDs: een LED voor elk spoor.
*/
/***** Import needed libraries ******/
#include <AccelStepper.h>
#define FULLSTEP 4
#define HALFSTEP 8
/***** Declare Pin Numbers *******/
// motor pins
#define motorPin1 12 // Blue - 28BYJ48 pin 1
#define motorPin2 11 // Pink - 28BYJ48 pin 2
#define motorPin3 10 // Yellow - 28BYJ48 pin 3
#define motorPin4 9 // Orange - 28BYJ48 pin 4
// sensor pins (analog)
#define startPin A0 // pin to detect turntable start position
#define buttonsPin A1 // analog pin to read buttons by Voltage divider
// led indicators pins
# define trackled1 5 // led for track 1
# define trackled2 4 // led for track 2
# define trackled3 3 // led for track 3
# define trackled4 2 // led for track 4
#define ledpin 13 // LED on Arduino
/******* Definitions for turntable control ******/
// ---- Turntable ----
// Physical definitions
#define slack 9 // steps of slack in stepper motor axel from middle
#define initMove -30 // steps to move at initialisation before sensor read
#define numberOfTracks 4 // number of tracks on turntable
// arrays below must correspond with number of tracks:
int track[] {-9, -185, -454, -624}; // positions for 4 turntable tracks (motor steps from 0)
int buttonBoundary[] {900, 750, 600, 300}; // voltage divider boundary values between buttons on buttonsPin
int ledPins[] {trackled1 ,trackled2, trackled3, trackled4}; // array for light track moving to or pointing at
// Operational definitions
#define startTrack 1 // initial track to move to (after detecting 0-position sensor)
#define maxTurnSpeed 55.0 // maximum speed of stepper motor normal operation
#define startTurnSpeed 20.0 // start speed of stepper motor
#define turnAccelleration 46.0 // acceleration of stepper motor
// ---- Led display ----
unsigned long prevms = 0; // blinking led milisecs last on/off
unsigned long curms = millis(); // blinking led milisecs now
const long blnkint = 250; // blink interval in milliisec.
/******* Global variables ******/
// ---- Turntable variables ----
int currentTrack = 0; // position after initialisation
int newTrack = 0; // 1st position to move to after initialisation
int button = -1; // button pressed (0, 1 2 or 3, -1 is no button)
// ---- Led display variables ----
int blnk = HIGH;
/****** Objects *******/
// ---- Stepper motor object ----
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
/****** Functions ******/
// ---- initialiation: 0-position detection ----
// Turntable initialisation after starting/resetting Arduino.
// It first moves the stepper motor counterclockwise (defined by initMove),
// and then moves the turntable clockwise slowly untill 0-positions is sensed
// on "startPin".
// Motor position "0"is set to the sensor position.
// Function returns "true" if sensor has been detected.
//
// Maximum steps is to find sensor: last track position + initial move steps.
// When 0 position is not sensed, function returns "false".
bool initTurntable () {
bool succesfull = true; // return parameter
int x = 0; // step counter
digitalWrite (ledpin,LOW); // show initialisation ongoing on Arduino board
// calculate total maximum number of steps (maxSteps) to find sensor:
// the number of steps to position of last track, including slack and initial move
int maxSteps = abs(track[numberOfTracks - 1]) + abs(initMove) +2*slack; // sensor must be found in less steps
// move turntable into start / reset position
stepper1.setMaxSpeed(1);
stepper1.setAcceleration(500.0);
stepper1.setSpeed(1);
// start with a move counterclockwise in case just beyond sensor...
x = initMove;
// now keep turning the table slowly until start point sensed
do {
stepper1.runToNewPosition(x);
x++;
} while ( (digitalRead (startPin) == HIGH) && (x < maxSteps) ); //run until sensor active, or until max steps done (error)
if (x < maxSteps) { // start position sensed. Intialise stepper position
stepper1.setCurrentPosition(0); // sensor position = 0
digitalWrite (ledpin,HIGH); // end of initialisation
} else { //initialisation error
succesfull = false;
}
stepper1.disableOutputs(); // Turn off stepper motor power
return succesfull;
}
// ---- read button sensor ----
// function to get button from analog pin
// returns button 0-3 pressed.
// returns -1 if no button pressed
int getButtonPressed () {
int r = analogRead (buttonsPin);
int b = -1;
if (r < buttonBoundary[0]) { // a button was pressed
delay(200); // wait for analog pin to stabalize
r = analogRead (buttonsPin);
// check which boundary value has been read on analog buttonPin
if (r < buttonBoundary[0]) {
b = numberOfTracks -1; // check lat button to first
while (r > buttonBoundary[b]) {
b--;
}
}
}
return b;
}
// ---- turntable movement calculation ----
// function to calculate new position for turntable to move to
// input: new track number
// output: new stepper position with corrections mechanical inaccuracies
int calcNewPosition (int trk) {
int pos = 0; // new stepper motor position
int curTurnDirection = 0; // current direction in Turntable = calculate for slack in movement
// keep values last move before calculating new move
currentTrack = newTrack;
newTrack = trk;
// Init new move
// check direction for additional slack movement.
// calculate new stepper position
if ( newTrack > currentTrack ) {
curTurnDirection = -1; // counter clockwise
} else {
curTurnDirection = 1; // clockwise
}
// calculate position to move to
pos = track[newTrack]; // bare track position
pos = pos + (curTurnDirection*2*slack); // correction for slack
return pos;
}
// ---- LED indiator function ----
// led on / of / blink function
// input: led number
// func: 0 = off, 1=blink, 2 = on
void setLed (int led, int func) {
if (func == 0) {
digitalWrite(ledPins[led], LOW);
}
if (func == 2) {
digitalWrite(ledPins[led], HIGH);
}
if (func == 1) {
curms = millis();
if (curms - prevms >= blnkint) {
prevms = curms;
if (blnk == HIGH) {
blnk = LOW;
} else {
blnk = HIGH;
}
digitalWrite(ledPins[led], blnk);
}
}
}
/****** SETUP: RUNS ONCE ******/
void setup()
{
bool init = false; // turntable intialisation status
int x = 0;
// set the digital led pins as output and initialise values
while (x < numberOfTracks) {
pinMode(ledPins[x], OUTPUT);
analogWrite (ledPins[x], 255);
digitalWrite (ledPins[x], LOW); // show initializing: all track leds off
x++;
}
digitalWrite (ledPins[0], HIGH); // show: initializing: outermost track leds on
digitalWrite (ledPins[3], HIGH);
pinMode (ledpin, OUTPUT);
digitalWrite (startPin,HIGH); // initialise startpin high
digitalWrite (buttonsPin,HIGH); // initialise button read
// turntable initialisation: search for 0-position sensor
init = initTurntable() ; // initialise turntable.
while (not init) { // Find 0-position (sensor), false = 0-pos. not found
digitalWrite(ledpin,HIGH); // Blink led indefenitely
delay(100);
digitalWrite(ledpin,LOW);
delay(100);
}
// no error: setup turntable and led indicators for normal operation
x=0;
while (x < numberOfTracks) { // switch of track leds
digitalWrite (ledPins[x], LOW);
x++;
}
// Setings for speed and accelaration during normal operation
stepper1.setMaxSpeed(maxTurnSpeed);
stepper1.setAcceleration(turnAccelleration);
stepper1.setSpeed(startTurnSpeed);
// move to initial track
stepper1.moveTo(calcNewPosition(startTrack)); // move to new position in normal operation
stepper1.runSpeed();
}//--(end setup )---
/****** LOOP: RUNS CONSTANTLY ******/
void loop()
{
stepper1.run(); // operate the stepper motor
// turntable stop
if (stepper1.distanceToGo() == 0) { // turntable at desired position
stepper1.disableOutputs(); // turn stepper motor off (all pins low)
setLed (newTrack,2); //turn on led for track positioned to
button = getButtonPressed (); // check if a button was pressed
if (button > -1 && button != newTrack) { // button pressed for another track than positioned on
setLed (newTrack,0); //turn off led for this track, we're moving away from it.
stepper1.moveTo(calcNewPosition(button)); // calculate new stepper position and move to it.
}
}
// turntable moving
else { // turntable turning (moving to desired position)
setLed (newTrack,1) ; // blink the led for the track where turntable is moving to
}
}//--(end main loop )---
//*********( THE END )***********
Succes!
Rob
-
Help,
Het forum doet iets met de vierkante haken in de sketch....
Even kijken hoe ik dit goed kan posten.
[...]
Ah, gevonden. Sketch alsnog als "code" in de post gezet.
Rob
-
Hallo Rob,
Het is gelukt!
Ik heb nu zelfs zes sporen aangesloten.
Wellicht dat ik nog meer wil, maar voor zover ben ik zeer tevreden.
-
Da's mooi Mark. Gaaf!
Tsja, nu is het wachten op tante Ali, denk ik...
En zodra de spullen geleverd zijn ben ik wel benieuwd naar de bouw van de rolbrug (en ik ben vast niet de enige).
Rob
-
Leuk project. Die Arduino stappenmotor herken ik. Want die heb ik thuis ook liggen. Helaas kan ik de sketch niet uploaden. krijg altijd een foutmelding. Waar zit hem dat in? Want ik wil dit wel na gaan maken, al heb ik de draaischijf nog niet in mijn bezit.
-
Is de sketch een .jpg bestand???
Als dat zo is dan moet je hem eerst uploaden naar een externe server/host aangezien hier niet direct .jpg bestanden geplaatst kunnen worden vanwege de ruimte op onze eigen server.
-
Hoi Semantha,
Is de sketch een .jpg bestand???
Als dat zo is dan moet je hem eerst uploaden naar een externe server/host aangezien hier niet direct .jpg bestanden geplaatst kunnen worden vanwege de ruimte op onze eigen server.
Nee, het is tekst. Meestal zet ik sketches als 'code' in het bericht.
Rob
-
Ik ga zo'n handdraaischijf een keer opsnorren! En dan ga ik dit eens maken. Het stappenmotortje heb ik al liggen.
-
Hoi Stoomlokkie,
Leuk.
Ik ga zo'n handdraaischijf een keer opsnorren! En dan ga ik dit eens maken. Het stappenmotortje heb ik al liggen.
Als je zover bent, laat het even weten: dan zet ik de nieuwste versie van het programma'tje (sketch) hier nog even neer.
Rob
-
Op verzoek hierbij de laatste software voor de draaischijf.
/* Turntable control
* =================
* For a partial turntable. 4 tracks at angles of 15, 20 and 15 degrees
*
* Beschrijving (NL)
* Besturing voor eeen modelspoor segmentdraaischijf met 4 sporen.
* De draaischijf wordt aangedreven met een stappenmotor.
* Bediening met een '0-positie' sensor en 4 drukknoppen op een spanningsdeler
* Terugmelding over 4 LEDs: een LED voor elk spoor.
*
* versie 2.0, 20 okt 2018
*/
/***** Import needed libraries ******/
#include <AccelStepper.h>
#define FULLSTEP 4
#define HALFSTEP 8
/***** Declare Pin Numbers *******/
// motor pins
#define motorPin1 2 // Blue - 28BYJ48 pin 1
#define motorPin2 3 // Pink - 28BYJ48 pin 2
#define motorPin3 4 // Yellow - 28BYJ48 pin 3
#define motorPin4 5 // Orange - 28BYJ48 pin 4
// sensor pins (analog)
#define startPin 8 // pin to detect turntable start position
#define buttonsPin A1 // analog pin to read buttons by Voltage divider
// led indicators pins
# define trackled1 9 // led for track 1
# define trackled2 10 // led for track 2
# define trackled3 11 // led for track 3
# define trackled4 12 // led for track 4
#define ledpin 13 // LED on Arduino
/******* Definitions for turntable control ******/
// ---- Turntable ----
// Physical definitions
#define slack 9 // steps of slack in stepper motor axel from middle
#define initMove -30 // steps to move at initialisation before sensor read
#define numberOfTracks 4 // number of tracks on turntable
// arrays below must correspond with number of tracks:
//int track[] {-9, -185, -454, -624}; // positions for 4 turntable tracks (motor steps from 0)
int track[] {-37, -207, -473, -643}; // positions for 4 turntable tracks (motor steps from 0)
int buttonBoundary[] {800, 500, 400, 200}; // voltage divider boundary values between buttons on buttonsPin
int ledPins[] {trackled1 ,trackled2, trackled3, trackled4}; // array for light track moving to or pointing at
// Operational definitions
#define startTrack 1 // initial track to move to (after detecting 0-position sensor)
#define maxTurnSpeed 55.0 // maximum speed of stepper motor normal operation
#define startTurnSpeed 20.0 // start speed of stepper motor
#define turnAccelleration 46.0 // acceleration of stepper motor
// ---- Led display ----
unsigned long prevms = 0; // blinking led milisecs last on/off
unsigned long curms = millis(); // blinking led milisecs now
const long blnkint = 250; // blink interval in milliisec.
/******* Global variables ******/
// ---- Turntable variables ----
int currentTrack = 0; // position after initialisation
int newTrack = 0; // 1st position to move to after initialisation
int button = -1; // button pressed (0, 1 2 or 3, -1 is no button)
// ---- Led display variables ----
int blnk = HIGH;
/****** Objects *******/
// ---- Stepper motor object ----
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
/****** Functions ******/
// ---- initialiation: 0-position detection ----
// Turntable initialisation after starting/resetting Arduino.
// It first moves the stepper motor counterclockwise (defined by initMove),
// and then moves the turntable clockwise slowly untill 0-positions is sensed
// on "startPin".
// Motor position "0"is set to the sensor position.
// Function returns "true" if sensor has been detected.
//
// Maximum steps is to find sensor: last track position + initial move steps.
// When 0 position is not sensed, function returns "false".
bool initTurntable () {
bool succesfull = true; // return parameter
int x = 0; // step counter
digitalWrite (ledpin,LOW); // show initialisation ongoing on Arduino board
// calculate total maximum number of steps (maxSteps) to find sensor:
// the number of steps to position of last track, including slack and initial move
int maxSteps = abs(track[numberOfTracks - 1]) + abs(initMove) +2*slack; // sensor must be found in less steps
// move turntable into start / reset position
stepper1.setMaxSpeed(1);
stepper1.setAcceleration(500.0);
stepper1.setSpeed(1);
// start with a move counterclockwise in case just beyond sensor...
x = initMove;
// now keep turning the table slowly until start point sensed
do {
stepper1.runToNewPosition(x);
x++;
} while ( (digitalRead (startPin) == HIGH) && (x < maxSteps) ); //run until sensor active, or until max steps done (error)
if (x < maxSteps) { // start position sensed. Intialise stepper position
stepper1.setCurrentPosition(0); // sensor position = 0
digitalWrite (ledpin,HIGH); // end of initialisation
} else { //initialisation error
succesfull = false;
}
stepper1.disableOutputs(); // Turn off stepper motor power
return succesfull;
}
// ---- read button sensor ----
// function to get button from analog pin
// returns button 0-3 pressed.
// returns -1 if no button pressed
int getButtonPressed () {
int r = analogRead (buttonsPin);
int b = -1;
if (r < buttonBoundary[0]) { // a button was pressed
delay(200); // wait for analog pin to stabalize
r = analogRead (buttonsPin);
// check which boundary value has been read on analog buttonPin
if (r < buttonBoundary[0]) {
b = numberOfTracks -1; // check lat button to first
while (r > buttonBoundary[b]) {
b--;
}
}
}
return b;
}
// ---- turntable movement calculation ----
// function to calculate new position for turntable to move to
// input: new track number
// output: new stepper position with corrections mechanical inaccuracies
int calcNewPosition (int trk) {
int pos = 0; // new stepper motor position
int curTurnDirection = 0; // current direction in Turntable = calculate for slack in movement
// keep values last move before calculating new move
currentTrack = newTrack;
newTrack = trk;
// Init new move
// check direction for additional slack movement.
// calculate new stepper position
if ( newTrack > currentTrack ) {
curTurnDirection = -1; // counter clockwise
} else {
curTurnDirection = 1; // clockwise
}
// calculate position to move to
pos = track[newTrack]; // bare track position
pos = pos + (curTurnDirection*2*slack); // correction for slack
return pos;
}
// ---- LED indiator function ----
// led on / of / blink function
// input: led number
// func: 0 = off, 1=blink, 2 = on
void setLed (int led, int func) {
if (func == 0) {
digitalWrite(ledPins[led], LOW);
}
if (func == 2) {
digitalWrite(ledPins[led], HIGH);
}
if (func == 1) {
curms = millis();
if (curms - prevms >= blnkint) {
prevms = curms;
if (blnk == HIGH) {
blnk = LOW;
} else {
blnk = HIGH;
}
digitalWrite(ledPins[led], blnk);
}
}
}
/****** SETUP: RUNS ONCE ******/
void setup()
{
bool init = false; // turntable intialisation status
int x = 0;
// set the digital led pins as output and initialise values
while (x < numberOfTracks) {
pinMode(ledPins[x], OUTPUT);
analogWrite (ledPins[x], 255);
digitalWrite (ledPins[x], LOW); // show initializing: all track leds off
x++;
}
digitalWrite (ledPins[0], HIGH); // show: initializing: outermost track leds on
digitalWrite (ledPins[3], HIGH);
pinMode (ledpin, OUTPUT);
digitalWrite (startPin,HIGH); // initialise startpin high
digitalWrite (buttonsPin,HIGH); // initialise button read
// turntable initialisation: search for 0-position sensor
init = initTurntable() ; // initialise turntable.
while (not init) { // Find 0-position (sensor), false = 0-pos. not found
digitalWrite(ledpin,HIGH); // Blink led indefenitely
delay(100);
digitalWrite(ledpin,LOW);
delay(100);
}
// no error: setup turntable and led indicators for normal operation
x=0;
while (x < numberOfTracks) { // switch of track leds
digitalWrite (ledPins[x], LOW);
x++;
}
// Setings for speed and accelaration during normal operation
stepper1.setMaxSpeed(maxTurnSpeed);
stepper1.setAcceleration(turnAccelleration);
stepper1.setSpeed(startTurnSpeed);
// move to initial track
stepper1.moveTo(calcNewPosition(startTrack)); // move to new position in normal operation
stepper1.runSpeed();
}//--(end setup )---
/****** LOOP: RUNS CONSTANTLY ******/
void loop()
{
stepper1.run(); // operate the stepper motor
// turntable stop
if (stepper1.distanceToGo() == 0) { // turntable at desired position
stepper1.disableOutputs(); // turn stepper motor off (all pins low)
setLed (newTrack,2); //turn on led for track positioned to
button = getButtonPressed (); // check if a button was pressed
if (button > -1 && button != newTrack) { // button pressed for another track than positioned on
setLed (newTrack,0); //turn off led for this track, we're moving away from it.
stepper1.moveTo(calcNewPosition(button)); // calculate new stepper position and move to it.
}
}
// turntable moving
else { // turntable turning (moving to desired position)
setLed (newTrack,1) ; // blink the led for the track where turntable is moving to
}
}//--(end main loop )---
//*********( THE END )***********
-
Beste ,
Ik ben nieuw hier en ook pas gestart met arduino .
Nu vergelijk ik de 3 versies van programmering voor de draaischijf . Heeft het een reden waarvoor A0 verwisseld is met startpin 8 in de laatste programmering ?
Ik zou de programmatie willen gebruiken op een draaischijf die ik reeds uitprintte van thingivers . (type met de tandwielen) Gebruik ook marklin wisselstroom sporen type C .
Het startpunt moet ik nog opbouwen met een sleepring , zoals jullie dat deden , of met een switch of iets dergelijks . Denk er nog over na . Moet daar ook een weerstand in dit contact verwerkt worden zoals in de drukknoppen ?
Alvast bedankt voor de hulp .
-
Hoi Francis,
Leuk dat je ook met de Arduino begonnen bent.
In de laatste 'sketch' heb ik de pin van analoog (A0) naar digitaal (8) gewisseld, omdat ik de "0 positie" (startpositie) detectie heb aangepast. Dit gebeurt nu met een magneetje in de draaischijf en een magneet detector (z.g Hall sensor). Daarvoor had ik een duidelijke 0 en 1 nodig, dus een digitale pin. De 0 positie op de rails was te onbetrouwbaar, met name niet nauwkeurig genoeg. Hierdoor was soms de uitlijning op de sporen niet goed.
Op zich hoeven er geen weerstanden op de pinnen van de Aduino, zolang je de spanning maar tussen de 0 en 5 volt houdt. Een spanning lager dan 0 (negatief) boven de 5 V op een I/O pin kan de Arduino beschadigen, net als een stroom van meer dan 40 mA.
Rob.
PS: wil je je misschien ook nog even voorstellen in dit topic http://www.h0modelspoor.nl/index.php?topic=3736.0 (http://www.h0modelspoor.nl/index.php?topic=3736.0) ?
-
Interessant project Rob! Was van plan een draaischijf te maken met microschakelaars voor de posities maar je hebt de drempel voor Arduino besturing weggehaald :)
Op MP staan nu ook Fleischmann schijven voor weinig maar die zijn wat klein lijkt me. Mijn grootste loc is bijna 20cm. Hoe groot is jouw draaischijf?
-
De 3D printer is voorlopig druk:
https://www.thingiverse.com/thing:1837520 (https://www.thingiverse.com/thing:1837520)
Dan ga ik Rob fijn even na-apen:)
Maak er wel een separaat draadje van
-
Bert, die url werkt hier niet.
-
Dank Tom, heb hem aangepast
-
Met Rob al even van gedachte gewisseld, voor een ieders vermaak hier verder.
Wat heb ik:
Proefopstelling met een stepper+driver en Arduino nano. Ik gebruik de standaard Arduino SW.
Met een simpel voorbeeld programma gaat de stepper draaien, dus stepper en Arduino zijn ok lijkt me.
Met de sketch van Rob komt de stepper niet in beweging, ook niet het zoeken naar de 0 positie.
Bij het uploaden de eerste keer had ik een fout, accellstepper was niet geladen, gedaan en vervolgens geen error.
Ik heb een oscilloscoop. Op alle 4 de driver ingangen geen pulsen (2 zijn constant hoog, 2 laag), de 4 aangesloten ledjes gaan wel knipperen totdat het in alarm gaat (rode led op de nano)
Wat kan dit zijn? Is de geladen AccelStepper ok? Ik zie by Patrick Wasp versie 1,61.0 staan.
-
Hoi Bert,
Misschien een open deur, maar je hebt de stappenmotor(controller) aangesloten op pinnen D2, D3, D4 en D5 van de Arduino?
Zo niet, dan de aansluiting of de definitie in de sketch aanpassen.
Dat laatste doe je met deze definities in de sketch:
// motor pins
#define motorPin1 2 // Blue - 28BYJ48 pin 1
#define motorPin2 3 // Pink - 28BYJ48 pin 2
#define motorPin3 4 // Yellow - 28BYJ48 pin 3
#define motorPin4 5 // Orange - 28BYJ48 pin 4
Rob
-
Gut wat stom. Ik had ergens in jouw draadje D9-D12 gelezen. De trackleds zitten op 2-5 ipv 9-12
Vandaar dat de leds fanatiek knipperen
Ff Aanpassen/proberen straks
-
Nou dat gaat een stuk beter…. ;D
Hij draait heel langzaam totdat ik even startpin 8 even een 0 geef. Dan draait hij een stukje terug en gaat wachten. Vervolgens bij kiezen van een track loopt hij er keurig naartoe. Ben er blij mee.
Morgen verder. In ieder geval de speed een stuk hoger, denk dat hij nu 10 minuten over een rondje doet door de vertraging. Denk ongeveer 1 minuut voor 360 graden?
Rob:
Ik zie max speed op 55 staan. Eerst maar naar 300?
Startturnspeed evenredig omhoog?
En wat is turnacceleration? Is dat een tijdsfactor of het aantal stappen dat hij op lage snelheid gaat?
Verder liggen bij mij door de vertraging de trackposities veel verder uit elkaar.
-
Hoi Bert,
Mooi.
Rob:
Ik zie max speed op 55 staan. Eerst maar naar 300?
Startturnspeed evenredig omhoog?
En wat is turnacceleration? Is dat een tijdsfactor of het aantal stappen dat hij op lage snelheid gaat?
De instellingen heb ik allemaal proefondervindelijk vastgesteld. Het mooie van de accelstepper bibliotheek is dat hij (vrij) nauwkeurig het aantal stappen bepaalt, onafhankelijk van acceleratie, snelheid en vertraging. Dus ik zou gewoon wat met de snelheid instellingen pielen tot het naar tevredenheid is.
Verder zijn de hoeken tussen de sporen (= aantal stappen vanaf de nulpositie) per spoor in te stellen. Dat kun je uitrekenen en/of uitproberen. (Bij mij was het uitrekenen, en dan precies op de stap juist krijgen door te proberen).
En als je wat verder bent, is ook de speling (slack) nog in te stellen. De motor maakt wat extra stappen bij het wisselen van de draairichting om eerst de speling "op te vullen" tussen motor-as en brug.
Ik ben wel benieuwd naar wat foto's :)
Rob
-
Dank je Rob!
Ga vandaag er nog verder mee.
Zal ook foto’s plaatsen.
Het is nog wel van een testopstelling. Houten balkje met tandwielen en deel van de brug.
Voor de schijf moet nog wat van tante Ali landen.
Ik heb tevens een schema gemaakt van de aansluitingen. Post ik ook
-
Hoi Bert,
Prima. En testopstellingen laten vaak goed zien hoe het werkt (alle aandrijvingen en draden liggen meestal bloot) :)
Ik heb tevens een schema gemaakt van de aansluitingen. Post ik ook
Ah top. Zo'n aansluitschema ontbreekt inderdaad nog.
Rob
-
Eerst het schema:
(https://myalbum.com/photo/esBXpWPoCxCK/720.jpg)
Indien er verduidelijking / aanpassingen gewenst zijn hoor ik dat graag!
Kennelijk heb ik de weerstanden iets anders in elkaar gezet dan Rob, in de sketch de posities verschoven:
int buttonBoundary[] {1000, 800, 600, 400}; // voltage divider boundary values between buttons on buttonsPin initieel:800, 500, 400, 200
En de proefopstelling:
(https://myalbum.com/photo/Lm8jgfdZFCat/720.jpg)
Hij loopt erg fraai, precies kan ik het later zien zodra de echte schijf gebouwd wordt over een paar weken.
Snelheid in de sketch heb ik met een factor 10 verhoogd ivm de vertraging, idem de posities.
~26.500 stappen is 1 omwenteling. Bij een schijf van ruim 30cm doorsnede kom ik dan op ruwweg 27 stappen per mm verplaatsing.
Ik gebruik nu een IR tunnel voor de 0 positie, daarom heb ik 'high' in 'low' veranderd in de sketch.
Verder moet ik uiteindelijk het aantal track posities nog flink uitbreiden, dat komt later.
Nog 1 dingetje Rob: door de vertraging duurt het zoeken naar de 0 positie erg lang, kan nog niet vinden waar de zoeksnelheid staat.
Dacht dat ik het gevonden had maar hier aanpassen maakt geen verschil:
stepper1.setMaxSpeed(10);// verhoogd van 1 naar 10
stepper1.setAcceleration(500.0);
stepper1.setSpeed(10); // verhoogd van 1 naar 10
??
-
Schema wordt nog aangepast, heb de library van de nano gevonden, maakt het nog wat beter denk ik
-
Hierbij het aangepaste schema, er zat ook een foutje in, de 0 detectie zat op een verkeerde poort getekend
Tevens de 4 led weerstanden vervangen door 1, Rob merkte terecht op dat er toch maar 1 led tegelijk aan is
(https://myalbum.com/photo/YqAxMeBpZp3c/720.jpg)
-
Ziet er goed uit, Bert.
En bedankt voor het aansluitschema, dat maakt het allemaal wat duidelijker.
Over die "0 positie" pin: in de eerdere versie van de sketch zat deze inderdaad op een andere (analoge) poort; ik heb dat later omgezet naar een digitale (D8).
Nog 1 dingetje Rob: door de vertraging duurt het zoeken naar de 0 positie erg lang, kan nog niet vinden waar de zoeksnelheid staat.
Dacht dat ik het gevonden had maar hier aanpassen maakt geen verschil:
stepper1.setMaxSpeed(10);// verhoogd van 1 naar 10
stepper1.setAcceleration(500.0);
stepper1.setSpeed(10); // verhoogd van 1 naar 10
??
Daar is niet zo heel veel aan te doen, Bert. De sketch werkt nu zo dat de stappenmotor steeds een klein stukje (1 stap) draait, en dan wordt gekeken of de 0-positie sensor al iets doet. Zo niet, weer een stukje draaien, enzovoorts. Dus dat is inherent traag.
Daar is vast ook wel iets met een interrupt te programmeren, of zo, maar dat heb ik (nog) niet gedaan.
Wat je eventueel kunt doen is meerdere stappen tegelijk nemen; met 27 stappen in een mm is 3 of 4 stappen nauwkeurig genoeg, denk ik. Dat heb ik niet in een definitie opgenomen, maar het staat in dit stukje code
// now keep turning the table slowly until start point sensed
do {
stepper1.runToNewPosition(x);
x++;
} while ( (digitalRead (startPin) == HIGH) && (x < maxSteps) ); //run until sensor active, or until max steps done (error)
Deze gaat 3x zo snel door
x++;
te vervangen door
x=x+3;
Het beste is om de draaischijf weer vlak bij die 0-positie te zetten voor je de stroom er af haalt. En anders moet je de volgende keer wat langer wachten.... ;)
Of een wat slimmer algoritme bedenken met grote stappen richting 0 positie, en zodra gevonden nog met wat kleine stappen heen-en-weer om de precieze 0 te vinden. Bijvoorbeeld eerst met 30 stappen tegelijk draaien. Zodra de ongeveer de 0 positie gevonden is, eenmaal 30 stappen terug, en dan weer per stap vooruit tot de echte 0 positie.
Rob
-
Bedankt voor het meedenken Rob!
Ga dat stukje code proberen. Aan jouw andere optie had ik ook even gedacht, snel naar 0 positie en dan ff langzaam heen en weer. Misschien iets voor later maar wellicht laat ik het zo, tiedzat
-
Hoi Rob,
Ik zit alvast naar meerdere tracks te kijken. De sketch erop aanpassen lijkt me niet al te ingewikkeld. Wel loop ik tegen de limiet aan wat betreft
D-uitgangen, alleen D6 en D7 zijn nog over.
Kunnen er daarvoor ook analoge uitgangen gebruikt worden?
Anders kan ik er wellicht wat logische poorten tussen planten
-
Mooi goedkoop printje gevonden, 16 kanaals (de)multiplexer:
(https://myalbum.com/photo/Lr38rhNxjcUi/720.jpg)
Wordt wel wat gepiel met de code
-
Rob: Indien je liever een separaat draadje ziet laat het dan even weten!
Op de brug moeten nog 2 sperseinen komen.
Schema erop aangepast. Met 1 nano uitgang moet rood en wit geschakeld kunnen worden. Klein nadeel: 4 draadjes naar elk sein ipv 3. Denk nog een Mosfet ertussen of een relais om de nano niet teveel te belasten.
Tevens de sleepring erbij getekend.
(https://myalbum.com/photo/xgLZsgyCSbDZ/720.jpg)
Klussen te gaan wat betreft de sketch:
Aantal tracks verhogen naar ~8
Multiplexen van de track leds
Schakelen van de sperseinen. Gedachte: commando bewegen, sein op rood, wachttijd, schijf naar volgende positie, wachttijd, sein weer op wit.
Of me dat allemaal gaat lukken weet ik niet, met wellicht een beetje hulp vast wel. Vanuit mijn jonge jaren heb ik een beetje ervaring met Basic, daar lijkt C wat op
-
Hoi Bert,
Lekker bezig!
Ik zit alvast naar meerdere tracks te kijken. De sketch erop aanpassen lijkt me niet al te ingewikkeld.
Klopt, als het goed is hoef je alleen maar de definities naar de sporen uit te breiden:
#define numberOfTracks 4 // number of tracks on turntable
// arrays below must correspond with number of tracks:
int track[] {-37, -207, -473, -643}; // positions for 4 turntable tracks (motor steps from 0)
En natuurlijk het aantal knoppen in de spanningsdeler en de daarbij behorende grenswaarden.
int buttonBoundary[] {800, 500, 400, 200}; // voltage divider boundary values between buttons on buttonsPin
(Al had jij al andere waarden, volgens mij)
Wel loop ik tegen de limiet aan wat betreft D-uitgangen, alleen D6 en D7 zijn nog over.
Kunnen er daarvoor ook analoge uitgangen gebruikt worden?
Ja, volgens mij kun je ook gewoon een digitalWrite() naar analoge uitgangen doen met laag en hoog. Maar je kunt ook overwegen om op een andere manier de terugmelding te doen dan een led per spoor. Misschien met een segmentdisplay of slechts één led die aangeeft of er een commando bezig is of niet (en dat je zelf onthoud waar-ie heen gaat, of je ziet dat als de draaischijf klaar is met draaien).
Het eenvoudigste om met minder dan 8 leds iets te doen is om deze Array de LEDS te hergebruiken. Bijvoorbeeld zo
int ledPins[] {trackled1 ,trackled1, trackled2, trackled2, trackled3 ,trackled3, trackled43, trackled4}; // array for light track moving to or pointing at
Op deze manier zijn de sporen per 2 gebundeld op 1 led. Wel zo simpel, toch?
Rob: Indien je liever een separaat draadje ziet laat het dan even weten!
Nee hoor, wat mij betreft is dit een aardige uitbreiding, hoor.
-
Wederom dank Rob!
Mij valt overigens op dat de simpele stepper zeer weinig geluid maakt.
Tracks is duidelijk!
Tevens de spanningsdeler.
Weet je wat de resolutie is van de deler, maw hoeveel weerstanden max? 10 zal zeker kunnen, alleen nieuwsgierigheid.
Wat betreft de trackleds. Prima zo’n array! Denk nog een typo te zien, 43 zal denk ik 4 moeten zijn.
Wel overweeg ik toch 1 led per track. Ben van plan een bedieningspaneel te maken met de schijf erop en in een cirkel schakelaars met trackleds. Daarnaast schakelaars/leds voor de wissels (aansturing via DCC Next
En dan nog de seinen.
-
Deze gaat 3x zo snel door
x++;
te vervangen door
x=x+3;
Ik merk geen verschil in snelheid. Is ook onbelangrijk, de eerste positie staat nu net een stukje naast de 0 detectie. Inderdaad prima om vanaf daar in te schakelen
-
Kreeg nav jouw suggestie om de leds dubbel te gebruiken een idee, kan niet vinden of dit kan.
Jouw voorstel:
int ledPins[] {trackled1 ,trackled1, trackled2, trackled2, trackled3 ,trackled3, trackled4, trackled4}; // array for light track moving to or pointing at
Is zoiets te doen:
int ledPins[] {0000, 0001, 0010, 0011 enzovoort};
Dus op index 0 alle leds uit, op index 1 led1 aan, dan led2, dan led 1 plus2 enzovoort.
Wordt dan (t=trackled):
{,t1, t2, t1+t2, enz}
Eigenlijk 2 vragen:
1: kun je springen in een array met een “,” (index 0 overslaan)
2: kun je op 1 index 2 leds aanzetten. En zo ja met welk scheidingsteken, ik gebruikte de “+”
Indien dit werkt kan ik eenvoudig de-muxen van 4 naar 16
-
Dit wordt gecompileerd, dus syntax is ok, morgen kijken wat het doet:
int ledPins[] {trackled1 ,trackled2 & trackled3, trackled3, trackled4}; // array for light track moving to or pointing at
-
excuus voor alle vragen Rob:)
Hoe werkt de analoge read?
Stel de weerstanden hebben een hoge tolerantie (niet bij mij, gebruik 1% exemplaren)
Stel een range is als (100, 200, 300, 400, 500, 600) ingesteld en de schakelaar waarde is 540. Wat gebeurt er dan? is er een vangbereik? In de sketch kan ik het niet vinden.
Misschien wat het dichtste bij zit?
-
Dit wordt gecompileerd, dus syntax is ok, morgen kijken wat het doet:
int ledPins[] {trackled1 ,trackled2 & trackled3, trackled3, trackled4}; // array for light track moving to or pointing at
Volgens mijn zoon gaat het niet werken met "&"
Hij is IT-er, gaat de sketch ombouwen, resultaat plaats ik tzt wel
-
Hoi Bert,
Ha, het vragen(v)uurtje is aangebroken :).
De sketch vragen/aanpassingen laat ik even liggen; daar gaat je zoon mee aan de slag.
Over de analoge poorten: hier zitten AD converters op die een spanning van 0 tot 5V omzetten in een getal tussen 0 en 1023.
In mijn ervaring levert die een behoorlijk stabiele waarde.
Je kunt even een programma'tje schrijven de de analoge pin uitleest en op het computerscherm zet met de seriële monitor in de Arduino IDE (Serial.print) en Serial.println). Als je dan de knopjes op de 8-voudige spanningsdeler uitleest, zet je de grenswaarden er precies tussenin. Misschien is er ook wel iets dergelijks te vinden, bijvoorbeeld een programmatje dat de waarde van een potmeter op een analoge pin uitleest. Dat is feitelijk ook een spanningsdeler.
Rob
-
Dank voor de tips Rob, ik ga eens wat experimenteren.
-
Hoi zet je de grenswaarden er precies tussenin.
Hoi Rob,
Ik las deze zin opnieuw, denk dat ik het nu pas begrijp…
Sketch van jou aangepast. Met kleine haperingen kan ik nu naar 10 posities bewegen.
TrackLeds is nog “wip”
Sketch geschreven om de knoppen uit te lezen, dat gaat perfect.
Ik veronderstelde dat ik die waarden moest gebruiken maar nu zie ik dat ik er juist tussenin moet gaan zitten.
Dus knoppen geven bijvoorbeeld de volgende waarden aan:
100, 300, 500 enz
De sketch dan:
0, 200, 400 enz
Goed begrepen?
-
Hoi Bert,
Ik veronderstelde dat ik die waarden moest gebruiken maar nu zie ik dat ik er juist tussenin moet gaan zitten.
Dus knoppen geven bijvoorbeeld de volgende waarden aan:
100, 300, 500 enz
De sketch dan:
0, 200, 400 enz
Goed begrepen?
Precies. Met de grenswaarden er precies tussenin is enige "ruis" of onnauwkeurigheid op de spanningsdeler niet zo snel een probleem. Als je de waarde ongeveer uit kan lezen is het goed :)
Rob
-
prima gelukt Rob!
Dit heb ik gebruikt voor het uitlezen:
void setup() {
Serial.begin(9600);
while(!Serial); // wait for Serial port to enumerate, need for Native USB based boards only
Serial.println("starting test");
pinMode (A1, INPUT);
}
void loop()
Moest even zoeken naar de Arduino seriële monitor.
In het totaal een projectje waar ik veel van leer.
{
int x=analogRead(A1);
Serial.print ("Analog value: "); // put your main code here, to run repeatedly:
Serial.println (x);
delay (500);
}
-
prima gelukt Rob!
Dit heb ik gebruikt voor het uitlezen:
void setup() {
Serial.begin(9600);
while(!Serial); // wait for Serial port to enumerate, need for Native USB based boards only
Serial.println("starting test");
pinMode (A1, INPUT);
}
void loop()
{
int x=analogRead(A1);
Serial.print ("Analog value: "); // put your main code here, to run repeatedly:
Serial.println (x);
delay (500);
}
Moest even zoeken naar de Arduino seriële monitor.
In het totaal een projectje waar ik veel van leer.
Hoop dat mijn zoon in het weekend de TrackLeds voor elkaar kan krijgen, hij heeft al een stuk gedaan, er zit nog een foutje in.
De led signalen wil ik ook gebruiken voor het openen van de ringloods deuren
-
mooie stap verder. Hij draait keurig naar 10 posities.
Sketch is klaar voorlopig.
De 4 trackleds geven nu de binaire code weer. Zodra ik de demultiplexer binnen heb kan ik daar Track1-track10 uithalen, max tot 16. Maar zien hoeveel tracks het uiteindelijk worden.
Tevens werkt het spersein. Die gaat eerst op rood (en wit uit) ff wachten, dan beweging, einde beweging weer een delay, dan rood uit/wit aan.
Wil de sketch best in de post zetten maar weet ff niet hoe Rob dat mooi doet in een venster?
In ieder geval is het schema voorlopig ook klaar:
(https://myalbum.com/photo/xgLZsgyCSbDZ/720.jpg)
Het lijkt heel wat maar valt reuze mee. Kom maar op met opmerkingen / vragen
-
Hoi Bert,
Nou, je hebt het hele gebeuren een heel stuk verder ontwikkeld. Leuk!.
Als je de sketch neer wil zetten, gebruik dan code tags. Dat is vierkantehaak-"code"-vierkantehaak, de sketch, vierkantehaak-slash-"code"-vierkantehaak. Die tags worden ook gemaakt met het #-knopje als je een bericht aan het maken bent.
groet,
Rob
-
Dank voor de opmerking Rob, het is erg leuk om te doen!
Er zullen nog wel wat puntjes op de i gezet worden. Een verbeteringspunt is nog het delay tussen het schakelen van de sperleds en start/einde beweging.
Iets wat ik nog wat belangrijker vind is " de kortste weg vinden" Nu draait ie vanuit 0 altijd linksom naar de grootste hoek, even ingesteld op 270 graden terwijl hij ook 90 rechtsom had gekund.
Ik weet even niet of jij dit erin had zitten en het hier verknoeid is?
De code kan nog wel wat opgeschoond worden. Bijvoorbeeld "TrackLed" past niet meer.
De sketch dan, hoop dat ik je goed begrepen heb:
/* Turntable control
* =================
* For a partial turntable. 4 tracks at angles of 15, 20 and 15 degrees
*
* Beschrijving (NL)
* Besturing voor een modelspoor segmentdraaischijf met 4 sporen.
* De draaischijf wordt aangedreven met een stappenmotor.
* Bediening met een '0-positie' sensor en 4 drukknoppen op een spanningsdeler
* Terugmelding over 4 LEDs: een LED voor elk spoor.
*
* versie 2.0, 20 okt 2018
*/
/***** Import needed libraries ******/
#include <AccelStepper.h>
#define FULLSTEP 4
#define HALFSTEP 8
/***** Declare Pin Numbers *******/
// motor pins
#define motorPin1 2 // Blue - 28BYJ48 pin 1
#define motorPin2 3 // Pink - 28BYJ48 pin 2
#define motorPin3 4 // Yellow - 28BYJ48 pin 3
#define motorPin4 5 // Orange - 28BYJ48 pin 4
// sensor pins (analog)
#define startPin 8 // pin to detect turntable start position
#define buttonsPin A1 // analog pin to read buttons by Voltage divider
// led indicators pins
# define trackLed1 9 // led for track 1
# define trackLed2 10 // led for track 2
# define trackLed3 11 // led for track 3
# define trackLed4 12 // led for track 4
// spersein leds
# define sperledRed 6 // rode led spersein
# define sperledWit 7 // witte led spersein
#define ledpin 13 // LED on Arduino
/******* Definitions for turntable control ******/
// ---- Turntable ----
// Physical definitions
#define slack 9 // steps of slack in stepper motor axel from middle
#define initMove -30 // steps to move at initialisation before sensor read
#define numberOfTracks 10 // number of tracks on turntable
// arrays below must correspond with number of tracks:
// positions for 10 turntable tracks (motor steps from 0) -> 1 omwenteling = ~ 26500 stappen.
int track[numberOfTracks]{-100, -2000, -3100, -4200, -5300, -6400, -7500, -13000, -15000, -17000};
int buttonBoundary[numberOfTracks]{1000, 900, 800, 700, 650, 550, 480, 380, 280, 180};
// Operational definitions
#define startTrack 0 // initial track to move to (after detecting 0-position sensor)
#define maxTurnSpeed 400.0 // maximum speed of stepper motor normal operation -> van 55 naar 400 =~ 60sec / omwenteling
#define startTurnSpeed 120.0 // start speed of stepper motor -> van 20 naar 120 verhoogd
#define turnAccelleration 46.0 // acceleration of stepper motor
// ---- Led display ----
unsigned long prevms = 0; // blinking led milisecs last on/off
unsigned long curms = millis(); // blinking led milisecs now
const long blnkint = 250; // blink interval in milliisec.
/******* Global variables ******/
// ---- Turntable variables ----
int currentTrack = 0; // position after initialisation
int newTrack = 0; // 1st position to move to after initialisation
int button = -1; // button pressed (0, 1 2 or 3, -1 is no button)
// ---- Led display variables ----
int blnk = HIGH;
/****** Objects *******/
// ---- Stepper motor object ----
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
// array of pins used to send out the binary-encoded track number
int ledPins[]{trackLed1, trackLed2, trackLed3, trackLed4};
/****** Functions ******/
#define ArrayCount(x) (sizeof(x) / sizeof(x[0]))
// ---- initialiation: 0-position detection ----
// Turntable initialisation after starting/resetting Arduino.
// It first moves the stepper motor counterclockwise (defined by initMove),
// and then moves the turntable clockwise slowly untill 0-positions is sensed
// on "startPin".
// Motor position "0"is set to the sensor position.
// Function returns "true" if sensor has been detected.
//
// Maximum steps is to find sensor: last track position + initial move steps.
// When 0 position is not sensed, function returns "false".
bool initTurntable() {
bool succesfull = true; // return parameter
int x = 0; // step counter
digitalWrite(ledpin, LOW); // show initialisation ongoing on Arduino board
// calculate total maximum number of steps (maxSteps) to find sensor:
// the number of steps to position of last track, including slack and initial move
int maxSteps = abs(track[numberOfTracks - 1]) + abs(initMove) + 2 * slack; // sensor must be found in less steps
// move turntable into start / reset position
stepper1.setMaxSpeed(10); // verhoogd van 1 naar 10
stepper1.setAcceleration(500.0);
stepper1.setSpeed(10); // verhoogd van 1 naar 10
// start with a move counterclockwise in case just beyond sensor...
x = initMove;
// now keep turning the table slowly until start point sensed
do {
stepper1.runToNewPosition(x);
x++; //was x++; nu sneller naar 0 positie
} while ((digitalRead(startPin) == LOW) && (x < maxSteps)); //run until sensor active, or max steps done (error)
if (x < maxSteps) { // start position sensed. Intialise stepper position
stepper1.setCurrentPosition(0); // sensor position = 0
digitalWrite(ledpin, HIGH); // end of initialisation
} else { // initialisation error
succesfull = false;
}
stepper1.disableOutputs(); // Turn off stepper motor power
return succesfull;
}
// ---- read button sensor ----
// function to get button from analog pin
// returns button 0-3 pressed.
// returns -1 if no button pressed
int getButtonPressed() {
int r = analogRead(buttonsPin);
int b = -1;
if (r < buttonBoundary[0]) { // a button was pressed
delay(200); // wait for analog pin to stabalize
r = analogRead(buttonsPin);
// check which boundary value has been read on analog buttonPin
if (r < buttonBoundary[0]) {
b = numberOfTracks - 1; // check lat button to first
while (r > buttonBoundary[b]) {
b--;
}
}
}
return b;
}
// ---- turntable movement calculation ----
// function to calculate new position for turntable to move to
// input: new track number
// output: new stepper position with corrections mechanical inaccuracies
int calcNewPosition(int trk) {
int pos = 0; // new stepper motor position
int curTurnDirection = 0; // current direction in Turntable = calculate for slack in movement
// keep values last move before calculating new move
currentTrack = newTrack;
newTrack = trk;
// Init new move
// check direction for additional slack movement.
// calculate new stepper position
if (newTrack > currentTrack) {
curTurnDirection = -1; // counterclockwise
} else {
curTurnDirection = 1; // clockwise
}
// calculate position to move to
pos = track[newTrack]; // bare track position
pos = pos + (curTurnDirection * 2 * slack); // correction for slack
return pos;
}
// ---- LED indiator function ----
// led on / of / blink function
// trackNumber: track number
// func: 0 = off, 1 = blink, 2 = on
void setLed(int trackNumber, int func) {
if (func == 0) {
writeLedPins(trackNumber, LOW);
}
if (func == 2) {
writeLedPins(trackNumber, HIGH);
}
if (func == 1) {
curms = millis();
if (curms - prevms >= blnkint) {
prevms = curms;
if (blnk == HIGH) {
blnk = LOW;
} else {
blnk = HIGH;
}
writeLedPins(trackNumber, blnk);
}
}
}
// Set led pins depending on the binary input in the `ledPins` array, at position `led`.
void writeLedPins(int trackNumber, int value) {
//Serial.println();
//Serial.print("Track: ");
//Serial.println(trackNumber);
// Loop over all led pins.
for (int i = 0; i < ArrayCount(ledPins); ++i) {
// If the bit for the current led pin is set, set the pin.
digitalWrite(ledPins[i], trackNumber & (int) round(pow(2, i)) ? value : LOW);
//Serial.print(trackNumber & (int) round(pow(2, i)) ? value : LOW);
}
//Serial.println();
}
void setSperSign(bool isWhite) {
digitalWrite(sperledRed, isWhite ? LOW : HIGH);
digitalWrite(sperledWit, isWhite ? HIGH : LOW);
}
/****** SETUP: RUNS ONCE ******/
void setup() {
bool init = false; // turntable intialisation status
//Serial.begin(9600);
int x = 0;
// set the digital led pins as output and initialise values
while (x < ArrayCount(ledPins)) {
pinMode(ledPins[x], OUTPUT);
analogWrite(ledPins[x], 255);
digitalWrite(ledPins[x], LOW); // show initializing: all track leds off
x++;
}
// show: initializing: Loop through all leds
for (int i = 0; i < numberOfTracks; ++i) {
writeLedPins(i, HIGH);
delay(250);
}
writeLedPins(0, LOW);
pinMode(ledpin, OUTPUT);
digitalWrite(startPin, LOW); // initialise startpin low. Default HIGH, aangepast ivm IR tunnel
digitalWrite(buttonsPin, HIGH); // initialise button read
// turntable initialisation: search for 0-position sensor
init = initTurntable(); // initialise turntable.
while (not init) { // Find 0-position (sensor), false = 0-pos. not found
digitalWrite(ledpin, HIGH); // Blink led indefenitely
delay(100);
digitalWrite(ledpin, LOW);
delay(100);
}
// no error: setup turntable and led indicators for normal operation
x = 0;
while (x < ArrayCount(ledPins)) { // switch off track leds
digitalWrite(ledPins[x], LOW);
x++;
}
// Setings for speed and accelaration during normal operation
stepper1.setMaxSpeed(maxTurnSpeed);
stepper1.setAcceleration(turnAccelleration);
stepper1.setSpeed(startTurnSpeed);
// move to initial track
stepper1.moveTo(calcNewPosition(startTrack)); // move to new position in normal operation
stepper1.runSpeed();
}//--(end setup )---
/****** LOOP: RUNS CONSTANTLY ******/
void loop() {
stepper1.run(); // operate the stepper motor
// turntable stop
if (stepper1.distanceToGo() == 0) { // turntable at desired position
stepper1.disableOutputs(); // turn stepper motor off (all pins low)
setLed(newTrack, 2); //turn on led for track positioned to
button = getButtonPressed(); // check if a button was pressed
delay(250);
setSperSign(true);
if (button > -1 && button != newTrack) { // button pressed for another track than positioned on
setSperSign(false);
delay(100); // Wacht een seconde na het spersignaal
setLed(newTrack, 0); //turn off led for this track, we're moving away from it.
stepper1.moveTo(calcNewPosition(button)); // calculate new stepper position and move to it.
}
}// turntable moving
else { // turntable turning (moving to desired position)
setLed(newTrack, 1); // blink the LED for the track where turntable is moving to
}
}//--(end main loop )---
//*********( THE END )***********
-
Hoi Bert,
code is, net als een modelbaan, eigenlijk nooit echt af :)
Iets wat ik nog wat belangrijker vind is " de kortste weg vinden" Nu draait ie vanuit 0 altijd linksom naar de grootste hoek, even ingesteld op 270 graden terwijl hij ook 90 rechtsom had gekund.
Ik weet even niet of jij dit erin had zitten en het hier verknoeid is?
Je hebt niets verknoeid. Mijn draaischijf is een segmentdraaischijf, en draait niet helemaal rond (kan ook niet).
(http://www.xs4all.nl/~robvd/Forum/09_OverzichtDraaischijf.jpg)
Dus was er geen kortste weg vraagstuk: die is altijd met de klok mee. De software heeft geen oplossing voor een probleem dat er nog niet was ;)
Overigens heeft de Arduino ook wat flash geheugen. Die kun je gebruiken om de laatste positie op te slaan. De posite wordt dan onthouden als de Arduino uit gaat. En dit geheugen kun je bij het opstarten weer uitlezen om daarmee de snelste route naar de 0-positie te vinden.
Ik zou wel die 0-positie blijven zoeken, zodat elke keer weer vanuit een goede reset wordt gestart.
Rob
-
Ah, goed te weten ;D
Kan zo maar zijn dat “we” het oplossen. Beter voor de arbeidsverhouding met het personeel ter plekke :D.
Kan nu even niet verder, wachten op tante Ali.
-
Hoi Rob,
Ik had vanmorgen een ingeving en dacht " de kortste weg" makkelijk te kunnen oplossen:
//if (newTrack > currentTrack) { // Rob's intitial statement
if (newTrack > currentTrack && newTrack + currentTrack <-13250) { // shortest direction is chosen. 13250 equals 180 degrees turn
curTurnDirection = -1; // counterclockwise
} else {
curTurnDirection = 1; // clockwise
Hij reageert hier niet op. Vervolgens jouw statement terug gezet en als test curTurnDirection de "-" verplaatst naar "else" Ook hierop reageert de stepper niet, het blijft zoals het is.
Ik duik er morgen verder in, anders zoon/IT-er wel maar wellicht zegt het jou direct iets?
-
Hoi Bert,
Ah, het gaat om de kortste weg bij gewoon gebruik. Ik dacht alleen aan het begin...
Dat is wel even een uitdenkertje. Want je kunt natuurlijk ook meer dan 180 of zelfs 360 graden draaien. En dan wordt de logica heel anders: blijf je doortellen na 360 graden, of zet je deze weer op 0. Wat nu als je van 330 graden naar 30 (390) graden draait en zo voorts.
Daar heb ik ook geen snel antwoord op.
Succes,
Rob
-
Hoi Rob,
ik hou wel van puzzels:)
Eerst maar even doorgronden waarom het omdraaien van de CurnTurn geen effect heeft, dan verder.
Wat hij namelijk in jouw sketch wel doet is de andere kant opdraaien indiendien hij van bv track 3 naar 4 was gegaan en dan weer terug moet.
Je gaat het vast horen
-
Spullen van tante Ali binnengekomen, kon ik mooi verder:
(https://myalbum.com/photo/dqziFgpGPv3n/720.jpg)
(https://myalbum.com/photo/mczKfMEPom2c/720.jpg)
Hij loopt lekker rustig en stopt keurig telkens op dezelfde plek. Met de slackcompensatie zit het dus ook wel goed.
Met de brug zit het me nog niet lekker. C-rail op de brug staat voor geen meter. 2e hands K-rail gevonden, komt hoop ik morgen beter. Heb voorbeelden gezien met “parket” op de brug en eventueel op de stuurhut, denk dat ik dat ga doen.
Gisteren liep ik ook weer aan tegen het “zoeken naar de 0 positie aan. DomDom, had hem uitgezet net op de verkeerde positie, duurt een uurtje voordat hij met zoeken rond is.
Bedacht een alternatieve oplossing, werkt uitstekend:
1 schakelaar die ff het zoeken stop zet ( lichtsluis overrulen)
2 schakelaar die kiest tussen normale weerstandsbrug en een potmeter omzetten
3 extra positie instellen die bijna helemaal rond gaat.
Hij volgt dan keurig de stand van de potmeter. Draaien tot ie bij de juiste positie staat.
4 Arduino dan resetten en meteen schakelaar terug op weerstandsbrug.
Ga het schema hierop aanpassen
-
poging gedaan om een video te maken:
met nog een C-rail erop ;D
-
Mooi stuk verder gekomen. Nu met Krail:)
Hekwerk en trappetje zijn ook klaar maar dat komt er later aan. Idem houten vlonders tot aan de spoorstaven.
Tevens de H- balken ter ondersteuning.
(https://myalbum.com/photo/xiVfHo2XcnMz/720.jpg)
-
Stap verder:
(https://myalbum.com/photo/yiXVVNoivcPP/720.jpg)
Oplopende bodem uiteindelijk van witte klei gemaakt, gemengt met wat zwart acrylverf. In ieder geval alvast een basis voor verdere afwerking. Hij loopt soepel over de rails.
-
daar gaat ie
https://www.youtube.com/watch?v=LIHeX7czPvk (https://www.youtube.com/watch?v=LIHeX7czPvk)
-
Mmoie stappen Bert, Gaaf om te zien..
-
Dat ziet er allemaal goed uit, Bert.
Ik heb je filmpje even tussen [youtube] tags gezet. Kunnen we het hier meteen op het Forum bekijken.
Rob
-
Dank Rob!
Ga ik dat de volgende keer ook zo doen
-
Stapje verder.
MDF rand vastgelijmd. Met een lintzaag uit een plaatje gehaald.
Binnenkort de brug spuiten in een soort legergroen.
-
Mooie update weer Bert. De draaischijf loopt prachtig.;)
-
(https://myalbum.com/photo/TFK8ynZnbUd5/720.jpg)
Verf moet nog wat bijgewerkt worden.
Daarna de planken nog
-
Hoi Rob,
Het was even stil rond de draaischijf. Inmiddels zijn de plannen wat aangepast en willen we (doe het samen met zoon Rutger) de schijf graag met DCC aansturen.
In de test deden we het met schakelaars en een weerstandsarray, bekend.
Rutger heeft een Ecos (met een loconet converter)
Verder gebruiken we DCCnext voor aansturing van o.a. De wissels.
Een denkbare oplossing:
10 DCC next uitgangen aansturen voor de 10 draaischijf posities met elke uitgang een andere DC waarde voor de analoge input van de Arduino.
Dit komt me wat krom over, heb jij (of een andere uiteraard) betere ideeen?
-
Hoi Bert,
Een denkbare oplossing:
10 DCC next uitgangen aansturen voor de 10 draaischijf posities met elke uitgang een andere DC waarde voor de analoge input van de Arduino.
Dit komt me wat krom over, heb jij (of een andere uiteraard) betere ideeen?
Ik ben niet bekend met het DCC protocol, maar ik kan me voorstellen dat je gewoon commando's naar de Ardino kan sturen, bijvoorbeeld met een serieel protocol. Ik gebruik (andersom) wel seriële communicatie (zend/ontvang) met een MP3 spelertje in mijn geluidsmodules. En dat werkt prima.
Anders kun je denken aan 10 pinnen één voor elke stand, maar die is ook weinig elegant.
Beter is dan misschien om 4 pinnen te gebruiken waarop je binair gaat tellen van 0 t/m -maximaal- 15.
Maar hoe je dit alles aansluit op DCC, ik heb geen idee of dat kan en hoe dat zou moeten.
Rob
-
Bedankt voor de reactie Rob!
10 pinnen had ik in gedachte, het lijkt me beter te kunnen, ff verder studeren.
Laat het nog wel weten! ::)
-
Alhoewel ik nog niet het gevoel heb dat het de perfecte oplossing is……
Met DCC-next kun je een PWM signaal uitgeven, daar is eenvoudig een DC signaal van te maken die vervolgens aangesloten kan worden op de analoge ingang van de draaischijf Nano……
In plaats van de DCC-next kan het ook “gewoon” een Arduino zijn met een opto schakeling voor de DCC in.
Moet ik nog wel even weten hoe de Ecos een draaischijf aanstuurt, het is waarschijnlijk eenvoudiger dan het nu lijkt
-
Hoi Bert,
Het begint al te rijpen, zo te lezen.
Alhoewel ik nog niet het gevoel heb dat het de perfecte oplossing is……
Met DCC-next kun je een PWM signaal uitgeven, daar is eenvoudig een DC signaal van te maken die vervolgens aangesloten kan worden op de analoge ingang van de draaischijf Nano……
Je kunt ook nog overwegen de PWM met de draaischijf Nano direct uit te lezen (dus zonder DA omzetting). Dat vereist wel wat herprogrammering van de draaischijf Nano om de tijd tussen de flanken van het PWM signaal te meten en dat om te rekenen naar een pulsbreedte percentage. Het kan in ieder geval: ik doe dit bij het 'lezen' van de PWM rijstroom met de geluidsmodules in mijn treinen.
Rob
-
Goed idee Rob! Lijkt me stabieler dan de gedachte route. Nu nog even de Ecos begrijpen.
Laat het nog wel weten.