Arduino analoge(!) modelbaan sturing

[smits66]

Hoi volgers,

Zoals ik gisteren schreef heb ik vandaag de AamsTrein library getest, helaas werkte deze niet of niet goed , met name het pwm gedeelte van de library, dat was even balen.

De trein trekt langzaam op en na een tijdje moet de trein langzaam afremmen, dit word door het pwm sturing geregeld en juist dat gedeelte van de code werkte niet .

De simple code (komt uit de library) :

Code: [Selecteer]

  if(train == 0){
 
    int value;
   
    for(value = 0 ; value <= 250; value++){

    digitalWrite(this-> pinAin1, inPin1);
    digitalWrite(this-> pinAin2, inPin2);
   
  analogWrite(this->  pinPwmA, value);

}
 } Dit is een klein gedeelte van de library code.

Je zou denken dat het werk maar het werk toch niet.

Om er zeker van te zijn dat de code in de library goed was heb ik deze code rechtstreeks in de Arduino IDE gezet, en vervolgens getest en wat denk je, het werkte ook daar niet    ,  dat is even balen. 

Verroest wat doe ik verkeerd, na wat switchen met de Accolades en andere code werkte het nog steeds niet.

Ineens had ik een idee misschien liep het programma te snel voor een goede pwm regeling, ik heb er een kleine vertraging in gebouwd, en zie het werkte YESSSSSSS! , de pwm regeling werkte nu wel goed, het was nu alleen nog uitzoeken hoe klein de vertraging moest wezen.

Wat mij ook opviel met de pwm sturing is, dat de vertraging van het optrekken groter moet zijn, dan de vertraging van het afremmen. , het zal wel een Arduino enigenaardigheidje zijn  

Het werkende stukje code:

Code: [Selecteer]

  if(train == 0){
 
    int value;
   
    for(value = 0 ; value <= 250; value++){

    digitalWrite(this-> pinAin1, inPin1);
    digitalWrite(this-> pinAin2, inPin2);
   
  analogWrite(this->  pinPwmA, value);
  delay(60);
}
 }
Ik heb het op verschillend manieren geprobeerd om het voor elkaar te krijgen maar het werkt alleen met het comando delay(vertraging)

Het was mij niet bekent dat je een kleine vertraging moet inbouwen om de pwm regeling goed te laten regelen. 

De bovenstaande code komt uit de library en zal, zoals het nu als code staat ook niet werken, het was als voorbeeld bedoeld.

Ik moet alleen nog drie functies maken voor de hand/terminal bediening.

De AamsTrein.cpp library :

Code: [Selecteer]

/*
AamsTrein.cpp v1 - Library voor Arduino Analoge Modelbaan Sturing of kortweg AAMS.
Writen by Paul Smits


/*
Deze library is, voor het sturen van de verschillende treinen.
*/


#include "AamsTrein.h"


AamsTrein::AamsTrein(byte pinPwmA, byte pinAin1, byte pinAin2, byte pinPwmB, byte pinBin1, byte pinBin2){

this-> pinPwmA = pinPwmA; // Arduino pin 3~
this-> pinAin1 = pinAin1; // Arduino pin 2
this-> pinAin2 = pinAin2; // Arduino pin 4
this-> pinPwmB = pinPwmB; // Arduino pin 6~
this-> pinBin1 = pinBin1; // Arduino pin 5
this-> pinBin2 = pinBin2; // Arduino pin 7

pinMode(this-> pinPwmA, OUTPUT);
pinMode(this-> pinAin1, OUTPUT);
pinMode(this-> pinAin2, OUTPUT);
pinMode(this-> pinPwmB, OUTPUT);
pinMode(this-> pinBin1, OUTPUT);
pinMode(this-> pinBin2, OUTPUT);

}

