[Quinn Dunki] got some free stuff from Element14 to evaluate, including this Mircrochip WiFi module. It’s been used as the centerpiece of an Arduino shield in the past, and she grabbed a copy of that library to see if it would play nicely with an ATtiny chip. What follows is a struggle to de-Arduino the code so that it’s portable for all AVR controllers.

This module is one of the least expensive ways to add WiFi to a project, coming in at around $23. But it’s not really an all-in-one solution as there’s still a huge software hurdle to cross. The hardware provides access to to radio functions needed to communicate with the network, but you need to supply the TCP/IP stack and everything that supports it. Hence the re-use of the Arduino library.

Battling adversity [Quinn] fought the good fight with this one. Switching from an ATtiny to the ATmega168, compiling more code, and troubleshooting the process. She used a single LED as feedback, and can get some connectivity with her hotspot. But to this point she hasn’t gotten everything up and running.

We’re hot for an AVR WiFi solution that is cheap and easy to use. But as we see here, the software is complex and perhaps best left up to beefier hardware like the ARM controllers. What do you think?

Prolific Hack a Day author [Mike S] has been playing in his lab again and he’s come up with a neat way to talk to microcontrollers with an LCD monitor. The basic idea behind [Mike]‘s work isn’t much different from the weird and/or cool Timex Datalink watch from the 1990s.

Despite the fancy dev board, the hardware is very simple – a photoresistor is pointed at a computer monitor and reads bits using Manchester encoding. The computer flashes a series of black and white screens thanks to a simple Javascript/HTML page, and data is (mostly) transmitted to the micro. [Mike] says he has about a failed message about 60% of the time, and he’s not quite sure where the problem is. He’s looking into another kind of Manchester encoding that uses samples instead of edges, so we hope everything works out for him.

This build is very similar – and was inspired by – an earlier post about microcontroller communication with flashing lights. Still, [Mike]‘s build reminds us of the strangely futuristic Ironman watch we had in ’97. Check out [Mike]‘s demo of his computer/micro comm link after the break and his code on github.

If you want people to really be impressed by your projects it’s often better not to have a fully finished look. In this case, we think hooking the stripboard version of FIGnition up to your TV will raise a lot more eyebrows than the PCB version will.

[Julian] put together a guide to building the computer on strip board. He’s using his own Java application for laying out circuits on this versatile prototyping substrate. This tool is worth a look as it may simplify those point-to-point solder prototypes you’ve been agonizing over. You’ll have to do some poking around on his site to gather all of the knowledge necessary to complete the build. Most of the components are easy to source, but unless you have them on hand, you’ll need put in a parts order for the crystal, the ATmega168, the SRAM chip, and the flash memory chip.

For those not familiar, FIGnition is an 8-bit computer with composite TV-out for a display and rudimentary input from the eight momentary push buttons.

Those following the ProtoStack tutorials will be happy to hear that there is a new installment which explains Pulse Width Modulation. If you’ve never heard of PWM before, it’s a method of generating a signal that is logic 1 for a portion of the time and logic 0 for the remainder of the time. It is the most commonly used method for dimming an LED, and that’s [Daniel's] example in this tutorial. But you’ll also find it used in many other applications such as servo motor control and piezo speaker control.

[Daniel] starts off with a brief explanation of duty cycle, then moves on to some examples of hardware and software PWM. Many of the AVR microcontrollers have a hardware PWM feature that allows you to configure a pin that toggles based on a target timer value. This is demonstrated using an ATmega168, but a method of using interrupts and your own code is also covered in case you don’t have a hardware PWM pin available.

It’s graduation time for many high schoolers, and while many students would love to decorate their caps, administration generally looks down upon this practice. [Victor], however, thought of a way around this.

The human eye cannot see infrared light, but camcorders generally can. Putting these two concepts together with a couple of infrared LEDs, [Victor] was able to make a cap that displayed his decoration in everyone’s “digital memory”, but wouldn’t be detected until the video of the offense was displayed. Hopefully by the time the prank is detected, [Victor] will have successfully graduated and presumably gone on to other pursuits.

An ATmega 168 controls this hat to display his message, “Congratulations Class of 2011,” in Morse code. What a creative use of both old and new technology to pull off an awesome graduation prank. Be sure to check out the video after the break to see how everything was put together.

[HuB's] set of 5.1 surround sound speakers was gobbling up a bunch of electricity when in standby as evidenced by the 50 Hz hum coming from the sub-woofer and the burning hot heat sink on the power supply. He wanted to add a way to automatically control the systems and offer the new feature of disconnecting the power from the mains.

The first part was not too hard, although he used a roundabout method of prototyping. He planned to use the IR receiver on the speakers to control them. At the time, [HuB] didn’t have an oscilloscope on hand that he could use to capture the IR protocol so he ended up using Audacity (the open source audio editing suite) to capture signals connected to the input of a sound card. He used this to establish the timing and encoding that he needed for all eight buttons on the original remote control.

Next, he grabbed a board that he built using an ATmega168 and an ENC28J60 Ethernet chip. This allows you to send commands via the Internet which are then translated into the appropriate IR signals to control the speakers and a few other devices in the room. The last piece of the puzzle was to wrap an RF controlled outlet into the project with lets him cut mains power to the speakers when not in use. You can see the video demonstration embedded after the break.

[Jarek Lupinski] is at it again, this time building a clock using 15 Nixie tubes. Just look at the time…. wait, how do you read this now? It’s not seconds since the epoch, but an homage to a very expensive New York City art piece. [Jarek] took his inspiration from the Metronome art installation in Union Square.

We hadn’t heard of it before and were shocked to learn that this art was commissioned at $4.2 million. It belches steam and confuses passersby with its cryptic fifteen digits. It seems that the eight digits on the left mark the current time – two digits for hours, two for minutes, two for seconds, and the final digit for hundreths of a second. The seven remaining digits count down the time left in the day. So when you watch it, you see the significant digits of the display increasing, and the insignificant half decreasing.

The Nixie version rests snuggly on a 15″x4″ PCB. We’re sure it doesn’t number in the millions, but that couldn’t have been cheap to have manufactured. Each tube has its own driver chip, removing the need for multiplexing. An ATmega168 controls the clock (along with some shift registers to expand the I/O count), reading time from a DS1307 RTC chip. It looks fancy, but where’s the belching smoke on this version?

[Powder4u] wanted to make a persistence of vision display for his bicycle but with 50 cm of snow on the ground it’s hard to get out and ride right now. Instead he made this persistence of vision ski-pole accessory. We asked him to share some details and he obliged. It’s made using an Arduino compatible ATmega168, LEDs with resistors, and installed on some protoboard. The enclosure is a clear pencil case, which isn’t water tight but he’s tried to bolster that with some creative scotch tape placement. There’s no sensor to detect which direction the board is moving in so displaying alpha-numeric messages will have some issues, but as you can see he managed to display image data without issue.

We’re used to night skiing with floodlights along the slopes. This would be a fun little thing to have along with you on those dark lift rides.

Like some strange manga come to life, you can remove this brassiere with a clap of your hands. Under the red bow is a not-so-small mechanical clasp that replaces the original on the strapless front-clasping undergarment. We hate to criticize, but [Randofo] really went off the deep end of hardware overkill on this project. The clasp itself is the electromagnetic coil removed from the case of a mechanical relay. An ATmega168 listens for a spike in sound pressure from a microphone, then drives the relay to release the feminine support system.

It is Valentine’s day. The question being is this romantic or sleazy? Watch the NSFW video after the break and let us know your opinion in the comments.

[Thanks DMF]

[Eric Friedrich] needed to keep the wort warm enough for yeast to ferment it into beer. To solve the problem he built his own fermentation temperature controler using a microprocessor to turn some heating tape on and off. You can see the heating element embracing that diminutive fermentation bucket in the picture above. This was originally meant for keeping reptile cages warm. It costs less than similar products meant just for brewing and works well for [Eric]. A DS1820 temperature sensor gives feedback to an ATmega168 which then uses a relay to switch the heat on and off. The target temperature can be changed using a potentiometer on the board, with the setting displayed on a character LCD screen on the project enclosure.

If you’ve been lusting after your own glowing display we’re here to help by sharing some simple building techniques that will result in an interesting project like the one you see above. This is a super-accurate clock That uses ping-pong balls as diffusers for LEDs, but with a little know-how you can turn this into a full marquee display. Join me after break where I’ll share the details of the project and give you everything you need to know to build your own.

Planning

Take some time to sit down and figure out how many pixels you need in your display. Above you can see the sketch that I drew on the back of some junk mail. Since I need a clock for my shop I’m only going to include LEDs for a twelve-hour time display. But I did plan to populate the entire grid with diffusers (ping-pong-balls) because it will look a bit cooler that way. I also planned to include a ring round the entire display so my final pixel area will be 15×7. Note the numbers below each digit, which are an LED count.

I also did quite a bit of planning at this point for the electronics. I need to make sure that I’m handling the current properly so that I don’t burn out any of the LEDs or chips that drive them. For now, let’s skip over the electrical issues and build the actual display.

Materials

First you need a box to host the project. I chose to use pegboard for the clock face because it already has accurately spaced holes that fit a 5mm LED quite snugly. The pegboard will be wrapped in a plywood frame which gives it strength, protection, and a place to mount the buttons and other hardware. You’ll also need all of the LEDs for the display (46 in my case) and ping-pong balls for the grid (105 in total).

From the start I wanted to complete this project with parts on hand. I already had the scrap of pegboard, and the plywood left over from building a wall-mounted desk for my office. Most of the electronic hardware was salvaged from another project (more on that later) and in the end I only had to buy ping-pong balls, hot glue, and some mounting hardware for the buttons. Here’s a list for the display itself, excluding the controller board and buttons:

• Pegboard for the face
• Plywood for the frame
• LEDs
• Ribbon cable
• 22 gauge hookup wire
• IDC connectors
• KK connectors or another 0.1″ pitch connector
• Woodworking tools: table saw, circular saw, straight edge
• Pocket screw jig and pocket screws
• Hot glue gun and hot glue
• Soldering supplies

Assembling the case

I first started by taping out the digits on a piece of pegboard, then clamped a straight edge along the cut lines and used a circular saw to trim it to size.

Pegboard is usually a bit flimsy so you should build a frame around it to make it rigid. I’ve just got some rudimentary woodworking tools so I’ve ripped 3″ plywood pieces, cut them to length with butt joints, and then cut a dado the width of the saw blade to receive the pegboard.

I bought this Kreg pocket screw jig when I was building my desk and I love it. Here I’ve cut pocket screw holes into the ends of the long rails. They butt up to the side rails and two screws will hold them nice and tight. You can get this jig for around $20, but if you don’t want to spend the money just pre-drill and countersink some holes from the outside and use wood screws to hold your frame together.

Here’s the outside of the finished box. All-in-all I’ve put about 90 minutes into the project. The majority of the time was spent measuring carefully, which you should take seriously. One wrong cut could cause an impromptu field trip for more supplies.

There’s plenty of room inside for the wiring and controller board. Now to start inserting the LEDs.

I had a great time building the LED Jack-o-lantern but that hardware has gone unused since Halloween night. Here I’ve desoldered all of the components from the protoboard and clipped apart all of the LEDs, separating them by color. I’ll reuse all of the green LEDs, the transistors, pin headers, some resistors, and many of the longer wires in this project.

Start by pressing the LEDs into place on the back of the pegboard. They’ll be quite tight and I found this process made my fingers hurt after a while. I checked each LED using a battery and resistor to make sure I had the polarity right and that they all worked and were the same color. Above I’ve started soldering all of the cathodes for each LED using ribbon wire. The cathodes are grouped by digit, and will be connected to ground by way of an NPN transistor.

Here all of the cathode connections have been made. I’ve used hook-up wire to run each of the four buses to one side, and inserted them together into a 4-channel KK connector. This will make it easy to plug the low end of the digits into a pin header on the control board. Don’t forget to hot-glue these wires to the pegboard as a form of strain relief.

Now it’s time to solder the anodes for the same pixel in each digit together. I used the waste pieces of ribbon cable from the last step in the process to do this. In the upper right you can see two ribbon cables which have IDC connectors hanging over the side. The top bundle drives seven of the 13 LEDs in each digit. The bottom bundle drives the remaining six. These will plug into double pin headers on the driver board, connecting the pixels through a resistor to a pair of shift register. The colon in between hours and minutes has been grouped with the hour-tens digit which only has pixels for the numeral 1.

Now it’s time to make sure everything works. We do need to add ping-pong balls as diffusers before the display will be finished but if there’s a problem you don’t want to have to remove the balls to fix it. Let’s build and test the control circuitry now.

Electrical Design

I wanted to use parts on hand for this project. I’ve got plenty of 595 shift registers but there’s one problem with those; the supply pin has a 70 mA absolute maximum rating. I can get around that limitation if I run my LEDs no higher than 10 mA each and split the 13 total pixels between two shift registers.

That takes care of the high side. To switch the low side of each digit I’ve sourced 2N3904 NPN transistors. They have a collector current limit of 200 mA which will have no issue sinking the 130 mA max coming off of a digit when the numeral 8 is displayed.

The multiplexing is handled by an ATmega168 running on the internal RC oscillator at 8 MHz. This makes it a breeze to drive the display without any visible artifacts, but it’s lousy at precision time keeping. I had a Maxim DS3232 real time clock on hand that will keep very accurate track of time. It has a backup battery which will keep time when power to the display is lost. This is perfect since I intend to power this from the bench outlets in my shop. I turn them off when I’m not working and that means the clock will only be illuminated when someone’s there to see it.

This how-to is intended to focus on the physical build and not the electronic design. If you make your own it would be much better to choose shift registers that offer constant current on each pin. This way the LEDs can be brighter and there’s no need to worry about pushing up against the current ratings of the shift registers. Most constant current drivers are low side, which means you would then use P-channel MOSFETS, PNP transistors, or similar to switch the high side of each digit. Basically the opposite of what I’ve done here.

Check out the LED pumpkin matrix for more on designing your own multiplexed displays. As for constant current drivers, there’s some nice hardware used in this whiteboard/LED marquee project. Just don’t feel locked into Maxim parts as they can often be difficult to source.

Building the controller

Having designed the circuit it’s just a matter of wiring it up and writing some firmware.

Here’s the breadboarded circuit. You can see the two IDC connectors jumpered with resistors to the shift registers on the breadboard. The yellow wires to the right connect the digit cathodes to their respective transistors. In the foreground is the DS3232 on a breakout board. You can see the coin cell in its hacked holder. I’m using a multimeter to measure the frequency of the 1 Hz square wave this chip provides, and a Bus Pirate to see what’s going on with the i2c communications. Now that it’s working, I just needed to find a more permanent solution.

Voila! The top of the finished controller board. Note the two pin sockets to received the DS3232 breakout board.

And the point-to-point soldering on the bottom. This took perhaps four hours to complete. It’s winter right now and I don’t like using Cupric Chloride inside to etch circuit boards so I went this route.

The last piece of the puzzle is adding buttons. I knew I had this old circuit board from a Sony shelf stereo system.

I needed four buttons so I used a Dremel to separate this segment from the larger board. I added two holes to use for mounting and soldered wires (reused from the pumpkin) terminating in another KK connector.

Here’s a view of the underside of the button board. I had to remove the resistors that connected the buttons into a matrix and I used hot glue for strain relief.

After a trip to Ace Hardware I was able to install the button board. I started by tracing the location of the buttons on a piece of paper, then using that as a template to drill holes through the top of the plywood case. You can just make out the ragged hole above each button.

While and the hardware store I picked up a dowel as well. Here I’ve cut it to length, eased the top edge with some sand paper (I spun the dowel in a power drill for that), and added a hole for a retaining pin.

Once installed I glued a finish nail into the hole of each button dowel so they won’t fall out.

Here’s the finished product. I love it!

Everything’s working, time to add the diffusers. I originally planned to buy ping-pong balls from the dollar store but they only had six 9-packs. I ended up ordering a gross online. I drilled a hole in each ball for the LED to stick through, then used hot glue to attach them. Make sure the drill bits you use for this are nice and sharp.

Here’s a test with the lights on.

And another with the lights off.

Conclusion

I’m quite happy with the way things turned out. If you build one yourself take into consideration the use of constant current LED drivers as I mentioned before. Also, I had crystal clear LED packages, you may want to experiment with diffuse packages. You can see that there is a bright point on the top of each ping-pong ball because of this. On the other hand, in bright light you can still make out the time because of those bright spots, so test this out before you purchase all of your parts.

When all is said and done the display portion of this was easy and quick to build. It took much longer to solder the control board and to finish writing the firmware. A link the git repository is included in the resources section below.

Resources

Source code repository

Follow Me

@szczys

When it comes to using servos in projects, there is a definite distinction between the cheap ones and the expensive high power and precision models. The OpenServo project gives you a couple options for enhancing your servo experience. By replacing the control board with a new one based on a familiar microcontroller, a whole new set of features can be attained. For those of you out there with a need for servos like these, you can buy the pre-built replacement board (unfortunately sold out right now), or build your own from the provided schematic, BOM, and source code.

Above you see a solenoid being used as a digital scale. The magnetic field from the coil in the base levitates the platform above, where a load to be measured is place. This floating platform has a permanent magnet in it, hovering above a hall effect sensor in the base. As the distance between that magnet and the sensor changes, the measurable magnetic field changes as well. The hall effect sensor is linear so the measured value can easily be correlated with a weight. In the video after the break [Vsergeev] demonstrates the device using test weights to show off its 0.5 gram resolution. He thinks that with a few hardware improvements he could easily achieve 0.1g accuracy.

[Alex] ramped up the precision of his timepiece by adding a ChronoDot to the Ice Tube Clock. These two items are among our favorites; the Ice Tube Clock for its old-style multi-digit display, and the ChronoDot for combining a DS3231, battery, and components into a nice small package.

There is a schematic link at the very bottom left of [Alex's] writeup. He mentions that he depopulated the clock crystal and its capacitor pair from the board and patched into the clock input on the AVR. A 100K pull-up resistor is included in the wiring as called for in the DS3231 datasheet. Although not specifically referenced, we assume that [Alex] reprogrammed the ATmega168 clock select fuses to use an external clock signal.

Now he can sit back knowing that the clock will be within 10 seconds per year accuracy.

• Expand the sample code, adding features to our simple program while I challenge you to write the code yourself.
• Discuss AVR fuse bits, how to use them, and what to watch out for
• Touch on some of the peripherals you’ll come across in these chips

As a grand flourish to the series, I’ve used the example hardware from this final part to build a bicycle tail light. Hopefully this will inspire you to create something much more clever.

Series roadmap:

• AVR Programming 01: Introduction
• AVR Programming 02: The Hardware
• AVR Programming 03: Reading and compiling code
• AVR Programming 04: Writing code

Adding to the Example Hardware

The example code that I’ve been working with on the last two parts of this tutorial is a bit boring. It makes one LED blink on and off at a rate of about 1 Hz. That LED was connected to the pin for PD0, so let’s start out by adding an LED and resistor to the rest of the PORT D pins for a total of 8 LEDs. We should also talk about inputs, so let’s add a switch on PC0. Here’s a schematic showing our changes:

I moved the original LED over to some open space on the right side of the breadboard. I’m connecting the cathode to the ground rail on the bottom, jumping the trench with a resistor, and connecting a jumper from that resistor to the Port D pins on the microcontroller. I organized the LEDs in ascending order from right to left making it easy to address them when writing code:

If you know your resistor color codes you’ll notice that the Brown-Green-Red resistors I’m using are 1.5 kOhms, strangling the current to a tiny trickle for LEDs. Well, I’m using super bright LEDs, and these resistors were the first that I pulled out. They work just fine for prototyping but should be replaced with a correctly calculated value on a finished product.

Next I hooked up a button. Digital inputs on microcontrollers need to have a value of 0V or VCC (input voltage which is 5V in our case). If they don’t have a clear value they are said to be “floating” which can lead to false button readings and other unhappy occurences. We need to set up hardware that will force a value of 0V or 5V at all times. This turns out to be quite simple. By connect the switch from the pin to ground and a resistor from the pin to VCC (called a pull-up resistor) there will always be a very small 5V current trickling into the pin, except when an unrestricted path to ground is created by pressing the button. We don’t even need our own resistor as there’s one inside the microcontroller that we’ll take advantage of. Here’s a schematic showing what this connection, along with the internal pull-up resistor, looks like:

That description is a mouthful but all we’re really doing is placing a button between PC0 and Ground. Pin 23 is PC0 on the ATmega168 and the pin right next to that (pin 22) is GND. I’ve connected a switch accordingly. In the following image please note that Pin 22 is connected with a jumper wire to the ground rail above it, but is obscured by the black wire from the push button:

And finally, I want to make connections to the chip for In-System Programming. I like to do this using a patch board that I created. This lets me use a 10-pin IDC cable for easy connection to my programmer:

That’s it. I plan to use this hardware with several different firmware examples so double-check your wiring and then start writing code.

Writing Code

Time to practice writing your own code. I have come up with four firmware examples ranging in difficulty from “Hello World” to “Damn That’s Slick”. I’ll discuss each of them briefly but along the way you should try to write your own code, using my examples as… examples. The best way to learn to code is to write a small portion of code, let the compiler yell at you for messing up, and then figure out how to fix it.

Blinking all 8 (8led_1hz)

First thing’s first, can you make the example code from Part 2 blink all 8 LEDs instead of just one?

There’s really only two things that you need to change from the original to make this happen. First, when setting up the input/output, make all of the pins on Port D outputs, then turn them all on. Second, when toggling the bits in the Interrupt Service Routine use a bitmask that affects all eight bits.

The source package for this part of the series includes this alteration. Grab a copy of it and look at the 8led_1hz code. In it you’ll find these changes:

  DDRD |= 0xFF;			//Set PortD pins as an outputs
  PORTD |= 0xFF;		//Set PortD pins high to turn on LEDs

  PORTD ^= 0xFF;		//Use xor to toggle the LEDs

As you can see, both portions of code use 0xFF as a bit mask. This is a byte containing all ones, which will manipulate every pin on the registers to which we apply it. Before I had shifted a bit using this:

'1<<0'

It resulted in a bit mask of 0×01, protected the upper seven bits from being changed during register manipulation.

Make the LEDs do something interesting (m168_led_effects)

Now I’m going to take a big step forward in C code difficulty. But I challenge you to develop three different types of LED effects by yourself:

• A binary counter which counts up at 1 bit per second
• A flasher that alternates lighting every other LED
• Larson scanner (a simple one, doesn’t need to use PWM)

You’ll find my example code in the m168_led_effects directory. Here’s some of the new things I’m using in my code:

Definitions: I’m using definitions for common settings and for I/O pins, ports, and direction registers. These are constants that the compiler will replace with appropriate values but they make your job much easier. If you get most of the way into a project and realize you need to change some of the hardware this will make it simple to do. Need to change from Port D to Port C? No problem, change the #define and the rest of the code will still work

Delay: AVR libc has a nice delay utility called delay.h. You can see that I’ve included it at the top of the source file and also written a function called delay_ms(). This is a moderately accurate way to mark the passage of time. The drawback to using this is that you are literally wasting time when the processor could be doing other things. Still, it’s simple and if you’re new to microcontrollers you’ll probably find yourself using this frequently at first.

Also notable in this version of the code is my use of functions to take the complexity out of MAIN. I like to do this when I can to make program flow more readable. If you use descriptive function names it will be easy for others to see how the firmware works just by looking at main. This is also why I comment my code quite a lot. Not just for others, but so I can read it quickly if I come back to it later and don’t remember what I originally wrote the program to do.

Before we move on here’s a quick synopsis of how I solved the three goals:

• When displaying a binary counter at 1Hz I simply start Timer 2 the same way I did for the blinking LED in Part 2 of the tutorial. Each time it fires I don’t toggle the pins, but set the entire port to an 8-bit variable value while incrementing it at the same time. The ++binary_counter increments that value just before it sets Port D. It is crucial that this value be a global variable using the keyword ‘volatile’ because it is changed by both the ISR and in the main loop. If you don’t make it volatile the compiler might optimize the code in a way that disturbs or disrupts the intended functionality.
• Creating an alternating flasher is much the same as toggling a single LED. I set up for the effect by instantiating a variable with every-other bit as 1. When using an exclusive OR operator (XOR) on this value, all of the bits will flip. I could have set up an interrupt with a shorter delay than the 1 Hz interrupt to take care of this but for learning purposes I used a delay instead.
• The Larson scanner is a classic bit of blinky goodness. The core function is to illuminate one LED and sweep it back and forth. To do this I just created a loop to shift the bits, waiting after each change. Once the LED on the end is lit the program leaves the loop and enters another one to shift bits the other way. The same could have been accomplished with a variable that keeps track of which direction the LED is moving, testing during each iteration.

When you’ve read and understood how this code works it is time to get the button up and running.

Make the button do something (m168_led_button)

We brought a button to the party, let’s alter our LED effects so that the button is used to change between the three possibilities. If you’ve never written code for a button input before there’s little chance you’ll be able to pull this off yourself, so open up the code in the m168_led_button folder and lets walk through it.

Debounce: Buttons often register more than one press if not handled correctly, a process called debouncing. There is a hardware fix for this, but you can learn about that on your own time. Recently, I gathered a post full of different debounce code, but the one I almost always use is based on code by [Peter Dannegger]. It relies on several parts:

• Code to start a timer with an overflow interrupt
• An ISR to service the timer overflow, resetting the timer for 10ms interrupts and polling the button pin.
• A bit mask and pin definitions that identify how the buttons are hooked up
• A function used to check if a button press has been registered
• Code to check that function and act when a button has been pressed.

The magic is in the ISR debounce code. It flips bits in a binary counter to register four successive button press readings totalling 40ms. That signals a legitimate button press and when the get_key_press function is called it will return a populated key mask. To help understand how this debounce code works, I have included a code example called button_debounce. This has been slimmed down to include only the code used to debounce. Pressing the button will toggle the LEDs.

During the hardware setup I talked about using the internal pull-up resistors. I have to remember to set those up at the beginning of the program or the input pin will be floating. The datasheet talks about this on page 71. When a pin is set to input using the Data Direction Register, writing a high value to the Port bit for that pin will enable the pull-up resistor. From there the current status of the pin can be grabbed from the appropriate Pin register. Notice the ISR used for debouncing reads KEY_PIN, which is defined as the PINC register at the top of the source code. You don’t have to read the Pin register because the ISR is doing it for you.

My implementation of button debouncing in the m168_led_button code is just fine, but my use of the button is a hack. I should have used a state machine and gotten rid of the delay functions in the code. For simplicity I just littered calls to get_key_press throughout the code whenever I was trapping the program in a loop. I used the detection of a key press to return to main from the function the program is stuck in.

Pick this apart, writing simple code that you understand and slowly you will build the knowledge base necessary to understand this code as a whole.

Creating something useful (m168_bike_light)

I wanted to finish the code writing section with a useful application for our test hardware. Behold, a bicycle tail light. It has a button to scroll through several different red light patterns, and it uses sleep mode to shut off the LEDs and conserve battery power.

I’ve changed the program flow to use a state machine. This is a bit of a juggling act. I use an interrupt to set a flag called ‘timer’. The main loop constantly polls that flag, as well as the button, and acts accordingly. Whenever that flag is set the next step of the LED effect is performed.

Sleep mode is also used in this example. One thing to note: when in sleep mode the chip uses almost no current, conserving batteries. But the linear power regulator still burns away like crazy. For this to be useful the code should be ported to a chip that operates at low voltages. For instance, you could use a tiny13 and two AA batteries without a regulator. Adjustments would need to be made for less pins and corrected LED resistor values, but these are not difficult changes to make. Have a look at the code in the m168_bike_light folder. The comments and your hard-earned AVR knowledge will help you understand how this works. Good luck!

Now I’ll move on to the discuss one of the most important parts of theses microcontrollers:

AVR Fuse Bits

The fuse bits are a set of registers that control some core features of the AVR line of chips. You can think of them as another type of memory, programmed separately from the code that you want to execute.

Read the datasheet

Fuse bits for the ATmega168 are covered starting on page 285 of the datasheet. You should make yourself thoroughly familiar with this information. Incorrectly programming these registers could render your chip useless unless you have a programmer capable of High Voltage Programming (HVP).

There are three fuse bit registers on our chip, the Extended fuse byte, the High fuse byte and the Low fuse byte. All of them use inverse logic, meaning that a ’1′ means the corresponding feature is NOT selected. I start every project with these registers set to the factory default, information I keep in a text file with the factory fuse defaults for all the chips I work with. At the beginning of every project I try to talk to the chip using the ‘-v’ option of AVRdude to make sure the programmer and chip are both working correctly to save time on later debugging. Here are the ATmega168 defaults:

• efuse: 0b11111111 (0xFF)
• hfuse: 0b11011111 (0xDF)
• lfuse: 0b01100010 (0×62)

I’ll touch on most of these features in the next section. But of particular concern are the bits that select the clock source, and the reset disable bit. If you disable the reset pin, by accident or in order to use it as an I/O pin, you will need to use HVP or debugWire to use ISP programming again. If the clock pins are changed you will need the appropriate external clock signal, or HVP for the same reason.

You can program the fuse bits using AVRdude. In fact, there’s an example in the documentation. This command will reset the fuses to the factory settings:

avrdude -c dragon_isp -P usb -p m168 -U efuse:w:0xff:m -U hfuse:w:0xdf:m -U lfuse:w:0x62:m

AVR Peripherals (A Whirlwind Tour)

Take a whirlwind tour of the features available to you on this chip. This is gonna be quick, but you already have the core skills you need. Just read the datasheet and using the Internet to connect the rest of the dots.

EEPROM memory

Most (if not all) of the AVR chips come with Electronically Erasable Programmable Read Only Memory. This is persistent memory that stores data between resets and when there is no power to the chip. This is where data loggers store information and often contains things like text strings, font data, etc. AVR-GCC will generate an .EEP file at compile time with any EEPROM data that you use in your programs. This needs to be programmed to the chip separately from flash data.

Timers (Regular and Watchdog)

Timers are where it’s at in terms of functionality. They go far beyond simply measuring time, and can be used to wake the chip up from sleep mode, to generate pulse width modulation frequencies, and much more. Some chips have asyncronous timers, like Timer/Counter 2 on the ATmega168, that can use an external clock signal separate from the other timers.

Also not to be missed is the Watchdog timer. These timers can save money, and even lives. They are a hardware timer enabled through the fuse bits that will reset the microcontroller if not handled in software. Why would you want to do that? Because nobody writes perfect code. When using a Watchdog timer you frequently reset its counter during successful code execution. That way if your code ever hangs or gets caught in a loop the Watchdog timer will automatically reset the device, getting you out of a software-caused bind. See what [Jack Ganssle] has to say about them.

Real time counter

I mentioned above that Timer/Counter 2 can be run asynchronously from the rest of the timer/counters. Why is that valuable? One of the uses is as a Real Time Counter (RTC). This works in conjunction with a clock crystal to keep track of the time and date.

Hardware PWM

Continuing with the theme of timer/counter based featured, these chips have hardware-based pulse width modulation. PWM generates a signal between 0V and VCC by turning a pin output on and off frequently. The frequency used, and the duty cycle (ratio of high versus low over one period) are set in the registers and you don’t have to think about it again until you want to change them. This is useful for a slew of things, like dimming an LED, driving a servo motor, or generating sound on a piezo.

ADC

If you want to measure an analog value you need an Analog-to-Digital Converter. Most AVR chips have several of these with varying degrees of precision. This enables you to do things like measure light levels using a photoresistor and reading the value of a potentiometer (using it like a settings knob).

USART

The ATmega168 has a Universal Synchronous and Asynchronous serial Receiver and Transmitter which allows it to communicate in many different ways. This includes serial communications like USB (by taking advantage of the V-USB stack), as well as chip-to-chip communication standards like SPI, I2C, and TWI.

SPI

The AVR family often incorporates Serial Peripheral Interface bus communications protocols into its hardware. The USART on the ATmega168 offers master SPI functionality, used to control other chips that also use the protocol via three connections; two for data one for clock.

I2C/TWI

The USART also offers hardware I2C and Two Wire Interface features. Like SPI these are common chip-to-chip protocols but they use just two wires; one for data and the other for a clock signal.

Analog comparator

The analog comparator uses two input pins to compare analog signals. Based on their relation, the chip can be set to fire interrupts if one changes value compared to the other. The two inputs can be mapped to any of the ADC pins, but only two values can be compared at one time. I’ve never used this feature and I’m basing this description purely on what I’ve read in the datasheet. Sorry!

Lock bits

Any code you write to these chips can be read back and stored (albeit what comes back out is machine code, the C code we’ve been writing can never be reproduced perfectly from what you get off the chip). That can then be used to program other identical chips. But there is a feature called lock bits that can protect that code. Once set, the chip cannot be read, and depending on which bits are set it may not be able to be reprogrammed. That is, until the chip has been erased, which resets these lock bits.

JTAG, debugWire, and High Voltage Programming

In this tutorial we’ve been using In System Programming, but there are a few other ways to program AVR chips. JTAG is a standard hardware debugging (and programming) interface that some chips have, but the ATmega168 does not. Many of these chips can use the debugWire protocol to program and debug with just one wire communicating on the reset pin. Both JTAG and debugWire protocols are configured using the fuse bits.

High Voltage Programming is used to rescue chips that cannot be reached using other programming methods. There are two kinds, High Voltage Parallel Programming, like the ATmega168 uses, or High Voltage Serial Programming which chips with a low-pin count use. If you disable the Reset pin or enable debugWire, or set the clock source incorrectly in the fuse settings, HVPP or HVSP should be able to reset the fuses and rescue the “bricked” chip.

Power and Sleep

Microcontrollers operate so quickly there is often just wasted time as they scroll the infinite loop waiting for an interrupt to happen. If you are operating under battery power this just wastes juice. By using the power saving and sleep modes batteries can last longer. This is accomplished by turning off power hungry peripherals like the ADC, and shutting down the processor when not needed by putting it to sleep. They’re a bit tricky to understand, but often worth your while

Conclusion

That’s it really. I’ve had a great time writing about this. Fiddling with microcontrollers is my favorite hobby and I hope it has become yours as well. These are really very simple concepts that grow in complexity as you pile them atop each other. Just compare the original Part 2 source code with the bicycle tail light code. But that’s the fun of it. This is the inventor’s equivalent of a choose your own adventure novel. So come up with a challenge and see where it takes you!

Follow Me

@szczys

Resources

Part 4 Firmware package: Github repository

Atmel AVR ATmega168 Datasheet (PDF)

AVR Libc manual