Show Posts
Pages: 1 2 [3] 4 5 ... 17
31  International / Software / Re: convertire un intero in una stringa ... on: January 23, 2013, 02:44:25 am
tux.....

non sono riuscito a farlo funzionare.. mi sà che esige un vettore di char ....

invece fuzniona bene String(intero);
non sono riuescito invece a fare questo
String keyPIN;
keyPIN = "0" + String(intero);  e non capisco perchè non dovrebbe concatenare le due stringhe??

neanche questo funzione
keyPIN.concat ("0", keyPIN); .. divrebbe unire al primo 0 la stringa keyPIN e rimettere tutto in keyPIN ... ma non funge...
suggerimenti????




32  International / Software / Re: convertire un intero in una stringa ... on: January 22, 2013, 10:56:08 am
Quote
ma cosè quel %05d????

Ma solo a me viene in mente di cercare su google ?
smiley-sweat

... cavolo mi sa che fà già la formattazoine come la voglio io!!!! ..

interessantissimo... posso formattare anche diversi dati in un unico output....

prima non gli ho dato molto peso a questa ipotesi di soluzoine perchè non l'avevo capita.. mi sembrava più semplice itoa .....


grazie .. e scusa!!!!
33  International / Software / Re: convertire un intero in una stringa ... on: January 22, 2013, 10:15:24 am
Ma scrivere String A=(String)numeroInt; non va?
Non saprei Pablos... non l'ho provato.. stasera provo, anche se, a questo punto, non è più importante visto che la ìconversoine la faccio!!! ... non ho problemi di tempo.. in quanto è una funzoine che viene richiamata una volta ogni qualche settimana .....

Posto che il tempo di esecuzione non sia un problema, potresti usare:
Code:
sprintf(buf, "%05d", numero);

... anche per questo.. stasera provo... ma anche se non funzoinasse nessun problema ... ma cosè quel %05d????

grazie comunque.... ma non mi avete suggerito come anteporre alcuni zeri alla stringa originata ...

gli zeri dovrebbero essere in numero pari a 6 - keyPIN.length()


34  International / Software / Re: convertire un intero in una stringa ... on: January 22, 2013, 08:36:26 am
Grazie... ho fatto così e funzione:

definito
int intPIN = 123;  // il pin in formato numerico int
char bufferPIN[6];
String keyPIN;


e nella funzione
keyPIN = itoa(intPIN, bufferPIN, 10));

e funziona bene.... senza dover modificare nulla del codice già esistente e funzionante...
ho capito che ha bisogno del buffer, anche se solo in modo temporaneo.... ma và bene così...


adesso ho questo problema, vorrei aggiungere degli zero quando la lunghezza della stringa è inferiore a 5 elementi...
cioè
il PIN potrà essere
65535 e convertito in stringa sara "65535".. ovvero se il PIN (impostato nella EEpROM) fosse, per esempio, 123... la conversione dovrà rendere "00123" .. quindi sempre composto da almeno 5 char...

pensavo di leggere la lunghezza della stringa e poi non mi è ben chiario come "concatenare", uno, due o tre zeri davanti....

come mi suggerite di fare per aggiungere qualche zero all'inizio della stringa???

grazie

35  International / Software / Re: convertire un intero in una stringa ... on: January 21, 2013, 03:09:12 am
grazie tux...

adesso non sono davanti all'ide ed al micro... ma se scrivessi così:

String  stringa;
int intero = 123;

stringa = sprintf(intero);

dovrebbe funzionare?????
36  International / Software / convertire un intero in una stringa ... on: January 21, 2013, 02:31:48 am
salve...

avrei bisogno di convertire un intero (0- 65535) ... nella stringa corrisponente...

tralasciamo gli zero iniziatli che potrei aggiungere dopo.... insomma se ho 123 come int. devo convertirlo in una stringa "123".... come potrei fare?

