Calcolatrice scientifica - Scientific calculator

 Calcolatrice RPN con 48 tasti

Si costruisce una calcolatrice migliorata rispetto a quella  realizzata nel 2017 che trovate su questo blog.

- Calcolatrice RPN -mia

Calcolatrice RPN con Arduino - 

-  RPN Calculator with Arduino-

- 28/08/2017-

Questo progetto utilizza 48 tasti per l'input  ed un display a 4 righe x 20 in questo modo è più facile e divertente  utilizzare la calcolatrice.

Il prototipo da me realizzato è molto spartano ma ognuno di Voi potrà realizzare un contenitore migliore. E' possibile alimentazione con batteria.

Questo progetto è interessante per la sua possibilità di personalizzazione ed utilizzo di quasi tutte le schede della famiglia "Arduino".

Potrete personalizzare sia il contenitore che lo sketch aggiungendo funzioni e programmi . 

Materiale occorrente:

Arduino UNO  oppure altre schede come Mega 2560 ed altre.

3 tastierini da 16 tasti per formare una tastiera di 4 righe x 12 colonne

Display 4 righe 20 caratteri I2C 

Si può collegare anche un display 4x20 non I2C ( ma in questo caso bisogna usare il Mega perché su Arduino UNO non sarebbero sufficienti i pin)

Cambiando la scheda si dovranno fare poche modifiche allo schema ed allo sketch.

Caratteristiche di questa versione:

A _ Con la tastiera a 48 tasti molte funzioni sono eseguibili con la pressione di un tasto.

B _ Rimangono disponibili molti tasti con la possibilità di assegnare loro una                        SECONDA FUNZIONE.

C_ Il display con 4 righe permette di visualizzare i registri X, Y, Z e quindi                             maggior facilità dell'uso della catasta operativa.

D_ Lo sketch è predisposto per inserire nuove funzioni ed assegnarle ai tasti disponibili         come seconda funzione.

E_ Possibilità d'integrare funzioni o programmi da richiamare con XEQ nn, questi programmi o funzioni possono essere integrati e richiamabili come le funzioni della calcolatrice facendo uso della catasta o dei registri di memoria.

F_ Possibilità di alimentazione a batteria diventando portatile.

Questa versione NON supporta la programmazione (diretta).*

 Non supporta le funzioni rivolte ai pin di Arduino presenti nel progetto "ArduinoQuadro".

Ho quindi semplificato l'uso e reso semplice l'integrazione e l'aggiunta di programmi o funzioni per una personalizzazione completa.

Manca si la possibilità di programmarla direttamente ma vedremo come sia semplice preparare dei programmi da integrare nella calcolatrice, e richiamabili con XEQnn.

Qui sotto trovate due schemi di collegamento :

Schema con Arduino UNO

Schema con ATmega 2560

Come si vede lo schema di collegamento è molto semplice.

I tastierini hanno 8 pin ciascuno i 4 a sinistra identificano la colonna ed i 4 a destra identificano le righe.

Si collegano insieme le 4 righe di ogni tastierino e queste le mandiamo a 4 pin di Arduino

Nello schema righe (verde, blu, grigio, marrone).

Ogni colonna (12) invece la colleghiamo ad un pin di Arduino (colori rosa, porpora, arancione, giallo)

La pressione di un tasto individua la chiusura dell'incrocio RigaX, e ColonnaY, la libreria Keypad.h provvede a restituire nella variabile key il codice del tasto premuto.

Lo sketch è molto commentato e si possono comprendere i vari passaggi.

Si possono realizzare con altre schede della famiglia Arduino cambiando i collegamenti dei tastierini (righe e colonne), e cambiare nello sketch la sola parte che riguarda i pin a cui sono collegati i tastierini.

Qui sotto la porzione di sketch da modificare.

//-----------------------------------------------------------------------------

//           pin assegnati al tastierino per ARDUINO UNO

//-----------------------------------------------------------------------------

byte pinrighe[righe] = {14, 15, 16, 17};  // pin analogici A0, A1, A2, A3

byte pincolonne[colonne] = {13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2};

//------------------------------------------------------------------------------

//            pin assegnati al tastierino per ATMEGA 2560

//------------------------------------------------------------------------------

    byte pinrighe[righe] = {23, 25, 27, 29};

byte pincolonne[colonne] = {53, 51, 49, 47, 45, 43, 41, 39, 37, 35, 33, 31};

