Guest Rant: From Bits To Atoms

October 18, 2013 by Quinn Dunki 83 Comments

I’ve been a software developer for quite a while. When you spend long enough inside a particular world, it’s easy to wind up with an ever-narrowing perspective. You start seeing everything from a software point of view. As the saying goes, when your only tool is a hammer, you tend to treat every problem as NP-Complete. Or something. I forget how that goes.

Anyway, the point is, it’s always good to broaden one’s horizons, and solve as many different kinds of problems as possible. To that end, I started to get into hobby electronics recently. The journey has been very enlightening in a number of ways.

Continue reading “Guest Rant: From Bits To Atoms” →

Interfacing A GPU With A CPU

December 26, 2012 by Mike Szczys 11 Comments

interfacing-a-gpu-with-a-cpu

[Quinn Dunki] pulled together many months worth of work by interfacing her GPU with the CPU. This is one of the major points in her Veronica project which aims to build a computer from the ground up.

We’ve seen quite a number of posts from her regarding the AVR-powered GPU. So far the development of that component has been happening separately from the 6502 centered CPU. But putting them together is anything but trivial. The timing issues that were so important to consider when developing the GPU get even hairier when it comes writing to the VRAM from an external component. Her first thought was to share a portion of the external RAM between the CPU and GPU as a way to push rendering commands from one to the other. This proved troublesome both in timing and in the number of pins available on the AVR chip. She ended up using something of a virtual register on the AVR chip that can receive commands from the CPU asynchronously. Timing dictates that these commands be written only during vertical blanking so this virtual register also acts as a status register to let the CPU know when it can send the next command.

Her post is packed with the theory behind the design, timing tests on the oscilloscope, and a rather intimidating schematic. But the most important part is the video showing her success in the end.

Macro Assembly For AVR Chips

December 12, 2012 by Mike Szczys 20 Comments

avr-macro-assembly

Here’s an interesting tip that can help improve your ability to write assembly code. In an effort to remove the complexity of assembly code for an AVR project [Quinn Dunki] figured out how to use macros when writing AVR code with the GNU toolchain. Anyone using AVR-GCC should keep this in mind if they ever want or need to pound out a project in assembly language.

If you look at the code snippet above you’ll see two commands that are obviously not assembly; PulseVRAMWrite and DisableVRAMWrite. These are macros that direct the assembler to roll in a hunk of code. But avr-as, the assembler used with this toolchain, lacks the ability to handle macros. That’s too bad because we agree with [Quinn] that these macros make the code easier to read and greatly reduce the probability of error from a typo since the code in the macro will be used repeatedly.

The answer is to alter the makefile to use GNU M4. We hadn’t heard of it, but sure enough it’s already installed on our Linux Mint system (“man m4” for more info). It’s a robust macro processor that swaps out all of her macros based on a separate file which defines them. The result is an assembly file that will play nicely with avr-as.

Her implementation is to help in development of the GPU for her Veronica computer project.

Fortifying Veronica’s VGA Output

August 10, 2012 by Mike Szczys 1 Comment

[Quinn Dunki] just moved to a new work space and had to pack up her homebrew computer project — called Veronica — in the process. She just unboxed it again and decided now was a good time to fortify the VGA display hardware. It wasn’t in the greatest of shape, since everything for the initial video tests had been built on a breadboard. The transition to protoboard ended up turning out just swell.

One of the thing’s that we like best about [Quinn’s] hacks is that she documents her failures (or perhaps we should just call them hiccups?) just as much as she does her successes. This is not a small thing. We understand, because our own screw-ups don’t usually get photographed due to our raging need to just make the frakking thing work.

Once she had moved all the components to the new board the circuit was amazingly organized. Since she’s doing high-speed switching with the VGA signals it was important to keep the lines as short and straight as possible, hence the SRAM stack seen above. But when it was first fired up she had a jumble of only-somewhat-organized color stripes. It turns out that she had forgotten to change the color register in the AVR code, the color lines were hooked up in the wrong order, and the switch mode supply was injecting noise into the system. But thanks to her documentation of these issues we’ll know what to do when we find ourselves in a similar situation.

Backplane And Mainboard For A 6502 Computer

January 4, 2012 by Mike Szczys 11 Comments

[Quinn Dunki] has been busy through the holidays giving her 6502 processor-based computer a place to live. The most recent part of the project (which she calls Veronica) involved designing and etching a mainboard for the device. In the picture above it’s the vertical board which is right at home in the backplane [Quinn] also designed.

The project is really gaining momentum now. You may remember that it started off as a rather motley arrangement of what we’d guess is every breadboard she owns. From there some nifty hex switches gave [Quinn] a way to program the data bus on the device. Many would have stopped with these successes, but the continuation of the project makes the hardware robust enough to be around for a while. The single-sided boards are playing nicely together, and the next step is to redesign the ROM emulator to use chips for storage. [Quinn] alludes to a side project in which she plans to build her own EEPROM programmer to help with getting code into the experimental computer.

Building A Computer Around A 6502 Processor

November 30, 2011 by Mike Szczys 24 Comments

When it came time to try out some old-school computing [Quinn Dunki] grabbed a 6502 processor and got to work. For those that are unfamiliar, this is the first chip that was both powerful, affordable, and available to the hobby computing market back in the 1970’s. They were used in Apple computers, Commodore 64, and a slew of other hardware.

The first order of business in making something with the chip is to establish a clock signal. She sourced a crystal oscillator which runs at 1 MHz, but also wanted the option to single step through code. Her solution was to build two clock signals in one. A toggle switch allows her to choose the crystal, or a 555 timer circuit which uses a push button to fire each clock pulse.

Check out the video after the break to see some single stepping action. There’s no memory on board just yet. But the input pins have been hard-wired to voltage or ground to simulate data input. We wondered what she was up to with that HEX Out project which stiffs the logic on the data bus. Looks like it’s extremely useful in this project!

Continue reading “Building A Computer Around A 6502 Processor” →