Scaled down it’s not as obvious that this image isn’t a crystal clear rendering of Mortal Kombat gameplay. But we’ve linked it to the full size version (just click on the image) so that you can get a better look. Notice the scan lines? This is the result of an effort to more accurately mimic the original hardware displays used in classic games. [Jason Scott] takes a look at the initiative by describing what he thinks is missing with the picture perfect quality of modern emulators.
One such effort is being mounted for MAME (Multiple Arcade Machine Emulator). There is a series of filters available — each with their own collection of settings — that will make your modern LCD display look like it’s a run-of-the-mill CRT. This is a novelty if you’re a casual gamer who dusts off the coin-op favorites twice a year. But if you’re building a standalone game cabinet this may be a suitable alternative to sourcing a working display that’s already decades old.
[skywodd] just finished his own DCPU emulator (French, translation) based on [notch]’s upcoming game, 0x10c. The neat thing about [skywodd]’s build is his emulator uses the lowly ATMega328, the same microcontroller found in (some) Arduinos.
The DCPU specification goes over the operations required of any DCPU emulator. There’s a lot of crazy stuff here – a division instruction that takes only 3 clock cycles, using an overflow for carry conditions, and a complete lack of a JMP instruction – but [skywodd] was able to tease something apart from DCPU studio and a VGA interface
Everything in this emulator is built on a solderless breadboard, but the ROM and RAM isn’t complete yet. As of now, everything is handled by the ‘328, using 478 bytes of RAM on the microprocessor.
We promised we would be holding a contest for the best physical implementation of the DCPU when we caught wind of 0x10c, and [skywodd]’s build is starting to look like the beginnings of the winning entry. We honestly have no idea when we’ll be holding this contest, but it’ll probably be shortly after the first playable release. Go bug [notch] if you’d like to speed up the progress, because obviously Twitter abuse speeds up software development.
[Notch], the guy behind Minecraft, is currently working on a new game called 0x10c. This game includes an in-game 16-bit computer called the DCPU that hearkens back to the 1980s microcomputers with really weird hardware architecture. [Benedek] thought it would be a great idea to turn his ThinkPad into a DCPU, so he wrote a bootable x86 emulator for the DCPU that is fully compliant with the current DCPU spec.
This bootable DCPU emulator comes from the fruitful workshop of [Benedek], the brains behind drawing fractals on the DCPU, emulating bit-flipping radiation, and even putting the Portal end credits inside [notch]’s 0x10c computer.
[Benedek] wrote this new in x86 assembly, allowing it to be booted without an OS from a USB flash drive on any old laptop. This allows for direct hardware communication for everything implemented for the DCPU so far.
If you’d like to run your bare-metal DCPU, [Benedek] made all the files avaiable. Since the entire emulator is only 1800 lines of x86 assembly, it’s possible to load this off a floppy disk; an ancient tech we’ll be seeing in [notch]’s new game.
Oh. One more thing. When we were introduced to 0x10c, we said we’ll be holding a contest for the best hardware implementation of the DCPU. We’re still waiting on some of the hardware specs to be released (hard drives and the MIDI-based serial interface), so we’ll probably be holding that when there is a playable alpha release. [Benedek]’s bootable emulator is a great start, though.
Falling on the heels of some fabulous ‘lets see what we can emulate on an AVR’ builds we’ve seen, [Dimitri] emulated an ARM Cortex-M0 on an 8-pin ATtiny85.
The emulator is written entirely in AVR assembly. Unfortunately, the instruction set of ATtinys don’t have a multiply instruction, so that had to emulated in a separate piece of code. Even with this addition, the emulator is very small; the core is just over 1300 instructions and small enough to fit on the Flash of the very small ‘tiny85.
Unlike the ATMega running Linux we saw last month, [Dimitri] won’t be doing anything crazy like making the tiniest and worst Linux computer ever. The Cortex-M0 doesn’t have a MMU, so Linux is out of the question. [Dimitri] could go with μCLinux, with the addition of a I2C EEPROM and RAM, but don’t expect a speed demon for an emulated ARM running at 200kHz.
[Dimitri] put all the code up on his webpage, and the installation is just running ‘make.’ It looks easy enough to get up and running very quickly, so we’re sure some bored hardware guru will come up with something interesting to do with this code.
[dgcx] has been working on reimplementing a PDP-10/x on an FPGA for the last 2 and a half years. This surprised us because we’re only hearing about this project now.
After designing three versions, [dgcx] eventually ended up with a one-FPGA implementation of a PDP-10 and an awesome PDF writeup. Although PDP-10 emulators do exist, this project isn’t an emulation – the system actually has the 36-bit word length of the original, implemented on five 4096 kilobit SRAM chips. This is a fully functioning replica, and even has CHAOSNET implemented with a small Ethernet controller.
Continue reading “Putting a PDP-10 on an FPGA”
When you are running emulators or virtual machines it may be sometimes handy to be able to connect a serial port from the guest machine to the host machine. [Aurimas] had that issue, and also had a fun fix for that using 2 USB <> Serial adapters, but as you can imagine that is not a ideal solution, enter the Virtual Serial Bridge.
Digging around Vmware it was found that the support for what he needed was there, but not really used. A little addition of a few lines to the guest OS vmx file and configuring the socat multipurpose relay package. Though the instructions revolve around the Mac platform as the host and Windows as the guest socat and Vmware you can probably mix it up with any software that uses the serial port and a *x or windows host.
This device is called the Cumulus and it’s used to emulate the floppy disk hardware for Oric-1 and Oric Atmos computers. These 1980’s era computers included an expansion slot to which you could connect a floppy drive. That module, called a Microdisc system, also included the driver circuit which means you can’t just use a modern-day floppy drive as a replacement. [Retromaster] sidestepped the need for magnetic media all together by building an SD card interface which emulates the original module. We can tell by the use of a color screen and clean board layout that a lot of love went into the project. A CPLD implements the communications protocol used by the Microdisc system and creates all of the registers that would have been found on the original hardware. A PIC takes care of the SD card communications and the user interface.
With the exception of comforting noises, we’d bet there are few who have fond memories of using floppy disks. No wonder we’ve been seeing hacks to replace them quite a bit lately.