train control project

Als U een gezamenlijk project wil starten of aan projecten van anderen mee wilt werken.
Gebruikers-avatar
Berichten: 31
Geregistreerd: 08 Sep 2016, 21:50

Re: train control project

Berichtdoor Kitemasters » 29 Sep 2016, 01:33

geprobeerd een switch te bouwen,

vreemd, waar het treintje eerst 60cm nodig had om te stoppen, deed hij dat na de verandering in nog geen 10 cm.
nu ik motor_Dec_Interval op 120 heb staan (was 100) is het ongeveer 30 cm.
bij een motor_Dec_Interval op 150 reed hij zowat de baan af (80cm).
valt op dat bij het spelen met de interval vooral het "lage" bereik langer gaat duren.


cpp code
/*
Train control
Drive the train between two gates made of a LED and LDR.
*/
// --------CONSTANTS (won't change)---------------

int sens_L_Pin = A4; // the pin number for ldr L
int sens_R_Pin = A5; // the pin number for ldr R
int led_L_Pin = 4; // the pin number for the L LED
int led_R_Pin = 5; // the pin number for the R LED
int motor_Pin = 3; // the pin number for the motor speed
int brake_Pin = 9; // the pin number for the motor brake
int direction_Pin = 12; // the pin number for the motor direction
int current_sens_Pin = A0; // the pin number for the current sensor

int read_sens_Interval = 200; // millisecs between reading sensors
int motor_Acc_Interval = 100; // millisecs between acceleration steps
int motor_Dec_Interval = 120; // millisecs between deceleration steps

//------------ VARIABLES (will change)---------------------

unsigned long currentMillis = 0; // stores the value of millis() in each iteration of loop()
unsigned long previous_sens_Millis = 0; // will store the last time sensors are read
unsigned long previous_state_Millis = 0; // will store the last time state is printed
unsigned long previous_Acc_Millis = 0; // will store time of last acceleration step
unsigned long previous_Dec_Millis = 0; // will store time of last deceleration step

int sensLreading = 0; //variable voor de waarde van sensL
int sensRreading = 0; //variable voor de waarde van sensR
int max_Speed = 200; //declare variable and set value for maximum Speed (0 to 255)
int Speed = 0; //declare variable and set value for current Speed (0 to 255)
boolean direct = true; //declare variable and set value for driving direction

#define STATE_IDLE 0
#define STATE_START 1
#define STATE_RUN 2
#define STATE_DECELERATE 3
#define STATE_TURN 4
#define STATE_ACCELERATE 5

int state = STATE_IDLE;

//========================================

void setup() {

Serial.begin(9600);

pinMode(led_L_Pin, OUTPUT); // set led_L_Pin as output
pinMode(led_R_Pin, OUTPUT); // set led_R_Pin as output
pinMode(motor_Pin, OUTPUT); // set motor_Pin as output
pinMode(brake_Pin, OUTPUT); // set brake_Pin as output
pinMode(direction_Pin, OUTPUT); // set direction_Pin as output
pinMode(sens_L_Pin, INPUT); // set sens_L_Pin as input
pinMode(sens_R_Pin, INPUT); // set sens_R_Pin as input
pinMode(current_sens_Pin, INPUT); // set current_sens_Pin as input

}
//========================================

void loop() {

currentMillis = millis(); // capture the latest value of millis()
read_sens(); // read the sensors

switch (state)
{
case STATE_IDLE:
state = STATE_START;
break;

case STATE_START:
Start();
break;

case STATE_ACCELERATE:
Accelerate();
break;

case STATE_DECELERATE:
Decelerate();
break;

case STATE_RUN:
break;
}
}
//========================================

void read_sens() {

if (currentMillis - previous_sens_Millis >= read_sens_Interval) { // time is up, so read sensors
sensLreading = analogRead(sens_L_Pin); // read left ldr (high value means the light is off or blockt)
//Serial.print("Left = "); // print for debug
//Serial.println(sensLreading); // print for debug
sensRreading = analogRead(sens_R_Pin); // read right ldr (high value means the light is off or blockt)
//Serial.print("Right = "); // print for debug
//Serial.println(sensRreading); // print for debug
previous_sens_Millis += read_sens_Interval; // and save the time we last read sensors

if (sensLreading > 200 && direct == true) { //if conditions are throu, the train reached left gate***
digitalWrite(led_L_Pin, LOW); //Turn left LED off
digitalWrite(led_R_Pin, HIGH); //Turn right LED on
state = STATE_DECELERATE; // set state to "decelerate"
}

if (sensRreading > 200 && direct == false) { //if conditions are throu, the train reached right gate***
digitalWrite(led_R_Pin, LOW); //Turn right LED off
digitalWrite(led_L_Pin, HIGH); //Turn left LED on
state = STATE_DECELERATE; // set state to "decelerate"
}
}
}
//========================================

void Start() {

digitalWrite(led_L_Pin, HIGH); // turn left led on
digitalWrite(brake_Pin, LOW); // Disengage the Brake
digitalWrite(direction_Pin, LOW); // Establishes left direction of train
state = STATE_ACCELERATE; // set state to "accelerate"
direct = true; // set direction to true (true = LOW = left)
}
//========================================

void Accelerate() {

if (currentMillis - previous_Acc_Millis >= motor_Acc_Interval) { // time is up, so accelerate
Speed = Speed + 1; // add 1 to speed
analogWrite(motor_Pin, Speed); // send Speed to motor_Pin
Serial.print("Speed = "); // print for debug
Serial.println(Speed); // print for debug
previous_Acc_Millis += motor_Acc_Interval; // last time of acceleration step
if (Speed == max_Speed) { // if speed reach max speed
state = STATE_RUN; // set state to "run"
}
}
}
//========================================

void Decelerate() {

if (currentMillis - previous_Dec_Millis >= motor_Dec_Interval) { // time is up, so decelerate
Speed = Speed - 1; // subtract 1 of speed
analogWrite(motor_Pin, Speed); // send Speed to motor_Pin
//Serial.print("Speed = "); // print for debug
//Serial.println(Speed); // print for debug
previous_Dec_Millis += motor_Dec_Interval; // last time of deceleration step
if (Speed == 0) {
if (direct == true) { // flip direction
direct = false;
digitalWrite(direction_Pin, HIGH); // Establishes right direction of train
}
else {
direct = true;
digitalWrite(direction_Pin, LOW); // Establishes left direction of train
}
state = STATE_ACCELERATE; // set state to "accelerate"
}
}
}
//========================================END

Advertisement

Gebruikers-avatar
Berichten: 2655
Geregistreerd: 06 Aug 2016, 01:03

Re: train control project

Berichtdoor Koepel » 29 Sep 2016, 16:50

De 'state' als integer ziet er veel beter uit :D

Bij welk interval van het versnellen van de trein (met gebruik van analogWrite) gaat het nog soepel ? Ook als er veel meer versnelling is dan met één ophogen.
Dat is de interval die je kiest.
Ik denk dat 10 keer per seconde een aardig getal is. Dus dan is je interval 100ms. Dat is zomaar gegokt hoor, misschien is het in het echt heel anders.

Als dat vast ligt, dan is de volgende vraag : hoe snel vertragen of versnellen ?
Dat doe je door de Speed aan te passen. Die verhoog je en verlaag je nu nog maar met één, maar daar regel je hoe lang het gaat duren. Dus verhogen en verlagen met een groter getal.

Gebruikers-avatar
Berichten: 31
Geregistreerd: 08 Sep 2016, 21:50

Re: train control project

Berichtdoor Kitemasters » 29 Sep 2016, 17:30

misschien simpel gedacht van mij maar

speed is de snelheid van de trein en omdat de stappen altijd 1 zijn zal hij dus 200 stappen moeten maken om op
maxspeed 200 te komen. als de interval op 100ms staat zou hij er 20 sec over doen om op snelheid te komen. :oops:

eh mijn berekening klopt ook niet echt geloof ik :o
of het moet zo zijn dat hij nu niet de maxspeed haalt.

....
(toegevoegd)

hmmm laat maar even.

ja toch gek, heb nu de intervals op 100 staan en in accelerate en decelerate een printregel
alles zou hetzelfde moeten zijn toch zie je in de serieele monitor dat accelerate
4 tot 5 x langer duurt (geschat) (( en bij lange na geen 20 sec))

Gebruikers-avatar
Berichten: 2655
Geregistreerd: 06 Aug 2016, 01:03

Re: train control project

Berichtdoor Koepel » 29 Sep 2016, 19:03

Ik heb het op een Arduino Uno gedraaid, en het is toch echt 20 seconden.
Dat is een gewone Arduino Uno op 16MHz.

Als de sensors iets verkeerd zien, dan kan de state naar "STATE_DECELERATE" gaan, maar dat zou je dan aan de getallen zien.

Gebruikers-avatar
Berichten: 31
Geregistreerd: 08 Sep 2016, 21:50

Re: train control project

Berichtdoor Kitemasters » 29 Sep 2016, 21:34

tja....tijd is relatief :idea:

ik heb helaas geen stopwatch maar wat vaststaat is;

Sainsmart mega 2560 (ook 16MHz)
Stilstand - Accelerate - Run - Decelerate - Stilstand (met een klok erbij duurt ongeveer 18sec)
Bij uploaden naar bordje lijkt de eerste accelerate wel langer te duren (met 21 22 23 ... tellen kom ik dan ongeveer op 18sec)
decelerate gaat sneller dan accelerate (veel sneller)

ik kan wel geloven, imitatie slechte kwaliteit enz. maar de 16MHz komt uit het crystal (zover ik weet)
en die ziet toch geen verschil tussen decelerate en accelerate?.

verder niet belangrijk, heb ik nu een aparte "state" voor het ompolen.
zodat dit niet meer vastzit aan de decelerate functie.
cpp code
/*
Train control
Drive the train between two gates made of a LED and LDR.
*/
// --------CONSTANTS (won't change)---------------

int sens_L_Pin = A4; // the pin number for ldr L
int sens_R_Pin = A5; // the pin number for ldr R
int led_L_Pin = 4; // the pin number for the L LED
int led_R_Pin = 5; // the pin number for the R LED
int motor_Pin = 3; // the pin number for the motor speed
int brake_Pin = 9; // the pin number for the motor brake
int direction_Pin = 12; // the pin number for the motor direction
int current_sens_Pin = A0; // the pin number for the current sensor

int read_sens_Interval = 200; // millisecs between reading sensors
int motor_Acc_Interval = 100; // millisecs between acceleration steps
int motor_Dec_Interval = 100; // millisecs between deceleration steps

//------------ VARIABLES (will change)---------------------

unsigned long currentMillis = 0; // stores the value of millis() in each iteration of loop()
unsigned long previous_sens_Millis = 0; // will store the last time sensors are read
unsigned long previous_state_Millis = 0; // will store the last time state is printed
unsigned long previous_Acc_Millis = 0; // will store time of last acceleration step
unsigned long previous_Dec_Millis = 0; // will store time of last deceleration step

int sensLreading = 0; //variable voor de waarde van sensL
int sensRreading = 0; //variable voor de waarde van sensR
int max_Speed = 200; //declare variable and set value for maximum Speed (0 to 255)
int Speed = 0; //declare variable and set value for current Speed (0 to 255)
boolean direct = true; //declare variable and set value for driving direction

#define STATE_IDLE 0
#define STATE_START 1
#define STATE_RUN 2
#define STATE_DECELERATE 3
#define STATE_TURN 4
#define STATE_ACCELERATE 5

int state = STATE_IDLE;

//========================================

void setup() {

Serial.begin(9600);

pinMode(led_L_Pin, OUTPUT); // set led_L_Pin as output
pinMode(led_R_Pin, OUTPUT); // set led_R_Pin as output
pinMode(motor_Pin, OUTPUT); // set motor_Pin as output
pinMode(brake_Pin, OUTPUT); // set brake_Pin as output
pinMode(direction_Pin, OUTPUT); // set direction_Pin as output
pinMode(sens_L_Pin, INPUT); // set sens_L_Pin as input
pinMode(sens_R_Pin, INPUT); // set sens_R_Pin as input
pinMode(current_sens_Pin, INPUT); // set current_sens_Pin as input

}
//========================================

void loop() {

currentMillis = millis(); // capture the latest value of millis()
read_sens(); // read the sensors

switch (state)
{
case STATE_IDLE:
state = STATE_START;
break;

case STATE_START:
Start();
break;

case STATE_ACCELERATE:
Accelerate();
break;

case STATE_DECELERATE:
Decelerate();
break;

case STATE_TURN:
Turn();
break;

case STATE_RUN:
break;
}
}
//========================================

void read_sens() {

if (currentMillis - previous_sens_Millis >= read_sens_Interval) { // time is up, so read sensors
sensLreading = analogRead(sens_L_Pin); // read left ldr (high value means the light is off or blockt)
//Serial.print("Left = "); // print for debug
//Serial.println(sensLreading); // print for debug
sensRreading = analogRead(sens_R_Pin); // read right ldr (high value means the light is off or blockt)
//Serial.print("Right = "); // print for debug
//Serial.println(sensRreading); // print for debug
previous_sens_Millis += read_sens_Interval; // and save the time we last read sensors

if (sensLreading > 200 && direct == true) { //if conditions are throu, the train reached left gate***
digitalWrite(led_L_Pin, LOW); //Turn left LED off
digitalWrite(led_R_Pin, HIGH); //Turn right LED on
state = STATE_DECELERATE; // set state to "decelerate"
}

if (sensRreading > 200 && direct == false) { //if conditions are throu, the train reached right gate***
digitalWrite(led_R_Pin, LOW); //Turn right LED off
digitalWrite(led_L_Pin, HIGH); //Turn left LED on
state = STATE_DECELERATE; // set state to "decelerate"
}
}
}
//========================================

void Start() {

digitalWrite(led_L_Pin, HIGH); // turn left led on
digitalWrite(brake_Pin, LOW); // Disengage the Brake
digitalWrite(direction_Pin, LOW); // Establishes left direction of train
state = STATE_ACCELERATE; // set state to "accelerate"
direct = true; // set direction to true (true = LOW = left)
}
//========================================

void Accelerate() {

if (currentMillis - previous_Acc_Millis >= motor_Acc_Interval) { // time is up, so accelerate
Speed = Speed + 1; // add 1 to speed
analogWrite(motor_Pin, Speed); // send Speed to motor_Pin
Serial.print("Speed = "); // print for debug
Serial.println(Speed); // print for debug
previous_Acc_Millis += motor_Acc_Interval; // last time of acceleration step
if (Speed == max_Speed) { // if speed reach max speed
state = STATE_RUN; // set state to "run"
}
}
}
//========================================

void Decelerate() {

if (currentMillis - previous_Dec_Millis >= motor_Dec_Interval) { // time is up, so decelerate
Speed = Speed - 1; // subtract 1 of speed
analogWrite(motor_Pin, Speed); // send Speed to motor_Pin
Serial.print("Speed = "); // print for debug
Serial.println(Speed); // print for debug
previous_Dec_Millis += motor_Dec_Interval; // last time of deceleration step
if (Speed == 0) { // if speed reach 0
state = STATE_TURN; // set state to "turn"
}
}
}
//========================================

void Turn() {

if (direct == true) { // flip direction
direct = false;
digitalWrite(direction_Pin, HIGH); // Establishes right direction of train
}
else {
direct = true;
digitalWrite(direction_Pin, LOW); // Establishes left direction of train
}
state = STATE_ACCELERATE; // set state to "accelerate"
}
//========================================END

Berichten: 4064
Geregistreerd: 16 Okt 2013, 14:31
Woonplaats: s hertogenbosch

Re: train control project

Berichtdoor shooter » 29 Sep 2016, 22:50

je waarnemingen kloppen en je tijden een beetje.
er is een groot verschil in de pwm waarde om de motor te starten en om te stoppen, dus je kunt bijvoorbeeld beginnen bij 50 voordat de loc begint te bewegen en afremmen is bijv tot 25 maar die getallen moet je vaststellen.

ik denk inderdaad dat de pwm niet tot 200 komt.
paul deelen
shooter@home.nl

Gebruikers-avatar
Berichten: 2655
Geregistreerd: 06 Aug 2016, 01:03

Re: train control project

Berichtdoor Koepel » 30 Sep 2016, 16:18

