HP Classic Calculator Emulator +
HP-35 Born 1972
Replacement CPU boards for the HP-55, HP-65 HP-67 and HP-97
New Spice CPU Board
The HP-67, HP-97 and Spice have Continuous Memory Features
- Drop in replacement for the original CPU boards
- Spice supports HP-31E, 32E, 33C, 34C, 37E and 38C models, inbuilt battery charger (LiPo), new mambrane keypad
- No soldering required (HP-97 requires battery charger wires soldered)
- Runs original HP microcode
- Supports original features of the magnetic card reader*^
- Programmable option to bypass the card write protection*^
- HP-97
has printer interface, HP-82240 IR printer interface, HP-97S mode,
alarm clock, adjustable print speed and intensity, beeper
- Real time battery backed clock (HP-97 and Spice)
- Bluetooth connectivity
- Companion Windows application
- Has internal memory storage for up to 810 program cards (HP-55 100 programs)
- Spice has 300 program storage each for HP-33C, 34C and 38C.
- Supports up to 100 user defined messages that can be displayed from a running program*^
- HP-55 has ability to fine tune timer
- HP-65 can store and recall calculator state
- Supports a memory dump to the CCE33 Emulator
- CPU board can be reflashed with program updates - Note: Requires an external adaptor
- HP-67 and HP-97 can transfer RAW card data to the PC to see what the card reader actually read
(* Not available for HP-55) (^ Not available for Spice)
Note: These CPU boards
will not fix problems with the display, keyboard or card reader
components, however if the card reader has failed, you can still save
and recall programs using internal storage memory.
Prices
HP-55, HP-65, HP-67 CPU boards - $Aus80.00 each
HP-97 CPU board $Aus170.00
Spice CPU board $Aus135.00
Plus tracked airmail postage cost
Contact Teenix for details
CalCom PC Program
This is the program that communicates with the CPU boards via Bluetooth or the USB port.
Download Files - Updated 280523
Can be unzipped into its own directory or into the Emulator files directory if installed.
Current CPU board upgrade hex files (If using, upgrade Calcom also)
HP-55 (V06)HP-65 (V15)HP-67 (V35)
HP-97 (V16)
Spice (V01)
ChangeLog Text File
NOTE: HP-67 Continuous Memory CPU board is still compatable with earlier versions
Poster (V01)
Updated 070621
|
The
HP-35 has reached its 50th anniversary since being manufactured so to
commemerate this event, this A1 size HP-35 poster project was created.
Click on the poster to download in PDF
format. Any design can be used as long as it can be printed. For example, your favorite calculator might be the HP-67
All
construction, circuit and help details are in the CalCom download
above. |
  
|
These zip files contain circuit diagrams, component overlays, and
Gerber details that a PCB manufacturer can use to create the boards.
Note: See Readme in each zip file.
2 Layer Circuit Board design for HP-35 HP-45 and HP-55. (16 pin Clock Driver)
|
 
