AVR

333 Articles

[CNLohr]’s Microscope Slide Linux AVR Minecraft… Thing

February 18, 2013 by 19 Comments

We’ve been following [CNLohr]’s process of creating an AVR-powered microscope slide running Linux and interfacing redstone circuits in Minecraft to real world electronic for a while now, but we’re really at a loss for words on how it works. Well, now there’s a video explaining everything you want to know about this amazingly complicated and overwrought thing.

The device is powered by an AVR microcontroller and Ethernet controller running [Fabrice Bellard]’s JSLinux in a browser. [CNLohr] added a few bits to JSLinux allowing him map the x86 IO ports emulated inside JSLinux to the AVR’s IO ports. This allows him to query the status – both analog and digital – using just a browser. Very cool, but [CNLohr] can also run his Minecraft server optimized for 8-bit devices on this microscope slide server to create a bridge between real electronics and redstone circuits.

To sum up what’s going on here, [Bellard] created an x86 emulator in JavaScript, and put Linux on it. [CNLohr] is serving this from a microcontroller attached to a circuit built on a microscope slide so he can blink an LED from within Minecraft. It’s the most beautifully over engineered and useless thing we’ve ever seen, basically.

In the video after the break, you can see [CNLohr]’s overly convoluted walk through of what’s going on with this microscope slide server. As a little bonus, you can also catch a glimpse of Hackaday at 00:20 in [CNLohr]’s most visited / new tab thingy in Firefox. We’re honored, really.

Continue reading “[CNLohr]’s Microscope Slide Linux AVR Minecraft… Thing” →

Another Take On The 6502 Computer

February 8, 2013 by 17 Comments

another-take-on-the-6502-computer

[Mark] is just starting off on his own 6502 computer odyssey. He was inspired by some of the other projects we’ve seen around here, like [Quinn Dunki’s] Veronica Project, but with a spin that leverages modern processors to alleviate some of the messy work. As you can see above, there’s an Atmel chip perched above the 65C02 processor. This chip not only feeds the processor data (through all those slightly diagonal yellow wires) but also provides the clock signal and operates the reset and bus enable lines.

This is more of a hello world post for [Mark]. The chip is simply running NOP commands right now. But it shows that the basic idea works, and the video after the break lets us see another time-saving aspect of the circuit. He’s using a character LCD to display memory location and data values. The plan is to get a blog going, which he’s hesitant to do as it takes valuable hacking time away from the project. We disagree. The write-up (although incredibly fun for us to read) ends up being a reference manual for him once the project starts to get really hairy.

Continue reading “Another Take On The 6502 Computer” →

An Attempt To Replace Multiple RFID Cards With A Single Hacked-together Tag

January 21, 2013 by 31 Comments

It’s kind of a convoluted title, but [Hudson’s] attempt to replace multiple HID Prox cards with one AVR chip didn’t fully pan out. The project started when he wanted to reduce the number of RFID access cards he carries for work down to just one. The cards use the HID Proximity protocol which is just a bit different from the protocols used in most of the hobby RFID projects we see. He ended up taking an AVR assembly file that worked with a different protocol and edited it for his needs.

The device above is the complete replacement tag [Hudson] used. It’s just an AVR ATtiny85 and a coil made of enameled wire. The coil pics up current from the card reader’s magnetic field, and powers the chip through the leakage on the input pins (we’ve seen this trick a few times before). The idea he had was to store multiple codes on the device and send them all in a row. He was able to get the tag to work for just one code, but the particulars of the HID Prox reader make it difficult if not impossible to send multiple codes. The card must send the same code twice in a row, then be removed from the magnetic field before the reader will poll for another combination.

Macro Assembly For AVR Chips

December 12, 2012 by 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.

Driving A WS2811 RGB LED Pixel

December 7, 2012 by 46 Comments

[Alan] has been working on driving this WS2811 LED module with an AVR microcontroller. It may look like a standard six-pin RGB LED but it actually contains both an LED module and a microcontroller to drive it. This makes it a very intriguing part. It’s not entirely simple to send commands to the module as the timing must be very precise. But once the communication has happened, the LED will remain the same color and intensity until you tell it otherwise. You can buy them attached to flexible strips, which can be cut down to as few as one module per segment. The one thing we haven’t figure out from our short look at the hardware is how each pixel is addressed. We think the color value cascades down the data line as new values are introduced, but we could be wrong. Feel free to discuss that in the comments.

The project focuses on whether or not it’s even possible to drive one of these pixels with a 16MHz AVR chip. They use single-wire communications at 800 kHz and this really puts a lot of demand on the microcontroller. He does manage to pull it off, but it requires careful crafting in assembly to achieve his timing constraints. You can see a quick clip of the LEDs fading between colors after the break.

Continue reading “Driving A WS2811 RGB LED Pixel” →

USB Keyboard Becomes An AVR Programmer

November 26, 2012 by 21 Comments

[Steve] created an AVR programmer using an old USB keyboard. We feature a bunch of AVR programmers, but this one is made from parts that many people will have lying around. There are two components: the controller PCB from a USB keyboard, and an optocoupler for emulating key presses.

In order to send data to the AVR, [Steve] used the LED outputs on the keyboard. These LEDs can easily be toggled according to the HID device specification. They provide a 5 volt output with current limiting resistors, which means they can be connected directly to the target AVR.

Reading data is a bit more complex. The optocoupler tricks the keyboard into believing that a single key has been pressed, firing off a data transfer. The MISO pin on the AVR is connected to the row and column of the shift key, which is read by the driver.

On the software side [Steve] created an avrdude interface driver. This allows the programmer to be used with avrdude, just like any other programmer. [Steve] does point out that it isn’t the fastest programmer since the keyboard tries to debounce the MISO input, greatly limiting the speed. However, since it’s made from stuff you might have in your junk bin, it’s a neat hack.

The Ultimate Low-cost Dev Board

November 10, 2012 by 58 Comments

We see a lot of microcontroller dev boards here at Hackaday, so much that we’re jokingly considering changing our name to Board a Day. These devices – from Arduinos to Arduino-compatible boards, very, very small boards, to extremely powerful ARM devices – are a great way to learn about the wonders of controlling electricity with code. There’s a problem, though: if you’re teaching a class on programming microcontrollers, giving each student a $20 board is nearly out of the question.

This is where the shrimp comes in. It’s a very, very minimal Arduino-compatible circuit meant to control all the pins on an ATMega328. The components only cost about £1.40 ($2.25 USD) when bought in volume, making it perfect for teaching a class or workshop on the Arduino and giving each student a circuit to take home.

The basic circuit is just an ATMega328 – the same microcontroller used in the Arduino Uno – with a few caps, resistors, and a 16 MHz crystal. It’s a very bare-bones system, but once built and programmed provides all the functionality of a $25 Arduino.

Like all microcontroller platforms, there’s the chicken-and-egg problem of actually programming the device. The Shrimp team is using a CP2102 USB to UART bridge to program each shrimp. Not an inexpensive part, but it is of course possible to only have one serial bridge for each workshop.