... inserire lo stesso blocco di codice in due schetc

... 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 che porta dentro di ciascuno schetc esattamemte lo stesso blocco di codice... mi date qualche dritta?
Grazie

In realtà è proprio come una libreria, devi creare il file comune, sia .h che .cpp, nella cartella libraries, il tutto deve essere organizzato sotto forma di singola funzione o raccolta di funzioni.
Tiene presente che con #include non puoi inserire direttamente del codice, come è possibile fare con una #define, semplicemente dici al compilatore dove trovare questo codice.

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

ciao Paolo S
Qua una guida come scrivere una bibliotheca.

Ciao Uwe

Questo link potrebbe aiutarti:

Tu devi essenzialmente crearti un file .h (il file .cpp può anche essere omesso, se alla fine dei includere solo delle variabili) e poi puoi includerlo in tutti i file che desideri con un #include

EDIT:
preceduto :wink:

E' una tecnica molto usata per evitare di far includere 2 volte la stessa porzione di codice, magari perché richiamata da 2 file differenti. Quindi si fa così: si controlla se una costante che abbia un certo nome è già stata definita oppure no. Se non è stata definita, la si definisce e si include il codice. Se è già stata definita, vuol dire che questo file è già stato incluso da qualche altra parte e quindi non si fa nulla.

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

#include "Morse.h"

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

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

Tu devi includere il file .h, lascia perdere quel "Morse_h", serve per altro, come ti ho spiegato.
Poi una volta inclusa la lib, procedi in base a come hai strutturato la lib. Se hai creato delle funzioni includendole in una classe, devi istanziare una copia della classe e poi chiamare le nuove funzioni usando l'operatore ".".

#include "Morse.h"
Morse myMorse; //esempio
....
myMorse.sendMessage(....); //esempio

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

la programmazoine ad oggetti con me non và molto d'accordo!!!!

Ti capisco ma devi fartela un po amica.

Non ti servono le classi, ti serve un file .h che contiene le eventuali #define e l'inizializzazione delle eventuali variabili, inoltre deve contenere i prototipi delle funzioni che inserisci nella libreria, il file .cpp contiene solo le varie funzioni che ti servono, se vuoi puoi creare anche il file keywords.txt che contiene le keyword da colorare nell'IDE.

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

Vuole dire che dentro il file .h ci DEVONO essere i prototipi delle funzioni, altrimenti il compilatore si arrabbia, inoltre devi usare l'include e non la define, quello che stai realizzando è a tutti gli effetti una libreria.

Non è facile entrare nel concetto di libreria.
Ti consiglio di rileggerti bene la pagina che ti abbiamo linkato e di iniziare a fare dei test con piccole porzioni di codice, per capire, dagli errori segnalati dal compilatore, dove stai sbagliando.

leo72:
Non è facile entrare nel concetto di libreria.

Ma non è quel posto pieno di libri che puoi acquistare/noleggiare ? :grin:

astrobeed:

leo72:
Non è facile entrare nel concetto di libreria.

Ma non è quel posto pieno di libri che puoi acquistare/noleggiare ? :grin:

:grin: