Wise time with Arduino

Scrolling message sign display with Wise Clock 3/4 - part 2

2012-01-28T11:57:00.004-05:00

This post, written some time ago, demonstrated how to make a message sign using two 3216 displays connected to Wise Clock 3. The font used in the demo is 8*8 (actually just 7*7), quite small for the 16 LED height of the display.

The code for a larger (11x14) font is already included in the Wise Clock 3/4 software (file fontLarge.h), ~~just not used~~ and used when the "Big Font" menu option is selected (file AppBig.cpp). ~~I resurrected this forgotten font and the functions that use it~~ and this is how it works:

I modified the original sketch (posted in this thread of the Arduino forum) to include the following lines at the top of the file:

char* msgLine = " Hello world - demo for large font scrolling on dual 3216 display.";
int crtPos = 0;
int crtColor = GREEN;

and the loop() function:

void loop ()

{

displayLargeScrollingLine();

if (crtPos >= strlen(msgLine))

crtPos = 0;

}

The source code for the demo in the video can be found here.

Related posts:

Introducing Wise Clock 4

I2SDv3 - Arduino buckler with microSD

2012-01-20T19:25:00.017-05:00

The Wyolum machine (these are the people who generously offered $3000 in innovation grants, with no strings attached) is forging ahead with a new and improved version of I2SD.
I just received their v3 prototype and it looks impressive. I must say it is the most feature-rich data logger / SD card backpack (here is the list of the competing products that I compared with).

Like its predecessor, I2SD v3 is a software-compatible Arduino (ATmega328/16MHz) with extras. It has on-board microSD card, DS3231 extremely accurate real-time-clock with backup battery, infrared receiver and 2 LED indicators for errors or status.

I2SDv3 comes assembled (all SMD), with the bootloader burnt in. Sketches can be uploaded through the FTDI connector.

The board can be plugged directly into Arduino, using one row of headers (A0-A4-GND-RST), hence the name "buckler" (like a "semi-shield", got it?)
I2SDv3 also offers header access to D4-D7 (v2 lacked that; my complaint was heard :), and it is compatible with the ChronoDot headers.

To test it, I decided to try the OpenLog library, by Nathan Seidle of Sparkfun. Surprisingly, it worked without a glitch from the first try. Well, kind of, I had to read the documentation :), and to change HardwareSerial.cpp, a "system file" (function SIGNAL(USART_RX_vect) is redefined in OpenLog.pde).

To emulate the OpenLog board closer, I changed the code to use D2 for the status LED, as shown:

from

#define STAT1 5 //On PORTD

int statled1 = 5; //This is the normal status LED

#define STAT1 2 //On PORTD

int statled1 = 2; // status LED on I2SDv3;

Note: The second LED of OpenLog board is connected to SCK (D13), so it blinks when the SD card is active (while reading or writing). The second LED on I2SDv3, being on D3, cannot be easily re-purposed.

Following OpenLog documentation, I connected to I2SDv3 using CoolTerm, typed in some text, pressed CtrlZ three times and voila!: file LOG0001.TXT got created and it contained the characters I typed in. Cool indeed.

Note: OpenLog won't compile with Arduino 1.0 IDE without some minor changes, as follows:
1. "WProgram.h" replaced everywhere with "Arduino.h"
2. function SdFile::write(uint8_t) must return size_t now (since it is virtual function defined in Stream.h); both SdFile.cpp and SdFat.h will need to be updated to reflect that.

Reminder: The OpenLog library should work with FAT32-formatted SD cards as well as FAT16. I will test it as soon as I get a 4GB microSD card.

MixiClock - 4 digits displayed on 8x8 LED matrix

2012-01-18T23:52:00.006-05:00

So far, on a 8x8 LED matrix, I have only seen the time displayed with scrolling numbers (beside the geeky binary/hex/tix/dice/dots/bars or other coded formats). There is simply not enough room to statically display 4 digits at once, since the tiniest set of human-readable digits can be defined in a grid not smaller than 3x5 pixels.

I challenged myself to find an intuitive way to display 4 digits on the "standard" 8x8 matrix. I figured that this is possible if using 2 colors. Even though they may overlap a bit (quite literally), digits of different colors can be easily distinguished. This is because the overlap makes a third color: in the case of the bi-color (red/green) LED matrix, it will be orange.

I focused on two aspects:

font definition (3x5) as simple as possible, with minimal number of "on" pixels, but still readable;

// tiny 3x5 digits;

byte digit[10][5] = {

{2, 5, 5, 5, 2}, // 0

{1, 1, 1, 1, 1}, // 1

{6, 1, 2, 4, 7}, // 2

{7, 1, 2, 1, 6}, // 3

{4, 5, 7, 1, 1}, // 4

{7, 4, 7, 1, 6}, // 5

{3, 4, 7, 5, 2}, // 6

{7, 1, 2, 4, 4}, // 7

{7, 5, 2, 5, 7}, // 8

{2, 5, 7, 1, 6}, // 9

};

optimal placement of the digits on the 8x8 matrix, so the overlap is minimal (sometimes 1 pixel, very rarely 2 pixels). The photo below shows the starting point. There is more tweaking of the positions in the code, depending on the combination of digits.

As for the name, there are not too many choices, most of them are already taken, so I hastily settled for "MixiClock" (I am open to suggestions though :).

The sketch, written for my 8x8 bi-color LED matrix shield (also used in the original glass-domed Wise Clock) can be downloaded from here. It should be easy to adapt it to any other RG 8x8 LED matrix. The code also features setting up the clock using two buttons.

As you may have guessed, the top digits (green) indicate the hours, the bottom ones (red) the minutes. The position of the digits changes slightly depending on the combinations, so that there is no overlap or it is minimal (max 2 pixels, and those will be orange). The code is not final and I am sure it can be improved.

As always, comments and suggestions are welcome.

Adventures in WiFly land - Part 1

2012-01-15T20:50:00.000-05:00

This was a bit of a struggle, working with the XBee-footprinted WiFly RN-XV module from Roving Networks.

The goal was to get some data from the RSS feeds, kind of what this project had achieved.

First, I tried to set up the RN-XV module following this crash course (and using ladyada's XBee adapter with the FTDI cable). Everything went fine except connecting to my home WiFi network: I kept getting "AUTH-ERR". Eventually, after many tries, the module joined the network. I thought this is caused by the weak WiFi signal and other people may experience a similar scenario (which should be dealt with by the software).
Then I found with this software library, which, of course, did not work in my special case. After I started tweaking it and read the RN-XV manual once again, I found the explanation: WPA (which I am currently using) handshaking takes more than 1,000ms (1 second), which is the default timeout for the module. The solution was to increase this timeout (to 5000ms) with the command

set opt jointmr 5000

I ended up writing this sketch that makes requests to Yahoo's weather and stock quotes RSS feeds. It should work with the mentioned WiFly library (if they don't keep changing it).

Actually, I had to modify the library a bit too, to include my own specific commands in the initialization procedure. So I created this new function

boolean WiFlyDevice::myInit()

{

if (!enterCommandMode())

{

DEBUG_LOG (1, "Failed to enter command mode");

return false;

}

// turn off remote string;

sendCommand("set com remote 0", false, "AOK");

return sendCommand("set opt jointmr 5000", false, "AOK");

}

then modified begin() to look like this:

void WiFlyDevice::begin()

{

DEBUG_LOG(1, "Entered WiFlyDevice::begin()");

if (!bDifferentUart) SPIuart.begin();

myInit();

}

Another detail worth mentioning is the tuning of the delay between sending the request and reading the response. If this delay is too long, the response buffer gets overwritten, so response data is lost. If the delay is too short, the response is not there yet. Similar consideration while retrieving the response data from the buffer: we need to wait a bit for more data to come before we can say (kind-of) for sure that all data was received.

Next step (Part 2) is to parse the responses to find the correct values we are looking for, temperature and stock price, respectively, then to display them on Wise Clock 4.

Note: The RSS feeds I used are

http://weather.yahooapis.com/forecastrss?w=24153215&u=c

and

http://pipes.yahoo.com/pipes/pipe.run?_id=ZKJobpaj3BGZOew9G8evXg&_render=rss&ticker=INTC

They could be custom-replaced with any other URL that returns a small(ish) set of XML data for easy parsing.

ZeeClock - nice mod running on Wise Clock 4

2012-01-11T20:22:00.004-05:00

Here we have the first "independent" mod running on Wise Clock 4, thanks to Mr. Jon S!

Jon shared the code (download it from here) and added this description:

This is an alarm clock for my toddler who can't tell time (of course). It uses colors to tell him when he should be sleeping and when he should get up.
I didn't need to, but I wrote all the code so it's self contained including setting multiple alarms, setting the time, and turning the audio on and off.
It's not perfect (I'm an artist not a programmer so the code is a bit of a mess), but it does the job.

I think it's a great job!
Thanks again Jon.

Wise Clock 4 - time synchronization with GPS

2012-01-03T18:54:00.002-05:00

This is my first foray into the world of GPS, made possible by the GPS XBee kit.
With Wise Clock 4 offering support for XBee, this little GPS module from seeedstudio seemed like a nice fit. The purpose is, of course, to synchronize the clock with the accurate time received from satellites.

Note: Some time ago I tried the WWVB atomic clock radio receiver module CMMR-6. It comes with a 60mm ferrite rod, pretty inadequate for receiving the Colorado radio signal in Toronto, more than 2200km away. On top of the fact that it is finicky (never worked for me), it is also bulky (the ferrite rod) and fragile (the thin antenna wire).

First, I inserted the module into the XBee adapter from adafruit, which is connected (through the FTDI cable) to a terminal session (9600, 8, N, 1).

Messages started flowing in, right off the bat: wow!

Next, I moved the GPS module onto the Wise Clock 4 and uploaded a sketch that uses TinyGPS library (modified by Justin).

Here is the serial monitor output.

For those who require maximum accuracy on top of the one provided by the DS3231 RTC chip itself, this GPS solution should do it.

Homework
Make the "Doomsday clock", like the one by Wyolum team shown in the video below, with Wise Clock 4 and 2 displays.

Old projects revisited

2012-01-01T11:08:00.002-05:00

I recently had to revisit the (original, glass domed) WiseClock and the SillyClock.

On WiseClock I streamlined the software (download from here) to only show the time and quotes. It also allows the time to be set from buttons as opposed to the Sony TV remote control (the Reset button on the 8x8 LED matrix shield was re-purposed/re-routed). As well, the character set is now defined in progmem as opposed to internal microcontroller EEPROM (font1.h contains the font definition).
The method I chose for setting the time is to show the hours in red and the minutes in green, and alternate between hours and minutes by pressing the left button (now named "Set"). The left button (the former "Reset") is now named "Inc" and connected to A2/D16 (a pull-up 10k resistor is also required), as shown in the photo.

This button is used for incrementing the hours or minutes. Once the right time is set, the clock will revert to displaying the scrolling quotes and time.

On SillyClock, the software (download from here) can now handle the tilt switch (on the "Dual RG bi-color LED matrix shield") and also sound the alarm.
Two hardware hacks are required:

addition of a pull-up 10k resistor on A0;
addition of a piezo buzzer between A1 and ground.

Wise Clock 4 - Using the RTC 1Hz "Heartbeat"

2011-12-17T13:01:00.010-05:00

DS3231 can generate a square wave output signal through pin 3 (aptly named "SQW"). Same pin can be also activated (set low) when one of the two internal alarms is triggered (that's why this pin is also called "INT").

Wise Clock 4 has the INT/SQW pin connected to D2 through a jumper. Therefore, to be able to use this RTC signal, a jumper must connect the 2-header pins, as shown in the picture below (jumper is red, between processor and SD card socket).

Since I don't seem to get things perfect from the first try, I forgot to add the mandatory 10k pull-up resistor (this is fixed in the next iteration of the board, shipping as of mid Dec 2011). Here is how you need to connect the pull-up resistor, as shown in the next photo. Solder one terminal of the resistor in the via (it fits the hole) and the other terminal to the 2-pin header.

Once the hardware is ready, compile and upload this very simple sketch.

#include "WProgram.h"
#include "Wire.h"
#include "DS3231.h"

void rtc_interrupt()
{
Serial.println(millis());
}

void setup()
{
RTC.enableSQW();
Serial.begin(57600);
Serial.println("RTC square wave enabled");
pinMode(2, INPUT);
attachInterrupt(2, rtc_interrupt, RISING);
}

void loop()
{
}

The sketch (tested with Arduino IDE 22) enables the 1Hz square wave on the RTC and attaches an ISR ("interrupt service routine") that gets executed once every second. (You can see the output of the ISR function in the serial monitor.)

Notes:

The square wave is not enabled by default as DS3231 gets powered. To enable the square wave, bit 2 of the register 0x0E must be set to 0 (it is 1 by default).
The square wave frequency can be one of the 4 values: 1Hz, 1024Hz, 4096Hz and 9182Hz. This frequency is selected by setting 2 bits (3 and 4) in control register 0x0E (check page 13 of the datasheet).
The file DS3231.h (also required is DS3231.cpp) is the one included in the WiseClock3 library.

I see at least two applications where this square wave/interrupt line can be used:

RTC alarm waking up the clock from sleep mode;
chronometer.

Data logging with Wise Clock 3/4

2011-12-16T17:30:00.010-05:00

If you ever tried to compile the SD library (packaged with Arduino IDE 22 and 23) targeting the Sanguino board (which also covers Wise Clock 3 and Wise Clock 4), you got compilation errors.

For example, compiling Datalogger.pde with the Sanguino file setup detailed here, will give these kinds of errors:

Datalogger:67: error: 'class File' has no member named 'println'
Datalogger:67: error: 'dataString' was not declared in this scope

The main cause for these errors is missing files (e.g. Stream.h, WString.h). Even if you fix these compilation errors, Datalogger.pde sketch will still not work, and this is because SPI pins are incorrectly defined for Sanguino. (Note that the Datalogger sketch compiles and works fine for Arduino.)

I know that Arduino IDE 22 and 23 are no longer supported, but I bet many out there are still using them, as I do. Until I upgrade to Arduino 1.0, I think it is worth fixing the issue in these older IDEs.

So here is the quick recipe for covering the Sanguino board in Arduino 22 and 23 IDEs:

1. add the following section to Arduino-0022/hardware/arduino/boards.txt file:

##############################
sanguino.name=Sanguino
sanguino.upload.protocol=stk500
sanguino.upload.maximum_size=63488
sanguino.upload.speed=38400
sanguino.bootloader.low_fuses=0xFF
sanguino.bootloader.high_fuses=0xDC
sanguino.bootloader.extended_fuses=0xFD
sanguino.bootloader.path=atmega644p
sanguino.bootloader.file=ATmegaBOOT_644P.hex
sanguino.bootloader.unlock_bits=0x3F
sanguino.bootloader.lock_bits=0x0F
sanguino.build.mcu=atmega644p
sanguino.build.f_cpu=16000000L
sanguino.build.core=sanguino
sanguino.verbose=false

2. Download file sanguino.zip and expand its content into the folder Arduino-0022/hardware/arduino/cores/. This will create the folder "sanguino" under "cores".

Sanguino.zip contains the following files, copied from Arduino-0022/hardware/arduino/cores/arduino/:

Only 2 of these arduino files have been modified specifically for Sanguino, and they are pins_arduino.h and pins_arduino.c.

By following the 2 steps above, you should be able to compile sketches for the "Sanguino" target (selectable from the menu "Tools/Board" of the IDE). (A few extra steps are required to be able to burn the bootloader, but I will leave this out for now, for the sake of simplicity.)

Now try compiling and uploading Datalogger.pde and see the results for yourself: data is appended to the file datalog.txt on SD card.

Note: The Wise Clock 3/4 software handles reading from SD card just fine even with the old Sanguino files because the SPI pins are defined in the file mmc.cpp, which is part of the Wise Clock 3/4 library. The SD library relies on externally-defined (in file pins_arduino.h) SPI pins.

Guess why am I bringing up data logging on Wise Clock 4? :)

