Did anybody make this clock work with an ESP8266 module via NTP server instead of an Arduino. If so I would greatly appreciate it if I could get the code from you. I would appreciate it even more if the time was 12 hr instead of 24 hr. I am still a beginner when it comes to coding.

Demo:  https://www.youtube.com/watch?v=gfU4sjN3h38 

Thanks but I've seen that video and I wanted to know if anybody had the code to do that

You are relay funny... it is my video and i have the code.

Is there anyway I can get it from you I would greatly appreciate it. You can privately message me so we can talk more about it

Obviously you are not going to reply to me asking for your code so thanks for wasting my time, I hope you feel good about it lording it over my head

Not sure how helpful this is for you. Here is some code to setup a NTP server on a ESP8266 that also handles daylight savings. The example is setup for Sydney time but you can modify it to any timezone.

#include <NTPClient.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <WiFiManager.h>
#include <TimeLib.h>
#include <Timezone.h>

//Time server
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org");

void setup() {
  WiFiManager wifiManager; // wifi configuration wizard
  wifiManager.autoConnect("NeoPixel_Clock", "secret"); // configuration for the access point, set your own secret. 
  Serial.println("WiFi Client connected!)");

  //Initialise time client
  timeClient.begin();
  timeClient.update();

  //Define your timezone and daylight saving dates here

  //Central European Time (Frankfurt, Paris)
  //TimeChangeRule CEST = {"CEST", Last, Sun, Mar, 2, 120};     //Central European Summer Time
  //TimeChangeRule CET = {"CET", Last, Sun, Oct, 3, 60};       //Central European Standard Time
  //Timezone CE(CEST, CET);

  //Australia Eastern Time Zone (Sydney, Melbourne)
  TimeChangeRule aEDT = {"AEDT", First, Sun, Oct, 2, 660};    //UTC + 11 hours
  TimeChangeRule aEST = {"AEST", First, Sun, Apr, 3, 600};    //UTC + 10 hours
  Timezone ausET(aEDT, aEST);

  //US Eastern Time Zone (New York, Detroit)
  //TimeChangeRule usEDT = {"EDT", Second, Sun, Mar, 2, -240};  //Eastern Daylight Time = UTC - 4 hours
  //TimeChangeRule usEST = {"EST", First, Sun, Nov, 2, -300};   //Eastern Standard Time = UTC - 5 hours
  //Timezone usET(usEDT, usEST);

  //Work out Time Zone offset
  TimeChangeRule *tcr;
  time_t utc = timeClient.getEpochTime();
  ausET.toLocal(utc, &tcr);

  Serial.print("Time Zone offset is ");
  Serial.println((tcr -> offset * 60), DEC);

  //Update time client with correct offset
  timeClient.setTimeOffset(tcr -> offset * 60);
  timeClient.update();
}

void loop() 
{ 
  //Functions for timeClient
  //timeClient.getHours()
  //timeClient.getMinutes()
  //timeClient.getSeconds();

  delay(250);
}

Thanks John for the reply thanks for finding the code

Dear Mr. ddragon1999,

ddragon1999 wrote 20 hours ago
Obviously you are not going to reply to me asking for your code so thanks for wasting my time, I hope you feel good about it lording it over my head

++++++++

I have written you two times here with PrivMessage Contact at Sep-11 10:50 PM    and  Sep-16 11:15 PM. Have a look on the PrivateMessage Icon on the Top right that website if you dont belive me.

Hi guys! I'm having a problem, please help!

I finished this project, but the numbers are not displayed completely. As I understand it, the display should be 00:00. See photo for details - https://drive.google.com/file/d/1cWhGuY-5M1Jz2sQahxqtH-n1r0ZVdGhV/view?usp=sharing

It also seems that there is no countdown.

And one more thing (assuming that the problem with the display is not due to software), how do you set the time anyway ??

One max7219 is responsible for 8 blocks. Where the 8 rows are empty, often the PINs on the chip are not soldered correctly. Also when 8 rows show the same errors.

