Arduino analoge(!) modelbaan sturing

[smits66]

Hoi Peter

Bedankt voor je reactie.

Bedankt voor je voorbeeld, makkelijk is het niet maar ik denk dat ik er wel wat mee kan.

Ik weet dat programmeren niet makkelijk is, maar ik vind het wel een uitdaging, iedere stap die werk geeft mij de zin om een volgend probleem op te lossen.

Dat ik alles zelf moet uitdokteren vind ik leuk, het is ook niet de bedoeling om er een nieuw product op de markt te zetten.

Dit is voor mijn eigen modelbaan, het programma hoeft dan ook niet perfect te zijn en de sturing hoeft ook niet perfect te zijn, je moet het systeem zien als een analoge bedieningspaneel, maar dan via de computer.
Ik wil mijn modelbaan sturen via de computer maar het moet/hoeft niet automatische te zijn, zeg maar een terminal bediening voor de treinbaan.

Mvg Paul

[Peter Korsten]

Dat scheelt al een boel. Het programma zal nog steeds niet vanzelfsprekend zijn, maar in ieder geval een heel stuk gemakkelijker dan wanneer je automatisch rijden zou willen hebben.

- Peter

[Timo]

Ik heb wat gesurft om het een en het ander uit te zoeken over verschillende mosfet 's , er zijn mij twee types opgevallen die mij geschikt lijken (IRF 720 en IRF 820) de max stroom continu van de IRF 720 is 3.3 A en van de IRF 820  2.5 A, deze mosfet's  lijken mij geschikt voor mijn wissels.

Ik kan je vertellen, dat wordt aardig krap. Op het eerste gezicht lijken ze aardig geschikt maar kijk je beter kom je er achter dat het niet zo is. Laten we beginnen met de IRF720, deze heeft een R_on van 1,8ohm. Bij 1A stookt de transistor al 1,8W, bij 2A is dat al 7,2A! Omdat je de transistor niet continue aan hebt is dit niet zo'n probleem maar toch zonde. En een continue last schakelen met dezelfde print gaat alleen lukken met flinke koellichamen. Bij de IRF820 is de R_on alleen maar erger met 3,0ohm.

En dit is als de MOSFET volledig open geschakeld wordt. Hiervoor is de gate-source spanning van belang (V_GS). In de datasheet staat dat deze minimaal tussen de de 2,0V en 4,0V moet zijn om de MOSFT open te schakelen. Nu levert de Arduino 5V dus zou je zeggen, geen probleem. Maar de opgegeven V_GS is bij een stroom van 250uA! Scrollen we naar beneden zien we dat we met 5V net 1A kunnen schakelen (op kamertemperatuur). IRF820 doet het iets beter maar houdt ook niet over.

Beide MOSFETs hebben dus aardige nadelen. Ik zou toch nog even verder kijken als ik jou was. Is de eerder genoemde IRF7103 niets? Kan 3,0A aan, kost €0,25 (per twee kanalen, is dual channel), heeft een R_on van 0,130ohm en met een V_GS van 5V is hij volledig aan voor 9A (pulsed). Hij is dan wel SMD maar op een geëtste printplaat met soldermask (hebben de printen uit China iig) is solderen echt een eitje.

Ik heb deze printjes juist  ruimer gemaakt, dat maak het solderen van de printjes een stuk makkelijker, ook als er een onderdeel kapot gaat is het makkelijk te vervangen.

Het lijkt tegenwoordig mode te zijn om de printen zo compact mogelijk te ontwerpen. 

Haha, klopt. Kleiner is nu eenmaal goedkoper! En dat vervangen is een beetje ruimte wel handig maar jij hebt zeeën! En voor vervangen is het vooral van belang dat je ruime gaten maakt. Een gat waar een component precies in past soldeert het makkelijkste maar desoldeert het lastigst, hoe veel ruimte je er ook omheen hebt.

Met wat ruimte over is niets mis maar zou ik wel een poging doen ze enkelzijdig te maken, moet makkelijk kunnen. Dat is toch altijd the holy grail bij het ontwerpen van printen  Schuin gelijk alle bochten in de printsporen af. Heb je vooraf al beetje gekeken hoe duur het laten maken van de verschillende formaten is? Waar wil je ze laten maken?

Ik ga thuis niet zitten kliederen met chemische stoffen om printjes te maken, de printjes in China laten maken is een stuk goedkoper( ik hoef geen aparte kamer met exotische apparaten, lichtbak, etsbak, spoelbak enz., te kopen) en een stuk schoner.

Tja, ik doe het zelf ook niet. Voor complexe printen is het het niet waard en je krijgt mooi soldermask en silkscreen enz. Maar voor simpele printjes als deze zou ik het nog wel eens willen gaan doen. (maar dan met een laserprinter, niet een lichtbak). Alleen nog niet van gekomen.

Sorry, maar ik begrijp de code niet helemaal

Schaam!!!  Er miste een belangrijk stuk in de code. Het had moeten zijn

Code: [Selecteer]

const byte turnouts[] = {30, 31, 32, 33, 34, enz };

void setTurnout(byte turnout, byte state){
   digitalWrite(turnouts[turnout], state);
}
Is het nu logischer?

Het is mij ook niet helemaal duidelijk hoe ik een libray met een klasse moet maken, heb je misschien een klein voorbeeld voor mij, om het wat begrijpelijker te maken. 