Uploading sketches to Wise Clock 3

Buy Complete Wise Clock 4 kit - includes display and enclosure

2011-12-02T07:30:00.003-05:00

When you buy the "Complete Wise Clock 4 kit", you get, on top, of the Wise Clock 4 kit, the 3216 bi-color (red/green/orange) LED display from Sure Electronics, plus the enclosure, consisting of two laser-cut plexiglass plates and the required hardware (spacers, screws etc) to assemble it.

The "complete kit" comes with everything you need to build a functional Wise Clock 4. You will need to add your own FAT16-formatted SD card (with the necessary files on it), the miniB USB power cable and, eventually, the XBee module (if you want Wise Clock 4 to display remote messages, sent through internet, for example).

Wise Clock 3 - Dec 2011 software release

2011-12-01T19:42:00.002-05:00

From the desk of Mr. Ruud, a new software release for Wise Clock 3 is now available.
Below is the long list of impressive features, improvements, changes etc. Ruud, thanks again.

Because of the large number (28) of menu entries the menu is now split in 2 loops, one for the Apps and one for the Settings.

------------------

Apps menu loop:
SETUP, QUOTE, BIG, TIX, WORDS, CNTDN, STOPW, SCORE, PONG, PACMN, TCLOK, UTC, LIFE, DEMO, STATS.

Settings menu loop:
APPS, ALARM, AL+/AL-, DATE+/DATE-, REMI+/REMI-, TEMP+/TEMP-, MESG+/MESG-, CHME+/CHME-, FONT+/FONT-, CELC/FAHR, 24H+/24H-, TIME, Y M D, DAY, SLEEP.

Selecting the "SETUP" menu entry will take you to the Settings menu loop, selecting the "APPS" menu entry
will take you to the Apps menu loop.

------------------

Stopwatch: This will show the time passed by in tenths of seconds, pressing the Set key will show the "lap" time.

Count Down Timer: This timer allows for setting a time of up to 24 hours and will beep 3 times after counting down to 0 seconds.

TIX clock: Showing the time using colored squares (if you do not know what a TIX clock is, Google it!) The PLUS key alows for changing the interval between 1, 4 and 60 seconds.

Time Clock: This allows for recording the amount of time spent on a project. You clock "IN" at the start of the project and clock "OUT" when you are finished for the day. The Time clock will show the total amount of hours and minutes spent on that project over several days. It allows for 5 different projects. A project may be cleared by pressing the Plus key when the "IN?" text is displayed, a future version will store all "IN" and "OUT" times together with the project number in an Excel compatible file on the SD card. This file may then be processed on a PC using Excel.

"Word Clock": This will show the time and date using words instead of numbers. All "words" come from a "word" text file on the SD card and can be changed with any editor. At runtime you may choose from 10 different "word" files. Currently there are 5 different "word" files included:

1. word1.txt The "official" English version showing: "The time is seven minutes past one o'clock in the morning on Monday the fourth of July."
2. word2.txt The short English version showing: "It's one oh-seven am"
3. word3.txt The "funny" English version showing: "It's 5 + 2 past six and you are up early"
4. word4.txt The French texts version showing: "Le temps est sept minutes apres une heure du matin."
5. word5.txt Example file for advertisement purposes, showing texts like: "We are now closed, opening hours are from 9 - 5" or "10% extra discount from 12 - 1".
You may create your own versions with whatever texts/language you like, see the word1.txt file for details.

New large Font: This new proportional font, selected by "FONT+/FONT-", is 14 dots high and has variable width (letter i = 2 dots wide, letter m = 10 dots wide).

The "message.txt" file now contains, 10 different personal messages, the "MESG+" menu entry allows for selecting one of them (M1, M2, M3 etc.).

The "Quotes" menu entry now let you choose from up to 10 different "Quotes" files named quot1.txt, quot2.txt etc. several sample files (like: Texts by Shakespeare, fake alarm system, Spanish lesson, the clock's user manual (what you are reading now = "quot0.txt") are included. If you select the 11th file then the "message.txt" file is displayed which shows e.g. all 10 personal messages, reminders, DST etc.You may put your own "quote" file on the SD card, make sure that lines are not longer then 175 characters and end with a Carriage Return and Linefeed character. The file must be bigger then 512 bytes.

It is now possible to put characters in the non visible "video" ram and make them visible by overlaying the present display in horizontal or vertical mode. When in Big Mode, press the Set Key to see a demo.

The "UTC" mode now allows for changing the number of hours difference (+12 till -12). It allows for showing the time in "Graph" (= analog clock) or "Text" mode. The "Time.txt" file is no longer used and should be removed.

The temperature (TEMP+ menu entry) will now also show the highest and lowest temperature for that day.

The brightness is now changed with the Plus Key and the scroll speed with the Set key. The Set key is used in some of the new apps, but the brightness can always be changed with the Plus Key.

"STATS" menu: This menu entry will show the highest and lowest temperature for the current year, the last time the power went off and the time when the power came back. It may take up to 24 hours before this info is available.

NOTE: The filemanager for the SD card is limited, so if you want to make any change to the files on the SD card then format the SD card first and copy all files in one go to the SD card. Also there cannot be more then 16 files on the SD Card.

Buy Wise Clock 4 kit

2011-11-28T17:43:00.005-05:00

The Wise Clock 4 kit includes the following parts (shown in the photo below):

PCB;
SD card socket (pre-soldered);
DS3231 extremely accurate RTC (real time clock) chip, soldered to the board;
MIC5219 voltage regulator, soldered to the board;
74HC125 level shifter (5V to 3V3), soldered to the board;
2 SMD LEDs (soldered);
3 SMD resistors (soldered);
ATmega644P, with the latest Wise Clock 4 software;
40-pin socket;
16MHz crystal;
2 x 22pF ceramic capacitors;
CR1220 backup battery for RTC;
holder for the coin battery;
3 x right-angle push buttons;
9 x 10k resistors;
3 x 4k7 resistors;
piezo buzzer;
USB miniB connector;
6-pin right-angle male header (FTDI connector);
two 2x8-pin female headers (display connectors);
two 10-pin 2mm female headers (XBee connectors);
220/470 uF electrolytic capacitor;
3 x 100nF decoupling capacitors.

Note that the first bunch of components in the list are SMDs and come soldered to the board (that is, I solder them for you).

US$67, free shipping to North America

Please contact me for pricing to outside North America. (Usually, for Europe, the price is $5 more.)

To build a finished Wise Clock 4, you need to add your own 3216 display, which plugs directly into the board (no cables are required to connect the Wise Clock 4 board to the display). You will also need to build your own enclosure.

Assembling the Wise Clock 4 kit is very similar to assembling Wise Clock 3, shown here. (The few differences between the two kits are related to the XBee, and are very easy to figure out. Regardless, all new components are SMD and they come pre-soldered.)

If you want the "Complete Wise Clock 4 kit", that includes the 3216 display and a simple yet elegant enclosure, please visit this page.

The ATmega644P processor comes already loaded with the latest software, so you don't need to use the Arduino IDE to compile and upload the code. Essentially, after soldering all components in place, Wise Clock 4 should work right away.

Upgrading the software on Wise Clock 4 (when a new release is published) is similar to Wise Clock 3, and this process is detailed here.

Also note that, although Wise Clock 4 has support for the XBee RF wireless modules, no XBee module is included in this kit.

Testing the XBee on Wise Clock 4

2011-11-26T16:21:00.008-05:00

To test the XBee on Wise Clock 4 I used the sketch below (upload it to the board; display is not required).

int nCount = 0;
void setup()
{
Serial.begin(9600);
Serial1.begin(9600);
Serial.println("WC4 XBee ready for comm...");
}

void loop()
{
// read from port 1, report characters on port 0:
while (Serial1.available())
{
char inChar = Serial1.read();
Serial.print(inChar);
}
Serial1.print("WC4 XBee transmit ");
Serial1.print(nCount++);
Serial1.print(", ");
Serial1.println(millis());
delay(3000);
}

Notice the use of Serial1 instance to talk to the XBee, since this is connected to the second hardware serial port of the ATmega644P (D10/D11, pins 16/17). Had Sanguino offered no support for the second USART, we could have used NewSoftwareSerial library.

The second XBee is linked directly to a terminal (e.g. HyperTerminal in Windows, or Terminal panel in the X-CTU application from Digi). I personally used the XBee Adapter from Adafruit, connected through the FTDI cable to the PC as shown here.

Once this XBee test passed, you can adapt the Wise Clock 4 software to display any message sent to it from a second XBee. A simple hack is to add to the function fetchMessage() in file WiseClock4.cpp, as shown below:

void WiseClock4::fetchMessage()

{

// new code for XBee............

// read from XBee into the "personalized message" buffer;

char* Ptr1 = &personalMsg[0];

if (Serial1.available())

{

while (Serial1.available())

{

*Ptr1++ = Serial1.read();

}

*Ptr1 = 0;

}

// existing code................

strcpy(msgLine, " ");

Now, instead of the personalized message (read from file message.txt on the SD card) you will get whatever is sent from the terminal application (second XBee).

Don't forget to add this line in function setup (file WiseClock4.pde):

Serial1.begin(9600);

Dual screen Wise Clock 4

2011-11-24T18:57:00.001-05:00

Using two 3216 displays together is an almost trivial hack. I wanted to make sure it works fine with the Wise Clock 4 board. The video below shows the new board running both "Night and Day" and "Wise Clock 3" (merged into one sketch, of course).

In practice, one can now build the "Dual Screen Wise Clock 4" with the two displays placed on opposite sides (back to back), or one next to the other (as shown in the video). A crazy idea would be to have 4 displays placed in a square :)

"Make: Special Issue: Ultimate Kit Guide" featuring Wise Clock 3

2011-11-18T15:39:00.002-05:00

Thank you for the honor, Make: magazine!

Here is the actual Make: web site dedicated to kit reviews.

Wise Clock 4

2011-11-16T12:45:00.007-05:00

The new Wise Clock 4 board has two main improvements over Wise Clock 3:

support for the XBee family of wireless RF modules (XBee, XBee Pro, XBee Wi-Fi, and the similar foot-printed Roving Networks WiFly RN-XV);
ability to easily connect a second display; this is achieved by moving the power connector on the "right" side, plus bringing the extension display connector closer to the bottom of the board.

Wise Clock 4 is "almost" compatible with Wise Clock 3. To run the existing sketch on Wise Clock 4, two changes are required:

Plus button is now on D3 (D2 is now designated for interrupts from RTC);
D15 is now connected to the CS line of the display, replacing D11, which is now used for communication with the Xbee module.

As can be noticed from the photos, a few more components are in SMD package (necessary to keep the size of the board to a minimum, to fit in the back of the 3216 display):

the level shifting buffer 74HC125;
three optional LEDs: 2 for the XBee communication lines, one for power;
the 3V3 voltage regulator MIC5219, capable of providing 500mA.

Updated Nov 26, 2011
The schematic, pictured below, can be downloaded from here (Eagle file).

The board layout, shown below, can be downloaded from here.

Freebees

2011-11-07T06:29:00.004-05:00

Updated Nov 17, 2011
Added more free stuff at the bottom of the page.
-----------------------------

Purchase any of my kits and you can get one (or more, if you ask nicely :) freebee from this page (just email me with your choice).

I am currently giving away a few "surplus" boards and LED matrices.
Shown below are, from left to right:

PCB for the LED matrix shield;
PCB for Wiseduino rev. 1.7;
PCB for the Dual bi-color LED matrix shield rev 1.4;
PCB for the Dual bi-color LED matrix shield rev 2.0;

You can also get the PCB for DWex, a small Arduino + RTC, that you can make into a DIY pocket/pendant watch. This board is mostly SMD, but not difficult to solder with a little exercise.

Any of the above PCBs can be used as originally intended (for kits), since there is nothing wrong with them (as far as I know). The challenge in building the LED matrix shields is in finding the right matrices (which is almost impossible, since they were "kind-of" custom made for me by a Chinese LED company some time ago). Nevertheless, one can connect other (compatible, that is common cathodes) types of LED matrices with wires, as this project demonstrates.

Next, there are 2 LED matrices. The left one is a 48mm x 48mm common anode RG, named GMA4688C, for which I couldn't find the datasheet. It is easy to figure out the pin configuration by checking the LEDs with a battery (and resistor, of course). The one on the right is a red LED matrix, 58mm x 58mm in size.

Keep an eye on this page as I will update it periodically. I will soon add other components (LEDs, rotary encoders, ribbon cables, terminal blocks etc) and remove the out-of-stock ones.

Also, if you need other parts for your projects, ask and I may be able to help.

Here is more:

SD card (empty) boxes

16-wires ribbon cables

DS1307 (either in SMD SOIC or DIP) + crystal 32,768Hz
2-pin terminal block
small and flat speaker, 16 ohms

LEDs (various shapes, colors and sizes)

rotary encoder (right angle)

laser-cut plexiglass plate (3mm thick) for the dual LED matrix shield

laser-cut plexiglass plate (3mm thick) for the 2416 single-color LED display from Sure

Lexon travel clock

2011-11-06T08:12:00.002-05:00

I am very "productive" lately (or maybe just wasteful with my time): this is my sixth post in as many consecutive days.

I recently "discovered", in a design shop, this great looking travel clock made by Lexon.

Things I like about it:

beautiful shape/form/dimensions (low profile, small, light) and nice finish (brushed aluminum);
apparent simplicity, with just one large(ish) button on the top and the lesser-used buttons placed on the bottom;
LCD screen covering the whole face, showing more than the time (date, day, temperature, alarm);
low consumption; powered by 2 CR2032 batteries, one for the clock, the other for the LCD backlight;
attention to detail is everywhere, including the bottom rubber bumpers: the front ones are higher than the back ones, as seen in the next photo.

This Lexon clock should be good inspiration for clock makers and clock designers.
I hope one day my Wise Clock N will be as great as this is :)

