- ArduinoQuadro -
- 15/12/2017-
Il progetto di calcolatrice con Arduino, si trasforma in ArduinoQuadro!!
Progetto evoluzione del precedente post "Calcolatrice RPN "
Materiale occorrente:
Arduino UNO
LCD 16x2 I2C
Tastierino a matrice 4x4.
Consultare il precedente post per schema collegamenti, e spiegazioni iniziali.
Rimane invariato lo schema e l'hardware.
_ Costo del materiale molto contenuto.
_ Calcolatrice scientifica di tipo RPN.
Si possono programmare funzioni matematiche e trigonometriche disponibili anche in modo diretto.
E sono disponibili alcune funzionalità di Arduino.
Si potranno realizzare piccoli "sketch" senza dover utilizzare un PC.
Sono disponibili PIN DIGITALI e PIN ANALOGICI che possono essere utilizzati
per input output.
Si potrà scrivere un piccolo programma che potrà essere conservato nella EEPROM.
Una volta lanciata l'esecuzione il programma viene eseguito in modalità "interpetre".
Non si esegue una compilazione quindi l'utilizzo come microcontrollore è limitato,
( sono limitati anche i pin disponibili ( da 0 a 7 sono utilizzati per il tastierino.)
Si potranno visualizzare risultati sul display LCD, immettere dati
dalla tastiera, e/o utilizzare i rimanenti pin disponibili di Arduino, compresi gli analogici.
ArduinoQuadro.
Queste alcune caratteristiche:
Programmazione diretta con la scrittura di piccoli programmi nel linguaggio
"Codice99".
Questo linguaggio appositamente preparato si basa su 99 codici che possono essere
scritti in ram e che successivamente l'interpetre utilizzerà per eseguire la relativa funzione.
Ad ogni codice corrisponde una funzione.
(Alcune funzioni avranno bisogno di più codici)
Ho lasciato disponibili alcuni codici per future versioni.
L'immissione del programma in ram avviene con un micro editor che consente
di scrivere il programma e rivederlo scorrendo le istruzioni ed eventualmente correggere errori.
Una volta scritto il programma potrà essere eseguito e/o salvato nella EEPROM
(salvandolo nella EEPROM rimane permanente fino alla cancellazione).
Questo arduino avrà alcuni registri speciali (catasta operativa)
X, Y, Z, T, U, lastX.
Ci saranno alcuni registri di memoria che i programmi utente potranno utilizzare.
Tastierino a matrice 4x4.
Consultare il precedente post per schema collegamenti, e spiegazioni iniziali.
Rimane invariato lo schema e l'hardware.
_ Costo del materiale molto contenuto.
_ Calcolatrice scientifica di tipo RPN.
Le novità in questo post!!
Ora la calcolatrice è programmabile!
Si possono programmare funzioni matematiche e trigonometriche disponibili anche in modo diretto.
E sono disponibili alcune funzionalità di Arduino.
Si potranno realizzare piccoli "sketch" senza dover utilizzare un PC.
Sono disponibili PIN DIGITALI e PIN ANALOGICI che possono essere utilizzati
per input output.
Si potrà scrivere un piccolo programma che potrà essere conservato nella EEPROM.
Una volta lanciata l'esecuzione il programma viene eseguito in modalità "interpetre".
Non si esegue una compilazione quindi l'utilizzo come microcontrollore è limitato,
( sono limitati anche i pin disponibili ( da 0 a 7 sono utilizzati per il tastierino.)
Si potranno visualizzare risultati sul display LCD, immettere dati
dalla tastiera, e/o utilizzare i rimanenti pin disponibili di Arduino, compresi gli analogici.
ArduinoQuadro.
Queste alcune caratteristiche:
Programmazione diretta con la scrittura di piccoli programmi nel linguaggio
"Codice99".
Questo linguaggio appositamente preparato si basa su 99 codici che possono essere
scritti in ram e che successivamente l'interpetre utilizzerà per eseguire la relativa funzione.
Ad ogni codice corrisponde una funzione.
(Alcune funzioni avranno bisogno di più codici)
Ho lasciato disponibili alcuni codici per future versioni.
L'immissione del programma in ram avviene con un micro editor che consente
di scrivere il programma e rivederlo scorrendo le istruzioni ed eventualmente correggere errori.
Una volta scritto il programma potrà essere eseguito e/o salvato nella EEPROM
(salvandolo nella EEPROM rimane permanente fino alla cancellazione).
Questo arduino avrà alcuni registri speciali (catasta operativa)
X, Y, Z, T, U, lastX.
Ci saranno alcuni registri di memoria che i programmi utente potranno utilizzare.
//******************************************************************************
FUNZIONI PROGAMMABILI E RELATIVI CODICI.
MEMORIE & INDICI = da 00 a 19 (questi codici vengono immessi prima della istruzione che li
utilizza. prima si imposta il numero e poi l'istruzione.
Es. prima 01 poi 67 (STOnn) in questo caso il contenuto di x viene
memorizzato nel regisro mem1
Le istruzioni qui sotto con (*) DEVONO ESSERE PRECEDUTE DALL'INDICE
------------------------------------------------------------------------------------------------------------
I/O = 20 PRINT 21 INPUT da 22 a 29 disp
------------------------------------------------------------------------------------------------------------
ARDUINO = 30 *PINPUT 31 *PIOUT 32 *DWHIGH 33 *DWLOW 34 *DREAD
35 *AREAD 36 *AWRITE 37 *DELAYn 38 *TONE 39 *NOTONE
------------------------------------------------------------------------------------------------------------
CONTROLLO = 40 XmaggioreY? 41 XminoreY? 42 X = Y 43 X maggiore 0? 44 Xminore 0?
45 *INCn 46 END 47 LOOP 48 RTN 49 NOP
-------------------------------------------------------------------------------------------------------FUNZIONI PROGAMMABILI E RELATIVI CODICI.
MEMORIE & INDICI = da 00 a 19 (questi codici vengono immessi prima della istruzione che li
utilizza. prima si imposta il numero e poi l'istruzione.
Es. prima 01 poi 67 (STOnn) in questo caso il contenuto di x viene
memorizzato nel regisro mem1
Le istruzioni qui sotto con (*) DEVONO ESSERE PRECEDUTE DALL'INDICE
------------------------------------------------------------------------------------------------------------
I/O = 20 PRINT 21 INPUT da 22 a 29 disp
------------------------------------------------------------------------------------------------------------
ARDUINO = 30 *PINPUT 31 *PIOUT 32 *DWHIGH 33 *DWLOW 34 *DREAD
35 *AREAD 36 *AWRITE 37 *DELAYn 38 *TONE 39 *NOTONE
------------------------------------------------------------------------------------------------------------
CONTROLLO = 40 XmaggioreY? 41 XminoreY? 42 X = Y 43 X maggiore 0? 44 Xminore 0?
45 *INCn 46 END 47 LOOP 48 RTN 49 NOP
MATEMATICHE = 50 (-) 51 (X) 52 (/) 53 (+) 54 CHS 55 Y^x 56 1/X 57 disp
58 SQRT 59 disp
------------------------------------------------------------------------------------------------------
CATASTA e VARIE = 60 DEL 61 ENTER 62 CLST (clr) 63 LASTX 64 XscambioY
65 RUOTA GIU' 66 CLX 67 *STOnn 68 *RCLnn 69 RUOTA SU R^
------------------------------------------------------------------------------------------------------
TRIGONOM e VARIE = 70 PI 71 SIN 72 COS 73 TAN 74 ASIN 75 ACOS
76 ATAN 77 disp 78 disp 79 disp
--------------------------------------------------------------------------------------------------------------
ESEGUI e VARIE = 80 SUB0 81 SUB1 82 SUB2 83 SUB3 84 SUB4 85 SUB5
86 disp 87 disp 88 *XEQnn 89 disp
--------------------------------------------------------------------------------------------------------------
LABEL e VARIE = 90 LBL0 91 LBL1 92 LBL2 93 LBL3 94 LBL4 95 LBL5
96 disp 97 disp 98 disp 99 ENDEND
--------------------------------------------------------------------------------------------------------------
*******************************************************************************
I programmi si scrivono semplicemente digitando il codice relativo alla funzione,
si dovranno immettere sempre 2 caratteri per digitare uno si scrive "01".
L'EDITOR visualizza un numero progressivo (linea programma).
Una volta scritto il programma si potrà controllare scorrendo (tasto 1 avanti) - (tasto 3 indietro) le linee di programma.
E' possibile correggere gli errori.
Finito il controllo è possibile salvare il programma in memoria.
(in questo modo ad una successiva accensione si potrà utilizzare il programma)
Qui sotto il loop principale del programma.
//**************************************************************
void loop()
{
inizializzazione(); // inizializzazione
iniarduino();
// scelte iniziali calcolatrice o arduQuadro menu
arduino();
while(arduQuadro == true)
{
nuovoprog(); // scelta se NEW (scrivere nuovo programma )
//oppure OLD programma in RAM
// finito la registrazione
// del programma o il caricamento da RAM
controllo(); // Si esegue il controllo e correzione
costanti(); // Possiamo inserire dati nei registri
stringhe(); // per inserimento stringhe
// pronto e si mette in attesa pressione tasto
pronto();
tasto();
// Esegue il programma utente
progUtente();
// uscita dal programma utente
fineprog();
}
// esegue come calcolatrice diretta
if (calcRPN == true) {uscitacalc = false;calcolatrice();}
}
//**** END LOOP ************************************
//***************************************************
dopo l'inizializzazione apparirà sul display questo menù, che ci chiede di scegliere fra
CALC (calcolatrice manuale) oppure arduQ ( uso in programmazione )
void arduino()
{
//stringaMenu0 = String("1234567890123456");
stringaMenu0 = String("arduinoQuadro-13");
stringaMenu1 = String("1=CALC 3= arduQ ");
sceltemenu();
if (old == true){arduQuadro = true; calcRPN = false;} // si programma come arduQuadro
else {arduQuadro = false; calcRPN = true;}/// si usa come calcolatrice
}
// con questa si esegue un programma esistente
// si corregge un programma esistente
// oppure si sceglie di scriverne uno nuovo
void nuovoprog()
{
stringaMenu0 = String("Menu programma ");
stringaMenu1 = String("1=NEW - 3=OLD"); **A
sceltemenu();
if (old == true){leggiprog();} // con old a true si legge il programma dalla EPROM
if (old == false) {scritturaprog();} // con old false si scrive nuovo programma
}
Se si sceglie NEW si scriverà un nuovo programma con l'editor.(si scrivono i codici delle istruzioni ogni codice 2 cifre )
in questo caso si vedrà sul display
lcd.print("C.. ");
ed ad ogni codice inserito il numero linea ed il codice
Per finire premere 2 volte il tasto (2F)
Secelta **A
OLD il programma prosegue richiamando il programma esistente e riprende dal controllo e correzione.
Alla richiesta di controllo possiamo scegliere se effettuare un controllo del programma in memoria oppure no.
Con l'editor possiamo scorrere le istruzioni avanti tasto (1) indietro tasto (3)
Possiamo correggere un'istruzione errata, ed è possibile inserire istruzioni.
( vedi più avanti spiegazioni uso editor )
Alla fine del controllo possiamo salvare il programma corretto
appare il messaggio " Salva in RAM"
Dopo questa fase possiamo inserire dati.
Per inserire dati nella catasta si opera in modo consueto come con la calcolatrice in modo diretto
Per inserire i dati nelle memorie utente occorre inserire il dato in X e nella linea visore il numero da 1 a 19 del registro che vogliamo utilizzare.
Con l'editor possiamo scorrere le istruzioni avanti tasto (1) indietro tasto (3)
Possiamo correggere un'istruzione errata, ed è possibile inserire istruzioni.
( vedi più avanti spiegazioni uso editor )
Alla fine del controllo possiamo salvare il programma corretto
appare il messaggio " Salva in RAM"
Dopo questa fase possiamo inserire dati.
Per inserire dati nella catasta si opera in modo consueto come con la calcolatrice in modo diretto
Per inserire i dati nelle memorie utente occorre inserire il dato in X e nella linea visore il numero da 1 a 19 del registro che vogliamo utilizzare.
void costanti()
{
stringaMenu0 = String("Ins. Dati ? ");
stringaMenu1 = String("1= SI - 3= NO");sceltemenu();
if (old == true){return;} // salta inserimento dati
// inseimento dati valori
dati = true;
while ( dati == true)
{
aggiornadisplay(); // sub che aggiona il display
tasto();
insertdati();
if (codice == 62){dati = false;}
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("OK dati inseriti");
delay (1000);
}
Una volta risposto SI (1) alla richiesta di inserire dati viene visualizzato la riga X e sotto la riga visore come nell'uso come calcolatrice.
Si può inserire le cifre e con Enter si passano nella catasta operativa ( si possono usare per l'inserimento i registri della catasta ( x,y,z,t,u) .... logicamente il programma dovrà essere scritto per utilizzarli tenendo conto delle operazioni in catasta.
E' possibile anche inserire dati nei registri dedicati all'utente da 1 a 19 ( sono float).
Per inserire un dato in questi registri si procede così:
_ Prima si inserisce nel registro X con Enter.
_ Poi si inserisce nella riga visore il numero del registro da 1 a 19 senza premere Enter
_ Quindi premere il tasto (+) più ( apparirà " OK " )
continuare così per tutti i dati da inserire
_ alla fine premere il tasto 2F con il quale si esce da inserimento dati, appare il messaggio
" OK dati inseriti"
Il programma chiederà se inserire stringhe.... ( per ora Una stringa )
Questa funzione è molto limitata si possono introdurre i codici ASCII ( solo minori di 99)
per formare una stringa MAX 16 caratteri che utilizzeremo nella PRINT
Questa funzione non è molto funzionale (ma la tastiera disponibile è limitata) penso di realizzare una versione con una tastiera più dotata e quindi semplificando l'immissione dei programmi e delle stringhe.
dopo questa fase il programma attende la pressione di un tasto e si avvia.
(si può lanciare in esecuzione anche un loop continuo che si ferma solo togliendo alimentazione o premendo il reset di arduino)
Al termine del programma UTENTE si potrà scegliere se continuare in programmazione o passare alla calcolatrice in uso manuale (STOP)
void fineprog()
{
stringaMenu0 = String("Fine programma");
stringaMenu1 = String("1=STOP 3=CONT"); // si stop
sceltemenu();
if (si == true) {calcRPN = true; arduQuadro = false;}
}
//*************************************************
Enter: Introduce in x quanto è contenuto sul "visore" e fa salire il resto della catasta, quello che era in x sale in y, il contenuto di y sale in z, il contenuto di z sale in t.
Del Cancella il contenuto del visore.
Qui descrivo l'uso diretto della calcolatrice
Uso diretto si usano le funzioni dirette e seconde ( 2F)
In modo del tutto analogo al precedente post.
Per uscire dall'uso diretto premere 2 volte il tasto 2F.
Indice delle funzioni e loro uso:
----------------------------------------------------------------------
Funzioni dirette
----------------------------------------------------------------------
Somma, sottrazione, : Si introducono i due operandi in Y ed X quindi si preme il tasto relativo alla funzione, il risultato viene posto in X.Enter: Introduce in x quanto è contenuto sul "visore" e fa salire il resto della catasta, quello che era in x sale in y, il contenuto di y sale in z, il contenuto di z sale in t.
Del Cancella il contenuto del visore.
F2 Tasto seconda funzione abilita la seconda funzione.
Questo tasto è utilizzato anche per altre funzioni nel programma (vedi note per F2)
----------------------------------------------------------------------------------
Funzioni seconde
----------------------------------------------------------------------------------
moltiplicazione, divisione: Si introducono i due operandi in Y ed X quindi si preme il tasto relativo alla funzione, il risultato viene posto in X
Sin, Tan, Cos : Restituiscono in X, il valore seno, tangente, coseno dell'angolo in Radianti contenuto in X.
Sqrt : Esegue la radice quadrata del contenuto in X, pone il risultato in X.
Y^x : Eleva a potenza , introdurre in Y il valore, in X l'esponente, il risultato è posto in X.
CHS : Cambio segno, cambia il segno ad X.
STO: Memorizza in un registro utente ( da 1 a 19) il contenuto di X, immettere in X il valore da memorizzare ( potrebbe anche essere il risultato di precedenti operazioni) poi nel visore scrivere il registro dove si vuole memorizzare (1 a 19) quindi premere il tasto funzione. Il contenuto di x rimane in x e viene duplicato nel registro indicato.
La stessa modalità si può utilizzare in programmazione:
1 inserire indice es : 01
2 inserire il codice : 67
queste due righe di programma memorizzano il contenuto di x nel registro utente 01.
RCL: Richiama in X il contenuto del registro ( da 1 a 19), immettere nel visore il numero del registro e premere il tasto funzione, in X avremo il contenuto del registro richiesto, il registro rimane invariato, nel registro lastx viene prima salvato il contenuto precedente di X.
La stessa modalità si può utilizzare in programmazione:
1 inserire indice es : 02
2 inserire il codice : 68
queste due righe di programma richiamano in x il valore contenuto nel registro indice 02.
FIX: Si possono impostare il numero dei decimali visualizzati ( da 0 a 5 ), scrivere in visore il numero da 0 a 5 e premere il tasto funzione. Di default ho posto a 4 i decimali.
Non programmabile
lastx: Recupera in X il contenuto precedente ad una operazione, il contenuto di X viene spostato in Y.
Utile per recuperare in caso di operazioni errate.
X_Y: Scambio X con Y, Insieme alla rotazione della catasta si può cambiare l'ordine degli operandi in catasta.
R! : Ruota giù, la catasta viene fatta ruotare y in x, z in y, t in z, x in t. Ad ogni pressione ruota fino a tornare nella situazione iniziale, utile per rivedere tutto il contenuto della catasta, ed eventualmente utilizzando lo scambio cambiarne la disposizione.
XEQ : Questa funzione richiama ed esegue funzioni o programmi, si scrive nel visore il numero della funzione e si preme il tasto XEQ, prima si dovrà immettere in catasta i valori richiesti dalla funzione e o programma rispettandone anche l'ordine. In uscita avremo la catasta aggiornata con i risulati.
Possono essere usati anche i registri utente che la funzione e/o programma possono utilizzare come input e/o come output.
La stessa modalità si può utilizzare in programmazione:
------------------------------------------------------------------------------------------
Riporto qui per maggior chiarezza le funzioni richiamabili.
da 1 a 3 arco seno di x, arco tangente di x, arcoseno di x, restituiscono in x l'angolo
relativo al valore trovato in x l'angolo è espresso in RADIANTI, si utilizza semplicemente
le funzioni della libreria. In Lastx si conserva il valore di partenza.
In programmazione queste si possono chiamare più semplicemente con il codice relativo:
4 e 5 converte angoli sesagesimali in sessadecimali e viceversa
6 richiama la costante PI (pigreco) anche questa nella libreria.
In programmazione si può digitare il codice 71:
9 cancella i registri catasta e visore, cancella anche lastx.
Queste funzioni usano due registi per input e output ( x , y).
10 da rettangolari a polari inserire in x la coordinata x, ed in y la coordinata y.
restituisce in y la distanza
restituisce in x angolo in RADIANTI
11 da polari a rettangolari inserire in x l'angolo alfa in RADIANTI
inserire in y la magnitudine o distanza.
restituisce le coordinate in x e y.
12 cancella memorie utente (tutte) non ha bisogno di input.
13 attiva o disattiva la notazione scientifica (ma se un numero è troppo grande
o troppo piccolo per essere visualizzato cambia automaticamente).
14 EEX entrata con l'esponente, per l'input di numeri con mantissa ed esponente
introdurre la mantissa in y e l'esponente in x.
15 e 16 logaritmo naturale ed e^x.
17 e 18 logaritmo in base 10 ed 10^x.
19 fattoriale di x ( x numero intero da 1 a 30 MAX), restituisce in x il fattoriale.
20 e 21 da RADIANTI a centesimali e viceversa.
-------------
**** P R O G R A M M A Z I O N E ****
Descrizione delle funzioni programmabili e relativi codici:
Codici da 1 a 19 --- INDICI si inseriscono nel programma prima della funzione che ne farà uso.
20 --- PRINT scrive sul display nella prima riga X= ...... e sotto la stringaUTENTE (che può anche essere vuota)
21 --- INPUT si possono inserire dati nei registri e nella catasta.
-----------------------------------------------------------------------------------------------------
Istruzioni funzioni "Arduino"
Istruzioni funzioni "Arduino"
30 --- PINPUT deve essere preceduta dal numero del pin da porre come Input.
31 --- PIOUT deve essere preceduta dal numero del pin da porre come Output.
32 --- DWHIGH deve essere preceduta dal numero del pin da porre ALTO (1).
33 --- DWLOW deve essere preceduta dal numero del pin da porre BASSO (0).
34 --- DREAD legge il valore 0/1 del pin indicato nell'istruzione che la precede.
35 -- AREAD legge il valore analogico del pin indicato nell'istruzione che la precede.
36 -- AWRITE scrive sul pin indicato il valore (0 -255) contenuto in x.
37 -- DELAY n scrivere prima uno dei seguenti indici :
1 = 5 mms, 2= 10, 3= 50, 4= 250, 5=500, 6 = 1000 mms
poi il codice 37 ed avremo un Delay del tempo indicato
per tempi diversi ripetere l'istruzione
38 -- TONE TONE (PIN,FREQUENZA,DURATA)
/ indirizzo per pin
nel regx la frequenza (intero)
// in regy se zero ( per fermare occorre la NOTONE)
// oppure inserire in y la durata in mms.
39 -- NOTONE per fermare la TONE indicare il pin da fermare.
(prima di attivare un pin occorre fermare il pin che esegue TONE)
--------------------------------------------------------------------------------------------------------------
Istruzioni di controllo ( IF )
Queste istruzioni eseguono il controllo,
il programma salta l'istruzione successiva SE VERA la condizione.
I controlli sono: 40 XmaY , 41 XmiY , 42 X=Y , 43 Xma0 , 44 Xmi0 .
45 -- INCn per simulare il for. Inserire un codice da 1 a 6 seguito dalla istruzione INCn (45).
Questa istruzione mette a disposizione 6 variabili di tipo intero,
inc1, inc2 ecc.. In fase di inserimento dati del programma queste
variabili si inizializzano con un valore da raggiungere ( target).
Nello stesso momento si pone a 0 le corrispondenti variabili
cont1, cont2 ecc.. che serviranno per il conteggio.
Tasto ( - ) durante la fase di Inserimento Dati
( vedi spiegazione tasti funzione più sotto)
Nella fase di elaborazione la variabile cont(n) viene incrementata di 1 ad ogni
ciclo, nel registro regx viene posto il cont attuale, ed in regy viene posto inc(n).
Ora si può fare un controllo X con Y per verificare se il target è stato raggiunto.
46 -- END con questa si indica la fine del programma. Quando il programma trova questa istruzione esce dall'esecuzione ed è disponibile per l'uso diretto.
47 -- LOOP questa istruzione se inserita crea un loop continuo il programma non termina.
La prima esecuzione del programma parte sempre dall'istruzione 0, se la loop è inserita come prima istruzione il programma riparte sempre da 0, altrimenti dopo la prima esecuzione le successive ripartono dalla riga loop.
Questo rende possibile eseguire un loop successivo ad una fase simile ad un setup.
48 -- RTN istruzione di fine subroutine.
Il programma torna alla riga successiva alla chiamata della corrispondente label.
Se questa istruzione non viene inserita il programma prosegue fino all'ultima istruzione.
49 -- NOP non operazioni
-------------------------------------------------------------------------------------------------------------------------
Matematiche
50 (-), 51 ( * ), 52 ( / ), 53 ( + )
54 -- CHS cambia segno al registro regx.
55 -- Y^x eleva il contenuto di regy alla potenza indicata in regx il risultato in regx.
56 -- 1/X uno su X ( esegue l'operazione 1/x il risultato nel regx)
57 -- disp
58 -- SQRT salva X in lastx e poi calcola la radice quadrata di X risultato in regx .
59 -- disp
-------------------------------------------------------------------------------------------------------------------------
Operazioni catasta.
60 -- DEL cancella "Visore" ( linea per inserimento dati ).
61 -- ENTER fa salire la catasta operativa ed introduce il contenuto del "Visore" nel registro
regx poi azzera il visore.
62 -- CLST cancella la catasta compreso lastx ed il visore.
63 -- LASTX nel registro regx ritorna il valore di lastx e sale tutta la catasta.
64 -- X_Y scambio fra regx e regy.
65 -- R! ruota la catasta GIU'
66 -- CLX azzera il registro x (prima salva il contenuto nel registro lastx)
67 -- STOnn introduce nel registro nn (indicato da indice ) il contenuto del regx.
68 -- RCLnn richiama dal registro nn (indicato da indice ) e pone il contenuto nel registro regx facendo salire la catasta.
69 -- R^ ruota la catasta SU
-------------------------------------------------------------------------------------------------------------------------
Trigonometriche
70 -- PI costante PI (pigreco) viene richiamate nel regx. (prima salva il contenuto di x in lastx)
71 -- SIN prima salva in lastx il registro x e poi calcola la funzione.
72 -- COS prima salva in lastx il registro x e poi calcola la funzione.
73 -- TAN prima salva in lastx il registro x e poi calcola la funzione.
74 -- ASIN prima salva in lastx il registro x e poi calcola la funzione.
75 -- ACOS prima salva in lastx il registro x e poi calcola la funzione.
76 -- ATAN prima salva in lastx il registro x e poi calcola la funzione.
--------------------------------------------------------------------------------------------------------------------------
Chiamata a SUB
da codice 80 a 85 SUB0, SUB1, SUB2, SUB3, SUB4, SUB5.
Questi codici indirizzano il programma sulla linea della relativa label.
Label da 90 a 95 LBL0, LBL1, LBL2,LBL3, LBL4, LBL5.
Quando il programma si sposta sulla label chiamata esegue le funzioni fino a trovare RTN
quando trova RTN torna all'istruzione successiva che ha chiamato la SUB, altrimenti prosegue fino alla fine del programma.
All'interno di una SUB è possibile chiamare altre sub fino ad un massimo di 6 nidificazioni.
--------------------------------------------------------------------------------------------------------------------------
88 -- XEQnn con questa si può chiamare una funzione od un programma.
Impostare nel visore il numero della funzione e/o programma e chiamare il
codice 88 (nella catasta o nei registri dovranno esserci già impostati i relativi dati per il calcolo.
Per esempio (funzione R-P da rettangolari a polari), posso impostare la coordinata X e la coordinata Y nei rispettivi registri poi nel programma indicherò
10 (numero di questa funzione) seguito da 88 ed avrò come risultato
in regy il vettore distanza, ed in regx l'angolo in radianti.
Questo codice XEQnn in pratica aggiunge molte altre possibili funzioni,
io ne ho preparate alcune ma altre possono essere fatte dall'utente per sua
comodità o per scopi specifici.
99 -- ENDEND fine del listato di programma (ultima istruzione).
-------------------------------------------------------------------------------------------------------------------------
Istruzioni di controllo ( IF )
Queste istruzioni eseguono il controllo,
il programma salta l'istruzione successiva SE VERA la condizione.
I controlli sono: 40 XmaY , 41 XmiY , 42 X=Y , 43 Xma0 , 44 Xmi0 .
45 -- INCn per simulare il for. Inserire un codice da 1 a 6 seguito dalla istruzione INCn (45).
Questa istruzione mette a disposizione 6 variabili di tipo intero,
inc1, inc2 ecc.. In fase di inserimento dati del programma queste
variabili si inizializzano con un valore da raggiungere ( target).
Nello stesso momento si pone a 0 le corrispondenti variabili
cont1, cont2 ecc.. che serviranno per il conteggio.
Tasto ( - ) durante la fase di Inserimento Dati
( vedi spiegazione tasti funzione più sotto)
Nella fase di elaborazione la variabile cont(n) viene incrementata di 1 ad ogni
ciclo, nel registro regx viene posto il cont attuale, ed in regy viene posto inc(n).
Ora si può fare un controllo X con Y per verificare se il target è stato raggiunto.
46 -- END con questa si indica la fine del programma. Quando il programma trova questa istruzione esce dall'esecuzione ed è disponibile per l'uso diretto.
47 -- LOOP questa istruzione se inserita crea un loop continuo il programma non termina.
La prima esecuzione del programma parte sempre dall'istruzione 0, se la loop è inserita come prima istruzione il programma riparte sempre da 0, altrimenti dopo la prima esecuzione le successive ripartono dalla riga loop.
Questo rende possibile eseguire un loop successivo ad una fase simile ad un setup.
48 -- RTN istruzione di fine subroutine.
Il programma torna alla riga successiva alla chiamata della corrispondente label.
Se questa istruzione non viene inserita il programma prosegue fino all'ultima istruzione.
49 -- NOP non operazioni
-------------------------------------------------------------------------------------------------------------------------
Matematiche
50 (-), 51 ( * ), 52 ( / ), 53 ( + )
54 -- CHS cambia segno al registro regx.
55 -- Y^x eleva il contenuto di regy alla potenza indicata in regx il risultato in regx.
56 -- 1/X uno su X ( esegue l'operazione 1/x il risultato nel regx)
57 -- disp
58 -- SQRT salva X in lastx e poi calcola la radice quadrata di X risultato in regx .
59 -- disp
-------------------------------------------------------------------------------------------------------------------------
Operazioni catasta.
60 -- DEL cancella "Visore" ( linea per inserimento dati ).
61 -- ENTER fa salire la catasta operativa ed introduce il contenuto del "Visore" nel registro
regx poi azzera il visore.
62 -- CLST cancella la catasta compreso lastx ed il visore.
63 -- LASTX nel registro regx ritorna il valore di lastx e sale tutta la catasta.
64 -- X_Y scambio fra regx e regy.
65 -- R! ruota la catasta GIU'
66 -- CLX azzera il registro x (prima salva il contenuto nel registro lastx)
67 -- STOnn introduce nel registro nn (indicato da indice ) il contenuto del regx.
68 -- RCLnn richiama dal registro nn (indicato da indice ) e pone il contenuto nel registro regx facendo salire la catasta.
69 -- R^ ruota la catasta SU
-------------------------------------------------------------------------------------------------------------------------
Trigonometriche
70 -- PI costante PI (pigreco) viene richiamate nel regx. (prima salva il contenuto di x in lastx)
71 -- SIN prima salva in lastx il registro x e poi calcola la funzione.
72 -- COS prima salva in lastx il registro x e poi calcola la funzione.
--------------------------------------------------------------------------------------------------------------------------
Chiamata a SUB
da codice 80 a 85 SUB0, SUB1, SUB2, SUB3, SUB4, SUB5.
Questi codici indirizzano il programma sulla linea della relativa label.
Label da 90 a 95 LBL0, LBL1, LBL2,LBL3, LBL4, LBL5.
Quando il programma si sposta sulla label chiamata esegue le funzioni fino a trovare RTN
quando trova RTN torna all'istruzione successiva che ha chiamato la SUB, altrimenti prosegue fino alla fine del programma.
All'interno di una SUB è possibile chiamare altre sub fino ad un massimo di 6 nidificazioni.
--------------------------------------------------------------------------------------------------------------------------
88 -- XEQnn con questa si può chiamare una funzione od un programma.
Impostare nel visore il numero della funzione e/o programma e chiamare il
codice 88 (nella catasta o nei registri dovranno esserci già impostati i relativi dati per il calcolo.
Per esempio (funzione R-P da rettangolari a polari), posso impostare la coordinata X e la coordinata Y nei rispettivi registri poi nel programma indicherò
10 (numero di questa funzione) seguito da 88 ed avrò come risultato
in regy il vettore distanza, ed in regx l'angolo in radianti.
Questo codice XEQnn in pratica aggiunge molte altre possibili funzioni,
io ne ho preparate alcune ma altre possono essere fatte dall'utente per sua
comodità o per scopi specifici.
99 -- ENDEND fine del listato di programma (ultima istruzione).
-------------------------------------------------------------------------------------------------------------------------
Tasti con funzioni multiple:
F2 ( tasto seconda funzione )
Se la calcolatrice è in uso diretto con la pressione del tasto si passa alle funzione secondarie dei tasti
( * ) , ( / ), SIN, COS ecc....
Premendo mentre siamo in 2F ( si vede dal visore con il 2 a sinistra) si esce dalla calcolatrice manuale e si riparte dal menù iniziale con la richiesta di scegliere fra arduQ o CALC.
Quando siamo in programmazione nell'EDITOR premendo F2 si indica la fine di scrittura del programma e si passa alla fase successiva.
Quando siamo in "Controllo" serve per uscire.
In fase di inserimento dati o stringhe serve per uscire.
-------------------------------------------------------------------------------------------------------------------------
Tasto ( - ) durante la fase controllo.
Si può correggere la linea di programma.
_ posizionarsi sulla riga da correggere
_ premere il tasto - (meno) e poi inserire il codice corretto, apparirà correzione OK.
_ Questo serve solo a sostituire una istruzione errata, il resto del programma rimane invariato.
_ Se serve cancellare la riga è sufficiente inserire una NOP ( 49) che non altera il programma.
_ posizionarsi sulla riga da correggere
_ premere il tasto - (meno) e poi inserire il codice corretto, apparirà correzione OK.
_ Questo serve solo a sostituire una istruzione errata, il resto del programma rimane invariato.
_ Se serve cancellare la riga è sufficiente inserire una NOP ( 49) che non altera il programma.
Tasto ( + ) durante la fase di controllo.
Con questo tasto si può inserire una nuova linea di programma. Tutto il programma si sposta dalla riga inserita in poi fino all'ultima.
_ posizionarsi con i tasti 1-3 sulla riga dove vogliamo inserire nuovo codice
_ si preme (+ )
_ ci chiede d'impostare il nuovo codice da inserire, inseriamo il codice
_ quindi sposta tutte le linee aggiungendo una riga al programma.
_ segnala con messaggio "correzione ok"
Per vedere la correzione spostarsi con i tasti 1-3.
_ posizionarsi con i tasti 1-3 sulla riga dove vogliamo inserire nuovo codice
_ si preme (+ )
_ ci chiede d'impostare il nuovo codice da inserire, inseriamo il codice
_ quindi sposta tutte le linee aggiungendo una riga al programma.
_ segnala con messaggio "correzione ok"
Per vedere la correzione spostarsi con i tasti 1-3.
In fase di controllo i tasti ( 1 ) e ( 3) servono per scorrere le istruzioni avanti e indietro.
-------------------------------------------------------------------------------------------------------------------------
Tasto ( + ) durante la fase di Inserimento Dati ( STOnn )
Dopo aver inserito in X il dato da memorizzare inserire in visore il registro desiderato e quindi
premere ( + ), nel registro nn viene inserito il valore.
Tasto ( - ) durante la fase di Inserimento Dati ( INCn)
Si può inserire il valore target del FOR in X ed nel visore il numero da 1 a 6 dei cicli possibili
poi premere il tasto ( - ).
Usare valori interi in ogni caso i registri utilizzati sono interi.
--------------------------------------------------------------------------------------------------------------------------
Programmi UTENTE
La programmazione con i codici qui proposta non è il massimo di semplicità ed immediatezza,
ma ho cercato di rendere disponibili le opzioni più comuni in un linguaggio di programmazione.
Le linee di programma attualmente previste sono 100.
Le label sono 6 ( possono essere chiamate più volte)
Le label LBL sono solo 6 e non possono essere inserite più volte nel programma.
Da una SUB si può chiamare altra SUB ma non se stessa.
Le IF di controllo possono essere fatte solo fra X e Y oppure fra X e 0.
Se il risultato del controllo è VERO salta l'istruzione successiva.
Il ciclo FOR è semplificato dalla INCn che mette a disposizione 6+6 variabili di tipo intero per il conteggio dei cicli.
Le variabili intere inc1, inc2, ...., inc6 contengono il valore da raggiungere, le variabili corrispondenti
con1, cont2, ... cont6 conterranno i valori incrementati, l'incremento è fisso di 1.
Per questi programmi occorre scrivere le varie istruzioni, poi scriversi i relativi codici, e poi inserirli.
Ho preparato alcuni esempi per meglio spiegare l'uso di questa calcolatrice.
Esempi di programmi in "codice99"
Considero che già utilizzate la calcolatrice in modo manuale ed abbiate ben chiaro come utilizzare la catasta operativa RPN.
In caso contrario date una lettura al precedente post
In caso contrario date una lettura al precedente post
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Questo esempio fa lampeggiare due led ed attiva il buzzer.
Si utilizzano i pin 8, e 10 per il led ed il pin 9 per il buzzer.
Prima si mettono in output i pin ( righe da 0 a 5 ) si indica il numero del pin seguito dall'istruzione PIOUT.
alla riga 6 si trova la label 0 LBL0 (codice 90)
Poi si accende un led si esegue un TONE ( in fase di inserimento dati ho introdotto 600 in Y ( durata del Tone, e 800 in X frequenza.
L'istruzione 12 esegue un Delay di 500mms
Quindi l'istruzione 14 spenge il led.
Poi si fanno le stesse cose con il secondo led.
Quindi all'istruzione 23 si trova la SUB0 che indirizza il programma sulla LBL0 riga 6
si entra così in LOOP che ripete le stesse istruzioni fino al reset della calcolatrice.
Allego un piccolo video dimostrativo.
Esempio di uso delle sub.
Uso i due led collegati ai pin 8 e 10.
Il programma del tutto simile al precedente serve solo a dimostrare l'uso delle sub.
La sub1 (LBL1 riga 10) fa accendere e spengere il led collegato al pin 8.
All'interno della sub1 viene chiamata la sub2 (LBL2 riga 21), questa sub fa accendere e spengere il led collegato al pin 10.
La sub2 quando trova RTN ritorna alla sub1 e a sua volta quando la sub1 trova RTN torna al programma principale.
IL programma principale continua eseguendo il loop fra la riga ( 4 LBL0 e la riga 8 SUB0).
In questi due sketch ho utilizzato un loop continuo ( per uscire occorre il reset della calcolatrice.)
Nel prossimo sketch faremo eseguire un numero determinato di cicli.
Qui si utilizza la funzione INCn che simula il FOR .
Il programma aggiunge rispetto al precedente 3 istruzioni
6 01 01 Questa indica quale INCn useremo
7 INCn 45 ad ogni passaggio la variabile cont1 viene incrementata
8 X=Y? 42 controlla se abbiamo raggiunto il target immesso nella fase ins dati.
con queste istruzioni si esegue il programma per un numero di volte da noi voluto
(nel campo int )
Arrivati al numero scelto il programma termina.
Se si esegue una seconda volta il programma occorre reinserire il valore target nella fase Inserimento dati.
La funzione INCn vista sopra può essere fatta anche con istruzioni in codice99 con qualche istruzione in più.
Vediamo il diagramma di flusso.
In questo sketch si legge un pin analogico A0 il valore letto va in X viene confrontato con il valore che abbiamo in Y (inserito nella fase "Inserimento dati" ) e se maggiore esegue l'istruzione successiva quindi torna a leggere un nuovo valore, questa fase si ripete fino a quando il valore X non risulta minore di Y ( loop corto).
Quando la luce diminuisce e X risulta minore del valore immesso in Y salta l'istruzione e prosegue accendendo il led e tornando alla partenza e così rimane fino a quando non cambia ulteriormente la luce ambiente ed il valore di X risulta MAGGIORE di Y.
Lo sketch ripete il loop fino al reset della calcolatrice.
Se avete salvato il programma nella EEPROM potrete richiamarlo e magari provare ad inserire in Y un valore diverso come soglia di luce.
Credo che con gli esempi fatti si possa capire come utilizzare questa calcolatrice.
Nel video qui sotto si vedono alcune funzionalità della calcolatrice, in particolare come scorrere il listato introdotto ed il funzionamento del (PRIMO) e del (QUARTO) sketch che ho proposto qui sopra.
Il listato per Arduino che allego è funzionante ma non ho testato tutte le possibilità.
La gestione degli errori nei programmi utente non è stata implementata.
In caso di errori o loop infiniti rimane solo la possibilità di reset.
Questo il messaggio dell' IDE dopo la compilazione.
Lo sketch usa 26.478 byte (82%) dello spazio disponibile per i programmi. Il massimo è 32.256 byte.
Le variabili globali usano 1.200 byte (58%) di memoria dinamica, lasciando altri 848 byte liberi per le variabili locali. Il massimo è 2.048 byte.
Scaricate lo sketch aggiungete le librerie richieste all'IDE
Sergio.
Si utilizzano i pin 8, e 10 per il led ed il pin 9 per il buzzer.
Prima si mettono in output i pin ( righe da 0 a 5 ) si indica il numero del pin seguito dall'istruzione PIOUT.
alla riga 6 si trova la label 0 LBL0 (codice 90)
Poi si accende un led si esegue un TONE ( in fase di inserimento dati ho introdotto 600 in Y ( durata del Tone, e 800 in X frequenza.
L'istruzione 12 esegue un Delay di 500mms
Quindi l'istruzione 14 spenge il led.
Poi si fanno le stesse cose con il secondo led.
Quindi all'istruzione 23 si trova la SUB0 che indirizza il programma sulla LBL0 riga 6
si entra così in LOOP che ripete le stesse istruzioni fino al reset della calcolatrice.
Allego un piccolo video dimostrativo.
Esempio di uso delle sub.
| SKETCH – lampeggio di due led utilizzando due sub (SECONDO) | |||||
| Riga | istruzione | codice | note | ||
| 0 | 8 | 8 | pin digitale 8 collegato al led | ||
| 1 | PIOUT | 31 | il pin 8 in OUTPUT | ||
| 2 | 10 | 10 | pin digitale 10 collegato al led | ||
| 3 | PIOUT | 31 | il pin 10 in OUTPUT | ||
| 4 | LBL0 | 90 | Label 0 | ||
| 5 | SUB1 | 81 | SUB 1 SI ESEGUE LA Sub va alla LBL1 | ||
| 6 | NOP | 49 | inserite per indicare possibili altre istruzioni | ||
| 7 | NOP | 49 | |||
| 8 | SUB0 | 80 | SUB 0 ( va alla riga 4 codice 90 ) LOOP | ||
| 9 | END | 46 | END programma | ||
| 10 | LBL1 | 91 | inizio SUB1 | ||
| 11 | 8 | 8 | |||
| 12 | DWHIGH | 32 | il pin 8 si porta alto HIGH | ||
| 12 | 5 | 5 | valore per delay ( 500 mms) | ||
| 14 | DELAY | 37 | esegue DELAY | ||
| 15 | 8 | 8 | |||
| 16 | DWLOW | 33 | il pin 8 si porta basso LOW | ||
| 17 | SUB2 | 82 | SUB2 esegue la sub va alla LBL2 | ||
| 18 | NOP | 49 | inserite per indicare possibili altre istruzioni | ||
| 19 | NOP | 49 | |||
| 20 | RTN | 48 | Torna a riga seguente la SUB1 (6) | ||
| 21 | LBL2 | 92 | |||
| 22 | 10 | 10 | |||
| 23 | DWHIGH | 32 | il pin 10 si potra alto HIGH | ||
| 24 | 5 | 5 | |||
| 25 | DELAY | 37 | esegue DELAY | ||
| 26 | 10 | 10 | |||
| 27 | DWLOW | 33 | il pin 10 si porta basso LOW | ||
| 28 | RTN | 48 | Torna a riga seguente la SUB2 (18) | ||
Uso i due led collegati ai pin 8 e 10.
Il programma del tutto simile al precedente serve solo a dimostrare l'uso delle sub.
La sub1 (LBL1 riga 10) fa accendere e spengere il led collegato al pin 8.
All'interno della sub1 viene chiamata la sub2 (LBL2 riga 21), questa sub fa accendere e spengere il led collegato al pin 10.
La sub2 quando trova RTN ritorna alla sub1 e a sua volta quando la sub1 trova RTN torna al programma principale.
IL programma principale continua eseguendo il loop fra la riga ( 4 LBL0 e la riga 8 SUB0).
In questi due sketch ho utilizzato un loop continuo ( per uscire occorre il reset della calcolatrice.)
Nel prossimo sketch faremo eseguire un numero determinato di cicli.
Qui si utilizza la funzione INCn che simula il FOR .
Il programma aggiunge rispetto al precedente 3 istruzioni
6 01 01 Questa indica quale INCn useremo
7 INCn 45 ad ogni passaggio la variabile cont1 viene incrementata
8 X=Y? 42 controlla se abbiamo raggiunto il target immesso nella fase ins dati.
con queste istruzioni si esegue il programma per un numero di volte da noi voluto
(nel campo int )
Arrivati al numero scelto il programma termina.
Se si esegue una seconda volta il programma occorre reinserire il valore target nella fase Inserimento dati.
| SKETCH – lampeggio di due led utilizzando due sub ( TERZO) | |||||
| Riga | istruzione | codice | note | ||
| 0 | 8 | 8 | pin digitale 8 collegato al led | ||
| 1 | PIOUT | 31 | il pin 8 in OUTPUT | ||
| 2 | 10 | 10 | pin digitale 10 collegato al led | ||
| 3 | PIOUT | 31 | il pin 10 in OUTPUT | ||
| 4 | LBL0 | 90 | Label 0 | ||
| 5 | SUB1 | 81 | SUB 1 SI ESEGUE LA Sub va alla LBL1 | ||
| 6 | 1 | 1 | si usa la INC 1 | ||
| 7 | INCn | 45 | ad ogni passaggio incrementa il contatore | ||
| 8 | X=Y? | 42 | controlla se abbiamo raggiunto il target | ||
| 9 | SUB0 | 80 | SUB 0 ( va alla riga 4 codice 90 ) LOOP | ||
| 10 | END | 46 | END programma | ||
| 11 | LBL1 | 91 | inizio SUB1 | ||
| 12 | 8 | 8 | |||
| 13 | DWHIGH | 32 | il pin 8 si porta alto HIGH | ||
| 14 | 5 | 5 | valore per delay ( 500 mms) | ||
| 15 | DELAY | 37 | esegue DELAY | ||
| 16 | 8 | 8 | |||
| 17 | DWLOW | 33 | il pin 8 si porta basso LOW | ||
| 18 | SUB2 | 82 | SUB2 esegue la sub va alla LBL2 | ||
| 19 | NOP | 49 | inserite per indicare possibili altre istruzioni | ||
| 20 | NOP | 49 | |||
| 21 | RTN | 48 | Torna a riga seguente la SUB1 (6) | ||
| 22 | LBL2 | 92 | |||
| 23 | 10 | 10 | |||
| 24 | DWHIGH | 32 | il pin 10 si potra alto HIGH | ||
| 25 | 5 | 5 | |||
| 26 | DELAY | 37 | esegue DELAY | ||
| 27 | 10 | 10 | |||
| 28 | DWLOW | 33 | il pin 10 si porta basso LOW | ||
| 29 | RTN | 48 | Torna a riga seguente la SUB2 (18) | ||
La funzione INCn vista sopra può essere fatta anche con istruzioni in codice99 con qualche istruzione in più.
Prova di funzionamento:
Utilizzate il pin digitale 09 per il LED ed il pin analogico A1 per collegare la fotoresistenza.
(nell'immagine qui sotto il filo verde è erroneamente posizionato sul pin A0 ) .
Dovrete inserire un valore in Y che corrisponda alla soglia di luce alla quale si deve accendere il led.
Vediamo il diagramma di flusso.
Quando la luce diminuisce e X risulta minore del valore immesso in Y salta l'istruzione e prosegue accendendo il led e tornando alla partenza e così rimane fino a quando non cambia ulteriormente la luce ambiente ed il valore di X risulta MAGGIORE di Y.
Lo sketch ripete il loop fino al reset della calcolatrice.
Se avete salvato il programma nella EEPROM potrete richiamarlo e magari provare ad inserire in Y un valore diverso come soglia di luce.
| SKETCH – simil WHILE (QUARTO) | |||||
| Riga | istruzione | codice | note | ||
| 0 | 9 | 9 | pin digitale 9 collegato al led | ||
| 1 | PIOUT | 31 | il pin 8 in OUTPUT | ||
| 2 | LBL0 | 90 | Label 0 | ||
| 3 | 1 | 1 | PIN A1 | ||
| 4 | AREAD | 35 | legge il valore analogico sul pin A1 | ||
| 5 | X |
42 | in Y avremo impostato un valore (ES= 90) | ||
| 6 | SUB0 | 80 | SUB 0 ( va alla riga 2 codice 90 ) LOOP | ||
| 7 | 9 | 9 | pin digitale 9 collegato al led | ||
| 8 | DWHIGH | 32 | il pin 9 si porta alto HIGH | ||
| 9 | 5 | 5 | valore per delay ( 500 mms) | ||
| 10 | DELAY | 37 | esegue DELAY | ||
| 11 | 9 | 9 | pin digitale 9 collegato al led | ||
| 12 | DWLOW | 33 | il pin 9 si porta basso LOW | ||
| 13 | SUB0 | 80 | SUB 0 ( va alla riga 2 codice 90 ) LOOP | ||
| 14 | END | 46 | FINE PROGRAMMA | ||
| 15 | |||||
Credo che con gli esempi fatti si possa capire come utilizzare questa calcolatrice.
Nel video qui sotto si vedono alcune funzionalità della calcolatrice, in particolare come scorrere il listato introdotto ed il funzionamento del (PRIMO) e del (QUARTO) sketch che ho proposto qui sopra.
Il listato per Arduino che allego è funzionante ma non ho testato tutte le possibilità.
La gestione degli errori nei programmi utente non è stata implementata.
In caso di errori o loop infiniti rimane solo la possibilità di reset.
Questo il messaggio dell' IDE dopo la compilazione.
Lo sketch usa 26.478 byte (82%) dello spazio disponibile per i programmi. Il massimo è 32.256 byte.
Le variabili globali usano 1.200 byte (58%) di memoria dinamica, lasciando altri 848 byte liberi per le variabili locali. Il massimo è 2.048 byte.
Come si vede c'è ancora spazio per aggiunte e o modifiche allo sketch, sono graditi commenti o segnalazioni di errori.
Scaricate lo sketch aggiungete le librerie richieste all'IDE
Sergio.
Nessun commento:
Posta un commento
Vi ringrazio per la lettura e vi invito al prossimo post.
Se il post vi è stato utile, vi è piaciuto oppure no, scrivete un commento.
Un saluto a tutti.
Sergio
Copyright - Condizioni d’uso - Disclaimer
http://avventurarduino.blogspot.it/2012/10/inizia-lavventura-arduino-12-settembre.html