Planet Arduino

Analog panel meters (APM) are instruments that measure and display variables on a dial, usually with a moving pointer or needle in front of a proportional scale.

I wanted to try using these meters in a clock project but have been put off by their high unit cost. However, a recent ‘fire sale’ at a local electronics wholesaler provided the opportunity to acquire 10 meters for just a few cents each, so this project became feasible.

All the files and software for this project are available online at my code repository.

The concept for this clock is to display the clock’s date and time elements on a number of separate meters, each driven by the voltage produced by the microcontroller analog output.

Analog Panel Meters

Panel meters are simple electromechanical devices that can be used to measure currents, voltages, and resistances.

The basic part of any meter is the movement (a moving coil with associate mechanical pivots and adjusters). The movement moves the needle over the calibrated range to indicate the quantity being measured.

The coil works as a simple electromagnet – if you apply a voltage to the coil and a current flows through it, it magnetizes its iron core and creates a magnetic field that moves the pointer in proportion to the voltage applied. A spring holds tension on the movement to balance the electromagnetic force and return it to the zero position when no voltage is applied.

A good video of how meters work can be found here.

The panels meters I purchased (Jaycar QP5020) are designed to measure a full-scale deflection of 20V DC, but the maximum analog output from the microcontroller is 5V, so something needed to be modified.

Meter Recalibration

Most panel meters are just a raw movement, with a certain sensitivity, often written on the lower portion of the scale. Typical wording would be “10 mA FS” to indicate that the meter needs a 10mA current through it for full scale deflection. This full scale current usually has no relation to the indicator scale markings.

To recalibrate the meter you need to adapt the resistance of the driving circuitry to achieve the full scale current of the panel meter with the new driving voltage. You can see in the photo below that, for the volt meter used in this project, there was an internal resistor in series with the + terminal used to calibrate the meter.

For the as-purchased full scale range (1mA from the meter specs), the 20V reading was achieved with a 20kΩ resistor in series with the measured voltage. By Ohms Law (I=V/R) this gives a full scale current of (20V/20kΩ) = 1mA. So, reversing the calculation, to show a full scale voltage of 5V – the maximum Arduino analog output – we need to replace the resistor with a (5V/1mA) = 5kΩ resistor.

Changing Meter’s Faceplate

Once the range is changed the original panel meter indicator scale becomes obsolete, so it needs a new faceplate. In any case I wanted to show time and date values, not voltages, so I went searching for software that could help with this task.

I found 2 commonly referenced/recommended specialist tools that run under Microsoft Windows:

• Meter (link here) has a paid and free version. The free MeterBasic (a cut down version of the paid version) is sufficient for a hobbyist who needs to generate the occasional simple scale. It is based on a subset of the features found in Meter and has no time or usage limitations. The design of the scale/faceplate is based on input entered into fixed parameter fields, with a draft displayed in the application window before printing it out.
• Galva (link here) is a free program that was specifically designed to draw precise dials for galvanometers, potentiometer, CVs, and other dial-type devices, although it is now more general. It can draw scales with all kinds of shapes (curved or straight) and graduations (linear, functions of a power, logarithmic, specific, manual, etc.). Scales are produced using a scripting language with an on-screen graphical preview before printing.

After experimenting with both I decided to use Galva. The learning curve was much steeper but it seemed to be more flexible and the output looker cleaner on my printer. The script used to produce the scales shown below is included within in the project sketch source folders.

MCU Analog Output

On thing to note is that the MCU ‘analog’ output is really a PWM output, which means that the meter is not measuring a constant voltage but an oscillating square wave.

I ran some tests with the meters used in this project and they did not seem to be affected by this (ie, setting the voltage to a known value showed the approriate proportional movement of the meter dial). However, this may not be the case for other meters and will need to be determined on a case by case basis. The solution would be to smooth out the voltage with a capacitor – lots on material on the internet for this.

It is also worth noting that USB power supplies are not usually exactly 5V and therefore the MCU output cannot be exact, creating errors in the full scale deflection of the meter. There are a couple of easy solutions for this:

1. Ensure that the voltage is correct. My experience is that a USB power supply is usually just under 5V, so this is the option I used. By adding by adding in a step-up buck converter at the USB power input to the clock, I ensure that the voltage remains at exactly 5V for ll the clock circuits. This makes the internal voltage independent of the supply voltage as long as it is 5V or less. If your usual supply is greater that 5V then a step-down buck converter could be used to the same effect.
2. Match the internal resistance to the expected voltage (eg, use an adjustable variable resistor instead of a fixed value). This works well for an arbitrary voltage but only for that specific voltage. Should the voltage fluctuate it will stop working and need readjusting.

System Hardware

Once I was sure that the concept was valid, it was time to consider the system architecture.

The clock is powered through a USB power-only socket. A step-up voltage converter is used to maintain the calibrated, accurate, constant 5V for the clock circuits.

The RTC time clock is a DS3231 module with an I²C interface. The APM displays month, date, day of week, hours and minutes on the meter dials APM1 through APM55.

Finally, two momentarily-on switches (for Mode and Set) are used for setting and displaying the time.

The hardware was prototyped using my existing prototyping modules (see this previous blog post) modules and an Arduino Uno, shown below.

Clock Case

Front Panel and Enclosure

For this project the case is made from three parts – a perspex front panel, plywood sides and a removable plywood back.

The perspex front panel was drawn in Fusion360 to produce a 1:1 paper template that allowed me to easily drill out the holes for the APMs. This does not need to be too neat as the holes are hidden behind the APM faces and the outside edges are covered by the enclosure face frame when installed.

The inside of the transparent perspex panel was sanded and spray painted black to produce the effect shown in the photos below.

The sides are a simple 12mm plywood box with a mitred face frame. The perspex panel was butted to the inside of the face frame and fixed in place with a bead of hot glue around the inside edge join in the box.

The back (not shown) is 3mm plywood attached with M3 machine screws into threaded inserts installed on the edge of the plywood box. The back has a cut out to install the USB connector and two tact switches.

Switches and Power Connection

A 3D printed part was produced as a scaffold for the USB connector and Mode/Set switches. This was modelled in Fusion 360, shown below.

The 3D model for this is included in the project files.

Software

To simplify software implementation I used my MD_DS3231 and MD_UISWitch libraries to manage the DS3231 RTC and the switches using the Arduino Pro Mini.

The software for this project is available from my code repository. Essentially it does 4 things:

1. Periodically update the display. Checks every second and updates when the minutes change.
2. Manage time setup progression when the mode switch is pressed.
3. Manage Summer Time offset when the mode switch is long pressed.
4. Display full range on all APM when the Set switch is pressed.

Display Update

The clock does not show seconds, so the minimum time resolution is 1 minute. The RTC is checked and the display updated every second by counting elapsed milliseconds.

Time Setup

The actual time needs to be input at the start and, from time to time, may need adjusting.

Adjusting the time is started by pressing the Mode switch to move between each APM, the Set switch to increment the value displayed, with roll-around, and the the Mode switch to move on to the next value to be changed. To show which APM is being the ‘current’ value being changed, all the other meter displays are set to zero.

Displays are updated in the order month, date, day of week, hour and minute. As this clock has a 12 hour dial, while the hours are being edited the minute display will move to zero if the hours are in the morning (AM) and move to full scale when the hours are PM.

P:ressing Mode after the last value (minutes) is set will set the time. A one minute inactivity timeout prevents the display from remaining in edit mode indefinitely – the time setting process is aborted and the new time is not set.

Summer Time Offset

Rather than go through the process of setting a new time the Summer Time period, a long press of the mode switch will set up an automatic +1 hour display offset to the RTC time. Summer Time offset is reset to +0 by another long press. The current Summer Time mode is stored in EEPROM and will be retained between power cycles.

Full Range Check

It is useful to occasionally check the full range is accurate. While the clock is displaying the time, pressing the Set switch moves the APM needles to full scale. Releasing the Set switch puts the clock back in normal display mode.

Putting it all together

Once the meters were installed in the enclosure, a ground wire was connected to all the – terminals and a lead to all the + terminals.

The USB and switch module was hot glued to the back panel. The hot glue was also spread over the switch connections to provide some mechanical stability for the wires.

The USB connector and the switch were added to the back panel and wired in. Hot glue was again used to lock the USB socket in place and reinforce the wire connections on the back.

All wires were then soldered to the Pro Mini and it, and the clock module, were hot glued to the base of the enclosure.

The entire was then unit tested before finally closing the case and putting the new clock on the shelf in my office.

This is a rewrite of a project I created in 2010 which brought me a lot of joy, so I hope you enjoy it too. Please read the entire article before starting your own. You can still make it today, the parts are easily available.

I’ve always enjoyed making Arduino-powered clocks, however over time they tended to become increasingly complex. So to counter this, allow me to introduce you to “Blinky” the one-eyed clock:

It reminds me of the giant killer orb “Rover” from “The Prisoner“… Using a minimal Arduino bootrom system, a DS1307 real time clock IC and an RGB diffused LED, you can make a clock that blinks the time, using the colours of the LED to note different numerical values.

For example, if the time is 12:45, the clock will blink red 12 times, then show blue for a second (think of this as the colon on a digital clock) then blink four times in green (for forty minutes), then blink three times in red for the individual minutes.

If there is a zero, blink blue quickly. Then the clock will not display anything for around forty seconds, then repeat the process. Here he (she, it?) is blinking the time:

Setting the clock is simple. It is set to start at 12:00 upon power up. So for the first use you have to wait until about five seconds before midday or midnight, then power it up. To save cost it doesn’t use a backup lithium battery on the real-time clock IC, but you could add one if required. So let’s get started.

The first thing to do was test the RGB LED for brightness levels, so I just connected it to the digital output pins of my Arduino-compatible board via suitable current-limiting resistors. Red, green and blue to D9, D10 and D11 respectively. Each LED is going to be different, so to ensure maximum brightness without causing any damage you need to calculate the appropriate resistor values.

This is quite easy, the formula is: resistor (ohms) = voltage drop / LED current So if you have a 5V supply, and LED that needs only 2 volts, and draws 20 milliamps (0.2 amps) , the calculation will be: resistor = (5-2)/0.02 = 150 ohms. To be safe I used 180 ohm resistors. The LED was tested with this simple sketch:

/*
  blinky LED test
 */

int red = 2;
int green = 3;
int blue = 4;
int d = 300;
void setup()
{
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
}

void loop()
{
  digitalWrite(red, HIGH);
  delay(d);
  digitalWrite(red, LOW);
  delay(d);
  digitalWrite(green, HIGH);
  delay(d);
  digitalWrite(green, LOW);
  delay(d);
  digitalWrite(blue, HIGH);
  delay(d);
  digitalWrite(blue, LOW);
  delay(d);
}

It was interesting to alter the value of d, the delay variable, to get an idea for an appropriate blinking speed. Originally the plan was to have the LED in a photo frame, but it was decided to mount a ping-pong ball over the LED for a retro-style look. Here is a short video of the result of the test:

If you are going to use a ping-pong ball, please be careful when cutting into it with a knife, initially it may require a lot of force, but once the knife cuts through it does so very quickly.

Now it was time to develop the sketch to convert time into blinks. The sketch itself is quite simple. Read the hours and minutes from the DS1307 timer IC; convert the hours to 12 hour time; then blink an LED for the number of hours, display another colour for the colon; divide the minutes by ten and blink that in another colour; then the modulus of minutes and ten to find the individual minutes, and blink those out. Here is the first test sketch:

/*
  "blinky" the one-eyed clock
  Version beta 1
  John Boxall August 2010/6th April 2022 - http://tronixstuff.com
  DS1307/i2c timekeeping based on code by Maurice Ribble 17-4-2008 -     http://www.glacialwanderer.com/hobbyrobotics
*/

#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68

int red = 9; // LEDs connected to these pins as you might want to PWM them to alter brightness
int green = 10;
int blue = 11;

// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
  return ( (val / 10 * 16) + (val % 10) );
}

