Published May 14, 2024 © GPL3+

Multi-functional Clock System with Two Pico-2040 Based Units

"Ultimate Pico2040 Digital Clock featuring Big Display, Scrolling Messages, Chimes, Voice Time Announcement, MP3 Player and More!"

IntermediateFull instructions provided6 hours2,522

Things used in this project

Hardware components

Raspberry Pi Pico

DS1307 RTC

SEVEN SEGMENT DISPLAY 2 .3 INCH

SEVEN SEGMENT DISPLAY 1 INCH

MAX 7219 4 IN 1 LED MATRIX DISPLAY

CD 4504 IC

ULN 2803 IC

BD 139 TRANSISTER

Linear Regulator (7805)

3.3 V REGULATOR MODULE

TSOP-1838 Infrared Sensor

MICRO SD CARD READER MODULE

DF Player Mini MP3 player module

DHT 11 TEMERATURE AND HUMIDITY SENSOR MODULE

Ultrasonic Sensor - HC-SR04 (Generic)

PAM 8403

Software apps and online services

Arduino IDE

Story

OVERVIEW:

The Multi-functional Clock System is composed of two distinct clocks, each based on the Pico-2040 micro controller. These clocks are interconnected via an I2C Bus, facilitating communication and synchronization between them. While each clock possesses its own Real-Time Clock (RTC) module, the primary timekeeping function is delegated to the second clock. The first clock features large common-anode seven-segment LED displays, while the second clock employs MAX7219 LED matrix displays for versatile messaging and data presentation.

FUNCTIONALITY:

Clocks synchronize their RTC modules on power-up, with Clock-1 acting as the master and Clock-2 as the slave.
Clock-2 manages various subcomponents such as the MP3 player, SD card reader, and sensors, while Clock-1 primarily handles display and user input.
Time Division Multiplexing is employed in Clock- 1 for efficient display management, with appropriate driver ICs utilized for driving large seven-segment displays.
Remote control enables convenient access to all clock functions, including time and alarm setting, audio mode selection, volume adjustment, and display control.

KEY FEATURES :

The Clock consists of 2 different Pico-2040 based clocks connected together using I2C interface. Each clock has its on RTC(cheap DS 1307 RTC modles are used here) which will be synchronized while switching on the power.
Clock-1 features large seven-segment displays for time indication, while Clock-2 utilizes scrolling LED matrix displays for displaying time, date, temperature, humidity, and messages. I have uses four 2.3 inch common anode Seven segment displays for the display of Hour/Minute and two 1 inch Seven segment Displays for displaying Seconds. The clock’s hard ware is capable of handling even higher sized seven segments if required.
Clock-2 has a MAX7219 scrolling LED matrix Display for display of Time, Date, Temperature, Humidity, time based wishing like Good morning, Good night etc and other status messages when come over in different modes. This display also used to read and display the text files stored in SD card line by line.
A mini MP3 player is integrated with the clock, using which any music can be played as Hour chime, Alarm, and also for playing any music(such as prayer songs) at any prefixed time. Also the clock can speak out the time, using this MP3 player. Though it can set to speak any time, the clock is here set to speak out at every half hour. On each full hour it is set to play a chime.
An Ultra sound sensor is integrated with the second clock which will sense some one comes near it and play randomly stored words like ( hi, hello.. how are U etc), and also display the same in words on the message board. Hundreds of such audio /words can be stored on the SD cards to select and display at random.
A DHT 11 module is integrated with the second clock for reading the room Temperature / Humidity and display these on it’s moving display.
A Full function remote is integrated for accessing all functions of the clock. Clock 1 is provided with an IR sensor, which can be accessed with a standard remote control. Real time, Alarm time, Date /year, different audio modes, volume of music player, etc can be set using the remote control. The Chime/Ultra sound sensor can be fully muted, fully activated or muted at night only by setting the remote control appropriately. Alarm also can be permanently muted or activated. Stopping of Alarm / audio playing can also be done using the remote.
The Led matrix display continuously scroll out real time, date, temperature, humidity, time based wishing( like Good morning, Good Night etc..) normally
The clock is also set to scroll and display Year & Date in Malayalam Era (another local calendar system), Astrological star, status of moon, and also events like Festivals , Holydays, Birthdays of family members , Wedding anniversary and other main events automatically . For this on every new year a text file with 365 lines need to be created, each line of which contain the details of each day and copied in to the SD card . This is very simple , needs a few minutes work using Excel work sheet. The clock on each day , read and access the line corresponding to that day from the text file stored in SD card and display it on the scrolling clock
While playing the music( here I set the clock to play 2 prayer songs one at 6.10 am and other at 6.10 pm) the display read and play the lyrics of the prayer line by line from the SD card and display it while playing the prayer on MP3 player. The LED matrix also displays status messages each time when a key is pressed on the remote control like “Set time", "Set Alarm ", "Set Date", "Set Volume", "Alarm off " etc. Alarm time and other settings of the clock will be written on the SD card itself on a specific file, and is read out each time when the clock is switched on. This display also compliment with some animations while the clock strikes full hour and half hour.
SD card reader, MP3 player and Ultra sound sensor are integrated with clock-2. Real time is also being maintained by the second clock. So each time the clock is switched on, the first clock request data from the second clock and the second clock send data consisting of Real time, and other data read from its SD card like Alarm set time, volume, status of chime play, alarm permanently off /on.. etc to the first clock via inter connected I2C bus. The first clock Set its time in synchronization with the data and time received from the second clock.
For I2C Communication clock 1 act as master clock and clock 2 is in slave mode. Since IR receiver is connected with the first clock, it respond to the Remote control and send the data received from the remote to the second clock via I2C for use and for writing on SD card for future use. It also prompt the second clock to display the status of different setting on its display when a remote control key is pressed.

PROJECT DESCRIPTION:

The clock is built around 2 PICO 2040 micro controllers. The project is divided in to 2 independent clocks which are connected together through I2C Bus. Each clock has its on RTC modules, but real time is maintained by the second clock. The first clock synchronize its RTC with the second clock each time when the clock is switched on. The first clock has big sized common anode seven segment LED displays and the second clock has 3 MAX 7219 LED matrix displays connected serially (4X3=12 units total), which is enough for scrolling messages of long lines. The second clock is mainly used for displaying the messages and maintaining different sub components like MP3 player, SD card reader, Temperature sensor, Ultra sound Sensor etc. Since scrolling messages on a MAX 7219 display is a processor hungry one, it’s a bit difficult to manage all the sub components, though I managed to do with the software. As a fancy thing I have added an ultra sound sensor which will respond to some one coming near the clock and speak and display some random words like Hello, Hai, How R U etc. If required it can be made to speak out real time when some one come near it!

All communication interfaces like I2C, SPI and UART are used in the program for communication with different modules. in fact two different I2C Bus of the processors are used independently one for connecting RTC with the processor and other for inter processor communication. Although one I2C bus can be used for both the purpose, due to some conflicts encountered I used different I2C busses for each purpose.

One Single 12V 1A power supply module is used to power both the clocks. Each clock contain its own 7805 5V regulator and 3.3 V regulator for powering its sub units.

The clock needs 2 micro SD cards of 1GB or higher one for storing music and message files on MP3 Player and other for storing text files and other data files in the SD card reader. In the SD card text files in plain.txt format can be written with any name. Folders on SD card on Mp3 player should be named as 001, 002, 003 etc. Audio files in the folders should also be names as 001, 002, 0003 etc…A command like Play (1, 3) refers to play file named 003 on folder no 001. Chime files and all other audio files should be stored on different folders on the SD card as described above, to use by the program. For paying random files when US sensor detects the corresponding files should be put in a folder with names 001, 002, 003… etc. Also the corresponding test file stored for random word in the SD card should be in line with the random audio files. That means if the first MP3 audio file 001 is to speak hello, the first line of the text file in the SD card should be hello.. and so on. Any cute ringing tones like big ben or cuckoo can be stored and used as hour chime.Here I used 2 prayer songs one for playing in the morning at 6.10 hrs and other at 6.10 PM

In one different folder on mp3 player’s SD card, 12 different audio mp3 files to play “ Now time is one hour thirty minutes”, “ Now time is two hour thirty minutes”…….etc are stored with file names 001 to 012. I have created these audio files using some text to speech converters available online.( If required these sound can be recorded and use with our own voice). One of the file will be played when the clock’s minutes reached 30(ie. on each half hour)

Regarding the remote control, any discarded IR remote or those available on electronic shops can be used. Here I have used a remote discarded from a car stereo. For using a remote we need to find out the code the remote will send when pressing each key, which can be easily find out by reading the serial monitor of Arduino IDE, on each pressing of each key. Write down and use these codes in the program for using the remote-control

Time division multiplexing is used for displaying time and other signs on the seven segment displays. Since large sized Seven segments using more than 3 serial LEDs on each segments, it need more power and the micro processor cannot drive them directly. So the seven segments of the display are driven through IC ULN2803 and the common anode of each digit is driven through a combination of CD4503 voltage level shifter IC and transistor BD139.This combination is capable of handling much higher sized seven segments, though I used 2 inch and 1 inch displays only for my project.

Regarding the construction I have used 2 home made PCBs, drawn with DIPTRACE and etched at home itself. Though it can be made on general purpose PCBs, it may not be get compact and neat. Two photo frames purchased from a photo framing shop were used here. The two frames were screwed together for getting enough height for placing the hardware. All the PCBs and hard wares are fixed with screws on the back plate which is finally screwed with the frame. The glass of the photo frame is painted with black enamel paint leaving space for the displays. Raspberry logo and words PICO 2040 were also printed on the front glass with white paint, which gives the clock a professional look. As such the clock looks great and no one will detect it as a DIY one!

Remote control :

Remote

All the functions of the clock can be controlled fully with the IR remote, When Time set key is once pressed the Second digits of the clock indicate as “St”, also a message “ SET Time” displayed on second clock’s display. You can type the time required using the numeric keys on the remote and press enter key to set.Also you can leave with out any change from the set mode by pressing the home button.

Similar is the procedure for setting alarm time and date using the remote.

The Key named CH SET is used to set different modes of audio. On pressing the key the 7 segment display will change to different modes like

1. CH –on means only hour chime and half hour speak always

2 CH -- nt means night mode hour chime and half hour will not work on night hours

3 --UL on means Chime is off and US sensor active always

4 CH UL nt means Chime and US sensor are under night mode and will not work during the pre-fixed night hours Etc.. etc

On pressing the enter key the mode is set and the first clock send the data to the second clock for usage and writing on its SD card for future use. Here also we can return with out setting any thing by pressing the home key.

On pressing the key labelled Temp, the first clock request and collect the current temperature from the second clock and display on its Seven segment display

AL POF key is used to set the Alarm permanently in off mode or in active mode. Pressing the button will toggle the mode from On and Off, and can be set by pressing enter key. If not in off mode the clock will blow alarm on all the days when reaching the set time.

PL OFF key is for stopping the alarm once it blown, and also to stop any music playing on the MP3 player

The VOL Button is meant for setting the volume of MP3 player. Maximum volume level is 30 which is divided in to 10 steps. Press the button multiple times to the required level and press the enter key to set the volume

An On-Off button is provided in the remote to On and blank both the LED displays.While in off mode only the displays gets blank, but the clock works normally with all it set modes

CLOCK DURING NORMAL DISPLAY

DISPLAYS AT DIFFERENT MODES

CONCLUSION: The Multi-functional Clock System combines advanced functionality with elegant design, providing users with a versatile timekeeping solution. With its innovative features and elegant design, it provides users with a unique and enjoyable timekeeping experience.

Code

/*
###########################################################################################
CODE FOR CLOCK 1
WRITTEN BY AJITH KUMAR B
THIS CLOCK WAS UPDATED ON 7 DECEMBER 2024  ADDING WITH NEW REMOTE CONTROL AND 
WITH IRremote 4.1 ver LIBRARY FILES.
USE <IRremote.hpp> IR LIBRARY

*/ 
//#######################   DECENMER 7 2024 #################################################
#include "RTClib.h"
#include<Wire.h>
#include <IRremote.hpp>
#define IR_RECEIVE_PIN 9
RTC_DS1307 RTC;
//IRrecv receiver(RECEIVER_PIN);
uint32_t IR_code;
int digit1 = 16;
int digit2 = 13;
int digit3 = 11;
int digit4 = 12;
int digit6 = 17;
int digit5 = 18;
int segA = 7;
int segB = 8;
int segC = 2;
int segD = 5;
int segE = 21;
int segF = 6;
int segG = 3;
int Dot = 10;
int Mode=0;
int aset;
int dtt2;
int setmode = 0;
int dispoff_flag = 1;
int keyx;
int count = 0;
int keysum;
int keysum1;
int keyvalid ;
int set_mode = 0;
int time_set  = 0 ;
int alm_set;
int charshow1;
int charshow2;
int char1;
int char2                                                     ;
int char3;
int char4;
int char5;
int char6;
int Hrset;
int oldHrset;
int Ulset;
int oldUlset;
int timp2;
int typeset  = 0;
int tempC =0;
int Alm_P_off;
int pc=0;
int kn=0;
int enterkeypress=0;
int retnkey=0;
int date_set;
int Snset;
int oldSnset;
int old_Alm_P_off;
unsigned long key_value = 0;
bool datesetflag =0;
bool set_start =0;
bool power_on=1;
String receive_string;
void ShowNumber(int );
void displaychar(int , int);
void Light_HR_MIN(int);
void IRR(int  , int);
void big_char(int , int ,int , int );
void sentdata2pico(String);
void recivdatapico(void);
void DT_SET( int ,  int );

