I am hosting a weekly microcontroller study group at the ATX Hackerspace. If you are interested in learning about microcontrollers in a casual setting, come on by at 7:30pm tonight.

Tonight at 7:30pm we will hold our weekly evening of microcontroller exploration, otherwise known as Microcontroller Monday.

The idea is not to have a fixed agenda or format.  This is not a class, though I’m pretty sure everyone who comes will learn something.

Some examples of things we might do on MM:

- start learning about the MSP430 and play with the MSP430 launchpads at the space
- have Danny and Christian teach us about the dsPIC
- build some USB devices and play with LUFA (the open source AVR USB library)
- corrupt Arduino users with the notion that there is something beyond analogWrite()
- discuss related topics, like circuit design, PCB layout, etc.

If any of this sounds interesting, consider stopping by tonight.

I plan to be at the space from 7:30 to around 10PM, but that doesn’t mean people can’t start hacking earlier or stay later.  While this event is open to non-members, since a member needs to be present to keep the space open, non-members should adhere to the 7:30pm – 10pm schedule.

ATX Hackerspace maintains a calendar so you can stay up to date with this and other goings-on at the space.

Has anyone else noticed that the ATmega48/88/168 family of 8-bit AVR microcontrollers recently joined Atmel’s “mature devices” list, shown above?

Truthfully, I was not surprised to see this, having been tipped off by an Atmel sales rep earlier this year at ESC in San Jose.

The good news is that while these much-loved ATmega devices are slowly being obsoleted, they are being replaced by the largely-identical ‘PA’ series, which includes the ATmega48PA, ATmega88PA, ATmega168PA, and the ATmega328P.  The ‘PA’ devices are enhanced versions of the former ‘P’ series, which added energy-saving picoPower functionality to the original devices.

Porting code to the new family should be fairly straightforward given that the PA family is designed to be a drop-in replacement.  To help with the switchover, Atmel has released some migration notes, including AVR512, “Migration from ATmega48/88/168 to ATmega48P/88P/168P” and AVR528, “Migrating from ATmega48/88/168 and ATmega48P/88P/168P to ATmega48PA/88PA/168PA“.  Regardless, check your header files and fuse bits for any changes.

If you are anxious about switching devices, don’t panic, the ATmega48/88/168 devices are still in stock at all major distributors, while the PA devices aren’t even on the radar yet.  While professionals might want switch AVRs for new designs, hobbyists will likely still be using the older devices for years to come.  (Long live the PIC16F84!)

Pete Harrison at Micromouse Online wrote a short tutorial about using Eclipse to program AVRs.   Eclipse is  an open source IDE that is supported on many platforms, including OS X on the Mac.

I have never used Eclipse myself, so I can’t vouch for how well this works, but I would like to upgrade from the command line tools I am using (part of AVRMacPack, which is now called CrossPack).  I could use Apple’s Xcode but last time I checked, the AVR integration in Xcode wasn’t that great.

Is anyone using Eclipse for AVR development? What do you like/dislike about it?

AVR, Eclipse and the Mac | Micromouse Online

This all started last year, when I was playing with an ATmega168 microcontroller and did something silly.  I programmed the RSTDISBL fuse bit, which effectively makes it impossible to reflash the chip using an ordinary (serial) programmer.

Instead of giving up and throwing out the “dead” chip,  I decided to try to revive it using an obscure high voltage parallel programming mode that isn’t supported by most AVR programmers.  Armed with my Arduino and the ATmega168 datasheet, I quickly designed and constructed a programmer using parts I already had on my workbench.

A few hours later, I tested my new programmer and it worked!  I revived my “dead” AVR by using spare parts and a few lines of Arduino code.  That week I published the schematics and Arduino sketch to the site and called it my Arduino-based AVR High Voltage Programmer.

The response was overwhelming.  Since I first posted the design, many people have built their own and used it to fix their “dead” AVR microcontrollers by restoring the fuse bits to sane values.  I even received several requests for a PCB and/or kit based on the design, which got me thinking…

Today I’m proud to introduce:

The AVR HV Rescue Shield

The AVR HV Rescue Shield is a high voltage parallel mode fuse programmer for Atmel AVR microcontrollers.

It currently supports the ATmega48/88/168/328 series and the ATtiny2313.  The Rescue Shield does everything my original AVR High Voltage Programmer does, and a lot more.  I think the new features make this a really useful tool for anyone working with AVR microcontrollers.

New features include:

• Custom 2-layer PCB with silkscreen and soldermask.  No more hacking and modifying perfboards to fit Arduino’s nonstandard pin spacing!
• Onboard 12V DC-DC boost converter eliminates the need for an external 12V power supply
• Support for two of the most common families of AVR microcontrollers, the ATmega48/88/168 and ATtiny2313
• Support for programming the extended fuse (EFUSE) byte.
• A new interactive mode, where desired fuses can be entered using the Arduino’s serial port.
• Separate Ready and Burn indicators
• Protection resistors on every single data, control, and supply line to the target AVR, meaning that your Arduino and AVR should survive any mishaps during programming, including inserting the AVR backwards or off by 1 pin.

I spent considerable time testing each new feature and documenting the Arduino sketch.  I hope that you’ll find that the finished product was worth the wait!

Ordering instructions:

To purchase bare PCBs and kits, head over to the AVR HV Rescue Shield product page.

Programming & Customizing PICmicro Microcontrollers, by Myke Predko, is probably the best book out there for someone who is starting out with the PIC series of microcontrollers from Microchip.  I used Myke’s book as both a tutorial and reference when I created my PIC RGB Video Display.  Since then, I have referred back to this book countless times even when working with other microcontrollers, like Atmel’s AVR family, because it contains so much useful architecture-independent technical information.  I have referred to this book for information about topics including LCD interfacing, debouncing switches, RS-232 serial interfaces, and multiplexed LED drivers.  As a technical reference it easily surpasses the majority of AVR books that are out there.

The book is starting to show it’s age by not including some of the latest PIC micros in the examples (like the PIC16F628), but the code is easily ported to newer/faster/better microcontrollers, a good learning excercise in itself.

The Arduino team has released a new version of the awesome Arduino platform called Arduino Duemilanove.  Improvements include automatic selection of USB vs. external power, header pins for RESET and 3.3V supply, and an easy to cut automatic-RESET-disable trace.

The wiki page includes a very helpful audio sample to demonstrate proper pronunciation of the new name.

Update 01/02/09: A PCB version of this circuit is in the design stages – some preliminary information is here.

Update 03/11/09: Kits based on this design are now for sale!

Update 12/14/10: The original AVR HV Rescue Shield kit has been replaced by the new and improved HV Rescue Shield 2.  Visit the HV Rescue Shield 2 product page for information about the new kit!

As I mentioned earlier this week, I recently “lost” an ATmega168 due to flashing the configuration fuses to disable the RESET pin, without realizing that this makes the device impossible to reflash with SPI.  This is particularly frustrating because the device is still 100% functional, just completely deaf to ordinary serial programmers.  The only way to recover the device is using what Atmel calls “High Voltage Parallel Programming Mode” which very few programmers support, most importantly, not the USBtinyISP I otherwise love.

Fortunately, my trusty Arduino came to the rescue – I created an Arduino-based AVR programmer that uses the high voltage programming mode and can fix pesky fuses like RSTDISBL.

The Arduino has just enough IO to implement the entire HV protocol plus a “go” button.  So far I have only implemented setting LFUSE and HFUSE in software, but there is no reason why the code couldn’t be extended to support chip erase and programming the entire flash as well.

Overview:

The fuse programming process is simple:

• Upload the HVFuse sketch to the Arduino, available for download here: HVFuse.pde
• Install the shield and apply +12VDC to the terminals on the left
• Wait for the red LED to turn on (if it isn’t already)
• Install the ATmega to be repaired
• Push the button
• As soon as the LED turns back on, the AVR is fixed and ready to be put back into service!

Schematic:

Here is an Eagle schematic of the HV Programming shield (click to enlarge):

Update 12/17/08:  An observant reader pointed out that there were three errors in the way GND/AGND, AREF and VCC/AVCC were connected on the target AVR in the original schematic.  The errors have been fixed and the updated schematic is below.  Apologies for any confusion this caused.

Parts list:

• An Arduino NG, Diecimila, or compatible
• A piece of perfboard cut to size
• Header pins for the Arduino interface (note I had to drill some of the holes to get the headers to fit the nonstandard pin spacing for digital lines 8-13.
• An LED which indicates when it is ok to insert/remove the AVR
• A 2N3903 or similar NPN transistor (2N2222, etc.)
• (20) 1k resistors – these protect the Arduino from short circuits in case something goes wrong
• A pushbutton switch – this is the ‘go’ button
• A 28 pin socket for the target AVR

Kits!

A kit version of this project is available.  Visit the HV Rescue Shield 2 product page for more information.

Most fuse bits can be set or reset without worry, that is, they can be flashed into one state and then flashed back again using an SPI programmer like the USBTinyISP.

However, some fuse bits are irreversable or at least awkward to change, similar to the code protection bits on a PIC microcontroller.

One example is the RSTDISBL fuse.  This fuse allows bit 6 of PORTC to be used as a general purpose I/O pin instead of the RESET pin.  Well, it turns out that SPI programmers need the RESET pin to flash the device.  (RESET is set as part of the routine to enter serial programming mode.)  Once the RSTDISBL fuse is set, no more SPI flashing is possible.  The only way to recover is with a high voltage programmer like the STK500, which I don’t have.

Too bad I didn’t realize that beforehand.

At least I’m not the only person who has done this before: http://support.atmel.no/bin/customer?=&action=viewKbEntry&id=13

Update: It’s alive!!!  I made a high voltage parallel programmer out of an Arduino, flashed the fuses back again, and the AVR came back to life.  The parallel programming protocol is well documented in the datasheet for the part and pretty straightforward.  I think I’ll transfer the circuit onto a perfboard just in case I ever need to do this again!

Previous posts on this project:

• PIC Microcontroller RGB Video – Animations!
• Space Invaders!
• Generating Analog RGB Video with a PIC Microcontroller

Materials needed:

• An LCD screen like the Sharp 4L-U4EB that accepts a noninterlaced NTSC analog RGB video signal (red/green/blue and composite sync all as separate signals).  Poor quality datasheet here.
• (1) PIC16F628 (the PIC16F628A should be a drop-in replacement.  Sorry, I have old PICs lying around.)
• A PIC programmer – I am using a K128, but support for it has been discontinued.  Microchip’s PICkit2 is probably your best bet, but I haven’t used one (yet).
• MPLAB - the free Microchip IDE, or a compatible PIC assembler
• (1) 20MHz crystal (HC-18 or whatever fits your breadboard)
• (2) 22pF ceramic capacitors
• (3) 470 Ohm 1/8W resistors
• (5) 10K 1/8W resistors
• A 1K potentiometer for brightness control (if needed, my LCD needs one to display anything)
• A regulated 5V supply for the PIC, and my LCD needed an 8V supply of its own
• Anything else specific to your LCD – hopefully not much.

Firmware:

• Source code (for use with MPLAB) – lcd_video7.asm
• Hex file – lcd_video7.hex
• Listing file (MPLAB output) – lcd_video7.lst

Schematic:

(click to enlarge)

Theory of Operation:

The LCD I chose for this project needs four main electrical signals to display video.  Three of them carry color information – red, green, and blue.  These three signals can vary from 0V (black) to 0.7V (full brightness).  To achieve this, I placed 470 ohm resistors in series with each, as shown in the schematic.  The LCD terminates each color signal with a 75 ohm resistor, so the 470 ohm series resistors serve to convert the 5V output of the PIC to a 0.7V max signal for the LCD (using a resistive divider).

The other signal the LCD needs is CSYNC – an inverse TTL composite sync signal.  This signal provides both the horizontal and vertical sync for the LCD.  Without these sync signals the image rolls across the display because the LCD doesn’t know where the image starts or ends.  Composite sync seems to be a little bit unusual – most RGB video signals have separate horizontal and vertical sync signals on separate wires.

A horizontal line of NTSC video is roughly 64μs long. (μs = microseconds)  At the beginning of each line, CSYNC is held low for 4us, then set high again.  The RGB lines are held low during sync and stay low for 8μs after sync, then set to the desired levels display the desired image on that line.  2μs before the end of the line, RGB are set low again to signal the end of the visible image.  At 64μs, the program loops back to start another line.

You can generate video like this but there would be no vertical hold – the image would be stable in the horizontal direction because we are generating a horizontal sync but not in the vertical direction.

To create a stable image with vertical sync, you have to create a valid “field” of video.  We’re creating non-interlaced video, so every field is the same (in contrast with ordinary interlaced video used in television.)  A field is composed of 262 horizontal lines.  The first line is blank, with CSYNC set low for the entire line.  This is the vertical sync.  The next 17 lines are called the “blanking interval” and occur above the visible image, during these lines horizontal sync is applied but no RGB signals.  The next line is the first visible line and consists of both a horizontal sync and RGB signals as discussed earlier.  243 lines later, we write one blank line, then loop back and repeat the process all over again.  Now we have a valid non-interlaced analog RGB video signal.

The blank lines are mostly due to compatibility with old television sets that needed time to reset the electron gun for the next field.  The nice thing is that they give us time to do housekeeping before displaying the next field.  For example, during the blanking interval I load the image to display into memory so it can be easily read back later.

The critical thing with regards to timing is that the PIC needs to execute the same number of instructions each time it loops, such that the sync signals always occur at the right time.  This is why there are a lot of ‘nop’ instructions in my code – to pad the program execution in the right spots and maintain sync.  I started by counting instructions to figure out where to put the ‘nop’s, but by the end of writing the program I was using MPLAB’s builtin “Stopwatch” feature instead.

That’s it for now!  If you have any questions, make use of these routines in your own projects, or just find this interesting, please leave a comment!

My favorites:

• NYC Resistor – Definitely the most interesting hackerspace in the US right now.  Updates almost daily.  I stand in awe of how prolific these guys/girls are, it seems like they are pushing the envelope of DIY every week.  This blog alone makes me want to move to NYC sometimes.  (Well, them and ITP.)
• Evil Mad Scientist Laboratories – Evil mad scientist duo Windell and Lenore showed the world what an electronics blog could be – 100% high quality photography, open source everything, and unique and captivating projects time and time again.  Along with Lada Ada they made the Atmel AVR the standard for beginning microcontrollers.  They sell stuff too.
• The Make: Blog – You could pretty much read this one alone and still stay on top of what’s hot in DIY right now.  They usually follow EMSL and NYC Resistor anyway.

And some new (to me) blogs:

• DadHacker – This guy wrote Donkey Kong for the Atari.  This blog has been around for years, lots 8-bit assembly coding stuff which is fascinating.
• Bre Pettis’ Blog – Bre is on a mission and is stirring up a lot of interest in DIY.  He has a TV show starting up in a couple weeks.  His departure from Make is still being mourned (by me at least).  Weekend Projects will never be the same (sorry, Kip).

That’s it for now.  If I missed any good ones, I’d love to hear about them, leave a comment or contact me.  You can access all of the blogs I mentioned (and a couple more) from the blogroll to the right.