//------------------------------------------------------------------------------

Se utilizzate Arduino MEGA con lo schema sopra indicato sono valide le righe in rosso

e quindi potete commentare le altre.

Se utilizzate Arduino UNO  sono valide le righe blu e commentate le righe rosse.

In ogni caso per qualsiasi altra scheda utilizzata seguite questo metodo. 

ATTENZIONE il mio display ha questo indirizzo

LiquidCrystal_PCF8574 lcd(0x27);

Il Vostro LCD potrebbe avere altro indirizzo, controllate anche di includere la libreria del vostro lettore LCD, in qualche caso potrebbero essere necessarie delle modifiche nello sketch alle istruzioni che mostrano i dati.

Uso della calcolatrice.

Su questo stesso blog trovate  alcune prime indicazioni nel post 

Calcolatrice RPN con Arduino

Calcolatrice RPN

Sul Web trovate anche i manuali della HP41 a cui mi sono ispirato.

Qui trovate lo sketch ( riferito allo schema MEGA) ma contiene anche le righe per Arduino uno come indicato sopra da modificare.

Questo il risultato verifica con IDE 2 di Arduino per il Mega:

Lo sketch usa 22272 byte (8%) dello spazio disponibile per i programmi. Il massimo è 253952 byte.

Le variabili globali usano 962 byte (11%) di memoria dinamica, lasciando altri 7230 byte liberi per le variabili locali. Il massimo è 8192 byte.

Come potete vedere c'è spazio per modifiche ed aggiunte di funzioni.

Lo sketch v506-48-v109.ino

Lo sketch si compone di più schede per poterlo leggere più agevolmente.

Scheda principale con il LOOP

 Qui ci sono le dichiarazioni, il setup, i pin utilizzati per il tastierino, le sub per l'inserimento dei dati e la chiamata alle funzioni. 

SCHEDA FUNZIONI DIRETTE E SECONDE
Qui trovate tutte le funzioni della calcolatrice dirette e con tasto 2F

SCHEDA XEQ-STO-RCL
 dedicata alle funzioni che vengono chiamate con indirizzo nn

SCHEDA PROG

Per i programmi da chiamare con XEQ (nn) numero programma, che potete integrare con i vostri programmi.

SCHEDA NOMI FUNZIONI

In questa trovate tutti i nomi funzioni che vengono visualizzati a destra sulla prima riga del LCD 
In questo sketch ho dato un tempo di 300 ms, potete cambiarlo o non visualizzare il nome funzione.

Indice delle funzioni e loro uso:

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

Funzioni dirette

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

Somma, sottrazione, moltiplicazione, divisione :

 Si introduce il primo operando, poi il secondo e si preme il tasto operatore 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 e disabilita la seconda funzione.

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 (01-19) quindi premere il tasto funzione STO. Il contenuto di x rimane in x e viene duplicato nel registro indicato.

RCL: Richiama in X il contenuto del registro ( da 01 a 19), immettere nel visore il numero del registro e premere il tasto funzione RCL, in X avremo il contenuto del registro richiesto, il registro rimane invariato, nel registro lastx viene prima salvato il contenuto precedente di X.

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 FIX. Di default ho posto a 4 i decimali.

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

Possono essere usati anche i registri utente che la funzione e/o programma possono utilizzare come input e/o come output.

 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.

 In Lastx si conserva il valore di partenza.

 costante PI (pigreco)  in x.

CLST cancella i registri catasta e visore, cancella anche lastx.

Altre funzioni che usano due registi per input e output ( x , y).

R>P  : Da coordinate rettangolari a polari, x,y  inserire le due coorinate e premere il tasto R>P restituisce in y la distanza in x l'angolo in radianti.

P>R  : 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.

Log : logaritmo in base 10.

LN : logaritmo in base e.

R^ : Rsu ruota la catasta  regx sale in regy , regy sale in regz e così via.

Aggiornamento 18/02/23 lo sketch aggiornato è v506-48-v109 

Questa è la tabella di corrispondenza dei tasti e del codice.

Ho aggiunto alcune funzioni e programmi da chiamare con la XEQnn

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

Funzioni seconde  ( prima premere il tasto 2F)

appare sulla linea del visore il 2, per togliere la 2F premere ancora il tasto, 

sul visore appare 1.

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

FACT : calcola il fattoriale di x