// Convert binary coded decimal to normal decimal numbers 
byte bcdToDec(byte val)
{
  return ( (val / 16 * 10) + (val % 16) );
}

void setDateDs1307(byte second,        // 0-59
                   byte minute,        // 0-59
                   byte hour,          // 1-23
                   byte dayOfWeek,     // 1-7
                   byte dayOfMonth,    // 1-28/29/30/31
                   byte month,         // 1-12
                   byte year)          // 0-99
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0);
  Wire.write(decToBcd(second));    // 0 to bit 7 starts the clock
  Wire.write(decToBcd(minute));
  Wire.write(decToBcd(hour));
  Wire.write(decToBcd(dayOfWeek));
  Wire.write(decToBcd(dayOfMonth));
  Wire.write(decToBcd(month));
  Wire.write(decToBcd(year));
  Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave
  Wire.endTransmission();
}

void getDateDs1307(byte *second,
                   byte *minute,
                   byte *hour,
                   byte *dayOfWeek,
                   byte *dayOfMonth,
                   byte *month,
                   byte *year)
{
  // Reset the register pointer
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
  *second     = bcdToDec(Wire.read() & 0x7f);
  *minute     = bcdToDec(Wire.read());
  *hour       = bcdToDec(Wire.read() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.read());
  *dayOfMonth = bcdToDec(Wire.read());
  *month      = bcdToDec(Wire.read());
  *year       = bcdToDec(Wire.read());
}

void blinkLED(int colour, int ondelay, int offdelay, int blinks)
// blinks LED on pin 'colour' for 'blinks' times with on and off delay of 'ondelay', 'offdelay'
// colour: 9 is red, 10 is green, 11 is blue
{
  for (int a = 0; a < blinks; a++) {
    digitalWrite(colour, HIGH); delay(ondelay); digitalWrite(colour, LOW); delay(offdelay);
  }
}

void blinkTime() // blinks the time
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  float aa;
  int bb;

  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
  // convert hours from 24 to 12 hour time
  if (hour == 0)
  {
    hour = 12;
  }
  if (hour > 12)
  {
    hour = hour - 12;
  }
  blinkLED(9, 500, 500, hour); // blink hours in red
  blinkLED(11, 1000, 500, 1); // show blue for one second
  aa = minute;
  aa = aa / 10;
  bb = int(aa); // find the value of tens of minutes (0~5)
  if (bb > 0)
  {
    blinkLED(10, 500, 500, bb); // blink tens of minutes
  }
  if (bb == 0) // but if the time is something like 03:02?
  {
    blinkLED(11, 200, 200, 1); // blink blue quickly for zero
  }
  aa = minute % 10; // find modulo of minutes to get single minutes
  if (bb > 0)
  {
    blinkLED(9, 500, 500, bb); 
  }
  if (bb == 0)
  {
    blinkLED(11, 200, 200, 1); // blink blue quickly for zero
  }
}

void setup()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  Wire.begin();
  second = 0;
  minute = 17;
  hour = 4;
  dayOfWeek = 6; // these values are moot, but need to store something
  dayOfMonth = 28;
  month = 5;
  year = 10;
  setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year); 
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
}

void loop() 
{
  blinkTime();
  delay(5000); 
}

Finally, the code was tested using the Arduino-compatible board and my home-made DS1307 real time clock shield (hey it was 2010, DS32xx were expensive). It is best to use existing hardware while testing, before committing to purchasing new hardware and so on. So here it is on the breadboard:

Here is the prototype in action:

If you’re wondering why the videos are potato-cam quality, smartphones couldn’t record using 4K Ultra HD in 2010.

But perhaps the first version was a little bland. By using analogWrite() we can control the brightness of the LED segments. So I’ve added two more functions, whiteGlow() and blueGlow(); whose purpose is to make the display “glow” by increasing then decreasing the brightness.

And I’ve scaled back the amount of blinking, to make blinky less obvious. So now the display will glow white to announce the forthcoming display of time, wait a second, blink the time (with a blue glowing colon) then stay dark for ten seconds before repeating the process. Here is a quick demonstration of this display style:

Here is the sketch for the above demonstration, and the final one I will use with the hardware prototype:

/*
  "blinky" the one-eyed clock - Version 2.1
  John Boxall 04 August 2010/6th April 2022
  IDGAF licence
  DS1307/i2c timekeeping based on code by Maurice Ribble
  17-4-2008 - http://www.glacialwanderer.com/hobbyrobotics
*/

#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68

int red = 9; // LEDs connected to these pins as you might want to PWM them to alter brightness
int green = 10;
int blue = 11;

// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
  return ( (val / 10 * 16) + (val % 10) );
}

// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
  return ( (val / 16 * 10) + (val % 16) );
}

void setDateDs1307(byte second,        // 0-59
                   byte minute,        // 0-59
                   byte hour,          // 1-23
                   byte dayOfWeek,     // 1-7
                   byte dayOfMonth,    // 1-28/29/30/31
                   byte month,         // 1-12
                   byte year)          // 0-99
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0);
  Wire.write(decToBcd(second));    // 0 to bit 7 starts the clock
  Wire.write(decToBcd(minute));
  Wire.write(decToBcd(hour));
  Wire.write(decToBcd(dayOfWeek));
  Wire.write(decToBcd(dayOfMonth));
  Wire.write(decToBcd(month));
  Wire.write(decToBcd(year));
  Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave
  Wire.endTransmission();
}

void getDateDs1307(byte *second,
                   byte *minute,
                   byte *hour,
                   byte *dayOfWeek,
                   byte *dayOfMonth,
                   byte *month,
                   byte *year)
{
  // Reset the register pointer
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
  *second     = bcdToDec(Wire.read() & 0x7f);
  *minute     = bcdToDec(Wire.read());
  *hour       = bcdToDec(Wire.read() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.read());
  *dayOfMonth = bcdToDec(Wire.read());
  *month      = bcdToDec(Wire.read());
  *year       = bcdToDec(Wire.read());
}