LunaTik "reloaded"

2011-11-05T20:06:00.000-04:00

This is my original post on LunaTik.

Coincidentally (I guess the Apple iPod Nano team thinks that they found the ideal shape and size), the latest, 7th, generation of iPod Nano has the exact same dimensions as the one it replaces (and for which LunaTik was designed). So, LunaTik and TikTok get a new (and well deserved) lease on life, from Apple itself. More, LunaTik is actually mentioned in one of Apple's presentations, officially endorsing the brand. Actually, even the current (6th) generation iPod Nano can be software-upgraded through iTunes with 16 new clock faces (some of them shown in the photo below, courtesy of LunaTik team, sent by email via kickstarter).

But this is not all. As I anticipated, watch "modules" (shown below) are being developed to be hosted by LunaTik. This could become the flagship of the designer watches. Can you imagine high-end watchmakers producing watches that fit LunaTik? How far fetched is to see a custom made-for-LunaTik Omega, for example?

A metal (aluminum) strap is in the works too. This new design, shown in the photo below (also received via kickstarter email) is called "Lynk", and available starting December 2011.

On the other hand, clones have started to pop up (see ebay), at much reduced prices.
I bought, out of curiosity, the black "LunaTik" from a Chinese site for $24. Packaging is identical (and as hard to unpack as the original), the 2-page presentation manual is the same and the two small Allen keys are included as well.

You can't tell until you look at the content. My black "LunaTik" has shiny silvery buckle, scratched aluminum strap stop and white steel socket screws. You get what you pay for. I wouldn't be surprised to see the black layer worn out after a few weeks/days (I may be a little ashamed to wear it in public though).

CubeClock

2011-11-04T21:08:00.007-04:00

This would make a nice replacement for the original glass-domed WiseClock.

I named it CubeClock for the simple reason that it is encased in a baseball display case, found on ebay for about $5.
It includes Wiseduino (with on-board RTC), a LiPo battery shield (I used the one from seeedstudio, but others should work too), a prototype shield with the cheap "orientation sensor" introduced here, and the bi-color LED mini-display shield.

The bottom board is the Wiseduino, secured to the box with 2 screws. The other shields are just stacked on top of each other. The battery shield from seeedstudio, discussed here, uses a 1,000mAh LiPo battery (did not come with the shield), attached to the shield itself with plastic ties. The clock can be turned on or off (to save the battery) from the power switch on the Wiseduino.

CubeClock can also be powered through the USB cable plugged into the battery shield (which also charges the LiPo battery), as shown below.

A closer look is shown in the next photo. The 2 buttons on the mini display shield and the power switch are on the opposite side. They are accessible after the top of box is removed, as is the FTDI connector.

The current sketch running on CubeClock is almost identical to the one on SillyClock (and IllyClock, for that matter), since the mini display shield uses almost the same schematic as the dual bi-color LED matrix shield.
The next release of the software should involve the "2-axis tilt sensor" (already connected on pin A3) to change the display according to its orientation. It could also include the displaying of messages from the 32KB EEPROM on the Wiseduino board (as does the glass-domed WiseClock).

Other ideas:

add infrared receiver (on D2, with interrupt; code picked from WiseClock);
add buzzer (on D16/A2, the only pin left unused at this point) for alarm clock functionality (half-implemented in the software already).

Finding STP16DP05 in DIL package

2011-11-03T09:51:00.000-04:00

It may have occurred to you to find an interesting device with LEDs, only to realize that it uses components that are obsolete and cannot be sourced anymore (or if they can , they may be prohibitively expensive). Such as the case with STP16DP05 in DIL (dual-in-line) package, used in a few kits by EvilMadScience.com and ModernDevice.com. STP16DP05 is a 16-bit LED sink driver still manufactured in SMD, but obsolete (and impossible to find) in "through-hole".

If you want to build such open-source popular kits as "Meggy Jr RGB" or "Peggy 2", you will have to re-design the board, replacing the DIL package with the SMD. What if you already have the PCB and are constrained to use the DIL version? The immediate solution that comes to mind is to use a breakout board with an SMD. Problem is, I couldn't find a breakout to the "narrow", 0.3", DIL format; they are all 0.6" wide.

So, the only choice I had was to use a replacement DIL for the STP15DP05. The first equivalent I found was MBI5026. Only after I received the few I bought (on ebay), I realized they have a different distance between pins (in the metric system). Complete write-off, since I have no chance to ever use these. Their complete name is MBI5026GNS. It never crossed my mind that there is a "metric" standard for ICs in DIL package. Well, lesson learned, but problem still there.
Later, I found out that MBI5026 also comes in the "inch" standard as well. Problem solved, finally.

A second choice would be A6278/A6279. They are pin-to-pin compatible with STP16DP05. Actually these are the LED drivers shipped with the "display board kit" from ModernDevice.com. (And this is how I found out about them, by buying that kit.)

This may not be directly applicable to the kit "business", but another lesson I learned is to design a board for multiple packages of the same IC, thus having a bigger selection for the parts.

Conclusion: pin-to-pin equivalents for the DIL version of STP16DP05 are MBI5026 and A6278/A6279. None of them are offered by digikey or mouser (in DIL format), but you may be able to find them on ebay, expecially the MBI5026. Pay attention to what you order though, since MBI5026 comes in 2 different DIL packages. Anyway, new projects designed around STP16DP05 should not rely on the DIP package. (Note: This is the case of ClockTHREE and C3Jr, both of which use STP16DP05 SMD on breakout boards. Smart.)

LiPo batteries and charger shields - part 2

2011-11-02T09:25:00.004-04:00

This should be an update to a previous post (I am too lazy to edit that nicely).

I bought two LiPo battery shields, one from Seeedstudio, one from cutedigi. None came with a LiPo battery. I guess it is assumed that the user selects the battery that suits his needs. My main need was for a battery that fit between the headers and was lower than the height of the headers, so that another shield can be stacked on top. Guess what: it's not easy to find such a LiPo battery. The round, AA or AAA-compatible ones, are out of the questions because of their size. The only candidates would be those silvery-flat-rectangular ones, as those pictured below.

The best match for the "Solar charger" from seeedstudio is the third LiPo in the photo, with a capacity of 1,000mAh. For comparison, 3 AA rechargeable batteries (1.2V each, making a similar 3.6V) usually have a capacity of 2,200 - 2,800mAh. So this flat LiPo battery would be a bit less than half of the capacity of the space-consuming and heavy pack of 3xAAs.

The next photo shows the LiPo battery installed in the shield.

Updated Nov 4, 2001
The "solar charger" from seeedstudio I have is V1. It is currently discontinued and replaced by "Solar Charger Shield V2". I don't know if there was a technical issue with V1, but my shield has the male headers shorter than the regular size. While building CubeClock, I had trouble with the contacts: some of the signals (A0 and A1, required by the buttons on the mini display shield) did not get passed the charger shield. After some investigation I figured that the charger shield was the culprit, specifically the shorter pins. The new V2 charger shield seems (from the photos) to have solved this issue.

All of the above batteries were purchased from seeedstudio. The second from left in the photo is sold as the "DSO Nano replacement battery" and dimensions were not published at the time. Now you can see it's a bit shorter than the 1,000mAh LiPo and almost 50% thinner.

A nice battery, size-wise and capacity-wise, is the right-most one in the photo. Although it does not fit on the top of the shield (and between the headers), it can be used underneath if you find a method for attaching it (I am still thinking).
Other bigger-capacity LiPos (e.g. 3,000mAh, 6,000mAh) are built by sticking together in shrink-wrap several of the ones shown above.

As for the charger shield from cutedigi, I cannot find an immediate use for it. It can only be used as the top shield, since it does not have extension headers. Also, the space for battery is quite small. The 500mAh LiPo can somehow fit, as shown in the photo below.

The battery would also need to be attached somehow; plastic ties come to mind, maybe this is the purpose of the 6 holes in the board. The 3 LEDs (top-left corner) should be left visible, yet another restriction on placing the LiPo battery. Maybe it's not for nothing that "600mAh" is written in the silkscreen of the board. Cutedigi may have designed this charger shield for a specific battery, which they don't make available.

As always, your comments are appreciated.

From the "fan club" - LindorClock

2011-11-01T00:10:00.002-04:00

Fellow Arduino enthusiast Anjan sent me these photos of his own interpretation of IllyClock, encased in a "compatible" Lindor chocolate case. I think it looks great.

From the email:
I put this one in a Lindor chocolate case and so the name. I had to cut the Lindor case to almost 2/3 rd the height to make it fit and look nice. The front design is still not complete, as you can see the components and wires inside.

He used his own LED matrices with my Dual bi-color LED matrix shield, hence the wires and the prototyping board in the next two photos.

Keep up the great job Anjan. You are an inspiration to others.

Wyolum 2011 Innovation grant

2011-10-29T22:20:00.003-04:00

Here is some motivation for you: Wyolum is offering two "$1,000 Innovation Grant" to the most qualified open source project applications submitted from now until Dec 3, 2011.

From the "news release":

WyoLum, LLC’s mission is to “Promote Open Source Hardware”.
To that end, we are pleased to announce two $1000 (USD) grants to be awarded to the most qualified applicants.

Entries will be evaluated on:
● Innovation
● Originality
● Technical feasibility
● Commercial viability
● Planned use of funds
● Timeline (Projects with goals that can be achieved within six months after the grant is awarded will score more favorably.)

Qualifying projects will be 100% open source (hardware and software) from development through to production. WyoLum team members will be available for advice and assistance throughout your project. If you have a killer idea, but have never fabricated a PCB, programmed a micro-controller or designed an enclosure, don’t let that stop you from submitting your idea. If we can’t immediately assist you, we will learn it together.

Submit completed applications to grants@wyolum.com by December 3, 2011. Applications will be excepted in a combination of video (encouraged), html, .odt, .doc, .docx, blogpost. We will make all reasonable efforts to receive and evaluate your application.

Hacking Meggy Jr. RGB

2011-10-26T21:00:00.004-04:00

You have a Megga Jr RGB "game console" from EMSL and you are tired of playing or writing new games for it. How about making it into a clock?
This takes a bit of hardware hacking on your side; I provide the basic-clock-functionality sketch (download here).
In the end, the "Meggy Jr Clock" will look and work as shown in this video.

Here is a list of what you need (beside an working Meggy Jr):

DS1307 and a 8-pin socket;
crystal (32768Hz);
coin battery (CR1220) and a holder for it;
a small piece of prototyping board;
2 pieces of 6-pin female header;
6-pin right-angle male header;
a few wires.

We will start with hacking the Meggy Jr board, which involves 3 steps:

remove the FTDI connector; you know the drill: desoldering wick, pliers etc;
in place of the FTDI connector solder a 6-pin female header;
connect, with a short piece of wire the 2 points as shown in the picture below.

The hacked Meggy Jr board will look as shown in this photo:

Next, we will build, on prototyping board, the circuit for the real-time-clock based on DS1307, as shown in the datasheet. We will use the 32768Hz crystal and the 3V coin battery (CR1220, with holder).

There are two requirements for the small RTC board we are building:

it will have a pair of 6-pin male headers that plug into the new headers we just installed on the Meggy Jr board;

it needs to fit in the small space above the processor, between the Meggy Jr edges, the buttons and the LED matrix.

So here is how we are going to do it:

- cut the piece of prototyping board to size;

- place it on the spot, above the headers;

- solder the 2 headers (which are already plugged in the female headers);

- place and wire the RTC circuitry;

- solder the new FTDI connector (6-pin right angle male header) at the top of the board, close to the edge (above the old one we removed);

- connect each of the 6 pins of the FTDI connector to the pins of the top header.

The little RTC board you built may look like in the photos below (both sides shown).

Now we put them together (plug the RTC board into the headers) and start testing.

The Meggy Jr Clock we just built will look something like this:

First, make sure the new FTDI connector works, by uploading any sketch.

Next, make sure the DS1307 works as well, by uploading this test sketch.

Once everything looks ok, upload the Meggy Jr Clock sketch.

If you need more detailed instructions, please visit my step-by-step tutorial at instructables.com.

WiseClock / BookClock with I2SD - part 2

2011-10-23T13:35:00.003-04:00

As promised, I am returning with the sketch (download from here).

Justin and Wyolum Co. also promised (wink, wink) that the next revision of I2SD will have the needed digital pins accessible through headers.

This "mixed breed wise clock" is using the I2SD (with on-board RTC and SD card), the display (and idea) from Book Clock, and code borrowed and adapted from Wise Clock 2.

