Arduino: luci in sequenza

[eldiablo84]

grazie dell'interessamento inanzi tutto .
Prima di rispondere ti dico che so programmare a livello base in c , o meglio imparai le istruzioni base del c++ . Quindi un pochino conosco questo linguaggio ma ho notato delle differenze tra il programmare in C con una delle tante piattaforme su PC ( io usavo il dev++ ) e il programmare arduino .
comunque non sono qui per copiare semplicemente codici facili quindi questi aiuti li userò sicuramente per imparare .

Tornando alle tue domande : (premetto che queste luci sono puramente decorative , la scalinata è è illuminata attraverso pulsanti con relay temporizzati )
Per fare un sistema del genere fatto davvero bene so che ci vorrebbero n fotocellule per n scale , ma sarebbe troppo sofisticato anche se bello . Io pensavo più a una sequenza up o down di intervalli di un secondo ad ogni accensione , indipendentemente dal fatto che una qualsiasi persona possa fermarsi , andare lenta o troppo veloce .

Vorrei solo semplicemente sequenza up e sequenza down qualora si attivi la rispettiva fotocellula . Questo ,sia se, a salire sia una singola persona oppure salgano 2 persone con un intervallo di 5s l'una dall'altra , sia se uno sale e un altro scende . Ora che ci penso dovrei metter 2 fotocellule per la salita e 2 per la discesa cosi che il sistema capisce se la persona sta salendo o scendendo . altrimenti come la persona percorre la gradinata e arriva alla fine , la sequenza partirebbe in discesa credendo che qualcuno stia scendendo .

[eldiablo84]

Ad ogni interruzione parte la sequenza , perché anche se salgono più persone insieme al massimo succede che invece di essere 3 scale illuminate che salgono , ne diventerebbero 4 o 5 o 6 , regalando comunque lo stesso effetto ottico ,oppure come suggerisci tu si potrebbe inserire un piccolo tempo di non intervento della fotocella diciamo di 1s.

[c1b8]

Ok, allora ti spiego la mia idea base, da sofisticare all'occorenza introducendo controlli/ritardi opportuni.

Anzitutto diciamo che tu hai luci totali da gestire nello scorrimento (es. 17 gradini = 17 luci), inoltre vuoi avere luci accese contemporaneamente (nel tuo caso 3).
Avrai quindi bisogno di almeno bit per gestire la sequenza di up e altrettanti bit per gestire la sequenza di down.
Nel tuo caso ti serviranno 22 bit, ovvero 3 byte per la sequenza di up e 3 byte per la sequenza di down.
Con questi 6 byte di RAM gestisci contemporaneamente un numero qualsiasi di sequenze up e down.


Vediamo cosa deve fare il programma.

Ad intervalli regolari di 1 secondo (modificabile in funzione della velocità di scorrimento che vuoi dare), il programma eseguirà (sequenza da eseguire ad esempio su interrupt):
- shift a sinistra di una posizione dei 3 byte della sequenza di up
- shift a destra di una posizione dei 3 byte della sequenza di down
- or logico dei byte (byte1_up in or con byte1_down, byte2_up in or con byte2_down, byte3_up in or con byte3_down) ottenendo così nuovi 3 byte.
- shift a destra di posizioni dei nuovi 3 byte. Il risultato sono le lampade da accendere/spegnere, il tuo output insomma dove ogni bit dei 3 byte rappresenta una lampada.

Nel main del programma dovrai:
- verificare se viene interrotta una delle fotocellule:
- se si interrompe la fotocellula di up esegui un or (come prima byte per byte) dei 3 byte della sequenza di up con il valore (nel tuo caso con il valore 7)
- se si interrompe la fotocellula di down esegui un or (come prima byte per byte) dei 3 byte della sequenza di down con il valore shiftato a sinistra di posizioni.

Con questi semplici passaggi puoi gestire contemporaneamente un numero qualsiasi di sequenze di up e di sequenze di down.
Un effetto collaterali da, eventualmente, gestire potrebbe essere:
Supponiamo che una persona interrompa la fotocellula up (vale lo stesso per la down) e rimanga fermo. In questo caso il programma rileva l'interruzione, imposta i valori nei byte di up e l'interrupt comincia a far scorrere le luci. Se non attendi che la fotocellula venga ripristinata (non interrotta) verrà rilevata una nuova interruzione dando inizio ad una nuova sequenza di up. In questo modo vedrai il numero di luci che scorrono aumentare. Potresti vedere l'intera scala accendersi senza effetto di scorrimento, effetto che riprende quando la persona esce dal primo gradino.

Non conosco arduino, non saprei quindi scriverti un programma, ma come hai visto la cosa è molto semplice.
Se hai qualche dubbio chiedimi pure.

[eldiablo84]

sinceramente non mi è molto chiara la risposta , cioè fila in maniera logica ma non saprei al momento come tradurre questa risposta in linguaggio di programmazione .

[c1b8]

Come ti dicevo non conosco Arduino, ma provo a scriverti il codice in C usando MPLab XC8, quindi per un PIC.
Credo, spero, che le modifiche necessarie per portarlo su Arduino siano poi semplici o nulle...

Prima cosa definisco le costanti e le variabili che mi servono nel resto del programma.
Per comodità ho già precalcolato il valore della sequenza iniziale Up e Down, le scrivo in binario per vedere meglio il valore di ogni bit.
Abbiamo detto che mi servono variabili da 3 byte per gestire le sequenze, utilizzo quindi delle variabili short long che sono da 4 byte. Quindi:

Codice: Seleziona tutto

#define sqzUpInit 0b000111
#define sqzDownInit 0b111000000000000000000

unsigned short long sqzUp=0;
unsigned short long sqzDown=0;


Questa la parte di codice che esegue lo scorrimento delle luci. Questo codice sarà eseguito ad intervalli di 1 secondo (vedi tu come fare: interrupt?):

Codice: Seleziona tutto

        // shift a sinistra di una posizione della sequenza UP
        sqzUp = sqzUp << 1;
        // shift a destra di una posizione della sequenza DOWN
        sqzDown = sqzDown >> 1;

      // accende le luci
       accendiLuci();


La routine accendiLuci()

Codice: Seleziona tutto

    void accendiLuci(void) {
        // or logico tra le due sequenze UP e DOWN
        unsigned short long sqzOut= sqzUp | sqzDown;
        // shift a destra di NumeroLuciContemporanee - 1
        sqzOut = sqzOut >> 2;
        // A questo punto la variabile sqzOut contiene lo stato delle luci in uscita
        // ogni bit rappreseta una luce.
        // Se hai 17 pin di out ti basta spostare questa variabile nei pin
        // altrimenti bisogna adattarla, ma comunque sia sqzOut è la nostra uscita
    }


Come vedi molto semplice. Alcune considerazioni.
Queste poche righe gestiscono contemporaneamente lo scroll delle luci verso l'alto e verso il basso. Ovvero le luci nelle due direzioni si muovono sempre nello stesso istante. Questo potrebbe significare che il primo spostamento verso l'alto o verso il basso non sia esattamente dopo 1 secondo dall'interruzione della fotocellula corrispondente: supponiamo che una persona interrompa la fotocellula UP, inizia la sequenza up e dopo 1 secondo si spostano le luci. Se qualcuno interrompe la fotocellula down mezzo secondo dopo l'interruzione della fotocellula up, la sequenza down avrà inizio dopo mezzo secondo e non dopo 1 secondo essendo le 2 sequenze sincronizzate.
Per evitare questo dovresti gestire due diverse tempistiche e dividere la routine sopra in 2 parti: una per la sola up ed una per la sola down.

Vediamo ora la parte di programma che controlla le fotocellule e inizia una nuova sequenza.
Tralascio il controllo della fotocellula.

Codice: Seleziona tutto

    if (scatta_foto_up) {
        // qui abbiamo rilevato una interruzione della fotocellula UP
        // inizio una nuova sequenza UP
        sqzUp |= sqzUpInit;
        accendiLuci();
    }

    if (scatta_foto_down) {
        // qui abbiamo rilevato una interruzione della fotocellula DOWN
        // inizio una nuova sequenza DOWN
        sqzDown |= sqzDownInit;
        accendiLuci();
    }


Tutto qui. E' solo la versione base, senza alcun tipo di ottimizzazione, ma come vedi estremamente semplice e funzionante.
Spero adesso ti sia più chiaro e facile da implementare su Arduino... forse però un semplice PIC ti basta!

[bladeblaze]

Secondo me senza un potenziamento hardware con ovviamente ovvia relativa ottimizzazione software la cosa è pericolosa.
Oltre a quello che va piano e/o si ferma c'è pure quello che ha fretta. Se le luci non vanno nel modo opportuno uno rischia di farsi male, e se fossi io poi farei male a te ..

[eldiablo84]

chiedo scusa , sono stato un po impegnato , grazie mille dell aiuto , provo appena possibile a convertire il cod in linguaggio arduino , il ragionamento ora mi è chiaro :)

[marc96]

Se le luci sono semplicemente decorative, prova a considerare la soluzione con led in cascata gestiti dall'integrato WS2801. Per 50 led node RGB spendi max 15€ e per Arduino ci sono librerie molto semplici da usare. Prova a cercare su youtube ws2801 o ws2811...