Upgrading The Battery In A Wrist PDA

September 8, 2014 by Brian Benchoff 22 Comments

No, your eyes do not deceive you. That’s a wrist-mounted PDA. Specifically, a Fossil Wrist PDA, also known as an Abacus, that was sold from 2003 to about 2005. Yep, it’s running PalmOS. [mclien] has had this watch/PDA for a while now, and found the original 180mAh battery wasn’t cutting it anymore. He made a little modification to the watch to get a 650mAh battery in this PDA by molding a new back for it.

The original PDA used a round Lithium cell, but being ten years old, the battery technology in this smart watch is showing its years. [mclien] found two batteries (380mAh and 270mAh) that fit almost perfectly inside the battery.

The new batteries were about 3mm too thick for the existing case back, so [mclien] began by taking the old case, adding a few bits of aluminum and resin, and making a positive for a mold. Two or three layers of glass twill cloth were used to form the mold, resined up, and vacuum bagged.

After many, many attempts, [mclien] just about has the case back for this old smartwatch complete. The project build logs are actually a great read, showing exactly what doesn’t work, and are a great example of using hackaday.io as a build log, instead of just project presentation.

Hackaday Retro Edition: 386 Compaqs

September 1, 2014 by Brian Benchoff 28 Comments

[Antoine] recently learned of a little challenge we have in the hinterlands of the Hackaday webosphere – what’s the oldest, or lowest spec hardware you have that can load this our retro edition? He has a pile of old PCs at his work, and with a lot of idle time at work because of summer, he decided to dig into that pile and get a really old computer up on the Internet.

While the pile of PCs didn’t have anything as old as he was expecting, [Antoine] did find an old Compaq from 1992. It has a 386DX running at 25MHz, 4MB of RAM, a 300 MB hard drive, VGA, and an Ethernet NIC. Gathering the requisite CRT monitor, PS/2 keyboard, and an AUI to a more modern Ethernet connector.

When getting these ancient computer on the Internet, the secret sauce is in the software configuration. [Antoine]’s box is running DOS 6.2, but was previously configured to connect to a Microsoft filesystem server on boot. This server was probably somewhere at the bottom of the same pile the Compaq was salvaged from, so rolling his own modern networking stack was the way to go. A driver for the NIC was downloaded on another computer and transferred via floppy, as was mTCP, the key to getting a lot of old PCs on the Internet. The browser is Arachne, and with the right configurations, everything worked perfectly.

[Antoine]’s efforts resulted in a computer that can easily handle the stripped down Hackaday retro edition, and can handle light browsing on Wikipedia. The effective download rate is something like a 33k modem; even with a fast (10M!) Ethernet connection, processing all the packets is taxing for this old machine.

Hackaday Retro Edition: Browser Wars On Solaris

August 23, 2014 by Brian Benchoff 21 Comments

sunn After seeing an earlier Hackaday post on old, old Unix systems loading up our retro edition, [Eugenio] decided he would play out the late 90s browser wars on a few machines of his own. Yes, it’s Internet Explorer vs. Netscape in a fight to the death. No <blink> or <marquee> tags were involved, but a Sun Ultra 5 was. We’re looking at the peak of the workstation world circa 1999 here, and only one browser would emerge victorious (it’s neither IE nor Netscape, btw).

The Solaris 9 system [Eugenio] has supports both Internet Explorer 5 and shipped with Netscape 4. Compared to the functionality of modern browsers, both IE5 and Netscape 4 are ancient and terrible. Remember kids, even the scroll wheel on a mouse is a relatively new invention.

Our retro edition doesn’t have any CSS, Javascript, or any of the new Web weirdness, so everything loaded as it should. One interesting problem [Eugenio] encountered was an inverse color desktop when the IE5 window was in focus. Bringing another window into focus returned the desktop to the right color. I guess Netscape wins the Solaris browser war.

[Eugenio] also dug out an old VT320 terminal and connected it to a Vaio x505 (the same approximate vintage as the Sun Ultra 5). This worked beautifully in both 80 and 132 column mode.

We’re always looking for new submissions of old computers loading up our retro site. We haven’t had many minicomputers loading the site, so dig out those Vaxxen and send something in.

Continue reading “Hackaday Retro Edition: Browser Wars On Solaris” →

When Worlds Collide: 68008 Bootstrapped By An Arduino Uno

August 21, 2014 by Adam Fabio 23 Comments

68008-ardu

[Peter Bjornx] brings classic microprocessors and modern microcontrollers together with his Arduino bootstrapped 68008 computer. The Motorola 68008 is the 8-bit external bus version of the well-known 68000 (or 68k) microprocessor. A friend gave [Peter] one of these chips, so he built a simple computer around it.

This isn’t one of those clean retrocomputers with every connection carefully planned out and wire wrapped. [Peter’s] created a true hack – a working 68k system on a breadboard created with whatever he had on hand at the time. The real gem of this system is the ROM. [Peter] replaced an EPROM chip with an Arduino.

In the not-so-good-old-days, microprocessors (and many microcontrollers) ran from an external ROM chip. This often was a UV-erasable EPROM. Carefully compiled code was burned into the EPROM with a device programmer. If the code wasn’t perfect, the EPROM had to be pulled and placed under a UV lamp for 20 minutes or so to erase it before it was time to try again. EPROM emulators were available, but they were way too expensive for the hobbyist.

