Ciao a tutti, volevo sapere come si fa ad avere uno storico degli ingressi, mi spiego meglio:
Ho 9 ingressi digitali che vorrei venissero memorizzati in sequenza dentro un' array e una volta completato lo stato di tutti gli ingressi, riceverli dalla seriale.
Inizialmente Il primo degli ingressi che è a livello alto, viene scritto nella posizione "0" del' array, se il l' ingresso 6 si porta a livello alto, va nella posizione due e cosi via fino a completare la lunghezza del' array.
Credo che serve una variabile dedicata al conteggio che, dovrà essere l' indice della posizione del' array dove memorizzare il valore del' ingresso che è stato portato a livello alto. Ogni volta che un' ingresso è portato da basso ad alto, fa avanzare di uno step quella variabile contatore e quando quella variabile è = a "9", azzera l' arry e invia lo stato tramite seriale.
Potete aiutarmi a capire se la logica è corretta oppure suggerendomi come fare?
Grazie 
La logica sembra corretta. Il codice di seguito è più o meno quel che ti serve (non testato):
#define N 9
byte inputs[N];
int next = 0;
loop () {
for (byte i = 0; i < N; ++i) {
if (digitalRead (i) && next < N)
inputs[next++] = i;
}
if (next >= N) {
for (byte i = 0; i < N; ++i) {
Serial.println (inputs[i]);
}
next = 0;
}
}
Gentilissimo , sto cercando di capirlo...
"N" è la costante che definisce il numero massimo del' array che in questo caso è settata a "9"
poi si definiscono le due variabili input e next
(input per la posizione degli ingressi, next per lo step avanzamento posizione array)
Nel loop parte il ciclo di for che fa la lettura degli ingressi digitali sui pin che vanno da 1 a 9
poi se la condizione che la variabile dedicata al conteggio (next) è maggiore o uguale a 9 (N), stampa e riazzera la variabile conteggio.
Corretto?
Rivedendo il codice, mi sembra di capire che viene scritto lo stato degli ingressi su array in relazione alla loro posizione. non deve essere in questo modo se fosse cosi.
il ciclo prende il primo ingresso e lo memorizza nella prima posizione, il secondo ingresso nella seconda e cosi via. Ho capito bene?
edstarink:
Nel loop parte il ciclo di for che fa la lettura degli ingressi digitali sui pin che vanno da 1 a 9
No, va da 0 a 9. Se i pin che devi leggere sono altri puoi aggiungere un ulteriore array in cui metti i numeri dei pin corretti nell'ordine che vuoi.
poi se la condizione che la variabile dedicata al conteggio (next) è maggiore o uguale a 9 (N), stampa e riazzera la variabile conteggio.
edstarink:
Rivedendo il codice, mi sembra di capire che viene scritto lo stato degli ingressi su array in relazione alla loro posizione. non deve essere in questo modo se fosse cosi.
il ciclo prende il primo ingresso e lo memorizza nella prima posizione, il secondo ingresso nella seconda e cosi via. Ho capito bene?
No, li salva nell'ordine in cui li trova HIGH. Se diventano HIGH nell'ordine 2 5 1 4..., li trovi nell'array in quello stesso ordine. Se ad un singolo giro ne trova HIGH più di uno, li inserisce nell'ordine di scansione.
... Non fai prima a provarlo?
Il resto sembra corretto.
Hai ragione, ma preferisco capire lo sketch prima di testarlo con arduino.
Non riuscivo a capire il discrose del HIGH...
Io lo immaginavo cosi...scusami se non è scritto in C++, ma potrebbe essere una alternativa se i pulsanti fossero 3 o quattro?
ingresso1=0
ingresso1 last=0
Dentro al Loop
se ingresso 1 è differente da digitalwreite1 + se digitalwrite1 =HIGH
ad+1 a step
memorizza nel' indice del' array(step) il valore del' ingresso 1
aggiorna ingresso1 last con ingresso1
e questo uguale per gli altri ingressi con altre variabili.
L' unica cosa che ho trovate nel tuo sketch riguardo ai digital write è questo:
if (digitalRead (i) && next < N)
ma vuol dire soltanto se l' ingresso(preso dal' indice 1) e se next è minore di N, addiziona+1 alla variabile next
Ma non trovo la parte che riguarda lo stato del digital write, non capisco come possa accadere che, alla variazione di stato di un' ingresso, venga scritto nel' array...è questo che non l' ho trovato nello sketch, scusa la mia ignoranza
Innanzitutto forse fai un po' di confusione tra digitalRead() e digitalWrite() :).
... O forse non ho capito bene io cosa vuoi fare! Cerco di commentarti il punto saliente del mio codice:
for (byte i = 0; i < N; ++i) { // Per ogni pin da 0 a 8 (N)...
if (digitalRead (i) && next < N) // ... Leggi il pin e se è HIGH (implicito)
inputs[next++] = i; // ... Salva il suo numero nella successiva posizione libera dell'array "inputs" e incrementa l'indice della prossima posizione libera
}
Forse l'if ti sarebbe più chiaro scritto così:
if (digitalRead (i) == HIGH) {
Diciamo che == HIGH è ridondante, ometterlo ha lo stesso effetto. Non che volessi confonderti, è solo questione di abitudine :). L'ulteriore controllo next < N serve a non scrivere oltre i limiti dell'array nel caso in cui, ad esempio, hai già salvato 8 elementi e al prossimo ciclo ne trovi 2 HIGH allo stesso tempo.
Ok, chiarissimo
Scusami, stavo scrivendo di fretta, digitalwrite è quello per le uscite, so la differenza, ma scrivevo di fretta perchè dovevo andare via.
Tutto il resto è chiaro...Sai che non sapevo che si poteva omettere, ecco perchè non capivo, il restante si commenta da solo.
Gentilissimo, provo su arduino e ti faccio sapere.
Grazie infinite
Leggi il registro e ne memorizzi 8 in un byte solo
Credo sia un po' troppo complesso per lui, almeno per ora :).
@edstarink, ma perché non studi?
Vuoi comunicare al pc lo stato delle porte di arduino? 3 byte a 500000 baund e deleghi le operazioni più complesse al pc che ha qualche x in più per tali calcoli.....ed hai finito ancor prima di innesscare una qualsiasi forma di ciclo loop.
Naturalmente lo studio richiede TEMPO E DEVOZIONE, per tutto il resto c'è il forum.
Perchè purtroppo non ho il tempo per farlo. Non è la solita scusante, veramente, non ho più il tempo e ho troppe cose da finire per dedicarmi solo a quello. Cerco di imparare o capire dai codici più simili alle funzioni che devo realizzare.
Non devo inviarli tramite seriale, ho detto della seriale per avere un debugger, Quei valori devono restare dentro al' arduino e gestiti in modo interno. alla fine ho deciso, sono 4 ingressi in totale:
Ogni ingresso da un valore a variabile associata es:
Ingresso 1 a valore HIGH, porta il valore della variabile statoinput 1= 1
Ingresso 2 a valore HIGHT, porta il valore della variabile statoinput 2= 2
e cosi via fino al quarto input
Completata l' arry che ha come dimensione 4, che potrebbe diventare, con la successione degli ingressi, 1324 , dovrà confrontarsi con una costante.
Se uguale...fai questo
else ...Fai altro
Ciao, finalmente sono riuscito a testare, ma mi appare una cosa strana.
Da seriale mi arrivano valori continuti, come se ci fosse una istruzione sempre valida.
Dovrei stampare i valori solo quando la variabile next è maggiore o uguale a 9
Il problema è che quella variabile looppa sempre, significa che il ciclo di for è sempre in esecuzione e non quando uno degli ingressi è stato portato in HIGH, mi aiuteresti a capire l' errore?
Grazie
#define N 9
byte inputs[N];
int next = 0;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
}
void loop () {
for (byte i = 0; i < N; ++i) {
if (digitalRead (i) && next < N)
inputs[next++] = i;
}
if (next >= 9) {
for (byte i = 0; i < N; ++i) {
Serial.println (inputs[i]);
}
next = 0;
}
}
Il for è per forza sempre in esecuzione, mica puoi fermarlo ;). Però se tutti gli ingressi sono bassi continua a ciclare senza fare niente.
Credo che il problema sia sui pin monitorati: per come è scritto monitora i pin 0-8, ma se stai usando la seriale 0 e 1 sono già impegnati da questa ed esce un gran casino :D. Quali pin ti interessano?
Veramente i pin sono 3 :-[
In realtà tutti i pin sono a livello basso, ma come hai detto tu, ci sono anche i pin 0 e 1 addetti alla seriale che dovrebbero essere liberi.
dal pin 2 al pin 4 sono quelli che mi interessano
Nello sketch manca anche la parte dedicata alla assegnazione degli ingressi che devo portare in HIGH. Utilizzo la resistenza interna di pull up di arduino.
Ma all'inizio parlavi di 9 ingressi!
Si, volevo utilizzare piu pin, ma alla fine me ne servono solo 3.
Basterebbe cambiare il valore alla costante e far partire la lettura dal pin 2 e non dal pin 0.
E io come facevo a saperlo? Comunque esatto, e sono sicuro che puoi farcela da solo ;).
Infatti, mi hai aiutato per quello che ti avevo chiesto e ti ringrazio molto
Comunque mi è chiaro quello che hai fatto, nel ciclo for, il primo pin che si porta in HIGH, scrive il numero identificativo del pin intervenuto e lo memorizza nella posizione 0 e fa aumentare di uno la variabile che tiene il posto nell' array al nuovo input ricevuto che andrà alla posizione 1, poi 2 ed infine, completato l' array, invia alla seriale il valore del' array stessa, riazzerando anche la variabile "next"
La logica è chiara, grazie infinite
@edstarink:
Perchè purtroppo non ho il tempo per farlo. Non è la solita scusante, veramente, non ho più il tempo e ho troppe cose da finire per dedicarmi solo a quello. Cerco di imparare o capire dai codici più simili alle funzioni che devo realizzare.
Nemmeno io ho il tempo di respirare, ma faccio il possibile per imparare nuove cose, mi porto sempre dietro il libro che sto leggendo e alla prima occasione lo leggo, mo che vado a fare la caccona, mo prima che mi addormenti, 5 minuti riesco sempre a trovarli.
Quindi è l'n-sima scusa di chi vuole la pappa pronta.
E poi invece di perdere tempo a fare cio che non sai fare, perche non studi così dopo ci metti meno tempo?
Bha.....
In effetti hai ragione, oggi per esempio ho stampato un sacco di pagine, non ho difficoltà a capire, ma ho difficoltà a mettere tutto insieme. Sarà perchè per fare una cosa, ci sono svariate possibilità e non c'è una vera regola da seguire. Se non ti rivolgi ad un forum oppure se non hai un' amico che ti assiste e ti corregge sugli errori, non è facile. Comunque hai ragione tu e seguirò il tuo consiglio