LED Display Over Bluetooth With Android

Old Clock Redux

I came across this neat bluetooth module called HC-06. It can be found as cheap as $6 on ebay, and gives you convenient UART access to bluetooth wireless capabilities.

My 3yr old has this home-made LED clock in his room. I thought it was time for an upgrade since the clock was very minimalistic. Its only function was to keep track of time and display it on the LED panel. And considering it was my first “completed” project with avr (atmega168), I thought I could make it better this time around.

I wanted to make use of bluetooth capability somehow, and thought it would be neat to send a text message to the display. In addition, I decided change up a few things:

• receive bluetooth text message up to 64 chars and scroll it across the panel
• set the time via bluetooth
• consolidate 2 push buttons into 1 for manual time adjustment
• make some noise with the piezo I put in there

The upgrade seems to have worked out nicely. I can send messages to it from my Android phone or from a Linux PC with bluetooth dongle attached. I used iteadstudio’s bluetooth assistant app to send text to the display.

A Simple Demonstration

Again, the source code is available at:

      https://github.com/jbremnant/ledclock.

Setting Up

The HC-06 module needs a bit of setting up before it can be used. On the internet, usually there are two variants of this module: HC-05 and HC-06. AFAIK, the hardware is identical across both modules, but the firmware is not. The main difference is that HC-05 is slave-only, whereas HC-06 can act as both master and slave.

These modules support AT commands which can be used to configure the bluetooth hardware. For example, you can change the passcode used in pairing (default: 1234) or change the baud rate. In order to issue the AT commands against it, you will need to put the chip into CMD mode. The easiest way to interface HC-06 chip is through FTDI over USB. If you own an Arduino or an FTDI breakout, you will need to make the corresponding TX/RX connections from the FTDI chip to HC-06 in order to be able to talk to it. I bought the Arduino bluetooth shield from iteadstudio, which conveniently makes all the pins accessible.

You will need to attach to the virtual device on Linux that represents the FTDI chip. On Ubuntu, that’s usually /dev/ttyUSB0. I use “minicom” for serial comm:

minicom -D /dev/ttyUSB0 -b 38400

But it’s usually good to just run

minicom -s

and configure the serial port manually. Make sure both the software and the hardware flow control is turned off.

Once the connection is made, verify that HC-06 module can respond to the commands. As soon as you type

AT

it should repeatedly send back:

OK
OK
OK
...

Here is the bare minimum AT commands I had to issue to configure the HC-06 module for my setup:

# set as slave
AT+ROLE=0
# set uart baud rate with stopbit, no parity
AT+UART=38400,1,0
# connect to any address
AT+CMODE=1

Once the module is configured, it needs to be reset into “DAT” mode. This is the mode that can send/receive data from master nodes that are paired up against it. Remember that the “CMD” mode is only used for issuing AT commands for modifying the config on the chip.

A Bit About the Hardware & Firmware

The LED panel is relatively cheap, and is sold by Sure Electronics. Its dimension is 8×32, which makes 256 individual LED’s that can be manipulated.  These panels contain a driver chip, HT1632, which makes every LED on the panel addressible with just 3 pins. The source file ht1632.[hc] contains the logic to communicate with the driver chip, and supports rudimentary functions to draw, print limited set of fonts, and scroll text across the panel.

I am a total noob when it comes to PCB design, soldering, and circuitry. The mini breadboard serves me well here. I don’t need to keep highly accurate time, and don’t mind a minute or two drift per year benchmarked against the “true” time. There are a few electrical properties that creates this time deviation. But simply put, this “small” time drift can happen when the oscillations produced by the 32.678kHz crystal is affected by things like inherent capacitance (more like parasitic) in the breadboard, temperature, overall integrity of the circuitry, etc… In any case, I am not overly concerned about accuracy, and this toy is not designed to keep military-grade time!

Only few parts are needed to build the necessary circuit to recreate this:

• 1 atmega168
• 1 HC-06 module (possibly on breakout board)
• 1 32.678kHz crystal oscillator
• 1 push button
• 1 breadboard & couple of jumper wires
• 1 piezo buzzer
• few discrete components: 2 resistors, 1 capacitor
• Lego blocks

And lastly, the firmware. The main source “clockdisplay.c” implements time keeping and processing data received via UART. It keeps track of hours, minutes, and seconds via software using interrupts. The interrupt is triggered each second, and 32.678kHz is chosen precisely for this reason. It has a frequency that is exactly 2^15. Therefore, the hardware counters are much more conducive to scaling by factors of 2. For example, the hardware registers are configured so that the ticks are generated exactly at multiples of 2. The function below sets up atmega168′s timer counters so that the interrupt is generated exactly 1 second apart.

void rtc_init(void)
{
  TCCR2A = 0x02;//clear timer on compare match
  // TCCR2B = (1<  TCCR2B = 0x07; // prescale by 1024, gives 32 ticks
  TIFR2  = 0x02;//clear the interrupt flag
  TIMSK2 = 0x02;//enable timer2A output compare match interrupt
  OCR2A  = 31;  //Set the output compare to 31 since the count starts at 0 - this gives 32 interrups per sec
  ASSR   = 0x20;//enable asynchronous mode, disable this line if you are using the 32khz crystal as a the system clock source
}

Within the interrupt routine, the following function is called to update the global volatile variables that keeps track of hours, minutes, seconds:

void update_datetime(uint8_t noincrement)
{
  if(!noincrement)
    seconds++;

  if(seconds >= 60)
  {
    seconds = 0;
    minutes++;
  }
  if(minutes >= 60)
  {
    minutes = 0;
    hours++;
  }
  if(hours >= 24)
  {
    hours = 0;
    days++;
    if( (days == 32) ||
      (days == 31 && months == (4|6|9|11)) ||
      (days == 30 && months == 2 && leap_year != 0) ||
      (days == 29 && months == 2 && leap_year == 0) )
    {
      days = 1;
      months++;
      if(months == 13)
      {
        months = 1;
        years++;
        if( (years % 400 == 0) ||
          (years % 4 == 0 && years % 100 != 0) )
        {
          leap_year = 1;
        } else {
          leap_year = 0;
        }
      }
    }
  }
}

The interrupt is generated from this auxiliary clock source (crystal oscillator), but what about the execution of the main code block? I use the internal clock on Atmega168 to run the main code, the part that processes UART data, displaying text on LED panel, etc… The mcu is configured to run at 8MHz and this requires fuse settings to be modified. You can run this command to change the fuse bits. (WARN! misuse of this command can brick the chip) Modifying the fuse bits can be done using AVR ISP programmers. I used a cheap clone.


avrdude -F -p m168 -P usb -c avrispmkII -U lfuse:w:0xE2:m


Adding Bluetooth Capability
Here is the clock going through surgery (hopefully for fine enhancements!). Luckily, I haven’t used up the RXD/TXD pins used by Atmega168′s hardware UART (PD0, PD1). The HC-06 bluetooth module will communicate bi-directionally with the host mcu using only these 2 pins.

The UART interface is a standard serial protocol that relies on baudrate. As such, the RXD/TXD can be connected to other devices that can “talk” UART and will be able to communicate with the mcu. In fact, you can hook up the FTDI chip directly in lieu of HC-06 and manipulate this LED clock directly from a terminal. Any other wireless modules that use the UART serial communication could probably replace HC-06.

That’s it! The hardware setup is simple and rest of the communication is then managed by the software on the Android app. The firmware simply accepts characters from the uart library, acts on the command being sent, and then echo’s back some confirmation characters. The uart library for atmega168 is also very simple, and it’s the one I have been using with the nerdkit when I first got into mcu’s.

About these ads