Smashed Laptop Becomes Stylish All-In-One

Many of us will have broken a laptop at one point or another, destroying the screen or smashing the case. It can be frustrating, as there’s a perfectly usable computer in there, trapped inside a broken husk of a body. [Matthew] saw this not as a problem, but an opportunity – and built a beautiful all-in-one desktop PC. (Video, embedded below.)

With a badly damaged Thinkpad laptop to hand, an ASUS monitor was sourced with a thin body and flat back, perfect for mounting hardware. An MDF base was created, on to which the laptop motherboard was mounted. A USB hub and audio amplifier were then added, along with a USB power isolator and soundcard to avoid problems with groundloops from the onboard headphone output. Speakers were Harman Kardon units salvaged from an old television, providing great quality sound for the build.

There’s plenty of great ideas in the video, from using epoxy for a strong permanent assembly, to a nifty hack to make the power button work. It has us contemplating a build for our own broken laptops in the junkpile. We’ve seen other creative all-in-one builds too, like this one inside a printer.

Continue reading “Smashed Laptop Becomes Stylish All-In-One”

Converting An Atari 2600 Into A Home Computer; Did That Ever Work?

[Tony] posted an interesting video where he looks at the Atari 2600 and the way many companies tried to convert it into a real home computer. This reminded us of the ColecoVision, which started out as a video game but could expand to a pretty reasonable computer.

It might seem silly to convert a relatively anemic Atari video game into a computer, but keep in mind that computers were pretty expensive in those days. Not to mention, the Atari itself was a fair investment back then, too.

Continue reading “Converting An Atari 2600 Into A Home Computer; Did That Ever Work?”

This CPU Has Only One Instruction

Most of us will be familiar at some level with the operation of a basic CPU, usually through exposure to microprocessors of the type that find their way into our projects. We can look at its internal block diagram and get how it works, see the registers and ALU, follow the principles of a von Neumann architecture, and understand that it has an instruction set with different instructions for each of its functions. We all know that this only describes one type of CPU though, and thus it’s always interesting to see alternatives. [Ike Jr] then has a project that should provide a lot of interest, it’s a CPU that only has a single instruction. It can only move data from one place to another, which seems to preclude any possibility of computation. How on earth can it work?

The machine has a set of registers as well as memory, and it achieves computation by having specific registers where we might expect to see instructions. For example the AND register is a two-position stack, that when it is full computes the AND of its two pieces of data and places the result in a general purpose register. The write-up goes into significant detail on the CPU’s operation, and while it’s unlikely the world will move en masse to this architecture it’s still a very interesting read. For now this is a machine that exists in software simulation rather than in silicon, and he’s working to release it so enthusiasts for unusual CPUs can have a go.

The idea of having registers that compute reminds us of a transport triggered architecture machine, being not the same as a one instruction CPU with a more conventional computing instruction.

Abstract PCB header image: Harland Quarrington/MOD [OGL v1.0].

3D Print Your Very Own Mechanical Computer

Most Hackaday readers are familiar with computers from the 70s and 80s, but what about ones even older than that? The Digi Comp 1 was a commercially available computer from the 1960s that actually cost less than a modern-day microcontroller. The catch? It was mechanical rather than electrical. Thanks to retro-wizard [Mike Gardi], now anyone can build a replica of one.

Admittedly the Digi Comp 1 was more of a toy than a tool, but it was still a working computer. It contained three flip-flops (memory) and had a lever that acted as a clock, allowing the user to perform boolean operations and some addition and subtraction. Certainly not advanced, but interesting nonetheless. [Mike]’s version of the Digi Comp 1 has an extra bit when compared to the original and includes some other upgrades, but largely remains faithful to the original design.

If you want to print one of these on your own, [Mike] has made all of the files available on Thingiverse. He has also experimented with other mechanical computers as well, including the sequel Digi Comp 2. We’ve seen some recent interest in that mechanical computer lately as well.

Continue reading “3D Print Your Very Own Mechanical Computer”

Proprietary Fan Blows, Gets PWM Upgrade

Proprietary components are the bane of anyone who dares to try and repair their own hardware. Nonstandard sizes, lack of labeling or documentation, and unavailable spare parts are all par for the course. [Jason] was unlucky enough to have an older Dell computer with a broken, and proprietary, cooling fan on it and had to make some interesting modifications to replace it.

The original fan had three wires and was controlled thermostatically, meaning that a small thermistor would speed up the the fan as the temperature increased. Of course, the standard way of controlling CPU fans these days is with PWM, so he built a circuit which essentially converts the PWM signal from the motherboard into a phantom thermistor. It’s even more impressive that it was able to be done with little more than a MOSFET and a Zener diode.

Unfortunately, there was a catch. The circuit only works one way, meaning the fan speed doesn’t get reported to the motherboard and the operating system thinks the fan has failed. But [Jason] simply disabled the warning and washed his hands of that problem. If you don’t want to use a CPU fan at all, you can always just dunk your entire computer in mineral oil.

Apollo Guidance Computer Saved From The Scrap Yard

NASA needed a small and lightweight computer to send humans on their journey to the Moon and back, but computers of the day were made out of discrete components that were heavy, large, complicated, and unreliable. None of which are good qualities for spaceflight. The agency’s decision to ultimately trust the success of the Apollo program on the newly developed integrated circuit was an important milestone in computer history.

Given the enormity of the task at hand and the monumental effort it took, it’s surprising to learn that there aren’t very many left in existence. But perhaps not as surprising as the fact that somebody apparently threw one of them in the trash. A former NASA contractor happened to notice one of these historic Apollo Guidance Computers (AGC) at an electronics recycling facility, and thankfully was able to save it from getting scrapped.

The AGC was actually discovered in 1976, but it was decided to get the computer working again in time for the recent 50th anniversary of the Moon landing. A group of computer scientists in California were able to not only get the computer up and running, but integrate it into a realistic simulator that gives players an authentic look at what it took to land on the Moon in 1969.

Restoring a computer of this age and rarity is no easy feat. There aren’t exactly spare parts floating around for it, and the team had to go to great effort to repair some faults on the device. Since we covered the beginning stages of the restoration last year, the entire process has been extensively documented in a series of videos on YouTube. So while it’s unlikely you’ll find an AGC in your local recycling center, at least you’ll know what to do with it if you do.

Continue reading “Apollo Guidance Computer Saved From The Scrap Yard”

Where The Work Is Really Done – Casual Profiling

Once a program has been debugged and works properly, it might be time to start optimizing it. A common way of doing this is a method called profiling – watching a program execute and counting the amount of computing time each step in the program takes. This is all well and good for most programs, but gets complicated when processes execute on more than one core. A profiler may count time spent waiting in a program for a process in another core to finish, giving meaningless results. To solve this problem, a method called casual profiling was developed.

In casual profiling, markers are placed in the code and the profiler can measure how fast the program gets to these markers. Since multiple cores are involved, and the profiler can’t speed up the rest of the program, it actually slows everything else down and measures the markers in order to simulate an increase in speed. [Daniel Morsig] took this idea and implemented it in Go, with an example used to demonstrate its effectiveness speeding up a single process by 95%, resulting in a 22% increase in the entire program. Using a regular profiler only counted a 3% increase, which was not as informative as the casual profiler’s 22% measurement.

We got this tip from [Greg Kennedy] who notes that he hasn’t seen much use of casual profiling outside of the academic world, but we agree that there is likely some usefulness to this method of keeping track of a multi-threaded program’s efficiency. If you know of any other ways of solving this problem, or have seen causal profiling in use in the wild, let us know in the comments below.

Header image: Alan Lorenzo [CC BY-SA 3.0].