Arduino analoge(!) modelbaan sturing

[Klaas Zondervan]

Volgens de datasheet ligt de current transfer ratio rond de 100% bij een uitgangsstroom van 50 mA. Dan moet je er dus ook 50 mA ingangsstroom in stoppen. Ik heb geen ervaring met de Arduino, maar is dat niet een beetje veel?

[Fritsprt]

je moet de uitgangen van de Arduino niet met meer dan 40mA belasten. Ik weet uit ervaring dat je een relais prima met een optocoupler kan aansturen. De ingangsstroom kan je dan met gemak kleiner dan 10mA laten zijn terwijl de uitgang met gemak 50mA schakelt.
Het is de keus aan de starter van dit draadje hoe hij het wil gaan doen. Ik adviseer altijd optocouplers i.c.m. microcontrollers. En als de relais meer stroom vragen kan je ook een combi maken van een optocoupler en een transistor.

[Klaas Zondervan]

De ingangsstroom kan je dan met gemak kleiner dan 10mA laten zijn terwijl de uitgang met gemak 50mA schakelt.

Maar dan moet de opto wel een CTR hebben van gegarandeerd 500%. Bij de PC817 kan die liggen tussen 50% en 600%. Je kan dus ook behoorlijk pech hebben als je een slechte treft.

[smits66]

Hoi volgers

@Arthur

Bedankt voor je input. 

Ik hoef deze diodes (1N4007) niet te kopen, heb er nog een stuk of 500 liggen.

Het bi-stabiele relais word gebruikt om op het bedieningspaneel, de stand van de wissel zichtbaar te maken( geel of groene led ) .
Het andere schakelcontact kan het onbereden spoor stroomloos te maken, of een andere functie, het belangrijkste is de terugmelding naar het bedieningspaneel.

@Fritsprt

Bedankt voor je input en schema, ik ga nu eerst maar eens een proefopstelling van de schakeling maken en het testen.

@Klaas

Bedankt voor je input 

@Hans

Bedankt voor je input. 

@Allen

Deze schakeling hoeft niet anders te doen dan via de Arduino of via het schakelpaneel een kort puls te geven om het bi-stabiele relais om te zetten voor een terugmelding van de wisselstand naar het bedieningspaneel,  en tegelijk met het andere relais een wissel om te zetten.

[Klaas Zondervan]

Paul, heb je er nooit aan gedacht om de wisselstand terug te melden via het eindafschakelcontact?
Dan heb je de echte wisselstand. Met dat bi-stabiele relais heb je een afgeleide stand, maar bij een weigering van het wissel hoeft die niet gelijk te zijn.

Het principe van zo'n terugmelding staat op mijn website

[smits66]

Hoi

@Klaas

Bedankt voor je input. 

Ik weet dat er wissels bestaan met een eind afschakel contact, helaas hebben Minitrix  wissels geen eind afschakel contact, ik ben dus gaan zoeken naar een andere oplossing voor de terugmelding naar het bedieningspaneel.

Mocht de wissel een keer weigeren(heb ik nog niet meegemaakt) vind ik dat geen probleem, op mijn modelbaan rijden niet veel treinen tegelijk.

[Timo]

Hoi Paul,

Helaas heb ik geen tijd om alle vorderingen uit te pluizen. Volgt er nog code?  Over het schema heb ik, net als velen  ,  wel een opmerking.

Ik zou zelf ook voor de schakeling gaan die de stroom sinkt (dus in de lijn naar ground zit zoals in je laatste tekening) ipv een opto. Een transistor koswt gewoon minder. Marrr....

