debug Arduino

Ciao,

ho realizzato un parser in arduino che rimane in ascolto sulla porta seriale, riceve byte li elabora e produce un output.

tutto sembra funzionare abbastanza bene ma ancora non ci siamo, certi valori in uscita non mi tornano.

C'è un modo per monitorare arduino e vedere cosa elabora e produce in uscita?

PS: è sempre il mio progetto del pannello led, pur inviando i dati corretti(da processing ho l' output in decimale dei valori inviati e tornano) ho dei problemi su arduino visto che non mi accende correttamente i led, su 3 righe(con 3 led ciascuna) solo una mi funziona correttamente, suppongo che sia solo un problema del parser.

Saluti Q

se cambi discussione sullo stesso argomento risulta difficile seguirti.

Non so se hai notato che in questo forum non c'è molta gente che partecipa... io, sino a quando non mi stancherò di questa desolazione, proverò a rispondere, ma non è detto che le mie risposte siano le migliori... (adesso, però, è: o così o ciccia 8-) )

Tornando al tuo problema: se non ho capito male stai usando il MAX7219, e se ti funziona solo una "riga" direi che il problema lo hai nella definizione dell'indirizzo del digit. La cosa migliore è che tu posti sia la parte di programma che devi verificare, sia il modo in cui hai collegato la matrice di led con il max (a quali segmenti e a quali linee comuni del catodo). Per verificare il funzionamento di arduino (come ho già scritto anche in un altro post), puoi farti inviare i valori che invii al max anche su seriale, così hai un feedback di quello che accade...

si ho notato anch' io un po di desolazione. mi dispiace se ho aperto duemila post ma essendo alla prima esperienza con arduino si son verificati problemi di vario genere :]

Ho provato con il feedback in seriale, ricevo un dato ma non mi torna il risultato sinceramente, penso che il problema sia nel parser(ne sion quasi sicuro).

invio 10 byte dei quali 2 di controllo e 8 per pilotare le righe, il problema obvviamente è che per le righe ho bisogno dei numeri da 0 a 255 8 bit e così facendo nn mi rimangono più bit per il controllo(inizio e fine trasmissione). é possibile inviare prendere dei segnali di controllo dalla seriale che non siano parte dell' informazione stessa? Ora invio byte, alcuni sono di controllo altri contengono informazioni, tutti comunque sono dati inviati singolarmente, sia quelli di controlo che le informazioni vere e proprie.

ovviamente ho subito pensato a splittare il byte anche se non so come e se possibile vorrei evitarlo sino all' ultimo visto che mi viene davvero comodo avere direttamente il byte da passare al max7219

questo cmq è il codice http://pastie.caboo.se/125890

grazie come al solito per l' aiuto :]

Q

l'indirizzo che mi hai postato per vedere il codice non mi funziona...

si dev' essere pastie che ha qualche problema.

comunque niente di eccezzionale, il problema son sicuro che è nel parser.

mi son riguardato il primo post dove mi dicevi anche come fare con i nibble solo che ho qualche dubbio.

io ho pensato a prendere 4 bit(dati) alla volta, mandarli nelle ultime 4 posizioni e usare le prime quattro per i caratteri di controllo. E' questo che intendevi anche tu?

nei 4 bit di controllo pensavo di inserire oltre ai token di inizio e fine riga anche informazioni relative alla posizione/ordine del nibble(alta o bassa), un identificatore per pilotare il relativo pannello(nel caso di più pannelli collegati insieme), per quanto riguarda il numero di riga relativa a quel byt(i nibble ricomposti) pensavo di usare l' ordine di arrivo sperando nn mi vada tutto a cazzi, anche se ho già pensato di mettere un controlle che nel caso i byte siano meno di 8(8 righe) setto la posizione mancante a zero giusto per evitare degli stuck, ovviamente così facendo la configurazione del pannello avrebbe una o più righe sbagliate ma se lo uso con un certo resfresh mi sembra una buona soluzione.

che ne pensi di questo?

http://pastie.caboo.se/125946 pastie sembra funzionare ora.

il problema adesso è che arduino mi salva solo il primo stream di byte(10), quelli che vengono dopo non li salva e non riesco davvero a capire il perchè.

es(solo 4 byte):

se mando A 129 195 Z e poi A 000 000 Z lui mi prende solo 129 e 195, quelli che vengono dopo non li salva. ho controllato tutti i contatori e sembrano andar bene, non riesco davvero a capire

Allora, la prima cosa che io modificherei è la definizione della variabile SerIn da int a unsigned char (per non avere problemi di conversione o quando usi gli operatori binari << e >>)
Poi, come ti avevo già indicato, temo che se non sommi ai valori = 0 (nel tuo caso A 000 000 Z) almeno un 0x10 (ovvero un 16 in decimale) al nibble che invii, temo che la gestione seriale non lascia passare nulla, perchè per convenzione in C le stringhe terminano sempre con il valore \0 (ovvero 0x00), e quindi i tuoi due byte vengono considerati solo come due stringhe nulle (vuote).

Questo è quello che posso dirti guardando solo il codice che riceve… sei certo di inviare ad Arduino i dati cortetti (con i nibble divisi e sommati ad un valore minimo)?

mmmm

mi sa che o io o te non abbiamo capito.

allora i dati da processing direi che sono corretti tant'è che alla prima passata arduino me li rimanda indietro correttamente.

io ho fatto così:

i primi 128 li uso per i caratteri di controllo.

i nibble li distinguo in base al range, al primo gli sommo 128 al secondo 192(128+64) visto che tanto il nibble ha un valore massimo di 15 in decimale, giusto?

fatto sta che invio il token di inizio comunicazione "S" come byte, invio tutti e sedici i nibble e per finire inzio "Z" il mio token di fine comunicazione.

su arduino li leggo e li spedisco indietro così come sono senza elaborarli, uso questa funzione di test solo per vedere cosa riceve arduino. ovviamente ho cercato di eliminare qualsiasi altra funzione in modo tale da avere solo una funzione echo e nient' altro, ho controllato i contatori che gestiscono il salvataggio dei nibble e i valori mi ritornano, ho incominciato a pensare che il problema fosse su processing ma non fa altro che inviare dati e leggerli sulla seriale stampandomeli quindi li errori non ce ne sono, svolge correttamente il proprio compito, pensavo che magari era solo processing che nn mi aggiornava i risultati ricevuti ma quello che stampa è quello che riceve, non passo per nessuna variabile quindi il dato è quello.

di seguito ti lascio un esempio di comunicazione e il link al codice di processing, ancora una volta ti ringrazio sperando di poter ricambiare il favore il prima possibile.

questo è il codice su processing http://pastie.caboo.se/126002

un esempio di comunicazione:

Stable Library

Native lib Version = RXTX-2.1-7 Java lib Version = RXTX-2.1-7 [0] "/dev/ttyUSB0" [1] "/dev/ttyS0" S intValue: 1 // il valore del primo nibble della prima riga nibble 1: 129 // il valore del primo nibble della prima riga MANIPOLATO E INVIATO nibble 2: 192 // il valore del primo nibble della prima riga MANIPOLATO E INVIATO debug: 83 129 // il valore del primo nibble della prima riga inviato da ARDUINO e ricevuto da PROCESSING 192 // il valore del secondo nibble della prima riga inviato da ARDUINO e ricevuto da PROCESSING 128 192 128 192 128 192 128 192 128 192 128 192 128 192 90 0 è vuoto perchè l'array che contiene i dati ricevuti in arduino è di 20, 16 nibble + 2 di controllo + 2 vuoti 0 nibble: 1 counter1: 8 counter2: 8

// INVIO SECONDA CONFIGURAZIONE(il comportamento è lo stesso per tutte le successive) S 128 192 intValue: 0 la configurazione è cambiata, il valore è 0 nibble 1: 128 il primo nibble infatti vale 0 +128 nibble 2: 192 debug: 83 129 QUI IL SINTOMO DEL PROBLEMA, dovrebbe restituire 128(0+128) invece restituisce 129 ovvero il valore della precedente configurazione inviata 192 128 192 128 192 128 192 128 192 128 192 128 192 128 192 90 0 0 nibble: 1 counter1: 8 counter2: 8

ora che ci faccio caso però ho notato un' anomalia

S 
intValue: 1
nibble 1: 129
nibble 2: 192
debug: 83
129
192
128
192

al primo invio e solo a questo, S non è seguita dai due nibble che tra l'altro non sto capendo nememno da dove li stampa, mi sono un' attimo incasinato comunque quella è l' unica anomalia che ho riscontrato. che ne pensi?

Andrea

** ho ricontrollato e sistemato il codice in processing e non fa una piega, tutto funziona, è arduino il problema.

ps: hocambiato serIn da int ad unsigned char e non è cambiato nulla, per l'altro problema dello zero direi che non è il mio caso come vedi il valore minimo è 129, basta che non uso il carattere di controllo 0x00 e sono a posto no?

Hai ragione … ti ho risposto in modo un po troppo “frettoloso”, scusami.
Veniamo al dunque, ho provato con il tuo codice a spedire una serie di valori con il software di Arduino (abilitando la seriale e scrivendo ogni singolo valore) sotto forma di codici ascii e mi pare che il tutto funzioni come vorresti, o no?

questo è il risultato del mio test:

invio: A, a, a, a, a, a, a, a, a, a, a, Z
torna:
65
97
97
97
97
97
97
97
97
97
97
90
0
0
0
0
0
0
0
0
nibble:
0
counter1:
0
counter2:
0
----
invio: A, b, b, b, b, b, b, b, b, b, b, b, Z
torna:
65
98
98
98
98
98
98
98
98
98
98
90
0
0
0
0
0
0
0
0
nibble:
0
counter1:
0
counter2:
0

qual’è l’errore che riscontri?

no, funziona solo il primo blocco di byte, quelli che vengono dopo non li legge, sto cercando di capire cosa fa esattamente perchè mi ha confuso, ho spostato un po di codice in modo tale da far stampare sulla seriale diretettamente da SerialParser, ho inserito anche un contatore per vedere quanti passaggi fa e praticamente mi restituisce 18, 16 nibble + due di controllo, la cosa strana è che pur non incrementando il contatiore stampo comunque dati sulla seriale e mi sembra incredibile visto che se stampa sulla serie dovrebbe aver già incrementato il tutto comunque ormai se ne riparla lunedì, in mattinata ho l' ultimo esame e almeno il pomeriggio prima vorrei studiacchiare.

fammi sapere se ti viene in mente qualche cosa, a me sembra che il problema sia nel ciclo while che controlla la seriale, forse non lo prende solo una volta

ho provato a togliere davvero tutto mantenendo solo una funzione di echo(ora sestituisce solo 3 caratteri) e non ho ancora risolto il problema, la variabile recived viane popolata solo al primo passaggio, per i successivi non viene più modificata pure comunque ritornando dei valori via seriale(quelli del primo passaggio, sempre e solo loro)

unsigned char  SerIn = -1;
byte  recived[18];
int k = 0;
boolean readyToSend;

void setup() {
  Serial.begin(115200);
  k = 0;
  readyToSend = false;
}


void loop() {   
  if(readyToSend){
    readyToSend = false;
    for(int h=0;h<3;h++){
      Serial.print((int)recived[h]);
    }
  }
  SerialParser();
}



void SerialParser(void) {
  while (Serial.available()) {  
    SerIn = '@';
    SerIn = Serial.read();
    recived[k] = SerIn;
    k++;
    
    if (SerIn == 90 || SerIn == 10 || SerIn == 13) {  
      readyToSend = true;
      break;     
    }
  }
}

per farlo più essenziale di così dovrei togliere la connessione seriale, quindi dove sto sbagliando? perchè non mi continua a riempire la variabile recived ad ogni passaggio?

Prova se così ti funziona:

unsigned char  recived[18];
unsigned int k = 0;
boolean readyToSend = false;

void setup() {
  Serial.begin(115200);
}

void loop() {   
  if(readyToSend){
    readyToSend = false;
    for(int h=0; h < k ; h++ ){  //qui limitavi il loop a 3, motivo?
      Serial.print((int)recived[h]);
    }
  }
  k = 0; //resetto l'indice del buffer!
  SerialParser();
}

void SerialParser(void) {
  while (Serial.available()) {  
    recived[k] = Serial.read();
    if (recived[k] == 90 || recived[k] == 10 || recived[k] == 13) {  
      readyToSend = true;
      break;      
    }
    ++k;
  }
}

Come vedi, rispetto al tuo codice, oltre a una semplificazione e ad un risparmio in variabili inutili (ricorda che con Arduino di memoria ram ne abbiamo molto poca!), ho corretto la gestione dell’indice del buffer (k), che torna dalla ricezione con il numero di byte ricevuti.

Comunque, io credo che la cosa migliore sia che tu invii sempre un numero determinato di byte, senza codice di inizio o fine. In fondo, il collegamento avviene solo tra i due dispositivi, e quindi non c’è possibilità di dover sospendere la comunicazione per lasciare la linea ad altri servizi (unico caso nel quale vedo la necessità di un protocollo).

Poi, se implementi un protocollo, devi prevedere anche un controllo sul checksum (tipo una xor di tutti i byte trasmessi) per i casi di “rumore” nella trasmissione, altrimenti è del tutto inutile farlo, giusto?

Spero di esserti stato utile :slight_smile:


:o piccola correzione:

for(int h=0; h <= k ; h++ ){

h <= k perchè esce dal loop while con break prima dell’incremento dell’indice ::slight_smile:

il tuo codice non funziona comunque avevo notato anch'io l' indice e l'avevo già sistemato, ho provato anche a fare il Serial.flush() dopo l' invio e quindi prima della ricezione dei nuovi dati ma niente, continua a mandarmi solo i primi valori che ha ricevuto. mi sembra davvero assurda come cosa, cioè o li legge e li legge tutti o non li legge.

... allora credo proprio che il problema non sia nel codice che scrivi ma in quello che gestisce la comunicazione.

Ha già letto in proposito quello che scrivono qui: http://www.arduino.cc/playground/Code/SimpleMessageSystem

non riesco a capire, i dati li riceve non è che non li riceve.

mi sembra di complicarmi la vita e di molto usando il simple message system, inoltre altri due tipi che han fatto una cosa simile non la usano, dev' esserci per forza un problema nel codice di arduino

quello che però non capisco è perchè le prove che faccio io qui a me vanno a buon fine...

Vuoi dire che per aiutarti mi tocca installare Processing per verificare il tutto con il mio hardware? :-?

Sei sicuro di non avere problemi con la seriale (o USB che dir si voglia?) Sei sotto winzoz o OsX/Linux ? Con winzoz il controllo delle risorse è un terno al lotto, lo sai vero? basta che ci sia un piccolo conflitto tra driver e gli incubi sono infiniti :'(

ora mi mangio la tastiera :o

ho trovato il problema, era in processing o almeno sembra

il ciclo while per leggere sulla seriale non riusciva più a rientrare dopo la prima lettura e nn mi svuotava la variabile, ora ne ho messo uno che funziona anche se sfasato però i risultati tornano, devo solo risolvere una cosuccia ma è solo in processing, 3 giorni per risolvere sta cosa pazzesco, voglio spararmi!

Bene!!! sono contento che tu abbia risolto ;) Comunque sia, almeno ti sono stato di aiuto nel mantenere i nervi sotto controllo... ;D .. e poi, anche il piacere di esserci conosciuti, giusto?

Comunque, io, se posso esserti utile, sono disponibile, anche se non credo che continuerò a frequentare questo desolatissimo e deprimente forum :-/ (hai visto in quanti hanno letto il mio post e non hanno risposto?)

Nel caso, mi rintracci anche come kokiua [at] gmail.com

Ciao e pensa al tuo esame!

nieè ufficiale, funziona tutto ddaasddsaasdasddasadsasd ora sono in grado di pilotare ogni singolo led e nn c’è nessun errore, figata!

cmq grazie mille, spero di ricambiare il piacere quanto prima.