cè una funzione diretta che faccia questo ?
grazie
37  International / Hardware / Re: Usb seriale con atmega328p standalone on: January 20, 2013, 04:25:34 am
io lo uso regolarmente e funzina benissimo per programmare il 644 così:
RX del convertitore ----> pin 14 (RXD0) del 644 :
TX del convertitore ----> pin 15 (TXD0) del 644:
DTR del convertitore ---> pin 9 (RESET) del 644: interrotto con un condensatore ceramico da 100K pF, ma ho riscontrato che anche
molto diversi va bene comunque ....
naturalmente + 5V e GND dal convertore al 644 ...

dovresti solo trovare i pin RX e tx del 328 quindi:
RX del convertitore ----> pin PD0 (RXD) del 328:
TX del convertitore ----> pin PD1 (TXD) del 328:
DTR del convertitore ---> pin 9 (RESET) del 328: interrotto con un condensatore ceramico da 100K pF, ma ho riscontrato che anche
molto diversi va bene comunque ....
naturalmente + 5V e GND dal convertore al 328 ...


non ho provato sul 328 ma io farei così....
ciao
38  International / Software / Re: ... inserire lo stesso blocco di codice in due schetc on: January 14, 2013, 02:46:17 pm
grazie ... uwe, leo ed astro..

che vuol dire che il file.h deve contenere i prototipi delle funzioni ... io le ho messe nel file.cpp ...
quindi ho creato la catella ComSer ... in librerie ..

dentro ci ho messo
ComSer.h con questo contenuto;

Quote
#define dimVettore 25  
#define baudSeriale  4800
char charRX[dimVettore+1];
char charTX[dimVettore+1];
boolean stringaRX_OK = false;
boolean decode = false;

poi ho creato il file ComSer.cpp e dentro ci ho messo questo...
Quote
void analizzaStringa ()
{
  stringaRX_OK = false;
  decode = false;
  
 if (charRX[0] >= 11) //  il messaggio ricevuto supera la lunghezza minima
    {  
        switch (charRX[7]) // byte in posizione 7
        {
        case 'A': //interrogazione tipo A
             switch (charRX[8]) // byte in posizione 8 ... tipo di interogazione o di comando
            {    
             case 'A': // interrogazione tipo AA ... lettura della modalità di funzionamento richiesta
             AA (); decode = true;
             break;
            
             case 'B': // interrogazione tipo AB ... lettura del tipo di modalita impostata al momento
             AB (); decode = true;
             break;

             case 'C': // interrogazione tipo AC ... lettura dei tempi di ritardo sulla coda dei 4 tx (t1, t2, t3, t4) in mS
             AC(); decode = true;
             break;
            }
        break;

        case 'B': //comando tipo B
            switch (charRX[8]) // byte in posizione 8 ... tipo di interogazione o di comando
            {
             case 'A': // comando tipo BA .... modifica e imposta i dati di funzionamento relativi ad una modalita' richiesta
             BA(); decode = true;
             break;
            
             case 'B': // comando tipo BB .... setta ed imposta il funzionamento alla modalità n ...
             BB (); decode = true;
             break;
            
             case 'C': // comando tipo BC ... imposta i tempi di ritardo sulla coda dei 4 tx (t1, t2, t3, t4) in mS
             BC (); decode = true;
             break;                
            }
        break;
        
        case 'C': //comunicazione: ricevuto ok
        C1 (); decode = true;
        break;
        }

    if (!decode) // non è stato decodificata alcuna richiesta
        {
         C0 (1);
        }  
    }
 else //  non ci sono i caratteri minimi necessari
    {
     C0 (2);
    }
}