//#################################  SET UP  ################################################
void setup() {
  Serial.begin(9600);
  Serial1.begin( 9600);
  Wire1.setSDA(14);
  Wire1.setSCL(15);
  Wire.setSDA(0);
  Wire.setSCL(1);
  RTC.begin(&Wire1) ; 
  Wire1.begin();
  Wire.begin();
  RTC.begin(&Wire1);
  DateTime now = RTC.now();
 //RTC.adjust(DateTime(__DATE__, __TIME__));// for setting clock   remove 
  //after setting clock again put // on the line and upload once more
  pinMode(segA, OUTPUT);
  pinMode(segB, OUTPUT);
  pinMode(segC, OUTPUT);
  pinMode(segD, OUTPUT);
  pinMode(segE, OUTPUT);
  pinMode(segF, OUTPUT);
  pinMode(segG, OUTPUT);
  pinMode(Dot, OUTPUT);
  pinMode(digit1, OUTPUT);
  pinMode(digit2, OUTPUT);
  pinMode(digit3, OUTPUT);
  pinMode(digit4, OUTPUT);
  pinMode(digit5, OUTPUT);
  pinMode(digit6, OUTPUT);
  digitalWrite(Dot, LOW); 
  digitalWrite(5, LOW); 
// ..................WELCOME DISPLAY.........................................................

  for (int p =3 ; p > 0  ; p--) {
  for (int i =80 ; i > 0  ; i--) {
  big_char(10,19,11,1) ;
  displaychar(33,33) ;
  }
  ShowNumber(10);
  delay(300);
 }
  IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);  // enable the receiver
}
//################################### END OF SETUP ##########################################
//#################################   MAIN LOOP  ############################################
void loop() { 
  IR_code =0xFFFFFFFF;
DateTime now = RTC.now();
if (power_on==1){
 delay (1000); 
recivdatapico();
oldHrset=Hrset;
oldSnset=Snset;
old_Alm_P_off=Alm_P_off;
 sentdata2pico("G");

}
power_on =0 ;
//###############################  DISPLAY OFF FUNCTION.####################################
  if ( dispoff_flag == 0) {
    digitalWrite(digit1, LOW);
    digitalWrite(digit2, LOW);
    digitalWrite(digit3, LOW);
    digitalWrite(digit4, LOW);
    digitalWrite(digit5, LOW);
    digitalWrite(digit6, LOW);
    digitalWrite(segA, LOW);
    digitalWrite(segB, LOW);
    digitalWrite(segD, LOW);
    digitalWrite(segC, LOW);
    digitalWrite(segE, LOW);
    digitalWrite(segF, LOW);
    digitalWrite(segG, LOW);
    digitalWrite(Dot, LOW);
    }
else{

//############################## TEMPERATURE DISPLAY ########################################

if (Mode == 4)
{
for (int i = 8 ; i > 0  ; i--) {
Light_HR_MIN(tempC);
displaychar(16 , 15) ;
}}
 else{}
 
//###########################  ALARM PERMANET OFF #############################################  
   
if (Mode ==8){
if(set_start == 0){
 sentdata2pico("a") ;
}
set_start=1;
if (Alm_P_off == 0) char4=17;
else   char4=18;
for (int i = 8 ; i > 0  ; i--) {
big_char(11,12,0,char4) ;
ShowNumber(10);
 }}
else{}
if (Mode ==8 &&  enterkeypress ==1)  {
Mode =0;  
enterkeypress =0; 
set_start=0;
old_Alm_P_off=Alm_P_off;
pc=0;
String ap;
ap = "N"+String(Alm_P_off);
sentdata2pico(ap);
delay(100);
 }
 else{}   
 
//############################### HOUR CHIME SETTING ########################################
       
if (Mode ==9){
if(set_start == 0){
 sentdata2pico("h") ;  }
set_start=1;
if (Hrset == 1){
      char1=16;
      char2=19;
      char3=26;
      char4=26;
      char5=0;
      char6=18;
        }
if (Hrset == 2){
       char1=26;
       char2=26;
       char3=27;
       char4=12;
       char5=0;
       char6=18;
      
        }
if (Hrset == 3){
       char1=29;
       char2=30;
       char3=13;
       char4=28;
       char5=0;
       char6=18;
        }
if (Hrset == 4){
       char1=16;
       char2=19;
       char3=26;
       char4=26;
       char5=18;
       char6=13;
        }
if (Hrset == 5){
      char1=26;
      char2=26;
      char3=27;
      char4=12;
      char5=18;
      char6=13;
       }
if (Hrset == 6){
      char1=29;
      char2=30;
      char3=13;
      char4=28;
      char5=18;
      char6=13;
       }
if (Hrset == 7){
      char1=29;
      char2=30;
      char3=13;
      char4=28;
      char5=0;
      char6=17;
       }
for (int i = 8 ; i > 0  ; i--) {
big_char(char1,char2,char3,char4) ;
ShowNumber(10);
displaychar(char6,char5);
 }}
else{}
if (Mode ==9 &&  enterkeypress ==1)  {
Mode=0;
enterkeypress =0; 
oldHrset=Hrset;  
set_start=0;
String hp = "R"+String(Hrset);
sentdata2pico(hp);
delay(100);
kn=0;
}
 else{}   
//#############################  VOLUME SETTING #############################################
if (Mode ==12){
if(set_start == 0){
 sentdata2pico("s") ;
}
set_start=1;
if (Snset>= 33  || Snset== 0)  Snset=0;    
else{} 
int z1=Snset%10;
int z2=Snset/10;
       
for (int i = 8 ; i > 0  ; i--) {
big_char(14,18,24,26) ;
ShowNumber(10);
displaychar( z1,z2  );
 } }
if ( Mode ==12 && enterkeypress ==1)  {
Mode=0;
enterkeypress =0; 
oldSnset=Snset;
set_start=0;
String hq = "S"+String(Snset);
sentdata2pico(hq);
kn=0;
 }
 else{}   

//###########################REAL TIME DISPLAY   #############################################

if (Mode == 0) {
if  (IrReceiver.decode()) {
IR_code =IrReceiver.decodedIRData.decodedRawData, HEX;
 //Serial.println(IR_code,HEX);
IrReceiver.resume(); }

 DateTime now = RTC.now();
int tim = (now.hour());
if (tim >  12) {
tim = tim - 12;  }
else;
if (tim ==  0) {
tim = 12;   }
else;
int timp = (tim * 100 + now.minute());
int timp1 = now.second();
timp2 = (now.hour() + now.minute());
// For Digits display
int sec1= timp1/10;
int sec2 = timp1%10;
for (int i = 2 ; i > 0  ; i--) {
Light_HR_MIN(timp);
displaychar(sec2,sec1);
 }
if (timp1 % 2 == 0 ) {
digitalWrite(Dot, HIGH);
delayMicroseconds(1000);  }
else;
{ digitalWrite(Dot, LOW);
 delayMicroseconds(2000);
    }}
    else {}
}
//########################### CHECKING REMOTE PESSING #######################################
if  (IrReceiver.decode()) {
IR_code =IrReceiver.decodedIRData.decodedRawData, HEX;
Serial.println(IR_code,HEX);
//Serial.println(IrReceiver.decodedIRData.decodedRawData, HEX);
IrReceiver.resume();  }
//##########################  TEMPERATURE  DISPLAY KEY  PRESSED  ############################
if (IR_code == 0xE51A7F80 ) {    
if(set_start == 0){
      sentdata2pico("g") ;
}
      set_start=1;
 
Mode = 4;
recivdatapico();
delay(200);
 }
else{ }

//#########################  DATE DISPLAY KEY PRESSED  ######################################

 if (IR_code == 0xE11E7F80 ) {
datesetflag=0;
if(set_start == 0){
 sentdata2pico("d") ;
}
set_start=1;
 DateTime now = RTC.now();
int hj  =  (now.day()*100)+now.month();
int df=(now.year()%100)/10;
int dh=(now.year()%100)%10;
for (int i = 2 ; i > 0  ; i--) {
Light_HR_MIN(hj);
displaychar(df,dh);
  }
Mode =15; 
  //   sentdata2pico("U");
typeset = 3;
setmode = 1;
int ya=now.day();
int yb=now.month();
int yc= now.year();       
int datest = ((ya*10000)+(yb* 100) + (yc%100));
DT_SET (datest , 3);
if (datesetflag ==1){
int hr=now.hour();
int mnn = now.minute();
int scs =  now.second(); 

int mnt = (date_set/100)%100;
int dy  = date_set/ 10000; 
int  yr = 2000+(date_set%100);
RTC.adjust(DateTime(yr,mnt,dy, hr, mnn,scs));
//---- date set for sending to other board---------------------------------------------------------
String hr1= String (hr);
if(hr/10 ==0) hr1=("0"+hr1);
if(hr ==0) hr1=("00");
int sss=scs+3;
if(sss>= 60) {
  sss=0;
mnn=mnn+1;}
String mn1= String(mnn);
if(mnn/10 ==0) mn1=("0"+mn1);
if(mnn ==0) mn1=("00");
String mnt1=String(mnt);
if(mnt/10 ==0) mnt1=("0"+mnt1);
if(mnt ==0) mnt1=("00");
String dy1=String(dy);
if(dy/10 ==0) dy1=("0"+dy1);
String yr1=String(yr);
String scc1=String(sss);
if(sss/10 ==0) scc1=("0"+scc1);
if(sss ==0) scc1=("00");
String tk = "T"+yr1+mnt1+dy1+hr1+mn1+scc1 ;
sentdata2pico("Z");
sentdata2pico(tk);
//sentdata2pico("Z");
delay(100);
datesetflag=0;
Mode = 0;
 set_start=0;
  }
else{ }
 }
//##############################  HOME KEY PRESSED  #########################################
 if (IR_code == 0xF7087F80  ) {

          typeset = 0;
          Mode = 0;
          enterkeypress ==0;
          Alm_P_off =old_Alm_P_off;
          Hrset=oldHrset;
          Snset=oldSnset;
          kn=0;
          pc=0; 
          set_start=0;
          retnkey == 1;   
          datesetflag ==0; 
          return; }
 //############################## ENTER KEY PRESSED  ########################################
 if (IR_code == 0xF6097F80  ) {
 enterkeypress=1;
 return; }
 else  enterkeypress=0;
  
 //#####################   ALRM PERMANENT OFF  key pressed  #################################
  
        if (IR_code == 0xFB047F80) { 
        Mode=8;
        Alm_P_off =  abs(Alm_P_off - 1);
        if(pc==0) Alm_P_off = old_Alm_P_off ;  
        else{} 
        pc= pc+1;
        delay(500);    }
        else{}

 //##############################  HOUR CHIME mode KEY PRESSED  #############################
    
       if (IR_code == 0xFC037F80 ) { 
       Mode=9;  
       kn=kn+1;
       Hrset = Hrset+1;
       if(Hrset>=8)Hrset=1;
       else{}
       if (kn ==1)
      {Hrset=oldHrset;
       } }   
       else{}
 
//#############################   ALARM SET KEY PRESSED   ##################################
      if (IR_code == 0xFD027F80  ) {  
   
      if(set_start == 0){
      sentdata2pico("n") ;
}
      set_start=1;
      typeset = 1;
      setmode = 0;
     Mode = 1;
      keysum1 = alm_set;
      int oldalm=alm_set;
      
      IRR( keysum1 , 1);
      alm_set = keysum1;
      if (retnkey == 1){
      alm_set=oldalm;
      retnkey == 0;
}
else{
      String al;
      al = "A"+ String(alm_set);
      sentdata2pico(al);
      aset = 6;
      typeset = 0;
    Mode == 0;
      }   }   

//#########################  TIME SET KEY PRESSED ###########################################
          
      if (IR_code == 0xFE017F80 ) {
      if(set_start == 0){
      sentdata2pico("t"); 
       delay(100);
}
       set_start=1;
       typeset = 2;
       setmode = 1;
       Mode = 1;
      DateTime now = RTC.now();
      dtt2 = now.hour() * 100 + now.minute();
      int Y1=now.year();
      int M1 = now.month();
      int D1 =now.day();
     
      IRR( dtt2 , 2);
//------------------------------------------------------------------------------------------
if (retnkey ==1){
      Mode = 0;
      enterkeypress ==0;
      retnkey == 0;   
}
 if (enterkeypress ==1){
 //     receiver.resume();
      int newtime = keysum1;
      int h1 = newtime / 100;
      int m1 = newtime % 100;
      //int s1=now.second();
      set_start=0;
  
//===========================================================================================
      String hh1= String (h1);
      if(h1/10 ==0) hh1=("0"+hh1);
      if(h1 ==0) hh1=("00");
      String mm1= String (m1);
      if(m1/10 ==0) mm1=("0"+mm1);
      if(m1 ==0) mm1=("00");
      String YY1= String(Y1);
      String MM1= String(M1);
      if(M1/10 ==0) MM1=("0"+MM1);
      if(M1 ==0) MM1=("00");
      String DD1= String(D1);
      if(D1/10 ==0) DD1=("0"+DD1);
      if(D1 ==0) DD1=("00");   
      int s1 =  now.second();   
      String ss1=String(s1);
      if(s1/10 ==0) ss1=("0"+ss1);
      if(s1 ==0) ss1=("00");
      String tr3 = "T"+ YY1+MM1+DD1+hh1+mm1+"00";
      RTC.adjust(DateTime(Y1,M1,D1, h1, m1, 0));
      set_start=0;
      enterkeypress=0;
    // sentdata2pico("Z");
      sentdata2pico(tr3);
   //   sentdata2pico("Z");
      delay(100);
  }
      else{}
  }

//###################ALARM OFF KEY PRESSED  #################################################
         
      if (IR_code == 0xFA057F80  ) {
        sentdata2pico("O");  }
      else {  }

//################ SOUND SET KEY PRESSED #################################################### 

    if (IR_code == 0xF9067F80 ) { 
      
      IR_code == 0xFFFFFFFF; 
   //  delay(100);
     Mode=12;  
      kn=kn+1;
      Snset = Snset+3;
      if(Snset>=33)Snset=0;
      else{}
    if (kn ==1)
      {Snset=oldSnset;  }
      else{}
IR_code == 0xFFFFFFFF;
 }
   
 //######################  DISPLAY ON/ OFF) KEY PRESSED  ####################################

 if (IR_code == 0xED127F80 ) { 
 dispoff_flag =  abs(dispoff_flag - 1);
 String di;
 di = "V"+String(dispoff_flag);
 sentdata2pico("Z0");
  sentdata2pico(di);
 // delay(100);
IR_code == 0xFFFFFFFF;
    
   }
  else {  }
 IrReceiver.resume();
 IR_code == 0xFFFFFFFF;     
  }

