Now, to complete work on the device, you only need to perform a number of simple operations:

Compiling the program code and further loading it into the microcontroller’s memory will take some time, usually no more than one minute. The successful completion of the operation will be reported in the Arduino IDE console. After which all that remains is to reboot the Arduino using the Reset button on the device - a simple clock on LED matrices is ready!

Ready clock on Arduino

The clock is set using two buttons. The device supports 12- and 24-hour time formats, displays the date and day of the week, and displays the time with or without seconds. It is also possible to change the brightness of the LEDs.

You will probably want to add more features in the future (for example, a thermometer), or install the device in a body of your own design - good results can be achieved by manufacturing on laser cutting machines. But now you can safely say that you have assembled a full-fledged electronic watch with your own hands!

So, after a short technical break, we continue our acquaintance with the ARDUINO MK family. In this lesson we will try to make a clock that works from the internal generator of the MK (with an external generator there will be one of the following lessons) and displays information on an LCD indicator of type 1602 (which means 16 characters in 2 lines, there is also type 1604 - 16 characters in 4 lines, you already understand that the first 2 digits indicate the number of indicator characters and the second ones indicate the number of lines). Let's not delay the introduction, let's get to work.

For the project we will need:

1. Arduino Uno
2. LCD indicator 1602
3. Development board
4. Wires
5. Trimmer resistor 10 kOhm

For those who are especially lazy, I advise you to go to the bottom of the page and download the finished sketch; for those who want to learn how to make sketches on their own, I will describe in more detail all the steps of the project. To work on a project correctly and quickly, a work algorithm is required. It’s better to sketch out almost any project on paper and then follow the algorithm step by step. We will do exactly the same. So let's create an algorithm. We have several conditions, let's write them in ascending order:

1. Seconds work in the range from 0 to 59 in a cycle with a second interval (this is understandable).
2. Minutes operate in the range from 0 to 59 in a cycle, switching occurs when the seconds value reaches 0.
3. The clock operates in the range from 0 to 24 (here you can choose to display it in a foreign style from 0 to 12 with AM and PM values, whichever you prefer) in a cycle, switching occurs when the minute value reaches 0.
4. Display all the necessary information on the display (for example, you may decide not to display seconds but just make a flashing dot between hours and minutes)

We assemble our watches according to this scheme:

Connecting LCD indicator 1602 to ARDUINO

Assembly tips. The 1602 indicator usually comes from China in a “naked” form, i.e. no pins are soldered, I advise you to use double-row computer sockets from motherboards for these purposes, one pin of the socket is inserted into 1602, the second pin is behind the edge of the board, solder both pins to one pin - this increases the mechanical and electrical strength. This diagram does not indicate the backlight connection diagram; these are the next 2 pins to the right of D7. You can connect them to the 3.3V power supply on ARDUINO, you can make a smooth switching on/fading if you connect the positive pin (it is labeled as A-anode) to the ARDUINO output and control the power through this pin, this is a secondary task, for now just connect the pin And on 1602 to 3.3V on ARDUINO, and pin K 1602 to GND ARDUINO.

Now let's start actually designing the watch. We launch the ARDUINO shell on the computer. Let's try to play with 1602 to check the correct connections of the circuit. Let's go File-Examples-LiqidCrystal and select any of the files. We upload the sketch to ARDUINO and watch what happens. If instead of symbols you see black squares, tighten the trimming resistor, this is a contrast regulator (do the same if nothing is displayed at all). Information must be displayed correctly and there simply should not be any “crazy stuff”. If they appear, check the connection diagram, where it was assembled incorrectly. You can immediately see in the sketches how to access the LCD indicator and be amazed at the ease of working with it! If everything works correctly for you, let’s move directly to programming.

Let's decide that our timer will work without the delay operator as written. Therefore, we enter the following code:

#include

// Variables will change:

void setup () {
lcd.begin(16, 2);

void loop ()
{

if (currentMillis - previousMillis >= interval) (

This code will already work but will not display anything. 1 will be added to the variable s every second. I.e. we already got the exact interval of 1 second! Now, following the algorithm, we need a limit of the variable between 0 and 59. Let's do it.

if(s>
{


}

Add this code to the program. According to the description, everything is clear - if the value of s is greater than 59, then we assign it 0 and add 1 minute to the variable m. At the moment we have a fully working second timer and an infinite (up to 32768 - the maximum value of the integer type) minute counter. Now you need to calculate the minutes in the same way. We write the following:

if (m>59) // if m values ​​are greater than 59
{


}

Add lines to the program. It should already look like this:

int h,m,s; // variables for hours, minutes, seconds
boolean z; // variable to display the point
// connect the indicator library
#include

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Variables will change:
int ledState = LOW; // ledState used to set the LED
unsigned long previousMillis = 0; // will store last time LED was updated
const long interval = 1000; // interval at which to blink (milliseconds)

void setup () {
lcd.begin(16, 2);

void loop ()
{

Unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) (
// save the last time you blinked the LED
previousMillis = currentMillis;
s++; // add one, equivalent to writing s=s+1;

// seconds counting section

if (s>59) // if the value of s is greater than 59
{
s=0; // assign value 0 to variable s
m++; // add 1 to the variable m responsible for minutes
}

// minute counting section

if(m>
{
m=0; // assign value 0 to variable m
h++; // add 1 to the variable h responsible for the clock
}

In principle, everything is clear. All that remains is to process the clock. Let's do it. We add after the minute counting section:

if(h>
{

}

That's it, the watch is ready! Fill in the sketch and the clock will run as it should! I would like to draw your attention to the fact that they will count in 24-hour format. Try making a 12-hour format yourself. All that remains is to display the information on the LCD indicator. There are 2 ways to write code to display information.

1. Calculate some data and immediately output it
2. Calculate all the data and display it all at once.

At this point you will decide for yourself which path you will take. If you follow the first path, then you need to write the display of information immediately in the calculation sections, if you follow the second path, you write a block after all the calculations. Let's take the second path because... it is more preferable and more logical (although, to be honest, my test sketch was written along the first path). So, to transfer data to the 1602 indicator, only 2 commands are used:

lcd.setCursor(3, 0); // sets the cursor to the 3rd character of the 0th line (counting lines and characters starts from 0)
lcd.print(0); // print (print- print, learn English) 0

There is also the lcd.clear command; meaning clear screen but we don't have to use it here.

We begin to display information. Let's start with seconds (you can start with any value, do whatever is convenient for you). Set the cursor to line 0 in position 6 and display the seconds value. Why in 6th position you ask? Let's imagine the following: the clock display format is 2 characters (hours), a separator (let's say:), 2 characters (minutes), a separator (:) and, finally, seconds. We count from the zero position: 0+2+1+2+1=6. Since the counting starts from 0, we subtract one from the data (zero is also a number), we get 6-1=5. This is how long it takes to display hours and minutes with delimiters, the next position is the second position and it is equal to 5+1=6. A little confusing but I'll write the following hh:mm:ss and calculate the coordinates first starting from 0. This is how coordinates are calculated on indicators of the 16xx family. Under these conditions, the clock will be displayed in the upper left corner, you can change the location as you wish, you can even enter a variable and, by selecting it, select the display position you need. Okay, let's write these lines:

lcd.setCursor(6, 0); // sets the cursor to the 6th character of the 0th line (line counting starts from 0)

The program will look like this:

int h,m,s; // variables for hours, minutes, seconds
boolean z; // variable to display the point
// connect the indicator library
#include

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Variables will change:
int ledState = LOW; // ledState used to set the LED
unsigned long previousMillis = 0; // will store last time LED was updated
const long interval = 1000; // interval at which to blink (milliseconds)

void setup () {
lcd.begin(16, 2);

void loop ()
{

Unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) (
// save the last time you blinked the LED
previousMillis = currentMillis;
s++; // add one, equivalent to writing s=s+1;

// seconds counting section

if (s>59) // if the value of s is greater than 59
{
s=0; // assign value 0 to variable s
m++; // add 1 to the variable m responsible for minutes
}

// minute counting section

if (m>59) // if the value of m is greater than 59
{
m=0; // assign value 0 to variable m
h++; // add 1 to the variable h responsible for the clock
}

// hour counting section

if (h>23) // if the value of h is greater than 23
{
h=0; // assign value 0 to variable h
}

// information output section

lcd.setCursor(6, 0);
lcd.print(s); // print data from variable s

Fill in the sketch and... seconds started to appear!!! Just pay attention, when counting from 0 to 59, everything is fine, but as soon as the next minute begins, tens of seconds begin to change instead of units of seconds, i.e. The time is displayed incorrectly. Let's figure this out. We have given the program a strict position 6,0 , and it displays the data exactly at this position without overwriting what is after this position. Exit 2. Apply lcd.clear or describe the display correctly, especially since with the first option it will be quite difficult to get used to the jumping digits of seconds (later minutes and hours). Let's write a correct display handler. What conditions will there be in this processing? Let's think about it. If the seconds are less than 10, then we write their value in the 7th position (6+1=7) and in the 6th position we write 0, if greater than or equal to 10, we write in the 6th position. It's quite simple. The condition will look like this:

if (s<10) //если секунд меньше 10
{

lcd.print(0); //print 0


}
else
{


}

Paste this code instead

lcd.setCursor(6, 0); // sets the cursor to the 7th character of the 0th line (line counting starts from 0)
lcd.print(s); // print data from variable s

and we are happy with the result already obtained! Everything is displayed correctly! In addition, a separator “:” appeared before the seconds! In the same way we write a handler for minutes and hours with the corresponding cursor coordinates. It might look like this for minutes:

If (m<10)
{
lcd.setCursor(3, 0);
lcd.print(0);
lcd.setCursor(4, 0);
lcd.print(m);
}
else
{
lcd.setCursor(3, 0);
lcd.print(m);
}

and so on for hours:

If (h<10)
{
lcd.setCursor(0, 0);
lcd.print(0);
lcd.setCursor(1, 0);
lcd.print(h);
}
else
{
lcd.setCursor(0, 0);
lcd.print(h);
}

Our program will take the following form:

int h,m,s; // variables for hours, minutes, seconds
boolean z; // variable to display the point
// connect the indicator library
#include

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Variables will change:
int ledState = LOW; // ledState used to set the LED
unsigned long previousMillis = 0; // will store last time LED was updated
const long interval = 1000; // interval at which to blink (milliseconds)

void setup () {
lcd.begin(16, 2);

void loop ()
{

Unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) (
// save the last time you blinked the LED
previousMillis = currentMillis;
s++; // add one, equivalent to writing s=s+1;

// seconds counting section

if (s>59) // if the value of s is greater than 59
{
s=0; // assign value 0 to variable s
m++; // add 1 to the variable m responsible for minutes
}

// minute counting section

if (m>59) // if the value of m is greater than 59
{
m=0; // assign value 0 to variable m
h++; // add 1 to the variable h responsible for the clock
}

// hour counting section

if (h>23) // if the value of h is greater than 23
{
h=0; // assign value 0 to variable h
}

// information output section

// output seconds

if (s<10) //если секунд меньше 10
{
lcd.setCursor(6, 0); // cursor at position 6, line 0
lcd.print(0); //print 0
lcd.setCursor(7, 0); //cursor at position 7 of line 0
lcd.print(s); //print the value of the variable s
}
else
{
lcd.setCursor(6, 0); //otherwise the cursor is in the 6th position of the 0th line
lcd.print(s); // print the value of the variable s
}
lcd.setCursor(5, 0); // cursor at position 5, line 0
lcd.print(':'); // print separator between seconds and minutes

// output minutes

if (m<10)
{
lcd.setCursor(3, 0);
lcd.print(0);
lcd.setCursor(4, 0);
lcd.print(m);
}
else
{
lcd.setCursor(3, 0);
lcd.print(m);
}
lcd.setCursor(2, 0); // cursor at position 2 of line 0
lcd.print(':'); // print separator between minutes and hours

// output clock

if (h<10)
{
lcd.setCursor(0, 0);
lcd.print(0);
lcd.setCursor(1, 0);
lcd.print(h);
}
else
{
lcd.setCursor(0, 0);
lcd.print(h);
}

The entire code fit into just over 3 kilobytes! Most of them were consumed by the library for the LCD indicator. I would like to note right away that this code is only the body of the program; you also need to add a function for setting the time. In addition, you can add a photoresistor and brighten the display backlight. You can add an alarm input function and work with sound. You can also display the room temperature, date, etc... In general, this indicator with the appropriate sensors can turn this watch into a unique device! The only disadvantage of this device is that if there is a power outage, you will have to set the clock again. Therefore, in the near future I will describe how to work with the RTC module. When working with it, even if the power goes out, when voltage is applied, the clock will work as if nothing had happened. For a cheaper version of the clock, you can use arduino pro mini, this is the same controller only does not have a USB connector but costs several times less and is very small in size. You can also use arduino nano, the same pro but with a USB connector. Until the next lesson. Thank you all for your attention.

PS*. By the way, the procedure for displaying values ​​can be written as a separate function and passing the necessary values ​​to it. Try this and compare the amount of memory occupied. Always aim for the smallest volume possible.