Waarom gebruik je nog relais???!!! Een wissel is prima met gelijkspanning aan te sturen. Een darlington array zoals de ULN2003A. Per uitgang kunnen deze 500mA leveren (piek @ 600mA). Deze mag je parallel schakelen. Dus met twee een uitgang van 1A maken. Dit moet wel genoeg zijn voor een wissel. Ze kosten minder dan een kwartje en daarmee heb je 7 uitgangen. Dit is dus genoeg voor net geen twee wissels @ 1a. Met 4 chipjes kun je zo 7 wissel schakelen. Een drukknop parallel hieraan is ook geen probleem. Minder onderdelen, minder mechanisch ,goedkoper en je gebruikt een opto niet buiten zijn spec's. Als je de voeding van de wissels uit een andere voeding haalt dan de voeding van de Arduino maar ze alleen common ground (gemeenschappelijke ground) bij de ULN's geeft is het geen probleem. De Arduino blijft dan wel lopen. 

Voor de relais om de baan mee af te schakelen zou ik vervolgens wel het current sink principe gebruiken. Gewoon een BC547 met een 1N4148. Overigens hebben die voor deze toepassing (blusdiode) ook de voorkeur boven de 1N4001. De 1N4148 is namelijk een high speed diode en kan dus sneller ingrijpen bij een piekspanning door de spoel. En ze kosten ook nog eens veeeeel minder 

En misschien wel heel erg buitenom. Het is natuurlijk niet nodig één Arduino al het werk te laten doen. Je wilt ze toch al in netwerk gooien dus meerdere Arduino's gebruiken om wissels te schakelen is geen probleem. Kan je juist alle drukknoppen naar de Arduino Mega doen. Of juist hier ook een losse arduino voor pakken. Scheelt je al die (dure) bistabiele relais. Nadeel, code code code. Je zult dit wel weer in de code moeten opnemen. Extra voordeel, je kan de Arduino een schakelactie laten blokkeren uit veiligheidsoverweging. Bijvoorbeeld van een wissel die bereden wordt.

Heb je al meerdere Arduino's met elkaar laten praten?


Timo

[Klaas Zondervan]

De 1N4148 is namelijk een high speed diode en kan dus sneller ingrijpen bij een piekspanning door de spoel.

Hier is toch sprake van een misverstand. Als een stroomvoerende spoel wordt afgeschakeld, dan wil de opgeslagen magnetische energie de stroom in stand houden. Als er geen blusdiode aan zit, dan kan die stroom nergens naar toe, en zal een piekspanning veroorzaken. Maar een blusdiode zorgt er voor dat de stroom wel een pad vindt, en de spanning over de spoel wordt dan niet groter dan de drempelspanning van de diode. En die is voor de 1N4001 en de 1N4148 hetzelfde.
De 1N4148 is weliswaar sneller, maar dat speelt hier geen rol. Hij is nl. sneller bij de overgang van geleiden naar sperren, de z.g. reverse recovery time.
Maar in de functie als blusdiode gaat het om de overgang van sperren naar geleiden, en ik kan me niet voorstellen dat daar verschil in zit.

[Timo]

Ah, tuurlijk  Mijn fout, dat deel mag dus vergeten worden  Bedankt voor het opfrissen Klaas 


Timo

[smits66]

Hoi volgers

@klaas

Bedankt voor je input.

@timo

Bedankt voor je input.

Ik heb de laatste tijd even minder tijd om aan het programma te werken, ik heb ondertussen wel een versie klaar waar het automatische gedeelte is ingebouwd, maar bij het testen van het programma krijg ik nog veel foutmeldingen, standalone werk het wel, er zullen wel een aantal variabelen, constanten nog niet goed staan, word nog aan gewerkt.

Ik maak van relais gebruik omdat mij dat minder poorten kost.
Met gebruik van relais kost het mij maar twee poorten per wissel inclusief de terugmelding wisselstand en bezet melding van het bereden spoor naar het bedieningspaneel, als ik dat rechtstreeks door de Arduino zal doen kost het mij 5 poorten, 2 x wissel en twee leds (geel/groen) misschien met een stukje programma kan ik het met vier poortjes af, als ik 20 wissels( 20 wissels x 4 poorten 2x spoel en 1 keer led 1x bezetmelding ) past dus niet op 1 Arduino mega,  heb kost mij dat minimaal 2 Arduino mega voor alleen, de wissels te kunnen sturen met terugmelding wisselstand en bezetmelding bereden spoor.

