Posts | Comments

Planet Arduino

Archive for the ‘clock’ Category

There are almost endless variations of clocks for sale on the internet today, but it is still easy to end up in a situation where you can’t quite find a model with the style and features you want. Marco Zonca ended up with that problem while searching for a new clock to put in his music studio. Nothing on the market fit the bill, so he built this minimalist network-updated digital clock.

Zonca wanted a simple design, the ability to adjust brightness, and NTP (Network Time Protocol) updates. There are clocks available with those features, but nothing in the style Zonca wanted. So he created the perfect clock for himself. It displays 24-hour time across a red LED matrix, lets the user control settings like brightness via Bluetooth® Low Energy communication, and always stays in sync with network time.

An Arduino Nano ESP32 board, programmed through Arduino Web Editor, controls all of those functions. It mounts onto a custom PCB that Zonca designed for this clock. The PCB also hosts an 8×32 LED matrix display with MAX7219 driver. Three buttons on the PCB let the user select modes. The PCB fits into a black 3D-printed enclosure that reflects the overall minimalist style.

Now Zonca has the perfect clock for his music studio. If you like the look of it, the sketch, PCB files, and 3D enclosure are all available on Hackster.io.

The post Building a minimalist network-updated digital clock with an Arduino Nano ESP32 appeared first on Arduino Blog.

[Build Some Stuff] created an unusual spiral clock that’s almost entirely made from laser-cut wood, even the curved and bendy parts.

The living hinge is one thing, but getting the spacing, gearing, and numbers right also takes work.

The clock works by using a stepper motor and gear to rotate the clock’s face, which consists of a large dial with a spiral structure. Upon this spiral ramp rolls a ball, whose position relative to the printed numbers indicates the time. Each number is an hour, so if the ball is halfway between six and seven, it’s 6:30. At the center of the spiral is a hole, which drops the ball back down to the twelve at the beginning of the spiral so the cycle can repeat.

The video (embedded below) demonstrates the design elements and construction of the clock in greater detail, and of particular interest is how the curved wall of the spiral structure consists of a big living hinge, a way to allow mostly rigid materials to flex far beyond what they are used to. Laser cutting is well-suited to creating living hinges, but it’s a technique applicable to 3D printing, as well.

Thanks to [Kelton] for the tip!

When Arduino first hit the maker scene, the world of embedded electronics was largely unconnected and offline. But as the IoT, home automation, and smart technology advanced, Arduino kept up. Today, there are a variety of Arduino development boards that offer built-in networking capability and you can use the Arduino Cloud to take advantage of them. To demonstrate that, Doug Domke built this button-free alarm clock.

User interface design is a complex field that has to balance usability, simplicity, and practicality. Take a look at the radio alarm clocks of the 1990s to see how bad user interfaces can make device interaction frustrating. Domke’s alarm clock goes in the complete opposite direction and omits buttons altogether. It lets the user “set it and forget it” through a simple Arduino Cloud dashboard. The time automatically updates based on the configured time zone and daylight savings settings.

This requires very little hardware. Power comes in through USB to an Arduino Nano ESP32 board, with a connected piezo buzzer module and four-digit seven-segment display. Those fit inside a basic 3D-printed enclosure. All the magic happens through the Arduino Cloud and Domke explains how to set up an Arduino Cloud account, create a dashboard, and connect the Nano ESP32 to that dashboard.

If you want a dedicated alarm clock, this is a quick and easy project that will help you get acquainted with the Arduino Cloud for future IoT projects.

The post No need for buttons with this Arduino Cloud alarm clock appeared first on Arduino Blog.

It’s back to school! Whether you are a student or not, Arduino’s Project Hub is a great place to never stop learning, thanks to the wealth of knowledge, experiments, and plain cool ideas our community so generously shares. The three highlights we’ve selected among the projects uploaded in June indeed all have something to teach us… with one valuable lesson in common: the past has a lot to offer, if we take the time to recharge, rediscover or revamp it just a little!

3. Give batteries new life

This tutorial is so clear it can make anyone feel capable of building their own charger – with additional functionalities such as determining battery wear. Batteries always have to be handled with care, but if you have the skills to customize code and solder a circuit according to the schematic provided, more power to you! All you need are an Arduino Nano and a few other common components.

2. Rediscover old-school wireless transmission

This is not just a project, but a wonderful deep-dive on wireless communication where you’ll learn about the ISM band, ASK modulation, and synchronous and asynchronous demodulation. More importantly, you might rediscover the “simpler and older radio frequency devices and schemes” that are perfect to save resources on smaller projects. In this case, they will be all you need to implement wireless communication interfacing a Nano with a 433 MHz RF module.

1. Ask more of your clock 

Time and date, timer and alarm, but also detailed temperature data and even the weather forecast: you can have it all in one clock! With this project, Project Hub user dzh121 improved upon a previous version of theirs by adding a touchscreen and displaying more information. An impressive device that makes great use of Arduino IoT Cloud-based dashboards. 

For your chance to be selected for a $100, $300 or even $500 gift card to spend on the Arduino Store, submit your best project on the Project Hub! We will be awarding three new entries every month, as detailed in the complete terms and conditions. Good luck! 

The post Old school meets new energy in Project Hub’s latest highlights! appeared first on Arduino Blog.

In retrocomputing circles, it’s often the case that the weirder and rarer the machine, the more likely it is to attract attention. And machines don’t get much weirder than the DEC Rainbow 100-B, sporting as it does both Z80 and 8088 microprocessors and usable as either a VT100 terminal or as a PC with either CP/M or MS-DOS. But hey — at least it got the plain beige box look right.