Thankfully those days are far behind us now with the advent of EEPROM and then Flash. [Peter] didn’t want to revisit the past either, so he wrote a simple Arduino sketch which allowed it to act as an EPROM emulator, including address logging via the serial port.

The design still caused [Peter] some headaches, though. His major problem was a classic 68k issue, /DTACK timing. /DTACK or Data Transfer Acknowledge is one of several bus control signals used by the 68k. When the 68k performs a read from the data bus, it waits for /DTACK before it transfers data. The Arduino was too slow to release /DTACK in this case, which caused the 68k to think every read was immediately completed. There is a much clearer explanation of the 68k bus cycles on this Big Mess O Wires page. [Peter’s] solution was simple – a D flip-flop connected to the address strobe took care of the timing issues.

It took quite a bit of tinkering, but the system eventually worked. Peter was able to run the 68008 from its reset vector into a simple loop using the Arduino. It’s only fitting that the 68k program loaded by the Arduino was an LED blinker, everyone’s favorite hardware Hello World.

Thanks [Robert!]

An FPGA Based 6502 Computer

August 16, 2014 by Eric Evenchick 20 Comments

A diagram of the CHOCHI Board

It’s no secret that people love the 6502 processor. This historic processor powered some of our favorite devices, including the Apple II, the Commodore 64, and the NES. If you want to play with the 6502, but don’t want to bother with obtaining legacy chips, the CHOCHI board is for you.

While many people have built modern homebrew 6502 computers, the CHOCHI will be much easier for those looking to play with the architecture. It’s based on a Xilinx XC3S50 FPGA which comes preconfigured as a 6502 processor.

After powering on the board, you can load a variety of provided binaries onto it. This collection includes a BASIC interpreter and a Forth interpreter. Of course, you’re free to write your own applications in 6502 assembly, or compile C code for the device using the cc65 compiler.

If you get bored with the 6502 core, you can always grab Xilinx’s ISE WebPACK for free and use the board as a generic FPGA development tool. It comes with 128K of SRAM and 31 I/O pins. Not bad for a $30 board.

Commodore 1530 Datasette Gets A Digital Counter

August 9, 2014 by Adam Fabio 25 Comments

Ah, the humble Commodore 1530 Datasette drive. It never enjoyed much popularity in the USA, but it was the standard for quite some time in Europe. [DerSchatten13] still uses and loves his 1530. When a co-worker showed him some 7-segment bubble LEDs, he knew what he had to do. Thus the 1530 digital counter (translated) was born.

[DerSchatten13] started out by building his design on a breadboard. He used every I/O pin on an ATtiny2313 to implement his circuit. Tape motion is detected by a home-made rotary encoder connected to the original mechanical counter’s belt drive. To keep the pin count down, [DerSchatten13] multiplexed the LEDs on the display.

Now came the hard part, tearing into the 1530 and removing the mechanical counter. [DerSchatten13] glued in some standoffs to hold the new PCB. After rebuilding the circuit on a piece of perfboard, he installed the new parts. The final result looks great on the inside. From the outside, one would be hard pressed to tell the digital counter wasn’t original equipment.

Operation of the digital counter is identical to the analog unit – with one exception. The clear button now serves double duty. Pressing and holding it saves the current count. Save mode is indicated by turning on the decimal point. If the user rewinds the tape, the counter will stop the motor when the saved count is reached. Cueing up that saved program just got a heck of a lot easier!

Continue reading “Commodore 1530 Datasette Gets A Digital Counter” →

Fixing A BASIC Calculator

August 3, 2014 by Brian Benchoff 26 Comments

The early days of modern computing were downright weird, and the HP 9830B is a strange one indeed: it’s a gigantic calculator, running BASIC, on a CPU implemented over a dozen cards using discrete logic. In 2014 dollars, this calculator cost somewhere in the neighborhood of $50,000. [Mattis] runs a retrocomputer museum and recently acquired one of these ancient machines, and the walkthrough of what it took to get this old machine running is a great read.

There were several things wrong with this old computer when it arrived: the keyboard had both missing key caps and broken switches. The switches were made by Cherry, but no one at Cherry – or any of the mechanical keyboard forums around the Internet – have ever seen these switches. Luckily, the key cap connector isn’t that complex, and a little bit of bent wire brings the switches back up to spec. The key caps were replaced from a few collectors around the globe.

Getting as far as booting the machine, [Mattis] found some weirdness when using this old calculator: the result of 2+2 was 8.4444444, and 3+1 was 6.4444444. Simply pressing the number 0 and pressing execute resulted in 2 being displayed. With a little bit of guesswork, [Mattis] figured this was a problem with the ALU, and inspecting the ROM on that board proved to be correct: the first 128 nibbles of the ROM were what they were supposed to be, and the last 128 nibbles were the OR of the last half. A strange error, but something that could be fixed with a new replacement ROM.

After hunting down errors with the printer and the disk drive, [Mattis] eventually got this old calculator working again. For such an astonishingly complex piece of equipment, the errors were relatively easy to hunt down, once [Mattis] had the schematics for everything. You can’t say that about many machines only 10 years younger than this old calculator, but then again, they didn’t cost as much as a house.