THP Entry: A 6502 SBC Robot (On Multiple Boards)

SBC

Robots have always been a wonderful tool for learning electronics, but if you compare the robot kits from today against the robot kits from the 80s and early 90s, there’s a marked difference. There are fairly powerful microcontrollers in the new ones, and you program them in languages, and not straight machine code. Given this community’s propensity to say, ‘you could have just used a 555,’ this is obviously a problem.

[Carbon]‘s entry for The Hackaday Prize is a great retro callback to the Heathkit HERO and robotic arms you can now find tucked away on a shelf in the electronics lab of every major educational institution. It’s a 65C02 single board computer, designed with robotics in mind.

The 6502 board is just what you would expect; a CPU, RAM, ROM, CPLD glue, and a serial port. The second board down on the stack is rather interesting – it’s a dual channel servo board made entirely out of discrete logic. The final board in the stack is an 8-channel ADC meant for a Pololu reflective sensor, making this 6502 in a Boe-bot chassis a proper line-following robot, coded in 6502 assembly.

[Carbon]‘s video of his bot below.


SpaceWrencherThe project featured in this post is an entry in The Hackaday Prize. Build something awesome and win a trip to space or hundreds of other prizes.

[Read more...]

An FPGA Based 6502 Computer

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.

Reverse Engineering Unobtanium

font

If you listen to [Bil Herd] and the rest of the Commodore crew, you’ll quickly realize the folks behind Commodore were about 20 years ahead of their time, with their own chip foundries and vertical integration that would make the modern-day Apple jealous. One of the cool chips that came out of the MOS foundry was the 6500/1 – used in the keyboard controller of the Amiga and the 1520 printer/plotter. Basically a microcontroller with a 6502 core, the 6500/1 has seen a lot of talk when it comes to dumping the contents of the ROM, and thus all the code on the Amiga’s keyboard controller and the font for the 1520 plotter – there were ideas on how to get the contents of the ROM, but no one tried building a circuit.

[Jim Brain] looked over the discussions and recently gave it a try. He was completely successful, dumping the ROM of a 6500/1, and allowing for the preservation and analysis of the 1520 plotter, analysis of other devices controlled by a 6500/1, and the possibility of the creation of a drop-in replacement for the unobtanium 6500/1.

The datasheet for the 6500/1 has a few lines describing the test mode, where applying +10 VDC to the /RES line forces the machine to make memory fetches from the external pins. The only problem was, no body knew how to make this work. Ideas were thrown around, but it wasn’t until [Jim Brain] pulled an ATMega32 off the top of his parts bin did anyone create a working circuit.

The code for the AVR puts the 6500/1 into it’s test mode, loads a single memory location from ROM, stores the data in PORTA, where the AVR reads it and prints it out over a serial connection to a computer. Repeat for every location in the 6500/1 ROM, and you have a firmware dump. This is probably the first time this code has been seen in 20 years.

Now the race is on to create a drop-in replacement of what is basically a 6502-based microcontroller. That probably won’t be used for much outside of the classic and retro scene, but at least it would be a fun device to play around with.

C64 Emulator For The Arduino Due

c64

Almost a year ago, [miker00lz] started a thread on the Arduino forums telling everyone about a 6502 emulator and BASIC interpreter he wrote for an Arduino Uno. The chip inside the Uno isn’t a powerhouse by any means, and with only 2KB of RAM it’s far less capable than just about any computer from the 70s. Arduino works on a lot of different chips, though, and after a few months, [Jan] turned an Arduino Due into a Commodore 64 emulator.

[Jan]‘s code isn’t limited to the DUE, and can be used with any chip with enough memory. If you’re feeling fancy, you can connect a TFT display for all the vintage goodness of PETSCII graphics, all while running a faster BASIC than the very stripped down EHBASIC.

Because the emulator is using software to talk to the outside world, it should be possible to use this project to interface with the cooler chips found in Commodore machines – SIDs for one, but also the cartridge port for some vintage Ethernet goodness. It’s not even limited to Commodore machines, either: the POKEY chips found in Atari 8-bit micros are seriously underutilized in the chiptune and demoscene, and having modern hardware to play with these chips couldn’t hurt in the slightest.

[Read more...]

Propeddle, The Software Defined 6502

propeddle

When it comes to building retrocomputers, there are two schools of thought. The first is emulation, that allows for greater compatibility and ease of use, and much easier to find parts. The second requires real, vintage hardware with all the bugs and idiosyncrasies found in vintage chips. Reconciling these two ideas is hard, but the software defined Propeddle manages to do it, all while using a real 6502 CPU.

The trick here is using a Parallax Propeller for the heavy lifting of loading the ROM into RAM with an extremely clever technique using the Reset and NMI pins, generating the clock and other signals required by the 6502, and hosting the keyboard, serial, and video I/O. Already [Jac] has the Propeddle running as an Apple 1 emulator (video below), making it possible to write programs for the Propeddle in BASIC or assembly.

It’s a great design that allows for emulation of a lot of the classic 6502 computers with a real CPU, all while doing away with the cruft of expensive ACIAs and video generation hardware. Awesome work, and we can’t wait for the next version that will be dedicated to [Bill Mensch].

[Read more...]

A Pick-And-Mix FPGA Retrocomputer

Logo

Cheap FPGA boards are readily available, as are VHDL implementations of classic CPUs like the 6502, 6809, and Z80. Up until now, we haven’t seen anyone take these two parts and combine them into a complete system that turns an FPGA board into a complete 8-bit retrocomputer. Thanks to [Grant]‘s work, it’s now possible to do just that (server on fire, here’s a google cache) with a $30 FPGA board and a handful of parts.

In its full configuration, the Multicomp, as [Grant] calls his project, includes either a 6502, 6809, Z80, or (in the future) a 6800 CPU. Video options include either monochrome RCA, RGB VGA, or RGB via SCART. This, along an SD card interface, a PS2 keyboard, and the ability to connect an external 128kB RAM chip (64k available) means it’s a piece of cake to build a proper and complete portable retrocomputer.

What’s extremely interesting about [Grant]‘s project is the fact the data and address lines are fully exposed on the FPGA board. This means it’s possible to add whatever circuit you’d like to whatever retrocomputer you can imagine; if you want a few NES gamepads, an IDE interface, or you’d like to design your own primitive video card, it’s just a matter of designing a circuit and writing some assembly.

If you’d like to build your own, search “EP2C5T144C8N” on the usual sites, grab a few resistors and connectors, and take a look at [Grant]‘s documentation and upcoming examples.

Via 6502.org forums

The Three Chip Retrocomputer

3chip

Where homebrew computers are usually complex bundles of wires and chips, [Mike]‘s own single board computer is not. It’s a three-chip computer with only a CPU, RAM, and a microcontroller that is able to emulate the retrocomputers of yore.

Normally, a homebrew computer project requires some amount of ‘glue’ logic – a few NAND, OR, or inverters to combine signals and send them where they’re needed for address decoding. This tiny pocket computer doesn’t need any of that; all the address decoding is done on a 40-pin PIC microcontroller.

With 64kB on the PIC 18F46K22, there’s enough space for all the address decoding logic, space for a pseudo ACIA mapped onto the $DF page, and a ROM image that provides a monitor program and a copy of BASIC. Basically, with the addition of a USB to serial adapter, this is a three chip 6502 single board computer, and with the right ROM monitor can emulate an Apple I, Woz monitor included.

Yes, 6502 projects are a dime a dozen, but [Mike]‘s work with the address decoding logic on the microcontroller is top-notch. There are a few remaining chip select lines in his schematic, and with another microcontroller it would be easy to add VGA out, a compact flash adapter, or some other really cool peripherals. Good thing there’s an expansion port on this thing.

Follow

Get every new post delivered to your Inbox.

Join 92,288 other followers