Met een relais kost het veel minder poorten  van de arduino  (20 wissels = 40 poorten)  dan heb ik maar 1 Arduino mega nodig.

Ik denk dat het programma daardoor een stuk overzichtelijker blijft.

Voor de prijs van een relais hoef ik het niet te laten,  een bi-polair relais 12v kost euro 1,95 en een unipolair relais 12v kost  euro 0,70
Voor twintig wissels heb ik 20 bi-polair relais en 40 unpolaire wissels nodig.

[Timo]

Met een relais kost het veel minder poorten...

Nee hoor, zorg voor redelijke transistors (bijvoorbeeld dubbele ULN2003 ofzo, zitten ook mooi in een array => maakt simpele printen) en plaats ipv het monostabiel relais (jij noemt ze unpolaire) gelijk de wisselspoel. Zo spaar je al die 40 monostabiele relais uit. Is toch mooi 40 x 70 cent = 28 euro! Je bistabiele relais hou je gewoon parallel aan de wisselspoelen en je gebruikt maar twee pinnen per wissel.

Denk er met deze methode aan dat jij wel dat je met de arduino niet terug kunt lezen dat je hem met de hand bedient hebt. Dit kan prima werken maar de wisselstand "in het geheugen" van Arduino hoeft dus niet met de werkelijkheid overeen te komen. Iets wat je makkelijk kunt vergeten.

Waar je ook nog aan zou kunnen denken, je stuurt toch maar 1 wissel per keer, is om de wissels te gaan multiplexen. Door bijvoorbeeld alle rechtdoor en alle afbuigen aan elkaar te hangen aan de high side en dan de low side van iedere wissel via een transistor aan de arduino te hangen. Zo heb je 20 (wissels) + 2 (richting) = 22 pinnen nodig om alle wissels te sturen.  Wil je wissel 5 afbuigen dan stuur je de low side van wissel 5 samen met de afbuigen high side. Deel je zo in twee groepen zelfs maar 14 pinnen (10 wissels + 1 rechtdoor groep 1 + 1 rechtdoor groep 2 + 1 afbuigen groep 1 + 1 afbuigen groep 2 = 14). Wissel 12 rechtdoor wordt dan output 2 (voor wissel 2 en 12) aansturen en dan groep 2 rechtdoor aansturen. Over multiplexen (veelal met led's maar idee is hetzelfde) is genoeg op internet te vinden. Ik kan anders ook wel een schema maken, dan zal je zien dan het niet zo veel voor stelt als dat het nu lijkt.


Timo

[smits66]

Hoi volgers

@Timo

Bedankt voor je input 

@ allen

Nadat ik gehoord had dat mijn vader niet lang meer te leven had, ondertussen is mijn vader overleden,  heb ik een lange tijd geen interesse meer in modelspoor gehad, had andere dingen aan mijn hoofd.

Ik ben weer verder gegaan met mijn Arduino analoge modelbaan sturing.
Ik heb het na lang zoeken en programmeren de sturing werkend gekregen, hoewel het nog niet perfect is werkt het wel, via de seriele monitor in het Arduino programma of via putty kan ik commando's van de computer naar de Arduino sturen die weer de commando's naar de baan stuurt.

Op dit moment kan ik twee blokken en twee treinen sturen en een noodstop commando geven , er moeten op de analoge in poort van de Arduino nog een acht tal knoppen worden gemaakt om de baan zonder de seriele monitor of putty te bedienen.

Dat is tevens mijn volgende uitdaging om dat te realiseren en het programma daar op aan te passen.

De sturing moet nog wel verbeterd worden zoals de aansturing van de treinen in meer stappen nu 3 stappen later 6 stappen om op te trekken en om af te remmen.

Ook moet er nog een functie in om de treinen van richting te laten veranderen, zodat er twee kanten op gereden kan worden

Er moet nog een functie worden in gebouwd om elke locomotief zijn parameters move (locomotief, snelheid, richting) en locomotief type, dit wil ik doen via een seriele input functie, ik weet nog niet hoe ik dat moet programmeren, daar kom ik wel achter.

De parameters zien er als volgt uit : Br80, 0, 128, 1, deze gegevens wil ik zien op het lcd display.

Foto van de sturing .



Filmpje van de Arduino analoge modelbaan sturing, het eerste test rondje.

http://youtu.be/mFR0suFjO38

Het programma:

Code: [Selecteer]

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

/***** Global vars ***********************************************/


// Define I2C Address where the PCF8574A is
#define BACKLIGHT_PIN     3

LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7); // adressering lcd display