It helps to change the code so that all segments light up. Attention, the display then needs a power supply that can deliver 2.5A.
The code is a pure clock, not a countdown timer.  Read other Comments to learn how to set the clock.

Thanks, I fixed everything! Really, the max7219 were badly soldered. And on the issue of the idle state of the clock, it turned out to be just a mess... The Tiny RTC I2C modules that were mentioned in the description (and installed by me) turned out to be with ds1307, instead of ds3231... the code just didn't work with ds1307.

And one more thing, in previous comments I noticed your link to the clock with manual time setting using buttons https://youtu.be/0hIdCUQpUH0  . This is a very useful update!

Can you share updated code for this?

Absolutely brilliant design

I made a desktop version that uses 0.28" displays. It has an alarm function as well.

Build instructions at https://www.hackster.io/john-bradnam/7-segment-array-clock-cd5b07

Video at https://youtu.be/sy4SN5N33_w

Many thanks for an interesting project

Just designed some 3D-printable supports for this clock:

https://www.thingiverse.com/thing:4373354

2 models for desktop versions, 1 for wall-hanging versions and 1 for your imagination.

This is awesome. Have you thought about doing a similar build using 14 Segment Alphanumeric displays so that the board can show messages?

Wow! This clock is awesome. Finally got a chance to assemble this over the weekend. It actually provided an excuse to do a virtual build party online with some of my friends as well.

I had trouble with the DS1037 Tiny RTC Modules I purchased. The time would successfully set, but it would never increment. Perhaps a bad crystal? 

I ended up adding an ESP8266 module in the mix and now I'm pulling the current time from an NTP server every 36 hours. Followed this tutorial to get me going on that https://www.geekstips.com/arduino-time-sync-ntp-server-esp8266-udp/

Thank you @Frugha  for this awesome 7 segment array clock. It's a beautiful display.

Hi, excellent project. Just received the components, soldered, and worked at 1st try.

For those not used with SMD soldering, I've just posted a video soldering components with this kit: https://youtu.be/oiQqhWsyi8w

Hope it helps.

My hint: the 7-segments are extremely tight placed. You want to place them from the centre of the board to the sides. Then flush them to same level, and finally solder them in place.

A suggestion: design a version 2 PCB able to work with ESP-8266 or ESP-32, and include 2 buttons so a user can manually change the time.

Hey, How can I change the Font? 

Take a look at the digits() function - though it would be pretty manual effort to change all those putPixels etc.

// place a number 'value' 0..9 on the display at positon 'place' 
// putPixel(x [0..5], y [0..23], value) 

void digits(byte place, byte value){  switch (value) {       
   case 0:          putPixel(0, place+2, 0b00011000);         
                         putPixel(0, place+3, 0b00111101);


See comments further down for my commented version of the .ino. 

The datasheet is also useful to understand how the 0b00000000 8-bit binary is encoded into the 7-segment display:

  https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf

Thank you Frugha!

Hey,

I don't really understand ahah.  Can you contact me at my e-mail? To see picture or somthings like this. 

Email: martinschoors@gmail.com

Thanks ;)

Hey,

I have it maked but I wqnt to change the hours automaticly with the summer time and winter time. Is it possible?

Integrate that https://github.com/JChristensen/Timezone   and https://create.arduino.cc/projecthub/Tittiamo/clock-set-date-time-0d46a4 and you will have a usable Clock.

or convert the code to a esp8266, get time from NTP.

Demo:  https://www.youtube.com/watch?v=gfU4sjN3h38 

I try but not succesfuly... Can you help me by mail? 

My mail = martinschoors@gmail.com

Demo Version: Clock with manual set Time with Buttons  https://www.youtube.com/watch?v=0hIdCUQpUH0&feature=youtu.be

Awesome and original take on a classic project! Well done.

Very nice.  Thanks for posting.  I've built a couple.  Now I am stuck with parts to make 3 more.  heh

Hi,

How can I est the clock please?

All the best

you must do this separately    https://forum.arduino.cc/index.php?topic=128928.0

Hey, It's working but my arduino nano does not remember the time. If I unplug the arduino cable and put the other cable back it becomes 52: 65

Maybe the Battery of the RTC is emty or  SDA and SCL swapped? With some RTC libraries the values are wrong when SDA RTC is connected with SCL Nano and vice versa. Possibly. your I2C needs pullup resistors? Everything is powered by the display and not by the Nano. See my Youtube video a little further down.

what is a pull up resistor?  and the problem is that if I put the program and watch the serial monitor the time does not advance, he repeats all the time 1:15 p.m., 1:45 p.m., 1:45 p.m. etc.  yet I have checked my battery and it is 3V

Was there a plan to read out the Temperature Sensor (Tiny RTC DS Pin goes to D2)? 

Why a DS1307 (Tiny RTC Module) and not a DS3231?

Hi guys, i noticed in the gerber preview of jlcpcb that 5v, 3.3v and GND pins of the arduino board are shorted, can you confirm this?

I have produced a circuit board with the Gerber Files (delivered by JLCPCB) and there is no short on 5v, 3,3V and GND. Unfortunately I have to wait for some parts to reproduce that project.

I have fully assembled the clock and it works fine! :D

OK, it works :-)  https://www.youtube.com/watch?v=nQFHQMoeyg4

