Just before the dawn of the PC era, IBM typewriters reached their technical zenith with the Wheelwriter line. A daisy-wheel printer with interchangeable print heads, memory features, and the beginnings of word processing capabilities, the Wheelwriters never got much time to shine before they were eclipsed by PCs. Wheelwriters are available dirt cheap now, and like many IBM products are very hackable, as shown by this simple Arduino interface to make a Wheelwriter into a printer.
[Chris Gregg] likes playing with typewriters – he even got an old Smith Corona to play [Leroy Anderson]’s The Typewriter – and he’s gotten pretty good with these largely obsolete but lovable electromechanical relics. Interfacing a PC to the Wheelwriter could have been as simple as scrounging up an original interface card for the machine, but those are like hen’s teeth, and besides, where’s the sport in that? So [Chris] hooked a logic analyzer to the well-labeled port that would have connected to the interface card and reverse engineered the somewhat odd serial protocol by banging on keys. The interface he came up with for the Wheelwriter is pretty simple – just a Light Blue Bean Plus and a MOSFET to drive the bus high and low for the correct amount of time. The result is what amounts to an alphanumeric printer, but with a little extra code some dot-matrix graphics are possible too.
Having spent a lot of time reverse engineering serial comms, we can appreciate the amount of work this took to accomplish. Looking to do something similar but don’t have the dough for a logic analyzer? Maybe you can free up $22 and get cracking on a similarly impressive hack.
There is one aspect of desktop computing in which there has been surprisingly little progress over the years. The keyboard you type on today will not be significantly different to the one in front of your predecessor from the 1970s. It may weigh less, its controller may be less power-hungry, and its interface will be different, but the typing experience is substantially identical. Or at least, in theory it will be identical. In fact it might be worse than the older peripheral, because its switches are likely to be more cheaply made.
Thus among keyboard aficionados the prized possessions are not necessarily the latest and greatest, but can often be the input devices of yesteryear. And one of the more famous of these old keyboards is the IBM Model M, a 1984 introduction from the computer behemoth that remains in production to this day. Its famous buckled-spring switches have a very positive action and a unique sound that once heard can never be forgotten. Continue reading “Do You Miss The Sound Of Your Model M?”→
There is a chain of trust in every modern computing device that starts with the code you write yourself, and extends backwards through whatever frameworks you’re using, whatever OS you’re using, whatever drivers you’re using, and ultimately whatever BIOS, UEFI, Secure Boot, or firmware you’re running. With an Intel processor, this chain of trust extends to the Intel Management Engine, a system running independent of the CPU that has access to the network, USB ports, and everything else in the computer.
Needless to say, this chain of trust is untenable. Any attempt to audit every line of code running in a computer will only be met with frustration. There is no modern Intel-based computer that is completely open source, and no computer that can be verified as secure. AMD is just as bad, and recent attempts to create an open computing platform have met with frustration. [Bunnie]’s Novena laptop gets close, but like any engineering task, designing the Novena was an exercise in compromise. You can get around modern BIOSes, coreboot still uses binary blobs, and Libreboot will not be discussed on Hackaday for the time being. There is no modern, completely open, completely secure computing platform. They’re all untrustworthy.
The Talos Secure Workstation, from Raptor Engineering, an an upcoming Crowd Supply campaign is the answer to the untrustworthiness of modern computing. The Talos is an effort to create the world’s first libre workstation. It’s an ATX-compatible motherboard that is fully auditable, from schematics to firmware, without any binary blobs.
[Connor Krukosky] wanted to buy another computer. Even though he is only 18, he had his first computer at 18 months old. He’s had plenty since then and his interest in computers led him to pursue a career in electrical engineering. A few years ago, [Conner] started collecting vintage computers.
He’d bought up some Apple computers, terminals, and even a Data General minicomputer. Then he found a notice that Rutgers was auctioning off an IBM z890 mainframe computer. People warned [Conner] that this wasn’t a desktop workstation, it was a 2,200 pound case that probably wouldn’t fit through standard doors.
He was undeterred. He won the auction for under $240. The real expense, of course, would be moving it. He planned to make two trips: One to strip the machine to parts and bring some parts back and then a second trip to get the remaining parts.
You can see in the video below that he had a lot of adventure moving the beast. Things didn’t fit and even some excavation had to happen to get the computer in his basement.
Old mainframe computers are interesting, especially to those of us who weren’t around to see them in action. We sit with old-timers and listen to their stories of the good ol’ days. They tell us about loading paper tape or giving instructions one at a time with toggle switches and LED output indicators. We hang on every word because its interesting to know how we got to this point in the tech-timeline and we appreciate the patience and insanity it must have taken to soldier on through the “good ol’ days”.
Ken describes in thorough detail how the IBM 1401 — which was first introduced in 1959 — takes a decimal number as an input and operates on it one BCD digit at a time. Before performing the instruction the BCD number is converted to qui-binary. Qui-binary is represented by 7 bits, 5 qui bits and 2 binary bits: 0000000. The qui portion represents the largest even number contained in the BCD value and the binary portion represents a 1 if the BCD value is odd or a 0 for even. For example if the BCD number is 9 then the Q8 bit and the B1 bit are set resulting in: 1000010.
The qui-binary representation makes for easy error checking since only one qui bit should be set and only one binary bit should be set. [Ken] goes on to explain more complex arithmetic and circuitry within the IBM 1401 in his post.
By the turn of the 19th century, most scientists were convinced that the natural world was composed of atoms. [Einstein’s] 1905 paper on Brownian motion, which links the behavior of tiny particles suspended in a liquid to the movement of atoms put the nail in the coffin of the anti-atom crowd. No one could actually see atoms, however. The typical size of a single atom ranges from 30 to 300 picometers. With the wavelength of visible light coming in at a whopping 400 – 700 nanometers, it is simply not possible to “see” an atom. Not possible with visible light, that is. It was the summer of 1982 when Gerd Binnig and Heinrich Rohrer, two researchers at IBM’s Zurich Research Laboratory, show to the world the first ever visual image of an atomic structure. They would be awarded the Nobel prize in physics for their invention in 1986.
The Scanning Tunneling Microscope
IBM’s Scanning Tunneling Microscope, or STM for short, uses an atomically sharp needle that passes over the surface of an (electrically conductive) object – the distance between the tip and object being just a few hundred picometers, or the diameter of a large atom.
A small voltage is applied between the needle and the object. Electrons ‘move’ from the object to the needle tip. The needle scans the object, much like a CRT screen is scanned. A current from the object to the needed is measured. The tip of the needle is moved up and down so that this current value does not change, thus allowing the needle to perfectly contour the object as it scans. If one makes a visual image of the current values after the scan is complete, individual atoms become recognizable. Some of this might sound familiar, as we’ve seen a handful of people make electron microscopes from scratch. What we’re going to focus on in this article is how these electrons ‘move’ from the object to the needle. Unless you’re well versed in quantum mechanics, the answer might just leave your jaw in the same position as this image will from a home built STM machine.
In days of yore, one could mine Bitcoin without much more than an AMD graphics card. Now, without specialized hardware it’s unlikely that you’ll make any appreciable headway in the bitcoin world. This latest project, however, goes completely in the other direction: [Ken] programmed a 55-year-old IBM mainframe to mine Bitcoin. Note that this is technically the most powerful rig ever made… if you consider the power usage per hash.
Engineering wordplay aside, the project is really quite fascinating. [Ken] goes into great detail about how Bitcoin mining actually works, how to program an assembly program for an IBM 1401 via punch cards, and even a section about networking a computer from this era. (Bonus points if he can get retro.hackaday.com to load!) The IBM boasts some impressive stats for the era as well: It can store up to 16,000 characters in memory and uses binary-coded decimal. All great things if you are running financial software in the early ’60s or demonstrating Bitcoin in the mid-2010s!
If it wasn’t immediately obvious, this rig will probably never mine a block. At 80 seconds per hash, it would take longer than the lifetime of the universe to do, but it is quite a feat of computer science to demonstrate that it is technically possible. This isn’t the first time we’ve seen one of [Ken]’s mainframe projects, and hopefully there are more gems to come!