|
4 Layer Circuit Board design for HP-65.
2 Layer Circuit Board design for HP-67.
|
|
Sense Circuit Board replacement design for HP-65 and HP-67
|
Poster Project Features:
-
A1 sized poster
-
The buttons work by touching the front glass of the poster panel
-
Selectable HP-35 (LN bug), 35, 45, 55, 65, 67, 70 and 80 models.
-
15 digit LED display
-
Decimal points are centred like real Classic displays
-
Up to 7 programs can be stored for use with the HP55, 65 and 67 models
-
12/24 hour clock, timing derived from 50/60Hz mains supply
-
Display dimming
-
CalCom connectivity via a wired FTDI RS232 connection for PC data transfers and reprogramming.
This project gives you
the opportunity to experience 31 different HP calculator models from the late 60's and 70's era.
PC Emulator Features
- PC emulator
- HP01, HP19C, HP21, HP22, HP25, HP25C, HP27, HP29C,
- HP31E,
HP32E, HP33E, HP33C, HP34C, HP37E, HP38E, HP38C
- HP35 red dot (2.02 bug), HP35, HP45, HP46, HP55, HP65, HP67, HP70,
HP80,
- HP91, HP92, HP95C, HP97, HP56i
- HP9100B
- PC emulator
- Normal speed or Turbo code execute mode
- Working program card readers for HP65, HP67, HP97 and HP9100B
- Emulates the HP19C, HP25C, HP29C, HP34C, HP33C and HP38C continuous memory
- Functional printer for HP19C, HP46, HP91, HP95C, HP97 and HP9100B with save option and prints in orginal format
- HP9100B also simulates working Marked Card Reader, Plotter and Extended Memory Unit
- Where available, calculators run original microcode
- Simulator with Assembler, Code Trace and Capture, Single Step, Slow and Run modes, register modify
- User defineable trace data capture
- Ability to log running programs
- Supports HP67 and HP97 parking cards while waiting for [Pause] or [WData] in programs
- HP-67 can emulate with 4 times normal memory
- Text file based program card editor which supports program labelling
- HP-65, HP-67 and HP-97 can display messages from running programs, HP-97 can also print them
- Preassembled HP65 DemoPac1, MathPac1, EEPac1,
StandPac1, AVPac1
- Preassembled HP67 DemoPac1 - Works with HP97
- Where possible original sound effects were used for calculators, printers, plotter etc.
Hardware Emulator Features
- USB interface
- In circuit PIC programming
- PDF schematic and circuit boards layout
- Circuit board design supplied in zipped Gerber format
- Printable keyboard overlays for PIC calculator models
While
pottering around the web some time ago I came across the HP-45
scientific calculator which was made by Hewlett Packard back in the
1970’s. Seeing it again fired up feelings of nostalgia and took me on a
journey back to my school days when I used to own one of these so many
years ago. Back in the day the HP-45 was one of the first in a new
breed of pocket scientific calculators which are referred to as the
Classic Series.
Calculators are pretty much taken for granted
these days, cheap and plentiful, tossed back into the drawer after use
and even for the technically inquisitive, hardly worth the look inside
when all you see is a small black blob on a circuit board. There was a
time when the calculator was a prized item and although not as fast as
today’s variants, were much faster and more accurate than the well used
slide rule and amazingly some mainframe computers as well. For the
curious, even to this day, there are still interesting goodies inside
to fire up a technical imagination. A few of the carry cases were
nicely crafted items too. Some were made from real leather and others
made from metal with a luxurious leatherette cover with a soft lining
inside. There were also lockable accessory items to chain those
expensive items to the desktop.
Back in those school days we had
to use paper, pencils, grey sandy erasers that loved to munch holes
through your work notes, and awful logarithm books to help solve
multiply and divide problems. Modern technology came to our maths class
one day when we were presented with a pile of odd looking cardboard
computer cards and given a simple problem to try and solve. Armed with
a high tech paper-clip we poked through the pre-punched numbers
imprinted on these cards causing a small snow storm of paper dots that
scattered around the classroom. Well, not that bad, but the cards were
soon gathered up by the teacher and mysteriously sent off to a
university mainframe computer and I’m guessing now that its error
routines went into overdrive as it tried to digest them. A few weeks
passed and the results came back printed on a pile of folded perforated
paper sheets, but sadly our paper clips were probably bent in the wrong
shape and none of us were ready to join the computer age just yet.
It
was about that time when calculators began to creep into the classroom
and like most I decided that I would like to own one too. Some I had
seen at the time were big with a tiny eight digit display, had the
basic four functions and maybe a square root key. I decided the one I
wanted was the new HP-45 scientific calculator but it had a "reduced" price tag of
around $240.00 and as my family was one of the usual battlers, the
challenge was up to me to figure out how to get one. No small feat for a wee school lad in those days.
Working before and after school and
on weekends eventually paid off and I found myself in the store
excitedly handing over my hard earned savings to a salesman who
presented me with a large white box in return. Bouncing around in an old “Red
Rattler” train during the trip home, I couldn’t wait any longer and I
still remember the strangely sweet but strong plastic odour that rose
up as I opened the box. At the flick of a switch my brand new
calculator came to life with the now familiar [0.00]
displayed in bright red LEDs. Sifting through the box, I found a spiral
bound owner manual, in colour, plus a smaller quick reference guide
which in itself would rival some of today’s manuals, (if any are
supplied), a battery charger and a soft real leather carry case. I
couldn’t wait to try it out at school. Geeks in the 70's, who would have thought....
An example of the HP-65 delivery package compared to todays models.
This
series of calculators have held their value over the years with many
still working today or have been restored back to working condition and
kept as collector’s items.
Internal Design
Having
an early interest in electronics, after awhile I couldn’t resist and
had to open up the calculator and see what was hiding inside. I didn’t
understand much about the internals back then but hopefully here is a better albeit brief
insight.
The
architecture of the Classic Series was similar although the HP-65 had
the unique magnetic card reader. The circuitry was optimized for
floating point operations and because silicon real estate was expensive
back then, the data bus paths were serial not parallel as you might
expect. This meant the circuitry and PCB design could be much simpler
and therefore cheaper. Sections of data such as the exponent of a
number could be intercepted in the serial bit stream and used
individually for the computations. The 3 busses were the SYNC line, the
Is line used for instructions, and the WS line used for gating the
serial stream.
The
chips used were MOS/LSI types and included
multiple ROMs, an Arithmetic and Register Circuit (ARC), a Control and
Timing Circuit (CTC), a two phase clock generator, LED anode cathode
drivers and some models had a RAM storage chip. The internal resgisters
were made up of 56 bits each. Low power consumption requirements soon
meant that CMOS chips
would be used, however at the time the extra gate required more silicon
and the additional manufacturing processes added up to a higher cost.
Negative Logic was used where 0V represented Logic 1 and 6V represented
Logic 0. The Classic Series consumed about 500mW and the switching
power supply transformed the 3.75V NiCad battery output to +6V, +8V
and -12V for circuit operation. The batteries would generally last for
a day depending on usage, and once flat, they would require an
overnight recharge.
Internally, numerical data is
made up of 14 digits in binary coded decimal (BCD) format giving a word
size of 56 bits. Ten of the digits were allocated for the mantissa, one
for the mantissa sign, two for the exponent and one for the exponent
sign.
The
ARC executes instructions from the Is line and sends out display data
to the LED anode driver and carry bit information to the CTC chip. It
also incorporates the seven 56 bit working registers A to M which
include the operational stack registers X, Y, Z and T. Not all of these
registers could communicate with each other. For example the M register
could only be accessed through the C register. The CTC controls the
house keeping functions of the calculator including interrogating the
keyboard, checking system status, synchronization and modifying
instruction addresses. The anode driver was responsible for final
decoding of the display data, driving the LED anodes, sending clock
signals to the cathode driver and low power indication which lit all
decimal points. The cathode driver is a 15 bit shift register for
sequentially controlling the on / off state of each display digit.
The
ROM chips could hold 256 ten bit words using serial address in and
serial data out. Three of these chips were used in the HP-35, shown
below as round cans. More program memory was required in the other
models so DIL packages were produced with four times the memory and
were referred to as Quad ROMs. To save space in models
like the HP-65 and HP-80, all the logic chips, with the exception of
the ROMs were placed on a hybrid chip carrier inside a rectangular
metal can.
To
run the internals, a series LC oscillator is used to generate a
frequency of about 800KHz.
This signal was divided down to a 2 phase 200KHz system clock which was
the
maximum allowed for the chips and gave a CPU word cycle time of about 286uS.
LC oscillators are not that accurate, so a more stable crystal
oscillator circuit was used in the HP-55 because it had a usable
timer function. The HP-45 had a non
documented timer but could be accessed by pressing RCL and then the
CHS, 7 and 8 keys simultaneously. Word got around that you could modify
the underside of the HP-45 ENTER key and then the timer could be
activated more easily by pressing
RCL then ENTER. It was also possible to install a 784KHz crystal to
make the timer more accurate. The timers were
implemented by a fixed 35 instruction code loop which set the time
delay for a 100th second counter. (35 x 286uS = 10mS, x 100 = 1 second). Because there were no software
interrupts, you either had a calculator or a timer.
Some average calculation speeds are as follows:
Add, Subtract 60mS
Multiply Divide 100mS
Trigonometric 500mS
These
delays will compound themselves when executing complex algorithms from
a running program, and the calculators could appear to ‘hang’ for
sometimes quite long periods.
Registers A and B are used both for holding display data and for
general software tasks, so while programs were running and with
some
calculations, the display shows the jumble of data going through these
registers to give some user feedback while the calculator is at work.
The following original
demonstration shows the length of time it took someone using a slide
rule and the
new HP-35 calculator to solve the great circle distance between San
Francisco and Miami.
Slide Rule
2255
5 minutes
HP-35 2254.093016 65 seconds
Breathtakingly
fast back in the day no doubt, and many of the engineers quickly
replaced the slide rules in their top pockets with these new
calculators. In fact the HP-35 quickly became a sought after item far
exceeding initial market expectations with over 300,000 units being
delivered in the 3 years following introduction. However, going
unnoticed until after production began, a problem occurred when
calculating the natural log of 2.02 using the ln key. Reversing the
process with the eX key gave an answer of 2 rather than the correct
2.02. This bug was discovered after many units were sold and
while it could have been ignored, all affected owners were notified and
offered replacements. Interestingly some owners decided not to take up
the offer and some of those buggy calculators are still floating
around today making good collector’s items.
All
the Classic calculators had a 15 digit display. The decimal point
position was not part of the 14 digit numerical data. Instead, its
position was decoded by the anode driver and occupied one whole digit
on the display. Its true position could still be seen even if all
decimal points were lit during a low power condition. Register A held
the BCD digits for the display while register B was used as a mask
register. Nibbles in register B were decoded by the anode driver such
that 9 = Digit Off, 0 = Digit On, and 2 = Decimal Point On. On
detecting the decimal point, the anode driver would display the
next digit and then add an extra step cycle to display the decimal point in the following digit. Numbers
were formatted in 10’s complement notation with 9’s in the sign digits
indicating negative
numbers and were decoded by the anode driver to
display the negative sign. An interesting feature of the multiplexed
LED display was its brightness and was achieved by using small
inductors to dump their stored charge into each LED segment. Timing was
critical so that the charge would not bleed into adjacent displays
causing them to be partially lit. The inductors had a charge time of
2.5uS and the discharge time through the LED segment was about 5uS and
gave an average single LED current of about 0.73mA.
The Status
register is made up of 12 bits and can be used as software flags but
some bits are connected directly to hardware logic. An example is
Status bit [0] which is set to 1 when a key is pressed and back to 0
when it is released. Register C nibbles 12 and 11 were used to load the
Data register with a RAM address from the instruction [c -> data
address]. The C register could then be loaded with a new number which could be stored
in RAM with the instruction [c -> data]. RAM was transferred back into
the C register with the instruction [data -> c].
Unique key
press values are generated from the CTC scanning process. For example
the ENTER key when pressed returns a value of 62. (60 if modified as
mentioned above.) The actual key values are transferred to the program counter
by using the instruction [keys -> rom address]. In this way each key
press provides an index to a simple but efficient jump table. In this
part of the
HP-45 code listing from ROM 4 you can see that the two entry points for
the ENTER key (60 and 62) do essentially the same thing, which in this case was
after the Shift key was pressed and executes microcode to set the [Deg] mode of operation.
60 clok: no operation
61 no operation
62 degr: a - 1 -> a[w]
There
was a lot of effort put into the keyboard operation to make it user
friendly even down to the key spacing and colouring. Each key had an
“oil canning” roll forward operation which gave them a high quality
positive feel and were double injection moulded for long lasting readability and even
after 40 years they still work.
RPN
After
purchasing the calculator I soon realised that the keyboard was missing
the [=] key and this confused me for a while. I had never heard of RPN
previously, but it was well demonstrated in the manual and the concept
was easy to learn. I have to say even to this day, I still prefer it
over conventional calculator operation.
A book by Jan
Lukasiewicz in 1951 first demonstrated that arbitrary expressions could
be specified unambiguously without parentheses. In other words, (a + b)
x (c – d) could be specified as:
a (enter) b (enter) [add] c (enter) d (enter) [subtract] [multiply]
This method is referred to postfix notation and became known as Reverse Polish Notation or RPN in honour of Lukasiewicz.
Implementing
this concept in a computer environment requires an arrangement in
memory called a stack. The Classic Series have 4 levels of stack named
X, Y, Z and T and these appear in registers C, D, E and F. Keying in
number (a) initially goes into the X register and pushes the other
values in the stack up by one level with the value in T being lost.
Number (b) is then entered followed by the operator [add]. This causes
the values in X and Y to be added with the result being placed back
into X. The upper stack levels all drop down by one with the T value
being duplicated into Z.
Stack manipulation in the calculators
is software driven and uses instructions like [c -> stack] which
pushes the stack up 1 level and copies the X register into Y. As an
example, it is used in code when the ENTER key is pressed. The user can
also manipulate the stack by rolling it up or down and swapping the X
and Y registers from the keyboard.
During the design phase,
building the circuits discretely for testing was considered but would
not be practical. Fortunately there was some computing power available
which could simulate designs down to gate level, although the data
input was on punched cards, (presumably better paper clips than mine)
and the output was printed on paper and had to be evaluated.
The
HP-35 actually had numerical algorithms that exceeded the precision of
some mainframe computers at the time and writing those calculator
algorithms offered some interesting challenges for the engineers.
Maintaining the accuracy of the various calculator functions was
difficult to achieve especially when rounding errors compound
themselves. Calculating SIN(x) for example required a divide, multiply,
subtract, two more divides another multiply, an addition and a square
root, with each process adding to rounding errors creating an
undesirable outcome. The code therefore had to be written using various
mathematical techniques and the engineers did a remarkable job getting
around these problems given the limited hardware available.
Coding
All
code for these calculators was listed in OCTAL format as shown in the
following instruction listing example at address @54 (44dec). The CPU
code is binary with dots representing 0’s.
Address 10 bit CPU
Code Instruction
44 L00054:
..1..1....
:
select rom 1
Here’s a small taste of one of the many problems those engineers would have been faced with.
The
ROM address space is limited by 256 word boundaries even in the Quad
ROMs. After an instruction executes at decimal address 255 the program
counter will wrap around and the next instruction will be fetched from
address 0. This actually happens purposely in some code segments. The
instruction that gives access to the other ROMs is called [select rom
n], where n can be 0 – 7. For the HP-35, n can be either 0, 1 or 2, for
the three available ROMs. However, a limitation is that you cannot jump
to a random address in another ROM, it is always the current program
counter + 1. Imagine the program counter is at address 44 in ROM 0 and
the instruction [select rom 1] executes. The program counter will
increase by one to address 45 as normal, but access is now from ROM
chip 1. That doesn’t sound like a big deal but it can be. For example,
as a talented engineer you try to fix that bug in the HP-35 code by
inserting a “clear register b” instruction into ROM 0 at address @20 - Not the real fix :-)
16 L00020:
....1.111.
: 0 -> B[W]
No
problem, there is ROM space
available and you just insert the instruction and recompile. Today this
would be a trivial thing to do, but alas not so in this case.
Imagine there is a
[select rom 0] instruction in ROM 2 at address @33. After this
instruction executes, the program counter will increment to @34 and the
program continues from ROM 0. Unfortunately the instruction that was
supposed to be there in ROM 0 is now one address higher because of the code
change and the program will now fail. To fix this new problem you will
have to go through the entire code listing and locate every [select rom
0] instruction that is positioned at or above address @20 and move them
up by one address or move the instructions at the other end down by one
address. As you might imagine, this could potentially disturb even more
instructions causing a coding nightmare. (Try the concept out using the emulator described below)
Some calculator models
required more than 8 ROMs so an extra hardware bit was added to enable
addressing for 2 groups of 8 ROMs. New instructions were introduced and
were called [delayed select group] and [delayed select rom]. They were
“delayed” because they only preset the ROM or group addressing bits and
had no effect until a jump or subroutine instruction was executed. That
way you could select a group and a ROM in that group prior to the actual program counter change. As
a bonus they also allowed jumps to random memory addresses which simplified
the programmer’s job quite a bit.
Magnetic Card
The
HP-65 and HP-67 were unique in that they incorporated a miniature
magnetic card read/write
mechanism and with 100 words of usable program memory (224 for the
HP-67) they were
formidable devices in thier day. Mind you, the earlier HP-9100A/B
models also had program card capabillity, but a box full of HP-67s
could fit in the case of one of those old beasties.The program elements
were just copies of the key
codes and each occupied 6 bits in memory, (8 bits for the HP-67). In
some cases two or three keys could
be saved as one code and therefore conserve expensive memory space.
Merging key
codes like this was a new concept back then and in the HP-65, they were
allocated to
25 commonly used key combinations such as STO 1, which stores the
displayed number into memory 1. The HP-67 had many more merged codes
available. The
HP-65 program memory was essentially a 600 bit serial buffer. It had
provision for a
fixed top of memory marker, plus a program pointer and a subroutine
pointer which were both free to circulate inside the buffer. The single
subroutine pointer allowed for one level of subroutine only.
The magnetic card read/write mechanism posed many
mechanical and electrical design difficulties such as card alignment,
low battery, temperature problems and greasy cards to name but a few.
They were eventually overcome and the result was a calculator that was
only slightly deeper in size than the others in the Classic Series. It
was impressive engineering for the day and without modern CAD systems
some cases were moulded in clear plastic to see how things would fit
inside. The HP-67 used 32 x 56 bit RAM registers to store the program
data. The memory cards for this calculator could also store data memory
and if required the programs and data could be stored on 2 cards.
The
HP-67 magnetic cards stored the program data, a header and checksum
and were written onto the magnetic media at 300 bits per inch. It took
about 2 1/2 seconds for the card to move over the head for the
read/write process. Once stored in the calculator memory, individual
program functions were generally activated from the A to E or R/S keys. If
desired, you could use a marker pen to write program details onto the
face of the card which you could slide into a slot above the keyboard
for reference. Many programs were available for purchase and you could
write and share your own which was quite popular.
Try it all out
The emulator
program allows you to use these calculators either by themselves on screen or
open them up to simulate, set break points, modify, compile and experiment with all
the
operating code and registers.
The
project was put together using freely available documentation from the
web, however some microcode information proved to be unreliable or totally
unavailable so in these cases a "best guess" approach was used to fill
in the blanks and do the repairs, however all calculators operate
as
presented in thier respective owner handbooks and documentation. For
example, the microcode for the HP-10 will probably never become
available as it is embedded inside a single large multipurpose chip, so the microcode for this
model was written completely from scratch using the owners manual as a
guide and assembled using the emulator described here.
Free
Downloads - Windows only
The software was developed in a Windows 10 environment. The MultiCalc and Extras downloads
include the PC emulator, Help file, PIC HEX file, schematics, PCB
design files, and key
overlays.
After installation, see the help file (PDF) for setup information.
Also included are construction details on how to build the real working
calculator.
The other downloads
are modules that implement the respective calculator.
All
files are in zipped format. Download MultiCalc.zip (and for new installs - the Extras file) and unzip into a
directory of your choice. All calculator modules (except stand alone applications) must be unzipped into
this directory or they won't work.
HP-65 includes
over 150 program card files, each with memory card graphics 
HP-67 includes 24 program card files for all the demo programs from the owners handbook
HP-91 now has original microcode thanks to Bernhard at Panamatik
HP-92 now has original microcode
HP-9100B includes simulated Marked Card Reader, Plotter, Printer and Extended Memory Unit
The owner handbooks for some calculators and
some of the quick reference guides and patent documents are also
available.
Note:
Please make sure you have the latest calculator module if it has been
updated or it might not work with the current MultiCalc files.
Emulator Download MultiCalc.zip Updated 270523
Some manuals available in some of the downloads are a bit grainy. If you would like to get some better ones
and also see a lot of interesting HP calculator information, take
a leisurley visit to the HP Museum.
PIC code updated - 270523
* Models not supported with current PIC code
Stand
alone applications. These do not need the MultiCalc files. Unzip into a seperate
directory
MultiCalc Calculator Project - Emulates 27 Models
Build A Real Working Calculator
All
design files are provided to create a real calculator that can
be built from cheap and easy to get components and is
based on the PIC18F47K40 microcontroller. The one circuit emulates the original
code and functionallity for 22 calculator models which can be selected by using an inbuilt menu
directly from the keyboard.
It also includes the slide switches for
functions like the Run-PGM-Timer function used on the HP-55 and
the Run-W/PGM functions
for the HP-65 and HP-67. Printable keyboard overlays for each calculator
are also
available. The original low power display modes are also fully working. The PC emulator program can communicate with it via the
USB port and lets you change calculator models, upgrade the driver software, and transfer a large range of
programs for the HP-65 and HP-67 memory cards and programs
for other programmable models like the HP-25.
This
is a totally new version of the MultiCalc based on a PIC 18F47K40
chip. Unfortunately due to the complex code changes, it was not
possible to
make it compatable with the earlier hardware calculator based on the
PIC16F1519. If you want to keep using the original version and also
want this one, download these newer files to a new directory.
The
original microcode for all calculators (HP-10 is my code) is stored
inside the PIC chip and each model is instantly selectable from the menu accessed from the keyboard.
Red LED display
Works on 3xAAA batteries, 3.7V LiPo, and can be powered via the USB port.
The calculator can store and recall up to 8 blocks of 51 programs for the
HP65 and HP67 plus a total of 8 blocks of 32 programs for the other programmable
models.
Continuous memory supported for the HP-19c, HP-25c, HP-29c, HP33c, HP-34c and HP-38c.
Battery monitoring and gives original looking low battery display when activated.
Working switches for each model
USB interface built in, but requires a generic USB cable for connection to a PC.
Reprogrammable via USB or PICkit3 ICSP
The HP-10, HP-19c,
HP-46, HP-91 and HP-97 all have a printer, so the PIC calculator can
transfer all the microcode printer instructions to the PC
(if connected to the USB
port)
and it will display the printer output from these models. You can
also print a hard copy to paper if desired. All printouts are in the
original
thermal or mechanical printer style.
\
