Experimenting With 8-bit Graphics

April 11, 2012 by Mike Szczys 6 Comments

[Vinod] has done a lot of work with microcontrollers, but this is his first try at displaying graphics using composite video. He had a small PAL television on hand, and an ATmega32 which just needs a stable clock source and a few resistors to get things going.

There are a lot of other hacks around that use composite video out with microcontrollers. But this is a ground-up approach which will help you understand the concepts behind these graphics. [Vinod] started by calculating the possible resolution. He needs to hold a frame buffer in memory, and since his chip has just 2 kilobytes of SRAM this will be the limiting factor. He settled on a display area of 128 by 64 pixels. This divides evenly by 8 so he’s not wasting any bits, and it totals 1k, leaving half of the SRAM for use in calculating the shapes which populate the buffer. An interrupt service routine runs ever 64 microseconds to feed data for each line of the display.

With the scanning in place, he moved on to fill the frame buffer. Two functions are used, one which sets a pixel the other clears a pixel. He compares these to using a pencil and an eraser. By calling these functions from his main program he is able to draw lines, boxes, and circles. A bit of creative looping and he’ll have animations as well, but that’s a concept for a different post.

HTML Based AVR Compiler Aims To Make Arduino Development On IOS Possible

April 10, 2012 by Mike Szczys 19 Comments

It’s surprising what lengths people will go to in order to bring functionality to their smart phones. In this case, [Tadpol] wanted a way to develop for his Arduino on an iOS device like an iPad or iPhone. He figures it’s possible to rewrite the IDE as HTML5, but since that’s a pretty large mountain to climb, he started by building a browser-based AVR compiler. It’s an interesting concept, and he’s got a working prototype up on Github for you to test. Perhaps you can throw your hat in the ring and help him with development?

The web interface uses boxes to add to the code. What you see above is three sets of commands which will blink an LED. The project, named Avrian Jump, uses a simple ladder language to feed the compiler, with several different options for output. The most interesting in our mind is a WAV file which can be used to program an AVR from the audio out of your device. That would make programming as simple as connecting the specially modified AVR to your headphone jack. There’s also an ASCII output which allows you to save your programs for later alteration, S19 output for AVRdude programming, and an assembler output for debugging purposes. It’s hard to see where this project might go, but we have to admit that the concept is intriguing.

JTAG Dongle Pushes Code To FPGA After Bootup

February 10, 2012 by Mike Szczys 12 Comments

This gnarly beast has near-magical qualities. [Sprite_TM] patched it together as a dongle which attaches to a JTAG header (we’re fairly certain this is not a standard footprint for that interface though). He uses it to push code to an FPGA after that device boots. Why? Well, there’s several reason, but the most generic answer is that some boards will not boot unless there is a chain of trust that validates the code which will be running.

In this case, [Sprite_TM] is using a knock-off board he acquired from a Chinese supplier. It’s a hardware network terminal (thin client), and as you can see in the video after the break, it works just fine. But that’s pretty boring and he wanted to use it for his own purposes. When he plugs in the dongle and powers up the board the network terminal is nowhere to be found, replaced with the code to play Pac-Man as if were a full arcade cabinet.

The dongle is simply a female DIL header, an ATtiny85, and a flash memory chip. The AVR has a software UART that speaks XSVF, the protocol used to push data to the FPGA. The data to be written is stored in the memory chip, and with that header in place reprogramming the AVR is just a matter of connecting an ISP programmer. Brilliant!

Continue reading “JTAG Dongle Pushes Code To FPGA After Bootup” →

Learning To Use The V-USB (AVR USB Firmware) Library

February 9, 2012 by Mike Szczys 17 Comments

The V-USB library is a pretty handy piece of code that lets you add USB connectivity to ATtiny microcontrollers (it was previously named tinyUSB). But if you’ve ever looked into adding the library to your own projects you may have been stymied by the complexity of the code. There are many examples, but there’s a lack of a concise quick-start for the uninitiated. [Joonas Pihlajamaa] has been working to correct that shortfall with his four-part V-USB tutorial series. It’s not for the absolute newbie; you should already be comfortable working with AVR chips but that’s the only real prerequisite we can see.

He starts the series with a look into the hardware considerations. USB provides a 5V power rail but the data lines expect 3.3V logic so this must be accounted for. With the test rig built on a breadboard he moves on to pick apart the code, covering various user-defined variables that you’ll need to set based on your project’s needs. We’re going to keep this on the back burner and hopefully the Troll Sniffing Rat will get a makeover (although we must say comments have been a lot nicer as of late… keep it up!).

We’ve embedded links to all four tutorial parts after the break.

Continue reading “Learning To Use The V-USB (AVR USB Firmware) Library” →

Build Your Own 4-channel Logic Analyzer

February 7, 2012 by Mike Szczys 26 Comments

If you’re just getting into hobby electronics chances are there are lots of tools you’d like to get you hands on but can’t yet justify the purchases. Why not build some of the simpler ones? Here’s a great example of a 4-channel logic analyzer that can be your next project and will add to your arsenal for future endeavors.

As you can see, [Vassilis’] creation uses a cellphone-sized LCD screen as the output. It is powered by four rechargeable batteries and driven by an ATmega8 microcontroller. He’s designed the tool without power regulation, relying on the ATmega’s rather wide range of operating voltages, and a few diodes to step down that voltage for the LCD screen.

As you can see in the clip after the break, alligator leads can be used to connect the test circuit to the inputs (don’t forget the ground reference!). Thee buttons at the bottom let you navigate the captured data by panning and zooming. Perhaps the best design feature is the single-sided circuit board which should be quite easy to reproduce at home.

Continue reading “Build Your Own 4-channel Logic Analyzer” →

Numerous Quiz Buttons Built On The Cheap

January 20, 2012 by Mike Szczys 3 Comments

[Sprite_TM] was tapped to build a rather large quiz buzzer system. Judging from his past work we’re not surprised that he seemed to have no trouble fulfilling the request. As the system is not likely to be used again (or rarely if it is) he found a way to finish the project that was both quick and inexpensive.

Each buzzer consists of a base, a button (both mechanical and electrical), and a couple of LEDs to indicate who buzzed in first. The mechanical part of the button uses a plastic bowl from Ikea and a wooden dowel surrounded by some pipe insulation. A momentary push switch is glued on the top of that dowel, and the insulation projects above that just a bit. This way it acts as a spring. The Dowel has been sized so that the bowl lip will hit the wooden base just as it clicks the switch.

As you can see, all of the buzzers are interlinked using Ethernet cable. The real trick here is how to read 14 buttons using just one CAT5 cable. This is done with the clever use of a 4×4 button matrix for a total of 16 buttons. The matrix also includes the LEDs for each buzzer. Since CAT5 has four twisted pairs this works out perfectly.

Looking for a more robust system thank this? Here’s a pretty nice one.

AVR External Memory Interface (XMEM) Reads Input Matrix

December 6, 2011 by Mike Szczys 3 Comments

Reading from a large number of inputs, like this piano keyboard, can be tedious. Even when multiplexing there’s a lot to keep track of. But if you choose the right microcontroller, you may have hardware assistance. Here’s an ATmega640 is using it’s external memory interface to read the key matrix.

You may remember the Open Music Labs article about reading from a shift register using just one pin of a microcontroller. This time around a shift register is still used, but instead of pulling in a long line of parallel inputs, the switches are multiplexed to reduce the number of I/O pins used to read them.

A 74HC573 is used to facilitate the multiplexing. We won’t go into how that part is accomplished; there’s a separate post that explains the process. What’s unique here is that the XMEM peripheral of the AVR microcontroller is used to grab the data. This is intended for external memory chips, but if you get the timing just right, it greatly simplifies reading in a matrix of up to 128 inputs.