Single digit clock - method and apparatus

I recently found, at the bottom of a drawer, my forgotten numitron single-tube clock. It has a LiPo battery which still lights up the filaments, but no RTC to actually show time. It has a single button, which activates the display (numitron tube) when pressed. Indeed, some digits flash on, but inconsistently. And, as a clock, one would want to be able to also set the time, which is definitely not possible in this current version.

The required revision consists in:

• adding RTC
• adding a second button
• updating the software (by adding the ability to set the time through buttons)

The method I devised for setting up the time follows this state-machine diagram,

where "Set time" state is part of this bigger picture:

The single digit clock has 2 buttons: "Activate", which shows the time in a sequence of 3 or 4 digits, formatted as "Hh-Mm" or "h-Mm", and "Set", which starts the process of setting up the time. This is where most of the effort was put, since the actual displaying of time is really trivial.

The whole source code file is proudly presented below (as answer to the lots of questions in the above mentioned old post).

/*************************************************************************
* Sketch for direct driving 7-segment numitron IV-9
*
* Segments are defined as follows:
*
*      A
*     ---
*  B |   | C
*     ---  D
*  E |   | F
*     ---
*      G
*
* Decimal point/comma is segment H.
* Common pin is wired to Vcc (would be nice to wire it to D11/MOSI
*      instead, which is also PWM (for brightness)).
* To light up a segment, just connect it to GND.
*
* To display a digit, ground these Arduino pins:
*   0: 6, 7, 8, 10, 11, 13
*   1: 7, 8
*   2: 6, 8, 10, 11, 12
*   3: 6, 7, 8, 11, 12
*   4: 7, 8, 12, 13
*   5: 6, 7, 11, 12, 13
*   6: 6, 7, 10, 11, 12, 13
*   7: 6, 7, 8
*   8: 6, 7, 8, 10, 11, 12, 13
*   9: 6, 7, 8, 11, 12, 13
*
*************************************************************************/

#include <Arduino.h>
#include <Wire.h>
#include "DS1307.h"

#define _DEBUG_

// arduino pins connected to tube terminals;
// chosen based on the natural positioning of the Numitron tube on Pro Mini board;
#define segA  6  	// tube pin 5
#define segB  13	// tube pin 6
#define segC  8  	// tube pin 3 
#define segD  12	// tube pin 7
#define segE  10	// tube pin 9
#define segF  7         // tube pin 4
#define segG  11	// tube pin 8
#define segH  9  	// tube pin 2

// button to initiate the setting up of the time;
#define PIN_BUTTON_SET_TIME  4   // D4

// button to activate the display or to increment the time digit;
#define PIN_BUTTON_ACTIVATE  17  // A3


byte segmentPin[8] = {segA, segB, segC, segD, segE, segF, segG};


byte digits[10][7] =
{
// A  B  C  D  E  F  G
  {0, 0, 0, 1, 0, 0, 0}, 	// 0
  {1, 1, 0, 1, 1, 0, 1}, 	// 1
  {0, 1, 0, 0, 0, 1, 0}, 	// 2
  {0, 1, 0, 0, 1, 0, 0},  	// 3
  {1, 0, 0, 0, 1, 0, 1},  	// 4 
  {0, 0, 1, 0, 1, 0, 0},   	// 5
  {0, 0, 1, 0, 0, 0, 0},   	// 6
  {0, 1, 0, 1, 1, 0, 1},   	// 7
  {0, 0, 0, 0, 0, 0, 0},   	// 8
  {0, 0, 0, 0, 1, 0, 0}  	// 9
};


byte state[4][7] =
{
// A  B  C  D  E  F  G
  {1, 0, 0, 0, 0, 0, 1}, 	// H
  {1, 0, 1, 0, 0, 0, 1}, 	// h
  {0, 0, 0, 1, 0, 0, 1}, 	// M
  {1, 1, 1, 0, 0, 0, 1},  	// m
};


volatile boolean wasTimeEverSet = false;
volatile boolean showingTime    = false;
volatile boolean settingTime    = false;

byte crtIndex = 0;  // 0..3, index in array timeDigits;
byte timeDigits[4] = {0, 1, 2, 3};
int hour   = 0;
int minute = 0;
int second = 0;
byte  crtValue =  0;  // used when setting the time, one digit at a time (for HHMM);
short crtState = -1;  // used when setting the time;
boolean newState = false;


void setup()
{
#ifdef _DEBUG_
  Serial.begin(9600);
  Serial.println("in setup");
#endif

  // each of display's 7 segment is connected to an output;
  for (byte i=0; i<7; i++)
  {
    pinMode(segmentPin[i], OUTPUT);
  }

  // buttons to activate tube and for setting up the time;
  pinMode(PIN_BUTTON_ACTIVATE, INPUT_PULLUP);
  pinMode(PIN_BUTTON_SET_TIME, INPUT_PULLUP);

  blankDisplay();
}


void loop()
{
  if (digitalRead(PIN_BUTTON_ACTIVATE) == LOW)
  {
#ifdef _DEBUG_
    Serial.print("settingTime=");
    Serial.println(settingTime);
#endif
    delay(200);	// debouncing;

    if (settingTime)
    {
      newState = false;

      crtValue++;
      if (crtValue > 9)
          crtValue = 0;
      displayValue(crtValue);

#ifdef _DEBUG_
      Serial.print ("crtValue=");
      Serial.println(crtValue);
#endif
    }
    else
    {
      getTimeFromRTC();
      splitTime();

      // show time as (h)h-mm;
      showingTime = true;
    }
  }
  
  if (digitalRead(PIN_BUTTON_SET_TIME) == LOW)
  {
    delay(200);	// debouncing;

#ifdef _DEBUG_
    Serial.print("crtState=");
    Serial.println(crtState);
#endif

    if (crtState == -1)
    {
      // user is initiating setting up the time;
      settingTime = true;
    }
 
    if (settingTime)
    {
      newState = true;
      crtState++;
    }

#ifdef _DEBUG_
    Serial.print("settingTime=");
    Serial.println(settingTime);
#endif
  }

  if (showingTime)
  {
#ifdef _DEBUG_
    Serial.print  ("show time, digit ");
    Serial.println(crtIndex);
#endif
    if (crtIndex == 0 && timeDigits[0] == 0)
    {
      // do not show the leading 0; 
    }
    else
    {
      if (crtIndex == 2)
      {
        // show the dash between hours and minutes;
        displayDash();
        // hold it for a second;
        delay(1000);
      }

      // make the digit flash (otherwise, if 2 consecutive digits are the same, you won't see a difference);
      displayDigit(crtIndex);
      // hold the digit for a second;
      delay(1000);
    }

    crtIndex++;
    if (crtIndex > 3)
    {
      showingTime = false;  // time will show again when button is pressed;
      crtIndex = 0;
      blankDisplay();
    }
  }

  if (settingTime)
  {
    if (newState)
    {
      newState = false;

      // need to save the crtValue;
      if (crtState > 0)
      {
#ifdef _DEBUG_
        Serial.print("set value ");
        Serial.print(crtValue);
        Serial.print(" at index ");
        Serial.println(crtState-1);
#endif
        timeDigits[crtState-1] = crtValue;
      }

      if (crtState > 3)
      {
        settingTime = false;
        crtState = -1;
        blankDisplay();

#ifdef _DEBUG_
        Serial.print("saving time: ");
        Serial.print(10 * timeDigits[0] + timeDigits[1]);
        Serial.print(":");
        Serial.println(10 * timeDigits[2] + timeDigits[3]);
        Serial.print("settingTime=");
        Serial.println(settingTime);
#endif
        // time is set only after all 4 digits (HhMm) were input, that is, after state "m" is left;
        setTime(10 * timeDigits[0] + timeDigits[1], 10 * timeDigits[2] + timeDigits[3], 0);
      }
      else
      {
        displayCrtState();  // one of the 4: H, h, M, m
        // hold it for a bit;
        delay(100);

        // start setting the value from 0;
        crtValue = 0;
      }    
    }
  }
}


void displayDigit(byte index)
{
  blankDisplay();
  delay(100);

  byte digit = timeDigits[index];

  // turn on the necessary segments of the digit;
  for (byte i=0; i<7; i++)
  {
    digitalWrite(segmentPin[i], digits[digit][i]);
  }
}


void displayValue(byte crtValue)
{
  blankDisplay();
  delay(100);

  // turn on the necessary segments;
  for (byte i=0; i<7; i++)
  {
    digitalWrite(segmentPin[i], digits[crtValue][i]);
  }
}


void blankDisplay()
{
  // turn off all 7 segments;
  for (byte i=0; i<7; i++)
  {
    digitalWrite(segmentPin[i], 1);
  }
}


void displayDash()
{
  blankDisplay();
  delay(100);
  digitalWrite(segD, 0);
}


void displayCrtState()
{
#ifdef _DEBUG_
    Serial.print  ("crt state is ");
    Serial.println(crtState);
#endif

  blankDisplay();
  delay(100);

  // turn on the necessary segments of the state/letter;
  for (byte i=0; i<7; i++)
  {
    digitalWrite(segmentPin[i], state[crtState][i]);
  }
}


//**********************************************************************************
// Read the entire RTC buffer
//
void getTimeFromRTC()
{
  int rtc[7];
  RTC_DS1307.get(rtc, true);

  // check to avoid glitches;
  if (rtc[DS1307_MIN] < 60 && rtc[DS1307_HR] < 24 && rtc[DS1307_SEC] < 60)
  {
    second = rtc[DS1307_SEC];
    minute = rtc[DS1307_MIN];
    hour   = rtc[DS1307_HR];
  }
/*
  // check to avoid glitches;
  if (rtc[DS1307_YR] <= 2050 && rtc[DS1307_MTH] <= 12  && rtc[DS1307_DATE] <= 31)
  {
    day    = rtc[DS1307_DATE];
    month  = rtc[DS1307_MTH];
    year   = rtc[DS1307_YR];
  }
*/  
  // The RTC may have a dead battery or may have never been initialized
  // If so, the RTC doesn't run until it is set.
  // Here we check once to see if it is running and start it if not.
  if (!wasTimeEverSet) {
    wasTimeEverSet = true;
    if (hour == 0 && minute == 0 && second == 0)
    {
      // set an arbitrary time to get the RTC going;
      setTime(10,23,45);
    }
  }

#ifdef _DEBUG_
    Serial.print("Time is ");
    Serial.print(rtc[DS1307_HR]);
    Serial.print(":");
    Serial.print(rtc[DS1307_MIN]);
    Serial.print(":");
    Serial.println(rtc[DS1307_SEC]);
#endif

}


//**********************************************************************************
//
void setTime(int hh, int mm, int ss)
{
  RTC_DS1307.stop();
  RTC_DS1307.set(DS1307_SEC,  ss);
  RTC_DS1307.set(DS1307_MIN,  mm);
  RTC_DS1307.set(DS1307_HR,   hh);
  RTC_DS1307.start();
}


void splitTime()
{
  timeDigits[0] = hour / 10;
  timeDigits[1] = hour % 10;
  timeDigits[2] = minute/10;
  timeDigits[3] = minute%10;
}

The single digit numitron clock is the simplest possible clock, in terms of the number of components included. The numitron tube is connected directly to the processor's outputs, the common electrode being wired to Vcc. I noticed that the 3.7V LiPo battery is not reliably capable to light up the filaments. USB's 5V gives the tube a stable functionality.

Below are some photos.

I was actually able to design the improvised RTC "shield" for ProMini shown in the above photo. Ordered from oshpark and shared here:

The "second" simplest single digit clock would be the one using a 7-segment LED display. It is the "second" simplest just because it requires 7 more current-limiting resistors. Otherwise, if the wiring (numitron tube and 7-segment display) is similar, the above code works with no changes (tried and proven).

Shown above is another ProMini-based prototype of a single digit clock, without the RTC shield. I expect this single digit 7-segment clock to work with the LiPo battery shield (unlike the single numitron clock). Note that the display is common anode, with the anode wired to Vcc and each cathode connected to processor's outputs. The segment is lit when the output is grounded (set to digital 0), similar to the numitron's driving.

Enclosure ideas for WiFiChron and other clocks

It turns out that most electronics, even prototypes, can be easily enclosed with Lego. And that means no screws, no glue, no fasteners, zero tools, just the bricks and some imagination.

This is the HDSP clock variant with 1" displays driven by HT16K33 (introduced here). The board was cut and filed (0.5mm on each side) to fit snug between the walls (see this).

Next is a HDSP clock variant with two Adafruit Quad Alphanumeric displays.

Similarly, the PCB was cut and filed a bit. The assembly fits solidly between the bricks (no movement when shaken). As in the previous build, the exposed PCB is kind-of-required to allow access to the two buttons (set hours, set minutes).

Both of the above can be mounted on a Lego wall (as found in schools) or they can desk-stand on their own.

Here is an example of a Lego-encapsulated WifiChron.

The PCB was also filed about 0.5mm on each side to fit between the lateral brick walls. It did not have to be fastened in any other way. The ESP8266 module fits inside nicely. The 3 buttons and the USB mini B connector are all easily accessible from the back.

Below is the Lego version of the Axiris clock.

Since it does not have any buttons, the time is set through Bluetooth (command "SET TIME=hh:mm", sent from Terminal app while BT paired).

And finally, a couple of OLED clocks, both running the same software on similar hardware: pro-mini + OLED shield and wsduino + 2.42" OLED shield, respectively.

Note that this is the prototype version, using a LiPo battery with charger (similar to the one shown here).

Again, all the above enclosures feel solid: nothing moves or rattles when upside down or even shaken. I did not try dropping them though :)

And lastly, the WiFiChron with Adafruit quad 0.56" displays from the previous post, sandwiched between scrap plexiglass plates:

More WiFiChron variants

This post shows two WiFiChron mods, that look more like finished projects rather than just experiments.

First one uses the WiFiChron board connected on I2C to two Adafruit Quad Alphanumeric Displays (I2C addresses 0x70 and 0x71). The WiFiChron software has similar adaptation as the one for HDSP clock (see this post for details).