Now its time to convert the Code using a ESP8266 and NTP

No short.  I also used the included files to have 5 made.  They work.

Great project, and surprisingly short code to make it work, though clearly lots of effort into the hand coded data for each digit. 

There's a lot of opportunity for some fun animations with this many displays. -- you could randomise an animation at each minute, e.g. random wipes, random numbers, scrolling etc.

I've already started work on C# project to convert images to segments.  The idea being was that I could automatically create font data without having to do any manual work...

... or convert an image of a world map and use the digits to show local time at various points in the world map :)

This project is awesome and I definitely want to attempt it. Would anyone be willing to release a detailed commented version of the Arduino code? I'm relatively new to learning Arduino and it would be very helpful to try to follow what's happening! Thanks for sharing this

Hi Bret - I've added some comments to the below from my interpretation of how the code works. Hope it's useful.  Thanks Frugha for sharing!

// Source code from "7 Segment display array clock"
// https://hackaday.io/project/169632-7-segment-display-array-clock
// by Frugha
//
// "I've build an digital clock made out of 144 7 segment displays 
// controlled by an arduino nano. The segments are controlled by 
// 18 MAX7219 ic's which can control up to 64 individual leds or 
// 8x 7 segment displays. The array has 144 displays made each up 
// of 8x individual leds so the array has an total off 1152 leds 
// you can control."
//
// A DS3231 Tiny RTC board is used for Real Time Clock
//  ** NOTE RTC time and date is set from the time this code
//     is compiled and downloaded
// 

#include <SPI.h>          
#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

int SPI_CS = 10;

// LED displays arranged in 6x rows of 24 displays
// SPI output from Arduino connects to MAX7219 chips in following
// arrangement:
//  Top left:  U1,  U2,  U3,
//             U4,  U5,  U6,
//             U7,  U8,  U9,
//             U10, U11, U12,
//             U13, U14, U15,
//             U16, U17, U18 [bottom right corner]
//
// MAX7219 datasheet:
//  https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf
//

// [assume the following is 6x rows worth of 24 displays, each 8 bit field is 1x display]
// note each 'row' maps to 1x MAX7219 chip, each has 8x 7 segment displays and
// there are 3x MAX7219 chips per physical row on the PCB

byte segment_array[][3] =
{
  //   row 0         row 1         row 2        
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  //   row 0         row 1         row 2         
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  //   row 0         row 1         row 2          
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  //   row 0         row 1         row 2         
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  //   row 0         row 1         row 2         
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  //   row 0         row 1         row 2                
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
  { 0b00000000,   0b00000000,   0b00000000,},
};

// overwrite a 'thebyte' at location x, y (0,0 is top left)?
// x is 0..5
// y is 0..23
void putPixel(byte x, byte y, byte thebyte)
{
  byte bx = x*8;
  byte by = y;
  int row = 1;
  if(by >= 8 && by <= 15){
    by = by-8;
    row = 2;
  }
  if(by >= 16 && by <= 24){
    by = by-16;
    row = 3;
  }
  segment_array[bx+by][row] = thebyte;
}

// logical OR 'thebyte' at location x, y
// x is 0..5
// y is 0..23
void addPixel(byte x, byte y, byte thebyte)
{
  byte bx = x*8;
  byte by = y;
  int row = 1;
  if(by >= 8 && by <= 15){
    by = by-8;
    row = 2;
  }
  if(by >= 16 && by <= 24){
    by = by-16;
    row = 3;
  }
  segment_array[bx+by][row] |= thebyte;
}

// fill 'thebyte' over a rectangle from x1,y1 to x2,y2
// x is 0..5
// y is 0..23
void fillPixel(byte x1, byte y1, byte x2, byte y2, byte thebyte)
{
  for(int i=x1; i<=(x2); i++){
    for(int j=y1; j<=(y2); j++){
    putPixel(i, j, thebyte);
    } 
  } 
} 

// clear all digits from 0,0 to 5,23 (x1,y1 to x2,y2)
void ClearSegmentArray()
{
    fillPixel(0, 0, 5, 23, 0x00);
} 

// loop to send digits 1..8 to each display drive chip. Send last chip first.
void DisplaySegmentArray(){
  for(int i=1; i<9; i++){
   MAX7219Send(
   i, segment_array[i-1+40][3], i, segment_array[i-1+40][2], i, segment_array[i-1+40][1],
   i, segment_array[i-1+32][3], i, segment_array[i-1+32][2], i, segment_array[i-1+32][1],
   i, segment_array[i-1+24][3], i, segment_array[i-1+24][2], i, segment_array[i-1+24][1],
   i, segment_array[i-1+16][3], i, segment_array[i-1+16][2], i, segment_array[i-1+16][1],
   i, segment_array[i-1+8][3],  i, segment_array[i-1+8][2],  i, segment_array[i-1+8][1],
   i, segment_array[i-1][3],    i, segment_array[i-1][2],    i, segment_array[i-1][1]);
   }
}

// Use SPI to send the data to the MAX7219 chips
void MAX7219Send( 
  uint8_t address, uint8_t value,
  uint8_t addressb, uint8_t valueb,
  uint8_t addressc, uint8_t valuec,
  uint8_t addressd, uint8_t valued,
  uint8_t addresse, uint8_t valuee,
  uint8_t addressf, uint8_t valuef,
  uint8_t addressg, uint8_t valueg,
  uint8_t addressh, uint8_t valueh,
  uint8_t addressi, uint8_t valuei,
  uint8_t addressj, uint8_t valuej,
  uint8_t addressk, uint8_t valuek,
  uint8_t addressl, uint8_t valuel,
  uint8_t addressm, uint8_t valuem,
  uint8_t addressn, uint8_t valuen,
  uint8_t addresso, uint8_t valueo,
  uint8_t addressp, uint8_t valuep,
  uint8_t addressq, uint8_t valueq,
  uint8_t addressr, uint8_t valuer){ 
    
  digitalWrite(SPI_CS, LOW);
  SPI.transfer(address);
  SPI.transfer(value);
  SPI.transfer(addressb);
  SPI.transfer(valueb);
  SPI.transfer(addressc);
  SPI.transfer(valuec);
  SPI.transfer(addressd);
  SPI.transfer(valued);
  SPI.transfer(addresse);
  SPI.transfer(valuee);
  SPI.transfer(addressf);
  SPI.transfer(valuef);
  SPI.transfer(addressg);
  SPI.transfer(valueg);
  SPI.transfer(addressh);
  SPI.transfer(valueh);
  SPI.transfer(addressi);
  SPI.transfer(valuei);
  SPI.transfer(addressj);
  SPI.transfer(valuej);
  SPI.transfer(addressk);
  SPI.transfer(valuek);
  SPI.transfer(addressl);
  SPI.transfer(valuel);
  SPI.transfer(addressm);
  SPI.transfer(valuem);
  SPI.transfer(addressn);
  SPI.transfer(valuen);
  SPI.transfer(addresso);
  SPI.transfer(valueo);
  SPI.transfer(addressp);
  SPI.transfer(valuep);
  SPI.transfer(addressq);
  SPI.transfer(valueq);
  SPI.transfer(addressr);
  SPI.transfer(valuer);
  digitalWrite(SPI_CS, HIGH);
}