Je software timing met millis() zal proberen om weer bij te komen. Er komt daardoor een burst van Decelerate.

Het gaat om deze regel:
Code: Alles selecteren
previous_Dec_Millis += motor_Dec_Interval;


Als de state op "STATE_DECELERATE" wordt gezet, dan zou "previous_Dec_Millis" een minuut kunnen achterlopen. Dat betekent dat bij iedere loop(), de Decelerate wordt uitgevoerd. Totdat eindelijk de "previous_Dec_Millis" bij de millis() terecht komt. Daarna gaat de normale interval in werking.

Je kunt de tijd goed laten beginnen, door de tijd goed te zetten als de state wijzigt. Dus twee keer deze code:
Code: Alles selecteren
  state = STATE_DECELERATE;
  previous_Dec_Millis = currentMillis;      // toegevoegd


Verder kun je de currentMillis gebruiken in plaats van op te hogen met de interval. Daarmee voorkom je dat er een burst van Decelerate ontstaat.
Code: Alles selecteren
  // previous_Dec_Millis += motor_Dec_Interval;                        // last time of deceleration step
  previous_Dec_Millis = currentMillis;


Een aparte state voor STATE_TURN is prima. Door het verder op te delen is het duidelijker.

Wat ik noemde een gebroken state machine, dat is nog steeds zo. De funktie read_sens() wijzigt de state buiten de state machine om. Met de uitbreiding die ik hierboven schreef, zie ik helaas je state machine steeds minder fraai worden :(


Zomaar een idee: De hele state machine is op dit moment alleen voor de snelheid van de trein. Dus op dit moment zou je de hele state machine binnen een software timer met millis() kunnen zetten. Dan verlopen de STATE_TURN en STATE_START ook binnen de interval, maar met 10 keer seconde merkt niemand dat ;)
Dan heb je nog maar twee software timers met millis(). De sensoren en de state machine.
Code: Alles selecteren
  currentMillis = millis();                      // capture the latest value of millis()
 
  read_sens();                                   // read the sensors
 
  // Run the state machine at a fixed interval.
  if (currentMillis - previous_state_Millis >= state_interval) {

    switch (state)
    {
      case STATE_IDLE:
        state = STATE_START;
        break;

Gebruikers-avatar
Berichten: 31
Geregistreerd: 08 Sep 2016, 21:50

Re: train control project

Berichtdoor Kitemasters » 30 Sep 2016, 17:53

koepel....eigenlijk ben je me net voor :)
en ik heb zomaar het gevoel dat je er niet ver naast zit.
maar omdat ik toch niet de hele morgen voor nop heb zitten prutsen
toch even mijn laatste ervaringen benoemen............ :P

de trein gaat pas rijden bij speed 85, bij stoppen zal dit inderdaad lager liggen.
bij starten zal een piekje nodig zijn om de massa in beweging te krijgen
bij stoppen zorgt dezelfde massa dat de trein door rolt.
maar ik geloof niet dat dit verder verband heeft met de millis functie.
ook zonder trein op de rails zie ik in de monitor dezelfde effecten.

als ik in de code println...speed zet en de monitor geeft 200 aan neem ik aan
dat pwm op dat moment ook 200 is.

omdat ik dit effect al in de eerste versies gezien had vroeg ik me af hoe ik dit weer zichtbaar kon maken.
:idea: gewoon weer een millis functie die elke halve seconde de millis print.

fase 1
na upload alles prima, 5 stapjes in een halve seconde. (of 6 , het heet wel "several things at the same time" maar hij kan echt geen 2 regels tegelijk printen)
en zoals te verwachten bij 20000 precies op 200
Afbeelding

fase 2
maar dan bij de omschakeling naar decelerate passen er ineens 20 stapjes in een halve seconde :shock:
dit loopt zelfs nog op tot 36 en 41.
Afbeelding

als ik dit verder laat lopen door met mijn vinger de poortjes te laten omschakelen word ook de accelerate in 40 stapjes gedaan.
maar die schakelt bij ongeveer 140 ineens weer naar 5 stapjes.... totdat hij weer naar decelerate schakelt dan is het weer 40 stapjes
in een halve seconde.

dit was alles zonder trein. mèt trein maakt hij er helemaal een potje van
Afbeelding
deze effecten had ik ook al in eerdere versies gezien. en is volgens mij voornamelijk te wijten aan het feit dat
op het moment van passeren van het poortje er teveel bezig is.
treintje dus weer op de grond :cry:

goed nu weer verder pielen met de laatste post van koepel ;)