Missing are the user buttons and a tilt switch, which may be connected to the free A0/D15 - A3/D18 pins available on the header of the I2SD board. (Note: The buttons and the tilt switch should be also supported in software as well, code which can be copied from the existing Wise Clock 2 and Book Clock sketches.)

Mixed breed Wise Clock (with I2SD)

2011-10-21T22:54:00.007-04:00

The great I2SD board from Wyolum (also introduced here) offers almost everything one needs to make a simple Wise Clock:

it's an Arduino with ATmega328 (and FTDI connector);
has on-board RTC (DS3231) with backup battery;
has on-board SD card (with the 3V3 regulator and voltage level shifter).

In other words, I2SD is equivalent to Arduino + Adafruit Logging shield, but equipped with a better RTC (DS3231 instead of DS1307). And it is much smaller. And cheaper (I think).

One of the essential ingredients in making the clock is the display. I chose to use the simpler 3208 LED display because it requires only 3 wires (CS, WR, DATA) in addition to the Vcc and GND and it's easier to manage in software (requires less code).

Here I show how to connect the I2SD to 0832 display from Sure Electronics.

First, we need to realize that this is a hack. I2SD was not designed to be used as a full-fledged Arduino. Most of the digital pins are not accessible through headers. Well, in our case, we only need access to 3 digital pins. It just happens that D5, D6, D7 and D9 are connected to some test points, basically holes where we can solder wires. It also happens that in other 3208-related sketches, I used these almost same pins as well. So, we will connect the nicely aligned D6, D7 and D9 to DATA (pin 7), WR (pin 5) and CS2 (pin 1), respectively, as shown in the photos.

The rig is a helper for the display connector. If you want to follow the same idea, this is the sequence of actions:

solder the 3 wires to the I2SD board, on the top side;
on the rig board, solder the connector (near the side) and the wires (to pins 1, 5, 7, 15 and 16);
solder the three I2SD wires (D6, D7, D9) to the rig.

It is now time to run the test sketch. It requires a small change in line 31, where we replace 8 with 9 (as I said earlier, we are using the easier-to-access D9 instead of the usual D8).

Note: Make sure you know how to handle the 3208 display you have, since there are two different types (see this post).

Now that Test_3208.pde runs successfully, we will work on integrating the SD card and RTC into the software (which shouldn't be a problem, since I will just copy chunks of tested code from the older sketches). The clock will alternate between displaying the quotes from SD card and displaying the time from RTC. Stay tuned.

PS It's worth mentioning that even with this hack applied, I2SD can still be used as initially intended: none of the headers was taken over and all connectors are still accessible. Nice and clean hack :)

Related posts:

I2SD kit

How to make a cheap two-axis tilt sensor

2011-10-15T22:35:00.006-04:00

I am sure many of you will find this trivial, but since I couldn't see any reference to something similar, I thought I should document it.

This hack allows you to measure tilt with a 90 degrees "accuracy" in a vertical (or I should say "non-horizontal") plan, basically to determine the orientation "up", "down", "left" or "right".

You will need 2 simple tilt switches and 3 resistors, wired as in the schematic below and assembled on a piece of prototyping board as shown in the photo.

It is important to place the 2 tilt switches as shown, 45 degrees on each side of the "vertical" axis. The little board now becomes the "2D tilt sensor". It is shown connected to the Arduino with 3 wires: Vcc (red), GND (black) and A1 (white-orange). I used axial tilt switches, but radial (as those sold by adafruit) work as well.

The voltage on analog input A1 of Arduino is dependent on the orientation of the 2D tilt sensor. I selected the value of the resistors so that the voltages are spread as much as possible over the 5V range.

Basically, by closing any or both of the switches, unique voltage dividers will be created. By reading the voltage on the analog pin we can easily figure out the orientation of the 2D tilt sensor.

Here are the 4 possible combinations:

S1 open, S2 open: A1 = 0V
S1 close, S2 open: A1 = 1.6V
S1 open, S2 close: A1 = 2.5V
S1 close, S2 close: A1 = 3V

As always, comments are appreciated.

Difference between 3208 and 0832 LED displays from Sure Electronics

2011-10-07T19:16:00.005-04:00

Many people are building stuff using the 3208 LED display from Sure, based on projects I have shown here (e.g. BookClock). The test code I published doesn't work "out of the box" with these newer displays. So they ask the question: why? Here is the answer.

The "older" 0832 LED display uses the HT1632 chip. The "newer" 3208 (which comes with either 3mm or 5mm LEDs) uses the slightly different HT1632C chip. (Note that HT1632C chip is also used in the bi-color 3216 displays.)
The difference between these two chips, from the software perspective, is in the initialization procedure.

Here is part of the ht1632_setup() function for the 0832 display (with HT1632):

ht1632_sendcmd(HT1632_CMD_SYSDIS); // Disable system
ht1632_sendcmd(HT1632_CMD_COMS10); // PMOS drivers
ht1632_sendcmd(HT1632_CMD_MSTMD); // Master Mode
ht1632_sendcmd(HT1632_CMD_SYSON); // System on
ht1632_sendcmd(HT1632_CMD_LEDON); // LEDs on

And here is the similar code for the 3208 display (both the 3mm and 5mm versions, only the LED matrices are different) with HT1632C:

ht1632_sendcmd(HT1632_CMD_SYSDIS); // Disable system

ht1632_sendcmd(HT1632_CMD_COMS00);

ht1632_sendcmd(HT1632_CMD_MSTMD); /* Master Mode */

ht1632_sendcmd(HT1632_CMD_RCCLK); // HT1632C

ht1632_sendcmd(HT1632_CMD_SYSON); /* System on */

ht1632_sendcmd(HT1632_CMD_LEDON); /* LEDs on */

I2SD kit

2011-10-01T12:09:00.004-04:00

A while ago I received the good-looking I2SD kit from Wyolum. This is another open source project created and generously shared by the same team that brought us ClockTHREE and C3Jr.

The I2SD kit is pictured below. As you can see, it is mostly SMD (0805 and SOIC packages). Not for a novice, but definitely easy to solder by anyone with a steady hand and a good pair of eyes.

As always, when I assemble a kit, I try to skip the "read the manual" part. I don't recommend this to anyone though. This is just a test for me to assess how user-friendly the kit is. (Note: Ironically, this test would fail for my own Wise Clock 3 kit because of the 3 resistors of 4K7. One really need to know exactly where those resistors go (R5, R6 and R7). An improvement in a future version of Wise Clock 3 would be to have the resistor values on the silkscreen, as C3Jr has.)
Well, the I2SD kit passed the "no manual required" test, which means that the kit is well thought and designed. Again, if you are not sure what you are doing, you should not attempt building this kit without reading the documentation first.

The next photos show the top and bottom sides of the assembled I2SD, with the SD card inserted into the socket.

As you can notice from the photos, I2SD has an on-board ATmega328, thus making it an (software-wise) Arduino-compatible. It also has an SD socket, an RTC chip (DS3231) with backup battery, and the 6-pin FTDI connector.

The I2SD was designed to be used as an Arduino storage peripheral, linked with Arduino devices on I2C.
For this purpose, the I2SD runs a sketch that:
- receives "read" commands from a host and returns the required data it reads from the SD card file;
- receives "write" commands from the host and stores the data in the SD card file.

As mentioned above, the I2SD itself can be used as a standalone Arduino (since the ATmega328 has the bootloader). To test it, I uploaded (with the Arduino IDE 22) this sketch which writes to the file TEST.TXT on the SD card.

I2SD can be integrated within many devices requiring data storage and retrieval, ranging from data logging (the RTC chip is definitely helping here), to system configuration, image capturing etc.

Wise Clock 3 with Duino644

2011-09-20T19:30:00.005-04:00

Let's start with a bit of "history".
Duino644 was designed to match with (plug into) the now-discontinued 2416 mono-color LED display from Sure Electronics.
Wise Clock 3 board was designed to plug into the 3216 bi-color LED display from Sure.
Both boards have a similar schematic, based on ATmega644, and they share similar features: RTC (DS3231) on I2C, SD card, piezo buzzer, 3 user buttons.

There are a few differences between the 2 boards:

Duino644 has IR receiver, connected on D2, whereas Wise Clock 3 has the Plus button on D2 and no IR receiver;
Wise Clock 3 has D11 connected to pin 2 (CLK) of the 3216 display; on Duino644, since the 2416 display does not require an input on pin 2, D11 is not connected.

Our goal is to adapt the "old" Duino644 board to the 3216 bi-color LED display and run the Wise Clock 3 software on it. This is easily achieved by doing the following hardware hacks:
1. connect the processor's pin 17 to pin 2 of the display's connector (red wire in the photo);
2. solder a bridge between processor's pins 3 and 4 (also visible in the photo);
3. cut out the IR receiver.

Now upload the Wise Clock 3 sketch (download latest version from here).
Plug the Duino644 board into the 5mm display, as shown in the photo above, then power it with the USB miniB cable. Surprisingly, the ensemble looks pretty functional and practical as it is: the buttons are accessible at the top (albeit a bit deep), the board is flush with the display, and the power (USB) socket is on the right side.
The enclosure could be a similar pair of plexiglass plates as used in Wise Clock 3. This bigger Wise Clock 3 would be more suitable to be hang on a wall (rather than sit on a desk).

Note that the Duino644 I tested uses DS3231. A version with DS1307 should work the same (except it will show 0 as the current temperature, I think).

As always, feedback is appreciated.

Wise Clock 3 with 5mm LED display

2011-09-18T10:25:00.006-04:00

I recently bought the 5mm LED display from Sure Electronics (same datasheet as the 3mm LED display), just to see how it would work with the Wise Clock 3 board (so I can answer the questions related to this combination).

As expected, just plug the Wise Clock 3 board into the "INPUT" connector of the display (as shown in the photo below), and everything should work. Since you may not want the board to stick out, a better solution would be to connect the two using the ribbon cable provided with the display (you would need to replace the 2x8-pin female header with a a 2x8-pin male header on the Wise Clock 3 board though).

This is a huge display. I think it may be visible from 30 meters away (can you imagine Wise Clock 3 in a public plaza?!).

Save on other technologies by using Lenovo coupons.

Related posts:

Introducing Wise Clock 3

ClockTHREE v2

2011-09-14T18:25:00.007-04:00

Although ClockTHREE v2 is yet to be officially introduced by the Wyolum team, I could not resist the temptation of showing off this beautiful new board.

Compared with v1, v2 has a few new features worth mentioning:

it can accommodate both piranha RGB LEDs and 10mm RGB LEDs (common anode);
as real time clock, supports DS1307, DS3231 and ChronoDot and wyolum's own rtcBob;
three kinds of different coin battery holders (for RTC backup battery) are supported;
the power socket can be mounted in 3 different places;
no more tweaking of the terminals is required when using the 10mm RGB LEDs.

The other great features are intact:

- relatively easy to build for such a large and complex kit, with well-written documentation, both on-line and on PCB's silkscreen;

- Arduino (ATmega328)-compatible: uses Arduino IDE for sketch upload;

- display consists of 16x10 RGB LEDs + 16x2 single-colour LEDs;
- on-board speaker/buzzer for the alarm;

- word-clock functionality, user-settable time and date etc.

An assembled ClockTHREE v2, with piranha LEDs, is shown in the photo below.

A new baffles design is in the works.
Should be offered in the store anytime now.

ClockTHREE completed

Night and Day add-on kit

2011-09-13T04:40:00.008-04:00

Want to build the Night and Day clock as shown by Justin?

Here is how we can help (and this is the exact reason why we described Wise Clock 3 as "highly hackable"):

1. If you already have Wise Clock 3, buy just the "Night and Day add-on kit", which includes

the world map printed on thick velum paper;
one thin (1.5mm) transparent acrylic laser-cut plate;

You will need to upload the Night and Day sketch yourself (read about the process here).

2. If you don't have Wise Clock 3 already, you can order the "Night and day add-on kit" alongside either the board kit or the complete kit. In this case, we will upload the sketch onto the processor for you.

Rechargeable battery shields for Arduino - a quick review

2011-09-01T08:18:00.002-04:00

Update Nov 2, 2011
Find an update to this post here.

Some time ago I purchased several shields for powering Arduinos from Li-Ion batteries.
They are:

5V DC-DC step-up power pack from nuelectronics.com
Li-Ion battery shield from cutedigi.com
Solar charger shield v0.9 from seeedstudio (no longer offered and replaced by v2.0).

My main requirement for such a shield was to have Arduino-form factor, so that I can just plug it into the Arduino, with no extra work required. Ideally, it would also have an on-board (attached) battery of at least 1000mAh.

Considering that the height of the headers in an Arduino shield is about 8mm and the space between them is about 43mm, the dimensions of the battery should not exceed 50mm x 43mm x 8mm.

None of the three solutions presented here met this requirement, at least not without modifications.

1. 5V DC-DC step-up power pack

This "power pack" shield comes with an on-board (attached) 1500mAh Li-Poly battery. The battery is wider than 43mm, so the headers are not (and cannot be) present. Therefore, the shield is not plug-able, which would technically disqualify it as an Arduino shield.

The "power pack" shield has the Arduino form factor though, with the matching 3 mounting holes, so it can be attached to the underside of an Arduino. (Note: Wiseduino's mounting holes are not aligned with those on Arduino 2009/Uno).
A schematic is not provided.

2. Li-Ion battery shield

It uses EUP8054 "linear Li-Ion battery charger with thermal regulation" chip. Schematic of the shield is provided here.

This battery shield does not come with a battery, but it has 6 big mounting holes that "can help you easily fix the battery pack". I could not find any photo (for inspiration) of the shield with batteries attached.

As shown in the photo above, the battery shield does not have the expansion female headers. It can be plugged into the Arduino, but no other shield plugged on top of it.

3. Solar charger shield V0.9

Seeedstudio discontinued this shield and replaced it with "Solar charger V2.0" (they also have a cheaper, non-shield version, the "Li-Po Rider").

This charger shield uses CN3083 chip. Schematic is published here and documentation can be found here.

The shield does not come with a battery, but it has the expansion headers installed. As expected, the ubiquitous, 68mm x 48mm flat Li-Ion 2000mAh battery (pictured connected to the shield in the photo above) does not fit between the headers, so stacking this shield only works with a smaller (both capacity and dimension-wise) type of battery, probably this 1000mAh one (50mm x 35mm x 5mm).

This battery shield would be the closest to my requirement, only if it had a battery.

Other battery chargers, shields or not, that I did not investigate yet are:

Lithium backpack from Liquidware - looks beautiful
USB LiPoly charger from Adafruit - not a shield
USB/DC LiPoly battery charger 5-12V, also from Adafruit - not a shield
USB LiPoly charger from Sparkfun - not a shield

New in store: Bi-color LED mini-display shield

2011-08-25T11:36:00.010-04:00

This is my third and newest LED display shield for Arduino. It features two 8x8 RG (red/green/orange) 3mm LED matrices and it has the Arduino form factor, so it stacks perfectly on top of an Arduino 2009/Uno.

This Bi-color LED mini-display shield uses a similar schematic as my other Dual LED matrix shield, based on four 595 shift registers and a driver, in SMD package. The two 8x8 RG LED matrices plug into the machined (round) female headers.

The photo below shows all 3 LED shields together for size comparison, along with an Wiseduino.

This LED mini-display shield also features 2 right-angle micro push buttons.

The LED mini-display shield comes fully assembled and tested.

The LED mini-display shield can be seen in this video, plugged into an Arduino running a test sketch.

The source code used in this demo can be found here.

Images of the schematic (download Eagle file) and board (download Eagle file) can be seen below.

Wise Clock 3 User manual

2011-08-23T13:44:00.000-04:00

I was finally able to put together a brief "user manual" for Wise Clock 3, which is also the last step of my "Wise Clock 3" instructable.

Here it is, below, cut and pasted from the instructable.

Wise Clock 3 has 3 buttons, named (in the silkscreen on the board) "Menu", "Set" and "Plus". The "Menu" button is the rightmost one as you face the clock, "Set" is the middle button.

By pressing the "Menu" button, the menu options are shown at the top of the screen, in sequence. A menu option is selected by pressing the "Set" button. Some of the menu options (e.g. "Time", "Date") allow the user to set values, for example the time, the date etc. To increment these values, the user presses button "Plus".

1. Set up the time
- press "Menu" repeatedly until the option "TIME" is shown;
- press "Set": now, one of either hours or minutes will start blinking;
- press "Plus" to increment the blinking value; for hours, next value after 23 is 0; for minutes, next value after 59 is 0;
- to change between setting (blinking) hours and minutes, press "Set";
- after the desired time is set (values for hours and minutes are on display), wait about 4 seconds for the blinking to end; this is the time now stored by the clock.
Note: The value for seconds is always set to 0 every time the value for hours or minutes is incremented.

2. Set up the date
- press "Menu" repeatedly until the option "DATE" is shown;
- press "Set": the top part of the display will show "Y M D", and the bottom part will show the date, in the format "YYMMDD" (year/month/day);
- press "Plus" to increment the blinking value; for years, next value after 50 is 0; for months, next value after 12 is 1; for days, next value after 31 is 1;
- to change between setting (blinking) year, month and day, press "Set";
- after the desired date is set (values for year, month and day are on display), wait about 4 seconds for the blinking to end; this is the date now stored by the clock.

3. Set up the day-of-week
- press "Menu" repeatedly until the option "DAY" is shown;
- press "Set": now the bottom half of the display will show the first three letters of the day of the week (e.g. Mon, Tue etc);
- press "Plus" to increment the day;
- after the desired day is reached (shown on display), wait about 4 seconds and the "DAY" option will be exit automatically; this is the day now stored by the clock.

4. Set display brightness
Every time the "Set" button is pressed in one of the main display modes ("Quotes", "Pong", "Pacman", "Big"), the brightness of the LEDs increases one level (out of 5 levels); next after the highest brightness level is the lowest level.

5. Set quote scrolling speed
To increase the speed of the scrolling, press the "Plus" button when in the mode "Quote". There are 5 speeds. Next after the highest speed comes the slowest.

6. Display modes
Changing the display modes is done by pressing the "Menu" button, then selecting the mode shown by pressing the button "Set".
The main mode is "Quote", which displays scrolling quotations, read from SD card, on the half top of the screen.

Other modes are:
- "Pacman" - Pacman passes by every minute;
- "Pong" - as in the old-days tennis game console; hours and minutes are displayed on both sides of the net, at the top of the screen, and change when a player "loses", every minute, of course;
- "Big" - hours, minutes and seconds are displayed on the whole screen, in may different fonts;
- UTC (universal time), useful for radio amateurs;
- "Score" - allows keeping the game's score between two players, between 0 and 99.

7. Clock settings (options)
Beside the current time, Wise Clock 3 can also display:
- current date, formatted as "Month Day, Year"; this setting is enabled/disabled through the "DT+"/"DT-" menu options.
- temperature, in both Celsius and Fahrenheit; this setting is enabled/disabled through the "TEMP+"/"TEMP-" menu options.
- a personalized, user-editable message, read from SD card (e.g. "Happy Birthday dear John"); this setting is enabled/disabled through the "MESG+"/"MESG-" menu options.
- reminders for special events (anniversaries, Christmas etc), also user-editable on SD card; this setting is enabled/disabled through the "REMI+"/"REMI-" menu options.
- hours as maximum 12 or 24; this setting is enabled/disabled through the "24H+"/"24H-" menu options;
- enable/disable chime (short beep at the bottom of the hour, double beep at the top of the hour), by selecting "CHME+"/"CHME-" respectively.

Note: Menu will no longer show entries which do not make sense, like "DATE+" when the Date is already on.

8. Set up the alarm time
Alarm time can set through the menu option "ALARM". Press "Menu" button until you reach this option, then press "Set". From here on, the process is the same as setting up the time (point 2 above).

When alarm time is set and the alarm is active/enabled, the hours and minutes are separated by a colon, e.g. 15:43. If the alarm is disabled, a dot is used to separate the two, e.g. 15.43.

Another alarm-related feature: 3 hours before the alarm goes off, the time is displayed in orange, 2 hours before the alarm goes off in red; otherwise, time is displayed in green.

9. Enable/disable the alarm
The alarm is activated (will sound) only if the alarm is enabled. Enable/disable the alarm by selecting the "AL+"/"AL-" menu option.

When the alarm goes off, the clock plays "Frere Jacques", followed by a siren. The alarm can be stopped (silenced) by pressing any button.

10. Displaying reminders
At startup and at midnight the "message.txt" file is scanned for any reminder for that new day. An orange dot is displayed at the bottom during this scan. If a reminder is found then it will be displayed, like the quotes, for the next 24 hours.
The message file may also contain the start and end date of the Daylight Saving Time period (DST), this will adjust the clock by 1 hour.
The personal Message is still contained in this message file but must now start with [M1] which will allow for more then 1 Personal Message in a future release.
See message.txt for more details and add your own reminders.

DIYGeigerCounter now completed

2011-08-07T22:22:00.006-04:00

Today I found the time to complete the great DIYGeigerCounter kit-based project, started a while ago.

As I was writing then, assembling it was a breeze, even though the kit I had, courtesy of BroHogan, was version 1.0. The Geiger counter worked nicely as soon as I powered it from (approx 5V) battery: the buzzer clicked and the LED flashed, even faster when the radioactive mantle was nearby. And this is where I stopped.

But the DIYGeigerCounter kit also offers the smart option of interfacing with an on-board microcontroller, specifically ATmega328, thus making it the cheapest Arduino-based Geiger counter available (compared to the Radiation shield from Libelium or Geiger counter from Sparkfun).

To finish this project, all I had to do was:

connect the LCD display as detailed here;
compile the software, provided here, and upload it;
find or make a practical enclosure;
assemble everything together.

The result is shown in the photo below.

The case is a cheap and sturdy plastic box, branded "Really Useful Box, 0.55 liters", bought a few years ago from Staples (it may still be available for sale). The lid is tightly held in place by the two blue side-handles.

A prototyping PCB provides the base for the main board, the LCD and the Geiger tube (I also added an FTDI connector, for software upgrades). The batteries, 4 rechargeable AAs, are connected to the board through a toggle switch (on the left side).

Should make for a handy Geiger counter anytime I get solicited by friends :)

A future extension (but realistically, a new project) would be adding logging capabilities, as documented here.

Related posts:

My Geiger counters

IllyClock revisited - the minimalist look

2011-08-03T19:48:00.007-04:00

Remember IllyClock, the Arduino-alarm-clock-in-a-coffee-can (featured on Instructables.com)?

We now have a new streamlined version, featuring rechargeable battery shield, tilt switches, infrared receiver, buzzer.
Although some of the "cool factor" is lost, this version is easier to build, a bit more practical (it is "portable") and smarter (with new, extended, software).

It was just a matter of time until someone would prefix the name IllyClock with an S. I wanted to be the first one on the record to do that; so from now on, we'll name this new version SillyClock.

NOTE: One more reason to call it "silly". I wrongly assumed that the previous IllyClock sketch, referencing a rotary encoder, would work without modifications with the new dualRG LED matrix shield, which has the rotary encoder replaced by two buttons. My apologies to anyone whom I misled with my assumption. The modified code can be downloaded from here. This file contains the sketches for both IllyClock (with rotary encoder; identical with the old code) and SillyClock (with 2 push buttons).

SillyClock is built using:

Wiseduino+ (Arduino-compatible, with ATmega328, has on-board DS3231 real time clock and 256KB of EEPROM);
dual RG LED matrix shield (has on-board tilt switch, two push buttons and infrared receiver);
Li-Ion battery shield (third party, there are many out there to chose from);
a second tilt switch and a piezo buzzer, both placed in the proto-area of Wiseduino+;
two laser-cut plexiglass plates (plus standoffs, screws and nuts) as enclosure.

Here is a (TODO) list of features I will add to the software in the next few days:

take advantage of the tilt switches to display scrolling time and quotes when the clock is placed horizontally, as in BookClock;
make use of the Infrared receiver for remote control;
hourglass;
kitchen timer.

On the hardware side, I would add, under the back transparent plate, a solar panel for recharging the battery (this feature is supported by the battery shield, I believe). Stay tuned.

Big display (64x16) made of four 0832 LED displays from Sure Electronics

2011-08-01T11:13:00.005-04:00

Here is some software help for those fellows interested in making a bigger (64x16 pixels) display by putting together four 0832 (sometimes also named "3208") displays from Sure Electronics (datasheet here).

The code base was originally written by WestfW. I just adapted it to keep track of the new X and Y coordinates and to direct the commands to the right display (among the four).

The four 0832 displays need to be arranged in the format below, with each one having the switch that corresponds to its number turned ON.

+----------+----------+
| 1 | 2 |
+----------+----------+
| 3 | 4 |
+----------+----------+

The code can be downloaded from here.

The 4x0832 setup running this code can be seen here (video taken by Sven). Note that the scrolling speed can be adjusted through the "delay" line at the bottom of the sketch, set to 3 seconds in the video.

Buy complete C3Jr kit

2011-07-10T11:10:00.008-04:00

Here you can buy a complete C3Jr kit, that will make a wonderful word clock once assembled (assembly instructions here). All you need is a soldering iron and some (almost trivial) soldering skills. The kit comes with the ATmega328 processor already loaded with the latest sketch (no need for you to program it).
Please contact me if you want an assembled and tested C3Jr.

Assembling C3Jr kit

2011-07-09T23:03:00.021-04:00

Assembling C3Jr kit is a medium-challenge project:

all components except the RTC chip DS3231 (which comes soldered to the board) are through-hole;
the spot and orientation of each component are printed on the board very clearly;
sockets are provided for each integrated circuit;
placing and soldering the components takes a few hours;
it is very important to pay attention to the correct orientation of the polarized components (LEDs, electrolytic capacitors, transistors, ICs), since any mistake takes time and effort to repair;
double check every time before soldering any component, even resistors.

The C3Jr kit you received includes (as shown in the photo):

large (18cm x 23cm) PCB;
ATmega328 with 28-pin socket;
16MHz crystal + two 22pF capacitors;
74LS154 and 24-pin socket;
STP08DP05 and socket;
DS3231, pre-soldered to the board;
CR2032 (3V) coin battery and battery holder;
130 diffused white (or blue, on request) 5mm LEDs;
17 PNP transistors 2N5401;
4 decoupling capacitors 100nF;
100uF electrolytic capacitor;
17 resistors 100 ohms;
6 resistors 10K;
2 resistors 4K7;
2 resistors 1K;
2 resistors 680 ohms;
USB type B (power) connector;
speaker/buzzer;
6-pin right-angle male header used as FTDI connector;
4 right-angle push buttons;
5k potentiometer;
set of laser-cut, black plastic, baffles;
laser-cut acrylic faceplate with your favorite choice of font;
laser-cut plastic backplate;
set of standoffs, screws, nuts, washers.

The step-by-step assembling instructions are presented below.

1. Place and solder the 100 ohm (brown-black-brown) resistors, 17 of them.

2. Place and solder the 6 resistors of 10K (brown-black-orange).

3. Place and solder the 2 resistors of 4K7 (yellow-purple-red), then the 2 resistors of 1K (brown-black-red), then the last 2 resistors, of 680 ohm (blue-grey-brown), as shown in the photo below.

4. Insert and solder the sockets for integrated circuits marked U3, U4 and U5. There are 3 sockets and they need to be placed with the notch matching the silkscreen markings. The photo below shows (in the upper-right corner) 2 rows of 12 machined female pins (also used as IC socket) where normally is the place for the 16-pin 0.3" socket.

If it happens to solder any of these sockets with the wrong orientation, don't try to fix anything; just make sure that the ICs are inserted with the correct orientation, matching that on the PCB's silkscreen.

5. Place and solder the decoupling capacitors (100nF), then the electrolytic capacitor (100uF), as shown in the next photo. The 100nF capacitors don't have polarity, so their orientation is not important. But the 100uF electrolytic capacitor (black small cylinder) must be positioned with the negative terminal (marked with a minus) closer to the right edge of the board.

6. Place and solder the USB type B connector (used here as power jack), in one of the 3 available spots, depending on how the clock will be displayed: J3 if on the wall or J1 if on the desk. (In the photo below, the USB connector is mounted for a desk configuration.) Then solder the 6-pin male right-angle header (used as FTDI connector) and the two 3-pin male headers. Next, solder the buzzer, the resonator (or crystal + 2 capacitors), the four right angle push buttons, the coin battery holder and finally the dimming pot. The board should look now like in the photo below.

Note that the RESET button and the debug LED are optional (and not populated on the board in the photo).

7. Solder the 17 PNP transistors, their orientation according to the silkscreen.

8. Solder the LEDs. Pay maximum attention to their orientation. The short pin is the cathode (negative terminal). The cathode is also indicated by a straighten arc at the bottom of LED's plastic capsule, see the drawing below.

When placing the LEDs, their cathode (short terminal) always goes toward the label on the silkscreen.

The board with the LEDs soldered looks as in the next photo.

There are 2 optional LEDs in addition to the 128 LEDs in the matrix: one (D260) is the power indicator and may be annoying since it is ON all the time, the other (D258) is used for debug purposes.

9. Insert the ICs into their respective sockets. Before doing this, bend all the pins on each side at once, by pushing them against the table, so both rows of pins become parallel.

Make sure the notch of each IC, indicating where the pin counting starts, matches the notch in the silkscreen (and also on the socket, if you place those correctly in Step 4).

The ATmega328 microcontroller comes programmed with the latest release of the C3Jr software. New sketches can be uploaded, with the Arduino IDE, through the FTDI cable/breakout (plugged into the 6-pin FTDI connector).

10. Assemble the enclosure, starting with the backplate/bottom plate. Insert the 4 long screws into the 4 holes closer the center of the backplate. Secure each with a small nut as shown in the photo below.

Slide the completed PCB on the protruding screws, with the buttons near the two keyholes at the top of the backplate. Then place each of the 4 small baffle locators on every screw and secure with the 4 small nuts, as shown in the next photo.

Interlock the baffle grid into place with the angled edge against the PCB. This provides a little extra space for the components. You can start with the top and bottom vertical pieces and slide all the horizontal pieces into place. Place the whole assembly on a flat surface (cardboard, book etc) and flip over, then transfer it over LED matrix region of the PCB. You can now install the remaining vertical pieces. Next, insert the 4 screws into each corner of the backplate and secure with the 20mm standoffs.

Note that the protection-paper on the baffles is still there. I did not bother to peel it off, but it doesn't seem to affect the functionality. After all, the purpose of the baffles is just to separate the LEDs in the matrix.

Install the faceplate on top of the baffles and secure with the 4 provided socket screws.

11. Power up the clock with the USB type-B cable, similar to those used for USB printers. (You can also use the FTDI cable to power it up, but ensure that the PWR SEL jumper is in the correct position, on the left 2 pins.)

Since the microcontroller is loaded with the latest C3Jr software, the clock will work right away (you just need to set the time.)

Introducing C3Jr kit

Introducing C3Jr kit

2011-07-02T20:23:00.010-04:00

Although I posted about ClockTHREE Junior (aka C3Jr) here, this is its formal introduction in my blog.

C3Jr is an Arduino-compatible, open-source alarm "word clock", which displays the time in words, similar to the original QlockTWO(*). It is the result of numerous hours of electronic design, mechanical engineering and programming by the Wyolum team. The goal of this effort was to develop a kit that would be affordable, easy to assemble and stand out aesthetically.

The content of the C3Jr kit is shown below (click for a larger picture).

It includes all the electronic components and mechanical parts to build the C3Jr clock shown in the next photo (on Justin's workbench).

The large display is based on a matrix of 16x8, individually addressable, white (or blue) LEDs. Beside lighting up small letters (one letter per LED) that make up words, the display can also be seen as a matrix of 16x8 pixels, which can show scrolling characters or animated sprites.

The time-keeping chip is the extremely accurate (max 2 minutes deviation per year), temperature-compensated, DS3231, with a 3V coin cell for backup (keeps the time when clock is not powered).

Here is a list of the parts:

large (18cm x 23cm) PCB;
ATmega328 with 28-pin socket;
either 16MHz resonator or 16MHz crystal + two 22pF capacitors;
74LS154 and 24-pin socket;
STP08DP05 and socket;
DS3231, pre-soldered to the board;
CR2032 (3V) coin battery and battery holder;
130 diffused white (or blue, on request) 5mm LEDs;
17 PNP transistors 2N5401;
4 decoupling capacitors 100nF;
100uF electrolitic capacitor;
17 resistors 100 ohms;
6 resistors 10K;
2 resistors 4K7;
2 resistors 1K;
2 resistors 680 ohms;
USB type B (power) connector;
speaker/buzzer;
6-pin right-angle male header used as FTDI connector;
4 right-angle push buttons;
5k potentiometer;
set of laser-cut, black plastic, baffles;
laser-cut acrylic faceplate with your favorite choice of font;
laser-cut plastic backplate;
set of standoffs, screws, nuts, washers.

The C3Jr kit is available for order here or in my store.
Here are the assembling instructions.

The schematic and board layout for C3Jr are shown in the images below (click on the image for the bigger version). The KiCAD files are available for download here.

(*) QlockTWO is an industrial product (as opposed to the amateur, home-made, C3Jr). Take a look at how it is manufactured.

June 2011 release of Wise Clock 3 software

2011-06-26T15:52:00.005-04:00

Mr. Ruud van der P. graciously offered his skills and time to extend and improve the Wise Clock 3 software, for which I am grateful.
He also took the video below, showing some of the newly added features in action.

This June/2011 release of Wise Clock 3 software (download from here) includes these features and changes:

PacMan - this new menu entry will show PacMan every 60 seconds.
Brightness of the display can now be changed with the Set key.
Show seconds in some of the "BIG" modes.
Time color when alarm is set: 3 hours before the alarm goes off, the time is displayed in orange, 2 hours before the alarm goes off in red; otherwise, time is displayed in green.
Chime may be enabled, giving a short beep at the half hour and a double beep at the full hour.
Alarm sound - the alarm will now play "Frere Jacques" followed by a siren and can be stopped by any button.
Menu will no longer show entries which do not make sense, like DATE+ when the Date was already on.
Score - new menu entry to keep a score for 2 players from 0 - 99.
Colors are now used in the Life and Demo apps.
Temperature is now a bit more accurate (after warming up) and uses the degree symbol to display the temp both in Celsius and Fahrenheit. In order to quickly see if the temp is rising or falling it is displayed with 1 decimal.
Bug fix: the file manager for the memory card did not read the last sector of a file and did not always handle the EOF (03) character correctly. It is important that all files have a EOF (03) character at the end to prevent reading behind the end of the file.
Displaying reminders:

At startup and at midnight the message.txt file is scanned for any reminder for that new day.
An orange dot is displayed at the bottem during this scan
If a reminder is found then it will be displayed (like the quotes) for the next 24 hours
The message file may also contain the start and end date of the Daylight Saving Time period (DST), this will adjust the clock by 1 hour.
The personal Message is still contained in this message file but must now start with [M1] which will allow for more then 1 Personal Message in a future release.
See message.txt for more details and add your own reminders.

Introducing Wise Clock 3

My impressions of Lunatik + iPod Nano

2011-06-21T17:58:00.006-04:00

For my pledge for Lunatik on kickstarter, I got two different watch kits that can transform iPod Nanos into wrist watches. Here they are, in their original packages, as I received them. One is plastic (TikTok), the other, the cooler one, is aluminum (Lunatik), both with rubber straps.

One of my motivations for the pledge was to get a re-usable watch case. I still wishfully think that I can make DWex (or any future watch I may make, for that matter) in the form factor of a Nano, so it can be used with Lunatik or TikTok (or other iPod Nano case/wrist band for that matter). But until then, I am going to use it for its intended purpose.

I have been wearing the Lunatik watch for several months now, so I had enough time to form an opinion.
A few impressions that come to mind, in no particular order:

stunning design (I find it); sometimes I look at the watch without checking the time;
there is a (sometimes annoying, depending on my mood) delay between the touch of the screen and the moment the watch actually displays the time (waking up from sleep mode, in microcontroller speak); but this is a function of the iPod nano and not of the Lunatik;
the free end of the rubber strap sometimes pops up from the metal "strap keeper" rather easily (especially when accidentally touching the desk, for example);
when new, the rubber strap has a strong odor; it goes away after a couple of days;
when used only as watch, iPod Nano would require charging just once a week.

Overall, I am very pleased with my Lunatik watch. As everybody knows, iPod Nano is more than a watch. I am actually carrying a small computer on my wrist. It definitely attracts attention :)

The problem with any iPod/iPad-related gadget is that they will eventually get thrown away with the iPods/iPads themselves. There is little chance that the gadget will fit a newer generation of the Apple product, so there is little chance that it can be re-used. That is, don't expect Lunatik to fit the next generation of iPod Nano, 'cause it probably won't. Well, good for the manufacturer, not so good for the consumer. Still, Lunatik will make a nice conversation piece even when it will be on display in the "personal museum".

North Carolina Maker Faire Preview

2011-06-17T23:54:00.003-04:00

Justin just sent this photo from North Carolina Maker Faire, happening this weekend (June 18-19, 2011), with lots of clocks, some bigger, some smaller.

And here is an instructable on how to assemble C3Jr, available for sale as a kit here.
Vote here for your favorite project in the LED contest.

How to define bitmaps and fonts

2011-06-13T22:24:00.008-04:00

This piece of knowledge is especially useful for understanding and hacking the Wise Clock 3 software, but can be also applied to any software that deals with pixel manipulation.

To define a small bitmap, start from a grid/matrix on paper (see photo below). Each square of the matrix will represent a pixel. Blacken the squares until the matrix resembles your bitmap. Next step is to translate the content of the matrix to numbers.

Let's take a closer look at the example below, a bitmap of 5x5 pixels.

This translates into an array of 5 numbers, one number per line. Each number is calculated by adding the values (at the top) of the selected columns.
So, the number for the first line is 14 (2 + 4 + 8), second number is 21 (1 + 4 + 16) and so on.
For the binary oriented fellows :), the hex values are between brackets.

