DOS Gaming PC Gets Necessary Updates

PC-104 is a standard computer form factor that most people outside of industrial settings probably haven’t seen before. It’s essentially an Intel 486 processor with lots of support for standards that have long since disappeared from most computers, but this makes it great for two things: controlling old industrial equipment and running classic DOS games on native hardware. For the latter, we turn once again to [The Rasteri] who is improving on his previous build with an even smaller DOS gaming rig, this time based on a platform even more diminutive than PC-104.

The key of a build like this is that it needs native support for the long-obsolete ISA bus to be able to interface with a SoundBlaster card, a gold standard for video games of the era. This smaller computer still has this functionality in a smaller package, but with some major improvements. First, it has a floating point unit so it can run games like Quake. It’s also much faster than the PC-104 system and uses less power. Finally, it fits in an even smaller case.

The build goes well beyond simply running software on a SoM computer. [The Rasteri] also custom built an interface board for this project, complete with all of the necessary ports and an ISA sound chip, all while keeping size down to a minimum. The new build also lets him give the build a better name than the old one (although he phrases this upgrade slightly differently), and will also let him expand some features in the future as well. Be sure to check out that first build if you’re new to this saga, too.

Continue reading “DOS Gaming PC Gets Necessary Updates”

Undocumented X86 Instructions Allow Microcode Access

For an old CPU, finding all the valid instructions wasn’t very hard. You simply tried them all. Sure, really old CPUs might make it hard to tell what the instruction did, but once CPUs got illegal instruction traps, you could quickly just scan possible op codes and see what didn’t throw an exception. Modern processors, though, are quite another thing. For example, you might run a random instruction that locks up the machine or miss an instruction that would have been valid but the CPU is in the wrong mode. [Can Bölük] has a novel solution: By speculatively executing the target instruction and then monitoring the microcode sequencer, he can determine if the CPU is decoding an instruction even if it refuses to execute it.

Some unknown instructions may have power for good or evil, such as the recently announced undocumented instructions that can apparently rewrite the microcode. We expect to see a post soon on how to reprogram your Intel processor to run as a 6502 natively.

Continue reading “Undocumented X86 Instructions Allow Microcode Access”

Oddball X86 Instructions

David Letterman made the top ten list famous. [Creel] has a top ten that should appeal to many Hackaday readers: the top 10 craziest x86 assembly language instructions. You have to admit that the percentage of assembly language programmers is decreasing every year, so this isn’t going to have mass appeal, but if you are interested in assembly or CPU architecture, this is a fun way to kill 15 minutes.

Some would say that all x86 instructions are crazy, especially if you are accustomed to reduced instruction set computers. The x86, like other non-RISC processors, has everything but the kitchen sink. Some of these instructions might help you get that last 10 nanoseconds shaved off a time-critical loop.

Continue reading “Oddball X86 Instructions”

Retrocomputing With Modern Hardware, No Emulation Required

The x86 processor family is for the time being, the most ubiquitous type of processor in the PC world, and has been since the 1980s when the IBM PC came on the scene. Emulating these older devices is easy enough if you want to play an old LucasArts game or experience Windows 3.1 again, but the true experience is found on original hardware. And, thanks to industrial equipment compatibility needs, you can build a brand new 486 machine with new hardware that will run this retro software as though it was new itself.

[The Rasteri] masterminded this build which is reminiscent of the NES classic and other nostalgic console re-releases. It’s based on the PC/104 standard which was introduced in the early 90s, mostly for industrial controls applications. The platform is remarkably small, and the board chosen for this build hosts a 486 processor running at 300 MHz. It has on-board VGA-compatible graphics but no Sound Blaster card, so he designed and built his own ISA-compatible sound card that fits in the PC/104’s available expansion port.

After adding some more tiny peripherals to the build and installing it in a custom case, [The Rasteri] has a working DOS machine on new, bare-metal 486 hardware which can play DOOM as it was originally intended. It can also run early versions of  Windows to play games from the Microsoft Entertainment Pack if you feel like being eaten by a snow monster while skiing. [The Rasteri] is no stranger to intense retro computing like this either, as he was the one who got DOOM to run on original NES hardware.