void blinkLED(int colour, int ondelay, int offdelay, int blinks)
// blinks LED on pin 'colour' for 'blinks' times with on and off delay of 'ondelay', 'offdelay'
// colour: 9 is red, 10 is green, 11 is blue
{

  for (int a = 0; a < blinks; a++)
  {
    digitalWrite(colour, HIGH);
    delay(ondelay);
    digitalWrite(colour, LOW);
    delay(offdelay);
  }
}

void blinkTime()
// blinks the time
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  float aa;
  int bb;
  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);

  // convert hours from 24 to 12 hour time
  if (hour == 0)
  {
    hour = 12;
  }
  if (hour > 12)
  {
    hour = hour - 12;
  }
  blinkLED(9, 500, 500, hour); // blink hours in red
  blueGlow(1, 10);
  aa = minute;
  aa = aa / 10;
  bb = int(aa); // find the value of tens of minutes (0~5)
  if (bb > 0)
  {
    blinkLED(10, 500, 500, bb); // blink tens of minutes
  }
  if (bb == 0) // but if the time is something like 03:02?
  {
    blinkLED(11, 200, 200, 1); // blink blue quickly for zero
  }
  aa = minute % 10; // find modulo of minutes to get single minutes
  bb = aa;
  if (bb > 0)
  {
    blinkLED(9, 500, 500, bb); // blink tens of minutes
  }
  if (bb == 0)
  {
    blinkLED(11, 200, 200, 1); // blink blue quickly for zero
  }
}

void whiteGlow(int n, int d)
{
  for (int nn = 0; nn < n; nn++)
  {
    for (int a = 0; a <= 255; a++)
    {
      analogWrite(red, a);
      analogWrite(green, a);
      analogWrite(blue, a);
      delay(d);
    }
    for (int a = 255; a >= 0; --a)
    {
      analogWrite(red, a);
      analogWrite(green, a);
      analogWrite(blue, a);
      delay(d);
    }
  }
}

void blueGlow(int n, int d)
{
  for (int nn = 0; nn < n; nn++)
  {
    for (int a = 0; a <= 255; a++)
    {
      analogWrite(blue, a);
      delay(d);
    }
    for (int a = 255; a >= 0; --a)
    {
      analogWrite(blue, a);
      delay(d);
    }
  }
}

void setup()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  Wire.begin();
  second = 0;
  minute = 17;
  hour = 4;
  dayOfWeek = 6; // these values are moot, but need to store something
  dayOfMonth = 28;
  month = 5;
  year = 10;
  setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year); // every time blinky has new batteries, it will start from midnight/midday
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
}

void loop()
{
  whiteGlow(1, 10); // glow white - announces that the time will now be shown
  delay(1000); // give people a second to focus on blinky
  blinkTime();
  delay(50000); // wait 50 seconds
}

Once happy with the sketch, I put a fresh ATmega328P-PU with Arduino bootloader in the board and programmed it with the sketch, to be used in the final version. The next step is to build my own hardware. The last hardware unknown is the amount of current the circuit draws. Once I know this the correct voltage regulator and power supply can be decided upon.

I had a fair idea it would be less than 100 milliamps, so I put a 6V battery onto supply duty via a 78L05 5V regulator (data sheet), and recorded the result:

So it varies, between 20.5 and 46 mA. As it only reaches 46 mA for a short time, we could consider the constant draw to be averaged out at 30 mA. I really want this to be able to run from a battery, but without having an external lead-acid battery lurking around, it will need a plug-pack with an output voltage greater than 7V DC.

Another alternative would be to run it from a USB socket, a nice source of 5V. If doing so, there wouldn’t be a need for the 78L05 regulator. Which brings us to the circuit diagram, which includes the power regulator. I’ve also altered the resistors to suit the RGB LED used, your values may be different:

And since it’s 2022, not 2010 – I’ve replaced the DS1307 circuit with a RTC module. Y1 is a three pin 16MHz ceramic resonator, we used those in 2010 as they were cheaper and easier than a crystal and two 22pF capacitors.

The circuit does not allow for uploading code, so you will need to program the microcontroller on another Arduino or compatible board, then transfer it to the blinky circuit board as described above. At this stage you should test it again – but using a solderless breadboard. In doing so you can make final hardware checks, and generally make sure everything works as it should. This is also a good stage to double-check you are happy with the display behaviour, default time and so on.

Used the Duemilanove as a lazy 5V for testing.

Time to solder up the circuit on some stripboard. Blank stripboard varies, but luckily I found this and a nice box to hold it in:

Stripboard does vary between retailers and so on, so you will need to work out the layout with your own board. In doing so, please double-check your work – follow the layout against the schematic and so on.

Have a break, then check it again. There is nothing worse than soldering away to realise you are one strip too far over or something. My hand-eye coordination is not the best, therefore my soldering isn’t pretty, but it works:

Note that the images above are using the 2010 circuit – which had a DS1307 sub-circuit.

One would say that there is a good argument for making your own PCBs… and I would agree with that. In 2010 it wasn’t that easy or inexpensive. Now you have KiCAD and Chinese PCB fabs tripping over themselves to give you cheap boards.

The LED is soldered to some short leads to give it a bit of play, and some heatshrink over the legs to keep them isolated:

And finally, to add a DC socket to feed blinky some power:

The last thing was to check the soldering once more under natural light, to check for bridges or shorts, then have a cup of tea. Upon my return I drilled out a hole in the enclosure lid for the LED, and one one the side for the DC socket, and fitted the lot together… and success! It worked.

I hope you enjoyed making this or at least reading about it. If you find this sort of thing interesting, please consider ordering one or both of my books from No Starch Press, or other book sellers:

• Arduino Workshop, 2nd Edition – a hands-on introduction to electronics and Arduino with 65 projects
• AVR Workshop – A comprehensive introduction to working with electronics and the Microchip AVR 8-bit family of microcontrollers with over 55 projects

And as always, have fun and make something.

This is a rewrite of a project I created in 2010 which brought me a lot of joy, so I hope you enjoy it too. Please read the entire article before starting your own. You can still make it today, the parts are easily available.

I’ve always enjoyed making Arduino-powered clocks, however over time they tended to become increasingly complex. So to counter this, allow me to introduce you to “Blinky” the one-eyed clock:

