Semaforo Complesso OK-Flip Flop Semplice ( e non ci salto fuori).

Intanto GRAZIE a TUTTIper la pazienza:

DOCSAVAGE innazitutto sto studiando e sto facendo tesoro di quello che mi avete insegnato, part dal principio che quando mi sino iscritto su questo url,avevo a malapena capito la differenza chedentro le parentesi tonde e quelle e graffe e grazie al vostro aiuto il mio ultimo schetch postato,me lo sono fatto quasi tutto da solo a memoria,ricontrollando tutto ed andando a copiare solo quando non ci saltavo fuori…ed io non sono jim e non credo nelle parabole.

gpb01 non ho capito ne cosa hai detto e neppure se era riferito a me…ti chiedo scusa.

Claudio_FF l’esempio sull’orologio è stato chiarissimo e mi ha fatto comprendere il millis ora ( se non ho studiato male, posso mettere vari orologi),ma non ora prima voglio capire in quanti modi posso utilizzarlo…non mi preoccupo neppure di azzerarlo per il momento…però grazie è stata un ottima spiegazione

PaoloP ti ringrazio nuovamente…ho rifatto un nuovo schetch molto più corto riprovando piu volte con tentativi diversi,ma il problema persiste è sempre lo stesso con millis incremeta gli INT fino a 2 e poi torna 0 (incrementarlo a 3…NON CI PENSA PROPRIO).

Premesso che sto utillizzando tinkercad per fare gli schect commento solo i codici che mi danno problemi…i codici inutili sono solo per fare esperienza e per scrivere senza copiare:

int P1=0;
unsigned long T1= millis();
unsigned long T2= millis();
unsigned long startime;
int A=0;

void setup() {
 Serial.begin(9600);
 pinMode(2, OUTPUT);
 pinMode(3, INPUT);
 startime = millis();
}

void loop() {
 if(digitalRead(3))
 {
   while(digitalRead(3)){;}
 
  ++P1;++A;Serial.println(A);Serial.println(P1);}
 
 if(P1>=3){P1=0;}
 if(A>=2){A=0;}
 if(A==0){digitalWrite(2,LOW);Serial.println(A);Serial.println(P1);}
 if(A==1){digitalWrite(2,HIGH);Serial.println(A);Serial.println(P1);}
 if(P1==3)
 {
 Serial.println(A);
 if(startime>=T1+500){++A;}
   if(startime>=T2+1000){++A;}}                                           // qui incrementa solo fino a 2 a 3 NO
}

Lo schetc è corretto unico problema l’incremento,poi se magari potessi vedere in serial monitor i dati incolonnati siù colonne diverse sarebbe meglio,ma non ci sono ancora arrivato.

Per il momento Grazie a tutti.

Puso:
PaoloP ti ringrazio nuovamente…ho rifatto un nuovo schetch molto più corto riprovando piu volte con tentativi diversi,ma il problema persiste è sempre lo stesso con millis incremeta gli INT fino a 2 e poi torna 0 (incrementarlo a 3…NON CI PENSA PROPRIO).

omissis, ma mettendo il tag code

  if(A>=2){A=0;}

Lo schetc è corretto unico problema l’incremento,poi se magari potessi vedere in serial monitor i dati incolonnati siù colonne diverse sarebbe meglio,ma non ci sono ancora arrivato.

Lo Scjetch é corretto cosa?
che non ti incrementa fino a tre perché tu stesso lo castri a due?

la vedi l’unica linea che ti ho citato?
tra l’altre cose scritta tra i tag code, che non è mica difficile, basta volerlo, si vede che qualcuno non vuole…

significa:
se A è maggiore o uguale a due lo riporto a zero

quindi TRE non lo sarà mai, ma non è colpa della millis

è colpa del tuo programma

ripeto, partire dal poco? per fare un solo errore per volta? per fare in fretta a capire e correggere?

si vede che ti da fastidio…

oh e te lo dico subito

non cominciare con la manfrina del

vorrei capire ma mi mancano le basi grazie del tempo che spendete per me ci sono quasi, mi manca poco

Non attacca....... gente che dice frasi del genere vengono via a due soldi la dozzina cerca di elevarti sopra la massa, che ci farai solo bella figura

ti metti d'impegno a fare quello che ti si consiglia, a partire dal mettere il codice tra i tag code, che non è difficile