xSQRy : calcola radice x del registro y

% : calcola la percentuale x del registro y

FRC : parte frazionaria di x ( elimina la parte intera di x)

INT : parte intera di un numero ( elimina la parte decimale senza arrotondamento).

%D : calcola pa differenza percentuale fra Y ed X 

MOD : resto della divisione Y / X 

Ho aggiunto solo 8 seconde funzioni dalla tabella sopra potete vedere che sono disponibili molti altri tasti da usare come seconda funzione (d nella tabella).

E' possibile aggiungere altre seconde funzioni per farlo occorre seguire questi passi:

1) nella sub void funzioni() - scheda principale-

aggiungere nello spazio dedicato alle seconde funzioni ( vedi qui sotto)

 //--------------------------------------------------

 //end funzioni_dirette

 //--------------------------------------------------

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

 //

 //     SECONDE FUNZIONI

 //

 //**************************-

 if (codice == 112) //fact() // funzione fattoriale max 30

  {

    nome_funzione(codice);

    if (visore != 0)enter();

    fact();

  }

una porzione di codice che richiami la nostra nuova funzione 

si può copiare questa cambiare il codice del tasto  e il nome della nuova funzione .

2) nella scheda :

 FUNZIONI DIRETTE E SECONDE CON 2F

scrivere una void con nome funzione che esegua il calcolo.

3)  aggiornare la scheda " NOMI FUNZIONI "

basterà indicare il nome scelto e sostituirlo al posto del codice 

 

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

  //  seconde funzioni + 50 da 93 a 140

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

 

  if (codice == 93)nomeFunzione = "093";// tasto piu

  if (codice == 94)nomeFunzione = "094";// tasto per

  if (codice == 95)nomeFunzione = "095";// tasto meno

  if (codice == 96)nomeFunzione = "097";// tasto diviso

  if (codice == 108)nomeFunzione = "108";//  

  if (codice == 109)nomeFunzione = "109";//

  if (codice == 110)nomeFunzione = "110";//

  if (codice == 111)nomeFunzione = "111";//

  if (codice == 112)nomeFunzione = "FACT";// FATTORIALE DI X

  if (codice == 113)nomeFunzione = "Rx-Y";// RADICE x DI Y

  if (codice == 114)nomeFunzione = " % ";// PERCENTUALE x DI Y

  if (codice == 115)nomeFunzione = "115";// 2F

  if (codice == 116)nomeFunzione = "116";//

  if (codice == 117)nomeFunzione = "117";//

  if (codice == 118)nomeFunzione = "118";//

  if (codice == 119)nomeFunzione = "119";//

  if (codice == 120)nomeFunzione = "FRC";// PARTE FRAZIONARIA DI X

  if (codice == 121)nomeFunzione = "INT";// PARTE INTERA DI X

  if (codice == 122)nomeFunzione = "% DI";// DIFFERENZA PERCENTUALE FRA X ED Y

  if (codice == 123)nomeFunzione = "MOD";// MODULO DIVISIONE Y MOD X IL RESTO è IN X

  if (codice == 124)nomeFunzione = "124";//

per esempio se abbiamo scelto il tasto relativo al codice 116 basterà inserire il nome della funzione abbreviato vedi esempi.

( questa operazione serve solo a visualizzare il nome della funzione eseguita ma non influisce sul calcolo )

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

Programmi aggiuntivi

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

Con questo aggiornamento ho aggiunto anche alcuni programmi di esempio richiamabili con la XEQ nn 

Questi programmi sono realizzabili scrivendoli con l'IDE Arduino nella scheda PROG-DI-XEQnn

Se si vuole aggiungere un programma si

// dovrà  modificare queste parti:

// 1) aggiungere in questa scheda il programma con suo nome

// 2) modificare in questa scheda il prog catalog aggiungendolo

// 3) modificare la scheda XEQ-STO-RCL nella parte relativa

// alla chiamata XEQnn inserendo nel ciclo case

// il nome del nuovo programma

Ho aggiunto il programma (1)  void catalog() 

questo programma visualizza il numero ed il nome dei programmi contenuti nella scheda quindi se aggiungete programmi aggiornate anche il catalog con il nome del nuovo programma. 

 programma (2)   carnot() 