It reminds me of the giant killer orb “Rover” from “The Prisoner“… Using a minimal Arduino bootrom system, a DS1307 real time clock IC and an RGB diffused LED, you can make a clock that blinks the time, using the colours of the LED to note different numerical values.

For example, if the time is 12:45, the clock will blink red 12 times, then show blue for a second (think of this as the colon on a digital clock) then blink four times in green (for forty minutes), then blink three times in red for the individual minutes.

If there is a zero, blink blue quickly. Then the clock will not display anything for around forty seconds, then repeat the process. Here he (she, it?) is blinking the time:

Setting the clock is simple. It is set to start at 12:00 upon power up. So for the first use you have to wait until about five seconds before midday or midnight, then power it up. To save cost it doesn’t use a backup lithium battery on the real-time clock IC, but you could add one if required. So let’s get started.

The first thing to do was test the RGB LED for brightness levels, so I just connected it to the digital output pins of my Arduino-compatible board via suitable current-limiting resistors. Red, green and blue to D9, D10 and D11 respectively. Each LED is going to be different, so to ensure maximum brightness without causing any damage you need to calculate the appropriate resistor values.

This is quite easy, the formula is: resistor (ohms) = voltage drop / LED current So if you have a 5V supply, and LED that needs only 2 volts, and draws 20 milliamps (0.2 amps) , the calculation will be: resistor = (5-2)/0.02 = 150 ohms. To be safe I used 180 ohm resistors. The LED was tested with this simple sketch:

	/*
	blinky LED test
	*/
	int red = 2;
	int green = 3;
	int blue = 4;
	int d = 300;
	void setup()
	{
	pinMode(red, OUTPUT);
	pinMode(green, OUTPUT);
	pinMode(blue, OUTPUT);
	}
	void loop()
	{
	digitalWrite(red, HIGH);
	delay(d);
	digitalWrite(red, LOW);
	delay(d);
	digitalWrite(green, HIGH);
	delay(d);
	digitalWrite(green, LOW);
	delay(d);
	digitalWrite(blue, HIGH);
	delay(d);
	digitalWrite(blue, LOW);
	delay(d);
	}

view raw blinkLEDtest.ino hosted with ❤ by GitHub

It was interesting to alter the value of d, the delay variable, to get an idea for an appropriate blinking speed. Originally the plan was to have the LED in a photo frame, but it was decided to mount a ping-pong ball over the LED for a retro-style look. Here is a short video of the result of the test:

If you are going to use a ping-pong ball, please be careful when cutting into it with a knife, initially it may require a lot of force, but once the knife cuts through it does so very quickly.

Now it was time to develop the sketch to convert time into blinks. The sketch itself is quite simple. Read the hours and minutes from the DS1307 timer IC; convert the hours to 12 hour time; then blink an LED for the number of hours, display another colour for the colon; divide the minutes by ten and blink that in another colour; then the modulus of minutes and ten to find the individual minutes, and blink those out. Here is the first test sketch:

	/*
	"blinky" the one-eyed clock
	Version beta 1
	John Boxall August 2010/6th April 2022 – http://tronixstuff.com
	DS1307/i2c timekeeping based on code by Maurice Ribble 17-4-2008 – http://www.glacialwanderer.com/hobbyrobotics
	*/
	#include "Wire.h"
	#define DS1307_I2C_ADDRESS 0x68
	int red = 9; // LEDs connected to these pins as you might want to PWM them to alter brightness
	int green = 10;
	int blue = 11;
	// Convert normal decimal numbers to binary coded decimal
	byte decToBcd(byte val)
	{
	return ( (val / 10 * 16) + (val % 10) );
	}
	// Convert binary coded decimal to normal decimal numbers
	byte bcdToDec(byte val)
	{
	return ( (val / 16 * 10) + (val % 16) );
	}
	void setDateDs1307(byte second, // 0-59
	byte minute, // 0-59
	byte hour, // 1-23
	byte dayOfWeek, // 1-7
	byte dayOfMonth, // 1-28/29/30/31
	byte month, // 1-12
	byte year) // 0-99
	{
	Wire.beginTransmission(DS1307_I2C_ADDRESS);
	Wire.write(0);
	Wire.write(decToBcd(second)); // 0 to bit 7 starts the clock
	Wire.write(decToBcd(minute));
	Wire.write(decToBcd(hour));
	Wire.write(decToBcd(dayOfWeek));
	Wire.write(decToBcd(dayOfMonth));
	Wire.write(decToBcd(month));
	Wire.write(decToBcd(year));
	Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register – turns on square wave
	Wire.endTransmission();
	}
	void getDateDs1307(byte *second,
	byte *minute,
	byte *hour,
	byte *dayOfWeek,
	byte *dayOfMonth,
	byte *month,
	byte *year)
	{
	// Reset the register pointer
	Wire.beginTransmission(DS1307_I2C_ADDRESS);
	Wire.write(0);
	Wire.endTransmission();
	Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
	*second = bcdToDec(Wire.read() & 0x7f);
	*minute = bcdToDec(Wire.read());
	*hour = bcdToDec(Wire.read() & 0x3f); // Need to change this if 12 hour am/pm
	*dayOfWeek = bcdToDec(Wire.read());
	*dayOfMonth = bcdToDec(Wire.read());
	*month = bcdToDec(Wire.read());
	*year = bcdToDec(Wire.read());
	}
	void blinkLED(int colour, int ondelay, int offdelay, int blinks)
	// blinks LED on pin 'colour' for 'blinks' times with on and off delay of 'ondelay', 'offdelay'
	// colour: 9 is red, 10 is green, 11 is blue
	{
	for (int a = 0; a < blinks; a++) {
	digitalWrite(colour, HIGH); delay(ondelay); digitalWrite(colour, LOW); delay(offdelay);
	}
	}
	void blinkTime() // blinks the time
	{
	byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
	float aa;
	int bb;
	getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
	// convert hours from 24 to 12 hour time
	if (hour == 0)
	{
	hour = 12;
	}
	if (hour > 12)
	{
	hour = hour – 12;
	}
	blinkLED(9, 500, 500, hour); // blink hours in red
	blinkLED(11, 1000, 500, 1); // show blue for one second
	aa = minute;
	aa = aa / 10;
	bb = int(aa); // find the value of tens of minutes (0~5)
	if (bb > 0)
	{
	blinkLED(10, 500, 500, bb); // blink tens of minutes
	}
	if (bb == 0) // but if the time is something like 03:02?
	{
	blinkLED(11, 200, 200, 1); // blink blue quickly for zero
	}
	aa = minute % 10; // find modulo of minutes to get single minutes
	if (bb > 0)
	{
	blinkLED(9, 500, 500, bb);
	}
	if (bb == 0)
	{
	blinkLED(11, 200, 200, 1); // blink blue quickly for zero
	}
	}
	void setup()
	{
	byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
	Wire.begin();
	second = 0;
	minute = 17;
	hour = 4;
	dayOfWeek = 6; // these values are moot, but need to store something
	dayOfMonth = 28;
	month = 5;
	year = 10;
	setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
	pinMode(red, OUTPUT);
	pinMode(green, OUTPUT);
	pinMode(blue, OUTPUT);
	}
	void loop()
	{
	blinkTime();
	delay(5000);
	}