char incomingByte;

/******************************************************************************
 * Definitions
 ******************************************************************************
 *motor A is aangesloten op OUT1 en OUT2 van de motorsturing
 *motor B is aangesloten op OUT3 en OUT4 van de motorsturing
 ******************************************************************************/

const char StringMotorA[] = "motor A: ";
const char StringMotorB[] = "motor B: ";
const char StringFull[] = "full";
const char StringHalf[] = "half";
const char StringLow[] = "low";
const char StringSpeed[] = " speed";

// constants won't change. Used here to
// set pin numbers:

const int ledPin =  13; // Pin nummer LedPin
const int blok1Pin = 6; // Pin nummer Blok 1
const int blok2Pin = 7; // Pin nummer Blok 2

int Interval = 500;
//int wachtTrein = 3000;
//int BlokVrij = 10000; //automatische mode 10 seconden voor het blok vrij gegeven word.
int tijd = 2000;

// Variables will change:

//Motor A

int PWMA = 3; //Speed control
int AIN1 = 9; //Direction
int AIN2 = 8; //Direction

//Motor B

int PWMB = 5; //Speed control
int BIN1 = 11; //Direction
int BIN2 = 12; //Direction

int ledState = LOW;             // ledState used to set the LED
int wachtState = LOW;
int blokState = LOW;

long previousMillis = 0;        // will store last time LED was updated
//long previousMillisWacht = 0;       
//long previousMillisBlok = 0;

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.

//long interval = 500;           // interval at which to blink (milliseconds)

void setup(){

  lcd.begin (16,2);

  // Switch on the backlight

  lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home ();                   // go home

  // Print a message to the LCD.

  lcd.setCursor(2,0); //Start at character 2 on line 0
  lcd.print("Arduino Uno");
  lcd.setCursor(1,1);
  lcd.print("L298  M-Sturing");

  Serial.begin(9600);

  Serial.println("Arduino test programma : Motorsturingen en blok meldingen");

  menu();

  // Set all the pins we need to output pins
  // pinMode(STBY, OUTPUT);

  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);

  pinMode(PWMB, OUTPUT);
  pinMode(BIN1, OUTPUT);
  pinMode(BIN2, OUTPUT);

  pinMode(2, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(ledPin, OUTPUT);
}

void loop (){

  // Controlle led om te zien of het programma nog werkt.

  unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > Interval) {

    // save the last time you blinked the LED

    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:

    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;

    // set the LED with the ledState of the variable:

    digitalWrite(ledPin, ledState);

  }

  if (Serial.available()) {

    //read serial as a character
    //char ser = Serial.read();

    if (Serial.available() > 0) {  // kijk of de seriele verbinding beschikbaar is.
      incomingByte = Serial.read(); // Lees een 'byte'.
    }

    // Begin Taak 1: Blok1 vrij

    if(incomingByte == '1') {
     
      lcd.home ();
      lcd.setCursor(0,1);
      lcd.print("Blok 1: vrijgave");
     
      Serial.println("Blok 1 : Vrij");
      digitalWrite(blok2Pin, HIGH);

      menu();
      prompt();   

    }

    // Einde Taak 1: Blok1 vrij 

    // Begin Taak 2: Blok 1 bezet 

      if(incomingByte == '2') {
     
       lcd.print("Blok 1: vrijgave");
       
      Serial.println("Blok 1 : Bezet");
      digitalWrite(blok2Pin, LOW);

      menu();
      prompt(); 

    }

    // Einde Taak 2: Blok 1 Bezet 

    // Begin Taak 3: Motor B aan

    if(incomingByte == '3') {
     
      lcd.home ();
      lcd.setCursor(1,1);
      lcd.print("   Speed low    ");
     
      Serial.println("Trein B: Low speed");
     
      move(1, 120, 1); //motor B, low speed, links
      schakeltijd();
     
      lcd.home ();
      lcd.setCursor(1,1);
      lcd.print("   Speed half   ");
     
      Serial.println("Trein B: Half speed");
     
      move(1, 150, 1); //motor B, half speed, links
      schakeltijd();
     
      lcd.home ();
      lcd.setCursor(1,1);
      lcd.print("   Speed full   ");
     
      Serial.println("Trein B: Full speed");
     
      move(1, 200, 1); //motor B, full speed, left
     
      Serial.println("Trein B rijd op full speed totdat er een stop comando komt.");

      menu();
      prompt();

    }

    // Einde Taak 3: Motor B on     

    // Begin Taak 4: Motor B off

    if(incomingByte == '4') {
     
     
      Serial.println("Trein B: Half speed");
     
      displ();
      lcd.print("   Speed half   ");

      move(1, 150, 1); //motor B, half speed, links
      schakeltijd();
     
      Serial.println("Trein B:  Low speed");
     
      displ();
      lcd.print("   Speed low   ");
     
      move(1, 120, 1); //motor B, low speed, links
      schakeltijd();
     
      Serial.println("Trein B: Stop");

      move(1, 0, 0); //motor B, stop

      Serial.println("Motor B staat stil omdat er een stop comando gegeven is.");

      displ();
      lcd.print("  trein stopt  ");
      schakeltijd();
      lcd.print(" Arduino trein ");
      menu();
      prompt();

    }
    // Einde Taak 4: Motor B off

    // Begin Taak 5 : Blok 2 On

    if(incomingByte =='5'){ 

      Serial.println("Blok 2 Vrij");
      digitalWrite(blok1Pin, HIGH);

      menu();
      prompt(); 

    }

    // Einde Taak 5 : Blok On

    // Begin Taak 6: Blok 2 Off

    if(incomingByte == '6') {

      Serial.println("Blok 2 Bezet");
      digitalWrite(blok1Pin, LOW);

      menu();
      prompt(); 

    }

    // Einde Taak 6: Blok 2 bezet

    // Begin Taak 7: Motor A On

    if(incomingByte == '7') {

      Serial.println("Trein A gaat vertrekken");
      Serial.println();
      Serial.println("Trein A: Low speed");
      lcd.print("   Speed low   ");
     
      move(0, 120, 1); //motor A, low speed, rechts
      schakeltijd();
     
      Serial.println("Trein A: Half speed");
      lcd.print("   Speed half   ");

      move(0, 150, 1); //motor A, half speed, rechts
      schakeltijd();
     
      Serial.println("Trein A: Full speed");
      lcd.print("   Speed full   ");

      move(0, 200, 1); //motor A, full speed, rechts

      Serial.println("Trein A rijd op full speed totdat er een stop comando komt.");

      menu();
      prompt();

    }

    // Einde Taak 7: Motor A on 

    // Begin Taak 8: Motor A Off

    if(incomingByte == '8') {

      Serial.println("Trein gaat stoppen");
      Serial.println("Trein A: Half speed");
      lcd.print("   Speed half   ");
     
      move(0, 170, 1); //motor A, half speed, rechts
      schakeltijd();
     
      Serial.println("Trein A:  Low speed");
      lcd.print("   Speed low   ");
     
      move(0, 120, 1); //motor A, low speed, rechts
      schakeltijd();
     
      Serial.println("Trein A: Stop");
      Serial.println("Trein A is gestopt omdat er een stop comando gegeven is.");
     
      move(0, 0, 0); //motor A, stop
     
      menu();
      prompt();

    }

    // Einde Taak 8: Motor B off

    // Begin Taak 9 : Noodstop

    if(incomingByte == '9') {

      Serial.println("Noodstop :Treinen A+B stop en blok 1+2 bezet");

      menu();
      noodstop();
      prompt();

      Serial.println("Trein 1 noodstop");
      Serial.println("Trein 2 noodstop");

      digitalWrite(blok1Pin, LOW);

      Serial.println("Blok 1: Bezet");

      digitalWrite(blok2Pin, LOW);

      Serial.println("Blok 2: Bezet");
     
      displ();
     
      lcd.print("Noodstop gemaakt");

      // Einde Taak 9 : Noodstop

    }
  }
}