void AA() // interrogazione tipo AA ... lettura della modalità di funzionamento trasmessa nel byte 9
{
 // il pattern è memorizzato nei byte 8 e 9 della eeprom, precisamente: address_start byte 8, mode_pattern al byte 9 ..... i varia da 1 a 3
 // EEPROM.write(address_start + (mode * mode_pattern ) + (i-1) * 4 + 0, busy );
 // EEPROM.write(address_start + (mode * mode_pattern ) + (i-1) * 4 + 1, azioneA );
 // EEPROM.write(address_start + (mode * mode_pattern ) + (i-1) * 4 + 2, azioneB );
 // EEPROM.write(address_start + (mode * mode_pattern ) + (i-1) * 4 + 3, azioneC );
 // compilo il vettore di dati da spedire come risposta
 charTX[7]  = 'C'; //stringa contenente una risposta
 charTX[11] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 0); // busy1   ..... 1° byte della risposta ....
 charTX[12] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 1); // azioneA1
 charTX[13] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 2); // AzioneB1
 charTX[14] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 3); // AzioneC1
 charTX[15] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 0); // busy2
 charTX[16] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 1); // azioneA2
 charTX[17] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 2); // AzioneB2
 charTX[18] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 3); // azioneC2
 charTX[19] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 2 * 4 + 0); // busy3
 charTX[20] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 2 * 4 + 1); // azioneA3
 charTX[21] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 2 * 4 + 2); // AzioneB3
 charTX[22] = EEPROM.read(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9) ) + 2 * 4 + 3); // azioneC3 ..... ultimo byte della risposta ....
 charTX[0]  = 22; //inserisce la posizione dell'ultimo byte usato
 invia_charTX ();
}

void AB () // interrogazione tipo AB ... lettura del tipo di modalita impostata
{
 // compilo il vettore di dati da spedire come risposta
 charTX[7]  = 'C'; //stringa contenente una risposta
 charTX[11] = EEPROM.read(5); // mode_repeater
 charTX[0]  = 11; //inserisce la posizione dell'ultimo byte usato
 invia_charTX ();
}

void AC ()
{
 charTX[7]  = 'C'; //stringa contenente una risposta
 charTX[11] = EEPROM.read(10); // byte basso t1
 charTX[12] = EEPROM.read(11); // byte alto  t1
 charTX[13] = EEPROM.read(12); // byte basso t2
 charTX[14] = EEPROM.read(13); // byte alto  t2
 charTX[15] = EEPROM.read(14); // byte basso t3
 charTX[16] = EEPROM.read(15); // byte alto  t3
 charTX[17] = EEPROM.read(16); // byte basso t4
 charTX[18] = EEPROM.read(17); // byte alto  t4
 charTX[0]  = 18; //inserisce la posizione dell'ultimo byte usato
 invia_charTX ();
}

void BA () // comando tipo BA .... imposta i dati di funzionamento relativi alla modalita' trasmessa al byte 9 ... i byte da impostare sono contenuti nei byte dall'11 al 22
{
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 0, charRX[11] ); // busy1
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 1, charRX[12] ); // AzioneA1
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 2, charRX[13] ); // AzioneB1
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 3, charRX[14] ); // AzioneC1
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 0, charRX[15] ); // busy2
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 1, charRX[16] ); // AzioneA2
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 2, charRX[17] ); // AzioneB2
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 3, charRX[18] ); // AzioneC2
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 2 * 4 + 0, charRX[19] ); // busy3
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 2 * 4 + 1, charRX[20] ); // AzioneA3
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 2 * 4 + 2, charRX[21] ); // AzioneB3
 EEPROM.write(EEPROM.read(smiley-cool + ((charRX[9]-65) * EEPROM.read(9)) + 2 * 4 + 3, charRX[22] ); // AzioneC3
 //costruisco la risposta di conferma
 charTX[7] = 'C'; // stringa contenente un messaggio di risposta
 charTX[8] = 'B'; //  
 charTX[9] = 'A'; //
 charTX[10] = 1;  // conferma ricezione comando tipo BA
 charTX[0]  = 10; // inserisce la posizione dell'ultimo byte usato
 invia_charTX ();
}

void BB() // comando tipo BB .... imposta il funzionamento sulla generica modalità di funzionamento trasmessa al byte 9 ...
{
 EEPROM.write(5 ,charRX[9]-65 ); // sull'indirizzo 5 della eeprom imposta la modalità operativa ...
 //costruisco la risposta di conferma
 charTX[7] = 'C'; // stringa contenente un messaggio di risposta
 charTX[8] = 'B'; //  
 charTX[9] = 'B'; //
 charTX[10] = 1;  // conferma ricezione comando tipo BB
 charTX[0]  = 10; // inserisce la posizione dell'ultimo byte usato
 invia_charTX ();
}

void BC () // comando tipo BC ... imposta i tempi di ritardo sulla coda dei 4 tx (t1, t2, t3, t4) in mS
{
 EEPROM.write(10, charRX[11]); // byte basso t1
 EEPROM.write(11, charRX[12]); // byte alto  t1
 EEPROM.write(12, charRX[13]); // byte basso t2
 EEPROM.write(13, charRX[14]); // byte alto  t2
 EEPROM.write(14, charRX[15]); // byte basso t3
 EEPROM.write(15, charRX[16]); // byte alto  t3
 EEPROM.write(16, charRX[17]); // byte basso t4
 EEPROM.write(17, charRX[18]); // byte alto  t4
 //costruisco la risposta di conferma
 charTX[7] = 'C'; // stringa contenente un messaggio di risposta
 charTX[8] = 'B'; //  
 charTX[9] = 'C'; //
 charTX[10] = 1;  // conferma ricezione comando tipo BC
 charTX[0]  = 10; // inserisce la posizione dell'ultimo byte usato
 invia_charTX ();
}

void C1 () // conferma di ricezione/esecuzione dell'ordine
{
}


void C0 (int i) //  non ci sono i caratteri minimi necessari
{
 //costruisco la risposta di errore di invio
 charTX[7] = 'C'; // stringa contenente un messaggio di risposta
 charTX[10] = 0;  // comunica errore di ricezione nell'ultimo invio di dati
 charTX[11] = i;  // contiene 1 o 2 a seconda di cosa ha generato l'errore
 charTX[0]  = 11; // inserisce la posizione dell'ultimo byte usato
 invia_charTX ();
}


... poi nello schetch ho cercando di richiamare tutto cioò mettendo questo alll'inizio:
Quote
#include <EEPROM.h> //needed to save settings in EEPROM
#define ComSer.h

.. ma non funge nulla .....

39  International / Software / Re: ... inserire lo stesso blocco di codice in due schetc on: January 14, 2013, 06:24:05 am
mumble .. mumble!!!! ... la programmazoine ad oggetti con me non và molto d'accordo!!!!
.. ma grazie Leo....
40  International / Software / Re: ... inserire lo stesso blocco di codice in due schetc on: January 13, 2013, 03:48:49 pm
grazie astro, innanzitutto ti chiedo scusa per il disturbo ... ma non ho capito bene.....

io devo includere la definizione di alcune variabili e una decina o poco più di funzioni che devono essere eguali nei due schetch ... ma non ho capito bene come fare.

... devo creare sia un file.h che un file.cpp??? ... non ho capito bene... e neanche la particolarità di define rispetto ad include....
mi puoi postare un link ove trattano questi agomenti, per favore????.