view raw blinkybeta1.ino hosted with ❤ by GitHub

Finally, the code was tested using the Arduino-compatible board and my home-made DS1307 real time clock shield (hey it was 2010, DS32xx were expensive). It is best to use existing hardware while testing, before committing to purchasing new hardware and so on. So here it is on the breadboard:

Here is the prototype in action:

If you’re wondering why the videos are potato-cam quality, smartphones couldn’t record using 4K Ultra HD in 2010.

But perhaps the first version was a little bland. By using analogWrite() we can control the brightness of the LED segments. So I’ve added two more functions, whiteGlow() and blueGlow(); whose purpose is to make the display “glow” by increasing then decreasing the brightness.

And I’ve scaled back the amount of blinking, to make blinky less obvious. So now the display will glow white to announce the forthcoming display of time, wait a second, blink the time (with a blue glowing colon) then stay dark for ten seconds before repeating the process. Here is a quick demonstration of this display style:

Here is the sketch for the above demonstration, and the final one I will use with the hardware prototype:

	/*
	"blinky" the one-eyed clock – Version 2.1
	John Boxall 04 August 2010/6th April 2022
	IDGAF licence
	DS1307/i2c timekeeping based on code by Maurice Ribble
	17-4-2008 – http://www.glacialwanderer.com/hobbyrobotics
	*/
	#include "Wire.h"
	#define DS1307_I2C_ADDRESS 0x68
	int red = 9; // LEDs connected to these pins as you might want to PWM them to alter brightness
	int green = 10;
	int blue = 11;
	// Convert normal decimal numbers to binary coded decimal
	byte decToBcd(byte val)
	{
	return ( (val / 10 * 16) + (val % 10) );
	}
	// Convert binary coded decimal to normal decimal numbers
	byte bcdToDec(byte val)
	{
	return ( (val / 16 * 10) + (val % 16) );
	}
	void setDateDs1307(byte second, // 0-59
	byte minute, // 0-59
	byte hour, // 1-23
	byte dayOfWeek, // 1-7
	byte dayOfMonth, // 1-28/29/30/31
	byte month, // 1-12
	byte year) // 0-99
	{
	Wire.beginTransmission(DS1307_I2C_ADDRESS);
	Wire.write(0);
	Wire.write(decToBcd(second)); // 0 to bit 7 starts the clock
	Wire.write(decToBcd(minute));
	Wire.write(decToBcd(hour));
	Wire.write(decToBcd(dayOfWeek));
	Wire.write(decToBcd(dayOfMonth));
	Wire.write(decToBcd(month));
	Wire.write(decToBcd(year));
	Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register – turns on square wave
	Wire.endTransmission();
	}
	void getDateDs1307(byte *second,
	byte *minute,
	byte *hour,
	byte *dayOfWeek,
	byte *dayOfMonth,
	byte *month,
	byte *year)
	{
	// Reset the register pointer
	Wire.beginTransmission(DS1307_I2C_ADDRESS);
	Wire.write(0);
	Wire.endTransmission();
	Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
	*second = bcdToDec(Wire.read() & 0x7f);
	*minute = bcdToDec(Wire.read());
	*hour = bcdToDec(Wire.read() & 0x3f); // Need to change this if 12 hour am/pm
	*dayOfWeek = bcdToDec(Wire.read());
	*dayOfMonth = bcdToDec(Wire.read());
	*month = bcdToDec(Wire.read());
	*year = bcdToDec(Wire.read());
	}
	void blinkLED(int colour, int ondelay, int offdelay, int blinks)
	// blinks LED on pin 'colour' for 'blinks' times with on and off delay of 'ondelay', 'offdelay'
	// colour: 9 is red, 10 is green, 11 is blue
	{
	for (int a = 0; a < blinks; a++)
	{
	digitalWrite(colour, HIGH);
	delay(ondelay);
	digitalWrite(colour, LOW);
	delay(offdelay);
	}
	}
	void blinkTime()
	// blinks the time
	{
	byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
	float aa;
	int bb;
	getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
	// convert hours from 24 to 12 hour time
	if (hour == 0)
	{
	hour = 12;
	}
	if (hour > 12)
	{
	hour = hour – 12;
	}
	blinkLED(9, 500, 500, hour); // blink hours in red
	blueGlow(1, 10);
	aa = minute;
	aa = aa / 10;
	bb = int(aa); // find the value of tens of minutes (0~5)
	if (bb > 0)
	{
	blinkLED(10, 500, 500, bb); // blink tens of minutes
	}
	if (bb == 0) // but if the time is something like 03:02?
	{
	blinkLED(11, 200, 200, 1); // blink blue quickly for zero
	}
	aa = minute % 10; // find modulo of minutes to get single minutes
	bb = aa;
	if (bb > 0)
	{
	blinkLED(9, 500, 500, bb); // blink tens of minutes
	}
	if (bb == 0)
	{
	blinkLED(11, 200, 200, 1); // blink blue quickly for zero
	}
	}
	void whiteGlow(int n, int d)
	{
	for (int nn = 0; nn < n; nn++)
	{
	for (int a = 0; a <= 255; a++)
	{
	analogWrite(red, a);
	analogWrite(green, a);
	analogWrite(blue, a);
	delay(d);
	}
	for (int a = 255; a >= 0; –a)
	{
	analogWrite(red, a);
	analogWrite(green, a);
	analogWrite(blue, a);
	delay(d);
	}
	}
	}
	void blueGlow(int n, int d)
	{
	for (int nn = 0; nn < n; nn++)
	{
	for (int a = 0; a <= 255; a++)
	{
	analogWrite(blue, a);
	delay(d);
	}
	for (int a = 255; a >= 0; –a)
	{
	analogWrite(blue, a);
	delay(d);
	}
	}
	}
	void setup()
	{
	byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
	Wire.begin();
	second = 0;
	minute = 17;
	hour = 4;
	dayOfWeek = 6; // these values are moot, but need to store something
	dayOfMonth = 28;
	month = 5;
	year = 10;
	setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year); // every time blinky has new batteries, it will start from midnight/midday
	pinMode(red, OUTPUT);
	pinMode(green, OUTPUT);
	pinMode(blue, OUTPUT);
	}
	void loop()
	{
	whiteGlow(1, 10); // glow white – announces that the time will now be shown
	delay(1000); // give people a second to focus on blinky
	blinkTime();
	delay(50000); // wait 50 seconds
	}

view raw blinkyV2-1.ino hosted with ❤ by GitHub

Once happy with the sketch, I put a fresh ATmega328P-PU with Arduino bootloader in the board and programmed it with the sketch, to be used in the final version. The next step is to build my own hardware. The last hardware unknown is the amount of current the circuit draws. Once I know this the correct voltage regulator and power supply can be decided upon.

I had a fair idea it would be less than 100 milliamps, so I put a 6V battery onto supply duty via a 78L05 5V regulator (data sheet), and recorded the result:

So it varies, between 20.5 and 46 mA. As it only reaches 46 mA for a short time, we could consider the constant draw to be averaged out at 30 mA. I really want this to be able to run from a battery, but without having an external lead-acid battery lurking around, it will need a plug-pack with an output voltage greater than 7V DC.

Another alternative would be to run it from a USB socket, a nice source of 5V. If doing so, there wouldn’t be a need for the 78L05 regulator. Which brings us to the circuit diagram, which includes the power regulator. I’ve also altered the resistors to suit the RGB LED used, your values may be different:

And since it’s 2022, not 2010 – I’ve replaced the DS1307 circuit with a RTC module. Y1 is a three pin 16MHz ceramic resonator, we used those in 2010 as they were cheaper and easier than a crystal and two 22pF capacitors.

The circuit does not allow for uploading code, so you will need to program the microcontroller on another Arduino or compatible board, then transfer it to the blinky circuit board as described above. At this stage you should test it again – but using a solderless breadboard. In doing so you can make final hardware checks, and generally make sure everything works as it should. This is also a good stage to double-check you are happy with the display behaviour, default time and so on.

Used the Duemilanove as a lazy 5V for testing.

Time to solder up the circuit on some stripboard. Blank stripboard varies, but luckily I found this and a nice box to hold it in:

Stripboard does vary between retailers and so on, so you will need to work out the layout with your own board. In doing so, please double-check your work – follow the layout against the schematic and so on.

Have a break, then check it again. There is nothing worse than soldering away to realise you are one strip too far over or something. My hand-eye coordination is not the best, therefore my soldering isn’t pretty, but it works:

Note that the images above are using the 2010 circuit – which had a DS1307 sub-circuit.

One would say that there is a good argument for making your own PCBs… and I would agree with that. In 2010 it wasn’t that easy or inexpensive. Now you have KiCAD and Chinese PCB fabs tripping over themselves to give you cheap boards.

The LED is soldered to some short leads to give it a bit of play, and some heatshrink over the legs to keep them isolated:

And finally, to add a DC socket to feed blinky some power:

The last thing was to check the soldering once more under natural light, to check for bridges or shorts, then have a cup of tea. Upon my return I drilled out a hole in the enclosure lid for the LED, and one one the side for the DC socket, and fitted the lot together… and success! It worked.

I hope you enjoyed making this or at least reading about it. If you find this sort of thing interesting, please consider ordering one or both of my books from No Starch Press, or other book sellers:

• Arduino Workshop, 2nd Edition – a hands-on introduction to electronics and Arduino with 65 projects
• AVR Workshop – A comprehensive introduction to working with electronics and the Microchip AVR 8-bit family of microcontrollers with over 55 projects

And as always, have fun and make something.

For most people, the idea of retiring is a very exciting thought. Finally, after decades of hard work, you can clock out for the last time and spend the rest of your life relaxing and enjoying your leisure years. RdRnr318’s coworker updates her whiteboard every day to countdown the number of days until she gets to retire. To save Martha some effort and reduce the office’s marker budget, RdRnr318 built this “Nearly-Autonomous Retirement Countdown Display” to replace the whiteboard.

This device does exactly what it says on the tin: it shows a countdown timer with the number of days until Martha reaches her retirement. It also displays the countdown in seconds, minutes, and hours, so Martha can get granular with her retirement daydreams. This device needs no buttons for setting the time, because RdRnr318 programmed it specifically for Martha. Her retirement date is hardcoded and there is a real-time clock with a battery backup, so it can automatically calculate the countdown even after losing power.

An Arduino Uno board controls the device. It monitors the current time using a SparkFun DeadOn DS3234 RTC Breakout and displays the countdown on a simple 20×4 character LCD screen. Power comes from a wall wart or, in case of a power outage, a CR2032 battery backup. The case is a standard prefabricated enclosure box. The sketch is straightforward and pulls the current time from the RTC. It then subtracts that from Martha’s retirement date to get the remaining time. It even accounts for the differing number of days in each month and leap years!

The post This clock counts down to retirement appeared first on Arduino Blog.