void carnot()  // funzione 02 ****

     {

      //  angolo in x in RADIANTI

     double latoa = regz; // uno dei lati conosciuti

     double latob = regy; // il secondo lato conosciuto

     double angolo = regx;// angolo compreso fra i due lati

     //  si cerca il terzo lato

     //  gli angoli sono inseriti in RADIANTI  INPUT

     //  gli angoli saranno in RADIANTI

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

     // due lati ed angolo compreso

     

     double latoc = sqrt(pow(latoa,2)+ pow(latob,2)-(2*latoa*latob)*cos(angolo));

     regx = latoc;  // in x troviamo il lato cercato opposto all'anglo compreso

     regy = latob;  // lato noto

     regz = latoa;  // lato noto

     regt = angolo; // angolo noto  in radianti

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

} // fine carnot

Si calcola il terzo lato del triangolo, conoscendo i due lati e l'angolo compreso, angoli in radianti.

 programma (3)  parallelo() resistori inserire in x ed in y i valore di due resistenze.

( valori espressi nella stessa unità di misura ) in x ritroviamo il valore del parallelo. 

void parallelo() // prog 03

{

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

 //       PARALLELO RESISTORI

 //

 //  //   r1 -r2

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

 // si inseriscono in x ed in y i valori di due resistori.

 //

 // questo programma modifica tutto lo stak

 // in uscita avremo in x la resistenza parallelo

 //

   

     double resp = 0;

   

        resp =  1/ ((1/regx)+ (1/regy));

       

      regx = resp;

      regy = 0;

      regz = 0;

      regt = 0;

}

// fine parallelo

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

programma (4)  erone()  Calcolo superfice triangolo noti i tre lati.

si inseriscono i tre lati in x,y,z e si ottiene la superficie in x.

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

//              superficie triangolo con Erone

//    noti i tre lati  in x lato a, in y lato b, in z lato c

//   restituisce in x la superficie, in y,z, t i lati a,b,c.

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

//

void erone()  //  fuzione 04 ****

{

 double latoa = regx;

 double latob = regy;

 double latoc = regz;

 

if (latoa >= (latob+latoc)|| latob >= (latoc + latoa)|| latoc >=(latob+latoa)) return;

         

    else {

         

            double perimetro = latoa + latob + latoc;

            double per2 = perimetro/2;

            double super = sqrt(per2*((per2-latoa)*(per2-latob)*(per2-latoc)));

            regx = super;

            regy = latoa;

            regz = latob;

            regt = latoc;

         }

}// fine erone

programma (5)   partitore()  Inserire Vin in x, e i valori delle resistenze in serie 

Vedi listato qui sotto 

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

// partitore di tensione

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

void partitore() // funzione 05

{

  //Vn= VIN(Rn/(R1 + R2 + R3)

    double r1 = regy; // inserire valore R1 in omm

    double r2 = regz; // inserire valore R2 in omm

    double r3 = regt; // inserire valore R3 se non serve inserire 0

    double vin = regx;// inserire Vin in Volt

    double v1 = vin * ( r1 / ( r1+r2+r3));

    double v2 = vin * ( r2 / ( r1+r2+r3));

    double v3 = vin * ( r3 / ( r1+r2+r3));

    regx = v1;  // Volt in v1

    regy = v2;  // Volt in v2

    regz = v3;  // Volt in v3

    regt = 0;

} // fine partitore

programma (6)  sco_iva()  Scorporo iva inserire in y l'aliquota, ed in x il totale con iva.

avremo in x iva, in y l'imponibile, in z il totale ed in t l'aliquota.

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

//       SCORPORO IVA impostare  in Y l'aliquota

//                    impostare  in X il totale compreso IVA

//           in OUTPUT avremo:

//           x = IVA, y = imponibile, z = il totale, t = aliquota.

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

//          

void sco_iva()//   funzione 06 ****

{

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

      double aliq = regy;

      double total = regx;

      double imponibile = (total*100)/(100+aliq);

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

      //output

      regx = (total - imponibile); // IVA

      regy =  imponibile;

      regz = total;

      regt = aliq;

 

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

} // fine scorporo iva

//---------------------------------------------------------------------------------------

Si possono realizzare programmi richiamabili utilizzando la stessa struttura.

Lasciate un commento se avete domande o riscontrate errori.

Grazie!!

Qui sopra la foto con le funzioni 2F aggiunte ( vedi tasti sulla destra con due funzioni).

Per utilizzarle premere il tasto 2F, per uscire dalle seconde funzioni premere ancora il tasto 2F.