Calculator GD9841R

The GD9841R Calculator

16 digit 14 segment LED display

20 digit x4 line LCD display

ATSAMD21G18 ARM Cortex M0 processor, 48 MHz
256K of FLASH, 32K of RAM

Rotary dial to select functions

Real time clock

Arduino IDE programmable in C++

By Gordon Dyer (gordyer@gmail.com).

To learn Arduino C++ programming, I decided to build a calculator that emulates the RPN stack of an HP-41C or HP-42S.

Using a 16 digit 14 segment alphanumeric display gives each character the look of the HP-41 but with a more retro LED display the size of old Nixie tube characters from the '50's and '60s.

To display the full 4 number RPN stack, I added a 20x4 LCD display with RGB back-lighting. The back-lighting colour is used to indicate the battery charge level, it changes from green through orange and then red as the battery discharges.

Calculations all use double precision 64-bit numbers. The 11 bit width of the exponent allows the representation of numbers between 10^−308 and 10^+308, and the 52 bit fraction gives full 15 to 17 decimal digits of precision.

The keyboard is a 6x5 matrix with traditional full travel key switches and key caps in a 70's colour scheme very reminiscent of the HP9825. https://www.hpmuseum.org/hp9825.htm

Selecting one of the many functions on the HP-41C or HP42S is a slow and painful process taking many key presses, so I have used a rotary encoder switch to select functions quickly. Apart from all the usual mathematical functions I have implemented a few unusual ones, including Prime Numbers, Number of Primes, Fibonacci sequence, Golden Ratio, Chinese Zodiac (to nearest year) and Volume of oil in a cylinder on its side. This is because my heating oil tank is a large cylinder on its side, 2.1m long and 1.2m diameter and I need to know how much oil is there from the oil depth tube.

A real time clock is included and the date and time can be shown on either of the two displays.

The power up display:

The famous HP-41C "Flying Duck" character announces the calculator is ready to use:

The LCD display is used to show the 4 number Stack X, Y, Z, T and can display the time, battery condition and indicates battery charge level using the RGB backlight colours.

Under the Bonnet (Hood) - there's not much in there!

Top left - Rotary encoder/switch

then the Sparkfun 20x4 LCD with RGB backlight

Top right - Keyboard PCB

Middle - a red shadow in the lid shows the back of the LED display board and red acrylic window

Bottom left - a stack of 3 Adafruit Feather boards with ATMEL M0 processor and SD card at the bottom, the DS3231 real time clock in the middle and the sparkfun Qwiic I2C interface on top.

Bottom right - LiPo battery 2000mAh and mounted on it is an Adafruit Battery monitor and 'fuel' guage

Inspiration for the GD9841R was taken from the HP9825, the HP-41C and the HP-42S

HP9825A Numeric Keys

A 14 segment display was chosen to look like the HP-41C

See the Museum of HP Calculators: https://www.hpmuseum.org/hp9825.htm

Functions implemented using the Rotary switch:

00 "HELP" Help for key functions

01 "1/X" Inverse of X

02 "2^X" 2 to the power of X

03 "10^X" 10 to the power of X

04 "ABS" Abolute value of X

05 "ACOS" Arc Cosine

06 "ASIN" Arc Sine

07 "ATAN" Arc Tangent

08 "AVG" Average of the 4 stack values

09 "BES0" Bessel function J0

10 "BES1" Bessel function J1

11 "CAS" Cosine And Sine, Cos+Sin

12 "CBRT" Cube Root

13 "CHIZ" Chinese Zodiac

14 "CLST" Clear the Stack registers

15 "CLT" Clear T register

16 "CLX" Clear X register

17 "CLY" Clear Y register

18 "CLZ" Clear Z register

19 "COMB" Combinations of X and Y

20 "COS" Cosine

21 "COSH" Hyperbolic Cosine

22 "e^X" Euler's number raised to the power of X

23 "FIBO" Fibonacci sequence number of X

24 "FP" Fractional Part using modf()

25 "GAMA" Gamma function

26 "GAML" Log Gamma function

27 "HCF" Highest Common Factor of X and Y

28 "HYPT" Hypotenuse of a right angle triangle

29 "INT" Integer part of X

30 "IP" Integer part of X

31 "IPFP" Y=Integer part of X, X=Fractional part of X

32 "LCM" Lowest Common Multiple of X and Y

33 "LNe" Natural Logarithm base e

34 "LOG" Log base 10

35 "MOD" Modulus (if X is -ve then X=-X)

36 "N!" Factorial of integer part of X

37 "PERM" Permutations of X and Y

38 "PHI" Golden Ratio

39 "PI" Constant Pi

40 "RCLn" Recall memory location n to X register

41 "REM" Remainder of Y/X

42 "RLDN" Roll the Stack Down

43 "RLUP" Roll the Stack Up

44 "SIN" Sine

45 "SINH" Hyperbolic Sine

46 "SQRT" Square Root

47 "STOn" Store Y in Memory location n in X register

48 "TAN" Tangent

49 "TANH" Hyperbolic Tangent

50 "TANK" Filled volume of cylindrical tank on its side Z=length, Y=diameter, X=fill level

51 "X^2" X Squared

52 "X^3" X Cubed

53 "Y^X" Y raised to Power X

54 "XRTY" Xth root of Y, Root = exp(ln(X)/Y)

The Source code is written in C++ using Arduino IDE (Integrated Development Environment)

// GD9841R RPN Calculator v11.9 with Functions Dial & Improved Keyboard Control// - Simulates behaviour of HP-41C, HP-42S 4 level number stack with Reverse Polish Notation// Quad alphanumeric display LED backpack x4, 16 digits, I2C (0x70, 0x71, 0x72, 0x73) https://www.adafruit.com/product/3130// - Display chosen to look like the characters on HP-41C caculator, but big 0.54" x 8" LED// 5x6 Matrix Keyboard using MCP23017 GPIO interface chip, I2C (0x20) https://www.adafruit.com/product/5157// Shift key LED connected to MCP23017 pin A7 - DollaTek MCP23017 Bidirectional 16-Bit I/O Expander with I2C https://www.amazon.co.uk/DollaTek-MCP23017-Bidirectional-Expander-Interface/dp/B07PMGGPN8/ref=sr_1_1?keywords=dollatek+mcp23017&qid=1639163313&sr=8-1// Adafruit Feather M0 Adalogger with microSD card for storage https://www.adafruit.com/product/2796// - Atmel ATSAMD21G18 ARM Cortex M0 processor, 48 MHz, 3.3V, 256K FLASH, 32K RAM// LiPo Battery 3000mAhr, microUSB power and programming interface, I2C (0x0B) https://www.adafruit.com/product/4712// Adafruit FeatherWing DS3231 Precision Real Time Clock, I2C (0x68) https://www.adafruit.com/product/3028// SparkFun SerLCD 20x4 display with RGB backlight, I2C (0x78) (default 0x72 changed to 0x78) https://www.sparkfun.com/products/16398// - backlight colours used to indicate battery charge state// Adafruit Rotary Dial and Switch used for Function selection (0x36) https://www.adafruit.com/product/377
// v1 Using 5x5 keyboard and Quad alphanumeric display LED 12 digits - 19/09/2021// v3 Using 5x5 keyboard and Quad alphanumeric display LED 12 digits, RTC added - 24/09/2021// v4 Using 5x5 keyboard and LCD display 20x4 digits, RTC - 01/10/2021// v5 Using 5x6 keyboard and LCD display 20x4 digits, RTC - 11/10/2021// v6 Using 5x6 keyboard and LCD display 20x4 digits, RTC, Rotary Encoder - 13/10/21// v7 Conditional Serial port printing included - 15/11/2021// v8.5 SetRTC procedure added - 22/11/2021// Changed trigonometric functions to use degrees with pi/180 - 25/11/2021// Fixed Factorial, Combinations, Permutations - 25/11/2021// Fixed DP<0 crash - 25/11/2021// Added REM function fmod(Y,X) = Remainder or Modulo Y/X - 25/11/2021// Added XRTY Xth Root of Y using Root = exp(ln(Y)/X) - 25/11/2021// Implement Scientific Standard form input and display - 30/11/2021// Changed some of the key char codes - 30/11/2021// Added Cylindrical Tank Volume function - 09/12/2021// v9.1 Added SD Card Setup (Store and Recall not yet implemented)// v9.2 Added Gamma function - 18/12/2021// v9.3 Added LCM and HCF to functions dial - 19/12/2021// v9.4 Added Bessel functions J0, J1 - 29/12/2021// v9.5 Added Chinese Zodiac animals - 08/01/2022// v9.7 Added Chinese Zodiac characteristics - 25/01/2022// v9.8 Seperate Sci and Fix display settings using C and 00 buttons - 26/01/2022// v10.0 Stack display for -ve numbers corrected - 26/01/2022// v10.1 Added Log Gamma function GAML, Added 2^X function - 29/01/2022// v10.2 Added Hypotenuse function HYPT - 29/01/2022// v10.5 Fix edit mode and enter key errors - 06/02/2022// v10.6 New Sci/Fix modes with dp entry after - 07/02/2022// v10.7 Fix large FACT, COMB and PERM crashes with x>y - 10/02/2022// v10.8 Add Fibonacci series scrolling using rotary encoder - 06/05/2022// v11.0 Improved Serial monitor information on startup - 09/05/2022// Speed up digit entry by not refreshing the LCD - 09/05/2022// v11.1 Added Help to Function 0, Fibonacci tidy up with set dP=0 - 29/05/2022// v11.2 Added Prime number check to Shift f2 - 30/05/2022// v11.3 Tankvol bugs fixed - 30/05/2022// v11.4 softVers constant added for display - 31/05/2022// v11.5 Added Nth Prime function to shift f3 - 02/06/2022// v11.6 Added cas(x) = cos(x)+sin(x) to functions - 11/06/2022// v11.7 Added Golden ratio, Phi to funtions - 19/06/2022// Added Fibonacci ratio to LCD (approximation to Phi) - 19/06/2022// v11.8 Added FP fraction part and IPFP to functions - 20/06/2022// v11.9 Added STOn using Shift-ENTER - 18/08/2022
const float softVers=11.9;
//#include <math.h> // C Standard Math library for double precision maths functions. In Arduino build//#include <string.h> // C Standard String library, for strcat. In Arduino build//#include <stdio.h> // C Standard Input and Output Library, for sprintf. In Arduino build#include <avr/dtostrf.h> // AVR library for double to string function#include <Wire.h> // Arduino Wire library for I2C serial interface#include <SPI.h> // Serial Peripheral Interface library#include <SD.h> // SD Card library#include "Adafruit_LC709203F.h" // Battery Monitor library https://www.adafruit.com/product/4712#include <Adafruit_GFX.h> // Adafruit Grafix-graphics library#include "Adafruit_LEDBackpack.h" // Adafruit LED backpack library includes Alphanumeric 14 segment display https://www.adafruit.com/product/3130#include <Adafruit_MCP23X17.h> // Adafruit MCP23017 library (keypad interface) https://www.adafruit.com/product/5157#include "RTClib.h" // Adafruit Real Time Clock library https://www.adafruit.com/product/3028#include <SerLCD.h> // Sparkfun LCD library http://librarymanager/All#SparkFun_SerLCD#include "Adafruit_seesaw.h" // Adafruit Rotary Encoder library https://www.adafruit.com/product/377//#include <seesaw_neopixel.h> // Adafruit Rotary Encoder LED NeoPixel library (hidden by panel so not used!)
// Setup the Displays - 4x4 Alphanumeric LED Adafruit FeatherWingAdafruit_AlphaNum4 alpha0 = Adafruit_AlphaNum4();Adafruit_AlphaNum4 alpha1 = Adafruit_AlphaNum4();Adafruit_AlphaNum4 alpha2 = Adafruit_AlphaNum4();Adafruit_AlphaNum4 alpha3 = Adafruit_AlphaNum4();
SerLCD lcd; // Create object for Sparkfun 20x4 LCD with RGB backlight
#define VBATPIN A7 // ARM Cortex M0 A7 Internal Battery Monitor pin
Adafruit_LC709203F lc; // External Battery Monitorconst float BcellAlarmV = 3.6; // Low Backup LiPo cell Alarm level (red)const float BcellGoodV = 4.0; // Good Backup LiPo cell level (green)
const int chipSelect = 4; // Chip Select pin for SD Card on Adalogger M0
RTC_DS3231 rtc; // Create rtc objectchar daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};bool timeDisplay = false;unsigned long currentTime; // Used in timing of events using millis()unsigned long previousTime; // Used in timing of events using millis()unsigned long elapsedTime; // Used in timing of events using millis()unsigned long oldSecond = 0; // Used to check for time display updateconst unsigned long idleTime = 60000; // Used to turn on clock display in LCD after idleTime ms
bool scientific = false; // if true set dP[1]=truechar displayBuffer[51] = {' ','I','m',' ','S','w','i','t','c','h','e','d',' ','O','n',' ','\0'};char keyNumChar[18];char lastChar;bool edit = true;bool enterOn = false;const uint8_t nChars = 16; // Number of display charactersbool dP[17]; // Decimal point array to LED displayint8_t dPos = -1; // Decimal point position in LED display, -1 for no dPbool dPset = false; // Is there a decimal point?uint8_t cursorPos = 0; // The cursor position from least=0 to most=11 (unsigned 8-bit integer)int8_t brightLevel = 4; // Brightness can be 0 - 15 (signed 8-bit integer used)
// Setup the KeypadAdafruit_MCP23X17 kbd; // Using 3rd party MCP23017 I/O Expander for keyboard interfaceconst uint8_t kbdAddress = 0x20; // Address of MCP23017 I/O expanderconst uint8_t ROWS = 5; // number of rowsconst uint8_t COLS = 6; // number of columnschar keyChar = char(32); // character read from the keyboard, set to nulluint8_t inputState[ROWS][COLS];uint8_t lastInputState[ROWS][COLS];//bool inputFlags[ROWS][COLS]; //Not used in this program//uint8_t inputCounters[ROWS][COLS]; //Not used in this programunsigned long lastDebounceTime = 0;unsigned long debounceDelay = 5;
// Setup Rotary Encoder and Switch#define SS_SWITCH 24 // Pin for built-in rotary encoder switch#define ROTARY_ADDR 0x36 // Rotary encoder I2C addressAdafruit_seesaw ss;int32_t encoder_position, new_position;
// Define the functions available from the rotary dialbool func = false;const uint8_t numberOfFunctions = 55;char functionChars[numberOfFunctions][5] = { "HELP", // Function0 is Help explaining the keys and shift-keys "1/X", "2^X", "10^X", "ABS", "ACOS", "ASIN", "ATAN", "AVG", "BES0", "BES1", "CAS", "CBRT", "CHIZ", "CLST", "CLT", "CLX", "CLY", "CLZ", "COMB", "COS", "COSH", "e^X", "FIBO", "FP", "GAMA", "GAML", "HCF", "HYPT", "INT", "IP", "IPFP", "LCM", "LNe", "LOG", "MOD", "N!", "PERM", "PHI", "PI", "RCLn", "REM", "RDN", "RUP", "SIN", "SINH", "SQRT", "STOn", "TAN", "TANH", "TANK", "X^2", "X^3", "Y^X", "XRTY"};const double piConst = 3.1415926535897932; // pi = circumference / diameter of circleconst double eConst = 2.7182818284590452; // Euler's constant e = sum(1/n!), e^(i*pi)=1, limit(1+1/n)^nconst double phiConst = 1.6180339887498948; // Golden ratio = (1 + sqrt(5))/2double phiApprox; // Fibonacci ratio as approximation to Phiconst double pi180 = piConst / 180.0; // To convert Degrees to Grads in trig functionsdouble memory[99]; // for STOn and RCLn into memory locations (change to SD card?)double stack[5]; // Double precision numbers in calculator stack [temp, X, Y, Z, T]double lastX; // NOT stack[0] used as per HP calculatorsdouble tempX; // used to resore X when sci notation chosen (same as stack[0]??)double fracPart1, intPart1, fracPart2, intPart2; // Used finding integer and fraction part of double numbersdouble primeN;bool shift = false; // Shift key toggle statechar signExp = '+'; // Editing number exponent signbool chsExp = false; // change sign operates on mantissa-false or exponent-trueuint8_t decimalPlaces = 3; // Default number of decimal placesuint8_t dPlaces = 3; // For temporary change to decimal places in e.g. integer functions
// Define the symbols on the buttons of the keypadchar keyChars[ROWS][COLS] = { {'S', 'U', 'Y', 'C', 'e', 'D'}, {'d', 'V', '7', '8', '9', '/'}, {'c', '\0', '4', '5', '6', '*'}, {'b', 'E', '1', '2', '3', '-'}, {'a', '\0', '0', ',', '.', '+'}};uint8_t pinRow[ROWS] = {0, 1, 2, 3, 4}; // row pinouts of the keypad on MCP23017uint8_t pinCol[COLS] = {8, 9, 10, 11, 12, 13}; // column pinouts of the keypad on MCP23017uint8_t keyRow, keyCol; // store row and col of pressed keyuint8_t ledShift = 7; // Shift LED pin on MCP23017
void setup() { Serial.begin(115200); delay(2000); // Set serial port to 115200bps, still works if port not connected Serial.println("Serial port connected at 115200bps");
Wire.begin(); // By default .begin() will set I2C SCL to Standard Speed mode of 100kHz Wire.setClock(400000); // Optional - set I2C SCL to High Speed Mode of 400kHz
lcd.begin(Wire, 0x78); // Set up the LCD for I2C communication at address (0x78) lcd.setContrast(5); // Set contrast. Lower to 0 for higher contrast lcd.setFastBacklight(255, 255, 255); // Set backlight to white (0 - 255 range R,G,B) lcd.clear(); // Clear the display - this moves the cursor to home position as well lcd.print("Hello Gordon! "); lcd.print(" GD9841R "); lcd.print(" Software v"); lcd.print(softVers,1); Serial.print("Hello Gordon! GD-41R Calculator v"); Serial.println(softVers,1);
// Set up LC709203 Battery Monitor if (!lc.begin()) { lcd.print(F("LC709203F BatMon fail")); Serial.println("LC709203F BatMon fail"); while (1) delay(10); } Serial.println(F("BatMon LC709203F connected")); // Serial.print("Version: 0x"); Serial.println(lc.getICversion(), HEX); lc.setThermistorB(3950); //Set 10k thermistor for battery temperature // Serial.print("Thermistor B = "); Serial.println(lc.getThermistorB()); lc.setPackSize(LC709203F_APA_3000MAH); // Set battery capacity lc.setAlarmVoltage(BcellAlarmV); // Low level alarm for battery
// Set up DS3231 Precision Real Time Clock if (! rtc.begin()) { lcd.print(F("DS3231 RTC not found")); Serial.println("DS3231 RTC not found"); Serial.flush(); abort(); } Serial.println("RTC DS3231 connected");
// Initialise the LED displays (addresses in reverse order as I initially planned // to address from LSD to MSD, had to reverse this but displays now soldered in!) alpha0.begin(0x73); // Initialise display 0 with (0x73) I2C address alpha1.begin(0x72); // Initialise display 1 with (0x72) I2C address alpha2.begin(0x71); // Initialise display 2 with (0x71) I2C address alpha3.begin(0x70); // Initialise display 3 with (0x70) I2C address
alpha0.setBrightness(brightLevel); alpha1.setBrightness(brightLevel); alpha2.setBrightness(brightLevel); alpha3.setBrightness(brightLevel);
// Switch On display trivia writetodisplay(); // Display Switch On message Serial.print("displayBuffer: "); Serial.print(displayBuffer); Serial.println("*"); delay(2000); displaycheck(); // Light up all digits for each character in turn DisplayTimeLED(); // Display Date and Time delay(2000); whirligig(); // Rotating character scrolls along the display eating the date-time flyingduckdisplay(); // from HP-41C alpha0.writeDigitRaw(0, 0x0980); //Flying Duck character from HP-41C alpha0.writeDisplay();
// Setup the keyboard and matrix pins if (!kbd.begin_I2C(kbdAddress)) { // Set address and check if connected lcd.print(F("Keyboard not connected")); Serial.println("Keyboard not connected"); while (1); // Terminate program } Serial.println("Keyboard connected"); // Set input pins for reading keyboard for (uint8_t i = 0; i < ROWS; i++) { kbd.pinMode(pinRow[i], INPUT_PULLUP); // reads row i } for (uint8_t j = 0; j < COLS; j++) { kbd.pinMode(pinCol[j], INPUT_PULLUP); // controls column j } // Initialise input flags and state for (uint8_t j = 0; j < COLS; j++) { for (uint8_t i = 0; i < ROWS; i++) { //inputFlags[i][j] = LOW; inputState[i][j] = HIGH; lastInputState[i][j] = LOW; } } // Set output pin for Shift LED kbd.pinMode(ledShift, OUTPUT); // set output pin for Shift LED kbd.digitalWrite(ledShift, LOW); // Turn on Shift LED delay(200); kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED
// Set up the Rotary Encoder if (! ss.begin(ROTARY_ADDR)) { Serial.println("Couldn't find Rotary Encoder on default address"); while (1); } Serial.println("Rotary encoder connected"); // use a pin for the built in encoder switch ss.pinMode(SS_SWITCH, INPUT_PULLUP); // get starting position encoder_position = ss.getEncoderPosition(); Serial.println("Turning on interrupts"); delay(10); ss.setGPIOInterrupts((uint32_t)1 << SS_SWITCH, 1); ss.enableEncoderInterrupt();
// Check SD card is present and can be initialized if (!SD.begin(chipSelect)) { // If SD NOT detected lcd.setCursor(0, 2); lcd.println("Card failed/not in"); lcd.setCursor(0, 3); lcd.println("Insert a card & reset"); Serial.println("SD card failed/not inserted"); while (1); // Stop program and wait for SD card then reset } else { lcd.setCursor(0, 2); lcd.print("SD Card OK."); // If SD card detected Serial.println("SD Card connected"); delay(1000); // wait to read message }
Serial.println("Functions available from rotary dial:"); for (uint8_t i = 0; i < numberOfFunctions; i++) { Serial.print(i); Serial.print(" "); Serial.println(functionChars[i]); }
DisplayBattery(); // Display battery information on LCD DisplayTimeLCD(1); // Display Date & Time on LCD line 1
previousTime = millis();
Serial.println("Ready to use calculator!");} // end of setup

void loop() { currentTime = millis(); // Used for Clock display time delay dPlaces = decimalPlaces; // Store the set number of decimal places in temporary register
// Rotary Encoder switch press to execute a Function if (! ss.digitalRead(SS_SWITCH)) { lastX = stack[1]; edit = false; enterOn = false; XecuteFunction(new_position); stackXtoLED(); stacktoLCD(); func = false; delay(100); }
// Rotary Encoder position change to select a Function new_position = -ss.getEncoderPosition(); if (encoder_position != new_position) { // did it move around? if (new_position < 0) new_position = 0; // limit the range if (new_position > numberOfFunctions - 1) new_position = numberOfFunctions - 1; ss.setEncoderPosition(-new_position); // -ve used to make positive clockwise encoder_position = new_position; // and save for next round // Serial.print(new_position); Serial.print(" "); Serial.println(functionChars[encoder_position]); // display new position and function lcd.setCursor(0, 0); lcd.print(" "); // clear top line lcd.setCursor(0, 0); lcd.print("Function #"); lcd.print(new_position); lcd.print(" "); lcd.print(functionChars[encoder_position]); func = true; }
// Scan the keyboard
KeyScan(); // Scan the keyboard for keyChar
switch (keyChar) { //Case the Key character case char(32): // If null check time display if (timeDisplay) { DateTime now = rtc.now(); //Read RTC if (now.second() != oldSecond) { DisplayTimeLED(); oldSecond = now.second(); } } if (!edit && (currentTime - previousTime >= idleTime)) { DisplayTimeLCD(0); // Display Date & Time on LCD line 0 } break; case 'S': // Shift key toggle shift = !shift; if (shift) kbd.digitalWrite(ledShift, LOW); // Turn on Shift LED else kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED break; case '.': if (!shift) { // decimal point if (!edit) { rollup(); cleardisplay(); } edit = true; decimalpoint(); } else { // > increase decimal places if (decimalPlaces < 15) decimalPlaces++; dPlaces = decimalPlaces; shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED stackXtoLED(); stackXtoLCD(); } //stackXtoLCD(); break; case ',': if (!shift) { // comma - write three zeros edit = true; if (cursorPos == 0) cleardisplay(); keyChar = '0'; for (uint8_t i = 0; i < 3; i++) { displaykeychar(); stack[1] = strtod(keyNumChar, NULL); } //stackXtoLCD(); } else { // < decrease decimal places if (decimalPlaces > 0) decimalPlaces--; dPlaces = decimalPlaces; shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED stackXtoLED(); stackXtoLCD(); } break; case 'D': // Delete last digit entry or Delete display if (!shift && edit) backspace(); else { cleardisplay(); stackXtoLCD(); } shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED //stackXtoLCD(); printstack(); break; case 'e': // Scientific format input and display if (!shift) { chsExp = true; // Set true to change sign of exponent when C pressed signExp = '+'; digitentry(); } else { scientific = true; // Scientific display mode setdecimalplaces(); shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED edit=false; enterOn = true; stackXtoLED(); stacktoLCD(); cursorPos = 0; } break; case 'C': // Change sign of X register if (!shift) { if (chsExp) { changesignexp(); digitentry(); } else { changesign(); stackXtoLED(); stackXtoLCD(); } } else { scientific = false; // General display mode setdecimalplaces(); shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED edit=false; enterOn = true; stackXtoLED(); stacktoLCD(); cursorPos = 0; } break; case 'Y': if (!shift) { // Exchange X<>Y xchangey(); edit = false; enterOn = false; } else { // Last X enterstack(); stack[1] = lastX; edit = false; enterOn = false; shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED } stackXtoLED(); stackXYtoLCD(); //printstack(); break; case 'U': if (!shift) { // Rollup the Stack rollup(); stackXtoLED(); stacktoLCD(); writetodisplay(); //printstack(); } else { // Increase LED display brightness ++brightLevel; brightness(); shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED } break; case 'V': if (!shift) { // Rolldown the Stack rolldown(); stackXtoLED(); stacktoLCD(); writetodisplay(); //printstack(); } else { // Reduce LED display brightness --brightLevel; brightness(); shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED } break; case 'E': if (!shift) { // Enter display into number stack chsExp = false; enterOn = true; enterstack(); } else { // STOn - Store Y in Memory X memory[long(stack[1])] = stack[2]; rolldown(); } stackXtoLED(); stacktoLCD(); //printstack(); break; case '+': // Add X and Y if (!shift) { addnumbers(); stackXtoLED(); stacktoLCD(); //printstack(); } else { // Display battery info DisplayBattery(); enterOn = false; shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED } break; case '-': // Subtract X from Y subtractnumbers(); stackXtoLED(); stacktoLCD(); //printstack(); break; case '*': // Multiply X and Y multiplynumbers(); stackXtoLED(); stacktoLCD(); //printstack(); break; case '/': // Divide Y by X dividenumbers(); stackXtoLED(); stacktoLCD(); //printstack(); break; case 'd': //F4 key - display the time if (!shift) { timeDisplay = !timeDisplay; DisplayTimeLED(); DisplayTimeLCD(0); // Display Date & Time on LCD line 0 //PrintTime(); } else { SetRTC(); shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED } break; case 'c': //F3 key - LCM and HCF if (!shift) LowestCommonMultiple(); else HighestCommonFactor(); //stacktoLCD(); //serialdisplay(); //printstack(); break; case 'b': //F2 key - Prime Numbers if (!shift) { fracPart1 = modf(stack[1], &intPart1); stack[1] = intPart1; bool primeTest = isprime(stack[1]); stackXtoLED(); stacktoLCD(); lcd.setCursor(0, 0); lcd.print("Is X a Prime? ="); if (primeTest) lcd.print("TRUE "); else lcd.print("FALSE"); } else { fracPart1 = modf(stack[1], &intPart1); stack[1] = intPart1; primeN = nprime(stack[1]); if (!enterOn) rollup(); enterOn = false; edit = false; stack[1] = primeN; stackXtoLED(); stacktoLCD(); lcd.setCursor(0, 0); lcd.print("Yth Prime ="); lcd.print(primeN,0); shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED } //stacktoLCD(); //serialdisplay(); //printstack(); break; case 'a': //F1 key - PI if (!enterOn) enterstack(); if (!shift) stack[1] = piConst; else { stack[1] = eConst; shift = false; kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED } dPset = true; dP[1] = true; dPos = 1; timeDisplay = false; enterOn = false; edit = false; stackXtoLED(); stacktoLCD(); //printstack(); break; default: // For number digit entry digitentry(); //serialdisplay(); //printstack(); break; }/* if (keyChar != char(32)) { unsigned long loopTime = (millis() - currentTime); Serial.println(loopTime); }*/ keyChar = char(32); // Reset to Null character before next key scan}

void KeyScan(){ for (uint8_t j = 0; j < COLS; j++) { kbd.pinMode(pinCol[j], OUTPUT); // set output pin for column j kbd.digitalWrite(pinCol[j], LOW); // create a GND connection for column j
for (uint8_t i = 0; i < ROWS; i++) { // test for keypress on each row i int keyState = kbd.digitalRead(pinRow[i]); if (keyState != lastInputState[i][j]) { // if keyState has changed lastDebounceTime = millis(); // start debounce timer } if ((millis() - lastDebounceTime) > debounceDelay) { // check debounce time has elapsed if (keyState != inputState[i][j]) { inputState[i][j] = keyState; if (inputState[i][j] == HIGH) { // set key state when key is released //inputFlags[i][j] = HIGH; keyChar = (keyChars[i][j]); keyRow = i; keyCol = j; // Serial.println(keyChar); } } } lastInputState[i][j] = keyState; } kbd.pinMode(pinCol[j], INPUT); // disconnect GND from column j }}
void digitentry(){ if (!edit && !enterOn) { rollup(); cleardisplay(); //stacktoLCD(); //Serial.println("!edit && !enterOn"); } if (enterOn) cursorPos = 0; timeDisplay = false; edit = true; enterOn = false; if (cursorPos == 0) { cleardisplay(); if (keyChar == 'e') { keyChar = '1'; displaykeychar(); keyChar = 'e'; } } displaykeychar(); stack[1] = strtod(keyNumChar, NULL); //stackXtoLCD(); // LCD update is too slow for digit entry!}
void setdecimalplaces(){ lcd.setCursor(0, 0); lcd.print("Input dec. places nn"); char nd[2]; for (uint8_t i=0; i<=1; i++) { while (!(isDigit(keyChar))) {KeyScan(); delay(10);} nd[i] = keyChar; lcd.setCursor(18+i, 0); lcd.print(keyChar); keyChar = char(32); } decimalPlaces = atoi(nd); if (decimalPlaces < 0) decimalPlaces = 0; if (decimalPlaces > 15) decimalPlaces = 15; dPlaces = decimalPlaces;}
void displaykeychar() // Display the next keyed character on the LED{ displayBuffer[cursorPos] = keyChar; if (dPset) { keyNumChar[cursorPos + 1] = keyChar; } else { keyNumChar[cursorPos] = keyChar; } cursorPos++; displayBuffer[cursorPos] = '_'; writetodisplay();}
void stackxtodisplaybuffer() // Write X register from the stack to the LED display buffer{ uint8_t keyNumLength; char disp; // disp[0] ='\0'; char format[7]; format[0] = '\0'; char n[3]; n[0] = '\0'; for (uint8_t i = 0; i < nChars; i++) { displayBuffer[i] = ' '; dP[i] = false; } dPos = -1; dPset = false;
dtostrf(dPlaces, 1, 0, n); // Convert dPlaces to char n strcat(format, "%+."); strcat(format, n); // Concatenate strings if (scientific) strcat(format, "e"); else strcat(format, "f"); keyNumChar[0] = '\0'; keyNumLength = sprintf(keyNumChar, format, stack[1]); // Prints stack[1] into keyNumChar and returns keyNumLength
for (uint8_t i = 0; i < keyNumLength; i++) { if (keyNumChar[i] != '.') { if (!dPset) { displayBuffer[i] = keyNumChar[i]; dP[i] = false; } else displayBuffer[i] = keyNumChar[i + 1]; } else { displayBuffer[i] = keyNumChar[i + 1]; dP[i - 1] = true; dPset = true; dPos = i - 1; } } if (dPset = false) cursorPos = keyNumLength + 1; else cursorPos = keyNumLength + 2; // Serial.print("keyNumChar : "); Serial.print(keyNumChar); Serial.println("*"); // Serial.print("keyNumLength : "); Serial.print(keyNumLength); Serial.println("*"); // Serial.print("displayBuffer: "); Serial.print(displayBuffer); Serial.println("*"); // Serial.print("Stack X : "); Serial.print(stack[1],15); Serial.println("*"); // Serial.print("temp X : "); Serial.print(tempX,15); Serial.println("*"); // Serial.print("edit : "); Serial.print(edit); Serial.println("*");}
void writetodisplay() // Write the displaybuffer to the LED display{ alpha0.writeDigitAscii(0, displayBuffer[0], dP[0]); alpha0.writeDigitAscii(1, displayBuffer[1], dP[1]); alpha0.writeDigitAscii(2, displayBuffer[2], dP[2]); alpha0.writeDigitAscii(3, displayBuffer[3], dP[3]); alpha0.writeDisplay(); alpha1.writeDigitAscii(0, displayBuffer[4], dP[4]); alpha1.writeDigitAscii(1, displayBuffer[5], dP[5]); alpha1.writeDigitAscii(2, displayBuffer[6], dP[6]); alpha1.writeDigitAscii(3, displayBuffer[7], dP[7]); alpha1.writeDisplay(); alpha2.writeDigitAscii(0, displayBuffer[8], dP[8]); alpha2.writeDigitAscii(1, displayBuffer[9], dP[9]); alpha2.writeDigitAscii(2, displayBuffer[10], dP[10]); alpha2.writeDigitAscii(3, displayBuffer[11], dP[11]); alpha2.writeDisplay(); alpha3.writeDigitAscii(0, displayBuffer[12], dP[12]); alpha3.writeDigitAscii(1, displayBuffer[13], dP[13]); alpha3.writeDigitAscii(2, displayBuffer[14], dP[14]); alpha3.writeDigitAscii(3, displayBuffer[15], dP[15]); alpha3.writeDisplay();}
void stackXtoLED(){ if (!edit) tempX = stack[1]; stackxtodisplaybuffer(); writetodisplay();}
void stackXtoLCD(){ lcd.setCursor(0, 3); lcd.print(" "); lcd.setCursor(0, 3); lcd.print("X:"); if (stack[1]>=0) lcd.print(" "); lcd.print(stack[1], dPlaces); previousTime = currentTime; // Resets the LCD clock display timer}
void stackXYtoLCD(){ lcd.setCursor(0, 2); lcd.print(" "); lcd.setCursor(0, 2); lcd.print("Y:"); if (stack[2]>=0) lcd.print(" "); lcd.print(stack[2], dPlaces); lcd.setCursor(0, 3); lcd.print(" "); lcd.setCursor(0, 3); lcd.print("X:"); if (stack[1]>=0) lcd.print(" "); lcd.print(stack[1], dPlaces); previousTime = currentTime; // Resets the LCD clock display timer}
void stacktoLCD() // Display X,Y,Z,T stack registers on the LCD{ lcd.clear(); //Clear the display - this moves the cursor to home position as well lcd.setCursor(0, 0); lcd.print("T:"); if (stack[4]>=0) lcd.print(" "); lcd.print(stack[4], dPlaces); lcd.setCursor(0, 1); lcd.print("Z:"); if (stack[3]>=0) lcd.print(" "); lcd.print(stack[3], dPlaces); lcd.setCursor(0, 2); lcd.print("Y:"); if (stack[2]>=0) lcd.print(" "); lcd.print(stack[2], dPlaces); lcd.setCursor(0, 3); lcd.print("X:"); if (stack[1]>=0) lcd.print(" "); lcd.print(stack[1], dPlaces); previousTime = currentTime; // Resets the LCD clock display timer}
void printstack() // Print X,Y,Z,T stack registers to Serial port for debugging{ Serial.print("T: "); Serial.println(stack[4], 12); Serial.print("Z: "); Serial.println(stack[3], 12); Serial.print("Y: "); Serial.println(stack[2], 12); Serial.print("X: "); Serial.println(stack[1], 12); Serial.print("L: "); Serial.println(lastX, 12); Serial.println();}
void serialdisplay() // Print info to Serial port for debugging{ Serial.print("CursorPos : "); Serial.println(cursorPos); Serial.print("displayBuffer: "); Serial.print(displayBuffer); Serial.println("*"); Serial.print("decimalPosn : "); Serial.println(dPos); Serial.print("keyNumChar : "); Serial.println(keyNumChar); Serial.print("keyNumDouble : "); Serial.println(atof(keyNumChar), dPlaces);}
void enterstack() // ENTER - Pushup the STACK then ENTER to X{ stack[4] = stack[3]; stack[3] = stack[2]; stack[2] = stack[1]; edit = false;}
void rolldown() // Roll Down the STACK - circular{ stack[0] = stack[1]; stack[1] = stack[2]; stack[2] = stack[3]; stack[3] = stack[4]; stack[4] = stack[0]; edit = false;}
void rollup() // Roll Up the stack - circular{ stack[0] = stack[4]; stack[4] = stack[3]; stack[3] = stack[2]; stack[2] = stack[1]; stack[1] = stack[0]; edit = false;}
void xchangey() // Xchange X with Y{ stack[0] = stack[1]; stack[1] = stack[2]; stack[2] = stack[0]; edit = false;}
void changesign() // Change sign of X register mantissa{ stack[1] = -stack[1]; signExp = '+';// edit = false; // ** doesn't allow for editing after Chs **}
void changesignexp() // Change sign of X register exponent{ if (signExp == '+') { keyChar = '-'; signExp = '-'; } else { keyChar = '+'; signExp = '+'; } // displaykeychar();}
void addnumbers() // X+Y->X and rolldown{ lastX = stack[1]; // Update lastX stack[1] = stack[2] + stack[1]; // Add Y + X stack[2] = stack[3]; // Roll Down the stack stack[3] = stack[4]; // T retains its value dtostrf(stack[1], 4, decimalPlaces, keyNumChar); // Convert double stack[1] to char keyNumChar edit = false;}
void subtractnumbers() // X-Y->X and rolldown{ lastX = stack[1]; // Update lastX stack[1] = stack[2] - stack[1]; // Subtract Y - X stack[2] = stack[3]; // Roll Down the stack stack[3] = stack[4]; // T retains its value dtostrf(stack[1], 4, decimalPlaces, keyNumChar); // Convert double stack[1] to char keyNumChar edit = false;}
void multiplynumbers() // X*Y->X and rolldown{ lastX = stack[1]; // Update lastX stack[1] = stack[2] * stack[1]; // Multiply Y * X stack[2] = stack[3]; // Roll Down the stack stack[3] = stack[4]; // T retains its value dtostrf(stack[1], 4, decimalPlaces, keyNumChar); // Convert double stack[1] to char keyNumChar edit = false;}
void dividenumbers() // Y/X->X and rolldown{ lastX = stack[1]; // Update lastX stack[1] = stack[2] / stack[1]; // Multiply Y / X stack[2] = stack[3]; // Roll Down the stack stack[3] = stack[4]; // T retains its value dtostrf(stack[1], 4, decimalPlaces, keyNumChar); // Convert double stack[1] to char keyNumChar edit = false;}
void XecuteFunction(int8_t funcNumber) // Execute function selected by rotary switch{ edit = false; switch (funcNumber) { //Case Function Number case 0: //"HELP" helpkeys(); break; case 1: //"1/X" stack[1] = 1 / stack[1]; break; case 2: //"2^X" stack[1] = pow(2, stack[1]); // or exp2(stack[1]) break; case 3: //"10^X" stack[1] = pow(10, stack[1]); break; case 4: //"ABS" stack[1] = fabs(stack[1]); // fabs for double numbers break; case 5: //"ACOS" stack[1] = acos(stack[1]) / pi180; // degrees break; case 6: //"ASIN" stack[1] = asin(stack[1]) / pi180; // degrees break; case 7: //"ATAN" stack[1] = atan(stack[1]) / pi180; // degrees break; case 8: //"AVG" stack[1] = (stack[1] + stack[2] + stack[3] + stack[4]) / 4; break; case 9: //"BES0" stack[1] = j0(stack[1]); break; case 10: //"BES1" stack[1] = j1(stack[1]); break; case 11: //"CAS" stack[1] = cos(stack[1] * pi180) + sin(stack[1] * pi180); break; case 12: //"CBRT" stack[1] = cbrt(stack[1]); break; case 13: //"CHIZ" chinesezodiac(); break; case 14: //"CLST" for (int8_t i = 0; i <= 4; i++) stack[i] = 0; break; case 15: //"CLT" stack[4] = 0; break; case 16: //"CLX" stack[1] = 0; break; case 17: //"CLY" stack[2] = 0; break; case 18: //"CLZ" stack[3] = 0; break; case 19: //"COMB" fracPart1 = modf(stack[1], &intPart1); fracPart2 = modf(stack[2], &intPart2); stack[1] = combyx(intPart2, intPart1); break; case 20: //"COS" stack[1] = cos(stack[1] * pi180); // input degrees break; case 21: //"COSH" stack[1] = cosh(stack[1]); break; case 22: //"e^X" stack[1] = pow(eConst, stack[1]); break; case 23: //"FIBO" fibonacciseries(); break; case 24: //"FP" fraction part fracPart1 = modf(stack[1], &intPart1); stack[1] = fracPart1; break; case 25: //"GAMA" stack[1] = tgamma(stack[1]); break; case 26: //"GAML" stack[1] = lgamma(stack[1]); break; case 27: //"HCF" HighestCommonFactor(); break; case 28: //"HYPT" rollup(); stack[1] = hypot(stack[2], stack[3]); break; case 29: //"INT" stack[1] = long(stack[1]); break; case 30: //"IP" fracPart1 = modf(stack[1], &intPart1); stack[1] = intPart1; break; case 31: //"IPFP" FP to X, IP to Y fracPart1 = modf(stack[1], &intPart1); rollup(); stack[1] = fracPart1; stack[2] = intPart1; break; case 32: //"LCM" LowestCommonMultiple(); break; case 33: //"LNe" stack[1] = log(stack[1]); break; case 34: //"LOG" stack[1] = log10(stack[1]); break; case 35: //"MOD" if (stack[1] < 0) stack[1] = -stack[1]; break; case 36: //"N!" stack[1] = factorial(stack[1]); break; case 37: //"PERM" fracPart1 = modf(stack[1], &intPart1); fracPart2 = modf(stack[2], &intPart2); stack[1] = permyx(intPart2, intPart1); break; case 38: //"PHI" golden ratio stack[1] = phiConst; break; case 39: //"PI" rollup(); stack[1] = piConst; break; case 40: //"RCLn" stack[1] = memory[long(stack[1])]; break; case 41: //"REM" stack[1] = fmod(stack[2], stack[1]); break; case 42: //"RLDN" rolldown(); break; case 43: //"RLUP" rollup(); break; case 44: //"SIN" stack[1] = sin(stack[1] * pi180); // input degrees break; case 45: //"SINH" stack[1] = sinh(stack[1]); break; case 46: //"SQRT" stack[1] = sqrt(stack[1]); break; case 47: //"STOn" memory[long(stack[1])] = stack[2]; rolldown(); break; case 48: //"TAN" stack[1] = tan(stack[1] * pi180); // input degrees break; case 49: //"TANH" stack[1] = tanh(stack[1]); break; case 50: //"TANK" tankvol(); break; case 51: //"X^2" stack[1] = stack[1] * stack[1]; break; case 52: //"X^3" stack[1] = stack[1] * stack[1] * stack[1]; break; case 53: //"Y^X" stack[1] = pow(stack[2], stack[1]); break; case 54: //"XRTY" Root = exp(ln(Y)/X) stack[1] = pow(eConst, (log(stack[2]) / stack[1])); default: break; }}
double factorial(double n){ fracPart1 = modf(n, &intPart1); return tgamma(intPart1 + 1);}
double permyx(double y, double x){ if (y <= x ) return 0; return factorial(y) / factorial(y - x);}
double combyx(double y, double x){ if (y <= x ) return 0; return factorial(y) / factorial(y - x) / factorial(x);}
double fibonacci(double n){ double fibN2, fibN1, fibNn; fibN2 = 0; fibN1 = 1; fibNn = 1; if (n <= 0) return 0; if (n == 1) return 1; if (n == 2) return 1; for (uint8_t i= 3; i <= n; ++i) { fibN2 = fibN1; fibN1 = fibNn; fibNn = fibN1 + fibN2; phiApprox = fibNn / fibN1; } return fibNn;}
void fibonacciseries(){ long series, newSeries; dPlaces = 0; series = int(stack[1]); ss.setEncoderPosition(-series); // Set rotary encoder position to sequence number fracPart1 = modf(series, &intPart1); stack[1] = fibonacci(series); stackXtoLED(); newSeries = series;
while(keyChar != 'D') { // Wait for Del key press to exit KeyScan(); // Test for rotary encoder change newSeries = -ss.getEncoderPosition(); if (series != newSeries) { // did it move around? ss.setEncoderPosition(-newSeries); // -ve used to make positive clockwise series = newSeries; // and save for next round fracPart1 = modf(series, &intPart1); stack[1] = fibonacci(intPart1); stackXtoLED(); lcd.clear(); //Clear the display - this moves the cursor to home position as well lcd.setCursor(0, 0); lcd.print(" Fibonacci Series "); lcd.setCursor(0, 1); lcd.print(" #"); lcd.print(series); lcd.setCursor(0, 2); lcd.print("Fibon"); lcd.print(int(stack[1])); lcd.setCursor(0, 3); lcd.print("Ratio"); lcd.print(phiApprox,13); } } dPlaces = decimalPlaces; stackXtoLCD(); ss.setEncoderPosition(-22); // Reset encoder position to -22="FIBO" keyChar = char(32); // Reset keyChar to Null}
bool isprime(int64_t num){ dPlaces = 0; // Handle base cases if (num <= 1) return false; if (num == 2) return true;
// Iterate upto sqrt(n) for (int64_t i = 2; i * i <= num; ++i) { if (num % i == 0) return false; } return true;}
int64_t nprime(int64_t n){ int64_t primeN=1, count=0; if (n<2) return 0; dPlaces = 0; if (n>499) calculating(); while (true) { primeN++; if (isprime(primeN)) { count++;// stack[1] = primeN;// stackxtodisplaybuffer();// writetodisplay(); } if(count==n) { return primeN; } }}
void calculating() // Busy calculating message to LED{ for (uint8_t i = 0; i < nChars; i++) { displayBuffer[i] = ' '; // Clear the display buffer dP[i] = false; // Clear decimal points } displayBuffer[1] = ('C'); displayBuffer[2] = ('a'); displayBuffer[3] = ('l'); displayBuffer[4] = ('c'); displayBuffer[5] = ('u'); displayBuffer[6] = ('l'); displayBuffer[7] = ('a'); displayBuffer[8] = ('t'); displayBuffer[9] = ('i'); displayBuffer[10] = ('n'); displayBuffer[11] = ('g'); displayBuffer[12] = ('.'); displayBuffer[13] = ('.'); displayBuffer[14] = ('.'); writetodisplay();}
void tankvol() // Cylindrical tank on its side{ double diam, leng, fil, radius, h, t, a, vol; diam = stack[3]; leng = stack[2]; fil = stack[1]; rollup(); radius = diam / 2.0; if ( fil < radius) h = fil; else h = diam - fil; t = 2.0 * acos((radius - h) / radius); a = 0.5 * radius*radius * (t - sin(t*pi180)); if (fil < radius) vol = a * leng * 1000.0; else vol = ((piConst * radius*radius) - a) * leng * 1000.0; stack[1] = vol;}
void LowestCommonMultiple() // Finds LCM of X and Y, puts result into X{ lastX = stack[1]; // Update lastX int64_t a, b, LCM; a = int(stack[1]); b = int(stack[2]); if (a > b) LCM = a; else LCM = b; while ( LCM % a != 0 || LCM % b != 0 ) { LCM++; } rollup(); // Roll Up the stack, numbers are preserved in Y and Z stack[1] = LCM; dPlaces = 0; stackXtoLED(); stacktoLCD(); lcd.setCursor(0, 0); lcd.print("LCM(Y,Z) = X"); //serialdisplay(); // printstack(); dPlaces = decimalPlaces;}
void HighestCommonFactor() // Finds HCF of X and Y, puts result into X{ lastX = stack[1]; // Update lastX int64_t a, b, HCF; a = int(stack[1]); b = int(stack[2]); // swapping variables n1 and n2 if n2 is greater than n1. if ( b > a) { int64_t temp = b; b = a; a = temp; } for (int64_t i = 1; i <= b; ++i) { if (a % i == 0 && b % i == 0) { HCF = i; } } rollup(); // Roll Up the stack, numbers are preserved in Y and Z stack[1] = HCF; dPlaces = 0; stackXtoLED(); stacktoLCD(); lcd.setCursor(0, 0); lcd.print("HCF(Y,Z) = X"); //serialdisplay(); // printstack(); dPlaces = decimalPlaces;}
void chinesezodiac(){ int chiYear, realYear, newYear, yearLength; char zodiac0[12][8] = {"RAT ","OX ","TIGER ","RABBIT ","DRAGON ","SNAKE ", "HORSE ","GOAT ","MONKEY ","ROOSTER","DOG ","PIG "}; char zodiac1[12][21] = {"Rat: quick-witted, ", "Ox: diligent, ", "Tiger: quick-witted,", "Rabbit: quiet, ", "Dragon: confident, ", "Snake: enigmatic, ", "Horse: animated, ", "Goat: calm, gentle, ", "Monkey: sharp, smart", "Rooster: observant, ", "Dog: lovely, honest,", "Pig: compassionate, "}; char zodiac2[12][21] = {" resourceful, ", " dependable, strong,", " resourceful, ", " elegant, kind, ", " intelligent, ", " intelligent, ", " active, ", " sympathetic. ", " curious. ", " hardworking, ", " prudent. ", " generous, "}; char zodiac3[12][21] = {" versatile, kind. ", " determined. ", " versatile, kind. ", " responsible. ", " enthusiastic. ", " wise. ", " energetic. ", " ", " ", " courageous. ", " ", " diligent. "};
for (uint8_t i = 0; i < nChars; i++) { displayBuffer[i] = ' '; // Clear the display buffer dP[i] = false; // Clear decimal points }
realYear = int(stack[1]); ss.setEncoderPosition(-realYear); // Set rotary encoder position to realYear newYear = realYear; chiYear = ((realYear - 4) % 12); // Write year and animal to LED display yearLength = sprintf(displayBuffer, "%4.4u", realYear); strcat(displayBuffer, " "); strcat(displayBuffer, zodiac0[chiYear]); writetodisplay(); alpha1.writeDigitRaw(2, 0x00C9); // 'Equivalent to' character, 3 bars alpha1.writeDisplay(); // Write year, animal and characteristics to LCD display lcd.clear(); //Clear the display - this moves the cursor to home position as well lcd.setCursor(8, 0); lcd.print(realYear); lcd.setCursor(0, 1); lcd.print(zodiac1[chiYear]); lcd.setCursor(0, 2); lcd.print(zodiac2[chiYear]); lcd.setCursor(0, 3); lcd.print(zodiac3[chiYear]);
while(keyChar != 'D') { // Wait for Del key press to exit KeyScan(); // Test for rotary encoder change newYear = -ss.getEncoderPosition(); if (realYear != newYear) { // did it move around? ss.setEncoderPosition(-newYear); // -ve used to make positive clockwise realYear = newYear; // and save for next round chiYear = ((realYear - 4) % 12); // Write year and animal to LED display yearLength = sprintf(displayBuffer, "%4.0u", realYear); strcat(displayBuffer, " "); strcat(displayBuffer, zodiac0[chiYear]); writetodisplay(); alpha1.writeDigitRaw(2, 0x00C9); // 'Equivalent to' character, 3 bars alpha1.writeDisplay(); // Write year, animal and characteristics to LCD display lcd.clear(); //Clear the display - this moves the cursor to home position as well lcd.setCursor(8, 0); lcd.print(realYear); lcd.setCursor(0, 1); lcd.print(zodiac1[chiYear]); lcd.setCursor(0, 2); lcd.print(zodiac2[chiYear]); lcd.setCursor(0, 3); lcd.print(zodiac3[chiYear]); } } stack[1] = realYear; ss.setEncoderPosition(-12); // Reset encoder position to -12="CHIZ" if (dPos >= 0) dP[dPos] = true; // Restore decimal point keyChar = char(32); // Reset keyChar to Null}
void decimalpoint() // Decimal point to LED display buffer{ if (cursorPos == 0) { displayBuffer[0] = '0'; keyNumChar[0] = '0'; cursorPos++; } if (!dPset) { dP[cursorPos - 1] = true; // Decimal point toggles for easy correction dPset = true; dPos = cursorPos - 1; keyNumChar[cursorPos] = '.'; } else { if (dP[cursorPos - 1]) { dP[cursorPos - 1] = false; dPset = false; dPos = -1; keyNumChar[cursorPos] = ' '; } else { } //do nothing if dP is at another position } writetodisplay();}
void backspace() // Delete last character and move cursor back{ if (cursorPos > 0) cursorPos--; { displayBuffer[cursorPos] = '_'; displayBuffer[cursorPos + 1] = ' '; } if (dPset) keyNumChar[cursorPos + 1] = ' '; keyNumChar[cursorPos] = ' '; if (dP[cursorPos] == true) { dP[cursorPos] = false; dPos = -1; dPset = false; } stack[1] = strtod(keyNumChar, NULL); writetodisplay();}
void scrollleft() //NOT USED{ // scroll the display left for each typed character lastChar = displayBuffer[0]; dPset = dP[0]; for (uint8_t i = 0 ; i <= nChars - 2; i++) { displayBuffer[i] = displayBuffer[i + 1]; dP[i] = dP[i + 1]; keyNumChar[i] = keyNumChar[i + 1]; } displayBuffer[nChars - 1] = ' '; dP[nChars - 1] = false; keyNumChar[nChars - 1] = ' '; if (dPset) { for (uint8_t i = 0 ; i <= nChars - 2; i++) { keyNumChar[i] = keyNumChar[i + 1]; } keyNumChar[nChars - 1] = ' '; dPset = false; } cursorPos--; writetodisplay();}
void scrollright() //NOT USED{ // scroll the display right for each typed character for (uint8_t i = nChars - 1; i > 0; i--) { displayBuffer[i] = displayBuffer[i - 1]; dP[i] = dP[i - 1]; keyNumChar[i] = keyNumChar[i - 1]; } displayBuffer[0] = lastChar; dP[0] = dPset; keyNumChar[0] = lastChar; if (dPset) { for (uint8_t i = nChars - 1; i > 0; i--) { keyNumChar[i] = keyNumChar[i - 1]; } keyNumChar[0] = '.'; } cursorPos++; writetodisplay();}
void cleardisplay(){ for (uint8_t i = 0; i < nChars; i++) { displayBuffer[i] = ' '; keyNumChar[i] = ' '; dP[i] = false; } displayBuffer[0] = '_'; cursorPos = 0; lastChar = ' '; dPset = false; dPos = -1; edit = true;// stack[1] = strtod(keyNumChar, NULL); stack[1] = 0; writetodisplay();}
void brightness() // Set LED display brightness{ if ( brightLevel < 0 ) brightLevel = 0; //limit minimum to 0 if ( brightLevel > 7 ) brightLevel = 7; //limit maximum to 7 alpha0.setBrightness(brightLevel); alpha1.setBrightness(brightLevel); alpha2.setBrightness(brightLevel); alpha3.setBrightness(brightLevel);}
void displaycheck() // Light up all digits for each character in turn{ uint8_t dDelay = 150; for (uint8_t i = 0 ; i <= 3; i++) { alpha0.writeDigitRaw(i, 0xFFFF); alpha0.writeDisplay(); delay(dDelay); alpha0.writeDigitRaw(i, 0x0000); alpha0.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { alpha1.writeDigitRaw(i, 0xFFFF); alpha1.writeDisplay(); delay(dDelay); alpha1.writeDigitRaw(i, 0x0000); alpha1.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { alpha2.writeDigitRaw(i, 0xFFFF); alpha2.writeDisplay(); delay(dDelay); alpha2.writeDigitRaw(i, 0x0000); alpha2.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { alpha3.writeDigitRaw(i, 0xFFFF); alpha3.writeDisplay(); delay(dDelay); alpha3.writeDigitRaw(i, 0x0000); alpha3.writeDisplay(); }}
void flyingduckdisplay() // Write HP-41C Flying Duck char to each digit from right to left{ uint8_t dDelay = 100; for (uint8_t i = 0 ; i <= 3; i++) { alpha0.writeDigitRaw(i, 0x0980); alpha0.writeDisplay(); delay(dDelay); alpha0.writeDigitRaw(i, 0x0000); alpha0.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { alpha1.writeDigitRaw(i, 0x0980); alpha1.writeDisplay(); delay(dDelay); alpha1.writeDigitRaw(i, 0x0000); alpha1.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { alpha2.writeDigitRaw(i, 0x0980); alpha2.writeDisplay(); delay(dDelay); alpha2.writeDigitRaw(i, 0x0000); alpha2.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { alpha3.writeDigitRaw(i, 0x0980); alpha3.writeDisplay(); delay(dDelay); alpha3.writeDigitRaw(i, 0x0000); alpha3.writeDisplay(); }}
void whirligig() // Light up rotating segments for each character in turn{ uint8_t dDelay = 20; uint16_t whirli[8] = {0x0201, 0x0403, 0x0086, 0x200C, 0x1008, 0x0818, 0x0070, 0x0121}; for (uint8_t i = 0 ; i <= 3; i++) { for (uint8_t j = 0 ; j <= 7; j++) { alpha0.writeDigitRaw(i, whirli[j]); alpha0.writeDisplay(); delay(dDelay); } delay(dDelay); alpha0.writeDigitRaw(i, 0x0000); alpha0.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { for (uint8_t j = 0 ; j <= 7; j++) { alpha1.writeDigitRaw(i, whirli[j]); alpha1.writeDisplay(); delay(dDelay); } delay(dDelay); alpha1.writeDigitRaw(i, 0x0000); alpha1.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { for (uint8_t j = 0 ; j <= 7; j++) { alpha2.writeDigitRaw(i, whirli[j]); alpha2.writeDisplay(); delay(dDelay); } delay(dDelay); alpha2.writeDigitRaw(i, 0x0000); alpha2.writeDisplay(); } for (uint8_t i = 0 ; i <= 3; i++) { for (uint8_t j = 0 ; j <= 7; j++) { alpha3.writeDigitRaw(i, whirli[j]); alpha3.writeDisplay(); delay(dDelay); } delay(dDelay); alpha3.writeDigitRaw(i, 0x0000); alpha3.writeDisplay(); }}
void DisplayTimeLED() // Display Date and Time on the LED display{ // Clear any decimal point for (uint8_t i = 0; i < nChars; i++) { displayBuffer[i] = ' '; dP[i] = false; }
// Read the Real Time Clock DateTime now = rtc.now(); //Read RTC char timeChars[17]; char yearChar[2], monthChar[2], dayChar[2], hourChar[2], minuteChar[2], secondChar[2];
dtostrf(now.year() - 2000, 2, 0, yearChar); // Convert now.year to yearChar[]
if (now.month() < 10) { char nowMonth[2]; dtostrf(now.month(), 1, 0, nowMonth); strcpy(monthChar, "0"); strcat(monthChar, nowMonth); } else dtostrf(now.month(), 2, 0, monthChar);
if (now.day() < 10) { char nowDay[2]; dtostrf(now.day(), 1, 0, nowDay); strcpy(dayChar, "0"); strcat(dayChar, nowDay); } else dtostrf(now.day(), 2, 0, dayChar);
if (now.hour() < 10) { char nowHour[2]; dtostrf(now.hour(), 1, 0, nowHour); strcpy(hourChar, "0"); strcat(hourChar, nowHour); } else dtostrf(now.hour(), 2, 0, hourChar);
if (now.minute() < 10) { char nowMinute[2]; dtostrf(now.minute(), 1, 0, nowMinute); strcpy(minuteChar, "0"); strcat(minuteChar, nowMinute); } else dtostrf(now.minute(), 2, 0, minuteChar);
if (now.second() < 10) { char nowSecond[2]; dtostrf(now.second(), 1, 0, nowSecond); strcpy(secondChar, "0"); strcat(secondChar, nowSecond); } else dtostrf(now.second(), 2, 0, secondChar);
strcpy(timeChars, " "); strcat(timeChars, yearChar); strcat(timeChars, "/"); strcat(timeChars, monthChar); strcat(timeChars, "/"); strcat(timeChars, dayChar); strcat(timeChars, " "); strcat(timeChars, hourChar); dP[11] = true; strcat(timeChars, minuteChar); dP[13] = true; strcat(timeChars, secondChar);
strcpy(displayBuffer, timeChars); writetodisplay();}
void DisplayBattery() // Display Battery stae on the LCD display{ uint8_t red, green, blue; float VB = lc.cellVoltage(); if (VB > BcellGoodV) VB = BcellGoodV; if (VB < BcellAlarmV) VB = BcellAlarmV;
red = (BcellGoodV - VB) * 255 / (BcellGoodV - BcellAlarmV); green = (VB - BcellAlarmV) * 255 / (BcellGoodV - BcellAlarmV); blue = 0; lcd.clear(); //Clear the display - this moves the cursor to home position as well lcd.setFastBacklight(red, green, blue); //Set backlight (0 - 255 range R,G,B) lcd.setCursor(0, 0); lcd.print("Hello Gordon! GD-41R"); lcd.setCursor(0, 1); lcd.print("Software v"); lcd.print(softVers,1); lcd.setCursor(0, 2); lcd.print("Bcel: "); lcd.print(lc.cellVoltage(), 2); lcd.print("V "); lcd.print(lc.cellPercent(), 0); lcd.print("% "); lcd.setCursor(0, 3); lcd.print("Temp: "); lcd.print(lc.getCellTemperature(), 1); lcd.print("C");}
void DisplayTimeLCD(byte line) // Display Date and Time on the LCD display at line number{ // Read the Real Time Clock DateTime now = rtc.now(); //Read RTC
// lcd.clear(); //Clear the display - this moves the cursor to home position as well lcd.setCursor(0, line);
lcd.print(now.year(), DEC); lcd.print('-'); if (now.month() < 10) lcd.print("0"); lcd.print(now.month(), DEC); lcd.print('-'); if (now.day() < 10) lcd.print("0"); lcd.print(now.day(), DEC); lcd.print(" ");
if (now.hour() < 10) lcd.print("0"); lcd.print(now.hour(), DEC); lcd.print(':'); if (now.minute() < 10) lcd.print("0"); lcd.print(now.minute(), DEC); lcd.print(':'); if (now.second() < 10) lcd.print("0"); lcd.print(now.second(), DEC); previousTime = currentTime; // Resets the LCD clock display timer}
void PrintTime() // Print Date and Time to the serial port{ // Read the Real Time Clock DateTime now = rtc.now(); //Read RTC
Serial.print(now.year(), DEC); Serial.print('-'); if (now.month() < 10) { Serial.print("0"); } Serial.print(now.month(), DEC); Serial.print('-'); if (now.day() < 10) { Serial.print("0"); } Serial.print(now.day(), DEC); Serial.print(" ");
if (now.hour() < 10) { Serial.print("0"); } Serial.print(now.hour(), DEC); Serial.print(':'); if (now.minute() < 10) { Serial.print("0"); } Serial.print(now.minute(), DEC); Serial.print(':'); if (now.second() < 10) { Serial.print("0"); } Serial.print(now.second(), DEC); Serial.println(); // display.display(); // Show the display buffer} // End of PrintTime
void SetRTC() { bool enterOnSet = false; unsigned long int adjustClock = 0; unsigned long int myDateTime[6]; String nameDateTime[6] = {"Year", "Month", "Day", "Hour", "Minute", "Second"};
// Read the Real Time Clock DateTime now = rtc.now(); //Read Precision RTC lcd.clear(); //Clear the display - this moves the cursor to home position as well DisplayTimeLED(); DisplayTimeLCD(0); lcd.setCursor(0, 1); lcd.print("Set Date & Time: "); lcd.setCursor(0, 3); lcd.print("Press Up Dn or ENTER ");
myDateTime[0] = now.year(); myDateTime[1] = now.month(); myDateTime[2] = now.day(); myDateTime[3] = now.hour(); myDateTime[4] = now.minute(); myDateTime[5] = now.second();
for (int i = 0; i < 6; i++) {
lcd.setCursor(0, 2); lcd.print(nameDateTime[i] + ": " + String(myDateTime[i]));
while (!enterOnSet) { KeyScan(); // Scan the keyboard for keyChar
switch (keyChar) { //Case Key character case char(32): // If null do nothing break; case 'U': // Increment the date or time myDateTime[i]++; break; case 'D': // Decrement the date or time myDateTime[i]--; break; case 'E': enterOnSet = true; break; } // end switch lcd.setCursor(0, 2); lcd.print(nameDateTime[i] + ": " + String(myDateTime[i]) + " "); keyChar = char(32); } //end while enterOnSet = false; } // next i
// This line sets the RTC with an explicit date & time rtc.adjust(DateTime(myDateTime[0], myDateTime[1], myDateTime[2], myDateTime[3], myDateTime[4], myDateTime[5])); DisplayTimeLED(); lcd.clear(); //Clear the display - this moves the cursor to home position as well DisplayTimeLCD(0);
} // End of SetRTC
void helpkeys(){ keyRow = 0; keyCol = 5; char helpKeyText[2][5][6][21] = { "SHIFT:shift function", "^: scroll Stack Up ", "Y: exchange X&Y ", "C: change sign ", "00: enter exponent ", "Del: delete last key", "f4: display datetime", "v: scroll Stack down", "7: enter number 7 ", "8: enter number 8 ", "9: enter number 9 ", "/: Y divided by X ", "f3: HCF high com fac", ": ", "4: enter number 4 ", "5: enter number 5 ", "6: enter number 6 ", "*: Y multiply by X ", "f2: Is X Prime? Test", "ENTER: enter number ", "1: enter number 1 ", "2: enter number 2 ", "3: enter number 3 ", "-: Y minus X ", "f1: the number Pi ", ": ", "0: enter number 0 ", ",: enter 000 ", ".: decimal point ", "+: Y plus X ", "SHIFT: toggle shift ", "^: +LED brightness ", "Y: recall LastX ", "C: set Dec places ", "00: set Sci places ", "Del: delete entry ", "f4: set datetime ", "v: -LED brightness ", "7: not used ", "8: not used ", "9: not used ", "/: not used ", "f3: LCM low com mult", ": ", "4: not used ", "5: not used ", "6: not used ", "*: not used ", "f2: Nth Prime ", "ENTER: not used ", "1: not used ", "2: not used ", "3: not used ", "-: not used ", "f1: the number e ", ": ", "0: not used ", ",: - decimal places ", ".: + decimal places ", "+: show battery info", };
lcd.clear(); //Clear the display - this moves the cursor to home position as well lcd.print("Press a key for Help"); lcd.setCursor(0, 1); lcd.print("Press DEL to return "); lcd.setCursor(0, 2);
while(keyChar != 'D') { // Wait for Del key press to exit keyChar = char(32); // Reset to Null character before next key scan KeyScan(); switch (keyChar) { //Case the Key character case 'S': // Shift key toggle shift = !shift; if (shift) kbd.digitalWrite(ledShift, LOW); // Turn on Shift LED else kbd.digitalWrite(ledShift, HIGH); // Turn off Shift LED break; default: lcd.setCursor(0, 3); lcd.print(helpKeyText[shift][keyRow][keyCol]); } }// stackXtoLED();// stacktoLCD();} // End of helpkeys

Contact: GorDyer@gmail.com