venerdì 15 dicembre 2017

ArduinoQuadro

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

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


Se si sceglie 3 (arduQ) si trova una ulteriore richiesta, se utilizzare il programma in memoria o scrivere un nuovo programma.




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




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;}

}

//*************************************************

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

richiama la costante PI (pigreco) anche questa nella libreria.
In programmazione si può digitare il codice 71:

7 e 8 converte angoli da RADIANTI a sessagesimali e viceversa.

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"

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

-------------------------------------------------------------------------------------------------------------------------

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.

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

SKETCH – lampeggio di due led e beep con buzzer.  ( PRIMO)
Riga
istruzione codice
note
0
9 9
pin digitale 9 collegato al Buzzer
1
PIOUT 31
il pin 9 in OUTPUT
2
8 8
pin digitale 8 collegato al led
3
PIOUT 31
il pin 8 in OUTPUT
4
10 10
pin digitale 10 collegato al led
5
PIOUT 31
il pin 10 in OUTPUT
6
LBL0 90
Label 0
7
8 8

8
DWHIGH 32
il pin 8 si porta alto HIGH
9
9 9

10
TONE 38
si esegue TONE (in x 800 freq, in y 600 durata)
11
5 5
valore per delay ( 500 mms)
12
DELAY 37
esegue DELAY
12
8 8

14
DWLOW 33
il pin 8 si porta basso LOW
15
10 10

16
DWHIGH 32
il pin 10 si potra alto HIGH
17
9 9

18
TONE 38
esegue TONE sul pin 9
19
5 5

20
DELAY 37
esegue DELAY
21
10 10

22
DWLOW 33
il pin 10 si porta basso LOW
23
SUB0 80
SUB 0 ( va alla riga 6 codice 90 )
24
END 46
END programma
25









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.

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.


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.

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