Buongiorno e Buon Natale a tutti.
E' da poco tempo che ho iniziato ad utilizzare le schede in modo da dividere lo sketch in vari blocchi e tutto sommato la funzionalità offerta l'ho trovata molto utile e semplice da utilizzare.
L'unico scoglio che ho trovato è come riuscire a definire una variabile pubblica in una scheda specifica, e non essere costretto a definirla in quella principale.
Non conosco molto bene il "C" e pertanto, dopo alcuni tentativi ho dovuto desistere.
Grazie
lelebum:
L'unico scoglio che ho trovato è come riuscire a definire una variabile pubblica in una scheda specifica, e non essere costretto a definirla in quella principale.
Che io sappia puoi dichiarare una variabile o a livelli glibale, quindi utilizzabile in ogni parte dello sketch quindi prima del void setup, o all'interno delle void per essere utilizzabili solo in quelle void ed infine quelle dichiarate all'interno delle operazioni cicliche come i for...provo a spiegarmi meglio
int myNum = 1; //questa variabile la puoi usare in tutto il tuo codice
void setup () {
Serial.begin(9600);
}
void loop () {
myNum++; //sommo 1 al valore myNum
Serial.println(myNum); //lo scrivo in seriale
delay(1000); //attendo 1 secondo
for (int i=1; i <=10; i++) {
myNum += i; //somma il valore i a myNum
Serial.println(myNum);//scrivo in seriale
delay (500); //attende mezzo secondo
int c = 0; //questa è una variabile che al termine del ciclo for non sarà più disponibile. NB: Ogni volta che ricomincia il loop del for verrà settata a 0.
}
//il valore di i e di c (e di tutte le altre dichiarazioni fatte all'interno del ciclo for) non saranno più disponibili ne qui ne in nessun'altra parte del codice.
somma();
}
void somma () {
int b =15; //questa variabile sarà disponibile solo in questa funzione chiamata somma
Serial.print("Risultato funzione somma: ");//scrivi in seriale
myNum += b;
Serial.println(myNum) //scrivo in seriale
delay(2000); //attendo 2 secondi
}
EDIT: scrivendo da smartphone e rivedendolo ho aggiunto qualche indicazione.
Quando parlo di "schede" intendo quella nuova funzionalità offerta dall'IDE che permette di suddividere lo sketch su più file *.ino
Gli stessi poi vengono visualizzati nell'IDE sotto forma di schede.
Dalle mie prove ho potuto verificare che le variabili globali possono essere definite solo sul file principale.
Penso che non hai scelta... dovrai definire le variabili globali nella scheda principale per poi utilizzarle nelle schede che vuoi. io personalmente uso più schede per i miei sketch e non ho mai provato a dichiarare fuori dalle funzioni scritte in altre schede le variabili. di istinto più che per conoscenza le ho sempre dichiarate tutte ad inizio codice. Ovviamente usando questo semplice concetto di organizzazione
//*******************Servo*************************
#include <Servo.h>
Servo myServo
unsigned long timeServo //questa magari verrà utilizzata in un'altra scheda
//********************Display************************
#include <LiquidCrystal.h>
//tutte le dichiarazioni del caso
unsigned long myDisplay //questa magari verrà utilizzata in un'altra scheda
//************variabili per pulsanti******************
//ecc ecc
Quindi cerco di raggruppare le dichiarazioni per poi consultare il più velocemente possibile. Mi scuso se ci sono errori ma scrivo da smartphone e quindi per quel che posso ricordare così.
Buon Natale.
Devi usare l'attributo extern ... puoi studiare come si usa QUI ed anche alcuni esempi QUI
Guglielmo
x miky_police
Tutto sommato direi che i metodi e i fini che usiamo sono analoghi.
In certi casi però potrebbe essere utile raccogliere sotto un unico file o scheda, un codice completamente indipendente da poter essere caricato su uno sketch principale, senza operare alcuna modfica.
Grazie a tutti comunque per l'aiuto offerto, ora vedo di studiarci sopra al link di Guglielmo
Buone Feste
Data la mia limitata conoscenza del "C", prendete la mia conclusione con le "pinze".
Dopo una serie di prove mi sembra di aver dedotto che nonostante si suddivida per comodità lo sketch in varie schede, di fatto il compilatore lo considera come un unico documento, accodando le varie schede una di seguito all'altra.
Se si vuole essere certi che il codice veda le variabili globali, le stesse devono essere dichiarate all'inizio del documento, analogamente alla dichiarazione delle librerie.
E' possibile disseminare le dichiarazioni delle variabili dentro le varie schede, ma si corre il rischio quasi certo che il compilatore si ritrovi a gestire una variabile che verrà definita successivamente.
Durante la compilazione dello sketch avvengono molte operazioni, fondamentalmente quando si suddivide in schede vengono creati altrettanti file .ino nel momento della compilazione tra le altre cose che avvengono viene preso il file principale (che si chiama come la cartella) a questo vengono accodati in ordine alfabetico tutti gli altri file .ino presenti nella cartella, quindi la cosa migliore da fare è quella di definire le variabili globali nella scheda principale per evitare errori di compilazione.
Chi ha dimestichezza potrebbe lasciare il file principale solo con setup e loop che richiamano metodi definiti in altre schede e creare una scheda (Es. AAA_Globali.ino, 0000_Globali.ino) in modo che i vari metodi nelle schede successive trovino le variabili definite ecc.
Ma la trovo una pratica poco utile e alle volte fuorviante, personalmente preferisco mettere define e globali all'inizio della shceda principale, commentate bene, e le varie schede per suddividere logicamente funzioni e metodi (Es. scheda per LCD, scheda per RTC, ecc.). In questo modo nella scheda principale ho tutto ciò che necessita al programma, l'inizializzazione dei pin (input, output) e dei device (RTC,LCD,ecc.) e nel loop richiamo per quanto possibile funzioni specifiche
Intervento chiaro e semplice.
Anch’io fino a ieri ho usato a questo schema. Nonostante la mia modesta esperienza con Arduino, sin dall’inizio avevo capito che dentro al “loop” dovevano trovarsi unicamente chiamate alle varie routine, e pertanto niente “if”, “switch”, “for”, ecc. come si vedono in tanti sketch in rete.
Poi ho scoperto le schede, e ora stavo valutando se continuare con il vecchio metodo o se si poteva tentare un nuovo approccio, ed è questo il motivo per cui ho aperto questo post.
Molte volte la fase di definizione delle librerie e delle variabili rappresenta un lungo elenco, soprattutto in presenza di numerosi dispositivi come nel mio progetto di antifurto (Lcd, Keypad, RTC, SD, ecc.).
In questi casi in fase di debug o modifica del codice, risulta davvero snervante scorrere il listato avanti indietro, molto più semplice commutare una scheda.
La mia idea era quella di tentare di raccogliere in un’unica scheda/fileino tutto quello che serve per la libreria e suoi accessori. Magari utilizzare la stessa scheda con altri sketch.
Proprio da questo confronto ho capito che la mia idea è poco fattibile e comunque non offrirebbe i vantaggi che cercavo.
lelebum:
Intervento chiaro e semplice.Anch’io fino a ieri ho usato a questo schema. Nonostante la mia modesta esperienza con Arduino, sin dall’inizio avevo capito che dentro al “loop” dovevano trovarsi unicamente chiamate alle varie routine, e pertanto niente “if”, “switch”, “for”, ecc. come si vedono in tanti sketch in rete.
E' una visione un poco estrema, dentro al loop possono esistere anche costrutti che permettano di porre decisioni o cicli, a volte rendono più semplice capire il flusso del programma piuttosto che saltare tra una funzione e l'altra.
Secondo me l'importante è che il tutto resti chiaro e lineare in modo da non complicare la lettura e il raltivo debug, ma questi aspetti rientrano nel modo in cui ciascuno si trova meglio a programmare, anche se alcune regole di base sarebbe bene rispettarle, rendono debug e lettura di codice a distanza di mesi/anni molto più semplice
Ok forse ho esagerato..
Comunque grazie per tue delucidazioni