Aandrijving inbouwen in handdraaischijf

[Rob]

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




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.






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.




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.




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.




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.






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.




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.

.


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.




Nu doen zowel de V60 als V160 het goed.






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.



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.




Nog even een overzicht van de gehele constructie.




En @mark mms , zal ik de Arduino sketch ook nog ergens neerzetten?

Rob

[Raages]

Dat is een mooie duidelijke uitleg van een interessant project.

[Dirk T]

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!

[Wim Corduwener]

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...


....maar daar zat een servo onder omdat die draaischijf niet helemaal rond hoefde te draaien. 

[Rob]

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:

Code: [Selecteer]

/*
 * 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

[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

[The Breeze]

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

[Rob]

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

[mark mms]

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.

[Rob]

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

[The Breeze]

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

[nico]

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.

[The Breeze]

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....)

[Rob]

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.



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.




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.




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.




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.




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.




Ik kan nog niet gaan strooien zolang de verf niet droog is, dus dan eerst de brug maar aangepakt.
Eerst een hekwerkje plaatsen.




Dan lekker met de kwast er tegenaan met bruin en een zelf gemengde grijs/groen.




En als laatste nog wat dry-brush met bruin en beige.




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

[Pierre]

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.

[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.

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

[Wim Corduwener]

...zuinig gebruik van materiaal, ook in het grootbedrijf.

Mooie uitleg, die ga ik een keer van je lenen. 

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?

[Rob]

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  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

[Rob]

Gewoon de hekjes rechtop gebogen en....
Het past net!




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

[Pierre]

Veel beter zo Rob. Top!

[Wim Corduwener]

De groepsdruk neemt weer toe 

“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. 

[NickvR]

Mooie draaibrug Rob! Vind het een interessant station worden, ik kijk uit naar het eind resultaat!

[Rob]

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).

[mark mms]

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.

[Rob]

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