The digital accelerometer I used here is ST’s triple-axis accelerometer LIS3LV02DL. I talked about how to use it using SPI a couple of months ago. You only need 2 axises for this particular application, since I happen to have this tripe-axis accelerometer on hand, I will use it here.

The following are the coordinates of the acceleration measurements.

LIS3LV02DL Orientation

If we are measuring the surface represented by x-axis and y-axis, the angles can be measured as:
\[\theta_x = tan^{-1}\frac{g}{g_x}\]
\[\theta_y = tan^{-1}\frac{g}{g_y}\]

When the accelerometer is placed on a perfectly flat surface, the force exerted on z axis would be approximately 1g.

Since LIS3LV02DL has 2 modes (2g and 6g), the 12 bit of resolution per axis (readings from -2048 to 2048) should give us 1/1000 resolution in 2g mode. 6g model can also be used, but the accuracy will be roughly three times lower than in 2g mode. Here is the schematics of the circuit using ATmega328p MCU:

LIS3LV02DL Digital Level

In my design above, I used one button to toggle the back light of the LCD display, one button to calibrate the device and one button to toggle between 2g and 6g modes. Here is a picture of the assembled digital level.

Digital Level

The picture below shows the digital level on a flat surface after initial calibration. Calibration is achieved by placing the digital level on a known flat surface and press the calibrate button. When the calibration button is pressed, the x and y readings are forced to 0′s and thus making relative measurements much easier.

Digital Level

The Arduino code for this project can be downloaded here. This project was developed with the NetBeans IDE and you may need to adjust the included header files if you are using Arduino IDE. For more information, please see my previous article on this topic.)

Without using any shift registers, a single ATmega328p chip can handle a around 20 I/O ports. I decided to use 16 LEDs, twice the number of LEDs as the ones you commonly see. This gives me at least four free pins for other purposes. You can probably build a POV with around 20 LEDs, but If you need more than that, you will have to use shift registers to expand the available IO pins or change to a chip that has more built-in IO pins (i.e. ATMega1280). But as you shall see later, the image generation process will be considerably more complex and the required memory storage will be much larger as well.

POV Display and Its Synchronization

In order to achieve a stable image output, the image frames generated by the POV device must be synchronized. A POV display can operate as a hand device (e.g. a wand) or be driven by a motor. When the POV device is built for hand use, it usually has a motion detector (from simple spring-in-cylinder switch to the more exotic accelerometer) so that the device can start displaying when the hand is waved. I decided to go with a motor driven design so that I can have more precise control over the output image. In this approach, image frames must be synchronized for each full rotation. A simple way to detect the motor rotation is to use a IR transmitter and receiver.

The following is the full design of my POV display (the left side shows the optical triggering mechanism mentioned above):

16 LED POV Schematics

And here is the finished circuit mounted on a motorized rotating platform:

16 LED POV Display (top view)

Here is a picture of the side view, you can see how the IR transmitter and receiver circuits are mounted. Whenever the transmitter and the receiver line up (it happens every rotation), the transistor would output a LOW signal to the ATMega328p (pin 28, Arduino analog pin 5) which indicates the beginning of a new frame. To reduce the light interference from the environment, the receiver is mounted on the rotor so it is facing downwards.

16 LED POV Display (side view)

Image Encoder

Building the circuit is only half of the game. In order to provide the most flexible and the richest displays, I decided to build a image encoder which can be used to automatically translates a binary image into the appropriate code that is needed for the POV display. For simple POV displays, the display patterns can be mapped directly into a binary two dimensional array, with 1 represents LED on and 0 represents LED off. But this approach is not practical when displaying larger images. For an image the size of 16×100, 1600 bytes would be required to store the image information. This might not sound like much but that is almost all of ATMega328′s usable SRAM. Of course, you can always store the data structure off in Flash memory using PROGMEM, but it is not the most efficient way to do so. A better approach would be to pack these pixels into bytes so that each byte can represent 8 pixel values.

This code is shown as below. This C# code works with both Microsoft’s .Net platform or Mono.Net and thus it can be run on either Windows or Linux:

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;

namespace convertImg
{
	class Program
	{
		static void Main (string[] args)
		{
			if (args.Length != 1) return;

			Image img = Image.FromFile (args[0]);			

			Bitmap bm = new Bitmap (img);
			BitmapData bmd = bm.LockBits (new Rectangle (0, 0, img.Width, img.Height),
			                              ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

			byte[,] ay = new byte[img.Width, img.Height];
			byte[] compactedAy = new byte[2 * img.Width];

			for (int y = 0; y < img.Height; y++) {
				for (int x = 0; x < img.Width; x++) {
					byte b = Marshal.ReadByte (bmd.Scan0, y * bmd.Stride + x * 4);

					if (b == 0)
						ay[x, y] = 1;
					else
						ay[x, y] = 0;

					Console.Write (ay[x, y]);
				}

				Console.WriteLine ();
			}

			Console.Write ("byte dispArray[] = {");

			for (int x = 0; x < img.Width; x++) {
				if (x % 8 == 0) {
					Console.WriteLine ();
					Console.Write ("\t");
				}

				compactedAy[2 * x] = (byte)(ay[x, 0] << 7 |
				                            ay[x, 1] << 6 |
				                            ay[x, 2] << 5 |
				                            ay[x, 3] << 4 |
				                            ay[x, 4] << 3 |
				                            ay[x, 5] << 2 |
				                            ay[x, 6] << 1 |
				                            ay[x, 7]);			

				compactedAy[2 * x + 1] = (byte)(ay[x, 8] << 7 |
				                                ay[x, 9] << 6 |
				                                ay[x, 10] << 5 |
				                                ay[x, 11] << 4 |
				                                ay[x, 12] << 3 |
				                                ay[x, 13] << 2 |
				                                ay[x, 14] << 1 |
				                                ay[x, 15]);

				if (x < img.Width - 1) {
					Console.Write ("{0,3} ", compactedAy[2 * x]);
					Console.Write (", ");
					Console.Write ("{0,3} ", compactedAy[2 * x + 1]);
					Console.Write (", ");
				} else {
					Console.Write ("{0,3} ", compactedAy[2 * x]);
					Console.Write (", ");
					Console.Write ("{0,3} ", compactedAy[2 * x + 1]);
				}
			}

			Console.WriteLine ();
			Console.WriteLine ("};");
		}
	}
}

The code above converts a binary image into an array of packed bytes. Every vertical line consists of 16 pixels (since we are using 16 LEDs) which is translated into two consecutive bytes in the resulting array. In general, the more LEDs you have, the more space it would take for each encoded line. As you can see, making the number of LEDs divisible by eight enables us to use full bytes for each encoded line. It is possible to use number of LEDs that do not fall into this pattern, but the resulting code would be either more difficult if full byte utilization is desired or leave some unused space between each line if lines need to start on byte boundaries.

Here is our test image.

Using the image above (in PNG format) as the input, the encoded image is outputted to the terminal (formatted as a C++ array)

byte dispArray[] = {
    0, 2, 0, 30, 0, 252, 7, 240, 31, 48, 252, 48, 224, 48, 252, 48,
    31, 48, 7, 240, 0, 252, 0, 30, 0, 2, 0, 0, 0, 0, 0, 0,
    15, 254, 15, 254, 6, 0, 12, 0, 12, 0, 12, 0, 0, 0, 1, 240,
    7, 252, 14, 14, 12, 6, 12, 6, 12, 6, 12, 6, 6, 12, 255, 254,
    255, 254, 0, 0, 0, 0, 0, 0, 0, 0, 15, 248, 15, 252, 0, 14,
    0, 6, 0, 6, 0, 6, 0, 12, 15, 254, 15, 254, 0, 0, 0, 0,
    0, 0, 0, 0, 207, 254, 207, 254, 0, 0, 0, 0, 0, 0, 0, 0,
    15, 254, 15, 254, 6, 0, 12, 0, 12, 0, 12, 0, 14, 0, 7, 254,
    3, 254, 0, 0, 0, 0, 0, 0, 1, 240, 7, 252, 6, 12, 12, 6,
    12, 6, 12, 6, 12, 6, 6, 12, 7, 252, 1, 240, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 3, 192, 12, 48, 48, 12, 32, 4, 76, 2,
    76, 66, 128, 33, 128, 17, 128, 17, 128, 17, 76, 34, 76, 66, 32, 4,
    48, 12, 12, 48, 3, 192, 0, 0
};

and is ready to be consumed by the Arduino side of the code.

Arduino Code

And here is the code on the Arduino side (I used Netbeans as my IDE, and you may need to change a couple of the includes if you are using the IDE bundled with Arduino. For more information, please see my previous article on this.)

As you can see, the dispArray is plugged in directly from the output of the encoder shown above. Note that here I assumed the image size is 16×100, if your image widths are different, then you will need to adjust the range of curPos accordingly.

The analogRead() statement in the main loop detects whether the IR transmitter and receiver are aligned. If so, the analog pin output would become lower as the transistor on the receiver side becomes saturated and when a pre-defined threshold is crossed, the decoding process begins. Depending on how fast the display spins, colDelay may need to be adjusted accordingly.

#include <binary.h>
#include <HardwareSerial.h>
#include <pins_arduino.h>
#include <WConstants.h>
#include <wiring.h>
#include <wiring_private.h>
#include <WProgram.h>
#include <EEPROM/EEPROM.h>

const int p1 = 0; //2;
const int p2 = 1; //3;
const int p3 = 2; //4;
const int p4 = 3; //5;
const int p5 = 4; //6;
const int p6 = 5; //11;
const int p7 = 6; //12;
const int p8 = 7; //13;
const int p9 = 8; //14;
const int p10 = 9; //15;
const int p11 = 10; //16;
const int p12 = 14; //23;
const int p13 = 15; //24;
const int p14 = 16; //25;
const int p15 = 17; //26;
const int p16 = 18; //27;

const int triggerPin = 5; //28;

const int colDelay = 8;

int ledPins[] = {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16};
int curPos = 0;

/** Image generator output */
byte dispArray[] = {
    0, 2, 0, 30, 0, 252, 7, 240, 31, 48, 252, 48, 224, 48, 252, 48,
    31, 48, 7, 240, 0, 252, 0, 30, 0, 2, 0, 0, 0, 0, 0, 0,
    15, 254, 15, 254, 6, 0, 12, 0, 12, 0, 12, 0, 0, 0, 1, 240,
    7, 252, 14, 14, 12, 6, 12, 6, 12, 6, 12, 6, 6, 12, 255, 254,
    255, 254, 0, 0, 0, 0, 0, 0, 0, 0, 15, 248, 15, 252, 0, 14,
    0, 6, 0, 6, 0, 6, 0, 12, 15, 254, 15, 254, 0, 0, 0, 0,
    0, 0, 0, 0, 207, 254, 207, 254, 0, 0, 0, 0, 0, 0, 0, 0,
    15, 254, 15, 254, 6, 0, 12, 0, 12, 0, 12, 0, 14, 0, 7, 254,
    3, 254, 0, 0, 0, 0, 0, 0, 1, 240, 7, 252, 6, 12, 12, 6,
    12, 6, 12, 6, 12, 6, 6, 12, 7, 252, 1, 240, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 3, 192, 12, 48, 48, 12, 32, 4, 76, 2,
    76, 66, 128, 33, 128, 17, 128, 17, 128, 17, 76, 34, 76, 66, 32, 4 of,
    48, 12, 12, 48, 3, 192, 0, 0
};

/**
 * delay ms * 0.1 milliseconds
 */
void delayMilliseconds(int ms) {
    for (int i = 0; i < ms; i++) {
        delayMicroseconds(100);
    }
}

void setup() {
    for (int i = 0; i < 16; i++) {
        pinMode(ledPins[i], OUTPUT);
        digitalWrite(ledPins[i], LOW);
    }
}

void loop() {
    if (analogRead(triggerPin) < 800) {
        for (int curPos = 99; curPos >= 0; curPos--) {
            byte b1 = dispArray[curPos * 2];
            byte b2 = dispArray[curPos * 2 + 1];

            for (int i = 0; i < 8; i++) {
                digitalWrite(ledPins[i + 8], (b1 & (1 << i)) >> i);
                digitalWrite(ledPins[i], (b2 & (1 << i)) >> i);
            }

            delayMilliseconds(colDelay);
        }

        for (int i = 0; i < 16; i++) {
            digitalWrite(ledPins[i], LOW);
        }
    }
}

POV Display in Action

Here’s the POV display in action. Using the programs in this article what you can show on this POV display is not just limited to characters, any binary image design that fits the image dimension (16×100 in this example) can be used. If you use different images for different frames you can even create your own POV animation.

16 LED POV Display in Action

To change the Apache log rotate frequency, you would want to change the apache2 configuration file located under /etc/logrotate.d. Configurations located in this directory overrides the default settings in /etc/logrotate.conf (the configurations in /etc/logrotate.d are included in logrotate.conf)

Here’s what my settings look like (note that I had commented out compress option so that all the logs can be easily browsed):

/var/log/apache2/*.log {
daily
missingok
rotate 365
#compress
#delaycompress
notifempty
create 640 root adm
sharedscripts
postrotate
if [ -f "`. /etc/apache2/envvars ; echo ${APACHE_PID_FILE:-/var/run/apache2.pid}`" ]; then
/etc/init.d/apache2 reload > /dev/null
fi
endscript
}

Common problem

A common problem after changing the log rotate frequency is that the Apache logs do not appear to be rotating daily even though the configuration file had been changed correctly.

This seems to be a known issue with logrotate. If you read the manual for logrotate you’d see the following explanation:

-f, –force
Tells logrotate to force the rotation, even if it doesn’t think
this is necessary. Sometimes this is useful after adding new
entries to a logrotate config file, or if old log files have
been removed by hand, as the new files will be created, and
logging will continue correctly.

Since the default cron daily job does not force the log rotation, you may want to add -f parameter to /etc/cron.daily/logrotate:

#!/bin/sh

test -x /usr/sbin/logrotate || exit 0
/usr/sbin/logrotate -f /etc/logrotate.conf

With this change, the logs will be forced to rotate daily according to the setup.

At first I noticed that the database was down, but when I finally got to the console after work, it appeared that the server had crashed for some reason. So naturally, I powered down the server and rebooted. But nothing happened, there was no POST message. At first I thought this was just a temporary glitch of some kind, but after repeated reboot attempts it became apparent that something was seriously wrong. I swapped RAM and CPU and tried a few other tricks but the machine refused to show any sign of life… I guess that somehow the old hand-me-down server had just bit the dust.

I could have just powered back on my old server but since I had intended to upgrade to Ubuntu 10.04 (my old server was running Ubuntu 8.04) I decided to run my server under VMWare for the time being till I get a chance to upgrade my old server to 10.04 first.

I guess I will have to live with my old Pentium III server for a bit longer. But hey, old as it is, it only consumes 40W of power!

Update 8/3/2010
I have switched back to my old server. As I mentioned yesterday, I upgraded the server to Ubuntu 10.04. So everything is back to normal, at least for now…

Luckily, I got a fully equipped hand-me-down Compaq (HP) ProLiant DL360 G2 server and I decided to migrate my website over during the weekend.

Even though this server is a few generations behind, it has dual Pentium III S 1.4 GHz processors, 15,000 RMP SCSI harddrive and 4GB of RAM which is more than plenty to meet my near future needs.

Since my web server was running on Ubuntu Server 8.04, this hardware upgrade also gives me an opportunity to upgrade the OS to the latest version of Ubuntu Server (10.04) which is also an LTS version.

With the new hardware and software, the site should be running rather smoothly for the next couple of years…

One such alternative is Silicon Labs‘ CP2102. I particularly like this USB to UART transceiver because very few extra components are required for it to work. As an added benefit, this chip is also cheaper than the ubiquitous FT232R. Of course, there are also a few trade offs. First of all, CP2102 does not provide a bit bang interface (the X3 pins on the Arduino board on the other hand can be used for bit bang operations, but the X3 pins are not soldered with header pins by default and thus for the average users no bit bang support should not be an issue). Secondly, CP2102 does not have the configurable general purpose I/O pins to drive the TX/RX LEDs. There are other minor differences as well (for instance the maximum transmission speed for FT232R is 3Mbps while CP2102 tops at 1Mbps. Both chips are more than adequate for the maximum 115,200 baud rate supported in Arduino environment), but they do not affect the performance in our application of interfacing with Arduino.

Here is the schematics for using CP2102 with ATmega328p (the circuit below is compatible with the Arduino IDE):

Arduino using CP2102

if you compare the above circuit with the official Arduino Duemilanove board you will see that the interfacing portions (RXD, TXD and TDR) are virtually identical.

Since CP2102 comes only in QFN-28 packaging, some people might find it slightly harder to deal with than TSSOP. Using the prototyping method I mentioned a few months back though, it is fairly straightforward to use the chip on a standard perf-board nevertheless. No special tools or stencils are needed. The following picture shows the USB to UART converter portion of the Arduino, which can be used to replace the FT232 break out board. I chose to break out the converter so that I could use it in other projects that require serial connections.

USB to Serial Board based on CP2102

If you are running Linux, you do not need any third-party device drivers. All recent Linux kernels support CP210x via the usbserial kernel module. Once connected, you should be able to use dmesg and see these messages:

[ 8333.572512] usb 8-2: new full speed USB device using uhci_hcd and address 3
[ 8333.744748] usb 8-2: configuration #1 chosen from 1 choice
[ 8333.785114] usbcore: registered new interface driver usbserial
[ 8333.785161] USB Serial support registered for generic
[ 8333.785221] usbcore: registered new interface driver usbserial_generic
[ 8333.785222] usbserial: USB Serial Driver core
[ 8333.792419] USB Serial support registered for cp210x
[ 8333.792460] cp210x 8-2:1.0: cp210x converter detected
[ 8333.920011] usb 8-2: reset full speed USB device using uhci_hcd and address 3
[ 8334.076745] usb 8-2: cp210x converter now attached to ttyUSB0
[ 8334.076760] usbcore: registered new interface driver cp210x
[ 8334.076762] cp210x: v0.09:Silicon Labs CP210x RS232 serial adaptor driver

If you are running Windows, you will need to install the royalty-free driver from Silicon Labs directly.

Under Linux, CP210x shows up as a a ttyUSB device. You can use the Arduino IDE to program your ATmega328p’s just as you would with an official Arduino. Serial communication via the serial monitor works the same way as well. Like the official Arduino, the above circuit also automatically resets whenever you upload a program.

The following picture shows this Arduino compatible circuit in action.

An Arduino Compatible Using CP2102

The reason I mentioned back then for going this route was that I did not have enough I/O pins since bq3287 used most of the pins on ATmega328p. Of couse, I could’ve just used a serial real-time clock like DS1307 and thus free up the pins, but I thought it would be a cool idea to experiment with bidirectional I2C communications. A key benefit of using I2C is that only three wires are required between the two MCUs, which makes it possible to use standard two-conductor shielded wire commonly used in stereo earphones to serve as the communication link.

For those who are impatient, the full source code can be downloaded toward the end of this article.

My main design goal was to achieve bi-directional communication between two ATmega328′s using I2C (TWI). Namely I wanted to be able to:

• transmit date/time information from the 7seg LED clock to the other MCU where time can be displayed on an LCD.
• set date/time from the remote MCU and sync the date/time settings back to the main 7seg LED clock.

At a high level, bidirectional communication using the Arduino Wire library can be achieved by assigning unique addresses to the devices that participate in the communication:

//device 1
Wire.begin(ADDRESS_1);
Wire.beginTransmission(ADDRESS_2);
...
Wire.endTransmission();

//device 2
Wire.begin(ADDRESS_2);
Wire.beginTransmission(ADDRESS_1);
...
Wire.endTransmission();

In order to be able to send the time and date information between the two ATmega328p’s, I defined the structure RTCMessage as follows:

struct RTCMessage {
    byte sender;
    byte msgType;
    byte year;
    byte month;
    byte day;
    byte hour;
    byte minute;
    byte secondInd;
    byte dayOfWeek;
};

On the 7seg clock side (where the RTC chip bq3287 is located), the Wire library is initialized to be a host on address 5 and listens on address 4. The event handler function receiveEvent processes the incoming date/time data and adjust the RTC settings accordingly. In the main loop, the current date/time info is sent to the other ATmega328p (address 4, ADDR_TWI_REMOTE) constantly so that the two clocks can keep in sync.

const int ADDR_TWI_LOCAL = 5;
const int ADDR_TWI_REMOTE = 4;

 //... ... code omitted here ... ...

void setup() {

    //... ... code omitted here ... ...

    Wire.begin(ADDR_TWI_LOCAL);
    Wire.onReceive(receiveEvent);
}

void receiveEvent(int howMany) {
    RTCMessage msg;

    msg.sender = Wire.receive();
    msg.msgType = Wire.receive();
    msg.year = Wire.receive();
    msg.month = Wire.receive();
    msg.day = Wire.receive();
    msg.hour = Wire.receive();
    msg.minute = Wire.receive();
    msg.secondInd = Wire.receive();
    msg.dayOfWeek = Wire.receive();

    adjust(ADDR_CUR_YEAR, msg.year);
    adjust(ADDR_CUR_MON, msg.month);
    adjust(ADDR_CUR_DAY, msg.day);
    adjust(ADDR_CUR_HOUR, msg.hour);
    adjust(ADDR_CUR_MIN, msg.minute);
    adjust(ADDR_CUR_DOW, msg.dayOfWeek);
}

void loop() {

    //... ... code omitted here ... ...

    RTCMessage message;

    message.day = curDay;
    message.dayOfWeek = curDOW;
    message.hour = curHour;
    message.minute = curMin;
    message.month = curMonth;
    message.year = curYear;
    message.msgType = MsgGetTime;
    message.sender = ADDR_TWI_LOCAL;
    message.secondInd = secondIndLEDOn ? 1 : 0;

    Wire.beginTransmission(ADDR_TWI_REMOTE);

    Wire.send(message.sender);
    Wire.send(message.msgType);
    Wire.send(message.year);
    Wire.send(message.month);
    Wire.send(message.day);
    Wire.send(message.hour);
    Wire.send(message.minute);
    Wire.send(message.secondInd);
    Wire.send(message.dayOfWeek);

    Wire.endTransmission();
}

The code on the other ATmega328p is slightly more complex but the idea is essentially the same. We first set up the master and slave address for TWI communication. Note that the master/slave addresses we set up here are the opposite compared to those we did on the RTC clock side.

Here is the code snippet relevant to the TWI communication on the LCD display side:

const int ADDR_TWI_LOCAL = 4;
const int ADDR_TWI_REMOTE = 5;

 //... ... code omitted here ... ...

void setup() {

    //... ... code omitted here ... ...

    Wire.begin(ADDR_TWI_LOCAL);
    Wire.onReceive(receiveEvent);

}

void receiveEvent(int howMany) {
    intProc = true;

    message.sender = Wire.receive();
    message.msgType = Wire.receive();
    message.year = Wire.receive();
    message.month = Wire.receive();
    message.day = Wire.receive();
    message.hour = Wire.receive();
    message.minute = Wire.receive();
    message.secondInd = Wire.receive();
    message.dayOfWeek = Wire.receive();

    if (currentMode == MODE_TIME_SETUP || currentMode == MODE_NORMAL_CANCEL) {
        displayTime();
    } else if (currentMode >= MODE_ALARM_SETUP) {
        displayAlarm(currentMode - MODE_ALARM_SETUP);
    }

    intProc = false;
}

void saveTimeSettings() {
    Wire.beginTransmission(ADDR_TWI_REMOTE);
    Wire.send(messageCopy.sender);
    Wire.send(messageCopy.msgType);
    Wire.send(messageCopy.year);
    Wire.send(messageCopy.month);
    Wire.send(messageCopy.day);
    Wire.send(messageCopy.hour);
    Wire.send(messageCopy.minute);
    Wire.send(messageCopy.secondInd);
    Wire.send(messageCopy.dayOfWeek);
    Wire.endTransmission();

    message = messageCopy;
}

void loop() {
    //process button pressed events
    for (int i = 0; i < NUM_OF_BUTTONS; i++) {
        if (buttonPressed(i)) {
            if (intProc) return;
            cli();

            lcd.setCursor(15, 1);
            lcd.print(" ");

            if (i == BTN_MODE_SELECT) {
                currentMode++;
                renderCurrentMode();
            } else if (i == BTN_CURSOR_CTRL) {
                if (currentMode == MODE_TIME_SETUP) {
                    renderTimeSetup();
                } else if (currentMode >= MODE_ALARM_SETUP) {
                    renderAlarmSetup();
                }
            } else if (i == BTN_UP || i == BTN_DOWN) {
                if (currentMode == MODE_TIME_SETUP) {
                    adjustTimeSetup(i);
                } else if (currentMode >= MODE_ALARM_SETUP) {
                    adjustAlarmSetup(i);
                }
            } else if (i == BTN_ENTER) {
                if (currentMode == MODE_TIME_SETUP) {
                    sei();
                    saveTimeSettings();
                    cli();
                    lcd.setCursor(15, 1);
                    lcd.write(SAVED_SYM);
                } else if (currentMode >= MODE_ALARM_SETUP) {
                    saveAlarmSettings(currentMode - MODE_ALARM_SETUP);
                    lcd.setCursor(15, 1);
                    lcd.write(SAVED_SYM);
                } else if (currentMode == MODE_NORMAL_CANCEL) {
                    backLight = !backLight;

                    if (backLight) digitalWrite(PIN_BACKLIGHT, HIGH);
                    else digitalWrite(PIN_BACKLIGHT, LOW);
                }
            }
            sei();
        }

        if (buttonRleased(i)) {
            //the button is released, no action is necessary.
        }
    }

    checkAlarms();
}

The LCD side has five buttons, which are used to set/navigate time and alarm settings (you can download the full source code below). The information displayed on the LCD changes depending on the modes these buttons are in. This aside, the general idea is that whenever the date/time information is transmitted from the remote 7seg RTC clock, it is displayed on the LCD via displayTime if the current mode is set to display time.

When the date/time settings are changed on the LCD side, it is saved back to the RTC clock via saveTimeSettings in the main loop. Note that the interrupts are disabled for most of the loop via cli except for syncing the date/time settings. This is necessary to ensure that the button selections are fully processed before any interrupt handling occurs. If this is not done, the output on the LCD would be garbled as the TWI interrupt might happen during a screen update.

The following picture shows how the LCD (in the front) and the 7seg clock are in sync with the I2C primitives shown above.

Clock Synchronization Via I2C

The alarm settings are stored in the EEPROM of the ATmega328p on the LCD side which are compared against the current time stamp in checkAlarms to determine whether the alarm conditions are met.

The full source code for this project can be downloaded here (note, I used NetBeans IDE to create these projects. Please refer to this post to see how it is done):

The 7seg Digital Clock: DigitalClock.tar
The LCD Controller: LCD.tar

… … …
avrdude: Device signature = 0×000000
… … …

Typically when I ran into this problem it was due to loose cable connection and I was able to get past it by reconnecting the ICSP header and try again. But this time, the it seems that no matter how many times I tried the problem remained.

I am pretty sure that chip itself was not damaged as it was sitting in the ICSP board I built all the time and I was able to program it successfully many times minutes before this happened.

Here’s what I have tried and so far had no success:

• rebooted system
• re-seated the IC
• changed -B option to allow more delays
• changed -b option to different baud rates
• tried to use external clock signal from a working ATmega328p

And just to be sure nothing was wrong with either the cable or the board itself, I popped in another ATmega328P and everything worked. So it seems that even though I did not change any fuse settings, and the only command I used was

avrdude -V -F -C avrdude.conf -c duemilanove -p m328p -U flash:w:{hex file})

I guess that somehow the fuse settings had changed and thus the chip stopped responding to the clock signal.

So, it’s time for me to try the high voltage parallel programming method (like this one) to see if my theory was correct.

Following the instructions, I built the shield quickly (not very pretty but serves the purpose nevertheless). The none-standard header spacing was not a big issue as it was easy enough to bend the header pins to achieve the desired spacing (see picture below):

Top view

Bottom View

For the high voltage programming enable 12V supply, I chose to use a simply transistor switch instead of the boost converter:

12V Supply

The drawback of this approach is that the output voltage is not as precise and I had to experiment a little bit to obtain the required HV programming voltage The enable signal comes from the Arduino is around 4.5 V which may not be sufficient to put the transistor in the saturated mode and in my case with a 14 Volt supply, I was able to obtain the required 12 V output. Since the control signal is inverted compared to the original schematic in the article, I had to invert all the digitalWrites to the 12V enable pin to make the program work with my version of the shield.

I used the AVR Fuse calculator to obtain the default fuse settings for ATmega328p:

LFuse = 0×62
HFuse = 0xD9
EFuse = 0xFF

And it brought the “bricked” ATmega328p back to life with the first try! So I guess a parallel mode programmer can come in handy in situations like this.

According to the user’s guide, UART0 (pin 10 and pin 11) is invoked in ROM loader mode when RST is set to High and both EA and PSEN are set to LOW simultaneously. After the ROM loader mode is enabled, serial communication can be handled between a PC’s RS-232 port and the microcontroller using a RS-232 transmitter/receiver such as DS232A.

It is also possible to communicate with DS89C430/450′s using PC’s USB port with a USB UART converter IC such as FTDI’s FT232R. If you have an Arduino, then you can just use the on-board FT232RL for this purpose. Technically speaking, this has little to do with Arduino as you could just use an FT232R adapter board, but with Arduino the RX/TX pins are readily accessible (pin 0 and pin 1) and thus using Arduino as a USB to UART converter couldn’t have been any easier. The basic schematic for using Arduino to invoke the DS89C430/450′s ROM loader mode is shown below:

DS89C430/450

Please note that DS89C430/450′s RX pin is connected to the socket on the Arduino board marked with RX and the TX pin is connected to the socket marked with TX. This is because Arduino’s RX socket is actually connected to the TX pin (pin 1) of FT232RL and TX socket is connected to the RX (pin 5) of FT232RL. The picture below shows how this is setup between an DS89C430 and Arduino (I used an external 5V supply here for the DS89C430 board, but you can use the 5V pin directly from the Arduino board if you want to).

Connecting DS89C430 to Arduino

According to the user guide, DS89C430/450′s ROM loader automatically tries baud rates generated by this equation:
\[ROM Loader Baud Rate = \frac{Crystal Frequency}{192\times(256-Timer Reload)}\]

And the timer reload values attempted by the loader are: FF, FE, FD, FC, FB, FA, F8, F6, F5, F4, F3, F0, EC, EA, E8, E6, E0, DD, D8, D4, D0, CC, C0, BA, B0, A8, A0, 98, 80, 60, 40. In order for a given generated baud rate to work, the error between the generated baud rate and the UART’s baud rate must be less than 3%.

To make the selection of crystal frequency easier, I developed a spreadsheet that can be used to determine which standard baud rate a particular crystal can operate under. You can simply plugin the crystal frequency you intend to use and the supported baud rates are automatically highlighted in green (see screenshot below).

Baud Rate, Crystal Frequency Calculation

This spreadsheet can be downloaded here:
baudratecalc.ods (OpenOffice)
baudratecalc.xls (Excel)

The crystal frequency I used is 21.7 Mhz which as you can see in the screenshot above supports most of the standard baud rates.

I use PuTTY for the serial communication with the following parameters (note the speed must be one of the supported baud rate calculated above, it depends on the crystal you use). You can use gtkterm as well.

Serial line to connect to: /dev/ttyUSB0
Speed: 115200
Data bits: 8
Stop bits: 1
Parity: None
Flow control: None

And here’s a screen shot of DS89C430 in ROM loader mode:

DS89C430 ROM loader

When the microcontroller is in ROM loader mode, programs can be uploaded using the ROM loader command interface mentioned in the user guide.

The BQ3287 model by itself is really easy to interface with MCUs. There is a nice tutorial on how to use BQ3287 with Arduino and some of the code I am using in this post is borrowed from that project. The main difficulty of turning BQ3287 into a full-fledged clock is that this RTC module uses up to 16 digital pins out of 20 usable pins an ATMega328p has, which leaves very few pins for display and control purposes. After toying with a few possible designs, I decided to use 13 out of the 16 pins so that no major functionality is sacrificed (MOT is left disconnected using Intel bus timing, RESET is tied to Vcc and CS is connected to ground).

Digital pin 0 and 1 (chip pin 1 and 2) are used for button input. Since these two pins are also used as serial RX TX pair when used with the Arduino (the FT232RL chip communicates to The ATmega328 via these two pins) board, I resorted to the ICSP method to program the chip without using the Arduino board.

With this setup, we have two additional pins (pin 27 and 28, these are analog pin 4 and 5 on the Arduino board) available. Since these two pin s are the SCL and SDA pins in TWI (I2C) communication, I am planning to use them to communicate to another ATmega328 chip to further expand the functionality of this clock in the future.

For now, I am using the two buttons to multiplex the following functions:

• Display Time
• Display Date
• Display Year
• Stop Watch
• Change Time Setting
• Change Date Setting
• Change Year Setting

Please see the comment in the code section below to see how these functionalities are achieved.

Three pins are used to control the 4 7 segment display I made earlier. The display update is triggered by the interrupt signal generated from the SQW output pin of BQ3287, I set the interrupt frequency to 128 Hz (RS3 RS2 RS1 RS0 = 1001) to ensure the accuracy of the stop watch (0.1 second) while still maintain a reasonable overhead. The update code all resides in the interrupt handler (intr()).

As you can see in the code, dot between the hour and minute display is turned on and off on a half second interval and in change settings mode the values to be changed also flashes at a half second interval.

Here are some pictures showing the clock displaying in various modes. And the last picture shows the board setup: the front board houses the 4 7 segment display, the left side is the ATmega328 board, the middle one contains the BQ3287 module and the right side board is the voltage regulator board. I used a Taxes Instrument TL720M05 LDO linear voltage regulator, which is a nice LDO pin compatible replacement of the good old 7805.

Time	Date
Year	Day of the Week (Thursday)
Stop Watch	The Setup

And here’s the code listing for this project. As mentioned earlier, I am planing to use a separate ATmega328 board to communicate with this clock using TWI so that I can setup timers/alarms to control other electronics.

//define the bidirectional address-data bus
const int ad0 = 3; //chip pin 5
const int ad1 = 4; //chip pin 6
const int ad2 = 5; //chip pin 11
const int ad3 = 6; //chip pin 12
const int ad4 = 7; //chip pin 13
const int ad5 = 8; //chip pin 14
const int ad6 = 9; //chip pin 15
const int ad7 = 10; //chip pin 16

//ALE or address strobe (AS pin)
const int as = 11; //chip pin 17
//WR or (RW pin)
const int rw = 12; //chip pin 18
//RD or OE (DS pin )
const int ds = 13; //chip pin 19
//interrupt request
const int irq = 14; //chip pin 23

//7-seg display pins
const int clockPin = 15; //chip pin 24
const int latchPin = 16; //chip pin 25
const int dataPin = 17; //chip pin 26

//control button pins
//Note, since these are the rx/tx pins when using FT232RL
//you will either have to program the chip using a programmer (the method I used)
//or using the remaining two two analog data pins (18 and 19). But then you are
//lossing two pins to work with.
const int btnPin1 = 0; //chip pin 1
const int btnPin2 = 1; //chip pin 2

const int COMMON_ANODE = 1; //1 CA, 0 CC

//bq3287 registers
const int regA = 0x0A;
const int regB = 0x0B;

//RO registers C,D
const int regC = 0x0C;
const int regD = 0x0D;

const int ADDR_CUR_SEC = 0;
const int ADDR_ALM_SEC = 1;
const int ADDR_CUR_MIN = 2;
const int ADDR_ALM_MIN = 3;
const int ADDR_CUR_HOUR = 4;
const int ADDR_ALM_HOUR = 5;
const int ADDR_CUR_DOW = 6;
const int ADDR_CUR_DAY = 7;
const int ADDR_CUR_MON = 8;
const int ADDR_CUR_YEAR = 9;

//display modes
//button 1 has 4 modes
const int DM_TIME = 0; //display time
const int DM_DATE = 1; //display date
const int DM_YEAR = 2; //display year
const int DM_DOW = 3; //display day of the week
const int DM_STOP_WATCH = 4; //display stop watch

//button 2 has 7 modes
const int DM_ADJ_NONE = 0; //display the current time
const int DM_ADJ_HOUR = 1; //adjust hour
const int DM_ADJ_MIN = 2; //adjust minute
const int DM_ADJ_MONTH = 3; //adjust month
const int DM_ADJ_DAY = 4; //adjust day
const int DM_ADJ_YEAR = 5; //adjust year
const int DM_ADJ_DOW = 6; //adjust day of the week

/** global variables for storing button's current mode.
 * Button functions
 * When button 2 is not pressed (in DM_ADJ_NONE)
 * press button 1 will cycle through the following display modes:
 *      current time (default)
 *      current date
 *      current year
 *      stop watch
 * when in stop watch mode, button 1 is used to start/stop/reset the stop watch.
 *
 * while in display current time mode (button 1 mode equals DM_TIME)
 * press button 2 will cycle through the following adjustment modes:
 *      adjust hour
 *      adjust minute
 *      adjust month
 *      adjust day
 *      adjust year
 *      adjust day of week
 * when in adjustment mode, button 1 is used to increment the settings.
 */
int btnMode1 = 0;
int btnMode2 = 0;

boolean btn1Pressed = false;
boolean btn2Pressed = false;

//stop watch initialization indicator, if this is set to true
//the stop watch is stopped and displays 0.0
boolean stopWatchInit = true;
boolean stopWatchStarted = false;

/** 7seg character mapping char <-> code */
struct CharMap {
    char c;
    byte v;
};

//the length of the character map, it must match
//the cmap[] array lengh below
const int cmap_len = 41;

//defines the 7seg display characters
struct CharMap cmap[] = {
    {' ', 0},
    {'1', 96},
    {'2', 218},
    {'3', 242},
    {'4', 102},
    {'5', 182},
    {'6', 190},
    {'7', 224},
    {'8', 254},
    {'9', 246},
    {'0', 252},
    {'A', 238},
    {'b', 62},
    {'c', 26},
    {'C', 156},
    {'d', 122},
    {'e', 222},
    {'E', 158},
    {'F', 142},
    {'g', 246},
    {'H', 110},
    {'h', 46},
    {'I', 96},
    {'J', 120},
    {'L', 28},
    {'n', 42},
    {'o', 58},
    {'P', 206},
    {'q', 230},
    {'r', 10},
    {'S', 182},
    {'t', 30},
    {'u', 56},
    {'U', 124},
    {'y', 118},
    {'-', 2},
    {'~', 128},
    {'_', 16},
    {'.', 1},
    {'|', 108},
    {'=', 144}
};

//indicates whether the led on 7seg indicating the "seconds" is on
boolean secondIndLEDOn = false;

//arrays for date/time conversion
char hour[2], minute[2], seconds[6];
char year[2], month[2], day[2], dow[1];

//the 4 characters on the 7seg
char c1, c2, c3, c4;

//this counter is incremented whenever the SW output pin
//triggers the interrupt
int interruptConter = 0;

//this counter is used to keep track of time in stop watch mode
unsigned int stopWatchCounter = 0;

/** same as delay() but works with interrupts */
void delayMilliseconds(int ms) {
    for (int i = 0; i < ms; i++) {
        delayMicroseconds(1000);
    }
}

/** get the display code for a character
/* it looks through the charactor map and find a match that corresponds to c
/* if no match is found, it returns 2 (corresponding to character '-') */
byte getCharDisplayCode(char c) {
    byte r = 2;

    for (int i = 0; i < cmap_len; i++) {
        if (c == cmap[i].c) {
            r = cmap[i].v;
            break;
        }
    }

    return r;
}

/** initialize the display
/* when the 7seg display is initialized, display nothing */
void init7seg() {
    pinMode(latchPin, OUTPUT);
    pinMode(clockPin, OUTPUT);
    pinMode(dataPin, OUTPUT);

    disp(' ', false, ' ', false, ' ', false, ' ', false);
}

/** this essentially is the library function shiftOut, it can be customized if
/* it is needed.
/* it works with 74HC595 (serial in, parallel out) */
void shiftOut(uint8_t dataPin, uint8_t clockPin, byte val) {
    int i;

    for (i = 0; i < 8; i++) {
        digitalWrite(dataPin, (val & _BV(i)));
        digitalWrite(clockPin, HIGH);
        digitalWrite(clockPin, LOW);
    }
}

/* display the characters on the 7seg
/* the boolean value between characters indicates whether to light up the
/* decimal point */
void disp(char c1, boolean dot1, char c2, boolean dot2, char c3, boolean dot3, char c4, boolean dot4) {
    byte b1 = getCharDisplayCode(c1);
    byte b2 = getCharDisplayCode(c2);
    byte b3 = getCharDisplayCode(c3);
    byte b4 = getCharDisplayCode(c4);

    if (dot1 == true) b1 += 1;
    if (dot2 == true) b2 += 1;
    if (dot3 == true) b3 += 1;
    if (dot4 == true) b4 += 1;

    if (COMMON_ANODE == 1) {
        b1 = 255 - b1;
        b2 = 255 - b2;
        b3 = 255 - b3;
        b4 = 255 - b4;
    }

    digitalWrite(latchPin, LOW);

    shiftOut(dataPin, clockPin, b4);
    shiftOut(dataPin, clockPin, b3);
    shiftOut(dataPin, clockPin, b2);
    shiftOut(dataPin, clockPin, b1);

    digitalWrite(latchPin, HIGH);
}

/** convert a number (maximum 2 digita) to a character array
/* returning the length of the converted char array
/* this is used to convert hour/minutes into characters for display */
int convertToCharAarray(byte num, char *dest) {
    sprintf(dest, "%d", num);

    if (num < 10) return 1;
    else if (num < 100 && num >= 10) return 2;
    else return -1;
}

/** displays the current time on 7seg,
/* the display mode is controlled by the states of the button states */
void dispCurrentTime() {
    if (!bitRead(readbyte(regA), 7)) {
        byte h = readbyte(ADDR_CUR_HOUR);
        byte m = readbyte(ADDR_CUR_MIN);

        byte l1 = convertToCharAarray(h, hour);
        byte l2 = convertToCharAarray(m, minute);

        if (l1 == 1) {
            c2 = ' ';
            c1 = hour[0];
        } else {
            c1 = hour[1];
            c2 = hour[0];
        }

        if (l2 == 1) {
            c4 = '0';
            c3 = minute[0];
        } else {
            c3 = minute[1];
            c4 = minute[0];
        }
    }

    disp(c2, false, c1, secondIndLEDOn, c4, false, c3, false);

    switch (btnMode2) {
        case DM_ADJ_NONE: //normal display mode, displays time
            disp(c2, false, c1, secondIndLEDOn, c4, false, c3, false);
            break;
        case DM_ADJ_HOUR: //if adjust hour, flash the hour digits
            if (secondIndLEDOn)
                disp(' ', false, ' ', true, c4, false, c3, false);
            else
                disp(c2, false, c1, true, c4, false, c3, false);
            break;
        case DM_ADJ_MIN: //if adjust minutes, flash the minute digits
            if (secondIndLEDOn)
                disp(c2, false, c1, true, ' ', false, ' ', false);
            else
                disp(c2, false, c1, true, c4, false, c3, false);
            break;
    }
}

/** displays in stop watch mode. */
void dispStopWatch() {
    for (int i = 0; i < 5; i++) seconds[i] = ' ';

    int i = (int) (((float) (stopWatchCounter) / 128.0) * 10.0 + 0.5);
    sprintf(seconds, "%6d", i);

    if (stopWatchInit) {
        disp(' ', false, ' ', false, '0', true, '0', false);
    } else {
        if (stopWatchCounter < 128) { //less than 1 second, displays the leading 0
            disp(seconds[2], false, seconds[3], false, '0', true, seconds[5], false);
        } else {
            disp(seconds[2], false, seconds[3], false, seconds[4], true, seconds[5], false);
        }
    }
}

/** displays current date */
void dispCurrentDate() {
    if (!bitRead(readbyte(regA), 7)) {
        byte m = readbyte(ADDR_CUR_MON);
        byte d = readbyte(ADDR_CUR_DAY);

        byte l1 = convertToCharAarray(m, month);
        byte l2 = convertToCharAarray(d, day);

        if (l1 == 1) {
            c2 = ' ';
            c1 = month[0];
        } else {
            c1 = month[1];
            c2 = month[0];
        }

        if (l2 == 1) {
            c4 = '0';
            c3 = day[0];
        } else {
            c3 = day[1];
            c4 = day[0];
        }
    }

    switch (btnMode2) {
        case DM_ADJ_NONE: //normal display mode, displays date
            disp(c2, false, c1, true, c4, false, c3, false);
            break;
        case DM_ADJ_MONTH: //if adjust month, flash the month digits
            if (secondIndLEDOn)
                disp(' ', false, ' ', true, c4, false, c3, false);
            else
                disp(c2, false, c1, true, c4, false, c3, false);
            break;
        case DM_ADJ_DAY: //if adjust day, flash the day digits
            if (secondIndLEDOn)
                disp(c2, false, c1, true, ' ', false, ' ', false);
            else
                disp(c2, false, c1, true, c4, false, c3, false);
            break;
        default:
            break;
    }

}

/** displays the current year (e.g. 2010) */
void dispCurrentYear() {
    if (!bitRead(readbyte(regA), 7)) {
        byte y = readbyte(ADDR_CUR_YEAR);

        byte l1 = convertToCharAarray(y, year);

        c2 = '2';
        c1 = '0';

        if (l1 == 1) {
            c4 = '0';
            c3 = year[0];
        } else {
            c3 = year[1];
            c4 = year[0];
        }
    }

    switch (btnMode2) {
        case DM_ADJ_NONE:
            disp(c2, false, c1, false, c4, false, c3, false);
            break;
        case DM_ADJ_YEAR:
            if (secondIndLEDOn)
                disp(c2, false, c1, false, ' ', false, ' ', false);
            else
                disp(c2, false, c1, false, c4, false, c3, false);
            break;
        default:
            break;
    }

}

/** displays the day of the week (e.g. day1 for Monday) */
void dispDayOfWeek() {
    if (!bitRead(readbyte(regA), 7)) {
        byte d = readbyte(ADDR_CUR_DOW);

        convertToCharAarray(d, dow);
    }

    switch (btnMode2) {
        case DM_ADJ_NONE: //normal display mode
            disp('d', false, 'A', false, 'y', false, dow[0], false);
            break;
        case DM_ADJ_DOW: //if adjust day of the week, flash the digit
            if (secondIndLEDOn)
                disp('d', false, 'A', false, 'y', false, ' ', false);
            else
                disp('d', false, 'A', false, 'y', false, dow[0], false);
            break;
    }
}

/** set the clock bus mode
/* INPUT or OUTPUT */
void setClkBusMode(int mode) {
    pinMode(ad0, mode);
    pinMode(ad1, mode);
    pinMode(ad2, mode);
    pinMode(ad3, mode);
    pinMode(ad4, mode);
    pinMode(ad5, mode);
    pinMode(ad6, mode);
    pinMode(ad7, mode);
}

/** read a byte from address */
byte readbyte(byte address) {
    byte readb = 0;

    //set address pins to output
    setClkBusMode(OUTPUT);
    //start READ cycle
    digitalWrite(rw, HIGH);
    //prepare to set address on bus
    digitalWrite(ds, HIGH);
    //delayMicroseconds(1);
    //set ALE high, on fall address latches
    digitalWrite(as, HIGH);

    //set address on bus
    digitalWrite(ad0, bitRead(address, 0));
    digitalWrite(ad1, bitRead(address, 1));
    digitalWrite(ad2, bitRead(address, 2));
    digitalWrite(ad3, bitRead(address, 3));
    digitalWrite(ad4, bitRead(address, 4));
    digitalWrite(ad5, bitRead(address, 5));
    digitalWrite(ad6, bitRead(address, 6));
    digitalWrite(ad7, bitRead(address, 7));

    //set ALE low, latch address
    digitalWrite(as, LOW);
    setClkBusMode(INPUT);
    //finish address setting
    digitalWrite(ds, LOW);
    //wait for data from address
    //set bus for input
    //start reading data
    readb = digitalRead(ad0) | (digitalRead(ad1) << 1) | (digitalRead(ad2) << 2) | (digitalRead(ad3) << 3) | (digitalRead(ad4) << 4) | (digitalRead(ad5) << 5) | (digitalRead(ad6) << 6) | (digitalRead(ad7) << 7);
    digitalWrite(ds, HIGH);

    return readb;
}

/** write a byte to address */
void writebyte(byte address, byte value) {
    //set address pins to output
    setClkBusMode(OUTPUT);
    //start READ cycle
    digitalWrite(rw, HIGH);
    //prepare to set address on bus
    digitalWrite(ds, HIGH);
    //set ALE high, on fall address latches
    digitalWrite(as, HIGH);
    //set address on bus
    digitalWrite(ad0, bitRead(address, 0));
    digitalWrite(ad1, bitRead(address, 1));
    digitalWrite(ad2, bitRead(address, 2));
    digitalWrite(ad3, bitRead(address, 3));
    digitalWrite(ad4, bitRead(address, 4));
    digitalWrite(ad5, bitRead(address, 5));
    digitalWrite(ad6, bitRead(address, 6));
    digitalWrite(ad7, bitRead(address, 7));
    digitalWrite(as, LOW);
    digitalWrite(rw, LOW);
    //set byte to write
    digitalWrite(ad0, bitRead(value, 0));
    digitalWrite(ad1, bitRead(value, 1));
    digitalWrite(ad2, bitRead(value, 2));
    digitalWrite(ad3, bitRead(value, 3));
    digitalWrite(ad4, bitRead(value, 4));
    digitalWrite(ad5, bitRead(value, 5));
    digitalWrite(ad6, bitRead(value, 6));
    digitalWrite(ad7, bitRead(value, 7));
    digitalWrite(rw, HIGH);
}

/** adjust a register value by 1*/
boolean adjust(byte address) {
    //read current value
    byte value = 0;
    byte b;
    if ((address < 0) || (address > 10)) return false;
    if (!bitRead(readbyte(regA), 7)) value = readbyte(address);
    b = readbyte(regB);
    //set SET bit of register B that will prevent double buffer update from internal buffer
    b = b | 0x80;
    writebyte(regB, b);

    if (bitRead(readbyte(regB), 7)) {
        switch (address) {
            case ADDR_CUR_SEC://seconds
                writebyte(address, 0); //reset
                break;
            case ADDR_ALM_SEC://seconds alarm
                writebyte(address, 0); //reset
                break;
            case ADDR_CUR_MIN://minutes
                if (value >= 59) {
                    writebyte(address, 0);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
            case ADDR_ALM_MIN://minutes alarm
                if (value >= 59) {
                    writebyte(address, 0);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
            case ADDR_CUR_HOUR://hours
                if (value >= 23) {
                    writebyte(address, 0);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
            case ADDR_ALM_HOUR://hours alarm
                if (value >= 23) {
                    writebyte(address, 0);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
            case ADDR_CUR_DOW://day of week
                if (value >= 7) {
                    writebyte(address, 1);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
            case ADDR_CUR_DAY:
                if (value >= 31) {
                    writebyte(address, 1);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
            case ADDR_CUR_MON://month
                if (value >= 12) {
                    writebyte(address, 1);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
            case ADDR_CUR_YEAR://year
                if (value == 99) {
                    writebyte(address, 0);
                } else {
                    value++;
                    writebyte(address, value);
                }
                break;
        }
    }

    //mask regA and clear SET bit
    b = b & 0x7F;
    writebyte(regB, b);
    return true;
}

/** interrupt handler routine */
void intr() {
    interruptConter++;

    if (stopWatchStarted) {
        stopWatchCounter++;
    }

    switch (btnMode1) {
        case DM_TIME:
            switch (btnMode2) {
                case DM_ADJ_NONE:
                    dispCurrentTime();
                    break;
                case DM_ADJ_HOUR:
                    dispCurrentTime();
                    break;
                case DM_ADJ_MIN:
                    dispCurrentTime();
                    break;
                case DM_ADJ_MONTH:
                    dispCurrentDate();
                    break;
                case DM_ADJ_DAY:
                    dispCurrentDate();
                    break;
                case DM_ADJ_YEAR:
                    dispCurrentYear();
                    break;
                case DM_ADJ_DOW:
                    dispDayOfWeek();
                    break;
            }
            break;
        case DM_DATE:
            dispCurrentDate();
            break;
        case DM_YEAR:
            dispCurrentYear();
            break;
        case DM_DOW:
            dispDayOfWeek();
            break;
        case DM_STOP_WATCH:
            dispStopWatch();
            break;
        default:
            break;
    }

    //flashes the second indicator (the dot) every half second
    if (interruptConter > 63) {
        interruptConter = 0;
        secondIndLEDOn = !secondIndLEDOn;
    }
}

/*********************
 * Arduino routines
 *********************/
void setup() {
    init7seg();
    pinMode(btnPin1, INPUT);
    pinMode(btnPin2, INPUT);
    digitalWrite(btnPin1, HIGH);
    digitalWrite(btnPin2, HIGH);

    pinMode(as, OUTPUT);
    pinMode(ds, OUTPUT);
    pinMode(rw, OUTPUT);

    //delay after power up to start-up
    digitalWrite(as, LOW);
    digitalWrite(ds, LOW);
    digitalWrite(rw, LOW);
    delayMicroseconds(200);

    // RS3 RS2 RS1 RS0 = 1001 set SQW output frequency to 128 Hz
    byte a = 41;
    writebyte(regA, a);

    byte b = readbyte(regB);
    b = b | 0xF;
    writebyte(regB, b);

    attachInterrupt(0, intr, RISING);
    c1 = ' ';
    c2 = ' ';
    c3 = ' ';
    c4 = ' ';
}

void loop() {
    if (digitalRead(btnPin1) == LOW && !btn1Pressed) {//debouncing btn1
        delayMilliseconds(20);
        if (digitalRead(btnPin1) == LOW) {
            switch (btnMode2) {
                case DM_ADJ_NONE:
                    btnMode1 = (btnMode1 + 1) % 5;
                    break;
                case DM_ADJ_HOUR:
                    adjust(ADDR_CUR_HOUR);
                    break;
                case DM_ADJ_MIN:
                    adjust(ADDR_CUR_MIN);
                    break;
                case DM_ADJ_MONTH:
                    adjust(ADDR_CUR_MON);
                    break;
                case DM_ADJ_DAY:
                    adjust(ADDR_CUR_DAY);
                    break;
                case DM_ADJ_YEAR:
                    adjust(ADDR_CUR_YEAR);
                    break;
                case DM_ADJ_DOW:
                    adjust(ADDR_CUR_DOW);
                    break;
                default:
                    break;
            }

            btn1Pressed = true;
        }
    }

    if (digitalRead(btnPin1) == HIGH) {
        delayMilliseconds(20);

        if (digitalRead(btnPin1) == HIGH) {
            btn1Pressed = false;
        }
    }

    if (digitalRead(btnPin2) == LOW && !btn2Pressed) {
        delayMilliseconds(20);

        if (digitalRead(btnPin2) == LOW) {//debouncing btn2
            if (btnMode1 == DM_TIME) {
                btnMode2 = (btnMode2 + 1) % 7;
            }

            if (btnMode1 == DM_STOP_WATCH && !stopWatchStarted && stopWatchInit) {
                stopWatchInit = false;
                stopWatchStarted = true;
            } else if (btnMode1 == DM_STOP_WATCH && stopWatchStarted && !stopWatchInit) {
                stopWatchStarted = false;
            } else if (btnMode1 == DM_STOP_WATCH && !stopWatchStarted && !stopWatchInit) {
                stopWatchInit = true;
                stopWatchCounter = 0;
            }

            btn2Pressed = true;
        }
    }

    if (digitalRead(btnPin2) == HIGH) {//debouncing btn2
        delayMilliseconds(20);
        if (digitalRead(btnPin2) == HIGH) {
            btn2Pressed = false;
        }
    }
}

Google PAC-MAN

I really admire Google’s creativity and it is actually quite impressive to cramp such a game into just 58K of javascript (http://www.google.com/logos/js/pacman10-hp.2.js) and a small PNG file:

Google PAC-MAN (behind the scene)

Despite its convenience, the Arduino IDE lacks some key features most modern IDEs have. To name a few, the Arduino IDE does not yet support auto-completion, code folding and contextual help. And the integrated parser sometimes have difficulties parsing complex code structures and do not give adequate information for the errors encountered. While it does not matter much for writing simple programs, the drawbacks are obvious when developing more complex applications. Since I am a software developer, I personally prefer a more advanced IDE.

If you are using Eclipse, then there is already a plugin available for AVR development, though I have not personally tried it I have seen other people using it regularly. Looking at the Arduino playground instructions for this plugin, it seems that it is pretty straight forward to set up. But if you are using NetBeans, currently there’s no Arduino support yet.

Luckily, it is actually fairly straight forward to add Arduino support in the NetBeans environment. In this article, I will show you step by step instructions on how to prepare your NetBeans environment for Arduino development purpose.

For those who are impatient and know your way around the NetBeans environment, you can download and install ArduinoPlugin_v1.0.tar.gz (Tools -> Plug-ins, under Downloaded tab, choose add plug-ins) and get started right away. You do need to configure your NetBeans environment to support avr-gcc tool chain before you can start using the Arduino module. If you are unsure how to do this, please read on.

Prerequisite

This plugin requires a functional Arduino development environment. Since this plug-in relies on the Arduino core libraries for code compilation, Arduino must be installed first. You can refer to the Getting Started with Arduino guide on the official Arduino site on how to install the Arduino programming environment.

The instructions in this article assumes that you are running Arduino under Linux, but I think you can adapt it to Windows environment with relatively few changes. Here is a list of the software versions I have installed on my PC.

Ubuntu 10.04 (64bit)
avr-gcc 4.3.4
avrdude 5.10
RXTX-2.2pre2
NetBeans 6.8
arduino-0018

Depending on your particular settings (e.g. the installation path of arduino-0018 is not located under your home directory or it is installed under a different directory name), minor modifications to the template might be needed.

Configure AVR Tool Chain

To setup the NetBeans environment, we need to first setup the AVR tool chain. To do so, first launch NetBeans, navigate to Tools -> Options and click “Add” under C/C++/Build Tools (see screen shot below), and from there we can create a new tool chain called Arduino and configure the paths in the right-hand-side pane accordingly. Here is a screenshot of the tool chain configuration on my system:

Base Directory: /usr/bin
C Compiler: /usr/bin/avr-gcc
C++ Compiler: /usr/bin/avr-g++
Assembler: /usr/bin/avr-as
Debugger: /usr/bin/gdb (this is not important since we do not run Arduino applications within NetBeans anyway)

avr-gcc tool chain setup in NetBeans

In order for the auto-complete feature to work with the Arduino/AVR header files, we also need to setup the paths under the Code Assistance tab. To begin with, you would need to setup the following paths:

~/arduino-0018/hardware/arduino/cores/arduino (assuming that you installed Arduino 0018 under your home directory)
~/arduion-0018/libraries/
/usr/lib/gcc/avr/4.3.4/include

If you use libraries located in other locations, you will need to add those paths to the C/C++ compiler code assistance tab as well.

Install the Arduino Plugin

To install the plugin, download the NetBeans module first (ArduinoPlugin_v1.0.tar.gz). Use the following command to extract the NetBeans Module (ArduinoPlugin_v1.0.nbm):

tar zxf ArduinoPlugin_v1.0.tar.gz

Then go to Tools -> Plugins, under Downloaded tab, choose Add plugins. Navigate to where you saved the .nbm file and click OK.

After installing the plugin, the plugin option screen should look like the following:

Arduino Plugin installed

How to use

To create an Arduino project, go to project new and choose Arduino project template.

Create an Arduino Project

After the project is created, you should see two files (main.pde and makefile) under Source Files folder, and main.pde contains the code skeleton:

#define __AVR_ATmega328P__

#include <binary.h>
#include <HardwareSerial.h>
#include <pins_arduino.h>
#include <WConstants.h>
#include <wiring.h>
#include <wiring_private.h>
#include <WProgram.h>
#include <EEPROM/EEPROM.h>

void setup()
{

}

void loop()
{

}

I tried to make the code structure look as close to that in Arduino IDE as possible, but for the code auto completion to work, some extra includes are needed. Also, note that I have included the MCU definition (#define __AVR_ATmega328P__) to get the the MCU specific intellisense work. You can change this to the type of MCU you are targeting.

Auto Completion

To build your project, right click on the makefile and choose make or make clean. If your build is successful, you should see a HEX file built in the applet directory within your project root. And you can use the Make Target -> upload option to upload the HEX file onto the Arduino board.

Build and Upload

Behind the scene

The Arduino plugin for NetBeans is developed as a NetBeans project sample module. The makefile is adapted from the make file used within the Arduino environment and is discussed here.

I had put some additional comments in places where you might need to edit for it to work with your projects. For instance, your project may link to more modules than the ones listed below.

#Note that if your program has dependencies other than those
#already listed below, you will need to add them accordingly.
C_MODULES = \
$(ARDUINO)/wiring_pulse.c \
$(ARDUINO)/wiring_analog.c \
$(ARDUINO)/pins_arduino.c \
$(ARDUINO)/wiring.c \
$(ARDUINO)/wiring_digital.c \
$(ARDUINO)/WInterrupts.c \
$(ARDUINO)/wiring_shift.c \

CXX_MODULES = \
$(ARDUINO)/Tone.cpp \
$(ARDUINO)/main.cpp \
$(ARDUINO)/WMath.cpp \
$(ARDUINO)/Print.cpp \
$(ARDUINO)/HardwareSerial.cpp \
$(ARDUINO_LIB)/EEPROM/EEPROM.cpp \

Also, I followed the technique used in the Arduino IDE to assemble the sketch with other necessary information and the main program at compile time (see the portion of the makefile below) to keep main.pde as simple as possible. The only issue is that compilation errors are referenced against the assembled source code rather than the code you write in main.pde. I had originally thought about putting all the necessary code in main.pde and thus would not require code merge at compile time, but it would make the code less compatible with the Arduino IDE environment.

#applet_files: main.pde
applet/$(TARGET).cpp: main.pde
# Here is the “preprocessing”.
# It creates a .cpp file based with the same name as the .pde file.
# On top of the new .cpp file comes the WProgram.h header.
# and prototypes for setup() and Loop()
# Then the .cpp file will be compiled. Errors during compile will
# refer to this new, automatically generated, file.
# Not the original .pde file you actually edit…
test -d applet || mkdir applet
echo ‘#include “WProgram.h”‘ > applet/$(TARGET).cpp
echo ‘void setup();’ >> applet/$(TARGET).cpp
echo ‘void loop();’ >> applet/$(TARGET).cpp
cat main.pde >> applet/$(TARGET).cpp

Future Enhancement

Currently, there is no serial port monitor integrated with the NetBeans environment. So if your code uses the Serial class (i.e. Serial.println()), you will have to use the serial monitor bundled with Arduino. This should not be a big issue though, since even in Arduino, you have to click on the Serial Monitor every time after you upload the code to use it any way. I am planning on integrating the serial monitor with NetBeans in the future but it would probably take some time.

Download

Arduino plugin for NetBeans: ArduinoPlugin_v1.0.tar.gz

The following code listing illustrates how to obtain temperature readings from LM19 with an Arduino. The code assumed that the sensor output is connected to Analog 0 pin.

void setup()
{
    Serial.begin(9600);
}

void loop()
{
  float vin = 5.0 * analogRead(0) / 1024.0;
  Serial.print(vin);
  Serial.print("  ");
  float tempC = (1.8663 - vin) / 0.01169;
  float tempF = 1.8 * tempC + 32.0;
  Serial.print(tempC);
  Serial.print("  ");
  Serial.println(tempF);
  delay(100);
}

In the code above, I used the approximated linear transfer function shown below. It is fairly accurate when the temperature range is around room temperature.
\[T_{Celcius} = \frac{(1.8663-V_o}{0.01169}\]

For more accurate temperature measurement over the full operating range, the following equation can be used:
\[T_{Celcius} = \sqrt{2.1962 \times 10^6 + \frac {1.8639 - V_o}{3.88 \times 10^{-6}}} - 1481.96\]

What makes LTC1665/LTC1660 attractive is that the D/A converters addressable via the serial interface. And thus, controlling the eight D/A channels requires relatively few connections with ATmega328p.

The schematic below illustrates how to utilize a D/A channel with input from ATmega328p. Pin IN, SCK, CSLD, CLR can be connected to any pins that accept digital input. And the pin labeled Analog Out outputs the conversion result.

LTC1665CN

The output voltage from the function output() is determined by:
\[Vout = \frac{Vref \times val}{256}\]
for LTC1665 (8 bit), and
\[Vout = \frac{Vref \times val}{1024}\]
for LTC1660 (10 bit). In my example above, Vref is connected to Vcc and is typically around 5V.

The following code uses Arduino to drive the DAC clock. To test the conversion result, the analog output is connected with an Arduino analog input pin.

const int pinIN = 8;
const int pinSCK = 7;
const int pinCSLD= 3;
const int pinCLR =12;

const int pinAnalogOut = 5;

void setup()
{
  pinInit();
  Serial.begin(9600);
  output(1, 64);
  Serial.println(analogRead(pinAnalogOut));
}

void pinInit()
{
  pinMode(pinIN, OUTPUT);
  pinMode(pinSCK, OUTPUT);
  pinMode(pinCSLD, OUTPUT);
  pinMode(pinCLR, OUTPUT);

  digitalWrite(pinCLR, HIGH);
  digitalWrite(pinSCK, LOW);
  digitalWrite(pinCSLD, HIGH);
}

//Performs D/A conversion
void output(long chn, long val)
{
  //the control word is 16 bits
  //the high 4 bits defines the output channel
  long t = chn << 12;

  //the lower 4 bits are don't cares so we make
  //them zeros.
  t = t | val << 4;
  //for LTC1660 it has 10bit resolution this line will
  //need to change to:
  //t = t | val << 2;

  digitalWrite(pinCSLD, LOW);
  for (long i = 15; i >= 0; i--)
  {
    long b = (t >> i) & 1;
    digitalWrite(pinIN, b);
    digitalWrite(pinSCK, HIGH);
    digitalWrite(pinSCK, LOW);
  }

  digitalWrite(pinCSLD, HIGH);
}

void loop()
{
}

The bit resolution difference between LTC1665 and LTC1660 is handled by the code within the output() function.

So, I decided to make a separate ICSP board just for programming ATmega328p. The concept is quite simple, as you can see in the schematics below it basically is a bare bone ATmega328 board with a reset button and ICSP headers. I added an LED to pin 19 (Arduino pin 13) so that if the boot loader is flashed successfully, the LED will blink just as would on an Arduino board. The LED will also serve as an indicator during flashing.

ATmega328p ICSP Board

The following is the board with the ICSP header based on the schematics shown above. This board is not just limited to burning Arduino boot loader or other Arduino programs though, it can serve as a standard template for any ATmega328 based system you build. Ideally, you probably want to replace the standard DIP socket with a ZIF socket so that it is more suitable to be used as a programmer board.

ATmega328 ICSP Board

Here is a picture taken while I was testing flashing boot loader with the bit-banging method. Since I kept the ICSP header pin layout the same as on the Arduino board, I can use the same cable as I used before. You can find more details on how to make the cable and here.

Testing the ICSP board

I decided to add voltage regulation circuitry so that I can use different power sources. The finished ICSP board with case is shown below:

Finished ATmega328 ICSP Board

Here’s another picture of the ICSP board in action:

Finished ATmega328 ICSP Board

And of course, you can also use a regular programmer to program chips on this ICSP board as well.

Before I start, I should mention that according to the product documentation, the normal operation voltage (Vdd) for LIS3LV02DL is between 2.16V and 3.6V. Ideally you should interface LIS3LV02DL with CMOS logic level rather than the standard TTL logic level Arduino provides. In order for the accelerometer to operate within spec, you should lower the Arduino supply voltage to 3.3V and will most likely have to reduce the crystal frequency to 8-12MHz to accommodate the reduced voltage.

That said, the absolute maximum supply voltage (Vdd) for LIS3LV02DL is 6V. So it should be able to withstand the 5V Arduino operates on. I was able to power LIS3LV02DL using Arduino’s power source without experiencing any issues. But, it is definitely not recommended for prolonged use since according to the product documentation:

“exposure to maximum rating conditions for extended periods may affect device reliability.”

I used the method I mentioned previously to mount the chip onto a perf board and soldered on connector pins to make it easier for testing on a breadboard.

My setup is like this:

LIS3LV02DL Accelerometer with Arduino

With LIS3LV02DL pin 3 connected to Arduino digital pin 11, LIS3LV02DL pin 2 connected to Arduino digital pin 12, pin 5 connected to digital pin 13 and pin 6 connected to digital pin 10.

The following is the code to retrieve data from the accelerometer using SPI.

#define DATAOUT 11//MOSI lis3lv02dl pin3
#define DATAIN  12//MISO lis3lv02dl pin2
#define SPICLOCK  13//sck lis3lv02dl pin5
#define CS 10//ss lis3lv02dl pin6, active low

//register addresses
const int REG_WHO_AM_I = 0x0f; //3A
const int REG_OFFSET_X = 0x16;
const int REG_OFFSET_Y = 0x17;
const int REG_OFFSET_Z = 0x18;
const int REG_GAIN_X = 0x19;
const int REG_GAIN_Y = 0x1A;
const int REG_GAIN_Z = 0x1B;
const int REG_CTRL_REG1 = 0x20;
const int REG_CTRL_REG2 = 0x21;
const int REG_CTRL_REG3 = 0x22;
const int REG_HP_FILTER_RESET = 0x23;
const int REG_STATUS_REG = 0x27;
const int REG_OUTX_L = 0x28;
const int REG_OUTX_H = 0x29;
const int REG_OUTY_L = 0x2a;
const int REG_OUTY_H = 0x2b;
const int REG_OUTZ_L = 0x2c;
const int REG_OUTZ_H = 0x2d;
const int REG_FF_WU_CFG = 0x30;
const int REG_FF_WU_SRC = 0x31;
const int REG_FF_WU_ACK = 0x32;
const int REG_FF_WU_THS_L = 0x34;
const int REG_FF_WU_THS_H = 0x35;
const int REG_FF_WU_DURATION = 0x36;
const int REG_DD_CFG = 0x38;
const int REG_DD_SRC = 0x39;
const int REG_DD_ACK = 0x3a;
const int REG_DD_THSI_L = 0x3c;
const int REG_DD_THSI_H = 0x3d;
const int REG_DD_THSE_L = 0x3e;
const int REG_DD_THSE_H = 0x3f;

//axis definitions
const int AXIS_X = 1;
const int AXIS_Y = 2;
const int AXIS_Z = 3;

const int CTRL_REG2_FS = 7;

void setup()
{
  byte b = 0;

  Serial.begin(9600);

  pinSetup();
  initSys();
  b = readRegister(REG_WHO_AM_I);
  Serial.println(b, HEX); //should be 3A

  setScale(1); //set range to 6g
}

void loop()
{
  Serial.print(" x = ");
  Serial.print(getValue(AXIS_X));
  Serial.print(" y = ");
  Serial.print(getValue(AXIS_Y));
  Serial.print(" z = ");
  Serial.println(getValue(AXIS_Z));
}

//transfer a byte using SPI
byte spiTransfer(volatile byte data)
{
  SPDR = data;

  while (!(SPSR & _BV(SPIF)));

  return SPDR;
}

void initSys()
{
  //disable device
  digitalWrite(CS,HIGH); 

  //initialize SPI
  SPCR = _BV(SPE) | _BV(MSTR)| _BV(CPOL)| _BV(CPHA);    

  //enable all axes
  writeRegister(REG_CTRL_REG1, 0x87);
}

void pinSetup()
{
  pinMode(DATAOUT, OUTPUT);
  pinMode(DATAIN, INPUT);
  pinMode(SPICLOCK,OUTPUT);
  pinMode(CS,OUTPUT);
}

byte getGain(int axis)
{
  byte r = 0;

  switch (axis)
  {
    case AXIS_X:
      r = readRegister(REG_GAIN_X);
    break;
    case AXIS_Y:
      r = readRegister(REG_GAIN_Y);
    break;
    case AXIS_Z:
      r = readRegister(REG_GAIN_Z);
    break;
    default:
      r = 0xff;
    break;
  }

  return r;
}

byte getOffset(int axis)
{
  byte r = 0;

  switch (axis)
  {
    case AXIS_X:
      r = readRegister(REG_OFFSET_X);
    break;
    case AXIS_Y:
      r = readRegister(REG_OFFSET_Y);
    break;
    case AXIS_Z:
      r = readRegister(REG_OFFSET_Z);
    break;
    default:
      r = 0xff;
    break;
  }

  return r;
}

void setScale(byte s)
{
  byte r = readRegister(REG_CTRL_REG2);

  if (s == 0) { // 2g
    r &= ~_BV(CTRL_REG2_FS);
  } else { //6g
    r |= _BV(CTRL_REG2_FS);
  }

 writeRegister(REG_CTRL_REG2, r);
}

int getValue(int axis)
{
  int r = 0;
  byte h, l;

  switch (axis)
  {
    case AXIS_X:
      l = readRegister(REG_OUTX_L);
      h = readRegister(REG_OUTX_H);
    break;
    case AXIS_Y:
      l = readRegister(REG_OUTY_L);
      h = readRegister(REG_OUTY_H);
    break;
    case AXIS_Z:
      l = readRegister(REG_OUTZ_L);
      h = readRegister(REG_OUTZ_H);
    break;
    default:
      l = 0;
      h = 0;
    break;
  }

  r = h << 8 | l;

  return r;
}

byte readRegister(byte reg)
{
   digitalWrite(CS, LOW);
   spiTransfer(reg | 0x80);
   byte b = spiTransfer(0);
   digitalWrite(CS, HIGH); 

   return b;
}

void writeRegister(byte reg, byte data)
{
   digitalWrite(CS, LOW);
   spiTransfer(reg & 0x7F);
   spiTransfer(data);
   digitalWrite(CS, HIGH);
}

In the global constants area, I listed all the registers available to LIS3LV02DL. It is relatively straight-forward to use them and you can consult the product documentation for more information. The readRegister/writeRegister are the two main functions to read from and write to the registers defined earlier. getValue returns the accelerometer reading of the axis specified. setScale sets the scale to either 2G or 6G, etc.

Many people are afraid of using LGA components in their projects as these components tend to be difficult to work with. They might be a bit harder to work with than ICs using DIP packaging, but you can easily make an adapter for them using only a standard soldering iron (15W to 30W). And all you need is a steady hand and some patience.

So for the first part of this two-part series, I will share my technique of how to make the LGA adapter using a perf-board. And for my next post, I will show you the programming behind to communicate with the Arduino. The hand soldering method I used here is especially suitable for working with components with only a handful of pins (in this case 16 pins).

1. Preperation

Since the LGA chip is extremely small (see actual size below), it can be damaged easily. So special care must be taken during handling and soldering.

The actual size of LIS3LV02DL

To work with such a small component, you need to clean your soldering iron’s tip and re-surface the tip if necessary so that the tip is at most 1mm in diameter. The soldering iron I used is just a very basic 30W one you can buy from Walmart or RadioShack. A fancier one can probably make life easier, but it is not necessary.

2. Mounting the chip

Without using any special printed circuit board, the best way to deal with LGA components is to turn it upside down and glue it onto the board like this:

LIS3LV02DL glued onto a perf board

Do not use too much glue as excessive glue can get on the soldering pads and make it very difficult to solder later. Usually, a tiny drop of super glue would do the trick. Also, consult the datasheet for pin orientation. The first pin is usually marked on both sides of the chip (in this case it is the tiny dot near the upper left corner, right under the pin pad).

3. Soldering

This is obviously the most crucial step. It is important to remember that the soldering time for each pad must be kept very short (less than half a second) as the soldering area is extremely small, excessive heat can easily cause the pad to detach from the IC and destroying the chip in the process. So if a solder point is not done successfully, wait till it cools down before giving it a second try. It is also helpful to apply a little bit of flux on each pad prior to soldering.

The wire I used to connect the pads is 38 AWG magnetic wire. Generally speaking anything in the neighborhood of 35 to 40 AWG should work just as well. Prior to soldering, use fine sand paper to carefully remove the thin layer of insulation. To ensure that the wire makes good contact with the pad and to reduce soldering time, the wires need to be pre-tined. A uniform layer of solder is also a good indicator of the successful removal of the insulation.

Start from the chip pads. Line up the tinned magnetic wire using one hand and use the solder iron tip to just touch the pad a for a split second. This is usually enough time to fuse the pre-tinned pad and magnetic wire together. Wait for a couple of seconds till the pad cools down and pull the magnetic wire gently to make sure that the soldering was done successfully. Then, solder the other end of the magnetic wire onto the perf-board and cut off the excessive wire. Repeat the above step till all pads are soldered. The finished board should look like this (with headers):

LIS3LV02DL on break-out board with headers

4. The finished breakout board

The finished breakout board can be used as is and you can solder the remaining components onto it to finish up. Or, if you intend to use it with breadboards or sockets, you can solder headers onto the board:

Finished LTS3LV02DL breakout board with male headers

Using similar techniques, you can make adapters for other LGA, BGA or SSOP chips as well. In my next post, I will give some code examples on how to handle the communications between this three-axis accelerometer and an Arduino using SPI.

Stay tuned.

Without further due, here’s the schematics of the 4 digit 7 segment display (click for higher resolution pictures):

4 Digit 7 Segment Display

For finer controls, I left the MR OE pins (pin 10 and 13) unconnected so that they can be controlled by program. But for general use, you can connect pin 10 (MR) to Vcc and pin 13 (OE) to ground so that the output is always enabled.

Here’s the finished display (the letters displayed are “A.S.A.P”)

The display in action (showing A.S.A.P.)

It is fairly straight forward to write programs to interact with the above 4 digit display. The following C code offers a simple method disp() to display letters/digits that are predefined (see the comment section before the code and you will get an idea how to build your own symbols other than the ones included). The four boolean variables (dot1 to dot4) are used to turn on the decimal point on each segment independent of what is being displayed.

//aaaaaa
//f    b
//fggggb
//e    c
//eddddc p

//   abcdefgp ~abcdefgp DEC	~DEC
//1  00001100  11110011 12 	243
//2  11011010  00100101 218 101
//3  11110010  00001101 242 13
//4  01100110  10011001 102	153
//5  10110110  01001001 182	73
//6  10111110  01000001 190	65
//7  11100000  00011111 224	31
//8  11111110  00000001 254	1
//9  11110110  00001001 246	9
//0  11111101  00000010 253	2
//A  11101110  00010001 238	17
//b  00111110  11000001 62	193
//c  00011010  11100101 26	229
//C  10011100  01100011 156	99
//d  01111010  10000101 122 133
//e  11011110  00100001 222 33
//E  10011110  01100001 158 97
//F  10001110  01110001 142	113
//g  11110110  00001001 246	9
//H  01101110  10010001 110	145
//h  00101110  11010001 46	209
//I  01100000  10011111 96 	159
//J  01111000  10000111 120	135
//L  00011100  11100011 28 	227
//n  00101010  11010101 42	213
//o  00111010  11000101 58	197
//P  11001110  00110001 206	49
//q  11100110  00011001 230	25
//r  00001010  11110101 10	245
//S  10110110  01001001 182 73
//t  00011110  11100001 30	225
//u  00111000  11000111 56	199
//U  01111100  10000011 124	131
//y  01110110  10001001 118	137
//-  00000010  11111101 2 	253
//-  10000000  01111111 128	127
//-  00010000  11101111 16	239
//.  00000001  11111110 1 	254
//|| 01101100  10010011 108	147
//=  10010000  01101111 144 111
//=  10000010  01111101 130 125
//=  00010010  11101101 18	237
//=- 10010010  01101101 146 109

int latchPin = 10;
int clockPin = 7;
int dataPin = 3;

//note that for common cathode displays the
//bit values are inverted (see code)
const int COMMON_ANODE = 1; //1 CA, 0 CC

struct CharMap
{
  char c;
  byte v;
};

const int cmap_len = 41;
struct CharMap cmap[] = {
{' ', 0},
{'1', 12},
{'2', 218},
{'3', 242},
{'4', 102},
{'5', 182},
{'6', 190},
{'7', 224},
{'8', 254},
{'9', 246},
{'0', 253},
{'A', 238},
{'b', 62},
{'c', 26},
{'C', 156},
{'d', 122},
{'e', 222},
{'E', 158},
{'F', 142},
{'g', 246},
{'H', 110},
{'h', 46},
{'I', 96},
{'J', 120},
{'L', 28},
{'n', 42},
{'o', 58},
{'P', 206},
{'q', 230},
{'r', 10},
{'S', 182},
{'t', 30},
{'u', 56},
{'U', 124},
{'y', 118},
{'-', 2},
{'~', 128},
{'_', 16},
{'.', 1},
{'|', 108},
{'=', 144}
};

byte getCode(char c)
{
  byte r = 2;

  for (int i = 0 ; i < cmap_len ; i++) {
    if (c == cmap[i].c) {
      r = cmap[i].v;
      break;
    }
  }

  return r;
}

//display c1 c2 c3 c4
//Note the boolean values for dot1 dot2 dot3 and dot4
//indicates whether or not to show the decimal point
void disp(char c1, bool dot1, char c2, bool dot2, char c3, bool dot3, char c4, bool dot4)
{
  byte b1 = getCode(c1);
  byte b2 = getCode(c2);
  byte b3 = getCode(c3);
  byte b4 = getCode(c4);

  if (dot1 == true) b1 += 1;
  if (dot2 == true) b2 += 1;
  if (dot3 == true) b3 += 1;
  if (dot4 == true) b4 += 1;

  if (COMMON_ANODE == 1) {
    b1 = 255 - b1;
    b2 = 255 - b2;
    b3 = 255 - b3;
    b4 = 255 - b4;
  } 

  digitalWrite(latchPin, LOW);        

  shiftOut(dataPin, clockPin,  b4);
  shiftOut(dataPin, clockPin,  b3);
  shiftOut(dataPin, clockPin,  b2);
  shiftOut(dataPin, clockPin,  b1);

  digitalWrite(latchPin, HIGH);
}

void setup7seg()
{
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

  disp(' ', false, ' ', false, ' ', false, ' ', false);
}

void shiftOut(uint8_t dataPin, uint8_t clockPin, byte val)
{
	int i;

	for (i = 0; i < 8; i++)  {
		digitalWrite(dataPin, (val & _BV(i)));
                delayMicroseconds(10);
		digitalWrite(clockPin, HIGH);
                delayMicroseconds(10);
		digitalWrite(clockPin, LOW);
                delayMicroseconds(10);
	}
}

void setup()
{
  setup7seg();
}

void loop()
{
  disp('d',false,'I',false,'S',false,'C',false); //displays the word dISC
  delay(1000);
}

The shiftOut method is actually included in standard Arduino libraries, the reason I included it in my code is that I had to add slight delay between each digitalWrite otherwise the output is not always correct. I suspect this is due to the long wiring I used on the circuit board.

The reason to use Kimio’s method is that no separate AVR programmer is needed as this method essentially turns the Arduino board (the FTDI module on the Arduino board to be precise) into an AVR writer (for more information, please see articles listed here on the Arduino site.)

There seems to be another method (ArduinoISP) that could be used to burn bootloaders onto blank MCUs but I haven’t been able to use it successfully. My understanding is that this method is similar to the FTDI bitbang method in that it generates the signals necessary to burn the bootloader via software. The main difference is that instead of programming the ft232r chip, this method generates the signaling via the MCU itself. The advantage is that no code changes and recompilation is necessary. I am not sure if anyone has had any luck with this method. So please post your detailed step-by-step instructions if you managed to get it to work.

Anyway, I am using Ubuntu 9.10 64 bit. And following the excellent directions mentioned by Nate and David, I got the FTDI bitbang method working on both avrdude 5.3.1 and avrdude 5.10.

There are a lot of variations of commands (covered in the references I listed above) that you can use to invoke avrdude to flash bootloader. Here’s the command I use to burn the bootloader (assuming you are within the directory where you have the FTDI bitbang patched avrdude. The bootloader HEX file and the configuration file are also in the same directory from which avrdude is launched). Note that the baud-rate is defaulted to 115200.

sudo ./avrdude -C avrdude.conf -c duemilanove -p m328p -u -U lock:w:0x3f:m -U efuse:w:0×05:m -U hfuse:w:0xDA:m -U lfuse:w:0xFF:m -U flash:w:ATmegaBOOT_168_atmega328.hex -U lock:w:0x0f:m

And here’s the sample output for a successful run:

avrdude: BitBang OK
avrdude: pin assign miso 3 sck 5 mosi 6 reset 7
avrdude: drain OK

ft245r: bitclk 230400 -> ft baud 115200
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e950f
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
ft245r: bitclk 230400 -> ft baud 115200
avrdude: reading input file “0x3f”
avrdude: writing lock (1 bytes):

Writing | ################################################## | 100% 0.02s

avrdude: 1 bytes of lock written
avrdude: verifying lock memory against 0x3f:
avrdude: load data lock data from input file 0x3f:
avrdude: input file 0x3f contains 1 bytes
avrdude: reading on-chip lock data:

Reading | ################################################## | 100% 0.02s

avrdude: verifying …
avrdude: 1 bytes of lock verified
avrdude: reading input file “0×05″
avrdude: writing efuse (1 bytes):

Writing | ################################################## | 100% 0.02s

avrdude: 1 bytes of efuse written
avrdude: verifying efuse memory against 0×05:
avrdude: load data efuse data from input file 0×05:
avrdude: input file 0×05 contains 1 bytes
avrdude: reading on-chip efuse data:

Reading | ################################################## | 100% 0.02s
avrdude: verifying …
avrdude: 1 bytes of efuse verified
avrdude: reading input file “0xDA”
avrdude: writing hfuse (1 bytes):

Writing | ################################################## | 100% 0.02s

avrdude: 1 bytes of hfuse written
avrdude: verifying hfuse memory against 0xDA:
avrdude: load data hfuse data from input file 0xDA:
avrdude: input file 0xDA contains 1 bytes
avrdude: reading on-chip hfuse data:

Reading | ################################################## | 100% 0.02s

avrdude: verifying …
avrdude: 1 bytes of hfuse verified
avrdude: reading input file “0xFF”
avrdude: writing lfuse (1 bytes):

Writing | ################################################## | 100% 0.02s

avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0xFF:
avrdude: load data lfuse data from input file 0xFF:
avrdude: input file 0xFF contains 1 bytes
avrdude: reading on-chip lfuse data:

Reading | ################################################## | 100% 0.02s

avrdude: verifying …
avrdude: 1 bytes of lfuse verified
avrdude: reading input file “ATmegaBOOT_168_atmega328.hex”
avrdude: input file ATmegaBOOT_168_atmega328.hex auto detected as Intel Hex
avrdude: writing flash (32670 bytes):

Writing | ################################################## | 100% 17.72s

avrdude: 32670 bytes of flash written
avrdude: verifying flash memory against ATmegaBOOT_168_atmega328.hex:
avrdude: load data flash data from input file ATmegaBOOT_168_atmega328.hex:
avrdude: input file ATmegaBOOT_168_atmega328.hex auto detected as Intel Hex
avrdude: input file ATmegaBOOT_168_atmega328.hex contains 32670 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 8.08s

avrdude: verifying …
avrdude: 32670 bytes of flash verified
avrdude: reading input file “0x0f”
avrdude: writing lock (1 bytes):

Writing | ################################################## | 100% 0.05s

avrdude: 1 bytes of lock written
avrdude: verifying lock memory against 0x0f:
avrdude: load data lock data from input file 0x0f:
avrdude: input file 0x0f contains 1 bytes
avrdude: reading on-chip lock data:

Reading | ################################################## | 100% 0.02s

avrdude: verifying …
avrdude: 1 bytes of lock verified

avrdude done. Thank you.

The bootloading process is extremely fast and takes only around a minute to finish.

One thing I found that you need to pay special attention to is that if you are flashing bootloader onto a brand new ATMega328p chip (i.e. it hasn’t been bootloaded before), you will need to do it at a slower baud rate and if you use the above command you will get the following error message:

avrdude: BitBang OK
avrdude: pin assign miso 3 sck 5 mosi 6 reset 7
avrdude: drain OK

ft245r: bitclk 230400 -> ft baud 115200
avrdude: ft245r_program_enable: failed
avrdude: initialization failed, rc=-1
Double check connections and try again, or use -F to override
this check.

If you add the -F switch as suggested by the error message, you will receive this error instead:

avrdude: BitBang OK
avrdude: pin assign miso 3 sck 5 mosi 6 reset 7
avrdude: drain OK

ft245r: bitclk 230400 -> ft baud 115200
avrdude: ft245r_program_enable: failed
avrdude: initialization failed, rc=-1
avrdude: AVR device initialized and ready to accept instructions
avrdude: Device signature = 0×000000
avrdude: Yikes! Invalid device signature.
avrdude: Expected signature for ATMEGA328P is 1E 95 0F
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.

After some investigation, I found out that when bootloading a new chip, the -B parameter is mandatory. The following command (with -B setting) can be used in this case:

sudo ./avrdude -C avrdude.conf -c duemilanove -p m328p -B 1.0 -u -U lock:w:0x3f:m -U efuse:w:0×05:m -U hfuse:w:0xDA:m -U lfuse:w:0xFF:m -U flash:w:ATmegaBOOT_168_atmega328.hex -U lock:w:0x0f:m

But with the -B 1.0 parameter, the flashing process is significantly slower as the baud rate is automatically set to 2400 and it would take about 6 minutes for the whole process to finish.

avrdude: BitBang OK
avrdude: pin assign miso 3 sck 5 mosi 6 reset 7
avrdude: drain OK

ft245r: bitclk 4800 -> ft baud 2400
avrdude: AVR device initialized and ready to accept instructions

…

After some research, it turned out that only the fuse and lock bit settings need to be done at a slower baud rate for new chips. Thus, you can split the command into the following two commands (the first one set the fuse and lock at the slow baud rate, the second one burns the bootloader at the higher baud rate) to speed things up:

sudo ./avrdude -C avrdude.conf -c duemilanove -p m328p -B 1.0 -u -U lock:w:0x3f:m -U efuse:w:0×05:m -U hfuse:w:0xDA:m -U lfuse:w:0xFF:m

sudo ./avrdude -C avrdude.conf -c duemilanove -p m328p -u -U flash:w:ATmegaBOOT_168_atmega328.hex -U lock:w:0x0f:m

So in summary, you can use the above two commands to load bootloaders onto either new chips or chips that already have bootloaders on them. Use the following command on chips that are previously bootloaded only if you want a succinct command:

sudo ./avrdude -C avrdude.conf -c duemilanove -p m328p -u -U lock:w:0×3f:m -U efuse:w:0×05:m -U hfuse:w:0xDA:m -U lfuse:w:0xFF:m -U flash:w:ATmegaBOOT_168_atmega328.hex -U lock:w:0×0f:m

Update:
It seems that someone had managed to get the Arduino as ISP function working, but I haven’t tried it yet.

The following schematic shows a simple dual H-bridge using eight general purpose transistors (2N3904 and 2N3906). Given the maximum Iceo of roughly 200mA, this circuit can be used to drive a small bipolar stepper motor operating between 5V and 12V, such as the stepper motors found in most floppy drives and CD/DVD drives.

A Dual H-bridge

The four control inputs (1,2,3,4) can be driven with Arduino‘s digital pins (i.e. 2,3,4,5) directly. The following program illustrates how to signal the four leads of a bipolar stepper motor for it to rotate. Of course, there’s already a stepper motor library built for this purpose. The program below is helpful when learning the sequence of the pulses required by bipolar stepper motors.

int coila1 = 2;
int coila2 = 3;
int coilb1 = 4;
int coilb2 = 5;

void setup()
{
  pinMode(coila1, OUTPUT);
  pinMode(coila2, OUTPUT);
  pinMode(coilb1, OUTPUT);
  pinMode(coilb2, OUTPUT);
}

void loop()
{
  digitalWrite(coila1, HIGH);
  digitalWrite(coila2, LOW);
  digitalWrite(coilb1, LOW);
  digitalWrite(coilb2, LOW);
  delay(10);

  digitalWrite(coila1, LOW);
  digitalWrite(coila2, LOW);
  digitalWrite(coilb1, HIGH);
  digitalWrite(coilb2, LOW);
  delay(01);

  digitalWrite(coila1, LOW);
  digitalWrite(coila2, HIGH);
  digitalWrite(coilb1, LOW);
  digitalWrite(coilb2, LOW);
  delay(10);

  digitalWrite(coila1, LOW);
  digitalWrite(coila2, LOW);
  digitalWrite(coilb1, LOW);
  digitalWrite(coilb2, HIGH);
  delay(10);
}

Here is a picture of an Arduino controlled CD-ROM stepper motor (the one controlling the tray mechanism) powered by the above dual H-bridge (with an added LED for power).

A CD-ROM stepper motor driven by Arduino