Weird or not, all computers have at least a few things in common, a fact which helped [Dr. Joshua Reichard] home in on the problem with a Rainbow that was dead on arrival. After a full recapping — a prudent move given the four decades since the machine was manufactured — the machine failed to show any signs of life. The usual low-hanging diagnostic fruit didn’t provide much help, as both the Z80 and 8088 CPUs seemed to be fine. It was then that [Joshua] decided to look at the heartbeat of the machine — the 24-ish MHz clock shared between the two processors — and found that it was flatlined.

Unwilling to wait for a replacement, [Joshua] cobbled together a temporary clock from an Arduino Uno and an Si5351 clock generator. He connected the output of the card to the main board, whipped up a little code to generate the right frequency, and the nearly departed machine sprang back to life. [Dr. Reichard] characterizes this as a “defibrillation” of the Rainbow, and while one hates to argue with a doctor — OK, that’s a lie; we push back on doctors all the time — we’d say the closer medical analogy is that of fitting a temporary pacemaker while waiting for a suitable donor for a transplant.

This is the second recent appearance of the Rainbow on these pages — [David] over at Usagi Electric has been working on the graphics on his Rainbow lately.

Of course, there’s nothing unusual about using 7-segment displays, especially in a clock. However, [Edison Science Corner] didn’t buy displays. Instead, he fabricated them from a PCB using 0805 LEDs for the segments. You can see the resulting clock project in the video below.

While the idea is good, we might have been tempted to use a pair of LEDs for each segment or used a diffuser to blur the LEDs. The bare look is nice, but it can make reading some numerals slightly confusing.

The remainder of the project is what you’d expect, a 3D-printed case and an Arduino Nano coupled with a DS1307 make the clock part work.

Honestly, with a few changes, we’d like to make up some of these boards for other kinds of custom displays. We can imagine a PCB where the bottoms of the display elements are right at the edge of the board instead of on stalks. You could even create a 14-segment display (we used to call these British flag displays) to make custom text messages. Of course, you can also make custom electroluminescent displays on a PCB reasonably easily, too.

Clocks are fantastic means of creative expression, as they serve a practical purpose and therefore have a reason to exist, but aren’t limited to pure functionality. As such, we see many interesting clock designs. But ihart’s 3D-printed digital clock made from 24 individual analog clocks takes the proverbial cake.

When observed from a distance, this clock looks like it contains large seven-segment displays. But it actually displays the numerical digits of the time using the two hands of 24 individual analog clocks. Those analog clocks don’t show the time, but instead form the segments that make up the “digital” digits. The choreographed dance of the clock hands as the time changes is mesmerizing and the sheer complexity of the system should excite even the most stoic engineers in our audience.

Each of the 24 analog clocks has two hands that move independently, so this clock requires a total of 48 stepper motors. Each hand also requires a Hall effect sensor for finding its home position. While there were many other potential solutions, ihart chose to use one Arduino Nano board for every analog clock. That means that each Arduino controls two stepper motors. To simplify wiring and power distribution, ihart designed a custom PCB to host each of those 24 Arduino boards. A 25th Arduino Nano, paired with an RTC (real-time clock) module, coordinates the operation of the other 24.

All of the mechanical components of the clock were 3D-printed. The design is somewhat modular to keep the unique part count down, which means that this could be expanded into a larger display. But even as it is, the clock is very impressive.

The post 3D-printed digital clock contains 24 analog clocks appeared first on Arduino Blog.

You’ve probably seen videos of people moving magnets near iron dust, which results in the dust aligning itself to the patterns created by the magnetic fields. Magnetic viewing film works the same way, but with the dust in an oil suspension sitting in the gap between two sheets of transparent plastic. By moving that film over magnets, one can see the magnetic fields almost like they’re on an LCD panel. Mosivers took advantage of that fact to build a clock that displays the time on magnetic viewing film.

Mosivers did this by putting a small sheet of magnetic viewing film in a 3D-printed frame over four wheels. They arranged numbers around the circumference of those four wheels, a bit like an analog clock face. The numbers are made of magnetic foil, so their magnetic fields appear on the viewing film as the wheels rotate. Four boxes stenciled onto the viewing film indicate which numbers make up the current time, so reading this magnet clock is as easy as any digital clock.

Each of the four wheels has its own pancake-style stepper motor. An Arduino Uno board controls those motors through a CNC Shield outfitted with stepper drivers. The Arduino keeps track of the current time using a DS3231 real-time clock (RTC) module. For now, the user must manually set the zero position of each wheel each time they turn the clock on, but Mosivers plans to add Hall-effect sensors soon to automate that process. The numbers are a little faint due to the weak magnetic fields produced by the foil, but are still completely readable.

The post This clever clock displays the time in magnetic fields appeared first on Arduino Blog.

For those unfamiliar with the details of the expansive work of fiction of Harry Potter, it did introduce a few ideas that have really stuck in the collective conscious. Besides containing one of the few instances of time travel done properly and introducing a fairly comprehensive magical physics system, the one thing specifically that seems to have had the most impact around here is the Weasley family clock, which shows the location of several of the characters. We’ve seen these built before in non-magical ways, but this latest build seeks to drop the price tag on one substantially.

To do this, the build relies on several low-cost cloud computing solutions and smartphone apps to solve the location-finding problem. The app is called OwnTracks and is an open-source location tracker which can report data to any of a number of services. [Simon] sends the MQTT data to a cloud-based solution called HiveMQCloud, but you could send it anywhere in principle. With the location tracking handled, he turns to some very low-cost Arduinos to control the stepper motors which point the clock hands to the correct locations on the face.

While the build does rely on a 3D printer for some of the internal workings of the clock, this does bring the cost down substantially when compared to other options. Especially when compared to this Weasley family clock which was built into a much larger piece of timekeeping equipment, having an option for a lower-cost location-tracking clock face like this one is certainly welcome.

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.



  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook