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

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;

#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...

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( + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 0); // busy1   ..... 1° byte della risposta ....
 charTX[12] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 1); // azioneA1
 charTX[13] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 2); // AzioneB1
 charTX[14] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 0 * 4 + 3); // AzioneC1
 charTX[15] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 0); // busy2
 charTX[16] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 1); // azioneA2
 charTX[17] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 2); // AzioneB2
 charTX[18] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 1 * 4 + 3); // azioneC2
 charTX[19] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 2 * 4 + 0); // busy3
 charTX[20] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 2 * 4 + 1); // azioneA3
 charTX[21] = EEPROM.read(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9) ) + 2 * 4 + 2); // AzioneB3
 charTX[22] = EEPROM.read(EEPROM.read( + ((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( + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 0, charRX[11] ); // busy1
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 1, charRX[12] ); // AzioneA1
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 2, charRX[13] ); // AzioneB1
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 0 * 4 + 3, charRX[14] ); // AzioneC1
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 0, charRX[15] ); // busy2
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 1, charRX[16] ); // AzioneA2
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 2, charRX[17] ); // AzioneB2
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 1 * 4 + 3, charRX[18] ); // AzioneC2
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 2 * 4 + 0, charRX[19] ); // busy3
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 2 * 4 + 1, charRX[20] ); // AzioneA3
 EEPROM.write(EEPROM.read( + ((charRX[9]-65) * EEPROM.read(9)) + 2 * 4 + 2, charRX[21] ); // AzioneB3
 EEPROM.write(EEPROM.read( + ((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:

#include <EEPROM.h> //needed to save settings in EEPROM
#define ComSer.h

.. ma non funge nulla .....

mumble .. mumble!!!! ... la programmazoine ad oggetti con me non và molto d'accordo!!!!
.. ma grazie Leo....

grazie Leo.. Grazie Uwe ...

io devo includere sia la definizine di alcune variabili, sia una decina (almeno) di funzioni ... quindi devo creare sia il file.h che il file.cpp

... nel file.h devo mettere la definizione delle variabili (header).... nel file.cpp devo mettere le funzioni che ho creto (source).

 Chiedo scusa ma con l'inglese sono davvero negato (oggi devo anche andare al corso). Al corso di inglese quando mi hanno chiesto a che livello ero ho risposto che se fossi nato lì, probabilmente sarei rimasto muto!!!

comunque .. vediamo di impararare a fare questa libreria ....
vi faccio ancora qualche domanda:

Code:

#ifndef Morse_h
#define Morse_h
// the #include statment and code go here...
#endif

che significa questo, in particolare cosa è questo : "#ifndef Morse_h" .. ho pensato che fosse una verifica per vedere se esiste morse_h .. allora carica morse_h... quindi questo: "#define Morse_h" determina il caricamento nllo schech della libreria morse_h...... è cos'?

.. invece se non voglio caricare tutta la libreria posso fare così:

Code:

#include "Morse.h"

e quando voglio richiamare una funzione di quella libreria faccio così:

Code:

Morse::Morse(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
}

... ma ho capito bene? mha... non mi convince.. perchè da una parte parla di morse.h e dall'altra parte di morse_h ??? .. bho!!!!

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????.

... 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

... 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 ...

@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

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

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

si Leo... se metto un delay al posto dei serial print .. funziona di nuovo tutto. Ma non mi piace la soluzione. Voglio trovare una soluziione che vada bene sempre e che non rallenti il codice più di quanto non sa srettaene necessario.

l'uscita con timeout la vedo corretta perchè:

2) se invece la stringa è piu corta, al raggiungimento dell'ultimo carattere dovrebbe iniziare a contare millis - count (con count che contiene l'ultimo valore di millis di quando ha letto l'ultimo carattere, quindi appena supera il tempo max di attesa significa che non ci sono più caratteri ed esce lo stesso.

il count viene inizializzato con millis al momento della letttura dell'ultimo carattere .... quindi esce se
(millis() - count > countMax) ... che diventa vero dopo che sono passati countMax  mS ...
mi pare che questa logica sia correttà...

sto pennsando di controllare la cancellazione del buffer con un altro controllo anzichè con seruial.available... perchè e lì che cè il punto critico...

ciao

Grazie Leo..... allora:

A parte che il codice è scritto un po' male.... si mette in genere una istruzione per riga, la "riga" che tu elimini in realtà sono più istruzioni.... poi gli spazi tra la fine di una istruzione ed il ";" di fine riga proprio non si possono vedere 
Poi c'è un controllo che non capisco.
 fineLettura = ( (index >= dimVettore) || (millis() - count > countMax));

Fatto così, che senso ha? Carichi millis subito prima del check. Quella parte lì sarà sempre false finché ricevi caratteri. Sarà sempre vera se non li ricevi perché count non lo inizializzi con millis() prima di fare l'if.

Ok... per lo stile che sicuramente è da rivedere....

il controllo dovrebbe disporre l'uscita dal do-while al verificarsi di una delle due condizioni:
1) se l'indice supera la dimesione del vettore (questo si verifica quando la stringa ricevuta  è più lunga della dimesione del vettore dove conservo i byte (char) ricevuti;
2) se invece la stringa è piu corta, al raggiungimento dell'ultimo carattere dovrebbe iniziare a contare millis - count (con count che contiene l'ultimo valore di millis di quando ha letto l'ultimo carattere, quindi appena supera il tempo max di attesa significa che non ci sono più caratteri ed esce lo stesso.

ma questa parte mi pare che funzioni bene...

ciò che non funziona è la parte che dovrebbe cancellare il buffer di ricezione della seriale, cioè questa:

Code:

     Serial.print("\n  VUOTA il BUFFER: eliminati:");
     byte tempByte;
     while (Serial.available()) {tempByte = Serial.read(); Serial.write(tempByte);}
     Serial.print("\n    ---------------------\n");

e questo, io credo, sia dovuto al fatto che mentre prima la riga che contiene le quattro istruzioni di serial print, introducono un certo ritardo, fanno si che quando l'struzine passa sul serial.available lo trova positivo, perchè nel frattempo è arrivato un altro carattere, quindi entra e cancella il buffer ...

se invece tolgo quei serial.print, passa troppo rapidamente a fare quella valutazione e serial.available è false... quindi non entra e non calcella il buffer... io credo sia quasto ma non trovo la soluzione .... ogni volt che mi sembra di aver trovato qualcosa basta che tolgo qualche serial print e non funziona più....

Chiedo scusa ma ieri è successo un piccolo problema dopo che ho insrito mezzo post.... è mancata l'energia elettrica, poi non c'era collegamento, posi sono dovuto uscire e sono rientrato tardissimo.. quindi in realtà ho postato solo metà della descrizione...

e vi ringrazio anche per esserevi trattenuti negli improperi ....

adesso l'ho corretto ed all'incirca si dovrebbe leggere tutta la descrizione del problema che cerco di riassumere anche qui ..

il problema consiste nel mettere in un array di char (voglio fare così.. non con una stringa) ... i primi n caratteri ricevuti dalla seriale e svuotare i caratteri che eventualmente ancora ci fossero in attesa di essere letti ...


il primo schetc funziona, finche ci sono anche le righe di serial.print che uso per il debug ... nel secondo script, dove cancello una riga di debug .. non funziona più..... ci sono sopra due giorni e non trovo soluzione .. porka miseria!!!!!

... se per esempio, digito la seguente stringa "abcdefghilmno"  mi da questo output

 

Code:

dopo do ---------------------

  VUOTA il BUFFER: eliminati:
    ---------------------

 INIZIO VETTORE MEMORIZZATO
 index:5
k=0    97    a
k=1    98    b
k=2    99    c
k=3    100    d
k=4    101    e
 FINE VETTORE MEMORIZZATO



   dopo do ---------------------

  VUOTA il BUFFER: eliminati:mno
    ---------------------

 INIZIO VETTORE MEMORIZZATO
 index:5
k=0    102    f
k=1    103    g
k=2    104    h
k=3    105    i
k=4    108    l
 FINE VETTORE MEMORIZZATO

cioè il vettore alla fine contiene "fghil" anzichè i primi 5 caratteri "abcde"

invece di quello corretto che dovrebbe essere questo

Code:

a  97    index:0
b  98    index:1
c  99    index:2
d  100    index:3
e  101    index:4
   dopo do ---------------------

  VUOTA il BUFFER: eliminati:fghilmno
    ---------------------

 INIZIO VETTORE MEMORIZZATO
 index:5
k=0    97    a
k=1    98    b
k=2    99    c
k=3    100    d
k=4    101    e
 FINE VETTORE MEMORIZZATO

con il vettore che, correttamemte, alla fine contiene solo i primi 5 caratteri ....

credo di essere stato maggiormente chiaro ... saluti ciao

Non riesco a leggere un stringa dalla seriale come vorrei io..
cioè sto cercando di mettere in un vettore di char la stringa che invio dalla seriale .. per il processamento successivo.

cioè se invio "ABCDEFGHIL" (senza gli apici) e fisso la lunghezza del vettore a 4, vorrei avere questo
stringa(0) ---> A
stringa(1) ---> B
stringa(2) ---> C
stringa(3) ---> D

ho cercato e letto decine di post che riguardano questo problema.
Ho capito che il problema è originato dalla velocità di lettura rispetto alla velocità di ricezione dei dati sulla seriale ..

ho fatto questo script e funziona, fintanto che ci sono le stampe su serial monitor per il debug:

Code:

#define dimVettore 5            // lunghezza max del buffer di lettura (stringa seriale)
char stringaSERIALE[dimVettore + 1]; // stringa buffer for contenente le letture estratte dal GPS
boolean fineLettura;                 // controllo sul checksum della stringa Seriale ricevuta

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

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

void leggiSeriale()
 {
   unsigned long count;      //interrompe la lettura dalla seriale se passano più di countMax ms senza che arrivino caratteri
   int const countMax = 5;  // limite max millisecondi senza che arrivino caratteri .. oltre chiude il ciclo di lettura (non scendere sotto i 5)
  
   int index=0;
   do    
     {
        if(Serial.available()> 0)                
         {
           stringaSERIALE[index]=Serial.read();  
           Serial.print("\n\t"); Serial.print(stringaSERIALE[index]); Serial.print("  \t"); Serial.print(stringaSERIALE[index], DEC); Serial.print("   \t index:"); Serial.print(index);
           index++; count = millis();                            
            }
            
      fineLettura = ( (index >= dimVettore) || (millis() - count > countMax));
      }
    while (!fineLettura);  
    Serial.print("\n   dopo do ---------------------\n");
 
  
     Serial.print("\n  VUOTA il BUFFER: eliminati:");
     byte tempByte;
     while (Serial.available()) {tempByte = Serial.read(); Serial.write(tempByte);}
     Serial.print("\n    ---------------------\n");
      
  
  
     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");
}

tutto questo funziona, ma basta che elimino una riga e già non funziona più...

Code:

#define dimVettore 5            // lunghezza max del buffer di lettura (stringa seriale)
char stringaSERIALE[dimVettore + 1]; // stringa buffer for contenente le letture estratte dal GPS
boolean fineLettura;                 // controllo sul checksum della stringa Seriale ricevuta

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

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

void leggiSeriale()
 {
   unsigned long count;      //interrompe la lettura dalla seriale se passano più di countMax ms senza che arrivino caratteri
   int const countMax = 5;  // limite max millisecondi senza che arrivino caratteri .. oltre chiude il ciclo di lettura (non scendere sotto i 5)
  
   int index=0;
   do    
     {
        if(Serial.available()> 0)                
         {
           stringaSERIALE[index]=Serial.read();  
           //Serial.print("\n\t"); Serial.print(stringaSERIALE[index]); Serial.print("  \t"); Serial.print(stringaSERIALE[index], DEC); Serial.print("   \t index:"); Serial.print(index);
           index++; count = millis();                            
            }
            
      fineLettura = ( (index >= dimVettore) || (millis() - count > countMax));
      }
    while (!fineLettura);  
    Serial.print("\n   dopo do ---------------------\n");
 
  
     Serial.print("\n  VUOTA il BUFFER: eliminati:");
     byte tempByte;
     while (Serial.available()) {tempByte = Serial.read(); Serial.write(tempByte);}
     Serial.print("\n    ---------------------\n");
      
  
  
     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");
}

... mi sta facendo impazzire.... se già non lo sono!!!! ... che cavolo gli devo fare perchè funzioni sempre ..

ciao gingardu....
ho appena cominciato a lavorarci... conto di riprendere appena dopo questi giorni di festa. appena ho qualcosa di funzionamente posto qui.. così facciamo qualcosa di standard e utilizzabile per molti usi.... .. a presto ciao...