[Hans Andersson] has been creating marvelous twisting timepieces for over a decade, and we’re pleased to be able to share his latest mechanical clock contraption with our readers, the Time Twister 5.

In contrast to his previous LEGO-based clocks, version five of the Time Twister uses 3D printed segments, undoubtedly providing greater flexibility in terms of aesthetics and function. Each digit is a mechanical display, five layers vertical and three segments horizontal, with a total of three unique faces. Each layer of each display can be individually rotated by a servo, and this arrangement allows for displaying any number between zero and nine. The whole show is controlled by an Arduino MEGA and a DS3231 real-time clock.

Watching these upended prisms rotate into legible fifteen-segment digits is enjoyable enough already, but the mechanical sound created by this timepiece in motion is arguably even more satisfying. Check out the video below to see (and hear) for yourself. If you want to build one yourself, all the details are here.

We last covered [Hans Andersson] and his very first Time Twister clock way back in November 2011. Since then we’ve come across many impressive mechanical clocks, like this seven-segment work of art. We’re constantly impressed by the outstanding craftsmanship of these mechanical clocks, and it’s inspiring to see one of our OG horologists back in the saddle once more.

[Fearless Night]’s slick dual hourglass doesn’t just simulate sand with LEDs, it also emulates the effects of gravity on those simulated particles and offers a few different mode options.

The unit uses an Arduino (with ATMEGA328P) and an MPU-6050 accelerometer breakout board to sense orientation and movement, and the rest is just a matter of software. Both the Arduino and the MPU-6050 board are readily available and not particularly expensive, and the LED matrix displays are just 8×8 arrays of red/green LEDs, each driven by a HT16K33 LED controller IC.

The enclosure and stand are both 3D-printed, and a PCB not only mounts the components but also serves as a top cover, with the silkscreen layer of the PCB making for some handy labels. It’s a clever way to make the PCB pull double-duty, which is a technique [Fearless Night] also used on their earlier optical theremin design.

Those looking to make one of their own will find all the design files and source code handily available from the project page. It might not be able to tell time in the classical sense, but seeing the hourglass displays react to the device’s orientation is a really neat effect.

Just when we think we’ve seen all possible combinations of 3D printing, microcontrollers, and pretty blinkenlights coming together to form DIY clocks, [Mukesh_Sankhla] goes and builds this geometric beauty. It’s kaleidoscopic, it’s mosaic, and it sorta resembles stained glass, but is way cheaper and easier.

The crucial part of the print does two jobs — it combines a plate full of holes for a string of addressable RGB LEDs with the light-dividing walls that turn the LEDs into triangular pixels. [Mukesh] designed digits for a clock that each use ten triangles. You’d need an ESP8266 to run the clock code, or if you’d rather sit and admire the rainbow light show unabated by the passing of time, just use an Arduino Uno or something similar.

Most of the aesthetic magic here is in the printed pieces and the FastLED library. It has a bunch of really cool animations baked in that look great with this design. Check out the demo video after the break. The audio is really quiet until the very end of the video, so be warned. In our opinion, the audio isn’t necessary to follow along with the build.

The humble clock takes many lovely forms around here, including pop art.

If we asked you to rattle off all the tools at your own personal disposal, you’d probably leave your timepieces off the list. But we say clocks are definitely tools — cool tools that come in countless forms and give meaning to endless days.

A clock form we hadn’t considered was that of an actual tool. So we were immeasurably delighted to see [scealux]’s clock made from a measuring tape. At least, the time-telling part of the clock is made from a measuring tape. The case isn’t really from a tape measure — it’s entirely printed, Bondo’d, sanded, and painted so well that it’s quite easy to mistake it for the real thing.

Tightly packed inside this piece of functional art is an Arduino Nano and a DS3231 precision RTC module, which we think is fitting for a tool-based clock. The Nano fetches the time and drives a stepper motor that just barely fits inside. There’s just enough tape wound around the printed hub to measure out the time in increments of one hour per inch. Take 1/16″ or so and watch the demo and brief walk-through video after the break.

Not all tools are sharp, and not all clocks are meant to be precise. Here’s a clock for the times that gives you the gist.

Good clocks are generally those that keep time well. But we think the mark of a great clock is one that can lure the observer into watching time pass. It doesn’t really matter how technical a timepiece is — watching sand shimmy through an hourglass has its merits, too. But just when we were sure that there was nothing new to be done in the realm of 7-segment clocks, [thediylife] said ‘hold my beer’ and produced this beauty.

A total of 28 servos are used to independently control four displays’ worth of 3D-printed segments. The servos pivot each segment back and forth 90° between two points: upward and flat-faced to display the time when called upon, and then down on its side to rest while its not needed.

Circuit-wise, the clock’s not all that complicated, though it certainly looks like a time-consuming build. The servos are controlled by an Arduino through a pair of 16-channel servo drivers, divided up by HH and MM segments. The Arduino fetches the time from a DS1302 RTC module and splits the result up into four-digit time. Code-wise, each digit gets its own array, which stores the active and inactive positions for each servo. Demo and full explanation of the build and code are waiting after the break.

When it comes to 7-segment displays, we say the more the merrier. Here’s a clock that uses pretty much all of them.

[Sofia] spent a lot of time looking around for the perfect LEGO clock. Eventually, she realized that the perfect LEGO clock is, of course, the one you build yourself. So if you find yourself staring at the same old boring clock, contemplating time and the meaning of time itself, why not spend some time making a new timepiece?

You probably already had the LEGO out (no judgment here). This build doesn’t take a whole lot of building blocks — just a microcontroller, a real-time clock module, some LED matrices to display the digits, shift registers if they’re not already built into the matrices, and a pair of buttons for control. [Sofia] used an Arduino Nano, but any microcontroller with enough I/O ought to work. Everybody needs a colorful new way to block out their time.

We love the way this clock looks, especially the transparent panels in front of the LED panels. Given the countless custom pieces out there from all the special sets over the years, we bet you could come up with some really interesting builds.

If your kid is too young to tell time, try building a kid-friendly clock to give them segmented structure.

Via r/duino