Continue reading “Retrocomputing With Modern Hardware, No Emulation Required”

New Part Day: Hackboard 2, An X86 Single-Board Computer

From the old Gumstix boards to everyone’s favorite Raspberry Pi, common single-board computers (SBCs) have traditionally had at least one thing in common: an ARM processor. But that’s not to say hackers and makers haven’t been interested in an SBC with a proper x86 processor. Which is why the $99 Hackboard 2 is so exciting. With a modern x86 chip at the core it’s akin to a small footprint desktop motherboard, but with all the extra features that we’ve come to expect in a hacker-friendly SBC.

So what’s the big deal? In a word, compatibility. The fact that these diminutive computing devices shied away from the x86 architecture that most of us have been using on our desktops and laptops since the 1980s originally introduced software compatibility issues, but this was largely outweighed by the advantages of ARM. The latest NVIDIA Jetson is running on an ARM chip for the same reason the smartphone in your pocket is: they’re smaller, cheaper, and more energy efficient than x86.

However they’re rarely more powerful. Even the latest and greatest Raspberry Pi 4, often touted as a viable desktop replacement thanks to its quad core Cortex-A72, will get absolutely trounced by the pokiest of Intel’s Celeron CPUs. The performance gap is just too great. While the Pi can admirably handle most of the tasks the hacker community asks of it, there will always be a call for a board that puts raw processing power before anything else.

Sucking down nearly 40 watts at full tilt, the Hackboard 2 isn’t the SBC you’d want to use for a solar powered weather station. But if you’re putting together a set top box to play back video and run the occasional emulator, its Celeron N4020 processor and Intel UHD 600 GPU represent the most powerful combination available for a device of this size.

Continue reading “New Part Day: Hackboard 2, An X86 Single-Board Computer”

Assembly Language For Real

We all probably know that for ultimate control and maximum performance, you need assembly language. No matter how good your compiler is, you’ll almost always be able to do better by using your human smarts to map your problem onto a computer’s architecture. Programming in assembly for PCs though is a little tricky. A lot of information about PC assembly language dates back from when assembly was more common, but it also covers old modes that, while still available, aren’t the best answer for the latest processors. [Gpfault] has launched a series on 64-bit x86 assembly that tries to remedy that, especially if you are working under Windows.

So far there are three entries. The first covers setting up your toolchain and creating a simple program that does almost nothing. But it is a start.

Continue reading “Assembly Language For Real”

Odyssey Is A X86 Computer Packing An Arduino Along For The Trip

We love the simplicity of Arduino for focused tasks, we love how Raspberry Pi GPIO pins open a doorway to a wide world of peripherals, and we love the software ecosystem of Intel’s x86 instruction set. It’s great that some products manage to combine all of them together into a single compact package, and we welcome the recent addition of Seeed Studio’s Odyssey X86J4105.

[Ars Technica] recently looked one over and found it impressive from the perspective of a small networked computer, but they didn’t dig too deeply into the maker-friendly side of the product. We can look at the product documentation to see some interesting details. This board is larger than a Raspberry Pi, but its GPIO pins were laid out in exactly the same order as that on a Pi. Some HATs could plug right in, eliminating all the electrical integration leaving just the software issue of ARM vs x86. Tasks that are not suitable for CPU-controlled GPIO (such as generating reliable PWM) can be offloaded to an on-board Arduino-compatible microcontroller. It is built around the SAMD21 chip, similar to the Arduino MKR and Arduino Zero but the pinout does not appear to match any of the popular Arduino form factors.

The Odyssey is not the first x86 single board computer (SBC) to have GPIO pins and an onboard Arduino assistant. LattePanda for example has been executing that game plan (minus the Raspberry Pi pin layout) for the past few years. We’ve followed them since their Kickstarter origins and we’ve featured creative uses here and there. LattePanda’s current offerings are built around Intel CPUs ranging from Atom to Core m3. The Odyssey’s Celeron is roughly in the middle of that range, and the SAMD21 is more capable than the ATmega32U4 (Arduino Leonardo) on board a LattePanda. We always love seeing more options in a market for us to find the right tradeoff to match a given project, and we look forward to the epic journeys yet to come.