Yep, dat gaf ik aan het einde van de vorige post: Writing a Library for Arduino

Ik maak  soms gebruik van bestaande code en pas die aan aan mijn eigen eisen, op deze manier heb ik de basisopzet van de modelbaan sturing ontworpen.

Helemaal niet mis mee  Maar een vuistregel bij code is, als je heel vaak hetzelfde aan het typen bent doe je iets fout en is er een makkelijkere manier

alleen wissels worden wat lastiger, daar zou een aparte Arduino voor nodig zijn.

Hoe bedoel je dit?

Wat wil ik per blok sturen allereerst de rijrichting en snelheid, blok vrij/bezet melding, blokseinen, wissel (max 2 wissels parallel), verlichting (extra), ga uitzoeken of dat mogelijk is om met 1 Arduino te sturen.

Doet een Arduino met twee vingers in zijn neus 

voor de kleinere blokken ga ik een Arduino Nano met shield gebruiken

Denk, als je toch aan de slag gaat met printen maken, dat het mooiste is als je gewoon een print maakt. En waarom gebruik je hier een Nano en voor de RGB wel een mini?

De rgb driver is een onafhankelijk systeem en word niet gekoppeld aan de Arduino blok sturing.

Waarom? Voor hetzelfde geld hang je deze ook aan het netwerk en laat je de PC deze ook aansturen. Knopje wordt dag, knopje wordt nacht, klaar. Eventueel later uitgebreid met één (of meer) Arduino('s) voor straatverlichting enz.

De communicatie tussen de Arduino's is een andere uitdaging om te ontwerpen, er zijn namelijk meerdere opties, I²C -bus, RS485 -bus, de rx/tx -bus functie op de Arduino.

I2C voor korte afstanden en als je ze onder de baan wil spreiden zou ik voor RS485 gaan. Je zou zelfs de "Arduino aan de computer" kunnen schrappen (want echt, wat zal zijn taak zijn?) en de PC gewoon direct aan de RS485 bus hangen.

De indeling van de Arduino, zoals ik in gedachte heb.

Een blok moet makkelijk passen dus. Ga je toch elk blok voorzien van een motordriver?

En voor het bloksein, je hebt nog neit gezegd hoe je dat wilt doen. Je hebt nu twee poorten maar als je de seinen zelf maakt (dus niet koopt maar gewoon twee ledjes) heb je dus aan één pin genoeg.

Wat ik vooral nog mis, detectie! Of wil je niet dat er een soort bloksysteem is?

En heeft echt elk blok een wissel? Is het misschien niet handiger om een losse Arduino uit te rusten met meerdere drivers en deze gewoon de wissels laten doen?

Op een Uno/Nano/Pro Mini heb je 22 poorten. Voor motordriver gebruik je er 3, voor data 2, 1 voor LED. Zit je op 6 pinnen, heb je er nog 16 pinnen vrij. Voor ieder subblok (relais) heb je dan nog 1 pin nodig voor het relais, een pin voor een bloksein (één zijde) en nog een pin voor detectie. Kan je dus nog 16/3 = 5 subblokken kwijt op dezelfde Arduino! Heb je dus één Arduino voor 5 blokken welk dan op dezelfde motordriver zitten. En dan nog is de Arduino niet echt hard bezig 

Of, als je twee motordrivers op een Arduino hangt, heb je: 2 voor data, 1 voor led, en 2x3 voor twee motordrivers. Heb je nog 13 pinnen vrij. 13/3 = 4. Heb je dus één Arduino met twee motordrives/blokken met elk 2 subblokken. Met een bloksein en detectie per subblok. Lijkt me ook nog makkelijk te maken. Zeker omdat je een dual motordriver wilde gebruiken. (Toch? Ik twijfel maar zie hem zo snel niet  )


Goed, weer heel verhaal  Ik snap dat het hobby moet blijven en dat je alles nog eens overdenkt. Vandaar ook me lange verhaal, beter nu even wat langer nadenken dan straks de pest er over in hebben dat het niet gaat zoals je wilt en het project naar de prullenbak verwijzen.


Timo

[smits66]

Hoi volgers.

Ik ben bijna drie dagen bezig geweest met solderen, aan de proefbaantje, voor de Arduino Analoge Modelbaan Sturing, kortweg AAMS.



Tussen de rails heb ik LDR's geplaatst als signalering of het spoor bezet is en op het kopspoortje een LDR en een reedcontact, er komen totaal 5 LDR's en 5 reed contacten op dit proefbaantje.



Ook heb ik even twee nood seinen gemaakt om de AAMS te testen



Onder het proefbaantje heb ik vier interfaces gemaakt.

2x een seinsturing een digitale / voeding interface en een analoge intertace, er moet nog een wissel sturing onder het proefbaante gezet worden, deze wil ik eerst testen voor ik hem plaats.



Ik heb een begin gemaakt met de stuurkast.
In de stuur kast komt een Arduino Uno met sensor shield, interface print analoog/ digitaal/ voeding, een motor shield (L298) een tweevoudige relais kaart, en twee voedingen 5V, 12V en evt treintravo ( als ik zelf wil rijden ).

Een gedeelte is klaar.



Het is wel de bedoeling om dit Mini baantje (60 cm x 50 cm) te voorzien van scenery (kan nog een leuke uitdaging worden).

De schakelingen zijn op gaatjes-print gebouwd, ik had er nog een aantal van liggen.

Als mijn gedachten spinsels werken wil ik er printen voor gaan ontwerpen, deze worden dan in mijn modelbaan geplaatst.

Een zelfde systeem komt in mijn BNLS  N-Spoor modulebaan waar ik nog mee bezig ben.

Mvg Paul

[smits66]

Hoi volgers

@Timo

Bedankt voor je input, ik heb jou reactie nog niet uitgebreid gelezen, maar dat doe ik zo spoedig mogelijk.

@Peter

Bedankt voor je reactie.

@Allen

Vandaag ben ik verder gegaan met het samen bouwen en testen van de interface's, alles werk in droge mode goed (pin 13 van de Arduino), er zat al een klein programma in.

Na nog wat soldeer werk zat alles in elkaar en kon er verder geëxperimenteerd worden.

Bij het testen van de analoge interface bleek deze verkeerd bedaard te hebben, tussen de baan en de stuurkast zitten 9 polige sub-D connectoren, tussen de analoge connector en de stuurkast zat de bedrading fout, dat heb ik veranderd.

Daarna nog een tijd bezig geweest met de sein-printen om ze goed af te regelen.

Ik heb een klein Arduino programma gemaakt om de drempel waarde van de LDR-sensoren te bepalen, deze waardes heb ik nodig om de verschillende LDR-sensoren te kunnen gebruiken met de AAMS.

Vanavond ben ik begonnen om het AAMS programma te schrijven.

Ik heb nog wat proef gereden met een trein, ik kwam er achter dat ik niet te snel over de LDR-sensoren moet rijden, het gaat overigens wel goed als ik op schaal snelheid rij, maar dat is ook de bedoeling.

mvg Paul.

[Fritsprt]

Hallo Paul,
Wat is de reden dat je LDR's gebruikt. Nadeel van de LDR is volgens mij dat deze "langzaam" van waarde verandert als de hoeveelheid opvallend licht verandert. Dat heb je al gemerkt als de locomotief te snel rijdt. Voordat de weerstandwaarde is veranderd is de trein er al overheen gereden. Een ander nadeel is dat de weerstand waarde afhankelijk is van het opvallende omgevingslicht. M.a.w. als het omgevingslicht vermindert dan zal de LDR aangeven dat er een trein passeert. Ik zou voor dat doel gewoon ir leds met ir transistoren gebruiken. Op de site van opendcc staat daarvan een mooi storingsvrij voorbeeld.
Verder is het weer leuk om je alternatieve treinbesturing te volgen.

Succes weer.

Frits

[smits66]

Hoi, Volgers

Ik zag dat dit topic al weer ruim 11000 bekeken is, allemaal heel erg bedankt daarvoor  , ik vind het leuk dat er toch zo veel belangstelling voor dit topic is.

Vandaag ben ik bezig geweest om de stuurkast samen te bouwen, ik zat nog te wachten op de Arduino Nano + shield , vanmorgen werd het pakketje bezorgt.

Ik ben overgestapt van de Arduino UNO naar de Arduino Nano omdat de Nano kleiner en flexibeler is.

Zoals gezegd ben ik verder gegaan met het bouwen en bedraden van de stuurkast.
In de stuurkast zitten twee Nano's, een L298 motorsturing, een blok Relais en een interface voor de koppeling naar de baan.

De onderlinge componenten zijn door middel van:  dupoint wires, met elkaar gekoppeld, dit werk een stuk makkelijker dan allemaal draden te moeten solderen, en het ziet er een stuk netter uit, de losse draden lopen door gootjes(ringbanden) heen.

Ik hen er even spanning op gezet en alles werk goed, het in nu alleen nog een kwestie van programmeren, dat is een flinke uitdaging, het programma zal niet klein zijn.

De stuurkast,




Morgen ga ik beginnen aan het AAMS programma, ik ga eerst een deel in de Arduino taal programmeren en er moet nog een programma in gambas (visual basic voor linux) gemaakt worden om het proefbaantje te kunnen sturen met de computer.

mvg Paul

[smits66]

Hoi Frits

Bedankt voor je input.

Ik vind het leuk om alternatieven uit te proberen, ik had nog van alles aan electronica onderdelen liggen, die ik voor dit project wil gaan gebruiken, vandaar mijn keuze voor een LDR en alle alternatieve oplossingen voor deze sturing, ik kan wel alles na-apen  (vind ik echt geen probleem, het wiel is al eens uitgevonden  ), ik wilde een budget oplossing om mijn modelbaan te automatiseren en ik vind het leuk om van alles uit te proberen.

De LDR-sensoren werken op het proefbaantje goed, je moet wel een drempelwaarde instellen om de LDR-sensor goed te laten werken, voor mijn bnls n-spoor module zal het omgevingslicht veel minder invloed hebben, doordat de module in een kijkkast zit met zijn eigen bijna constante verlichting.

Dat ik langzamer moet rijden met mijn locomotieven vind ik niet erg, kan ik meer genieten van een trein die door een mooi landschap rijd, en kleine stoom locomotief op TGV snelheid heb ik nog nooit zien rijden

Ik wil op mijn baan op bijna schaal snelheid rijden (niet alle locomotieven kunnen op schaalsnelheid rijden), de treinen zullen niet hard rijden, zodat de LDR-sensoren goed blijven werken.

Als ik zover ben zet ik wel een filmpje op het forum.

Ik wil zeker nog andere sensoren gaan testen op het proefbaantje, ik ben al bezig met reed-contacten.

We blijven zeker nog wel een tijdje experimenteren om een budget analoge modelbaan sturing te ontwerpen. 

Oja, deze sturing heb mij nog geen 50 Euro gekost en het levert mij een hoop hobby plezier op.

Mvg Paul

[smits66]

Hoi, volgers

Hierbij een kort filmpje van een werkende  AAMS programma, het programma is nog lang niet af, maar het begin is er.
De loc rijd eerst snel als de loc een sein voorbij rijd gaat de loc langzamer rijden, en gaat weer sneller rijden voorbij het volgende sein.

De film kwaltijd is niet zo goed, maar het gaat om de sturing.
De seinen werken ook al is het niet zo goed te zien.

Het filmpje: https://www.youtube.com/watch?v=oJxiB2Qlw_w

Mvg Paul

[smits66]

Hoi, Volgers

Het is alweer een tijdje geleden dat ik een update van de Arduino analoge modelbaan sturing heb geplaatst.
Dat wil niet zeggen dat ik er niet mee ben verder gegaan, ik heb ondertussen een Arduino programma geschreven, het is nog lang niet klaar en er moet nog veel geprogrammeerd worden, maar het basis programma werkt goed.

Het programma moet nog beter uitgewerkt worden, er staat nog teveel code in, ik laat het er in om verder te kunnen testen.

Het voorlopige programma:

Code: [Selecteer]

/*
   Arduino analoge modelbaan stuuring.
   
   Auteur : Paul Smits
   
   Versie 1.0 (is nog in testfase)
   
   Nieuwe functie sturing(trein,snelheid,richting)
   Vervangt de functie move(motor,speed,direction)
   Zijn feitelijk dezelfde funcie alleen omgezet naar de modelbaansturing.
   
   Het in stappen optrekken en afremmen is er uit gehaald.
   De trein trekt nu langzaam op of remt nu langzaam af zonder stappen.
   
   Deze software is vrij aanpasbaar en kan door iedereen gebruikt worden,
   voor zijn eigen modelbaan of eigen project.
   
   LET OP !:Het gebruik van het programma geschied op eigen risico.
*/


  #include <Wire.h>
  #include <LCD.h>
  #include <LiquidCrystal_I2C.h> // library voor 12c lcd display

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

  // Set pin numbers als constanten, deze waardes zullen niet veranderen.
 
  const int seinR1 = 2;   // sein 1 Rood = stop blok 1
  const int seinG1 = 3;   // sein 1 Groen = vrijgave blok 1
  const int seinG2 = 5;   // sein 2 Rood = stop blok 2
  const int seinR2 = 4;   // sein 2 Groen = vrijgave blok 2
 
  const int wisselR = 6;  // Wissel stand Rechtdoor
  const int wisselA = 7;  // Wissel stand Afbuigend
  const int AIN1 = 8;    // Richting Rechtom
  const int AIN2 = 9;    // Richting Linksom
  const int PWMA = 10;    // Snelheids regeling trein
  const int blok1 = 11;    // Blok 1
  const int blok2 = 12;    // Blok 2
  const int ledPin = 13;  // Controlle of het programma nog loopt.
 
  // Analoge porten toewijzen.
 
  const int ldrBlok1  = A0; // Detectie Blok1
  const int ldrBlok1s = A1; // Detectie Blok1 sectie 1
  const int ldrBlok2  = A2; // Detectie Blok 2
  const int ldrBlok2s = A3; // Detectie Blok 2 sectie 1
 
  int ledState = LOW;
  int seinR1State = LOW;
  int seinG1State = HIGH;
  int seinR2State = LOW;
  int seinG2State = HIGH;
  int blok1State = HIGH;
  int blok2State = HIGH;
  int wisselRState = HIGH;
  int wisselAState = HIGH;
 
  int Interval = 500; // Tijd vertraging van 0.5 seconden
  // Drempelwaarde van de LDR-sensors moeten induvueel ingesteld worden.
  int Drempelwaarde  = 300;
  int Drempelwaarde1 = 150;
  int Drempelwaarde2 = 300;
  int Drempelwaarde3 = 150;
 
  long previousMillis = 0;
 
 void setup()
 {
   pinMode(seinR1,OUTPUT);
   pinMode(seinG1,OUTPUT);
   pinMode(seinR2,OUTPUT);
   pinMode(seinG2,OUTPUT);
   pinMode(blok1,OUTPUT);
   pinMode(blok2,OUTPUT);
   pinMode(wisselR,OUTPUT);
   pinMode(wisselA,OUTPUT);
   pinMode(PWMA,OUTPUT);
   pinMode(AIN1,OUTPUT);
   pinMode(AIN2,OUTPUT);
   pinMode(ledPin,OUTPUT);
   // Beginstand porten defineren
   
   digitalWrite(seinR1,HIGH);
   digitalWrite(seinG2,HIGH);
   digitalWrite(seinG1,LOW);
   digitalWrite(seinR2,LOW);
   digitalWrite(wisselR,HIGH);
   digitalWrite(wisselA,HIGH);
   digitalWrite(blok1,HIGH);
   digitalWrite(blok2,HIGH);
   
   lcd.begin (16,2);
   
  // Zet de backlight aan.

  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 Nano");
  lcd.setCursor(1,1);
  lcd.print("AAMS V1.0");

  Serial.begin(9600);
  Wire.begin();
  Serial.println("Arduino Nano test programma : Motorsturing, bloksturing, seinsturing");
 }
 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:

     ledState = !ledState;

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

    digitalWrite(ledPin,ledState);

    }
     
    if (Serial.available() > 0) {  // kijk of de seriele verbinding beschikbaar is.
      incomingByte = Serial.read(); // Lees een 'byte'.
    }
   if(incomingByte == '1') {
     
     Wire.beginTransmission(5);
     Wire.write('H');
     Wire.endTransmission();
     
     int ldrBlok1Waarde  = analogRead(ldrBlok1);
     int ldrBlok1sWaarde = analogRead(ldrBlok1s);
     int ldrBlok2Waarde  = analogRead(ldrBlok2);
     int ldrBlok2sWaarde = analogRead(ldrBlok2s);
     
      digitalWrite(blok2, LOW);
      Serial.println("Blok 2 : Vrij");
   
     
   if   (ldrBlok1Waarde < Drempelwaarde){
        digitalWrite(seinR1,LOW);
        digitalWrite(seinG1,HIGH);
        digitalWrite(seinR2,HIGH);
        digitalWrite(seinG2,LOW);
        sturing(1,150,1);
       }
 
   if  (ldrBlok2Waarde < Drempelwaarde){
        digitalWrite(seinR1,HIGH);
        digitalWrite(seinG1,LOW);
        digitalWrite(seinR2,LOW);
        digitalWrite(seinG2,HIGH);
        sturing(1,125,1);     
      }
   }
    if(incomingByte == '2') {
         
     int ldrBlok1Waarde  = analogRead(ldrBlok1);
     int ldrBlok1sWaarde = analogRead(ldrBlok1s);
     int ldrBlok2Waarde  = analogRead(ldrBlok2);
     int ldrBlok2sWaarde = analogRead(ldrBlok2s);
     
     digitalWrite(blok2, LOW);
     
     if  (ldrBlok1Waarde < Drempelwaarde){
       blok(1,1);
       sturing(1,150,1);   
       }
     if (ldrBlok2Waarde < Drempelwaarde){
       blok(0,1);
       sturing(1,125,1);
     } 
       
   }
   if(incomingByte == '0') {
     
     Wire.beginTransmission(5);
     Wire.write('L');
     Wire.endTransmission();
     
     sturing(1,0,1);
     
      digitalWrite(blok2, HIGH);
     
      digitalWrite(seinR1,LOW);
      digitalWrite(seinG1,HIGH);
      digitalWrite(seinR2,HIGH);
      digitalWrite(seinG2,LOW);
   }   
} // einde loop


void sturing(int trein, int snelheid, int richting){
 
  // Zet de parameters van de functie sturing(trein, snelheid, richting)
  // Trein 1: linksom en Trein 2 output B op het motorshield
  // Snelheid: 0 is stop, 255 is maximale snelheid
  // Richting: 0 Rechtsom, 1 Linksom
 
  boolean inPin1 = LOW;
  boolean inPin2 = HIGH;

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

  }

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

  }

  if(trein == 1){
    digitalWrite(AIN1, inPin1);
    digitalWrite(AIN2, inPin2);
    analogWrite(PWMA, snelheid);

  }

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

 // }
}
 void blok(int sein, int blokState){
   
   boolean sPin1 = LOW;
   boolean sPin2 = HIGH;
   boolean bPin1 = LOW;
   boolean bPin2 = HIGH;
   
   if (sein == 1){
     
     digitalWrite(seinR1,sPin1);
     digitalWrite(seinG1,sPin2);
     digitalWrite(seinR2,sPin2);
     digitalWrite(seinG2,sPin1);
   }
   
   //else{
     
     //digitalWrite(seinR1,sPin2);
     //digitalWrite(seinG1,sPin1);
     //digitalWrite(seinR2,sPin2);
     //digitalWrite(seinG2,sPin1);
   //}
   
   if (sein == 0){
     
     digitalWrite(seinR1,sPin2);
     digitalWrite(seinG1,sPin1);
     digitalWrite(seinR2,sPin2);
     digitalWrite(seinG2,sPin1);
   }
   
   //else{
     //digitalWrite(seinR1,sPin1);
     //digitalWrite(seinG1,sPin2);
     //digitalWrite(seinR2,sPin2);
     //digitalWrite(seinG2,sPin1);
  // }
   
   if (blokState == 1){
     digitalWrite(blok1,bPin2);
     digitalWrite(blok2,bPin1);
     Serial.println("Blok 1: vrij --> Blok 2 bezet");
    }
   //else {
     //digitalWrite(blok1,bPin1);
     //digitalWrite(blok2,bPin2);
    // Serial.println("Blok 1: bezet --> Blok 2: vrij");
   //}
   if (blokState == 0){
     digitalWrite(blok1,bPin1);
     digitalWrite(blok2,bPin2);
     Serial.println("Blok 1: bezet --> Blok 2: vrij");
   }
   
   //else {
     //digitalWrite(blok1,bPin1);
     //digitalWrite(blok2,bPin2);
    // Serial.println("Blok 1: bezet --> Blok 2: vrij");
   //}   
 } 
 
Ik zal proberen nog een aantal schema's van de diverse componenten in dit topic te zetten.

De Schema's

Seinsturing:



De Seinsturing heb ik reeds gebouwd en dat werk, ik wil nog uittesten of ik de seinsturing van twee seinbeelden kan sturen met 1 i/o port, zie schema 2

Wisselsturing:



Ik wacht op de bestelde onderdelen om de wisselsturing te gaan bouwen.

Bezetmelding:


T1 is een BC 557

Ik wacht op de bestelde onderdelen om de bezetmelding te gaan bouwen.

Onder de test baan zit nog een analoge interface, dat schema moet ik nog maken, en in de kast zit nog een interface ook dat schema moet ik nog maken.

Zoals altijd hou ik mij aanbevolen voor verbeteringen en/of aanmerkingen van het AAMS programma, of de hardware 

Mvg Paul

[gvandersel]

LEDs van je seinen even omdraaien. Zo doen ze het echt niet.

Gerard van der Sel..

[Timo]

Hoi Paul,

Ik ga weer eens reageren 

Wat ik me als eerste vooral afvraag, hoe ga je de boel voeden? Je tekent wel steeds 12V lijnen, 5V lijnen enz. Maar zijn dit allemaal losse voedingen? En wat ga je allemaal hoe voeden? Heb je
- één voeding Arduino's (liefst 7v+)
- één voeding voor rijden
- één voeding voor wissels
- één voeding voor seinen
Of zijn er dingen gecombineerd? En waar voedt je de relais uit?

Vraag komt vooral omdat je steeds wel tekent van, deze lijnen gaan naar de Arduino. Maar GND zit daar nooit bij...

Wisselsturing
Voor de wisselsturing, toch afgestapt van MOSFETs? Je zou de gate weerstand nog wat kunnen verkleinen. Met 1k limiteer je jezelf tot 1,8A voor de spoelen. (V_BE van 2,5V, blijft er 2,5V over voor 1k. 2,5V / 1k x 750 = +-1,8A.) Zeker in de piek kan een wissel wel meer vragen waardoor de spanning wat traag op kan lopen.

Seinsturing
Je moet inderdaad de LEDjes omdraaien. En waarom stuur je ze op twee verschillende manieren aan? Ook, als je per Arduino maar twee seinen aanstuurt, kan je het ook prima direct uit de Arduino voeden. (En juist de slurpende relais uit een losse voeding.) Zo heb je geen transistors nodig en per sein maar 1 pin.

Bezetmelding
Mooie basis bezetmelder. Je zou eventueel nog een weerstandje over de diodes kunnen zetten. Wordt eigenlijk altijd gedaan omdat op deze manier de melder wel heel erg gevoelig is. En ik zou een Ctje plaatsen over R2 zodat je bezetmelder niet staat te klapperen op je PWM signaal. En hij is nu natuurlijk maar in één rijrichting te gebruiken... Is dat de bedoeling? Lijkt me niet zo praktisch.