Did I mention that two plexiglass plates are still waiting to be cut and screwed in the standoffs?

This (poor) video shows it in action.

The interesting thing about the Chinese clones (of the Adafruit displays) I had in hand is that each module has one (2 digit) display red and the other orange. Initially I thought it's a manufacturing error, but after checking, it seems that this is intended (for reasons I do not understand).

The second one is an "HDSP clock" with a 8-character display with 16-segment LED modules, introduced here, cased in a LEGO enclosure.

After cutting the top of board off (since there is no HDSP-2534) and a little filing of all sides, the PCB fit perfectly between the LEGO bricks.

For this display, the line that has to be enabled (un-commented) in DAL.h is:

#define DISPLAY_HT16K33

Alternative displays for HDSP or WiFiChron clocks

So you would like to build your own HDSP clock or WiFiChron clock but you find the HDSP-2534 display too small or too expensive. Why not just replace it with a bigger 8-character display, like the 1-inch 8 x 16-segment or two cascaded Adafruit 0.54" 4 x 14-segment backpacks? We have you covered, in software. Both these displays are now supported, as extension classes of the DAL (Display Abstraction Layer), together with the 128x64 I2C OLED and the HT1632-based 32x8 LED matrix display (used to be from Sure  Electronics). Support could be further extended to LCD displays (think big font on 40x4), MAX6955 with 8 x 16 segment etc., basically anything that can show 8 alphanumeric characters (numbers only, like regular Nixie tubes, would not suffice).

Below are some examples.

Two Adafruit 4-character backpacks are connected on I2C, addresses 0x70 (default) and 0x71, handled by class DisplayAda14seg, which in turn uses the Adafruit_LEDBackpack library.

To enable this display, uncomment the line (in DAL.h, comment out the rest):

#define DISPLAY_ADA_14SEG  // 2 x Adafruit 4x14seg displays;

Functionality for the 8x32 (or 16x32) LED matrix display is implemented in class DisplayHT1632, which is based on code recycled from Wise Clock 4. To enable this display, simply uncomment the line (in DAL.h, comment out the others):

#define DISPLAY_HT1632	 // Sure 8x32 LED matrix controlled by HT1632;

To accommodate the 8 characters on a 32-pixel line, fontTiny had to be used (each character is 4 pixels wide).

Note the connections for the HT1632 display (in DisplayHT1632.cpp):

#define HT1632_DATA 4 // Data pin (pin 7 of display connector)

#define HT1632_CS         3      // Chip Select (pin 1 of display connnector)

#define HT1632_WRCLK 2 // Write clock pin (pin 5 of display connector)

#define HT1632_CLK 5 // clock pin (pin 2 of display connector)

Other possible definitions in DAL.h are:

//****************************************************************************************
// Define the display you wish to use here.
// Comment out the ones not used.

//#define DISPLAY_HDSP2534	// original HDSP-2534 display in HDSP clock;
//#define DISPLAY_HUB08		// TODO: 8x32 LED matrix display with cascading shift registers (?)
//#define DISPLAY_DL1414	// 2 x DL1414; tested June 23, 2018 (http://timewitharduino.blogspot.com/2018/06/wifichron-adapter-for-dl-1414-displays.html)
//#define DISPLAY_HT16K33	// my 8x16-segment driven by HK16K33, tested Jul 26, 2020;
//#define DISPLAY_OLED		// I2C OLED; tested
  #define DISPLAY_HT1632	// Sure 8x32 LED matrix controlled by HT1632; tested Aug 14, 2020;
//#define DISPLAY_MAX6955	// TODO: 8x16 segment driven by MAX6955
//#define DISPLAY_LCD1602	// TODO: classic LCD 16x2 (or better 40x4, with big font);
//#define DISPLAY_ADA_14SEG	// 2 x Adafruit 4x14seg displays, wired on 0x70 and 0x71 I2C addresses; tested Jul 26, 2020;

// show time on the 60-pixel Adafruit Neopixel ring;
//#define _ADD_NEOPIXEL_
//****************************************************************************************

And so on.

HDSP clock fully through-hole revision 3

The only SMD component in the HDSP clock was the USB miniB connector. To make the kit completely beginner-friendly, this connector was replaced by either of its two (right angle or straight) through hole equivalents. Other changes (from revision 2) are:

• fixed the two smaller pads for DS1307
• some re-routing (which reduced the number of vias to 5)

The TH right angle USB connector is to be mounted on the top, as shown below.

The straight USB connector can only be mounted on the bottom side of the PCB, as shown below.

This latter configuration allows the clock to be used without any additional enclosure, with just two standoffs holding it in a vertical position, like this:

Assembly instructions for the HDSP clock kit can be found here, with the only difference being the last step, where the miniB USB connector is soldered.