docsavage: a partire dal mettere il codice tra i tag code, che non è difficile

Si come no, per loro è più facile postare 1000 righe di codice senza usare il corretto tag che capire come va usato , questo fino a che il moderatore non si scoccia di essere preso per i fondelli, dopo l'ennesimo richiamo, e prima scatta la chiusura del thread, poi se ce la recidiva il ban.

bè docsavage intanto Grazie che mi hai fatto capire dove ho sbagliato(domani provo a correggere e...vedrò di starci più attento la prossima volta...ripeto sono ignorantissimo sulla programmazione sono alle prime armi,ma mi sto impegnando). Per ringraziarti ti racconto anchio una storiella(senza offesa....è solo come la vedo io):

Una volta un uomo voleva arrivare in cima ad una montagna;

chi lo conosceva gli consigliò di lasciare perdere perche non ci saqrebbe mai arrivato;

l'uomo partì lo stesso, e durante il suo percorso chiese aiuto su come raggiungere la vetta;

incontrò persone che gli dissero che non era possibile ed altre che gli dissero come avvicinarsi alla cima;

l'uomo non arrivò mai in cima, ma ci arrivò più vicino, di chi gli aveva consigliato di lasciar perdere o di chi gli disse che non era possibile.

e durante il rientro incontro un altro uomo che gli chiese come arrivare in cima alla montagna.

astrobeed seper mettere i tag intendi mettere tra//il spiegare la riga metto nel forum solo quelle che non capisco quelle semplici mi sembra inutile metterle

Grazie per la storiella non la conoscevo e mi è piaciuta

sembra però saggezza orientale

la saggezza orientale contiene sempre un lato "oscuro", non per niente gli orientali tentano tutti di vivere alla occidentale

in particolare la storiella non dice se l'uomo è arrivato anche più in la di chi gli consigliava, o se non è riuscito nemmeno ad eguagliare i suoi consiglieri, quelli buoni intendo

ecco, vedi di non essere così...

comunque, io parla che ti parla, mettendo in pratica i MIEI consigli il semaforo lo ho fatto, a tempo perso....

naturalmennte ho cominciato con il descrivere l'obbiettivo

altrimenti non saprei nemmeno da che parte si troverebbe la montagna

// simulazione semaforo
// 2 vie a 90 gradi, 4 paline
// per i pedoni, tutte le via unificate
// verde senza giallo, con rosso semplicemente negato in hardware
// un buzzer che bippa lento per i ciechi
// durante il "giallo" per i pedoni il buzzer bippa veloce

// un pulsante di chiamata pedonale
// un led di conferma chiamata pedonale presa in carico
// per tranquillizzare chi preme il pulsante
// un interruttore per servizio notturno lampeggiante

come vedi il tag code funziona

poi ho descritto il campo giochi

ho messo le paline (scusate il gioco di parole)

che significa letteralmente ho descritto i collegamenti tra arduino e le paline dei semafori

// definizione paline

byte const P1R     = 2; // palina 1 (e 3) rosso
byte const P1G     = 3; // palina 1 (e 3) giallo
byte const P1V     = 4; // palina 1 (e 3) verde

byte const P2R     = 5; // palina 2 (e 4) rosso
byte const P2G     = 6; // palina 2 (e 4) giallo
byte const P2V     = 7; // palina 2 (e 4) verde

// per i pedoni
byte const PPV     = 8; // verde per pedoni sottinteso rosso è negato
byte const PPG     = 9; // Giallo per i pedoni
byte const CHI    = 10; // led di conferma chiamate pedone presa in carico
byte const PUL    = 11; // pulsante di chiamata pedone

byte const NOT    = 12; // selettore servizio notturno
byte const SEG    = 13; // Led lampeggiante per indicare impianto in servizio




// le paline 1 e 3 sono su una via e danno il verde assieme
// le paline 2 e 4 sono su altra via e danno il verde assieme

poi ho pensato che un semaforo è un oggetto ciclico

quindi basta scrivere una sequenza di azioni che si richiamano una con l'altra

e quindi mi son detto:

una bella tabella, scritta in codice parlante (vuol dire che si capisca cosa dice) con la prima lettera comada la prima palina, e cos' via

// stabiliamo la sequenza di segnali

// 0 Palina Spenta
// R palina su rosso
// G palina su giallo - con verde acceso
// V palina su verde
// L palina con giallo senza verde
// per i segnali pedonali
// P luce verde al pedone, rosso sottinteso negato, basta la prima palina, lo raddoppio sulla seconda solo per estetica
// W luce verde al pedone, rosso sottinteso negato, buzzer inermittente per indicare giallo

// tempistica
// da definire
// A 1 secondo (usato per il giallo lampeggiante)
// B 5 secondi (sovrapposizione tra i due rossi, cambio tra auto e pedoni)
// C 15 seconfi (giallo prima del verde)
// D un minuto (usato per la via 1)
// E due minuti (usato per la via 2)

//sequenze:
// si legge: numero, non registrato, indice dello array
// stato palina 1, stato palina 2, durata, riga da leggere per la prossima

poi mi sono scritto come dovrebbe essere la sequenza delle azioni del semaforo

// sequenza normale

/* alternativa
  0RRB1   due vie rosse, pronti per la via 1
  1VRD2
  2GRC3
  3RRB4
  4RVE5
  5RGC0
  che forse va anche meglio
*/



// sequenza di via pedone libera, parte da via 1 gialla
// attende lo stato 1GRC2....
// 6RRB7 vie impedite // non serve, ci siamo già
// 7PPD8 vie impedite, vie pedoni libere
// 8WWB0 vie impedite, vie pedoni libere, allarem pedoni affreettarsi
// da qui riprende ciclo normale,

// lampggio notturno
// 9LLA: occhio interessante usare : come 10
// :00A9  anello rapido di lampeggio

dove la sola cosa difficile è che avendo 11 righe ho dovuto usare il carattere successivo al 9 per indicare il 10 il carattere successivo al 9 è il duepunti

e si tratta di una tabella di 11 righe che contiene le sole 11 configurazioni possibili del semaforo (anzi, 10, perchè una è risultata inutile, ma non sono stato li a toglierla)

a questo punto le variabili globali

e qui ho truccato, non le ho scritte tutte subito

mano a mano che mi sono servite le ho aggiunte

char sequenza[11][5] = {"RRB1", "VRD2", "GRC3", "RRB4", "RVE5", "RGC0", "RRB7", "PPD8", "WWB0" , "LLA:" , "00A9"}; // array di sequenza delle luci

unsigned long tempo = 0; //istante del prossimo cambio luci
unsigned long tempseg = 0; //istante del prossimo lampeggio led


byte stato = 0; // punto in esecuzione nel ciclo
byte chiamata = 0; // presenza chiamata pedonale
byte buzzer = 0; //lampeggio per simulare il buzzer
byte servizio = 0; // 0 servizio diurno, uno servizio notturno

in fondo sono quasi obbligate... non c'è storia...

pure la setup è quasi obbligata

void setup() {
  // uscite
  pinMode(P1R, OUTPUT);
  pinMode(P1G, OUTPUT);
  pinMode(P1V, OUTPUT);
  pinMode(P2R, OUTPUT);
  pinMode(P2G, OUTPUT);
  pinMode(P2V, OUTPUT);
  pinMode(PPV, OUTPUT);
  pinMode(PPG, OUTPUT);
  pinMode(CHI, OUTPUT);
  pinMode(SEG, OUTPUT);
  // ingressi
  pinMode(PUL, INPUT_PULLUP);
  pinMode(NOT, INPUT_PULLUP);

  // inizializzo seriale
  Serial.begin(9600);
  Serial.println(F("Programma di prova semaforo a due vie"));
  // faccio partire il semaforo
  luci(sequenza[0]);
}

la sola cosa particolare è la chiamata della luci(sequenza[0])

sequenza indice zero è la prima configurazione utile del semaforo la funzione luci(stringa) accende e/o spegne le paline secondo la configurazione data dalla stringa in ingresso

ecco la funzione luci()

void luci(char comando[]) {
  // per debug, la mando in seriale
  Serial.println(comando);


  // poi carico il tempo
  // che e' codificato nel terzo carattere
  switch (comando[2]) {
    case 'A':
      tempo = millis() + 1000;
      break;
    case 'B':
      tempo = millis() + 5000;
      break;
    case 'C':
      tempo = millis() + 15000;
      break;
    case 'D':
      tempo = millis() + 60000;
      break;
    case 'E':
      tempo = millis() + 120000;
      break;

  }

  // prenoto la prossima configurazione
  // che e' codificata nel quarto carattere
  stato = comando[3] - '0';

  // tutto il lavoro delle luci è dato dai due primi caratteri

  // palina 1
  switch (comando[0]) {
    case '0':
      // palina spenta
      digitalWrite(P1R, LOW);
      digitalWrite(P1G, LOW);
      digitalWrite(P1V, LOW);
      digitalWrite(PPV, LOW);
      digitalWrite(PPG, LOW);
      buzzer = 0;
      break;


    case 'R':
      // rosso
      digitalWrite(P1R, HIGH);
      digitalWrite(P1G, LOW);
      digitalWrite(P1V, LOW);
      digitalWrite(PPV, LOW);
      digitalWrite(PPG, LOW);
      buzzer = 0;
      break;

    case 'G':
      // giallo
      digitalWrite(P1R, LOW);
      digitalWrite(P1G, HIGH);
      digitalWrite(P1V, HIGH);
      digitalWrite(PPV, LOW);
      digitalWrite(PPG, LOW);
      buzzer = 0;
      break;

    case 'V':
      // Verde
      digitalWrite(P1R, LOW);
      digitalWrite(P1G, LOW);
      digitalWrite(P1V, HIGH);
      digitalWrite(PPV, LOW);
      digitalWrite(PPG, LOW);
      buzzer = 0;
      break;
    case 'L':
      // giallo del lampeggio
      digitalWrite(P1R, LOW);
      digitalWrite(P1G, HIGH);
      digitalWrite(P1V, LOW);
      digitalWrite(PPV, LOW);
      digitalWrite(PPG, LOW);
      buzzer = 0;
      break;

    case 'P':
      // verde ai pedoni
      digitalWrite(P1R, HIGH);
      digitalWrite(P1G, LOW);
      digitalWrite(P1V, LOW);
      digitalWrite(PPV, HIGH);
      digitalWrite(PPG, LOW);
      buzzer = 0;
      break;
    case 'W':
      // giallo ai pedoni, che lampegggia come buzzer
      digitalWrite(P1R, HIGH);
      digitalWrite(P1G, LOW);
      digitalWrite(P1V, LOW);
      digitalWrite(PPV, HIGH);
      digitalWrite(PPG, HIGH);
      buzzer = 1;
      break;
    default:
      break;

  }
  // palina 2 alcune voci non servono
  switch (comando[1]) {
    case '0':
      // palina spenta
      digitalWrite(P2R, LOW);
      digitalWrite(P2G, LOW);
      digitalWrite(P2V, LOW);
      break;


    case 'R':
      // rosso
      digitalWrite(P2R, HIGH);
      digitalWrite(P2G, LOW);
      digitalWrite(P2V, LOW);
      break;

    case 'G':
      // giallo
      digitalWrite(P2R, LOW);
      digitalWrite(P2G, HIGH);
      digitalWrite(P2V, HIGH);
      break;

    case 'V':
      // Verde
      digitalWrite(P2R, LOW);
      digitalWrite(P2G, LOW);
      digitalWrite(P2V, HIGH);
      break;
    case 'L':
      // giallo del lampeggio
      digitalWrite(P2R, LOW);
      digitalWrite(P2G, HIGH);
      digitalWrite(P2V, LOW);
      break;

    default:
      break;

  }

}

come si vede è una pura unumerazione di casi e accendi spegni...

una noia scriverla.........

le cose interessanti:

la variabile stato, letta dal 4 carattere, converito da ASCII a numerico col semplice trucco di togliere il valore '0'

la variabile stato NON è lo stato attuale, ma lo stato FUTURO

e se una delle vie fosse più trafficata delle altre?
ed ad esempio avesse bisongno di una 4°luce per svoltare da un lato mentre l’altro semaforo è verde?

poi mi sono scritto una loop semplice semplice

per provare se compilava

void loop() {
  // lampeggio al led 13
  if (tempseg < millis()) {
    digitalWrite(SEG, !digitalRead(SEG));
    tempseg = millis() + 301;
  }
}

che fa lampeggiare il led 13 senza bloccare nulla 3011 è scelto per non far mai coincidere i tempi tra le varie funzioni

e adesso stacco che devo andare a dormire, sono sicuro che il resto della loop a questo punto è chiaro...

casomai domani.....

buona notte

Puso: e se una delle vie fosse più trafficata delle altre? ed ad esempio avesse bisongno di una 4°luce per svoltare da un lato mentre l'altro semaforo è verde?

nulla ti vieta di farlo, ma finora non ci sei riuscito...............

scusa, il veleno, ma criticare sei stato capace subito vedo

non hai cavato un ragno da un buco, ma indicare una mancanza altrui subito fatto

per tua regola il mio metodo funziona ed è espandibile, il tuo non cava un ragno da un buco

non indicare a me la montagna, se tu non sai nemmeno salire un paracarro

:) :)

l'uomo non arrivò mai in cima, ma ci arrivò più vicino, di chi gli aveva consigliato di lasciar perdere o di chi gli disse che non era possibile.

qui ho fatto copia incolla.. sulle ultime stavo scherzando(sono davvero ingorante)....domani verififico il tuo consiglio. Per il momento grazie e buonanotte.

Puso: gpb01 non ho capito ne cosa hai detto e neppure se era riferito a me......ti chiedo scusa.

Si, fondamentalmente è riferito a te e ... ... rileggiti attentamente il mio post e fai quanto richiesto (e dettagliatamente descritto) [u]su tutti i tuoi post dove hai messo del codice[/u] o ... mi vedo costretto a chiudere il thread per mancato rispetto del regolamento.

Grazie,

Guglielmo

Puso: l'uomo non arrivò mai in cima, ma ci arrivò più vicino, di chi gli aveva consigliato di lasciar perdere o di chi gli disse che non era possibile.

qui ho fatto copia incolla.. sulle ultime stavo scherzando(sono davvero ingorante)....domani verififico il tuo consiglio. Per il momento grazie e buonanotte.

non hai capito la domanda

io non ero interessato a sapere se ha fatto più e meglio di chi gli diceva che non fosse possibile ero interessato a sapere se era riuscito almeno ad eguagliare chi gli aveva insegnato......

dal fatto che non hai risposto............. capisco da solo la risposta

Proseguendo con l'esposizione del semaforo:

da ultimo ho aggiunto alla loop (che rimane veloce, anzi velocissima)

la rotazione del semaforo (ovvero ciclare tra le varie configurazioni di luci)

// testo se abbiamo gia' raggiunto il tempo
  if (tempo < millis()) {
    // cambio stato semaforo
    luci(sequenza[stato]);
  }

ovviamente se stato è lo stato FUTURO del semaforo, basta farlo eseguire alla luci() per avanzare di un passo

la sorveglianza del selettore del servizio notturno

  if (!digitalRead(NOT) != servizio) {
    servizio = !digitalRead(NOT);
    if (!servizio) {
      // servizio diurno, appena avviato
      luci[0];
      //partita sequenza standard, con doppio rosso
    } else
    {
      // servizio notturno prenotato
      // nulla da fare
    }

e questo esegue la PRE-notazione del servizio notturno, oppure fa ripartire da zero il ciclo semaforico a seconda dei casi

se il servizio notturno è prenotato

if (servizio)  {
    // servizio notturno prenotato
    // se siamo in doppio rosso iniziale:
    if (stato == 1 ) {//stato vale 1 solo dopo aver eseguito la luci[0]
      servizio = 0; // do per aver eseguito il comando
      stato = 9;
      // stato 9 è il lampeggio notturno
    }
  }

e solo durante il doppio rosso iniziale del ciclo prenota come prossimo stato il 9, ciclo di lampeggio

questo evita che se un pirla qualsiasi gioca col bottone il semaforo passi da verde su una via trafficata a giallo lampeggiante, che dopo diventa difficile decidere chi ha torto e chi ha ragione nell'incidente che certamente avverra

basta pensarci un attimo, e diviene chiaro che occorre evitare che da verde passi di colpo a lampegginate

da verde deve sempre passare a giallo e poi rosso, il modo di funzionamneto del semaforo deve cambiare solo con tutti i veicoli FERMI al rosso altrimenti chi glielo spiega all'automobilista che è entrato nell'incrocio col verde che siccome è scattato il servizio notturno doveva dare la precedenza a destra ed è colpa sua dell'incidente provocato?

chiarito questo analogo discorso per i pedoni la sorveglianza del pulsante del passaggio pedoni è questa:

// prenotazione pedone

if (!digitalRead(PUL)){
  // pulsante premuto
  chiamata=1;
    digitalWrite(CHI,HIGH);
    // accendo il led di segnalazione chiamata prenotata
   
  
  }

che oltre a leggere il pulsante accende anche la segnalazione di chiamata prenotata, così il pedone non ci massacra il pulsante........

e al doppio rosso successivo....

if (chiamata){
  // chiamata pedone
  if (stato==1){
    // doppio rosso di inizio sequenza
    chiamata=0;
    // do la chiamata per soddisfatta
    stato=7; // inizio sequenza pedone

    digitalWrite(CHI,LOW);
    // spengo il led di segnalazione chiamata prenotata
    
    }
  
  
  }

per poi eseguire il passaggio a pedone al termine del doppio rosso

la sequenza di pedone termina con una chiamata alla sequenza zero, riattivando automaticamente il ciclo normale del semaforo

questo ha anche il vantaggio di evitare che il pirla di pedone di trno continui a fermare il semaforo giocando col bottone

dopo una chiamata pedonale il semaforo esegue sempre e comunque almeno un ciclo altrimenti i semafori messi all'uscita di scuole o manicomi non lascerebbero passare mai nessuna auto

poco rimane ormai

// lampeggio del giallo pedone, vale come buzzer per i ciechi
  if (buzzer){
    digitalWrite(PPG,digitalRead(SEG));
    //SEG lampeggggia già di suo, inutile inventare l'acqua calda.....
    
    
    }

che fa lampeggiare il verde pedonale negli ultimi secondi, vale come giallo per i pedoni e per un eventuale buzzer per i ciechi

rimane da dire che non lo ho ancora debuggato

ci metto di meno a scrivere il rpogramma che attaccare i led

comunque compilare compila al monitor seriale lo stato del semaforo cicla il led 13 lampeggia, ad indicare il funzionamento della scheda

semmai c'è qualche corrispondenza nome-piedino-colore del led da mettere a posto o cose così

nel pomeriggio vado a casa (adesso sono in ferie, e non cominciamo a dire che dalle feria vedo a casa una volta al giorno, se non volete una vita complicata non fate domande)

dicevo nel pomeriggio vado a casa e imbarco una manciata di relè e una breadboard, per provare a vedere le lucine

invece, per le malelingue che hanno subito detto che potrebbe essere necessario avere vie preferenziali con tempi differenti

dimostrano solo di non saper leggere

i tempi tra la via uno e la due erano differenti già fin dal primo post dove ne parlavo..... oltre a non capire il tag code, non sanno nemmeno leggere, che squallore..............

se qualcuno volesse seriamente, magari per un plastico, espandere il semaforo con altre vie o tempi è semplice:

basta dichiarare le nuove paline (eventualmente con una MEGA invece che una UNO) e ri-scrivere la tabella delle configurazioni possibili, scrivendole in un ciclo che parta dal doppio rosso

comunque il programma è documentato, e parimenti documentato il metodo che ho usato per scriverlo

buon pomeriggio a tutti

docsavage: ... la saggezza orientale contiene sempre un lato "oscuro", ...

Heheh ... mi fai venire in mente il vecchio "augurio" orientale ... "ti auguro di vivere in tempi interessanti" ... di solito lo si fa ai nemici ... uno potrebbe chiedersi perche' ?

Be', calma, pace, tranquillita', sono desiderabili ma non molto "interessanti" ... che c'e' di piu "interessante" ? ... vediamo, guerre, alluvioni, terremoti, carestie, pestilenze, catastrofi ... :D :D :D

io in oriente ci sono stato non fa per me

la saggezza di un popolo si misura anche da quanto riescono a risolvere i loro problemi materiali

non credo che un popolo che la mattina raccoglie i morti con la nettezza urbana (vabbe', loro usano un altro nome) abbia qualcosa da insegnarmi, credo piuttosto che abbiano sbagliato strada, molto molto tempo fa, se ne sono accorti, ma per non ammetterlo si raccontano un fracco di storie

do più credito ai cinesi, che infatti da loro stessi imitano più dapresso gli americani..........

anche questo fa pensare