Code
Het maken van een library is nog niet gelukt? Dit lijkt mij de boel echt veel eenvoudiger te maken namelijk. Zoals gezegd, als je vaak bijna hetzelfde aan het opschrijven bent is er een makkelijkere methode.

Eerste wat me opvalt is dat je nogal slordig de code wel en niet hebt laten inspringen. Dit is niet zo bevorderlijk voor de leesbaarheid en maak je makkelijk fouten. Dus doe jezelf een lol en probeer dit netter te doen. Arduino helpt je hier al erg hard mee! Dus inspringen na een { en de sluitende } op gelijke hoogte als de functie waar de openende bracket bij hoort.

En nog een ding wat gebruikelijk is bij Arduino en de leesbaarheid ten goede komt, een const begint met een hoofdletter en een niet const begint juist niet met een hoofdletter. Dus:

Code: [Selecteer]

const int DitIsDusEenConst;
int ditIsGeenConst;
Dit zodat je aan de naam kunt zien of je hem nu kunt beschrijven of niet.

Daarna ben je redelijk goed aan de slag gegaan met millis(). Maar, previousMillis moet een unsigned long zijn om gekke problemen te voorkomen. Iets wat je later wel doet met

Code: [Selecteer]

  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > Interval) {
Het wegschrijven van millis() naar een var is hier overigens een beetje nutteloos. Je kan gewoon

Code: [Selecteer]

  if(millis() - previousMillis > Interval) {
Huidige millis() wegschrijven is alleen nuttig als je op meerdere intervals gaat controleren en je zeker wilt zijn dat het check moment voor alle intervallen gelijk is.

Ook declareer je een hele rij met states. Deze gebruik je vervolgens nergens. Is ook niet nodig aangezien je dat gewoon terug kunt lezen. Om een LED te togglen kan je gewoon schrijven digitalWrite(LedPin, digitalRead(LedPin));

In de hele if-tree voor het binnenkomende byte (wat geen byte is maar een char....) kan je de boel iets meer vrij maken door else if te gebruiken. Als er dan een regel gevonden wordt waaraan de binnenkomende char gelijk aan is dan stopt hij met checken van de rest. Nogal zinloos om, nadat je hebt vastgesteld en hebt gehandeld alsof het een "1" is, dan nog te checken of het een twee is.

In de functie blok() maak je eerst een rij met bools aan om ze daarna alleen maar in te vullen in digitalWrite. Maakt het niet echt leesbaar. Wat is het idee er achter?

Om de afhandeling wat soepeler te maken zou ik ook de baud rate van serial opvoeren.

Library
Om een beetje aan te geven wat het idee is van een library in dit geval heb ik een kleine opzet gemaakt van een blok.
AamBlok.h

Code: [Selecteer]

/*
AamBlok.h v1 - Library to iets
Created by Timo Engelgeer (Septillion), February 2, 2015
*/

#ifndef AamBlok_h
#define AamBlok_h

#include "Arduino.h"

#define AAM_GROEN 1
#define AAM_ROOD 0

class AamBlok{
public:
AamBlok(byte pinBlok, byte pinSein, byte pinLdr, byte pinLdrS, int ldrDrempel);
void bezet();
void vrij();
void sein(byte state);
bool checkBezet();
bool isBezet();
void checkStop();
void update();

protected:
bool bezetState;

byte pinBlok;
byte pinSein;
byte pinLdr;
byte pinLdrS;

int drempel;

};

#endif

AamBlok.cpp

Code: [Selecteer]

/*
AamBlok.h v1 - Library to iets
Created by Timo Engelgeer (Septillion), February 2, 2015
*/

/*
Blaa, dit doet iets :p
*/

#include "Arduino.h"
#include "AamBlok.h"

AamBlok::AamBlok(byte pinBlok, byte pinSein, byte pinLdr, byte pinLdrS, int ldrDrempel){
this->pinBlok = pinBlok;
this->pinSein = pinSein;
this->pinLdr = pinLdr;
this->pinLdrS = pinLdrS;
this->drempel = drempel;

pinMode(this->pinBlok, OUTPUT);
pinMode(this->pinSein, OUTPUT);
pinMode(this->pinLdr, INPUT);
pinMode(this->pinLdrS, INPUT);

digitalWrite(this->pinBlok, HIGH);
digitalWrite(this->pinSein, HIGH);
}

//maak blok bezet
void AamBlok::bezet(){
this->bezetState = true;
}

//maak blok vrij
void AamBlok::vrij(){
this->bezetState = false;
}

//zet sein op rood of groen.
void AamBlok::sein(byte state){
digitalWrite(pinSein, state);
}

//Check of LDR een trein ziet en pas bezet aan. return bezet.
bool AamBlok::checkBezet(){
if(analogRead(this->pinLdr) < this->drempel){
this->bezetState = true;
}
else{
this->bezetState = false;
}

return this->bezetState;
}

//return is blok is bezet
bool AamBlok::isBezet(){
return this->bezetState;
}

void AamBlok::checkStop(){
if(analogRead(this->pinLdrS) < this->drempel && digitalRead(this->pinSein) == AAM_ROOD){
digitalWrite(this->pinBlok, LOW);
}
}

void AamBlok::update(){
this->checkBezet();
this->checkStop();
}

In de basis gebruik je dat dus als:

Code: [Selecteer]

#include <AamBlok.h>

//AamBlok(pinBlok, pinSein, pinLdr, pinLdrS, drempelwaarde)
AamBlok blok1 = AamBlok(0, 1, A0, A1, 300);
AamBlok blok2 = AamBlok(2, 3, A2, A3, 300);

void setup(){
   
}


void loop(){
    blok1.sein(AAM_ROOD);
}

Succes er weer mee!


Timo

[smits66]

Hoi, volgers

@Gerard

Bedankt voor je reactie, de seinsturing is op je juiste manier gebouwd, moet ook niet laat op de avond schema's gaan tekenen

@Timo

Bedankt voor je input.

De boel word gevoed met :

12V via treintrafo naar Motorshield (daarmee kan ik de snelheid van de treinen beter bijregelen.) als de verschillende locomotieven verschillende snelheden hebben (het is een analoge treinsturing), later word dat geregeld met een potmeter op de analogeport.

De voeding van de wissel spoelen komt ook van de treintrafo, later word er een vaste voeding voor de wissel spoelen gemaakt.

Een 5V voeding voor zowel de seinsturing en de Arduino Nano en de relais,  5Volt en 1.5 Ampere.

De gate weerstand verlaagt naar 820 Ohm, dat is ongeveer 2,5 Ampere, ik denk dat het wel voldoende is om de wissels te sturen, worden max 2 wissels per keer gestuurd.

De ledjes op de seinsturing die ik gebouwd heb werken wel, alleen verkeerd in het schema gezet.

De seinen worden met  1 van de twee schakelingen gestuurd, ik moet nog even testen wat makkelijker is, ik heb een kleine voorkeur voor iedere led een eigen i/o port, het testen zal dat uitwijzen.

De transistors zitten er expres tussen om wat meer led's te kunnen voeden Sein, bedienings-paneel en op de print zelf.

Wat moet de weerstandswaarde over de diodes ongeveer zijn en hoe groot moet de condensator over de weerstand R2 zijn, ik heb daar nog geen ervaring mee.

Er word voorlopig maar in 1 richting gereden (om het wat makkelijk te houden), de modelbaan word gebouwd volgens het hondebot principe.
Ik ben nog wel bezig om een sturing te ontwerpen voor een pendelbaan, dat is pas voor later.

Nee dat klopt, hoe het komt dat de code niet goed inspringt weet ik niet  , het Arduino programma maak er zelf een rommeltje van, na iedere programma regel geef ik een enter, zodat de regel naar mijn idee op de juiste manier inspringt.

Bedank voor het opzetje om een library te schrijven, en een korte beschrijving hoe ik het moet aanroepen,
ik ga er zo snel mogelijk mee aan de slag.

Mvg Paul

[Timo]

Hoi Paul,

Voeding
Omdat je voor de wissels en het rijden een losse trafo gebruikt mis ik eigenlijk in je ontwerpt de verbinding van de verschillende voedingen. Zou kunnen dat je deze bij de trafo uitvoert en gewoon een GND leiding maakt. Maar bedenk wel dat deze dan echt dik moet zijn. Alle stroom door de kabel veroorzaakt dan spanningsval voor alle lijnen. Zeker als je de Arduino uit 5V voedt heb je niet zo veel marge om spanning kwijt te raken.

Seinen
Kan gebeuren  Ik moest ook drie keer kijken wat GND was. Maar echt nodig zijn transistors niet. Hoeveel LEDjes komen er nu aan één Arduino? Max 4 seinen? Waarvan altijd max één LED aan staat. En je tekent zelf in je schema 680ohm dus dat maakt nog een 5mA per LED. Kom je uit op maar 20mA voor de LEDjes. Dit kan je dan ook wel uit de Arduino zelf voeden, scheelt weer schakelingen. En je kan gewoon 1 pin per sein gebruiken  (Ga ik in de library opzet ook vanuit.)

En als je toch transistor wilt gebruiken, waarom ben je dan niet gewoon voor dezelfde opzet gegaan als bij de wissels? Dus een NPN transistor naar GND? Dit is ook de manier waarop alle moderne decoders het doen en hoe seinen dus gemaakt zijn nu. Lijkt me dus een pluspunt. Ook kan je dan gewoon de voeding van de seinen wisselen als je kant en klaar seinen wilt gebruiken en dus 12V nodig hebt. Iets dat nu niet kan.

Detectie
Zeg dat je een minimale stroom van 2mA wilt hebben. Over iedere diode valt bij lage belasting misschien een halve volt. Dus spanningsval over de weerstand moet 1V zijn bij 2mA. 1V / 2mA = 500ohm. Maar aangezien de transistor al eerder met geleiden zal beginnen zal er wat minder stroom nodig zijn maar het is een richtlijn. Bij geen last is de basis van de transistor nu in ieder geval dichtgetrokken.

De condensator kan je ook wel berekenen maar is iets lastiger maar kunnen het een beetje afschatten. Spanningsval over de LED is typ. 1,3V. Een C over R2 laad zich op tot 12V. De spanning van R3 is dus 12 - 1,3 = 10,7V. Verwaarlozen dat de spanning over de LED verandert met de stroom en dat er nog een 100k zit kunnen we het benaderen met V = V_start * e^{-t * 1/(RC)} waarbij R = R₃ = 1k. Stel dat we zeggen dat er minimaal 1mA door de LED moet blijven lopen om bezet te melden en de PWM frequentie is 100Hz (maakt 10ms periode). Minimale voltage is dan 1mA x 1k = 1V. Bouw je de formule voor de spanning om naar C krijg je (en dit netjes weergeven is een forum niet zo goed in) C = -t / (ln( V/V_start ) * R). Invullen geeft - 10ms / (ln(1/12) * 1k) = 4uF.

De waarde is een richtwaarde, ik heb verschillende aannames gedaan, oa minimale stroom voor de LED en eigenlijk een duty cycle van 0% enzo. Dus ik verwacht dat de waarde aan de grote kant is. Maar dus iets in de orde grote van 1uF. 4uF kan ook en verwacht ik niet dat hij er merkbaar traag van wordt ofzo.

En voor het ompolen, mm, ik weet zo 123 daar geen mooie oplossing voor... Zou ik echt moeten gaan tekenen... Maar als altijd in één richting gereden wordt is het makkelijk.

Code
Voor het inspringen, Arduino doet het inderdaad zelf. Maar ik heb er ook wel eens ruzie mee als ik dingen aanpas. Vooral als je zelf een keer de backspace gebruikt. Arduino pas het alleen aan als je echt enter drukt of } gebruikt maar zal het niet later corrigeren als je het anders doet.

Wat betreft library, snap je nu het principe? Iets wat ik er nog niet ingebakken heb is zeg maar een blok nummer in het algemene systeem. Dus uniek op alle Arduino's). Dit zou op zich communicatie tussen alle blokken makkelijk maken. En om het makkelijk schaalbaar te houden zou je ook de blokken anders in de sketch kunnen zetten namelijk als array.

Code: [Selecteer]

#include <AamBlok.h>

//AamBlok(pinBlok, pinSein, pinLdr, pinLdrS, drempelwaarde)
AamBlok blokken[] = {AamBlok(0, 1, A0, A1, 300), AamBlok(2, 3, A2, A3, 300)};

#define NR_BLOKKEN sizeof(blokken)/sizeof(blokken[0])  //Geeft aantal blokken

void setup(){
   
}

void loop(){
    blokken[1].sein(AAM_ROOD); //Zet sein tweede blok op rood
   
    blokken[0].sein(!blokken[1].isBezet()); //Maakt sein van 1e blok rood als 2e blok bezet is.

    //alle blokken langs lopen
    for(byte i = 0; i < NR_BLOKKEN; i++){
        blokken[i].update();
    }
}
Zoals je ziet kan je dan makkelijk iets bij alle blokken doen zonder dat je deze dus zelf allemaal moet nalopen. Of je er nu 2 of 5 hebt  Library is nog erg basic maar denk dat het op zich goed uit te breiden is


Timo[/code]

[Fritsprt]

Om het programma overzichtelijker te maken kan je in de Arduino IDE in het tabblad Extra op Automatische opmaak klikken (Cntr+T)



gr. Frits