In the early days of handheld computing, PDAs were typically powered by ordinary alkaline batteries. The Psion Organiser, for instance, used a single 9‑volt battery, while the Psion Series 3 ran on two AA‑sized 1.5‑volt cells. These are just two examples—most competitors relied on similar power sources. Yet those batteries often lasted for weeks of normal use.
At first glance, this seems almost impossible. Today’s smartphones usually last only one or two days between charges, even though their lithium‑ion batteries store an order of magnitude more energy than the alkaline cells of the past.
So what changed?
To understand this apparent contradiction, we need to break down where the power actually goes inside handheld computers—both past and present.
A Rough Comparison of Power Consumption
| Component | Psion Organiser (1984) | Modern Smartphone (2024) |
|---|---|---|
| CPU | ~5–10 mW | 500–3,000+ mW |
| RAM | ~0.5–1 mW | 100–500 mW |
| Storage | ~50 mW | 50–1,000 mW |
| Display | ~1–2 mW | 200–2,000 mW |
| Miscellaneous | ~0 mW | 500–5,000 mW |
| Total (active) | ~60 mW | ~1,500–10,000+ mW |
Even a rough look at the bottom line makes the difference obvious: the Organiser consumed only a tiny fraction of the power of a modern smartphone. Let’s take a closer look at each component.
CPU: From Thousands to Billions of Transistors
The CPU is the most complex part of any computer, and it has evolved dramatically over the last 40 years. At its core, a CPU is a vast network of logic gates built from transistors.
The Hitachi 6301 CPU used in the Psion Organiser contained on the order of 40,000 transistors. By contrast, the Apple A17 chip found in a 2024 iPhone contains roughly 19 billion transistors—almost half a million times more.
Each transistor primarily consumes power when it switches state, from on to off or vice versa. In modern chips, however, transistors are so small and so densely packed that leakage currents between adjacent structures become significant. As a result, the chip must constantly be “refreshed” simply to maintain its state, even when it appears to be idle.
Static Design and the “Clock‑Stop” Era
Early microprocessors often used what is known as a static design. This meant that you could literally stop the clock signal and the CPU would retain its internal state. In this “stopped‑clock” mode, the processor drew almost no power at all.
For a PDA, this was ideal. The CPU could remain effectively off until you pressed a key or triggered some calculation.
In modern processors, leakage currents and complex internal subsystems make this approach impractical. Even when a smartphone appears to be sleeping, large parts of its system remain partially active.
Frequency, Voltage, and Power
Another key factor is how fast the CPU runs—its clock frequency.
- The Hitachi CPU in the Psion Organiser ran at about 0.9 MHz.
- A modern smartphone CPU typically runs at around 4 GHz.
That is more than 5,000 times faster.
A simplified expression for dynamic power consumption looks like this:
P = C · V² · f
Where:
- P = Power consumption
- C = Effective capacitance (a constant for a given design)
- V = Supply voltage
- f = Clock frequency
As the formula shows, increasing the frequency increases power consumption—but increasing the voltage has an even greater effect, because it is squared.
Older CPUs typically ran at 5 volts, while modern chips operate at well under 1 volt. This dramatic reduction in voltage helps keep power consumption within practical limits, despite the massive increase in frequency and transistor count.
Memory: SRAM vs. DRAM
Early PDAs used Static Random Access Memory (SRAM) both for running the operating system and applications and for storing user data. SRAM only consumes noticeable power when it is being read from or written to. When “nothing happens,” its power draw is extremely small.
This is why a tiny coin‑cell battery could keep a PDA’s memory alive for months.
Later devices switched to Dynamic Random Access Memory (DRAM). DRAM can store far more data in the same physical space, which made it very attractive to designers. However, DRAM requires constant refreshing to maintain its contents—and that refresh process consumes power continuously.
The trade‑off was clear: much higher memory capacity in exchange for much higher power consumption. Most designers chose capacity.
Displays: From Passive to Power‑Hungry
The first PDAs used simple monochrome LCD panels with low resolution and no backlight. These displays required very little energy. In many ways, they behaved like capacitors: they mainly consumed power when changing state, not while holding an image.
As resolutions increased and backlighting became standard, displays began to demand more energy. When full‑color LCDs entered the market, the screen often became one of the single largest contributors to overall power consumption.
“Miscellaneous”: The Always‑On World
Early PDAs were simple, single‑task devices. Even when basic multitasking appeared, there was very little happening in the background.
There was no need to constantly check for:
- Wi‑Fi networks
- Cellular connections
- GPS signals
- Bluetooth devices
- Printers, sensors, or file system changes
Those technologies simply did not exist in early handhelds. Modern smartphones, by contrast, contain a whole ecosystem of radios and sensors that remain partially active at all times—and all of them consume power.
Summary
In the early days of handheld computers, very little happened unless you made it happen. The CPU and memory could remain in near‑zero‑power states for long periods, and most of the device truly “slept” while sitting in a pocket or a drawer.
Modern smartphones are fundamentally different. They are always connected, always monitoring, and always running background processes. Even when you are not actively using them, a great deal of computation and communication continues behind the scenes.
This shift—from user‑driven activity to always‑on computing—explains much of the dramatic difference in battery life.
Longing Back?
After reading this, you might find yourself nostalgic for the “good old days,” when the programmer had full control over everything that happened inside the machine.
I felt that sense of control again years later when I started programming microcontrollers like the Arduino and the ESP32. These systems do not have an operating system in the traditional sense. Instead, they provide a small bootloader and a communication routine that lets you upload your program. Once started, the device runs only your code, beginning at a predefined entry point.
For me, it was a powerful reminder of what early computing felt like: a machine that did exactly what you told it to—and nothing more.