Berichten: 4064
Geregistreerd: 16 Okt 2013, 14:31
Woonplaats: s hertogenbosch

Re: train control project

Berichtdoor shooter » 30 Sep 2016, 19:47

je telt telkens de tijd erbij en dat is niet slim, beter is het om previous gelijk te maken aan current (zoals ook in de blink without delay gebeurt.

jouw methode kan wel, maar dat heeft dan te maken met rel time controle.
paul deelen
shooter@home.nl

Gebruikers-avatar
Berichten: 31
Geregistreerd: 08 Sep 2016, 21:50

Re: train control project

Berichtdoor Kitemasters » 02 Okt 2016, 04:22

voorlopig de aanpassing (previous_Dec_Millis = currentMillis;      // toegevoegd) gekozen.
ik kreeg eerst een berg foutmeldingen waar ik niet veel van begreep maar dat
bleek te komen omdat ik te lui was even te typen en de aanpassing uit je voorbeeld
probeerde te kopiëren. kennelijk kopieer je dan iets mee dat niet zichtbaar is.

dit maakt wel het verschil, Decelerate interval heb ik terug moeten brengen naar 10.
accelerate blijft 100 zodat hij mooi langzaam opstart.

verder nog wat comments en intro aangepast.

cpp code
/*
Train control
This code is developed to "test" drive
a model train between two gates made of a LED and LDR.

Parts required:
1 - arduino uno/mega or compatible
1 - arduino motor shield R3
2 - Led brite white (5mm)
2 - Ldr (A 9013 photo resistor 5mm)
2 - 10K resistor
2 - 220 Ohm resistor
1 - model train

Created 2 October 2016
by Kitemasters

This code is part of the public domain
*/
// --------CONSTANTS (won't change)---------------

int sens_L_Pin = A4; // the pin number for ldr L
int sens_R_Pin = A5; // the pin number for ldr R
int led_L_Pin = 4; // the pin number for the L LED
int led_R_Pin = 5; // the pin number for the R LED
int motor_Pin = 3; // the pin number for the motor speed
int brake_Pin = 9; // the pin number for the motor brake
int direction_Pin = 12; // the pin number for the motor direction
int current_sens_Pin = A0; // the pin number for the current sensor

int read_sens_Interval = 200; // millisecs between reading sensors
int motor_Acc_Interval = 100; // millisecs between acceleration steps
int motor_Dec_Interval = 10; // millisecs between deceleration steps

//------------ VARIABLES (will change)---------------------

unsigned long currentMillis = 0; // stores the value of millis() in each iteration of loop()
unsigned long previous_sens_Millis = 0; // will store the last time sensors are read
unsigned long previous_Acc_Millis = 0; // will store time of last acceleration step
unsigned long previous_Dec_Millis = 0; // will store time of last deceleration step

int sensLreading = 0; //variable voor de waarde van sensL
int sensRreading = 0; //variable voor de waarde van sensR
int max_Speed = 200; //declare variable and set value for maximum Speed (0 to 255)
int Speed = 0; //declare variable and set value for current Speed (0 to 255)
boolean direct = true; //declare variable and set value for driving direction

#define STATE_IDLE 0 //declare value 0 to be STATE_IDLE
#define STATE_START 1 //declare value 1 to be STATE_START
#define STATE_RUN 2 //declare value 2 to be STATE_RUN
#define STATE_DECELERATE 3 //declare value 3 to be STATE_DECELERATE
#define STATE_TURN 4 //declare value 4 to be STATE_TURN
#define STATE_ACCELERATE 5 //declare value 5 to be STATE_ACCELERATE

int state = STATE_IDLE; //declare variable "state" and set value to STATE_IDLE

//========================================

void setup() {

Serial.begin(9600);

pinMode(led_L_Pin, OUTPUT); // set led_L_Pin as output
pinMode(led_R_Pin, OUTPUT); // set led_R_Pin as output
pinMode(motor_Pin, OUTPUT); // set motor_Pin as output
pinMode(brake_Pin, OUTPUT); // set brake_Pin as output
pinMode(direction_Pin, OUTPUT); // set direction_Pin as output
pinMode(sens_L_Pin, INPUT); // set sens_L_Pin as input
pinMode(sens_R_Pin, INPUT); // set sens_R_Pin as input
pinMode(current_sens_Pin, INPUT); // set current_sens_Pin as input

}
//========================================

void loop() {

currentMillis = millis(); // capture the latest value of millis()
read_sens(); // read the sensors

switch (state)
{
case STATE_IDLE:
state = STATE_START;
break;

case STATE_START:
Start();
break;

case STATE_ACCELERATE:
Accelerate();
break;

case STATE_DECELERATE:
Decelerate();
break;

case STATE_TURN:
Turn();
break;

case STATE_RUN:
break;
}
}
//========================================

void read_sens() {

if (currentMillis - previous_sens_Millis >= read_sens_Interval) { // time is up, so read sensors
sensLreading = analogRead(sens_L_Pin); // read left ldr (high value means the light is off or blockt)
sensRreading = analogRead(sens_R_Pin); // read right ldr (high value means the light is off or blockt)
previous_sens_Millis += read_sens_Interval; // and save the time we last read sensors

if (sensLreading > 200 && direct == true) { //if conditions are throu, the train reached left gate***
digitalWrite(led_L_Pin, LOW); //turn left LED off
digitalWrite(led_R_Pin, HIGH); //turn right LED on
state = STATE_DECELERATE; //set state to "decelerate"
previous_Dec_Millis = currentMillis; //set previous_Dec_Millis to current time
}

if (sensRreading > 200 && direct == false) { //if conditions are throu, the train reached right gate***
digitalWrite(led_R_Pin, LOW); //turn right LED off
digitalWrite(led_L_Pin, HIGH); //turn left LED on
state = STATE_DECELERATE; //set state to "decelerate"
previous_Dec_Millis = currentMillis; //set previous_Dec_Millis to current time
}
}
}
//========================================

void Start() {

digitalWrite(led_L_Pin, HIGH); //turn left led on
digitalWrite(brake_Pin, LOW); //Disengage the Brake
digitalWrite(direction_Pin, LOW); //Establishes left direction of train
state = STATE_ACCELERATE; //set state to "accelerate"
previous_Acc_Millis = currentMillis; //set previous_Acc_Millis to current time
direct = true; //set direction to true (true = LOW = left)
}
//========================================

void Accelerate() {

if (currentMillis - previous_Acc_Millis >= motor_Acc_Interval) { //time is up, so accelerate
Speed = Speed + 1; //add 1 to speed
analogWrite(motor_Pin, Speed); //send Speed to motor_Pin
//Serial.print("Speed = "); //print for debug
//Serial.println(Speed); //print for debug
previous_Acc_Millis += motor_Acc_Interval; //last time of acceleration step
if (Speed == max_Speed) { //if speed reach max speed
state = STATE_RUN; //set state to "run"
}
}
}
//========================================

void Decelerate() {

if (currentMillis - previous_Dec_Millis >= motor_Dec_Interval) { //time is up, so decelerate
Speed = Speed - 1; //subtract 1 of speed
analogWrite(motor_Pin, Speed); //send Speed to motor_Pin
//Serial.print("Speed = "); //print for debug
//Serial.println(Speed); //print for debug
previous_Dec_Millis += motor_Dec_Interval; //last time of deceleration step
if (Speed == 0) { //if speed reach 0
state = STATE_TURN; //set state to "turn"
}
}
}
//========================================

void Turn() {

if (direct == true) { //flip direction
direct = false;
digitalWrite(direction_Pin, HIGH); //establishes right direction of train
}
else {
direct = true;
digitalWrite(direction_Pin, LOW); //establishes left direction of train
}
state = STATE_ACCELERATE; //set state to "accelerate"
previous_Acc_Millis = currentMillis; //set previous_Acc_Millis to current time
}
//========================================END

VorigeVolgende

Terug naar Gezamenlijke projecten

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 8 gasten