// setup once at boot time
void setup() {

  // define chip select (CS) pin as output
  pinMode(SPI_CS, OUTPUT);
  
  // initialize SPI driver
  SPI.begin(); 

  // 18x chips, each needs 8bit address + 8bit data = total 36x bytes sent
  // "0x0F00" == display test 0x00 means normal operation
  MAX7219Send(
  0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 
  0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 
  0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00);
    
  // "0x0900" == decode mode 0x00 which means NO decode, i.e. each bit sets a segment
  MAX7219Send(
  0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
  0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
  0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00);
  
  // "0x0B07" == scan limit 7, which means drive 8 displays
  MAX7219Send(
  0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 
  0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 
  0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07, 0x0B, 0x07); 

  // "0x0C01" == shutdown mode off, which means power is on
  MAX7219Send(
  0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 
  0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 
  0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01, 0x0C, 0x01);  
  
  // "0x0A13" == intensity 13 which I believe is actually intensity 3 (3/32 duty)
  MAX7219Send(
  0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 
  0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 
  0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13, 0x0A, 0x13); 

  // "0xyy00" == set each digit from 0 to 8 to 0x00
  for (int y=0; y<=8; y++) {
    MAX7219Send(
    y, 0x00, y, 0x00, y, 0x00, y, 0x00, y, 0x00, y, 0x00, 
    y, 0x00, y, 0x00, y, 0x00, y, 0x00, y, 0x00, y, 0x00, 
    y, 0x00, y, 0x00, y, 0x00, y, 0x00, y, 0x00, y, 0x00); 
  }

  // Open serial for debug
  Serial.begin(9600);

  // check RTC is alive
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while(1);
  }

  // Use Arduino compilation time to set date and time -> recompile and download to update!
  if (rtc.lostPower()) {
    Serial.println("RTC lost power, lets set the time!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

}

// Loop forever
void loop() {

  // get time from real time clock
  DateTime now = rtc.now();
  
  // clear the display
  ClearSegmentArray();

  // display hours
  digits(0,  (now.hour()/10)%10);
  digits(5,  now.hour()%10);
  
  // display minutes
  digits(13,  (now.minute()/10)%10);
  digits(18,  now.minute()%10);
  
  // draw colon between hours and minutes
  putPixel(1, 12, 0b00011101);
  putPixel(4, 11, 0b00011101);
  DisplaySegmentArray();
  delay(600); // wait 0.6s

  // clear colon between hours and minutes
  putPixel(1, 12, 0b00000000);
  putPixel(4, 11, 0b00000000);
  DisplaySegmentArray();
  delay(800); // wait 0.8s

  // draw colon between hours and minutes
  putPixel(1, 12, 0b00011101);
  putPixel(4, 11, 0b00011101);
  DisplaySegmentArray();
  delay(200); // wait 0.2s
  
}

  // place a number 'value' 0..9 on the display at positon 'place'
  // putPixel(x [0..5], y [0..23], value)
  void digits(byte place, byte value){
  switch (value) {
        case 0:
          putPixel(0, place+2, 0b00011000);
          putPixel(0, place+3, 0b00111101);
          putPixel(0, place+4, 0b01111111);
          putPixel(0, place+5, 0b00011111);
          putPixel(1, place+1, 0b00010000);
          fillPixel(1, place+2, 1, place+5, 0b01111111);
          putPixel(1, place+3, 0b01100111);
          putPixel(1, place+4, 0b01111011);
          putPixel(2, place+2, 0b01101111);
          putPixel(2, place+5, 0b01001111);
          putPixel(2, place+1, 0b01111101);
          putPixel(2, place+4, 0b00110000);
          fillPixel(3, place+1, 3, place+4, 0b01111111);
          putPixel(3, place+3, 0b00010000);
          putPixel(3, place+2, 0b00000110);
          addPixel(3, place+5, 0b00000110);
          fillPixel(4, place+1, 4, place+3, 0b01111111);
          putPixel(4, place+2, 0b00011111);
          putPixel(4, place+4, 0b01000111);
          putPixel(5, place+1, 0b01110011);
          putPixel(5, place+2, 0b01111111);
          putPixel(5, place+3, 0b01100111);
          break;
        case 1:
          putPixel(0, place+3, 0b00010000);
          putPixel(0, place+4, 0b01111111);
          putPixel(0, place+5, 0b00011111);
          fillPixel(1, place+3, 1, place+4, 0b01111111);
          putPixel(1, place+5, 0b00000110);
          putPixel(2, place+2, 0b00111101);
          putPixel(2, place+3, 0b01111111);
          putPixel(2, place+4, 0b01001111);
          fillPixel(3, place+2, 3, place+3, 0b01111111);
          putPixel(3, place+1, 0b00110000);
          putPixel(3, place+4, 0b00000110);
          fillPixel(4, place+1, 4, place+2, 0b01111111);
          putPixel(4, place+3, 0b01000110);
          putPixel(5, place, 0b00100000);
          putPixel(5, place+1, 0b01111111);
          putPixel(5, place+2, 0b01111111);
          putPixel(5, place+3, 0b00000000);
          break;
        case 2:
          putPixel(0, place+2, 0b00011000);
          putPixel(0, place+3, 0b00111101);
          putPixel(0, place+4, 0b01111111);
          putPixel(0, place+5, 0b00011111);
          putPixel(1, place+1, 0b00110000);
          putPixel(1, place+2, 0b01111111);
          putPixel(1, place+3, 0b01100010);
          putPixel(1, place+4, 0b01111011);
          putPixel(1, place+5, 0b01111111);
          putPixel(2, place+3, 0b00111000);
          putPixel(2, place+4, 0b01111111);
          putPixel(2, place+5, 0b01000110);
          putPixel(3, place+2, 0b00111101);
          putPixel(3, place+3, 0b01111111);
          putPixel(3, place+4, 0b01000110);
          addPixel(4, place, 0b00010000);
          fillPixel(4, place+1, 4, place+2, 0b01111111);
          putPixel(4, place+3, 0b01000110);
          putPixel(5, place, 0b00100000);
          putPixel(5, place+1, 0b01110011);
          fillPixel(5, place+2, 5, place+3, 0b01111111);
          putPixel(5, place+4, 0b01100111);
          break;
        case 3:
          putPixel(0, place+2, 0b00011000);
          fillPixel(0, place+3, 0, place+4, 0b01111111);
          putPixel(0, place+5, 0b00011111);
          putPixel(1, place+1, 0b00100000);
          putPixel(1, place+2, 0b01111111);
          putPixel(1, place+3, 0b01100010);
          putPixel(1, place+4, 0b01111011);
          putPixel(1, place+5, 0b01111111);
          putPixel(2, place+2, 0b00011000);
          fillPixel(2, place+3, 4, place+4, 0b01111111);
          putPixel(2, place+3, 0b00111101);
          putPixel(2, place+5, 0b01000110);
          putPixel(3, place+2, 0b01100000);
          putPixel(3, place+3, 0b01110011);
          putPixel(3, place+5, 0b00000100);
          putPixel(4, place+2, 0b00011101);
          putPixel(4, place+1, 0b00011000);
          putPixel(4, place+3, 0b00111101);
          addPixel(4, place+5, 0b00000110);
          putPixel(5, place, 0b00100000);
          putPixel(5, place+1, 0b01110011);
          fillPixel(5, place+2, 5, place+3, 0b01111111);
          putPixel(5, place+4, 0b01000010);
          break;
        case 4:
          putPixel(0, place+2, 0b00111000);
          putPixel(0, place+3, 0b01111111);
          putPixel(0, place+4, 0b00010000);
          putPixel(0, place+5, 0b01111111);
          putPixel(1, place+1, 0b00010000);
          fillPixel(1, place+2, 2, place+2, 0b01111111);
          putPixel(1, place+3, 0b01000110);
          putPixel(1, place+4, 0b01111101);
          putPixel(1, place+5, 0b01001111);
          putPixel(2, place+1, 0b01111101);
          putPixel(2, place+3, 0b00111000);
          putPixel(2, place+4, 0b01111111);
          putPixel(2, place+5, 0b00000110);
          fillPixel(3, place+1, 3, place+4, 0b01111111);
          putPixel(3, place+5, 0b00000000);
          addPixel(3, place, 0b00010000);
          putPixel(4, place+2, 0b00010000);
          putPixel(4, place+3, 0b01111111);
          putPixel(4, place+4, 0b00000110);
          putPixel(5, place+2, 0b01111111);
          putPixel(5, place+3, 0b01100111);
          break;
        case 5:
          putPixel(0,  place+2, 0b00111101);
          fillPixel(0, place+3, 0, place+5, 0b01111111);
          putPixel(1,  place+1, 0b00110000);
          putPixel(1,  place+2, 0b01111111);
          putPixel(1,  place+3, 0b01011111);
          putPixel(1,  place+4, 0b00001100);
          putPixel(2,  place+3, 0b01111111);
          putPixel(2,  place+2, 0b01110011);
          putPixel(2,  place+4, 0b01111111);
          putPixel(2,  place+5, 0b00000110);
          putPixel(3,  place+3, 0b00110000);
          fillPixel(3,  place+4, 4,  place+4, 0b01111111);
          putPixel(3,  place+5, 0b00000110);
          fillPixel(4, place+1, 4, place+2, 0b00011101);
          putPixel(4,  place+3, 0b00111101);
          putPixel(4,  place+5, 0b00000010);
          putPixel(5,  place, 0b00100000);
          fillPixel(5,  place+1, 5,  place+2, 0b01111111);
          putPixel(5,  place+3, 0b01100111);
          putPixel(5,  place+4, 0b01000010);
          break;
        case 6:
          putPixel(0, place+3, 0b00011000);
          putPixel(0, place+4, 0b01111111);
          putPixel(0, place+5, 0b00000110);
          fillPixel(1, place+2, 2, place+4, 0b01111111);
          putPixel(1, place+2, 0b00111101);
          putPixel(1, place+4, 0b01000010);
          putPixel(2, place+1, 0b00111000);
          putPixel(2, place+5, 0b00000100);
          addPixel(3, place, 0b00010000);
          fillPixel(3, place+1, 4, place+4, 0b01111111);
          putPixel(3, place+2, 0b01000110);
          putPixel(3, place+3, 0b01100000);
          putPixel(3, place+5, 0b00000110);
          addPixel(4, place, 0b00110000);
          putPixel(4, place+2, 0b00011111);
          putPixel(4, place+3, 0b00111101);
          putPixel(5, place+1, 0b01110011);
          putPixel(5, place+2, 0b01111111);
          putPixel(5, place+3, 0b01100111);
          break;
        case 7:
          putPixel(0, place+1, 0b00110000);
          fillPixel(0, place+2, 0, place+4, 0b01111111);
          putPixel(0, place+5, 0b00011111);
          putPixel(1, place+1, 0b00100000);
          putPixel(1, place+2, 0b01100011);
          putPixel(1, place+3, 0b01100011);
          putPixel(1, place+4, 0b01111111);
          putPixel(1, place+5, 0b01111111);
          putPixel(2, place+5, 0b01000110);
          putPixel(2, place+4, 0b01111111);
          putPixel(2, place+3, 0b00111101);
          putPixel(3, place+2, 0b00111101);
          putPixel(3, place+3, 0b01111111);
          putPixel(3, place+4, 0b01100111);
          putPixel(4, place+1, 0b00111101);
          putPixel(4, place+2, 0b01111111);
          putPixel(4, place+3, 0b01000110);
          fillPixel(5, place+1, 5, place+2, 0b01111111);
          putPixel(5, place, 0b00100000);
          break;
        case 8:
          putPixel(0, place+2, 0b00011000);
          fillPixel(0, place+3, 0, place+4, 0b01111111);
          putPixel(0, place+5, 0b00011111);
          putPixel(1, place+1, 0b00110000);
          putPixel(1, place+2, 0b01111111);
          putPixel(1, place+3, 0b01100010);
          putPixel(1, place+4, 0b01111011);
          putPixel(1, place+5, 0b01111111);
          putPixel(2, place+1, 0b00100000);
          putPixel(2, place+2, 0b01111111);
          fillPixel(2, place+3, 4, place+4, 0b01111111);
          putPixel(2, place+3, 0b00111101);
          putPixel(2, place+5, 0b01000110);
          putPixel(3, place+1, 0b00111101);
          putPixel(3, place+2, 0b01100111);
          putPixel(3, place+3, 0b01110011);
          putPixel(3, place+5, 0b00000100);
          putPixel(4, place+2, 0b00011101);
          putPixel(4, place+1, 0b01111111);
          putPixel(4, place+3, 0b00111101);
          addPixel(4, place+5, 0b00000110);
          addPixel(4, place, 0b00110000);
          putPixel(5, place+1, 0b01110011);
          fillPixel(5, place+2, 5, place+3, 0b01111111);
          putPixel(5, place+4, 0b01000010);
          break;
        case 9:
          putPixel(0, place+2, 0b00011101);
          putPixel(0, place+3, 0b01111111);
          putPixel(0, place+4, 0b00011111);
          putPixel(0, place+5, 0b00001100);
          fillPixel(1, place+1, 3, place+4, 0b01111111);
          putPixel(1, place+1, 0b00111000);
          putPixel(1, place+3, 0b01100011);
          putPixel(1, place+4, 0b01111011);
          putPixel(1, place+5, 0b01111111);
          putPixel(2, place+2, 0b01011111);
          putPixel(2, place+3, 0b00011100);
          putPixel(2, place+5, 0b01001111);
          putPixel(3, place+1, 0b01100000);
          putPixel(3, place+2, 0b01111011);
          putPixel(3, place+5, 0b00000010);
          putPixel(4, place+1, 0b00011000);
          putPixel(4, place+2, 0b01111111);
          putPixel(4, place+3, 0b01100111);
          putPixel(5, place, 0b00100000);
          putPixel(5, place+1, 0b01111111);
          putPixel(5, place+2, 0b01000110);
          break;
      }
}

awesome thank you so much!

excellent, thank you.

this is gorgeous! I have same question as Supercrab regarding the font. I wonder if this is trial and error to fine tune the font the way you want. You did no share a python script so I guest it was not automated. I think you just played with  bits in the switch case of the digits function.

          putPixel(0, place+5, 0b00011111);
          fillPixel(1, place+3, 1, place+4, 0b01111111);

anyway amazing!!

I had a reply!  Response from Fruga: "I made an picture of the clock while off and then photoshopped the font on top of the display so I could see what segments where on"

Damn it!  This fucken awesome! :D

EDIT: I've just ordered the circuit board and will have 2 spare if anyone in the UK is interested in building this. :)

A wemos D1 mini (ESP8266) could be used instead of the Atmel, and, in conjunction with an NTP server you wouldn't need the RTC.

I hope I can get to build this (add this project to current list of unifinished ideas) as I'd love to test it out it's animation capabilities!

I did this (wemos d1) but am having problems with various sections of 8 displays going wacko (which means the MAX units have an issue), but haven't figured out why yet.  I put in a level shifter, but that didn't resolve anything. Uhhhg

A very sweet and ingenious project! Well done. The wiring behind it is pretty cool as well. 

Very nice project ! Congrats :)

I know about coupling and decoupling capacitor. However, could someone tell me how does it work the 2 caps in gnd of MAX7219CWG attached to vcc in this case ?

They are both for decoupling. That is filtering out noise on Vcc. The noise can be of a wide range on frequencies. High value capacitors are best at filtering low frequency noise. Low value capacitor are best at filtering high frequency noise. By using both 0.1uF and 10uF you get a wider range of filtering.