next topic »

[on:]

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

[Reply #1 on:]

. anche se non è esattamente una libreria, quella che devo caricare!!!

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.

[Reply #2 on:]

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

[Reply #3 on:]

ciao Paolo S
Qua una guida come scrivere una bibliotheca.
http://arduino.cc/en/Hacking/LibraryTutorial
Ciao Uwe

[Reply #4 on:]

Questo link potrebbe aiutarti:
http://arduino.cc/en/Hacking/LibraryTutorial

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 

[Reply #5 on:]

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

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ì:

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

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

Code:

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

[Reply #6 on:]

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

[Reply #7 on:]

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

Ti capisco ma devi fartela un po amica.

[Reply #8 on:]

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

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.

[Reply #9 on:]

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

[Reply #10 on:]

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

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.

[Reply #11 on:]

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.

[Reply #12 on:]

Non è facile entrare nel concetto di libreria.

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

[Reply #13 on:]

Non è facile entrare nel concetto di libreria.

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