//############################### BEND OD REMOTE KEY PRESS CHECK ###########################
 
//###################### END OF MAIN LOOP ###################################################

//#################### SUB PROGRAMME  #######################################################


void IRR( int keysum ,  int typeset ) {
keyvalid = 1; 
while (typeset != 0) {
if (typeset == 1) {
for (int i = 8 ; i > 0  ; i--) {
Light_HR_MIN(keysum);
displaychar(12 , 11) ;
//  Light_HR_MIN(keysum);
  }}
else {}

if (typeset == 2) {
for (int i = 8 ; i > 0  ; i--) {
Light_HR_MIN(keysum);
displaychar(13 , 14) ;
//  Light_HR_MIN(keysum);
}  }
 else {}
switch (IR_code) {

         case 0xF7087F80 ://--------------------RETURN(HOME) KEY PRESSED---------------------
            typeset = 0;
            Mode = 0;
            retnkey=1;
            set_start=0;
            enterkeypress=0;
            keyvalid = 0; 
            break;
 
//-------------------------------------------------------------------------------------------

          case 0xF6097F80 :  //  ----------------PRESSING ENTER KEY--------------------------

              if (  keysum / 10 == 0 && keysum >= 60 ) {
              count = 0;
              keysum = 0;
              keyvalid = 0;
              set_start=0;
              enterkeypress=1;
            }
            else {}

            if ( keysum / 100 == 0 && keysum >= 60) {
              count = 0;
              keysum = 0;
              keyvalid = 0;
            }
            else {}
              if ( keysum / 100 == 0 && keysum / 1000 == 0    &&   keysum % 100  >= 60   ) {
              count = 0;
              keysum = 0;
              keyvalid = 0;
            }
            else {}

            if ( keysum / 10000 == 0    &&  keysum % 100  >= 60  ) {
              count = 0;
              keysum = 0;
              keyvalid = 0;
            }
            else { }
            if (keyvalid == 1) {
              typeset = 0;
             Mode = 0;
             retnkey =0;
             enterkeypress=1;
            }
            else {}
            break ;
//-------------------------------------------------------------------------------------------
          case 0xF50A7F80:  //........KEY 1.........
            keyx = 1;
            keysum = keysum * 10 + keyx;
            count = count + 1;
            break;

      
          case 0xE41B7F80:   //........KEY 2.....
            keyx = 2;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break;

        
          case 0xE01F7F80:   //........KEY 3 ....
            keyx = 3;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break;

          case 0xF30C7F80:    //........KEY 4.....
            keyx = 4;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break ;
          
          case 0xF20D7F80:   //........KEY 5.....
            keyx = 5;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break ;
         
            
          case 0xF10E7F80:     //........KEY 6.....
            keyx = 6;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break ;
        
          case 0xFF007F80:     //........KEY 7.....
            keyx = 7;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break ;
           
 
          case 0xF00F7F80:    //........KEY 8.....
            keyx = 8;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break ;
 
         case 0xE6197F80:    //........KEY 9.....
            keyx = 9;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break ;
        
         case 0xF8077F80:     //........KEY 0.....
            keyx = 0;
            count = count + 1;
            keysum = keysum * 10 + keyx;
            break ;
         }
        IR_code =0xFFFFFFFF;  
  //-----------------------------------------------------------------------------------------
        if (count >= 5) {
          count = 0;
          keysum = 0;
          keyvalid = 0;
        }
        else {}

        if (keysum >= 2400) {
          keysum = 0;
          count = 0;
          keyvalid = 0;
        }
        else {}

        if (keysum <= 0) {
          keysum = 0;
          count = 0;
          keyvalid = 0;
        }
        else {

        keyvalid = 1;
        }
        keysum1 = keysum;

        if (typeset == 1) {
          alm_set = keysum;
        }
        else {}
        if (typeset == 2) {
          time_set = keysum;
        }
        else {}
  IrReceiver.resume();
    }  }
   
//##################### DISPLAY OF HR AND MIN #############################################
  void Light_HR_MIN(int toDisplay) {
if  (IrReceiver.decode()) {
IR_code =IrReceiver.decodedIRData.decodedRawData, HEX;
IrReceiver.resume();  }
    
#define BRIGHTNESS  1000
#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
int hrr = toDisplay / 100;
if (Mode == 1)
{ digitalWrite(digit5, LOW);
digitalWrite(digit6, LOW);
    }
    else {}
for (int digit = 4 ; digit > 0 ; digit--) {
   switch (digit) {

        case 1:
          if (hrr < 10  && hrr != 0 )
          {
            digitalWrite(digit1, DIGIT_OFF);
          }
          else {
            digitalWrite(digit1, DIGIT_ON);
          }
          break;
        case 2:
          digitalWrite(digit2, DIGIT_ON);
          break;
        case 3:
          digitalWrite(digit3, DIGIT_ON);
          break;
        case 4:
          digitalWrite(digit4, DIGIT_ON);
          break;
      }
ShowNumber(toDisplay % 10);
toDisplay /= 10;
delayMicroseconds(BRIGHTNESS);
ShowNumber(10);
//Turn off all digits
digitalWrite(digit1, DIGIT_OFF);
digitalWrite(digit2, DIGIT_OFF);
digitalWrite(digit3, DIGIT_OFF);
digitalWrite(digit4, DIGIT_OFF);
    }  }

//###################   SHOW NUMBER #######################################################
  void ShowNumber(int numberToDisplay) {
  // Define segment states
  #define ON  HIGH
  #define OFF LOW

  // Array defining the segment states for each character
  const uint8_t segmentMap[34][7] = {
      {ON, ON, ON, ON, ON, ON, OFF}, // 0
      {OFF, ON, ON, OFF, OFF, OFF, OFF}, // 1
      {ON, ON, OFF, ON, ON, OFF, ON}, // 2
      {ON, ON, ON, ON, OFF, OFF, ON}, // 3
      {OFF, ON, ON, OFF, OFF, ON, ON}, // 4
      {ON, OFF, ON, ON, OFF, ON, ON}, // 5
      {ON, OFF, ON, ON, ON, ON, ON}, // 6
      {ON, ON, ON, OFF, OFF, OFF, OFF}, // 7
      {ON, ON, ON, ON, ON, ON, ON}, // 8
      {ON, ON, ON, ON, OFF, ON, ON}, // 9
      {OFF, OFF, OFF, OFF, OFF, OFF, OFF}, // Blank (10)
      {ON, ON, ON, OFF, ON, ON, ON}, // A (11)
      {OFF, OFF, OFF, ON, ON, ON, OFF}, // L (12)
      {OFF, OFF, OFF, ON, ON, ON, ON}, // t (13)
      {ON, OFF, ON, ON, OFF, ON, ON}, // S (14)
      {ON, ON, OFF, OFF, OFF, ON, ON}, // Degree (15)
      {ON, OFF, OFF, ON, ON, ON, OFF}, // C (16)
      {ON, OFF, OFF, OFF, ON, ON, ON}, // F (17)
      {OFF, OFF, ON, OFF, ON, OFF, ON}, // n (18)
      {OFF, ON, ON, OFF, ON, ON, ON}, // H (19)
      {ON, OFF, ON, ON, ON, ON, ON}, // G (20)
      {OFF, OFF, ON, ON, ON, OFF, ON}, // Small o (21)
      {OFF, OFF, ON, ON, ON, OFF, OFF}, // Small v (22)
      {OFF, OFF, ON, OFF, OFF, OFF, OFF}, // Small i (23)
      {OFF, ON, ON, ON, ON, OFF, ON}, // Small d (24)
      {OFF, OFF, ON, OFF, ON, OFF, ON}, // Small n (25)
      {OFF, OFF, OFF, OFF, OFF, OFF, ON}, // - (26)
      {OFF, ON, ON, ON, ON, ON, OFF}, // U (27)
      {OFF, OFF, ON, OFF, ON, ON, ON}, // h (28)
      {OFF, OFF, ON, ON, ON, ON, ON}, // b (29)
      {OFF, OFF, ON, ON, ON, OFF, ON}, // Small o (30)
      {OFF, ON, ON, ON, OFF, OFF, OFF}, // Small j (31)
      {OFF, OFF, ON, ON, ON, ON, ON}, // b (32)
      {OFF, OFF, OFF, ON, OFF, OFF, OFF} // Underscore (33)
  };

  // Check for IR signal
  if (IrReceiver.decode()) {
    IR_code = IrReceiver.decodedIRData.decodedRawData;
    IrReceiver.resume();
  }

  // Validate the input range
  if (numberToDisplay < 0 || numberToDisplay >= 34) {
    numberToDisplay = 10; // Default to blank if out of range
  }
  // Map each segment to the pin and set its state
  digitalWrite(segA, segmentMap[numberToDisplay][0]);
  digitalWrite(segB, segmentMap[numberToDisplay][1]);
  digitalWrite(segC, segmentMap[numberToDisplay][2]);
  digitalWrite(segD, segmentMap[numberToDisplay][3]);
  digitalWrite(segE, segmentMap[numberToDisplay][4]);
  digitalWrite(segF, segmentMap[numberToDisplay][5]);
  digitalWrite(segG, segmentMap[numberToDisplay][6]);
}

//################# DISPLAY CHARACTOR#########################################################

 void displaychar(int charshow1 , int charshow2) {
if  (IrReceiver.decode()) {
IR_code =IrReceiver.decodedIRData.decodedRawData, HEX;
IrReceiver.resume(); }
    
#define BRIGHTNESS 2000
#define BRIGHTNESS1  400
#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW

    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(digit6, DIGIT_OFF);
    digitalWrite(digit5, DIGIT_ON);
    ShowNumber(charshow2);
    delayMicroseconds(BRIGHTNESS);
    ShowNumber(10);
    digitalWrite(digit5, DIGIT_OFF);
    digitalWrite(digit6, DIGIT_ON);
    ShowNumber(charshow1 );
    delayMicroseconds(BRIGHTNESS);
    digitalWrite(digit6, DIGIT_OFF);
    digitalWrite(digit5, DIGIT_OFF);
    ShowNumber(10);
  }
//###################  DISPLAY BIG CHAR ####################################################
 void big_char(int char1 , int char2,int char3 , int char4) {
#define BRIGHTNESS 1000

if  (IrReceiver.decode()) {
 IR_code =IrReceiver.decodedIRData.decodedRawData, HEX;
 //Serial.println(IR_code,HEX);
IrReceiver.resume();
  }

#define BRIGHTNESS1  400
#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
     digitalWrite(digit6, DIGIT_OFF);
     digitalWrite(digit5, DIGIT_OFF);
     digitalWrite(digit1, DIGIT_ON);
     digitalWrite(digit2, DIGIT_OFF);
     digitalWrite(digit3, DIGIT_OFF);
     digitalWrite(digit4, DIGIT_OFF);
     ShowNumber(char1);
     delayMicroseconds(BRIGHTNESS);
     ShowNumber(10);
     digitalWrite(digit1, DIGIT_OFF);
     digitalWrite(digit2, DIGIT_ON);
     ShowNumber(char2 );
     delayMicroseconds(BRIGHTNESS);
     ShowNumber(10);
     digitalWrite(digit2, DIGIT_OFF);
     digitalWrite(digit3, DIGIT_ON);
     ShowNumber(char3 );
     delayMicroseconds(BRIGHTNESS);
     ShowNumber(10);
     digitalWrite(digit3, DIGIT_OFF);
     digitalWrite(digit4, DIGIT_ON);
     ShowNumber(char4 );
     delayMicroseconds(BRIGHTNESS);
     ShowNumber(10);
     digitalWrite(digit4, DIGIT_OFF);
    ShowNumber(10);
    return;  }
//####################  DATE SET ###########################################################

void DT_SET( int keysum ,  int typeset ) {
//if(set_start == 0){
//Serial.println("dateset"); 
 //sentdata2pico("d") ;
//}
//set_start=1;
keyvalid=1;
while (typeset != 0) { 
int seca =(keysum%100)%10;
int secb = (keysum%100)/10;
  for (int i = 8 ; i > 0  ; i--) {
      Light_HR_MIN(keysum/100);
      displaychar(seca, secb) ;
  //  Light_HR_MIN(keysum/100);
      }
                      
switch ( IR_code) {

       case 0xF7087F80 ://--------------------RETURN KEY PRESSED----------------------------
            typeset = 0;
            Mode = 0;
            retnkey=1;
            set_start=0;
            enterkeypress =0;
            datesetflag =0;
            keyvalid=0;
            
            break;

      case 0xF6097F80 :  //  -------------------PRESSING ENTER KEY--------------------------

            if (  keysum %100 <= 10 || keysum%100 >=51  ){
              count = 0;
              keysum = 0;
              keyvalid = 0;      
            }
            if ( ((keysum / 100)%100) < 0 || ((keysum / 100)%100) >=13)  {
              count = 0;
              keysum = 0;
              keyvalid = 0;      
            }
...

This file has been truncated, please download it to see its full contents.

/*PROGRAM FOR SCROLLING  CLOCK
 FOR USING IN COBINATION WITH THE SKETCH FOR BIG CLOCK 
 WRITTEN BY BY AJITH KUMAR B
 UPDATED ON 7 DECEMBER 2024
*/
  #include <SPI.h>
  #include <RP2040_SD.h>
  #include <MD_Parola.h>
  #include <MD_MAX72xx.h>
  #include <Wire.h>
  #include "NewPing.h"
  #include "DHT.h"
  #include <RTClib.h>
  #include "DFRobotDFPlayerMini.h"
  #define DHTPIN 11
  #define DHTTYPE DHT11
  #define MAX_DEVICES 4
  #define CS_PIN 9
  #define DATA_PIN 7
  #define CLK_PIN 6
  #define SOUND_VELOCITY 0.034
  #define TRIGGER_PIN 22
  #define ECHO_PIN 21
  #define MAX_DISTANCE 400 
  #define HARDWARE_TYPE MD_MAX72XX::FC16_HW  
  NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
  RTC_DS1307 rtc;
  DHT dht(DHTPIN, DHTTYPE);
  MD_MAX72XX *pM;
  MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);
  DFRobotDFPlayerMini myDFPlayer;
 void TOTAL_LINE ( String );
  void disptime(int);
  void mp3play(int  , int, int);
  void timespeak(void);
  void mng_evg_song_play(int, int);
  void checkstatus(void);
  void ultrasound(void);
  void sd_datastor(String);
  void line1(void );
  void Temperature(void);
  void retryInitialization(void);
  void NTH_LINE_SD_READER ( String  , int);
  void LinebyLinereader(String ,int,int);
  File myFile;
  String displine;
  String lin;
  String lin1;
  String spos;
  String L;
  String data_string;

//=============================================
  int snd_block_start =21; int snd_block_end =4;
  int mrg_wish_hr = 5; int mrg_wish_min = 15;
  int mngsong_hr = 6; int mngsong_min = 10;
  int evgsong_hr = 18; int evgsong_min = 1;
  int cal_hr_on = 4; int cal_hr_off = 18;
//=============================================
  String message1 = "Good Morning..";
  String message2 = "Good After Noon..";
  String message3 = "Good Evening..";
  String message4 = "Good Night..";
  String message5 = "Maha Lekshmi Namah";
  String message6= "Ohm Nama Shivaya..";
  String randomfile ="comments.txt";;
  String Calender_file="2024.txt";
  String Mng_song ="lekshmi.txt";
  String Evn_song ="lalitha.txt";
//============================================
  String calender_message= "";
  String message;
  String mess;
  String Nth_line;
  char care;
  char R;
  char song;
  long duration;
  bool ch_stat = 0;
  bool hr_onoff;
  bool ul_onoff;
  bool lin_stop = 0;
  bool Powr_on=1;
  float humid;
  float heat;
  float dist_cm;
  int Alm_time = 06;
  int chimeblk=0;
  int alhr ;
  int almn;
  int I = 0 ;
  int lineno;
  int k;
  int totline;
  int mpos;
  int ps[800];
  int dely = 1000;
  int Tempr;
  int randtotline;
  int Tot_line;
  int rr = 1;
  int Disp_on;
  int snoozon;
  int Almoff  = 0;
  int ALM_time;
  int Hr_status;
  int Alm_Poff;
  int Snd_vol;
  int req_no=1;
  int cum_month[13] = {0,0,31,59,90,120,151,181,212,243,273,304,334};
    
//############################  SET UP  ##################################################
  void setup()
  {
  Wire1.setSDA(14);
  Wire1.setSCL(15);
  Wire.setSDA(12);
  Wire.setSCL(13);
  rtc.begin(&Wire1) ;
  Wire.begin(8);
  Wire1.begin();
  Wire.begin(8);
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent);
  Serial1.begin( 9600);
  Serial.begin(9600);
  dht.begin();
  pM = myDisplay.getGraphicObject();
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  myDisplay.begin();
  myDisplay.setIntensity(0);
  myDisplay.setTextAlignment(PA_RIGHT);
  myDisplay.setPause(1000);
  myDisplay.setSpeed(100);
  myDisplay.displayClear();
  Serial.begin(9600);
//----------------------------------------
 if (!SD.begin(17)) {
    retryInitialization();  } 
  else {}
 myFile = SD.open(randomfile);
 //---------------------------------------------
  mpos = 0;
  pinMode(10, INPUT);
  Serial1.begin(9600);
  Serial.begin(9600);
  myDFPlayer.begin(Serial1);
  delay(1000);
  if (!myDFPlayer.begin(Serial1)) {
  }
  myDFPlayer.start();
  delay(100);
  sd_datastor("R" ) ;
  alhr = ALM_time / 100;
  almn = ALM_time % 100;
  myDFPlayer.volume(Snd_vol);
  myDFPlayer.playFolder(5, 1);
  delay(100);
  myDisplay.displayText("HAI..", PA_CENTER, 100, 1, PA_BLINDS);
  while (myDisplay.displayAnimate() == false) { } 
delay(500);
TOTAL_LINE(randomfile); 
  }
//########################   MAIN LOOP   #################################################
  void loop() {
  Temperature();
  Serial.begin(9600);
  DateTime now = rtc.now();
  int hr = now.hour();
  int mn = now.minute();
  int scc = now.second();
  myDisplay.displayClear();
  myDFPlayer.volume(Snd_vol);
  //---------------------------------------------------------------------------------
  if (hr >= 4 && hr <= 12)message = message1;
  if (hr >= 13 && hr <= 16)message = message2;
  if (hr >= 16 && hr <= 20)message = message3;
  if (hr >= 20 && hr <= 23)message = message4;
  if (hr >= 0 && hr < 4)message = message4;
  if (hr == 5 )message = message5;
  if (hr == 18 )message = message6;
  checkstatus();

//###################### CALENDER MESSAGE  FINDING ########################################

  if((Powr_on==1) || ( hr==0 && mn==3 && scc<= 30) ){
  Powr_on=0; 
  int dyy = now.day();
  int mnn = now.month();
  // int yrr = now.year();
  // String Calender_file = String(yrr)+".txt";
   int  day_count =cum_month[mnn]+dyy;
  NTH_LINE_SD_READER ( Calender_file,day_count);
  calender_message = Nth_line;
}
//########################################################################################
//---------------------------------------morng wish-start----------------------------
  if ( hr == mrg_wish_hr && mn == mrg_wish_min  && scc <= 2) {
  ch_stat = 1;
  myDisplay.displayClear();
  myDFPlayer.volume(Snd_vol);
  myDFPlayer.playFolder(5, 2);
  delay(1000);
  myDisplay.displayText("  Good Morning Sobha...", PA_RIGHT, 100, 1, PA_SCROLL_LEFT);
  while (myDisplay.displayAnimate() == false) {
  }
  ch_stat = 1;
  }
//------------------------------------morng wish  end---------------------------------
//################################### 30 MIN AND HOUR CHIME###############################
//------------------------------------30 min  speak------------------------------------
  if (  (mn == 30) && (scc <= 3) &&   (hr_onoff==0) &&  (chimeblk==0)  && ( digitalRead(10) == HIGH )) {
  ch_stat = 1;
  myDisplay.displayClear();
  myDFPlayer.volume(Snd_vol);
  myDFPlayer.playFolder(7, 2);
  delay(1000);
  for (int kh = 1 ; kh <= 2 ; kh++) {
  myDisplay.displayText("HALF HOUR ", PA_CENTER, 100, 1, PA_BLINDS);
  while (myDisplay.displayAnimate() == false) {
  }
  delay(1000);
  }
  timespeak();
  ch_stat = 0;
  myDisplay.displayClear();
  }
  else
  {ch_stat = 0; }
  //----------------------hOUR cHIME -----------------------------------------------------
  if (  mn == 0 && scc <= 3 &&   hr_onoff==0 &&  chimeblk==0) {
  ch_stat = 1;
  myDisplay.displayClear();
  myDFPlayer.volume(Snd_vol);
  myDFPlayer.playFolder(7, 1);
  delay(1000);
  for (int hh = 1 ; hh <= 6 ; hh++) {
  myDisplay.displayText("DING  DING ", PA_CENTER, 100, 1, PA_BLINDS);
  while (myDisplay.displayAnimate() == false) {
  }
  myDisplay.displayClear();
  delay(1500);
  }
  ch_stat = 0;
  }
  else {
  ch_stat = 0; 
  }

//#########################   ALARM ######################################################
  if ( hr == alhr && mn == almn  && scc <= 2  && Alm_Poff == 1) {
  ch_stat = 1;
  chimeblk=1;
  myDisplay.displayClear();
  myDFPlayer.volume(Snd_vol);
  Almoff = 0;
  myDFPlayer.playFolder(3, 1);
  delay(1000);
  myDisplay.displayText("ALARM            ", PA_RIGHT, 100, 1, PA_SCROLL_LEFT);
  while ((myDisplay.displayAnimate() == false)   ||(Almoff == 0) ) {
  checkstatus();
  }
  delay(2000);
  ch_stat = 1;
  chimeblk=0;
  }
//########################### MORNING & ENG SONG #########################################
  if ( hr == mngsong_hr && mn == mngsong_min && scc <= 2    ) {
  ch_stat = 1;
  chimeblk=1;
  myDFPlayer.volume(Snd_vol);
  LinebyLinereader(Mng_song, 3, 2);
  ch_stat = 0;
  chimeblk=0;
  Almoff = 0;
   }
  if ( hr == evgsong_hr && mn == evgsong_min && scc <= 2  ) {
  ch_stat = 1;
  chimeblk=1;
  myDFPlayer.volume(Snd_vol);
  LinebyLinereader(Evn_song, 3, 3);
  ch_stat = 0;
  chimeblk=0;
  Almoff = 0;
  } 
  
//---------------- --- End  of morning  and Evg song--------------------------------

//#################################### NORMAL TIME #######################################
  checkstatus();
  if (ch_stat == 0) {
  myDisplay.displayClear();
  int msglength = (message.length() + 1);
  char mssg[msglength];
  message.toCharArray(mssg, msglength);
  myDisplay.displayScroll(mssg, PA_RIGHT, PA_SCROLL_LEFT, 80);
  while (myDisplay.displayAnimate() == false) {
  ultrasound();
  checkstatus();
  if (ch_stat == 1)return; }
  if ((hr != 5 ) && (hr != 18 ) ) { // to display message5 or 6 alone at 5 am and 6 pm

//########################CALender MESSAGE ###############################################

  if ( hr >= cal_hr_on  && hr <= cal_hr_off){
  myDisplay.displayClear();

  if (calender_message.length() > 3) {
     mess  = calender_message.substring(3);
  } else {
    mess= "";
  }
  int Clength = (mess.length() );
  char cmssg[Clength];
 mess.toCharArray(cmssg, Clength);
  myDisplay.displayScroll(cmssg, PA_RIGHT, PA_SCROLL_LEFT, 80);
  while (myDisplay.displayAnimate() == false) {
  ultrasound();
  checkstatus();
  if (ch_stat == 1)return;
  };
}

//********************** TEMPERATURE DISPLAY *********************************************
  myDisplay.displayClear();
  String tmp = "Temp: " + String(heat) + " 'C" + "                      Humid: " + String(humid) + " %" ;
  int tmp_length = (tmp.length() + 1);
  char tmpr[tmp_length];
  tmp.toCharArray(tmpr, tmp_length);
  myDisplay.displayScroll(tmpr, PA_RIGHT, PA_SCROLL_LEFT, 80);
  while (myDisplay.displayAnimate() == false) {
  ultrasound();
  checkstatus();
  if (ch_stat == 1)return;
  }
//*****************************************************************************************
  myDisplay.displayClear();
  disptime(1);
 }
 checkstatus();
 }
 ultrasound();
  }
//-------------------END OF MAIN LOOP----------------------------------------------

//#################### SUB PROGRAMS   ###################################################

  void disptime(int tipe) {  // to diplay Real time on Parala display
  DateTime now = rtc.now();
  char time_format[] = "     hh:mm:ss AP";
  char date_format[] = "     DDD DD MMM YY";
  char time_format2[]  = " hh:mm   AP";
  if (tipe == 1) {
  String apm;
  int h1=now.hour();
  int m1=now.minute();
  int s1=now.second()+3;
  if(s1>=60){ 
  s1=0; 
  m1=m1+1;  }
  if(m1>=60){ 
  m1=0; 
  h1=h1+1;  }     
  if(h1 >= 12)apm=":PM";
  else{
  apm= ":AM";  
  }
  if(h1 >= 12)h1=h1-12;    
  if(h1 == 0)h1=12;    
  String hh1= String (h1);
  if(h1/10 ==0) hh1=("0"+hh1);
  if(h1 ==0) hh1=("00");
  String mm1= String (m1);
  if(m1/10 ==0) mm1=("0"+mm1);
  if(m1 ==0) mm1=("00");
  String ss1=String(s1);
  if(s1/10 ==0) ss1=("0"+ss1);
  if(s1 ==0) ss1=("00");
  String tr5 = hh1+":"+mm1+":"+ss1+apm;
  int msgln = (tr5.length() + 1);
  char msg[msgln];
  tr5.toCharArray(msg, msgln);
  myDisplay.displayScroll(msg, PA_LEFT, PA_SCROLL_LEFT, 80);
  while (myDisplay.displayAnimate() == false) {
  ultrasound();
  checkstatus();
  if (ch_stat == 1) return;
    }
  myDisplay.displayClear();
  String up=now.toString(date_format);
  up.toUpperCase();
  int upln = (up.length() + 1);
  char upm[upln];
  up.toCharArray(upm, upln);
  myDisplay.displayScroll(upm, PA_LEFT, PA_SCROLL_LEFT, 80);
  while (myDisplay.displayAnimate() == false) {
  ultrasound();
  checkstatus();
  if (ch_stat == 1) return;
  }
  myDisplay.displayClear();
  ch_stat == 1;
  return;
  }
  if (tipe == 2) {
  myDisplay.print(now.toString(time_format2));
  }
  return; }
//###########################################################################################
  void mp3play(int fold , int playfileno , int timedely) {  //  to play Specifif Mp3 file on DF player
  myDFPlayer.playFolder(fold, playfileno);; //now
  delay(1000);
  }
//##########################################################################################
  void timespeak( void) {   // to play the time on MP3 player
   
  DateTime now = rtc.now();
  int h = now.hour();
  int m = now.minute();
  int s = now.second();
  if (h >= 12) {
    h = h - 12;
  }
  if (h == 0) {
    h = 12;
  }
  myDFPlayer.playFolder(1, h); //hour
  delay(dely);
  while (digitalRead(10) == LOW) {
  }
  return; }

//#########################################################################################
  void checkstatus(void){ // To check the status  of different sub systems 
  DateTime now = rtc.now();
  long int a1 = now.hour() * 3600 + now.minute() * 60 + now.second();
  long int a2 = now.minute() * 60 + now.second();
  long int mwish = mrg_wish_hr * 3600 + mrg_wish_min * 60;
  long int msong = mngsong_hr * 3600 + mngsong_min * 60;
  long int esong = evgsong_hr * 3600 + evgsong_min * 60;
  long int alr = alhr * 3600 + almn * 60;

  if (( a1 >= mwish - 3) && ( a1 <= mwish + 3) ) { // mrng wish
    ch_stat = 1; return; }
    
  if (( a1 >= msong - 3) && ( a1 <= msong + 3) ) { // morng song
    ch_stat = 1; return; }
    
  if (( a1 >= esong - 3) && ( a1 <= esong + 3) ) { // evening song
    ch_stat = 1; return; }
    
  if (( a2 >= 3597) || ( a2 <= 3)) { // full hour chime
    ch_stat = 1; return; }
    
  if ( (a2 >= 1797) && (a2 <= 1803) ) { // half hour chime
    ch_stat = 1; return; }

  if (( a1 >= alr - 3) && ( a1 <= alr + 3) ) { //alarm
    ch_stat = 1; return; }
  ch_stat = 0;

//-------------------------------------------------------------------------------------
  hr_onoff =1;ul_onoff =1;
  if ((Hr_status==7) ){
  hr_onoff =1; 
  ul_onoff =1;
  }
  else {}
  if ((Hr_status==1) ||  (Hr_status==3)  ) hr_onoff =0;
  else {}
  if ((Hr_status==2) ||  (Hr_status==3)  ) ul_onoff =0;
  else {}
  if ((( now.hour()>= snd_block_end)&&(now.hour()<=snd_block_start  ))&& ( (Hr_status==4)|| (Hr_status==6))           )  {
  hr_onoff =0;
  }
  else {}
  if ((( now.hour()>=snd_block_end)&&(now.hour()<=snd_block_start ))&& (    (Hr_status==5)|| (Hr_status==6)       )    )  {
  ul_onoff =0;
  }
  else {}
  return;
  }
//########################################################################################
  void ultrasound(void) {  // to check/play ultra sound sensor
  if(digitalRead(10) == LOW) {
   return;}
  if(ul_onoff==0 &&  chimeblk==0){
  dist_cm=sonar.ping_cm();
  if ((dist_cm >= 2 ) && (dist_cm <= 300 )) {
  ch_stat = 1;
  myDisplay.displayClear();
  int rand_fileno = random(1, Tot_line - 1);
  NTH_LINE_SD_READER ( randomfile, rand_fileno);
   int Line_length = Nth_line.length() - 1;
  char dispa[Line_length];
  Nth_line.toCharArray(dispa, Line_length);
  mp3play(10, rand_fileno, 1000);
  delay(100);    
  for (int kh = 1 ; kh <= 5 ; kh++) {
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print(dispa );
  delay (200);
  myDisplay.displayClear();
  delay (200);
  } }
  else{}
  }
  else{}
  return;
   }
//########################################################################################
  void receiveEvent(int howMany) {  // for actions to do when an event is received from master clock throuh I2C
  Wire.begin(8);
  String uc = "";
  String yt = "";
  String dt = "";
  String ti;
  String req_type;
  while (0 < Wire.available()) {
  char c = Wire.read();
  uc = uc + c;
  }
  if (uc == "")uc = "Z0";
  req_type = uc.charAt(0);
  uc = uc.substring(1);
  ti =uc.charAt(0);
 //  if (uc == "Z")return;
   
//========================================
  if (req_type == "N" ) {
  //Serial.println  ("ALM PER OFF  ");
  Alm_Poff = ti.toInt();
  sd_datastor("W" ) ;
  }
//=========================================
  if (req_type == "R" ) {
  //Serial.println  (" hour chime set mode");
  Hr_status = ti.toInt();
  sd_datastor("W" ) ;
  }
//==========================================
  if (req_type == "A" ) {
  //Serial.println  (" alarm set time");
  ALM_time =  (uc.substring(0, 4)).toInt();
  alhr = ALM_time / 100;
  almn = ALM_time % 100;
  sd_datastor("W") ;
  }
//==========================================
  if (req_type == "O" ) {
  //Serial.println  (" ALM OFF");
  Almoff = 1;
  myDFPlayer.stop();
  lin1 = "ALM/PLR OFF";
  line1() ;
  }
  if (req_type == "S" ) {
//Serial.println  (" SOUND VOL");
  Snd_vol = (uc.substring(0, 2)).toInt();
  sd_datastor("W") ;
  }
//=========================================
  if (req_type == "V" ) {
  //Serial.println  (" DISPLAY OFF");
  Disp_on = ti.toInt();
  if (Disp_on==0){
  pM->control(MD_MAX72XX::SHUTDOWN,1); }
  else{
  pM->control(MD_MAX72XX::SHUTDOWN,0);
 }}
//==========================================
  if (req_type == "t" ) {
  lin1 = "SET TIME"; line1() ; }
  
  if (req_type == "n" ) {
  lin1 = "SET ALARM"; line1() ;}
  
  if (req_type == "a" ) {
  lin1 = "SET ALM-ON"; line1();}
  
  if (req_type == "d" ) {
  lin1 = "SET DATE";line1() ;  }
  
  if (req_type == "y" ) {
  lin1 = "SYNC TIME";line1() ; }
  
  if (req_type == "s" ) {
  lin1 = "SET VOL"; line1() ;  }
  
  if (req_type == "h" ) {
  lin1 = "SET CHIME";line1() ; }
  
  if (req_type == "G" ) {
  lin1 = "SENT DATA";line1() ; }
  
  if (req_type == "g" ) {
  lin1 = "TEMPERATURE";line1() ;
  
  }
  
  if (req_type == "T" ) {
  int ss = ((uc.substring(12)).toInt()) +3;
  int mm = (uc.substring(10, 12)).toInt();
  if (ss >= 60 ){
  ss = ss - 60;
  mm = mm + 1;  }
  int hh = (uc.substring(8,10)).toInt();
  int DD = (uc.substring(6, 8)).toInt();
  int MM = (uc.substring(4, 6)).toInt();
  int YY = (uc.substring(0, 4)).toInt();
  DateTime now = rtc.now();
  Wire1.begin();
//  rtc.begin(&Wire1) ;
  delay(50);
  rtc.adjust(( DateTime(YY, MM, DD, hh, mm, 3)));
  delay(500);
  lin_stop = 0;
  }
  Wire1.begin();
  return;  }

//#######################################################################################
  void requestEvent() { // To read  data from SD card and send to Master on power on 
  Temperature() ;
  DateTime now = rtc.now();
  int Y1=now.year();
  int M1 = now.month();
  int D1 =now.day();
  int h1 =now.hour();
  int m1 =now.minute();
  int s1=now.second()+6;
 if(s1 >=60){
  s1=0;
  m1=m1+1; }
  String hh1= String (h1);
  if(h1/10 ==0) hh1=("0"+hh1);
  if(h1 ==0) hh1=("00");
  String mm1= String (m1);
  if(m1/10 ==0) mm1=("0"+mm1);
  if(m1 ==0) mm1=("00");
  String YY1= String(Y1);
  String MM1= String(M1);
  if(M1/10 ==0) MM1=("0"+MM1);
  if(M1 ==0) MM1=("00");
  String DD1= String(D1);
  if(D1/10 ==0) DD1=("0"+DD1);
  if(D1 ==0) DD1=("00");   
//  int s1 =  now.second()+;   
  String ss1=String(s1);
  if(s1/10 ==0) ss1=("0"+ss1);
  if(s1 ==0) ss1=("00");
  String tr3 = YY1+MM1+DD1+hh1+mm1+ss1;
  String a1 = String(ALM_time);
  if ((ALM_time / 1000) <= 0)a1 = "0" + a1;
  String a2 = String(Alm_Poff);
  if (Alm_Poff == 0)a2 = "0";
  String a3 = String(Hr_status);
  if ((Hr_status == 0))a3 = "0";
  String a4 = String(Snd_vol);
  if ((Snd_vol / 10) <= 0)a4 = "0" + a4;
  String t = String(Tempr);
  String a5 = tr3+a1 + a2 + a3 + a4 + t;
  char rs[27];
  a5.toCharArray(rs, 27);
  Wire.begin(8);
  delay(50);
  Wire.write(rs, 26);
  delay(100);
   return;
  }
//####################### STORE DATA ON SD CARD ##########################################
  void sd_datastor(String rw ) {  // For reading and Writing  data on SD card
  String la;
  char ra;
  if (rw == "R") {
  myFile = SD.open("datastor.txt", FILE_READ);
  la = "";
  while (myFile.available()) {
  ra = myFile.read();
  la = la + ra;
  }
  data_string = la;
  ALM_time = (la.substring(0, 4)).toInt();
  Alm_Poff = (la.substring(4, 5)).toInt();
  Hr_status = (la.substring(5, 6)).toInt();
  Snd_vol = (la.substring(6)).toInt();
  myFile.close();
  return;
  }
  if (rw == "W") {
  SD.remove("datastor.txt");
  myFile = SD.open("datastor.txt", FILE_WRITE);
  int d = ALM_time * 10000 + Alm_Poff * 1000 + Hr_status * 100 + Snd_vol;
  String dd = String(d);
  myFile.print(dd);
  myFile.close();
  return;
  }}
//########################################################################################
  void line1(void ) {  // for diplaying messages in single line on Parola
  int lin1_length = lin1.length();
  char lin[lin1_length];
  lin1.toCharArray(lin, lin1_length + 1);
  lin_stop = 1;
  for (int kh = 1 ; kh <= 6 ; kh++) {
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print(lin );
  delay (200);
  myDisplay.displayClear();
  delay (200);
  }
  return;  }
//########################################################################################
  void Temperature(void) { // to Read Temperature and humidity from Sensor
  delay(500);
  humid  = dht.readHumidity();
  heat = dht.readTemperature();
  Tempr = int(heat * 100);
  return;
  }
//########################################################################################
void retryInitialization() {
  
  int attempts = 0;
  const int maxAttempts = 5;
  while (attempts < maxAttempts) {
 // Serial.print("Attempt ");
  // Serial.println(attempts + 1);
    if (SD.begin(17)) {
   //   Serial.println("SD card initialized successfully.");
      return;  // Exit function if successful
    } else {
  //  Serial.println("SD card initialization failed!");
      delay(2000);  // Wait before retrying
    }
    attempts++;
  }}

//########################################################################################
void LinebyLinereader(String fileto_read, int fold ,int fle){
 Serial.begin(9600);
int op=1;
   myFile = SD.open(fileto_read);
  if(Almoff == 1) {
  Almoff == 0; 
   return;
  }  
  if (op == 1) {
  mp3play(fold, fle, 1000);
  delay(1000);
  op=0;
  } 
  if (myFile) {
  while (myFile.available()) {
  String line_read = myFile.readStringUntil('\n');  
  if(Almoff == 1) {
  Almoff == 0;
  return;
  }  
    //--------------- 
   int linelength = line_read.length() - 1;
  char line_disp[linelength];
  line_read.toCharArray(line_disp, linelength);
  while (myDisplay.displayAnimate()) {
  myDisplay.displayText(line_disp, PA_RIGHT, 100, 1, PA_SCROLL_LEFT);
  }
  while (myDisplay.displayAnimate() == false) {
  }
  while (myDisplay.displayAnimate()) {
    myDisplay.displayText("      ", PA_RIGHT, 40, 1, PA_SCROLL_LEFT);
  }
  while (myDisplay.displayAnimate() == false) {
  }
  myDisplay.displayClear();
//----------------    
  }
  myFile.close(); 
 }
  else {}
  return;
}
//########################################################################################
  void NTH_LINE_SD_READER ( String file_name, int lineNo){
  myFile = SD.open(file_name); 
  String line = "";
  int currentLine = 1;
  while (myFile.available()) {
  line = myFile.readStringUntil('\n'); 
  if (currentLine == lineNo) {
  break;
   }
  currentLine++; }
  if (line.length() <= 0)line=" ";
  Nth_line=line;
  myFile.close();  
  return; }
//########################################################################################

void TOTAL_LINE ( String file_N){
myFile = SD.open(file_N); 
  int Line_no = 1;
String line ="";
  while (myFile.available()) {
  line = myFile.readStringUntil('\n'); 
  Line_no++; }
  Tot_line=Line_no;
  myFile.close(); 
  return;  }
 //###############################   END  ################################################