41  International / Software / ... inserire lo stesso blocco di codice in due schetc on: January 13, 2013, 01:01:31 pm
... salve... dovrei inserire lo stesso identico blocco di codice in due microcontrollori .... come posso fare???'''
Dovrebbe essere la stessa tecnica per la costruzione di  una libreria.. anche se non è esattamente una libreria, quella che devo caricare!!!

.. devo caricare il codice per la comunicazione seriale tra due micro e, per evitare di fare copia incolla,  e per avere sempre aggiornati gli schetc per ciascuno dei due micro vorrei fare un <include> che porta dentro di ciascuno schetc  esattamemte lo stesso blocco di codice... mi date qualche dritta?
Grazie
42  International / Software / Re: Comunicazione seriale tra due microcontrollori .. on: January 13, 2013, 10:04:06 am
... wee gingardu.. ci sei o non ci sei ????? ...

... ho sviluppato un'altra parte.
innazitutto ho modificato la mappatura della stringa interrogazione/comando , usando questo schema:
Code:
/* MAPPATURA STRINGA DATI
byte 0 - lunghezza max del vettore-buffer, (n: numero di byte - caratteri di cui si compone la stringa dati)
byte 1 - ID destinatario (0 - 128) (al momento inutilizzato)
byte 2 - ID mittente (0 - 128) (al momento inutilizzato)
byte 3 - PIN prima parte, per riconoscere il comando/interrogazione (al momento inutilizzato)
byte 4 - PIN seconda parte, per riconoscere il comando/interrogazione (al momento inutilizzato)
byte 5 - inutilizzato (al momento inutilizzato)
byte 6 - inutilizzato (al momento inutilizzato)
byte 7 - COMANDO/DISPOSIZIONE (A: interrogazione;     B: comando;     C: invio dati; )
byte 8 - COMANDO/DISPOSIZIONE, sotto categoria di quanto specificato al byte 7
byte 9 - COMANDO/DISPOSIZIONE, sotto categoria di quanto specificato al byte 8
byte 10 - al momento utilizzato in ricezione facendo (-65) .. così uso un carattere ascii per ricevere un numero <33
byte 11 - inizio sequenza del comando\dispositivo, 1 byte
byte 12 - continuo sequenza del comando\dispositivo, 2 byte
byte 13 - continuo sequenza del comando\dispositivo, 3 byte
... ...
... ...
byte n-2 - penultimo byte della sequenza comando\dispositivo, n-2'esimo byte
byte n-1 - ultimo byte della sequenza comando\dispositivo, n-1'esimo byte
byte n   - checksum (al momento inutilizzato), n'esimo byte
*/

lo sviluppo lo sto facendo interrogando il micro inviandogli una stringa secondo la convenzione di cui sopra.. e ricevendo sempre via seriale la risposta ...
qui allego gli esempi a cui sto lavorando già testati e funzionanti.

in seguito conto di inserire la softserial e rendere utilizzabile la connessione tra due micro..

io, nel mio caso, devo controllare il contenuto della eeprom ed eventualemnte modificarne i valori ..
... domani aggiungo maggiori dettagli ...

43  International / Software / Re: Comunicazione seriale tra due microcontrollori .. on: January 11, 2013, 02:08:42 pm
@GINGARDU
Ho iniziato il lavoro ...

il primo problema, il minore, l'ho risolto approssimativamente così:
....  per ricevere la stringa via seriale.... faccio così:
Code:
#define dimVettore 25                // lunghezza max del buffer di lettura (stringa seriale)
#define baudSeriale  4800            // velocità seriale
char stringaSERIALE[dimVettore+1]; // stringa buffer destinata a contenere la stringa ricevuta dalla seriale
boolean stringaOK = false;

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

void loop()
{
if (Serial.available()>0){leggiSeriale();}
}

void leggiSeriale()
 {
   unsigned long count = millis();      //interrompe la lettura dalla seriale se passano più di countMax ms senza che arrivino caratteri
   unsigned long const countMax = 10;   // limite max millisecondi senza che arrivino caratteri .. oltre chiude il ciclo di lettura (non scendere sotto i 5 per 4800 bps e 10 1200bps)
   boolean fineLettura;                 // controllo sul checksum della stringa Seriale ricevuta

   int index=1;
   // LEGGE i primi dimVettore caratteri ........
   do   
     { if(Serial.available()> 0) {stringaSERIALE[index]=Serial.read(); count = millis(); index++; }
       fineLettura = ((index > dimVettore) || (millis() - count > countMax));}
   while (!fineLettura);   
   
   stringaSERIALE[0]= index-1; // in posizione 0 pone l'indice massimo ... servirà per il parser della stringa ...
   fineLettura = false;

    byte tempByte;
   // CANCELLA il buffer, se c'è ancora qualcosa nel buffer .....
   do
     { if(Serial.available()> 0) { tempByte = Serial.read(); count = millis();}
       fineLettura = (millis() - count > countMax);}
   while (!fineLettura);

     int k=0;
     Serial.print("\n ......................................................................");
     Serial.print("\n\t k=0\t   "); Serial.print(stringaSERIALE[0], DEC); Serial.print(" dimensione Vett");
     while (k < stringaSERIALE[0])
     {  k++;
        Serial.print("\n\t k="); Serial.print(k);
        Serial.print("\t   ")  ; Serial.print(stringaSERIALE[k], DEC);
        Serial.print("\t   ")  ; Serial.print(stringaSERIALE[k]);
       }
      Serial.print("\n ...................................................................... \n\n\n");
}
... la stringa viene ricevuta e messa nel vettore stringaSeriale[] .. in posizione 0 viene messo il valore massimo raggiunto dal puntatore..... mi pare che funzioni sempre, con qualsiasi velocità di bps.....
per adesso, per il debug, uso la seriale standard, ma poi l'idea è di usare la libreria softSerial per usare qualsiasi PIN ed usare la seriale standard come eco dei comandi e dei messaggi ricevuti ...

Ho anche abozzato la mia idea della decodifica della stringa comando  in questo modo:
Code:
#define dimVettore 25                // lunghezza max del buffer di lettura (stringa seriale)
#define baudSeriale  4800            // velocità seriale
char stringaSERIALE[dimVettore+1]; // stringa buffer destinata a contenere la stringa ricevuta dalla seriale
boolean stringaOK = false;

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

void loop()
{
if (Serial.available()>0){leggiSeriale();}
if (stringaOK) {analizzaStringa();}
}

void leggiSeriale()
 {
   unsigned long count = millis();      //interrompe la lettura dalla seriale se passano più di countMax ms senza che arrivino caratteri
   unsigned long const countMax = 10;   // limite max millisecondi senza che arrivino caratteri .. oltre chiude il ciclo di lettura (non scendere sotto i 5 per 4800 bps e 10 1200bps)
   boolean fineLettura;                 // controllo sul checksum della stringa Seriale ricevuta

   int index=1;
   // LEGGE i primi dimVettore caratteri ........
   do   
     { if(Serial.available()> 0) {stringaSERIALE[index]=Serial.read(); count = millis(); index++; }
       fineLettura = ((index > dimVettore) || (millis() - count > countMax));}
   while (!fineLettura);   
   
   stringaSERIALE[0]= index-1; // in posizione 0 pone l'indice massimo ... servirà per il parser della stringa ...
   fineLettura = false;

    byte tempByte;
   // CANCELLA il buffer, se c'è ancora qualcosa nel buffer .....
   do
     { if(Serial.available()> 0) { tempByte = Serial.read(); count = millis();}
       fineLettura = (millis() - count > countMax);}
   while (!fineLettura);

  stringaOK = true;
}


/* ipotesi di mappatura della stringa di comando

byte 0 - lunghezza max del vettore-buffer, (n: numero di byte - caratteri di cui si compone la stringa dati)
byte 1 - ID destinatario (0 - 128) (al momento inutilizzato)
byte 2 - ID mittente (0 - 128) (al momento inutilizzato)
byte 3 - PIN prima parte, per riconoscere il comando/interrogazione (al momento inutilizzato)
byte 4 - PIN seconda parte, per riconoscere il comando/interrogazione (al momento inutilizzato)
byte 5 - inutilizzato (al momento inutilizzato)
byte 6 - inutilizzato (al momento inutilizzato)
byte 7 - inutilizzato (al momento inutilizzato)
byte 8 - comando/dispositivo (A: interrogazione;     B: comando;     C: invio dati;     D: comunicazione ricevuto Ok;     E: comunicazione errore ricezione ... etc.)
byte 9 - inutilizzato (al momento)
byte 10 - inutilizzato (al momento)

byte 11 - inizio sequenza del comando\dispositivo, 1 byte
byte 12 - continuo sequenza del comando\dispositivo, 2 byte
byte 13 - continuo sequenza del comando\dispositivo, 3 byte
... ...
... ...
byte n-2 - penultimo byte della sequenza comando\dispositivo, n-2'esimo byte
byte n-1 - ultimo byte della sequenza comando\dispositivo, n-1'esimo byte
byte n   - checksum (al momento inutilizzato), n'esimo byte
*/

void analizzaStringa ()
{ stringaOK = false;

 if (stringaSERIALE[0] >= 12) //  ci sono i caratteri minimi necessari
    {
        switch (stringaSERIALE[8]) // byte in posizione 8
        {
        case 'A': //interrogazione
        Serial.print("\n\t Scelta:A");
       
        break;

        case 'B': //comando
        Serial.print("\n\t Scelta:B");
       
        break;
       
        case 'C': //comunicazione: ricevuto ok
        Serial.print("\n\t Scelta:C");
       
        break;

        case 'D': //comunicazione: errore ricezione
        Serial.print("\n\t Scelta:D");
       
        break;
        }

     // stampa i dati ricevuti .....
     int k=0;
     Serial.print("\n ......................................................................");
     Serial.print("\n\t k=0\t   "); Serial.print(stringaSERIALE[0], DEC); Serial.print(" dimensione Vett");
     while (k < stringaSERIALE[0])
     {  k++;
        Serial.print("\n\t k="); Serial.print(k);
        Serial.print("\t   ")  ; Serial.print(stringaSERIALE[k], DEC);
        Serial.print("\t   ")  ; Serial.print(stringaSERIALE[k]);
       }
      Serial.print("\n ...................................................................... \n\n\n");
    }
 else //  non ci sono i caratteri minimi necessari
    {
     Serial.print("\n\t Stringa comando non corretta. Ricevuti solo ");  Serial.print(stringaSERIALE[0], DEC);  Serial.print(" caratteri!!");
    }
}

ipotizzo che la stringa di comando abbia questa forma:

byte 0 - lunghezza max del vettore-buffer, (n: numero di byte - caratteri di cui si compone la stringa dati)
byte 1 - ID destinatario (0 - 128) (al momento inutilizzato)
byte 2 - ID mittente (0 - 128) (al momento inutilizzato)
byte 3 - PIN prima parte, per riconoscere il comando/interrogazione (al momento inutilizzato)
byte 4 - PIN seconda parte, per riconoscere il comando/interrogazione (al momento inutilizzato)
byte 5 - inutilizzato (al momento inutilizzato)
byte 6 - inutilizzato (al momento inutilizzato)
byte 7 - inutilizzato (al momento inutilizzato)
byte 8 - comando/dispositivo (A: interrogazione;     B: comando;     C: invio dati;     D: comunicazione ricevuto Ok;     E: comunicazione errore ricezione ... etc.)
byte 9 - inutilizzato (al momento)
byte 10 - inutilizzato (al momento)

byte 11 - inizio sequenza del comando\dispositivo, 1 byte
byte 12 - continuo sequenza del comando\dispositivo, 2 byte
byte 13 - continuo sequenza del comando\dispositivo, 3 byte
... ...
... ...
byte n-2 - penultimo byte della sequenza comando\dispositivo, n-2'esimo byte
byte n-1 - ultimo byte della sequenza comando\dispositivo, n-1'esimo byte
byte n   - checksum (al momento inutilizzato), n'esimo byte


lo so,  ci sono molti bit inutilizzati ed inutili per la comununicazione seriale ... ma io, poi, vorrei utilizzarlo anche per altre cose.... quindi vorrei fare una sorta di protocollo generale utilizzabile per molti casi....

una volta stabilita la lunghezza max del buffer contenente la stringa, nella variabile dimVettore, che nel mio caso ho messo a 25, perchè certamente bastano per gestire il mio progetto ..... la decodifica della stringa sarebbe da fare con opportuni switc case.

Adesso comincio a scrivere la parte di decodifica specifica per il mio progetto che sostanzialmente consiste in:
- il primo micro interroga il secondo per estrarre il contenuto di 12 byte della eeprom, a partire da  in una certa posizione , quindi invia i dati al 2 micro;
- il primo micro invia i dati per modificare i 12 byte della eeprom ...

aspetto opinioni al riguardo ....
ciao
44  International / Software / Re: Non riesco a leggere una stringa da seriale ..... l'ennesima richiesta!!!! on: January 07, 2013, 09:56:07 am
ok... adesso funziona bene .... così:

Code:
#define dimVettore 4            // lunghezza max del buffer di lettura (stringa seriale)
char stringaSERIALE[dimVettore + 1]; // stringa buffer for contenente le letture estratte dal GPS

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

void loop()
{
if (Serial.available()>0){leggiSeriale();}
}


void leggiSeriale()
 {
   unsigned long count = millis();      //interrompe la lettura dalla seriale se passano più di countMax ms senza che arrivino caratteri
   unsigned long const countMax = 5;    // limite max millisecondi senza che arrivino caratteri .. oltre chiude il ciclo di lettura (non scendere sotto i 5)
   boolean fineLettura;                 
   
   int index=0;
   // LEGGE i primi dimVettore caratteri ........
   do   
     {
        if(Serial.available()> 0)               
         {
           stringaSERIALE[index]=Serial.read(); count = millis(); 
           index++;                           
         }
         fineLettura = ( (index >= dimVettore) || (millis() - count > countMax));
      }
    while (!fineLettura);   

     fineLettura = false;

    byte tempByte;
   // CANCELLA il buffer, se c'è ancora qualcosa nel buffer .....
   do
     {
       if(Serial.available()> 0)               
       {
         tempByte = Serial.read(); count = millis();                         
       }
       fineLettura = (millis() - count > countMax);
     }
   while (!fineLettura);
 
     Serial.print("\n INIZIO VETTORE MEMORIZZATO");
     Serial.print("\n index:"); Serial.print(index);
     for(int k=0; k<index; k++){
                            Serial.print("\n\t k=")   ; Serial.print(k);
                            Serial.print("\t   ")     ; Serial.print(stringaSERIALE[k], DEC);
                            Serial.print("\t   ")     ; Serial.print(stringaSERIALE[k]);
                          }
      Serial.print("\n FINE VETTORE MEMORIZZATO \n\n\n");
}
adesso posso passare al post-proccesso della stringa....
grazie ciao
45  International / Software / Re: Non riesco a leggere una stringa da seriale .....RISOLTO!!! on: January 07, 2013, 04:45:20 am
credo di aver trovato la soluzione:

il carattere lo leggo così:
Code:
do    
     {
        if(Serial.available()> 0)                
          {
           stringaSERIALE[index]=Serial.read();  
           index++; count = millis();                            
            }
      fineLettura = ( (index >= dimVettore) || (millis() - count > countMax));
     }
 while (!fineLettura);  

quindi c'è un ciclo do - while controllato dalla variabile booleana "fineLettura". all'interno, però,  c'è un IF nidificato che fa si che si possa leggere il carattere solo se serial.vailable è true ... se è falso ì non viene letto nulla, ma non esce comunque dal do-while .. attende, infatti, che serial.vailable sia di nuovo vero , se nel frattempo è arrivato un altro carattere, oppure aspetta il timeout (perchè non sono arrivati altri caratteri... Tutto questo funziona bene....

devo semplicemente riproporre lo stesso meccanismo per cancellare il buffer della seriale, quando è uscito dal primo do-while.. e tutto funzionerà (.. almeno credo)...
insomma questo è sbagliato:
Code:
 while (Serial.available()) {tempByte = Serial.read();}
devo riproporre lo stesso schema, con do-while controllato con una condizione logica, e timeout per accertarsi che non ci sia più nulla in coda al buffer (come faccio sopra per leggere il carattere) .. altrimenti, se non faccio così,  se l'esecuzione passa velocemente a queste istruzioni (come quando cancello i serial.print di debug), trova serial.available ancora false, perchè non è ancora giunto il byte (specie se la connesisone seriale è impostata a bassa velocità) e mi salta la cancellazione del buffer, quindi al ciclo successivo mi mette nel mio vettore gli ultimi valori ricevuti anzichè i primi ...
Credo sia questa la soluzione .... stasera riprovo con questa idea ...
grazie ciao
Pages: 1 2 [3] 4 5 ... 17