void AamsTrein::start(byte train, byte direction)
{

  bool inPin1 = LOW;
  bool inPin2 = HIGH;

  if(train == 0)
   {
    digitalWrite(this-> pinAin1, inPin1);
    digitalWrite(this-> pinAin2, inPin2);
    analogWrite(this->  pinPwmA, 120);
    delay(25);
   }

  else if(train == 1)
   {
    digitalWrite(this-> pinBin1, inPin1);
    digitalWrite(this-> pinBin2, inPin2);
    analogWrite(this->  pinPwmB, 120);
    delay(25);
   }

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

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

void AamsTrein::stop(byte train)
{

  if(train == 0)
   {
     analogWrite(this-> pinPwmA, 0);
   }

  else if(train == 1)
   {
     analogWrite(this-> pinPwmB, 0);
   }
}
void AamsTrein::vertrek(byte train, byte direction)
{
  bool inPin1 = LOW;
  bool inPin2 = HIGH;

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

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

  if(train == 0){
 
    int value;
   
    for(value = 0 ; value <= 250; value++){

    digitalWrite(this-> pinAin1, inPin1);
    digitalWrite(this-> pinAin2, inPin2);
   
  analogWrite(this->  pinPwmA, value);
  delay(60);
}
 }

  else if(train == 1){
 
   int value;
   
   for(value = 0 ; value <= 250; value++){

    digitalWrite(this-> pinBin1, inPin1);
    digitalWrite(this-> pinBin2, inPin2);

  analogWrite(this->  pinPwmB, value);
  delay(60);
 
}
 }
}

void AamsTrein::remmen(byte train, byte direction){

  bool inPin1 = LOW;
  bool inPin2 = HIGH;
  int value;

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

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

  if(train == 0){
   
     for(value = 250 ; value >= 0; value--){

   digitalWrite(this-> pinAin1, inPin1);
   digitalWrite(this-> pinAin2, inPin2);
     
  analogWrite(this->  pinPwmA, value);
  delay(25);
 
}
 }

  else if(train == 1){
 
  for(value = 250 ; value >= 0; value--){

    digitalWrite(this-> pinBin1, inPin1);
    digitalWrite(this-> pinBin2, inPin2);

  analogWrite(this->  pinPwmB, value);
  delay(25);
 
}
 }
}

void AamsTrein::snelheid(byte speed)
   {
//Er word nog aan functie snelheid gewerkt! (deze functie is bedoeld voor Handbediening)
   }

void AamsTrein::richting(byte direction)
   {
// Er word nog aan functie richting gewerkt! (deze functie is bedoeld voor Handbediening)
   }

void AamsTrein::on(byte train)
   {
// Er word nog aan functie on gewerkt! (deze functie is bedoeld voor Handbediening)
   }
void AamsTrein::noodstop(int speed)
   {
// Er word nog aan functie noodstop gewerkt!
if (speed == 0){

   analogWrite(this->  pinPwmA, 0);
   analogWrite(this->  pinPwmB, 0);
   }
}

Hardware

De Aams sturing is ondertussen uitgebreid met een I²C interface en I²C LCD display.
Beide Arduino Nano's zijn met elkaar verbonden via I²C en kunnen met elkaar communiceren.

Er gaat nog een derde en een vierde Arduino Nano bij komen om wissels om te zetten en om twee keerlussen te kunnen sturen.

Ook nog in de planing een I²C tijd/datum module met weergave op het LCD Display.

De ruimte in de stuurkast word nu wel erg krap , dat word een grotere behuizing bouwen.



Mvg Paul

[spock]

Hoi Paul,

Ik ben sinds een paar maanden ook bezig met Arduino en zie toch aardig wat overeenkomsten met jou vorderingen.

Ik heb niet het hele draadje gelezen, maar als jij meerdere treinen wilt laten lopen dan ben ik bang dat je toch tegen een limiet aan gaat lopen.

Het gebruik van de functie delay is ten zeerste af te raden. In het voorbeeld (voor het op tellen) werd een delay van 60ms gebruikt in een loop van 250. Dit is 15 seconden. Ik weet dat het een voorbeeld is, maar al breng je het terug naar 1 seconde (per blok), dan is het nog lang.

Ik heb een modelauto 4-wegkruising besturingsprogramma geschreven (20 input sensoren en 4 servo's als output) en daar is nergens een delay gebruikt.

De structuur van het programma wordt daardoor wel anders (en ingewikkelder/interressanter).
Het progamma wordt dan een loop van:  lees sensoren, bereken de aktie, voer aktie uit. Het idee is dat je de vertragingen gaat doen mbv tijdmeting mbv de functie millis().
Je zet PMW signaal, onthoud de tijd en gaat verder. Bij de volgende keer dat je langs komt kijk je of de tijdverstreken is en zet dan de PMW naar de volgende waarde, enz.

Voorbeeld met millis():

http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

Hierdoor kun je later makkelijk nog een paar blokken er bij zetten, de Arduino is er krachtig genoeg voor om dit af te handelen.

MVG spock

[smits66]

Hoi volgers,

@ spock

Bedankt voor je input.

Het gebruik van de functie delay is ten zeerste af te raden. In het voorbeeld (voor het op tellen) werd een delay van 60ms gebruikt in een loop van 250. Dit is 15 seconden. Ik weet dat het een voorbeeld is, maar al breng je het terug naar 1 seconde (per blok), dan is het nog lang.

Ik weet even niet wat het een en het ander met elkaar te maken hebt, de teller lus word gebruikt om de locomotief langzaam te laten optrekken of langzaam te latten stoppen, de vertraging zorgt er voor dat de teller lus ook als teller lus werkt.

Met het millis lukt dat niet (kan komen omdat mijn kennis van de Arduino nog niet zo groot is, en de voorbeelden die gegeven zijn, werken op de een of andere manier niet.)

Als ik het delay() comando niet gebruik rijd de locomotief meteen op volle snelheid, er moet dus een kleine vertraging ingebouwd worden om dat te voorkomen de waarde 60 heb ik gebruikt om de pwm regeling te kunnen testen met LED's , deze waarde moet ik nog bepalen om een gemiddelde optrek/af-rem vertraging in te stellen, het zal ongeveer op de 30-40 ms uitkomen.

Voor zo ver mijn kennis reikt word alleen de teller lus aangeroepen als dat nodig is.

Daarbij komt nog dat een vertraging op mijn te bouwen baan niet veel uitmaakt, omdat er niet meer treinen kunnen rijden als er blokken zijn (klop al niet helemaal).
Heb ik 10 blokken kan ik er maar 5 treinen op laten rijden,  in mijn planning gaan er max 5 tegelijk rijden en ik denk dat ik dat al niet eens haal, een vertraging in het Arduino programma zal niet veel invloed op het trein verloop hebben.

Voornamelijk word de Arduino gebruikt met terminal bediening om het trein verloop te regelen.

Misschien dat er op een gedeelte van de baan automatische gereden word, ik denk dat vertragingen in het Arduino programma niet veel invloed heeft op het rijden van de verschillende treinen.

Wat ook meespeelt is dat deze baan 100% analoog blijft, maar wel met computer bediening.

Als ik het verkeerd denk hoor ik dat graag.

Voor de duidelijkheid,  deze Arduino Analoge Modelbaan Sturing is voor mijn baan thuis gemaakt en niet voor  commercieele  toepassingen, mochten er mensen zijn die deze code willen gebruiken is dat geen probleem, wees welkom. 

Op mijn, te bouwen baan komen waarschijnlijk 2 keerlussen, de aansturing van de keerlussen wil ik gaan doen met de Arduino, mijn volgende library word dan ook een keerlus library,  deze sturing wil ik ook weer opnemen in mijn AAMS programma, voor de sturing ga ik gebruik maken van een Arduino Nano die weer via i²C word gestuurd.

Dit word weer een flinke uitdaging om het voor elkaar te krijgen , ach ja het is tenslotte een hobby 

Voor het baanplan zie mijn draadje "Laubenstein" link beneden

Mvg Paul

[Robert E]

Ipv delay kun je misschien  beter een soft timer module gebruiken zoals bijvoorbeeld deze

http://www.freetronics.com.au/blogs/news/6864767-arduino-softtimer-the-new-timer-manager-arduino-library#.VVXpiJO2pUE

Enige nadeel is dat men de loop ook in die module heeft gedaan, dat is eruit halen en de timer aanroep die daar staat in je eigen loop zetten. Geloof dat er ook geen stop in zat en nog eentje die er niet in zat en makkelijk is.... Kwestie van toevoegen...

Mvg,

Robert

[spock]

Hoi Paul,

De opmerking over het gebruik van delay was als een algemene opmerking bedoeld vwb een wat groter Arduino programmering project, niet alleen specifiek dit geval.

Wat ik probeerde aan te geven is dat als je die millis() methode toepast je meerdere akties tegelijk kunt uitvoeren.

In jou geval:

Stel: je wilt 3 treinen van je bord laten starten. Dan druk je op de eerste lok (dan moet je wachten totdat deze op de gewenste snelheid is) en kun je daarna pas de tweede lok starten. In de voorgestelde methode kunnen meerdere loks tegelijkertijd gestart worden. Het is echter een moeilijkere implentatie, dat geef ik toe.

Die millis() methode werkt wel (ervaringsdeskundige), maar als je dit pricipe toepast dan veranderd het hele principe (en code) van je programma.
In de huidige methode wordt 1 taak eerst compleet afgehandeld voordat taak 2 wordt afgehandeld. In de voorgestelde methode wordt er afwisselend aan delen van taak 1 en 2  gewerkt.

Zoals ik al aangaf had ik niet het hele draadje gelezen  . Ik had namelijk het idee dat er misschien  blokmeldingen gemist of te laat gezien zouden worden (lekker Nederlands).

Met vriendelijke groet, spock

[Timo]

Als ik het verkeerd denk hoor ik dat graag.

Bij deze dan  De delay zorgt er (onnodig) voor dat je hele Arduino hangt. In die tijd (die het eigenlijk uit zijn neus staat te vreten) reageert hij nergens meer op. Ook niet meer op bijvoorbeeld een noodstop! Als ik jou was zou ik toch echt de BlonkWithoutDelay eens een keer aan de gang krijgen. Dit is in mijn ogen echt wel een basis begrip dat je onder de knie moet hebben wil je meer gaan doen met de Arduino.

En inderdaad, een Arduino (of elke microcontroller) is heel snel. Tot 250 tellen kost hem (voor ons idee) dus geen tijd. Vertraging is inderdaad nodig maar met delay is niet de "juiste" manier.

Library is verder leuk opgezet. Alleen... Splits die boel nu eens  Je denk steeds in te grote blokken. Het feit dat er 2 motordrivers op één print zitten betekend niet dat je deze in één library moet onderbrengen. Beide motordrivers zijn los van elkaar aan te sturen. Als je nu ook in code kijkt zie je dat je heel veel dingen er nu dubbel in hebt staan, een keer per driver kant. Het mooie van een library zou in dit geval juist zijn dat je hier geen last van hebt!


Timo

[woutermelis]

Wauw! Wat een project. Probeer het al een tijdje met bewondering te volgen en te snappen. Gaat mijn pet nog te boven. Leuk dat we drie weken geleden een project voor V5 leerlingen met arduino's zijn gestart. Ik ben met 2 maten bezig om een stoplicht situatie na te maken, dat valt toch wat in het niets bij dit project! Puik werk!

[Timo]

Verkijk je daar niet op Wouter, een verkeerslicht kan heeeeeeeeel ingewikkeld gemaakt worden 


Timo

[Timo]

@Paul, Ik hoop niet dat je het erg vindt maar ik heb je library weer een beetje herschreven  Aangezien de cavia van mijn vriendin mijn USB verlengkabeltje door heeft geknaagd heb ik het nog niet kunnen testen Ga ik nu maar even solderen. Compilen doet het iig gewoon (Arduino IDE 1.6.3)

Maar in de basis geeft het een idee wat ik bedoel. Ik heb zo veel mogelijk de functies gebruikt die jij ook had. Een paar waarvan ik niet snapte wat je er mee wilde of overbodig waren zijn vervallen. Paar andere zijn erbij gekomen. Ik heb de delay vervangen door de millis() optie. Ipv direction gebruikt het een speed die positief is voor vooruit en negatief voor achteruit. Dit maakt de code net iets makkelijker.

AamsTrein.h

Code: [Selecteer]

/*
AamsTrein.cpp v2 - Library voor Arduino Analoge Modelbaan Sturing of kortweg AAMS.
Writen by Paul Smits
Edit by Timo Engelgeer ;)
*/

/*
Deze library stuurt de motordriver L298 voor de Arduino Analoge Modelbaan sturing.
*/

#ifndef AamsTrein_h
#define AamsTrein_h

#include "Arduino.h"

class AamsTrein {
public:
AamsTrein(byte pinPwm, byte pinIn1, byte pinIn2);

void snelheid(int speed);
int getSnelheid();
void update();
void setVertraging(unsigned int vertraging);
unsigned int getVertraging();
void noodstop();
void start(byte direction);
void stop();

protected:

void setSnelheid(int speed);

int setSpeed; //Snelheid die we willen gaan rijden
int curSpeed; //Snelheid waarop de PWM werkelijk is ingesteld.
unsigned int vertraging;
unsigned long millisLast;

byte pinPwm;
byte pinIn1;
byte pinIn2;


};

#endif

AamsTrein.cpp

Code: [Selecteer]

/*
AamsTrein.cpp v2 - Library voor Arduino Analoge Modelbaan Sturing of kortweg AAMS.
Writen by Paul Smits
Edit by Timo Engelgeer ;)


/*
Deze library is, voor het sturen van de verschillende treinen.
*/


#include "AamsTrein.h"


AamsTrein::AamsTrein(byte pinPwm, byte pinIn1, byte pinIn2){
//Save the pins to use
this->pinPwm = pinPwm;
this->pinIn1 = pinIn1;
this->pinIn2 = pinIn2;

//Make them output
pinMode(this->pinPwm, OUTPUT);
pinMode(this->pinIn1, OUTPUT);
pinMode(this->pinIn2, OUTPUT);

vertraging = 0; //Standaard geen vertraging

}

void AamsTrein::snelheid(int speed){
//Snelheid begrenzen tot max 255 in beide richtingen
if(speed > 255){
speed = 255;
}
else if(speed < -255){
speed = -255;
}

setSpeed = speed;

if(vertraging == 0){
this->setSnelheid(setSpeed);
}
}

//Geeft de ingestelde snelheid
int AamsTrein::getSnelheid(){
return this->setSpeed;
}


//Protected functie, niet van buiten de classe te benaderen.
//Stelt werkelijk de hardware in op de juiste snelheid
void AamsTrein::setSnelheid(int speed){
if(curSpeed != speed){
curSpeed = speed;

if(speed < 0){
digitalWrite(this->pinIn1, HIGH);
digitalWrite(this->pinIn2, LOW);
analogWrite(this-> pinPwm, -speed);
}
else{
digitalWrite(this->pinIn1, LOW);
digitalWrite(this->pinIn2, HIGH);
analogWrite(this-> pinPwm, speed);
}
}
}

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

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

//Stelt de vertraging tussen het aanpassen van de snelheid in (in ms)
void AamsTrein::setVertraging(unsigned int vertraging){
this->vertraging = vertraging;
}


//Geeft de ingestelde vertraging
unsigned int AamsTrein::getVertraging(){
return this->vertraging;
}

//Triggert de noodstop
void AamsTrein::noodstop(){
//Door beide in-pinnen laag te maken en de PWM pin hoog is er een "Fast Motor Stop"
digitalWrite(this->pinIn1, LOW);
digitalWrite(this->pinIn2, LOW);
digitalWrite(this->pinPwm, HIGH);

//En even de snelheden updaten
setSpeed = 0;
curSpeed = 0;
}

// Volgende functies erin gehouden omdat deze er waren

//Gewoon starten met snelheid 120 met mogelijkheid om richting op te geven
//Houdt rekening met de ingestelde vertraging
void AamsTrein::start(byte direction){
if(direction){
this->snelheid(120);
}
else{
this->snelheid(-120);
}
}

//Stop de treinen
//Houdt rekening met ingestelde vertraging
void AamsTrein::stop(){
this->snelheid(0);
}

Voorbeeld hoe je deze code gebruikt met beide motordrivers waarbij de eerste driver achteruit naar snelheid 200 optrekt:

Code: [Selecteer]

#include <AamsTrein.h>

#define AANTAL_BLOKKEN 2

AamsTrein treinen[AANTAL_BLOKKEN] = {
  {3, 2, 4},    //Eerste motordriver
  {6, 5, 7}     //Tweede motordriver
};

void setup() {
  //Geef de eerste driver een 60ms vertraging tussen iedere snelheidsstap
  treinen[0].setVertraging(60);

  //Geeft tweede motordriver dezelfde vertraging als de eerste
  treinen[1].setVertraging( treinen[0].getVertraging() );

}

void loop() {
  //Dit blok moet altijd in je loop staan (=vaak aangeroepen worden)
  //om te zorgen dat de blokken de juiste snelheid hebben
  //Gebruik GEEN delay in de loop, dit zal de optrek/afrem vertraging in de war schoppen
  for (byte i = 0; i < AANTAL_BLOKKEN; i++) {
    treinen[i].update();
  }
 
  //trek op naar "-200" (achteruit dus)
  treinen[0].snelheid(-200);
 
}

Ik hoop dat dit een beetje een beeld geeft wat ik eerder al bedoelde en iets geeft waarmee je verder kan Denk het wel want heb zo veel mogelijk de functies die jij voor ogen had aangehouden



Timo

[smits66]

Hoi volgers,

@Timo

Bedankt voor je input en library.

De functies die nog niet geprogrammeerd zijn, waren speciaal bedoeld voor de Terminal bediening van de Arduino.

Ik heb echter nog een vraagje je definieert het volgende 

#define AANTAL_BLOKKEN 2

is dit een functie binnen de Arduino ide of kan ik het als volgt definiëren

#define AANTAL_TREINEN 2

ik hou graag dezelfde definitie van de library aan.

De library werk ook in de praktijk, dat heb ik net even getest.

Laat de Cavia van je vriendin zelf het usb kabeltje repareren

Deze libray geeft mij voldoende informatie om verder te gaan met het maken van verschillende library's voor mijn AAMS sturing.


@ Robert, Wouter, spock

Bedankt voor jullie reactie.

mvg Paul

[Timo]

Hoi Paul,

Wat ik al zei, doel van de functies was me niet helemaal duidelijk. Vandaar dat ik ze niet had overgenomen. Misschien dat je ze verder toe kunt lichten wat het idee er achter was? Want volgens mij heb je buiten deze functies geen extra functies nodig om de boel aan te sturen via terminal. Afgezien van de optrek/afremvertraging zit er 0 automatie in. Dus mijn vraag, wat was je doel specifiek met die functies in vergelijking met wat je af had/ik gemaakt had?

Een define is precies wat het zegt, het definieert iets. De compiler doet eigenlijk een zoeken en vervangen actie voor elke define voor hij met het echte compilen begint. Je gebruikt een define zo (of zie Arduino):
#define HIER_EEN_NAAM [wat het echt moet zijn]
Het "HIER_EEN_NAAM" mag alles zijn wat jij wilt. Wordt normaal in hoofdletters gedaan om aan te geven dat het een define is.
Vervolgens wordt overal waar je in je sketch "HIER_EEN_NAAM" gebruikt vervangen door "[wat het echt moet zijn]".
In het voorbeeld had ik het even snel "AANTAL_BLOKKEN" genoemd maar je hebt gelijk dat "AANTAL_TREINEN" of "AANTAL_DRIVERS" beter is. Gaat er vooral om dat het aangeeft hoeveel verschillende instaties van AamsTrein je hebt (en dat overal gebruikt waar ik "AANTAL_BLOKKEN" schreef of war je wilt weten hoeveel blokken je hebt).

Maar het hele was vooral te laten zien dat ipv een library die beide motordrivers aan stuurt je makkelijker twee instanties (in een array, treinen[0] en treinen[1]) kunt maken die ieder één driver doen. Zie het als twee instanties van een bestuurder maken die beide een auto besturen ipv een complexere instantie die twee auto's tegelijk kan besturen 


Timo

[smits66]

Hoi Timo

Deze functie's heb ik nodig om in het Gambas programma strings naar de seriele poort stuur bv. trein 1, snelheid 100, richting rechtsom of iets dergelijks, door de Arduino te laten sturen.

Deze functie heb ik ook nodig om bv wissels dan wel wisselstraten aan te sturen bv. wissel1, rechtdoor,   wissel 2, rechtdoor,  wissel 3, afbuigend enz.

Als ik dat met de ascii code's moet doen ben ik snel door mijn ascii codes heen.

Mvg Paul

[Timo]

Dat kan toch prima met deze library? De vertaalslag van ascii strings naar de actie lijkt me niet iets voor de AamsTrein library maar voor de sketch er om heen. Die kan dan ook bepalen of "trein 1" werkelijk op deze Arduino zit of dat het door een andere afgehandeld moet worden. De library neemt precies de taak op zich van de naam, die stuurt de trein aan. Je moet niet alles in een (of één) library willen stoppen. Het is juist makkelijk voor "iets waar je er meer van hebt" (in dit geval motordrivers/treinen) aan te sturen zonder enorme bergen code dubbel te schrijven.

Als ik dat met de ascii code's moet doen ben ik snel door mijn ascii codes heen.

Nee hoor. Het hoeft geen uniek ascii karakter te zijn voor elke optie. Je zou iedere trein kunnen aansturen door een bericht als:
0x54 0x01 0x80 0x64
Voor bijvoorbeeld trein 1 snelheid -100 (achteruit).

0x54 is in ascii een T, hiermee geef je aan dat het om een trein gaat.
0x01 is in decimaal gewoon 1
0x80 is in bitjes 1000000, om aan te geven dat het om een negatief getal gaat)
0x64 is in decimaal 100

0x80 0x64 geeft -100 als je dat in een (Arduino) int schuift.

Code: [Selecteer]

  int speed;
  speed = 0x80;  //Plaats linker deel erin
  speed <<= 8;   //Schuif erin (naar links)
  speed &= 0x54; //Voer rest toe

Voor wissels kan je iets gelijks doen. Stuur bijvoorbeeld
0x57 0x0A ("W" "10" => wissel 10 recht)
of:
0x77 0x0A ("w" "10" => wissel 10 afbuigen)

Dit zijn heel wat minder bytes

Overigens wil dat niet zeggen dat jou idee van string based berichten niet werken. In tegendeel. Alleen het verwerken van een string is best lastig voor een Arduino. Als je de string "trein 1, snelheid 100, richting rechtsom" dan stuur je 20 bytes over. Ook moet de Arduino ALLE 20 bytes testen tegen de stings in de Arduino. En dat is alleen als je maar één test doet in de Arduino (if(stringIn == "trein 1, snelheid 100, richting rechtsom"){).

Ik zeg dus niet dat het een must is maar het is minder data versturen (= sneller) en een heeeeeel stuk makkelijker voor de Arduino om te lezen (en kan het snel door met waar het nog meer mee bezig was). En het is zelfs eigenlijk makkelijker programmeren. (Sorry, kon het niet laten een voorbeeldje te schrijven. Zeg maar als je het vervelend vindt.)

Code: [Selecteer]

//Zijn maar random voorbeeld getallen/adressen
#define AANTAL_TREINEN 2
#define AANTAL_WISSELS 4
const byte TreinAdres 0;
const byte WisselAdres 8;

void loop() {
  if(bytesIn[0] == "T"){ //begint het met een T?
    if(bytesIn[1] >= TreinAdres && bytesIn[1] < (TreinAdres + AANTAL_TREINEN){
      //Dit adres zit op deze Arduino   
     
      //Selecteer juiste trein
      //Maak van de twee bytes een int
      //Zet snelheid
      treinen[bytesIn[1] - TreinAdres].snelheid( byteToInt(bytesIn[2], bytesIn[3]) );
    }
  }
  else if(bytesIn[0] == "w" || bytesIn[0] == "W"){ //begint het met een w of W?
    if(bytesIn[1] >= WisselAdres && bytesIn[1] < (WisselAdres + AANTAL_WISSELS){
      if(bytesIn[0] == "W"){
        wissels[bytesIn[1] - WisselAdres].rechtdoor();
      }
      else{
        wissels[bytesIn[1] - WisselAdres].afbuigen();
      }
    }
  }
}

int byteToInt(byte msb, byte lsb){
  int out;
  out = 0x80;  //Plaats linker deel erin
  out <<= 8;   //Schuif erin (naar links)
  out &= 0x54; //Voer rest toe
 
  return out;
}
Geen 100% code, maar bytesIn is wat de module op serial of I2C of weet ik wat binnen heeft gekregen.



Timo

[smits66]

Hoi Volgers,

@Timo

Bedankt voor je Input.

(Sorry, kon het niet laten een voorbeeldje te schrijven. Zeg maar als je het vervelend vindt.)

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

@Allen

De wisselsturing.

De wissels ga ik sturen door middel van relais , dat heeft als voordeel dat ik een complete galvanische scheiding hebt met de Arduino en de voeding van de  wissels.

De terugmelding naar mijn bediening-paneel is voor mij  belangrijk, omdat mijn baan vrij groot is ongeveer 280 cm x 220 cm x 240 cm  met een breedte van  60 cm en is in een U-vorm gebouwd waardoor het bijna onmogelijk word om de wissels in de gaten te houden, Ik kan er ook wel de poorten van de Arduino voor gebruiken, maar dat vind ik eigenlijk een beetje zonde.

De gebouwde wisselsturing.


Beschrijving wisselsturing:

Via de connector links zet ik de 5V en de Gnd (twee linker pinnen) op de print, de twee rechter pinnen zijn voor de sturing via de Arduino of rechtstreeks via een drukknopje en of reed-contact.

De wissels die ik gebruik (minitrix)  hebben geen terugmelding en geen eind afschakeling, ik kan dus maar een korte puls op de pinnen zetten ongeveer 200 ms tot 250 ms om de relais te bekrachtigen echter heb ik dan geen feedback terug van de wisselstand, nu kan ik dat ook wel sturen via de Arduino poorten, zoals ik dat al eerder opmerkte vind ik dat zonde.

Om dat op te lossen maak ik gebruik van een bi-polair relais (de witte relais) deze relais hebben maar een korte puls nodig om te schakelen en blijven dan in die stand staan totdat er op de andere spoel weer een korte puls binnenkomt, daardoor zal de stand van het relais veranderen, van deze eigenschap maak ik gebruik om de terugmelding naar het bedienings-paneel voor de wisselstand, zichtbaar te maken.

Via de Arduino kan dat ook wel, alleen weet je de wisselstand niet als de Arduino is uitgezet of gereset is,  je moet dan eerst alle wissels een voor een omzetten om de juiste wisselstand te hebben, bij een bi-polair relais staat de stand altijd vast tenzij je de wissel hebt omgezet via de schakel relais (de twee zwarte relais).

Deze wisselsturing is ook geschikt om het met drukknopjes en/of sensoren te bedienen zonder tussenkomst van de Arduino, wat het een flexibele wisselsturing maakt.

De werking van de wisselsturing.

De stuursignaal komt via een van de twee rechter pinnen binnen, dit stuursignaal gaat via een weerstand naar de transistor en stuurt twee transistoren open de ene transistor (achter de zwarte relais) stuurt het schakelrelais aan en de andere transistor (vooraan op de print) stuurt het bi-polair relais(witte relais) aan, dit relais blijft dan in deze stand staan terwijl de stuurrelais (zwarte relais)  afvalt.
Via de schakelcontacten van het bi-polair(witte relais) kan ik nu de stand van de wissel zien op mijn bedienings-paneel.     

Het stuursignaal kan via de Arduino gegeven worden of via een drukknop of via een reed-contact, echter niet tegelijk, dat is met diodes wel op te lossen, maar dat vind ik op dit moment nog niet belangrijk.

De schakeling is getest en werk bijzonder goed, het is altijd weer de vraag of je schakeling wel of niet werkt

Mvg Paul

[lok1614]

Leuk Project.

Zelf ben ik bezig met een soort gelijksysteem voor mijn fallercarsysteem.
Middels attiny85 modules die via een RS485 bus met elkaar kunnen praaten, als programeertaal gebruik ik ook arduino.
Ik gebruik een soortgelijk idee als wat Timo beschrijft, een aantal ascii codes achterelkaar zoals #1MWL wat zoiets inhoud als #, let op er komt een bericht, 1 het is voor node 1, M het komt van de master, W een wisselcommando en L hij moet naar links.
Toen ik bezig was met een stoplicht module kwam ik er ook achter dat een delay niet de oplossing was, tijdens de wacht cyclus kon hij geen berichten meer ontvangen, dit opgelost met een timerinterrupt.
En geloof me Paul ik ben ook geen programmeur, maar youtube kan zo erg je vriend zijn in dit soort gevallen  .

Het meest trots ben ik op de module die een soort barcode uitleest onder de auto en zo straks vaste busroutes kan maken https://youtu.be/e8LsRgYtqVc voor een filmpje

Blijf draadje vol interessen volgen igg...

Gr Peter