Servo motori per deviatoi

[Luca Regoli]

oggi pomeriggio ho fatto alcuni passi avanti:
Il sinottico è ora a se stante
ho modificato gli sketch affinchè possano elaborare i task in parallelo.
Prima la logica era puramente sequenziale:
scelta dell'itinerario premendo un tasto
cancellazione del vecchio itinerario dal sinottico
un lampeggio
movimento motore 1
un lampeggio
moviemnto motore 2
un lampeggio
accensione stabile

Ora ho parallelato il lampeggio al movimento dei motori (vedere video)
Siccome Arduino non gestisce le funzioni di fork() tipiche del linguaggio C, per parallelare 2 processi bisogna usare una
diversa strategia. In pratica vanno eseguite le istruzioni nel ciclo loop in sequenza temporale considerando i task
che vogliamo eseguire in parallelo. Ogni task è composto da più comandi comprese le funzioni delay(ms) che fermano l'elaborazione
dell'Arduino.

Faccio un esempio:

Ecco uno sketch per far lampeggiare un led

const byte led = 13;
void setup() {
pinMode(led, OUTPUT); //inizializza il pin 13 come uscita.
}
void loop() {
digitalWrite(led, HIGH); //accende il LED (HIGH il voltaggio alto)
delay(1000); //attende 1000ms = 1 secondo
digitalWrite(led, LOW); //spegne il LED (LOW è il voltaggio basso)
delay(1000); //attende 1000ms = 1 secondo
}

Se vogliamo far lampeggiare un secondo led contemporaneamente ma con diversa frequenza non possiamo: possiamo solo farli lampeggiare in sequenza.
Allora come fare?
Basta far riferimento ad contatore assoluto che ci viene fornito dalla funzione millis() che raprresenta il numero di millisecondi da quando accendiamo arduino
essendo un unsigned long la variabile si resetta ogni 50 giorni. Più che sufficiente x i ns scopi.
ecco lo sketch:

const int ledPin = 13; // Led pin
byte ledState = 0; // stato del Led
unsigned long previousMillis = 0; //memorizza l'ultimo istante in cui il LEDstate è stato aggiornato
unsigned long interval = 1000; //intervallo di lampeggio (millisecondi)
void setup() {
pinMode(ledPin, OUTPUT); //pin 13 a cui è collegato il led:
}

void loop() {
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
previousMillis = currentMillis; //salva l'ultimo istante in cui ha lampaggiato il led
//se il led è spento accendilo altrimenti spegnilo (è uno XOR corrisponde a ledState=ledState ^ 1)
ledState ^= 1;
digitalWrite(ledPin, ledState);
}
}

Con questo script possiamo fare la stessa cosa di prima senza bloccare il processore con delay()

const int ledPin1 = 13; // Led pin 1
const int ledPin2 = 12; // Led pin 2
byte ledState1 = 0; // stato del Led 1
byte ledState2 = 0; // stato del Led 2
unsigned long previousMillis1 = 0; //memorizza l'ultimo istante in cui il LEDstate è stato aggiornato
unsigned long previousMillis2 = 0; //memorizza l'ultimo istante in cui il LEDstate è stato aggiornato
unsigned long interval1 = 1000; //intervallo di lampeggio 1 (millisecondi)
unsigned long interval2 = 690; //intervallo di lampeggio 2 (millisecondi)
void setup() {
pinMode(ledPin1, OUTPUT); //pin 13 a cui è collegato il led:
pinMode(ledPin2, OUTPUT); //pin 12 a cui è collegato il led:
}

void loop() {
unsigned long currentMillis1 = millis();

if(currentMillis1 - previousMillis1 > interval1) {
previousMillis1 = currentMillis1; //salva l'ultimo istante in cui ha lampaggiato il led
//se il led è spento accendilo altrimenti spegnilo (è uno XOR corrisponde a ledState=ledState ^ 1)
ledState1 ^= 1;
digitalWrite(ledPin1, ledState1);
}
unsigned long currentMillis2 = millis();
if(currentMillis2 - previousMillis2 > interval2) {
previousMillis2 = currentMillis2; //salva l'ultimo istante in cui ha lampaggiato il led
//se il led è spento accendilo altrimenti spegnilo (è uno XOR corrisponde a ledState=ledState ^ 1)
ledState2 ^= 1;
digitalWrite(ledPin2, ledState2);
}
}
In questo modo i led lampeggeranno con diversa frequenza.
Il concetto quindi è molto semplice: dovremo, usando il numero di ms che venogno usati come tempo minimo di attesa di una operazione,
porre una condizione di uscita dal ciclo per eseguire il blocco di istruzioni successivo. All'occhio sembrerà che le operazioni vengono eseguite contemporamente.
Quindi il blocco minimo è questo e verrà eseguito moltissime volte all'interno dello stesso intervallo interval1 pari a 1 secondo. Sino a che il programma resterà nei 1000ms (interval1)
il led resterà nello stesso stato (o acceso o spento) mentre il secondo led cambierà stato avendo un interval2 più breve (690 ms). Se invece di due led, facciamo muovere
motori, led, o relays, il concetto resta sempre lo stesso.

Ed è esattemente quel che ho fatto nel codice dell'apparato ad itinerari!

[Luca Regoli]

iniziano le prove di ... voce

ImageUploadedByTapatalk1457259105.153198.jpg

[Luca Regoli]

cuore del sistema audio (è troppo pretenzioso chiamarlo così ma almeno ci capiamo) è il modulo wtv020m01 che si trova su internet a pochi euro (3-4)

ImageUploadedByTapatalk1457259268.386922.jpg

[Luca Regoli]

Vi posto lo schema del quadro sinottico:
Ogni segmento è composto da 3 led e costituisce la minima entità pilotabile.
Lo schema è semplicissimo:
il transistor si pilota mandando alta l'uscita a cui è collegato. Il transistor metterà a massa il collettore e la striscia di led corrispondente si illuminerà.
Ho utilizzato dei led verdi da 3 mm com sagomatura rettangolare della parte superiore. Costo dell'insieme: qualche euro (10 transistor= 1€, 100 led 5€.. ometto il costo delle resistenze...).
Il calcolo delle resistenze è stato fatto tenendo conto delle caratteristiche dei led: personalmente preferisco consumi ridotti di corrente a scapito della luminosità ma a vantaggio della
durata....

Schermata 2016-03-07 alle 13.48.44.png