Let's now jump to the actual code. The bitmap definition will look like this:

byte PROGMEM smallBitmap[3][5] = {
{
0x0E, // _XXX_
0x15, // X_X_X
0x1F, // XXXXX
0x1F, // XXXXX
0x15, // X_X_X
},

...

}

The above piece of code declares a two-dimensional ("[3][5]") array of bytes, in program space ("PROGMEM"). The first dimension ("3") represents the number of defined bitmaps. The second dimension ("5") represents the number of lines in each bitmap. A line in the bitmap definition is referenced using values for both dimensions. For example smallBitmap[0][4] is 0x15 and represents the last (index 4) line of the first (index 0) bitmap. [Note that array indexes start with 0, that is, first element in an array has index 0.]

Similarly, snippets of font definitions are shown below:

// define all ascii characters starting with 32 (blank);
unsigned char PROGMEM myfont[95][8] = {
{
0x00, // ________ blank (ascii 32)
0x00, // ________
0x00, // ________
0x00, // ________
0x00, // ________
0x00, // ________
0x00, // ________
0x00 // ________
},
{
0x00, // ________ !
0x08, // ____X___
0x08, // ____X___
0x08, // ____X___
0x08, // ____X___
0x00, // ________
0x08, // ____X___
0x00, // ________
},
...

{

0x00, // ________ 0

0x1C, // ___XXX__

0x26, // __X__XX_

0x1C, // ___XXX__

0x00, // ________

{

0x00, // ________ 1

0x0C, // ____XX__

0x1C, // ___XXX__

0x0C, // ____XX__

0x1E, // ___XXXX_

0x00, // ________

{

0x00, // ________ 2

0x1C, // ___XXX__

0x26, // __X__XX_

0x0C, // ____XX__

0x18, // ___XX___

0x30, // __XX____

0x3E, // __XXXXX_

0x00, // ________

{

0x00, // ________ 3

0x3E, // __XXXXX_

0x06, // _____XX_

0x1C, // ___XXX__

0x06, // _____XX_

0x26, // __X__XX_

0x1C, // ___XXX__

0x00, // ________

...

}

The data structure "myfont" above is an array of 95 character-bitmaps, each bitmap having 8 lines and 6 columns.

Bigger bitmaps, those having more than 8 columns, require more than a byte for each line.
Take a look at the definition of the Pacman bitmaps below.

uint16_t PROGMEM bitmap[7][14] = {
{
0x02E0, // ____XXXXX_____
0x0FF8, // __XXXXXXXXX___
0x07FC, // ___XXXXXXXXX__
0x03FC, // ____XXXXXXXX__
0x01FE, // _____XXXXXXXX_
0x00FE, // ______XXXXXXX_
0x007E, // _______XXXXXX_
0x007E, // _______XXXXXX_
0x00FE, // ______XXXXXXX_
0x01FE, // _____XXXXXXXX_
0x03FC, // ____XXXXXXXX__
0x07FC, // ___XXXXXXXXX__
0x0FF8, // __XXXXXXXXX___
0x02E0, // ___XXXXX______
},
{
0x03E0, // ____XXXXX_____
0x0FF8, // __XXXXXXXXX___
0x1FFC, // _XXXXXXXXXXX__
0x1FFC, // _XXXXXXXXXXX__
0x07FE, // ___XXXXXXXXXX_
0x01FE, // _____XXXXXXXX_
0x007E, // _______XXXXXX_
0x007E, // _______XXXXXX_
0x01FE, // _____XXXXXXXX_
0x07FE, // ___XXXXXXXXXX_
0x1FFC, // _XXXXXXXXXXX__
0x1FFC, // _XXXXXXXXXXX__
0x0FF8, // __XXXXXXXXX___
0x03E0, // ____XXXXX_____
},
{
0x03E0, // ____XXXXX_____
0x0FF8, // __XXXXXXXXX___
0x1FFC, // _XXXXXXXXXXX__
0x1FFC, // _XXXXXXXXXXX__
0x3FFE, // XXXXXXXXXXXXX_
0x07FE, // ___XXXXXXXXXX_
0x00FE, // ______XXXXXXX_
0x00FE, // ______XXXXXXX_
0x07FE, // ___XXXXXXXXXX_
0x3FFE, // XXXXXXXXXXXXX_
0x1FFC, // _XXXXXXXXXXX__
0x1FFC, // _XXXXXXXXXXX__
0x0FF8, // __XXXXXXXXX___
0x03E0, // ____XXXXX_____
},
{
0x03E0, // ____XXXXX_____
0x0FF8, // __XXXXXXXXX___
0x1FFC, // _XXXXXXXXXXX__
0x1FFC, // _XXXXXXXXXXX__
0x3FFE, // XXXXXXXXXXXXX_
0x3FFE, // XXXXXXXXXXXXX_
0x3FFE, // XXXXXXXXXXXXX_
0x3FFE, // XXXXXXXXXXXXX_
0x3FFE, // XXXXXXXXXXXXX_
0x3FFE, // XXXXXXXXXXXXX_
0x1FFC, // _XXXXXXXXXXX__
0x1FFC, // _XXXXXXXXXXX__
0x0FF8, // __XXXXXXXXX___
0x03E0, // ____XXXXX_____
},
...
};

And this is the function that uses the actual Pacman bitmaps defined above.

/************************

* load and display a given bitmap (defined in bitmaps.h);

void putBitmap(int x, int y, byte nBmp, byte color)

{

for (byte row=0; row < 14; row++)

{

uint16_t rowDots = pgm_read_word_near(&bitmap[nBmp][row]);

for (byte col=0; col<14; col++)

{

if (rowDots & (1<<(13-col)))

ht1632_plot(x+col, y+row, color);

else

ht1632_plot(x+col, y+row, BLACK);

}

Now you should be all set to start your own animation (which is just a sequence of bitmaps).

Pacman mode on Wise Clock 3

2011-06-11T00:24:00.004-04:00

This display mode shows the time with seconds. To add some spice, Pacman passes by once a minute, when the minutes are about to change.

The animation is based on a short sequence of bitmaps (only monochrome at the moment) loaded from program memory.

The latest code will be released soon, and will include new features courtesy of fellow Arduino-er Ruud. Stay tuned.

Related posts:

Introducing Wise Clock 3

World "day and night" on Wise Clock 3

2011-05-23T21:00:00.003-04:00

Can you believe this? Wise Clock 3 displaying day and night world map, courtesy of Justin!

The map is printed on thick velum and sandwiched between the display (with a little space) and the front plate. The result looks really amazing.

Note that the "day and night" feature is also found on ClockTHREE (and maybe soon on C3Jr as well).

From the mailbag

2011-05-14T18:03:00.003-04:00

From Matthias:
Check this out: http://arduino.komakino.ch/

From Bill:
Just wanted to let you know that I enjoyed putting together the clock. I have every step done except for cutting the coffee can and inserting the clock – wanted to get a little better and using the dremel tool first!

From Magnus:
Put the DWex in a case now. Very prototypish and could be improved but it looks really cool to wear around the neck :)
Here's a video
http://www.youtube.com/watch?v=B2pb41jTmms
Sorry about the Swedish in the video :)

From Nick (after a few back-and-forth hiccups :)
Florin, success! I've attached a photo....pride of place next to my Bulbdial clock....

A few updates on the kits:

the original glass-domed Wise Clock is no longer offered because the domes are more difficult to find (and more expensive these days, like everything else, it seems);
Wise Clock 2 complete kit is no longer offered either, since Sure does not sell the original (for which Duino644 was designed) 2416 LED display anymore; fellow Arduino-er Kenny suggested switching to (that is re-design the board for) the new 2416 display (also from Sure), but I figured it is not worth the effort to maintain two branches of the code (for WC2 and WC3) since Wise Clock 3 offers so many more advantages (size, colors);
compiled a TODO list for Wise Clock 3 software, including suggestions from Nick and Ruud:

display time with different colors, indicating the time left before the alarm goes on (as in IllyClock);
dimming the display from button "Set" (as in Wise Clock 2, which uses the 2416 display);
display seconds in "big clock" mode;
chime for hour and half hour (enable/disable);
moon phases (as in BroHogan's Nex10 clock);
adapt the menu options to the current settings; for example, do not show DT+ if the date is currently displayed;
display date-dependent messages (e.g. "Merry Xmas" for Dec 25), reminders (e.g. "John's birthday, 416.234.5555");
automatic daylight saving;
countdown timer.

Spilling the beans - C3Jr

2011-05-08T15:01:00.011-04:00

I don't usually do this: advertising a project before its completion. But the beans are out anyway :)

I have already received inquiries about ClockTHREE price and availability. Although I don't make this kit and I did not participate in its design, I would gladly redirect all questions to its makers, the WyoLum team, mainly Justin and Anool.

The latest news is that ClockTHREE (read my brief review here) is already available in their store as a "complete kit" for US$333. It may look expensive, but considering what is included, it may actually pass as a bargain. Just think of the following:

stylish, unique, wall-mountable, well designed & engineered, hackable, Arduino-programmable, multi-color Word Clock, featuring alarm, day-of-week and temperature display, scrolling text, plus many function modes;
160 high-quality 10mm RGB diffused LEDs and 32 10mm diffused white LEDs;
a huge (about 25cm x 30cm) PCB and a lot of electronic components, including an ATmega328 and a ChronoDot;
a large set of laser-cut plastic parts for baffles and enclosure, and the laser printed faceplates;
great (open source) software developed specifically for it.

The assembled ClockTHREE is also available for US$444 (they surely have an affinity for numbers :).

Now back to the beans: a simplified, and hence lower-cost, version of ClockTHREE is under development by the same great WyoLum team (I also joined in for this one). It was named C3Jr, as in ClockTHREE Junior. Its functionality will be similar: word clock, alarm, day of week, various display modes etc. C3Jr will be single-color (usually white; blue is also considered), just a bit smaller, and, hopefully, as elegant as its predecessor. The "C3Jr complete kit" will be priced at under $200 and available mid June (2011), just in time for MakerFaire North Carolina.

Stay tuned for more details.

Updated May 16, 2011

PCBs are in, shown below (photo by Justin).

Updated May 20, 2011
C3Jr assembled by Justin. I think it looks beautiful.

ClockTHREE completed!

2011-05-03T22:10:00.003-04:00

My previous post on ClockTHREE, a while back, was about my first impressions. The work I did then, starting to assemble the clock, consisted in a lot of tedious soldering and did not require a lot of thinking and analysis. Yet, not surprisingly, the clock passed all the software tests.

Now that I received the long-awaited blue LEDs, standoffs and faceplates (thanks again Justin), I was able to finalize my ClockTHREE. And let me tell you something: this is the most under-rated Arduino-based project in the history of Arduino, seriously. I am just now impressed with the amount of work that went into this project, from designing the PCB, to writing the scripts to generate the faceplates, to developing the software/firmware. I did a few of my own and I know what goes into this kind of endeavors. ClockTHREE is one complex piece of engineering: electronics, mechanical structure, software.

Here are a few more observations:

the top frame fits perfectly on top of the baffles (the inside baffles being a tad taller, to compensate for the thickness of the frame), holding them down and keeping them square (as shown in the next two photos);

Frame on top of the baffles:

everything (top and bottom covers, faceplate, baffles and frame, board) is held solidly in place with just 6 sets of hardware (standoff, screws, washers);
the software works impeccably right off the bat (I was going to set the RTC time using an older library, then I found the operating instructions);
the software has quite a few features implemented already (e.g. setting the display color, few display modes etc);
the visual aspect of the clock is as elegant as that of QlockTWO.

Justin and Anool did an impressive job on ClockTHREE. Come to mind Steve Wozniak's words: "I would have loved to have invented that".

My Geiger counters

2011-04-30T17:16:00.002-04:00

I have had a Geiger counter project on my "todo" list for a long time, ever since fellow Arduino hobbyist BroHogan (aka John) created one more than a year ago. His Geiger project received a lot of interest lately, with the unfortunate events in Japan, so he decided to provide a kit (which seems, not surprisingly, to be sold out pretty quickly). John graciously offered to send me one of his kits, which I just finished assembling, and I am glad to report on the impressions and results.

First of all, DIYGeigerCounter is a big kit in a small package; it's got more than 40 through-hole parts, on a PCB that would fit in an Altoids gum tin box (Note: only the PCB, not the Geiger sensor itself, which is too long).

The kit contains both the Geiger analog circuit (that generates the high voltage for the tube) and the ATmega328 microcontroller part (that can eventually drive an LCD), together on the same board.

The version I received is 1.0; the version John is selling is 1.4. The differences are minor: the latest revision has the resistors placed horizontally, a few more headers on the processor side and four screw holes in the corners.

Because of the complexity of the circuit, one needs to take the time to read the assembling instructions. There are lots of resistors and capacitors that need to be placed correctly. And then there are the diodes. To determine their orientations (they are not marked on the silkscreen in revision 1.0), one needs to use the continuity meter and the schematic, which is not a bad thing at all, since one learns about the circuit. (I know that the tendency is to just assemble everything in a haste, because I do that myself. I only learn when something goes wrong and the circuit does not work. Then I have to go to the schematic and use the multimeter.) OK, so no shortcuts here; this kit requires a bit of study, checking and identifying the parts, even crossing them off the list once installed (this is what I did).

Needless to say that the kit worked superbly right off the bat. I measured (with a regular voltmeter, not using the method BroHogan describes here) the high voltage, and it is 310V. It may sound dangerous, but I felt nothing when I touched those pads. The assembled Geiger counter is shown below, without the Geiger tube.

Notice the nice clips for the tube. Other kits usually recommend just wrapping some wire around the tube's terminals, or worst, soldering the wires directly to the tube (this procedure may damage the tube, apparently).

The tube I used for partial testing (since I don't have any radioactive materials just yet) was part of another, much simpler (and much more expensive) kit, from electronic goldmine, shown assembled below.

I just inserted the clips over the installed tube and powered DIYGeigerCounter and started clicking (with the LED turning on) every 2 seconds, giving thus a "reading" of about 30 CPM (clicks per minute).

Next step is the addition of the LCD, detailed here. Then, I will need to build and enclosure, so I can take it out on the field and impress my friends when they chose their granite kitchen counter-tops :)

Scrolling message sign display with Wise Clock 3

2011-04-23T17:36:00.003-04:00

A feature of Wise Clock 3 board that was not previously "advertised" is its ability to drive more than one 3216 LED display, making it easy for anyone to quickly assemble a window sign display.

Wise Clock 3 board plugs into both connectors of the display. To cascade a second display, you will need to solder, on the Wise Clock 3 board, a right-angle 16-pin (8x2) male header in the place provided below the existing connector, then use the 16-wire ribbon cable coming with the 3216 display to connect this newly added header to the input connector of the second 3216 display, as shown in the photo below.

A demo (put together by Tim Gilmore) of a 64x16 windows sign display powered by Wise Clock 3 is shown in action in the following video. The demo software can be downloaded from here (for more details see this thread in the arduino forum).

Besides saving more, making your own clock brings a great sense of accomplishment.

Related posts:

A new kind of baffles

2011-04-19T19:30:00.006-04:00

It started as a challenge, then it became an obsession: the baffles for my own version (still work in progress) of Word Clock, the grid that separates the LEDs from one another, so that every letter on top of a LED can be lit individually.

Baffles for Word Clock clones have been made before, see here and here (part of this and that instructables, respectively). These examples separate groups of LEDs rather than each individual LED. Justin and Anool of ClockTHREE fame raised the bar (they did not call it ClockTHREE for nothing :) with their individually addressable LEDs and the associated baffles, an elegant and remarkable solution, nicely integrated with the board and the case. Trying to replicate their results for just one prototype is both expensive (laser-cutting) and tedious (calculations, drawings, assembly). After a lot of thinking, I "invented" my own solution for the baffles, as shown in the photo below.

Basically, I used 40-pin female headers to separate the low-profile, wide-angle, LEDs. The headers are held in place by soldering them to the prototyping board. For the 8x14 LED matrix, I used about 40 headers, for a cost of about $12.

Generally speaking, designing and making the baffles is a feat. With so many choices, one needs to answer a few questions before designing them:

what material should be used (cardboard, plastic, wood etc)?
what manufacturing process would be the most appropriate (in terms of price, assembly time etc)?
how could they be attached to the board?

Plastic is an obvious choice for the material:

laser-cut (expensive, requires the assembly of the parts);
mold-injected (perfect for mass-production; no assembly required: what you get is what you use);
3D printed (suitable only for prototyping; may be expensive).

Even after having the baffles made, the question of how to attach them to the board still remains. They need to be placed equidistant between the LEDs and held solidly in place (screwed down to the board maybe?).

Now you don't need to wonder anymore why Peggy 2 does not come with baffles :)

Weekend in Paris...

2011-03-27T22:30:00.004-04:00

I wish.

This was another well spent weekend, inside, soldering. Lots of soldering, mostly LEDs.
I never built a LED matrix myself from discrete LEDs. (I actually started one for the "Word clock" on instructable.com, but never finished it.) I always took "for granted" (not literally; I paid for them) the 8x8 LED matrices or the LED displays from Sure Electronics. But this weekend I truly understood why the German-made (?) QlockTWO is as expensive as it is. Not only because of the design but also because of the amount of labor involved.

To cut through the chase, I started assembling the ClockTHREE. It's got 160 RGB LEDs organized in a matrix of 16x10. For those not familiar, ClockTHREE is an initiative by Justin and Anool to develop a better (multicolor, programmable) and open-source version of the above-mentioned QlockTWO.

This is how it looks so far (not finished yet, still waiting for a few components to arrive).

A few first impressions on the hardware:

This is not your average project. Even though it may look like the "LOL shield" from a distance :), it is more than just soldering LEDs. Each RGB LED requires a bit of preparation (with the special wedge tool), then careful insertion and double checking with the multimeter. It is absolutely necessary to read the assembly instructions before starting soldering the LEDs.
The PCB, one of the biggest I have seen offered in a kit, looks very professional. It's nice to see the component values (for example, "10K" for resistor) in the silkscreen. The layout is very well balanced, with parts placed around the LED matrix display area, buttons and connectors accessible at the bottom.
There are a couple of surface-mounted ICs (the shift registers), which would require non-novice soldering skills. Note (from Justin): the actual kit will come with the SMDs pre-soldered on breakouts, which will allow for easy removal in case of testing/debugging.
The rtcBOB, compatible with the ChronoDot, could be used in other projects as well, since it is removable (and connected through headers).

As shown in the photo, the board is missing the last two rows of LEDs. They will be populated with single color 10mm white (or blue) LEDs.

Just bragging

2011-03-25T20:05:00.003-04:00

This is in return to my more-than-modest contribution to ClockTHREE project on kickstarter.com.

Thank you, Justin and Anool! Keep up the great work!

And here are some parts for my next project, guess what it is.

Complete "Wise Clock 3" kit now available

2011-03-21T22:18:00.009-04:00

The "Complete Wise Clock 3 kit", shown in the photo below, includes:

Wise Clock 3 kit (PCB and the parts), as described here;
3216 multicolor (red, green, orange) 3mm LED display from Sure Electronics;
enclosure made of two laser-cut, either clear or smoked, acrylic plates;
set of standoffs, screws, nuts and washers.

The main clock mode, "Quote" (hence the name "Wise Clock"), is shown in the video below.

Here is Wise Clock 3 running Pong as another clock mode:

Besides being an alarm clock, Wise Clock 3 has the following features:

ability to set the time, date and day from the buttons, in an intuitive and user-friendly way;
display a user-editable, personalized message (e.g. Happy Birthday John);
display the current date and the current temperature.

The software is published (open source) and available for anyone to modify and improve.

The hardware is compatible with Arduino IDE, and more accurately, is a clone of the Sanguino platform, using the same microcontroller (ATmega644P) and Arduino files.

Related posts:

Wise Clock 2 with Pong and other features

2011-03-15T21:45:00.013-04:00

The latest release of the Wise Clock 2 software is now available for download.

It includes the following new features:

"Pong clock" (adapted to 16x24 display from Nick's version for 16x48 display);

ability to set the date (year/month/day) and day-of-week from the buttons (the "old" way of setting the clock through the file time.txt on the SD card is still there);
"Big clock", courtesy of Ruud;
display the temperature (for Duino644+ boards using the DS3231 real time clock).

The following animation (click on the photo) shows all menu options (displayed by pressing the button "Menu").

The existing attempt to a "user manual" still has valid information, so please browse through that too.

The software was compiled with Arduino IDE 21. After downloading it, the file should be unzipped in the folder "arduino21/libraries/". It is confirmed that both WiseClock2 and WiseClock3 software cannot co-exist in the same "libraries" folder.

In order to build, you will need the Sanguino files. Please refer to this post on the environment setup for the build/upload.

The code can handle both the red and the green 24x16 LED displays from Sure Electronics. The current default setting is for the green display. If you have the red display, comment out this line

#define _GREEN_DISPLAY_

in file HT1632.cpp.

Regarding setting the date, this is performed through the "DATE" menu option. The bottom half will show the date in the format YYMMDD. Move between the three by pressing the "Set" (middle) button. The flickering number indicates the current selection that gets incremented by pressing the "Plus" button. Note that the year (first 2 digits) will rollback after 50, so if you accidentally passed the current year (11), you will need to go all the way to 50, then back to 0, then to 11 again.

The day-of-week can be set through the menu "DAY". After the menu was selected (button "Set", the middle one), scan through the days by pressing button "Plus".

To save the settings, wait for the menu to timeout (after about 4 seconds after the last button press).

The display of the temperature is enabled/disabled from the menu options "TMP+" / "TMP-" respectively.

Other nice-to-have features on the TODO list:
- indicate special dates (e.g. friends' or family birthdays, anniversaries, holidays);
- automatic daylight-saving-time adjustment;
- chime at top and bottom of the hour.

Related posts:

The new Duino644+ board for Wise Clock 2

From the inbox

2011-03-03T20:18:00.004-05:00

Nicole from "wg buettgen childrenhome" in Germany, emailed these photos of their projects inspired from this blog.

"we use y bookclock as a wall clock, in the morning we turn it and it shows the "todo rules" for the kids........great !!! only thing is we must write in a special type because in english they don't know the letters ä,ö,ü (ae,oe,ue)"

Impressive is the fact that these projects are not made from the kits. The "kids" used the schematics, explanations ans sketches found on this blog. So I am not really wasting my time after all :)

Nicole and kids, keep up the great work!

Uploading sketches to Wise Clock 3

2011-02-24T19:14:00.006-05:00

Updated March 6, 2011 - Added screenshot for WiseClock3 folder (after unziping).

Sooner or later, if you have Wise Clock 3, you will want to upgrade the software.
This process requires the following prerequisites:

installation of the Sanguino-related files (since Wise Clock 3 is compatible with Sanguino);
connection to the board, through the FTDI cable/breakout.

To install the Sanguino files, follow the instructions found here. Basically, you need to do two things:

add the definition of the Sanguino board to the file arduino21/hardware/arduino/boards.txt;
create the folder "sanguino" and copy the Sanguino files, as shown in the screenshot below.

After these two steps are completed, you should see "Sanguino" listed in the menu "Tools/Board" of Arduino IDE 21 (used as an example here).

To upload the sketch, you will need to connect the board to the PC/Mac with an FTDI cable/breakout. The USB end of this cable gets plugged into the PC/Mac, the FTDI end gets connected to the Wise Clock 3 board as shown in the photo below.

With both the software and hardware in place, the upgrade will consist in the following steps:

download the latest software on the PC;
launch Arduino IDE and load the sketch;
compile, using Sanguino as the target board;
upload to the Wise Clock 3 board.

Unziping the WiseClock3 source code (found here) should result in a directory structure as shown in the screenshot below.

If you get compilation errors related to "tone.cpp" file, like the following,

...\ArduinoIDE\libraries\WiseClock3\Sound.cpp: In function 'void soundAlarm()':
...\ArduinoIDE\libraries\WiseClock3\Sound.cpp:60: error: 'tone' was not declared in this scope
...\ArduinoIDE\libraries\WiseClock3\Sound.cpp: In function 'void beep()':
...\ArduinoIDE\libraries\WiseClock3\Sound.cpp:75: error: 'tone' was not declared in this scope

make sure the file Tone.cpp is present in the sanguino folder, as shown in the next screenshot.

Also, make sure that WProgram.h (in the sanguino folder) contains the line

void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0);

FM Radio + MP3 Player Module

2011-02-20T16:20:00.015-05:00

Updated Oct 30, 2011
Not a failure anymore! Thanks to Viraj's advice, by connecting the audio ground to GND, the USB works fine as well.
I also found this rather brief instructable, which shows how to connect the buttons, basically shorting V+, V-, Mode and P to the ground.
The module takes around 53mA when playing the radio, and about 90mA when playing from USB stick (medium volume and using headphones). The current would be lower with the LED display turned off (I guess that display itself takes at least 20mA). So a small-sized LiPo battery of 300-500mAh could last a few good hours.

Now that it's all kind-of figured out, this small module could be integrated into a larger project, eventually controlled by Arduino; radio alarm clock comes to mind. (I wish the module had integrated RTC and work as clock as well.)

These modules, manufactured by Vire, seem to be used in a lot of devices. They also come in various formats and shapes, with different displays (LCD, for example). They can be bought from alibaba.com in bulk for about $5.
There are also variations of the small Vire module, probably made by other manufacturers, that include the extras (SD card socket, infrared receiver, USB socket, buttons). These, like the one pictured below (from dealextreme), retail for under $15.

On the other hand, they can be bought as finished consumer products (encased, even including the LiPo battery and charger, cables, speaker) for about $15 (ebay, dealextreme, amazon).

----------------------------------------------

This is a posting about failure. I wanted to document it before I shelve it and forget about it.

A while back I bought an "FM radio and MP3 player" module, with the purpose of integrating it with an Arduino. (I looked into many other FM radio modules, but this seemed the lowest cost and easiest to interface.) Here it is in the photo below.

The FM radio module I received was capable of much more than just digital radio receiving, it seemed:

show, on a 3 1/2 7-segment LED display, the FM radio station frequency (MHz);
scan FM range and memorize up to 30 stations;
control from an infrared receiver, with the provided (included) remote control;
play MP3 files from USB memory stick or SD card;
interpret and execute complex commands: volume up/down, mute, repeat, equalizer (5 types, preset).

The module is designed to interface with the peripherals through JST 1mm-pitch connectors. Unfortunately, the connectors and cables were not provided. (I recycled some from a junk CD player).
With no application note/schematic/datasheet, the only way to connect it was to resort on the names of the pins found on the silkscreen.
The bottom connector has the following pins:
L, G, R, V+, MODE, V, P, G, IR, 3V3

I correctly assumed that L is "Left audio channel", "G" is ground, "R" is right audio channel, "IR" is infrared input from an external infrared receiver.
I assumed incorrectly that "P" is positive (Vcc), because pins P-G-IR coincide with the terminals of the infrared receiver.
Once powered (5V), the radio, which is the default mode, starts working and an FM frequency is shown on the display. The only way to control the module at this point was through the remote control. After re-connecting the Vcc of the infrared receiver from pin "P" to "5V", the remote control started to work.

So far so good. Now, on to the MP3 player and USB.
I managed to get the schematic for the module

which showed how to wire the 4 pins of an USB type-A connector: GND, DP, DM, 5V. These are the 4 bottom pins of the lateral 10-pin connector.

With the USB memory stick (with a few MP3 tracks on it) inserted, the module seems to be reading it: the LED on the USB stick flickers. But, and this is where the failure is, there is no sound in the headphones, as it is when the radio is active.

While struggling with this module, I found a radio+MP3 player device that I believe uses internally a similar one. The major difference seems to be the display, which is LCD instead of LED.

I tested the USB memory stick with it and it plays just perfect.
I tried to open it up to look at its internals, but it seems to be glued together with no chance to put it back once opened. The case is made of pressed particle board, covered in some plastic veneer. There are just 4 screws in the back, which I was able to remove for a peek inside.

The box is mostly empty, except for the 2 side speakers and a rechargeable battery glued to the top (green object in the photo above). The small board shown is the audio amplifier. The FM+MP3 module is in the front of the enclosure, I guess, together with the LCD display and the sockets for USB type-A and SD card,

So here is what I have so far:

Both modules I have behave the same (USB mode is "silent", no sound from the USB memory stick), although the USB stick seems to be read correctly, based on the flickering LED.
The audio part works fine, since the radio is audible.
I double checked my connections, the 4 wires from the module to the USB connector (proof is that the USB seems to be read, as well).
I made sure the MP3 files are accessible and playable by a similar device.

I ran out of ideas. Looking at the schematics, I realize that it could be also a software (microcontroller) bug. The audio signal is output by the microcontroller through pins 14 (DAC_L) and 16 (DAC_R), I assume.

Since the radio works (using the same pins), I also assume that these pins are correctly connected to the audio amplifier.

Assembling Wise Clock 3 kit

2011-02-08T18:45:00.012-05:00

Updated May 16, 2011
Thanks Scott for contributing this PDF version of the assembling instructions.

The Wise Clock 3 PCB comes with the SD card socket and the RTC chip already soldered, and looking like this.

Follow these steps:

1. Place and solder the miniB USB connector; actually, since this connector is only used for power, only the two extreme pins (1 and 5) must be soldered; the middle three can be left untouched. Make sure the connector is solidly anchored to the board through the 4 lateral holding pads; there will be lots of mechanical tension when the power cable is plugged/unplugged.

2. Solder the 100 ohm resistor (brown black brown), indicated on the PCB as R14, then the LED, paying attention to its orientation. The shorter pin, the cathode, goes into the left (as you look at the PCB as in the image below) hole. At this point, by plugging in the power cable, the LED should light up.

3. Solder resistors R5, R6, and R7, all 4K7 (yellow purple black brown brown), as shown in the next photo.

4. Solder the rest of the resistors, all 10K, as shown in the photo below.

Note that there are 9 resistors of 10K value (brown black orange): R1, R2, R3, R4, R9, R10, R11, R12, R13.

5. Solder the 40-pin socket, then the battery holder and the 4 buttons, see photo below.

6. Solder the 3 decoupling capacitors (100nF, labeled "104"): C3, C5, C8. Then continue with soldering the two smaller ones C1, C2 (both 22pF).

7. Insert the crystal (the small, metallic, oval cylinder, with 2 pins, labelled "16.000" on its top) in its position on the left side of the microcontroller socket, indicated by an oval (see the above image). Orientation is not important for the crystal.
Then insert the 3V3 voltage regulator (black, 3-pinned, semi-cylindric part labeled "L78L33ACZ") as indicated on the silkscreen by the half-cylinder on the right side of the microcontroller socket (its orientation is very important), then solder in place.
Next solder the 6-pin male header, and then the piezoelectric buzzer (its orientation is not important).
Look at the photo of the final assembled board (two photos down) before soldering, to make sure you have these parts placed correctly.

8. Insert the two 16-pin female headers on the back of the board (opposite to the parts side) and solder them on the top (parts) side.

To get the best alignment possible on these headers, Justin (thanks) suggested to insert the 16-pin headers into their sockets (in the display), then solder the board on top. (This is similar to the way the male headers are soldered on an Arduino-shield.)

9. It is time to add now the preprogrammed ATmega644P microcontroller. Before inserting it in the socket, slightly bend both sets of its pins on a table, so that they become parallel. Position the chip carefully on top of the socket, paying attention to its orientation: pin 1, marked with an arrow (triangle), must be close to the upper side of the board. Push the chip firmly into the socket.
Next insert the coin battery in the battery holder.
The assembled board should look like in the photo below.

10. Plug the Wise Clock 3 board into the 3216 LED display from Sure Electronics (not supplied in the Wise Clock 3 kit).

11. Copy the files (provided in the zip) onto the SD card, formatted FAT16, then insert the SD card in the socket.

12. Power the board with a miniB USB cable. You made it! Congratulations! Next, set up the clock (date and time) from the buttons. Then chose your favorite clock mode and enjoy.

Related posts: