AVR8 Virtual Processor On FPGA

November 19, 2009 by Mike Szczys 15 Comments

[Jack] wrote in to let us know about a project that creates a virtual microprocessor core based on the ATmega103 by using a Field-Programmable Gate Array. Great, we thought. Here’s another rather esoteric project like the NES on a FPGA, but what’s the motivation behind it? We asked [Jack] and he provided several scenarios where this is quite useful.

Implementing the AVR core allows code already written for the chips to be easily ported to an FPGA without a code rewrite. This way, if your needs outpaced the capabilities of the microcontroller long after the project has started, you can keep the code and move forward from that point with the added capabilities of the gate array. Having the core already implemented, you then only need to work with HDL for the parts of the project the AVR was unable to handle. He also makes the point that having an open source AVR core implementation provides a great tool for people already familiar with AVR to study when learning VHDL.

With products like the Butterfly that this project is based around, or the Maple we’ve seen in the past, programmable logic for the recreational hacker is starting to get a little easier.

PIC Powered AVR Programmer

November 18, 2009 by Mike Szczys 28 Comments

[Texane] wrote in to let us know he has implemented AVR ISP programming using a PIC microcontroller. He wrote some code for an 18F4550 that uses the STK500 standard for In System Programming. This means that his hardware is compatible with AVRdude, the open source AVR programming software. There has long been an argument over the virtues of PIC versus AVR but we say why not both? If you have already honed your programming chops with PIC, you can build your own programmer and give the Atmel family a try.

The current implementation uses a serial port to connect the programmer to a computer. Keep your eye on this one as [texane] plans to add USB connectivity and has told us he will post schematics for the device as soon as that is complete.

RFID Door Lock – The Right Way

November 17, 2009 by Mike Szczys 40 Comments

[youtube=http://www.youtube.com/watch?v=XT7E_GEIPVg]

[Pcmofo] has shared a well-built, well-explained example of how to implement an RFID key system for a door. We call this the right way because it is well thought out and functional. In the past we’ve seen doors that unlock via a secret knock, keypads, and RFID, but they are all non-permanent solutions capable being transplanted from one door to another. Rather than building a mechanism to turn the door handle, this implementation uses an electric strike mounted in the framing of the door to allow access. These are used for security doors in buildings and are built to keep your door secure.

The hack in this case is the electronics. Using an AVR ATmega168 running the Arduino boot-loader, [pcmofo] has prototyped a two-part design. An RFID reader is mounted outside the door with data wires running to the inside where the microcontroller resides. A hard-coded RFID card is used as a “master” to train any number of tags for entry. The master puts the device in training mode and the next tag to be read is added to the list of tags authorized to open the door.

We like messy wires and quickly thrown together devices but this is built to last and will look great once mounted in an appropriate enclosure.

Bulbdial Redux

November 15, 2009 by Jakob Griffith 9 Comments

[Taufeeq] sent in his “Circle of Light” bulbdial clock. You may remember when we showed you Evil Mad Scientist’s version a while back, and [Taufeeq] did use it as a base but he’s added some of his own little touches. Some of the changes include using a PIC with an RTC chip instead of AVR, which allowed him to shrink the board down small enough to fit behind the clock face, rather than on front. He’s even zipped everything up conveniently to help you build your own.

PCB Light Box In A Scanner Shell

November 10, 2009 by Mike Szczys 18 Comments

scanner-exposure-box

[Kizo] repurposed a flatbed scanner to use as an exposure box for making printed circuit boards. Exposure time is controlled by an AVR ATtiny2313 microcontroller. The device is connected to a separate display board to control four 7-segment displays using one shift register for each. Time is set in ten second increments and once started, switches on the lights with a relay. Once the right exposure time has been reached, the lights are switched off and a piezo speaker is buzzed. There’s no mention of they type of bulbs he’s using but they look like compact fluorescent with tin foil beneath as a reflector.

If these are just CFL bulbs, how will the performance compare to a light box based around a UV light source?

[Thanks Jake]

8-bit Device Quenches IPhone Envy

November 3, 2009 by Mike Szczys 69 Comments

avr-iphone-envy

[Peter] deserves an award for doing more with less. He’s built a handheld device based on an AVR controller that has features normally associated with much more powerful devices. Here’s what it doesn’t do: no phone calls, no text messages, no accelerometer, and best of all no app approval needed. What it does do is leverage inexpensive, readily available components combined with common homebrew development techniques to create a touch sensitive handheld.

The demo video embedded after the break details the device playing video, rendering 3D objects, and displaying pictures and ebooks with touch scrolling. All of this is running at 60 fps for a smooth picture. The whole thing is no larger than the 320×240 LCD that he salvaged from a broken MP3 player. An Atmel AVR ATmega644 microcontroller ties together the display, a resistive touch screen, and a microSD card for storage. The chip also controls the backlight, a Lithium Polymer battery, and uses USB for PC connectivity, charging, and even a mouse or keyboard interface. He etched the PCB himself for surface mount components and managed to do it with just four jumpers needed on the underside.

This is a big leap forward from the last AVR based touch sensitive device we saw. All of the functionality seen in the demo is run using 4k of memory and 32k of programming space. Because [Peter’s] powering this at 3.3v the system clock is limited to 12MHz but he’s managed to make it work. We asked him to post code and schematics and he didn’t hold back. Head over to the microtouch project page to download the code, Eagle CAD files, and PCB artwork. All of the demo files are there just waiting for you to build on his hard work. When you’ve got something running, don’t forget to share it with us!

Continue reading “8-bit Device Quenches IPhone Envy” →

Make Your Own SNES Games With Developer Cartridge

October 23, 2009 by Mike Szczys 75 Comments

Have you always wished that you could develop games for the Super Nintendo but couldn’t because you were only 4 years old when it was released in 1990? Here’s a second chance. [Max] and his team have created a SNES developer’s cartridge that allows you to load your own code, run it on the SNES, and debug as needed. At its core is an Atmel AVR ATmega644 that is running a boot loader, allowing for firmware updates via USB. Once the system is powered on, ROM code is sent over USB to the 16 megabits of onboard SRAM. A debug terminal can be connected with an RS232 converter, providing status information and allowing some register manipulation.

We can believe there are a few hardcore SNES fans out there who will take the time to write custom code. We could also see this being used for the purposes of SNES sythesized music. But is there a wide demand for this type of hardware? If you’ve ever looked into developing for the SNES, let us know in the comments.