void move(int motor, int speed, int direction){

  //Move specific motor at speed and direction
  //motor: 0 for B 1 for A
  //speed: 0 is off, and 255 is full speed
  //direction: 0 clockwise, 1 counter-clockwise

  boolean inPin1 = LOW;
  boolean inPin2 = HIGH;

  if(direction == 1){
    inPin1 = HIGH;
    inPin2 = LOW;

  }

  else{
    if(direction == 0) 
      inPin1 = LOW;
    inPin2 = HIGH;

  }

  if(motor == 1){
    digitalWrite(AIN1, inPin1);
    digitalWrite(AIN2, inPin2);
    analogWrite(PWMA, speed);

  }

  else{
    digitalWrite(BIN1, inPin1);
    digitalWrite(BIN2, inPin2);
    analogWrite(PWMB, speed);

  }
}

void noodstop(){

  //Motor A en B stoppen

  move(1, 0, 0);// motor A stop
  move(0, 0, 0);// motor B stop

}

void displ(){

  lcd.home ();                   // go home
  lcd.setCursor(1,1);
 
}

void schakeltijd(){

  delay(tijd);

}

void menu(){


  Serial.println();
  Serial.println("Stuur comando's");
  Serial.println();
  Serial.println("1 = Blok 1 vrijgeven            5 = Blok 2 vrijgeven");
  Serial.println("2 = Blok 1 bezet melden         6 = Blok 2 bezet melden");
  Serial.println("3 = Motor A starten             7 = Motor B starten");
  Serial.println("4 = Motor A stoppen             8 = Motor B stoppen");
  Serial.println("< = Motor linksom               > = Motor rechtsom");
  Serial.println();
  Serial.println("9 = Motoren A en B stoppen en blok 1 en 2 bezet melden");
  Serial.println();

}

void prompt(){

  Serial.println();
  Serial.println("Volgende comando >");
  Serial.println();

}

 

[tuurtje]

Beste Paul,

Mijn oprechte deelneming met het verlies van je vader.


m.vr.gr.

Arthur van Holst

[smits66]

Hoi volgers

@Arthur

Bedankt voor je medeleven.

@allen

Hoewel ik even niet actief op het forum en in mijn draadjes ben, ben ik wel verder gegaan met de sturing.

Het programma ben ik aan het aanpassen, het aantal blokken word uitgebreid naar 4 en word bediend door  een drukknop per blok, de motorsturing blijft hetzelfde , voorlopig blijft de sturing handbediend, het is al vrij ingewikkeld om een goed werkend programma te schrijven.

Er komt nog een uitbreiding bij namelijk een bleutooth verbinding met een tablet om daarmee de sturing te bedienen, de terminal bediening blijf gehandhaafd, zodat ik kan kiezen of ik de sturing kan bedienen met de computer of de tablet.

Ook zijn er plannen om eens wat meer te gaan doen met I2C om meerdere Arduino's met elkaar te verbinden, zodat de ene Arduino de blokken kan bedienen en de ander wissels en seinen.

Ik ben bezig om een kleine Arduino print (7x5 cm) te ontwerpen zodat ik de standaard Arduino voor andere projecten kan gebruiken.

[Fritsprt]

Paul, tenzij je het heel leuk vindt om printjes te ontwerpen en maken zou ik je aanraden om een Arduino pro mini of een nano te gebruiken voor je stationaire opstelling.
Elders op het forum is een draadje over gebruik van een pro mini. (Weet uit mijn hoofd de naam even niet)

Leuk draadje trouwens. Ik lees graag mee met je ervaringen.

Gr. Frits