Bios
Подключение DS1307 к микроконтроллерам AVR. Русское описание DS1307 Ds1307 установка времени

Подключение DS1307 к микроконтроллерам AVR. Русское описание DS1307 Ds1307 установка времени

Тема часов на микросхеме DS1307 довольно актуальна — это простое, но в то же время интересное устройство. Кроме того, оно может реально пригодиться. Но описывать отдельно микросхему смысла нет, поэтому я решил собрать себе подобное устройство, заодно рассказать о том, какие шишки набил при этом. Сам процесс разработки и сборки буду описывать, по мере прохождения некоторых этапов готовности девайса.

Update 17.10.2015
Вначале это была серия статей, целью которых было рассказать про создание устройства с нуля до состояния готовности, но внезапно у меня появилась аллергия на все что называется «часы», поэтому я слил все в одну статью. Устройство закончено на 99.9%, (осталось закрутить винты), но сделать это ой как не просто 🙂 Как только аллергия пройдет появится окончательная фотка.

Начнем с того, что пока нам ничего не известно про ds1307 кроме того, что с ее помощью делают часы. Поэтому качаем документацию, на эту микросхему и читаем список «вкусностей», которыми она обладает. Итак, из первого абзаца в целом понятно, что она обладает низким энергопотреблением, информация передается по I2C, можно узнать дату и время, 12 и 24 часовой формат, автоматическая подстройка даты. Но самое интересное это схема (TYPICAL OPERATING CIRCUIT).

Курим даташит и пытаемся разобраться что к чему. Идем слева направо, CPU — микроконтроллер (то есть наша atmega), два резистора, написано pull up — значит подтягивающие (можно взять по 10к), кварц на 32768Гц, сама микросхема и батарейка. Выход SQW/OUT может дрыгаться с частотой 1Hz, 4kHz, 8kHz, 32kHz, пока нам это не интересно. Пожалуй, этой информации пока достаточно, хочется уже чего нибудь накодить 🙂

Создаем проект в CodeVision, в разделе I2C находим ds1307 и включаем его в проект. Хорошо бы еще выводить куда нибудь информацию, например на LCD и пара кнопок не помешает.

Все что нужно это LCD настроить на порт D и три кнопки с подтяжкой на вход. Далее нужно вывести на LCD время, для этого заглянем в мануал CodeVision и возьмем оттуда пример. Оказывается все просто — есть функция устанавливающая время:
rtc_set_time(3,0,0); //установить 03:00:00

т.е. после вызова данной функции в переменных h, m, s будут находиться часы(h), минуты(m) и секунды(s). Осталось вывести их на экран. Уж это мы умеем делать)
Итоговый код будет выглядеть так:

#include #include #include #include // Alphanumeric LCD Module functions #asm .equ __lcd_port= 0x12 ; PORTD #endasm #include char lcd_buf[ 33 ] ; void main(void ) { char hour, min, sek; PORTC= 0x07 ; DDRC= 0x00 ; // I2C Bus initialization i2c_init() ; rtc_init(0 , 0 , 0 ) ; // LCD module initialization lcd_init(16 ) ; rtc_set_time(3 , 0 , 0 ) ; while (1 ) { rtc_get_time(& hour,& min,& sek) ; lcd_clear() ; lcd_gotoxy(0 , 0 ) ; sprintf (lcd_buf, "%2d:%02d:%02d\n " , hour, min, sek) ; lcd_puts(lcd_buf) ; delay_ms(500 ) ; } ; }

#include #include #include // Alphanumeric LCD Module functions #asm .equ __lcd_port=0x12 ;PORTD #endasm #include char lcd_buf; void main(void) { char hour,min,sek; PORTC=0x07; DDRC=0x00; // I2C Bus initialization i2c_init(); // DS1307 Real Time Clock initialization rtc_init(0,0,0); // LCD module initialization lcd_init(16); rtc_set_time(3,0,0); while (1) { rtc_get_time(&hour,&min,&sek); lcd_clear(); lcd_gotoxy(0,0); sprintf(lcd_buf,"%2d:%02d:%02d\n",hour,min,sek); lcd_puts(lcd_buf); delay_ms(500); }; }

Собираем и тестируем в протеусе:

Схема и прошивка

Продолжим модернизировать нашу прошивку. Начнем со следующей задумки: у DS1307 есть выход SQW/OUT, который может генерировать несколько частот. Если настроить этот выход на 1Гц, и подать этот сигнал на вход внешнего прерывания, то получится, что раз в секунду 1307 будет дергать «за хвост» нашу atmega8. Для меги это будет сигналом к тому, что пора обновлять время. Это позволит не нагружать микроконтроллер постоянным обновлением времени, информация о текущем времени будет обновляться ровно раз в секунду.

Добавим в проект внешнее прерывание по низкому уровню (low level) на ножке Int1 и включим подтяжку. Выход DS1307 настроим на частоту 1Гц. Кстати, читать мануалы полезно, нашел интересную особенность — подтягивающие резисторы на ножках SCL, SDA должны быть 3,3k — 4,7k. Учтем это.

Получившийся код будет выглядеть так:

interrupt [ EXT_INT1] void ext_int1_isr(void ) { time_flag= 1 ; }

interrupt void ext_int1_isr(void) { time_flag=1; }

В прерывании выставляем флаг, разрешающий вывод времени, в основном цикле, если флаг выставлен, то показываем время, если не выставлен ничего не делаем.

if (time_flag== 1 ) { rtc_get_time(& hour,& min,& sek) ; lcd_gotoxy(0 , 0 ) ; sprintf (lcd_buf, "%02d:%02d:%02d\n " , hour, min, sek) ; lcd_puts(lcd_buf) ; }

if(time_flag==1) { rtc_get_time(&hour,&min,&sek); lcd_gotoxy(0,0); sprintf(lcd_buf,"%02d:%02d:%02d\n",hour,min,sek); lcd_puts(lcd_buf); }

Теперь перейдем к следующему вопросу, на сколько эффективно использовать sprintf? Чтобы не разводить пустых разговоров, приведу 2 куска кода, которые выполняют одно и тоже — выводят информацию о времени на дисплей.

Первый вариант, уже нам известный:

sprintf (lcd_buf, "%02d:%02d:%02d\n " , hour, min, sek) ; lcd_puts(lcd_buf) ;

sprintf(lcd_buf,"%02d:%02d:%02d\n",hour,min,sek); lcd_puts(lcd_buf);

Согласитесь просто в использовании и наглядно. Теперь вариант номер 2:

lcd_putchar(hour/ 10 + 0x30 ) ; lcd_putchar(hour% 10 + 0x30 ) ; lcd_putchar(":" ) ; lcd_putchar(min/ 10 + 0x30 ) ; lcd_putchar(min% 10 + 0x30 ) ; lcd_putchar(":" ) ; lcd_putchar(sek/ 10 + 0x30 ) ; lcd_putchar(sek% 10 + 0x30 ) ;

lcd_putchar(hour/10+0x30); lcd_putchar(hour%10+0x30); lcd_putchar(":"); lcd_putchar(min/10+0x30); lcd_putchar(min%10+0x30); lcd_putchar(":"); lcd_putchar(sek/10+0x30); lcd_putchar(sek%10+0x30);

Не очень наглядно, но разобраться можно. Как мы их будем сравнивать? Делается это очень просто — запускаем отладчик AVR STUDIO и смотрим количество тактов затраченных на их выполнение. Итак, «барабанная дробь», результаты… Первый кусок кода выполнялся 16 466 тактов, что равносильно 2 058,25 мкс, при рабочей частоте в 8МГц, для второго куска кода эта цифра составила 12 278 тактов или 1 534,75 мкс. Согласитесь, снизить время выполнения, а значит и разгрузить микроконтроллер на ~25% достаточно весомая причина, чтобы не использовать sprintf. Выкидываем sprintf из нашего проекта, в след за ним можно выкинуть stdio.h и lcd_buf.

Некрасиво, когда в основном цикле мешанина из кода, поэтому вывод информации можно засунуть в функцию. В основном цикле останется

while (1 ) { if (time_flag== 1 ) { show_time() ; //показать информацию о текущем времени } } ;

while (1) { if(time_flag==1) { show_time(); //показать информацию о текущем времени } };

Объявление самой функции будет выглядеть так:

void show_time() { rtc_get_time(& hour,& min,& sek) ; lcd_gotoxy(0 , 0 ) ; lcd_putchar(hour/ 10 + 0x30 ) ; lcd_putchar(hour% 10 + 0x30 ) ; lcd_putchar(":" ) ; lcd_putchar(min/ 10 + 0x30 ) ; lcd_putchar(min% 10 + 0x30 ) ; lcd_putchar(":" ) ; lcd_putchar(sek/ 10 + 0x30 ) ; lcd_putchar(sek% 10 + 0x30 ) ; time_flag= 0 ; }

void show_time() { rtc_get_time(&hour,&min,&sek); lcd_gotoxy(0,0); lcd_putchar(hour/10+0x30); lcd_putchar(hour%10+0x30); lcd_putchar(":"); lcd_putchar(min/10+0x30); lcd_putchar(min%10+0x30); lcd_putchar(":"); lcd_putchar(sek/10+0x30); lcd_putchar(sek%10+0x30); time_flag=0; }

Теперь в нашу прошивку, нужно добавить вывод даты. Установка даты, производится следующей функцией:

rtc_set_date(6,13,10,13); //6- день недели, 13 - день, 10 - месяц, 13 - год

rtc_get_date(&week_day,&day,&month,&year); //день недели, день, месяц, год

Вывод даты можно организовать, пока что в основном цикле, рядом со временем, полный исходный код получился такой:

#include // I2C Bus functions #asm .equ __i2c_port= 0x18 ; PORTB .equ __sda_bit= 0 .equ __scl_bit= 1 #endasm #include // DS1307 Real Time Clock functions #include // Alphanumeric LCD functions #include char hour= 0 , min= 0 , sek= 0 , day= 0 , month= 0 , year= 0 , week_day= 0 ; bit time_flag= 0 ; char menu= 0 ; // External Interrupt 1 service routine interrupt [ EXT_INT1] void ext_int1_isr(void ) { time_flag= 1 ; } void show_time() { rtc_get_time(& hour,& min,& sek) ; rtc_get_date(& week_day,& day,& month,& year) ; lcd_gotoxy(0 , 0 ) ; lcd_putchar(hour/ 10 + 0x30 ) ; lcd_putchar(hour% 10 + 0x30 ) ; lcd_putchar(":" ) ; lcd_putchar(min/ 10 + 0x30 ) ; lcd_putchar(min% 10 + 0x30 ) ; lcd_putchar(":" ) ; lcd_putchar(sek/ 10 + 0x30 ) ; lcd_putchar(sek% 10 + 0x30 ) ; lcd_gotoxy(0 , 1 ) ; lcd_putchar(day/ 10 + 0x30 ) ; lcd_putchar(day% 10 + 0x30 ) ; lcd_putchar("/" ) ; lcd_putchar(month/ 10 + 0x30 ) ; lcd_putchar(month% 10 + 0x30 ) ; lcd_putchar("/" ) ; lcd_putchar(year/ 10 + 0x30 ) ; lcd_putchar(year% 10 + 0x30 ) ; time_flag= 0 ; } void main(void ) { PORTC= 0x0F ; DDRC= 0x00 ; PORTD= 0x08 ; DDRD= 0x00 ; // I2C Bus initialization i2c_init() ; // DS1307 Real Time Clock initialization // Square wave output on pin SQW/OUT: On // Square wave frequency: 1Hz rtc_init(0 , 1 , 0 ) ; // External Interrupt(s) initialization // INT0: Off // INT1: On // INT1 Mode: Low level GICR|= 0x80 ; MCUCR= 0x00 ; GIFR= 0x80 ; // LCD module initialization lcd_init(16 ) ; rtc_set_time(12 , 0 , 0 ) ; rtc_set_date(6 , 13 , 10 , 13 ) ; #asm("sei") while (1 ) { if (time_flag== 1 ) { show_time() ; } } ; }

#include // I2C Bus functions #asm .equ __i2c_port=0x18 ;PORTB .equ __sda_bit=0 .equ __scl_bit=1 #endasm #include // DS1307 Real Time Clock functions #include // Alphanumeric LCD functions #include char hour=0,min=0,sek=0,day=0,month=0,year=0,week_day=0; bit time_flag=0; char menu=0; // External Interrupt 1 service routine interrupt void ext_int1_isr(void) { time_flag=1; } void show_time() { rtc_get_time(&hour,&min,&sek); rtc_get_date(&week_day,&day,&month,&year); lcd_gotoxy(0,0); lcd_putchar(hour/10+0x30); lcd_putchar(hour%10+0x30); lcd_putchar(":"); lcd_putchar(min/10+0x30); lcd_putchar(min%10+0x30); lcd_putchar(":"); lcd_putchar(sek/10+0x30); lcd_putchar(sek%10+0x30); lcd_gotoxy(0,1); lcd_putchar(day/10+0x30); lcd_putchar(day%10+0x30); lcd_putchar("/"); lcd_putchar(month/10+0x30); lcd_putchar(month%10+0x30); lcd_putchar("/"); lcd_putchar(year/10+0x30); lcd_putchar(year%10+0x30); time_flag=0; } void main(void) { PORTC=0x0F; DDRC=0x00; PORTD=0x08; DDRD=0x00; // I2C Bus initialization i2c_init(); // DS1307 Real Time Clock initialization // Square wave output on pin SQW/OUT: On // Square wave frequency: 1Hz rtc_init(0,1,0); // External Interrupt(s) initialization // INT0: Off // INT1: On // INT1 Mode: Low level GICR|=0x80; MCUCR=0x00; GIFR=0x80; // LCD module initialization lcd_init(16); rtc_set_time(12,0,0); rtc_set_date(6,13,10,13); #asm("sei") while (1) { if(time_flag==1) { show_time(); } }; }

Результат:

Схема и прошивка:

Перейдем к организации меню. Самый главный вопрос состоял в том, как оно все должно выглядеть, т.е. нужно было сформулировать техническое задание(т.з.).
Мне хотелось, чтобы это были отдельные экраны:
-главный экран;
-экран настройки времени;
-экран настройки даты;
-экран настройки будильника.

При этом обойтись четырьмя кнопками — вверх, вниз, влево, вправо. Переход между экранами должен осуществляться кнопками вверх и вниз. Настройка производится на соответствующем экране. Применяемый микроконтроллер atmega8. Вот такое примитивное т.з.

То что размер кода будет достаточно большой было понятно изначально. При этом нужно было его разбить на логически связанные части. С частями все понятно — обработка одного экрана одна часть кода. Поэтому начал с того, что основной цикл разбил на четыре части, переключения между которыми производится оператором switch. Внутрь засунул функции — пустышки. Кнопки 0(вверх) и 3(вниз) порта C позволяют изменить переменную menu. Таким образом мы скачем между менюшками. Но пока такая прошивка еще работать не могла, ибо функции еще не определены.

while (1 ) { switch (menu) { case 0 : show_time() ; break ; case 1 : set_time() ; break ; case 2 : set_date() ; break ; case 3 : set_alarm() ; break ; } } ;

while (1) { switch(menu) { case 0: show_time(); break; case 1: set_time(); break; case 2: set_date(); break; case 3: set_alarm(); break; } };

Следующий шаг определение этих функций, изначально я нарисовал статичные названия, вроде lcd_puts(«Set time»); функции получились, такими.

void set_alarm() { ////////просмотр настроек будильника lcd_gotoxy(0,0); lcd_puts("Set alarm"); } void set_time() { ////////просмотр настроек времени lcd_gotoxy(0,0); lcd_puts("Set time"); }

Теперь это уже была рабочая прошивка, в которой можно было переключаться между менюшками и смотреть статичные надписи. Настало время оживить эти надписи. С главным экраном проблем не было, вывод времени/даты аналогичен предыдущему уроку.

Встал следующий вопрос: как организовать сам процесс настройки? Поразмыслив, мне показалась интересной следующая идея: переходим кнопками вверх/вниз в интересующее нас меню, нажимаем вправо, появляется курсор, говорящий нам о том, что идет процесс настройки. Кнопками вверх/вниз мы изменяем величину, влево/вправо скачем курсором между настраиваемыми параметрами. Когда курсор находится под последним параметром, повторное нажатие кнопки вправо позволяет выйти из настройки. Курсор при этом скрывается, что говорит о том что мы вышли из настройки и можем снова переключаться между менюшками.

Но есть небольшие проблемы, например, кнопка вверх должна изменять параметры и при этом, переключать следующий экран. Т.е. логику кнопок внутри одного экрана, пришлось разделить. Из за этого код здорово разросся. Например, на экране будильника, вводим подпрограмму настройки(sub_alarm), соответственно кнопки внутри подпрограммы обрабатываются одним образом, а вне другим.

void set_alarm() //Функция обработки будильника { //режим отображения меню настроек будильника if(sub_alarm==0) { if(PINC.0==0) //кнопка вверх - смена экрана меню { menu=0; ..... } } //подменю настройки будильника if(sub_alarm==1) { if(PINC.0==0) //кнопка вверх - увеличить величину { a_hour++; .... } }

Есть еще такой момент, когда зашли в подменю настройки одна и таже кнопка (возьмем опять в качестве примера кнопку вверх), может менять часы, а может минуты. Поэтому была введена еще одна переменная subProgram.
Например:

if(PINC.0==0) //кнопка вверх { if(subProgram==1) //subProgram=1 - изменяем часы { a_hour++; ... } if(subProgram==2) //subProgram=2 - изменяем минуты { a_min++; ... } if(subProgram==3) //subProgram=3 изменяем флаг будильника { ... } }

Единственное о чем стоит упомянуть это спецсимвол, который выводится на главном экране, когда будильник включен.

Пример взят из примеров в папке CodeVision\examples\lcd char.

typedef unsigned char byte; //переопределяем тип flash byte char_table[ 8 ] = { //рисуем свой символ 0b10000000 , 0b10000100 , 0b10001110 , 0b10001110 , 0b10001110 , 0b10011111 , 0b10100100 , 0b11000000 } ; // function used to define user characters void define_char(byte flash * pc, byte char_code) { byte i, address; address= (char_code<< 3 ) | 0x40 ; for (i= 0 ; i< 8 ; i++ ) lcd_write_byte(address++,* pc++ ) ; } void main(void ) { byte i, address; lcd_init(16 ) ; define_char(char_table, 0 ) ; //Грузим символ в лсд while (1 ) { lcd_putchar(0 ) ; //выводим символ на дисплей }

typedef unsigned char byte; //переопределяем тип flash byte char_table={ //рисуем свой символ 0b10000000, 0b10000100, 0b10001110, 0b10001110, 0b10001110, 0b10011111, 0b10100100, 0b11000000}; // function used to define user characters void define_char(byte flash *pc,byte char_code) { byte i,address; address=(char_code<<3)|0x40; for (i=0; i<8; i++) lcd_write_byte(address++,*pc++); } void main(void) { byte i,address; lcd_init(16); define_char(char_table,0); //Грузим символ в лсд while(1) { lcd_putchar(0); //выводим символ на дисплей }

Рисовать можно символ 5х7, единичка — пиксел закрашен, ноль — не закрашен. Получился символ колокольчика.

Прошивка

Следующий шаг, это продумывание внешнего вида устройства. В моем представлении это будет жк экран и четыре кнопки на лицевой части, внутри будет печатная плата на которой будут все остальные элементы. Питание будет от блока питания, аналогично тому что сделан из китайской зарядки.

Начнем с печатной платы, для этого требуется программа, которая позволяет рисовать печатки. Существует множество подобных программ: P-cad, Altium, Sprint layout… Мне нравится Альтиум, только потому, что для него куча готовых библиотек с элементами, ибо тратить время на набивку собственной библиотеки элементов, на мой взгляд не дело. Общий смысл всех подобных программ одинаков — сначала рисуется электрическая схема.

В трассировщике все элементы уже знают, какой с каким должен соединяться, благодаря электрической схеме.

Остается только удобно расположить элементы и соединить их проводниками.

Здравствуйте!
Сегодня я хочу Вам поведать о такой интересной микросхеме как DS1307. Это чудные часики плюс календарь и самое замечательное что к этой микрухе есть библа в CVAVR. Да и просто она мне под руку попалась и я решил ее помучить 8) Первым делом нам понадобится схема ее подключения. Она довольно проста и была взята из даташита. Но тут есть небольшое исключение. В даташите требуют подключить резистор между ножкой питания и ножкой вывода прямоугольных импульсов. Так как я делал отдельную плату, дабы иметь возможность на ней тестировать дальнейшие проекты, приляпал еще светодиод. Очень удобно получилось. Видно например секундные импульсы.
Собственно схема.

А вот как это выглядит в сборе.

Испытания я проводил в связке ATmega32 + LCD 16x2 + DS1307. Далее есть два варианта. Первый, можно сгенерить код прям генератором CVAVR. Второй, самому все написать. Я предлагаю писать самому, но сначала давайте пройдемся по функциям DS1307.
1. rtc_init(rs, sqwe, out) Эта самая первая функция для инициализации микросхемы. Теперь все аргументы по порядку. rs нужен для того чтобы задать частоту выходных прямоугольных импульсов на ноге SQW/OUT . 0 - 1 Гц 1 - 4096 Гц 2 - 8192 Гц 3 - 32768 Гц sqwe нужен для разрешения выхода прямоугольных импульсов. 1 - можно 0 - нет. out нужен для определения логического уровня на выходной ноге если нет разрешения на вывод прямоугольных импульсов. Во загнул. Короче если не нужно дергать ногой SQW/OUT , то параметр sqwe ставим в 0 и теперь если out равен 1 , то и на ножке будет 1 , а если запишем 0 , то и на ноге тоже 0 . Пример: rtc_init(0,1,0); Это значит включить вывод прямоугольных импульсов с частотой 1 Гц. 2. rtc_set_time(hour, min, sec) Ну из названия видно что эта функция устанавливает время. Тут все просто, аргументы часы, минуты и секунды. 3. rtc_set_date(day, month, year) Та же шляпа но с датой. 4. rtc_get_time(&hour, &min, &sec) А вот тут по подробнее. Эта функция нужна для получения текущего времени. Аргументы функции являются адреса переменных куда она потом запишет значения. Это сделано из-за того что функции могут возвращать лишь один параметр (такой вот С). То есть перед вызовом функции нужно проинициализировать три беззнаковые переменные char. 5. rtc_get_date(&day, &month, &year) То же самое но с датой. Теперь все то же на примерах. rtc_set_time(15, 0, 0); Установили время 15:00:00 rtc_set_date(14, 2, 14); Установили дату 14 февраля 2014 г. Заметьте что год пишется двумя числами. Кусок даташита: Real-Time Clock (RTC) Counts Seconds, Minutes, Hours, Date of the Month, Month, Day of the week, and Year with Leap-Year Compensation Valid Up to 2100 До 2100 года, а так как у нас в функцию передается unsigned char, то значение может приниматься от 0 до 255. Я не пробовал загонять больше ста, но записанный с перепугу 2014 год отображался как 144 8) unsigned char hour, min, sec; rtc_get_time(&hour, &min, &sec); Сначала инициализируем переменные, а после вызываем функцию. После ее вызова можно смело оперировать временем которое запишется в переменные. unsigned char day, month, year; rtc_get_date(&day, &month, &year); В принципе тут тоже самое только в переменных будет лежать дата. Ну и наконец вся программа с коментами как и обещал. /***************************************************** Программа для работы с часами реального времени DS1307 Микроконтроллер: ATmega32 Частота кварца: 3,686400 MHz *****************************************************/ #include // Указываем порт и пины для шины I2C #asm .equ __i2c_port=0x1B ;PORTA .equ __sda_bit=0 .equ __scl_bit=1 #endasm #include // Подключаем библиотеку для работы с DS1307 #include // Указываем к какому порту подключен ЖКИ #asm .equ __lcd_port=0x12 ;PORTD #endasm // Подключаем библиотеку для работы с ЖКИ #include // Подключаем библиотеку для работы со строками #include void main(void) { // Инициализация массива для строки и переменные для данных unsigned char string; unsigned char c, m, s, d, me, g; PORTA=0x00; DDRA=0x00; PORTB=0x00; DDRB=0x00; PORTC=0x00; DDRC=0x00; PORTD=0x00; DDRD=0x00; // Инициализация шины I2C i2c_init(); // Инициализация DS1307 rtc_init(0,1,0); // Инициализация дисплея lcd_init(16); // Эти функции я использовал один раз для установки времени и даты. // rtc_set_time(16, 0, 0); // rtc_set_date(13, 2, 14); while (1) { // Получили время rtc_get_time(&c, &m, &s); lcd_gotoxy(0,0); // Отформатировали sprintf(string, "Время %02i:%02i:%02i ", c, m, s); // Вывели время lcd_puts(string); // Получили дату rtc_get_date(&d, &me, &g); lcd_gotoxy(0,1); // Отформатировали sprintf(string, "Дата %02i.%02i.20%2i ", d, me, g); // Вывели дату lcd_puts(string); }; } Ну вроде как и все. Для старта я думаю понятно, а там кому как. Вот как это выглядит в работе.

Роман 29.10.15 21:30

Спасибо за статью, все понятно и без воды.

Алексей 29.10.15 22:47

Стараюсь)

Женя 07.11.15 09:33

Алексей спасибо большое!

Алексей 07.11.15 10:23

Пожалуйста.

Петр 05.04.16 00:11

А в проге flowcode реально это повторить?

Алексей 05.04.16 08:52

А что это за программа?

Михаил 09.09.16 00:18

Алексей 09.09.16 12:16

Сергей 20.11.16 12:28

Спасибо за подробное объяснение примеров. Не могли бы Вы дополнить пример ручной установки времени в RTC? Иногда корректировка времени все таки нужна.

Алексей 20.11.16 15:33

Для полноценной работы с часами реального времени DS1307 и DS3231 мной написаны функции которые входят в библиотеку . Рекомендую использовать для боле упрощенной генерации проекта под Atmel Studio. Так же можно посмотреть видео о использовании данной библиотеки.

Вениамин 10.12.16 23:33

Rtc_set_date(13, 2, 14);
На такую запись компилятор может ругаться "too few arguments" так как должно передаваться 4 аргумента, первый из которых - день недели. Поэтому передавать нужно 4 числа, и забирать - тоже 4. Насколько мне известно в некоторых версиях codevision прокатывает с тремя, но я лично порядком повозился, пока выяснил почему у меня время спокойно пишется и читается, а дата - нет.

Алексей 11.12.16 00:00

Вот поэтому я забил на CVAVR с ее косяками (а они не только в часах), перешел на AtmelStudio и написал библиотеку под нее а-пя CVAVR. Теперь у меня все работает и не глючит.)))

АНОНИМ 02.03.17 00:39

Всем советую заменять Ds1307 на 3231 т.к 32я намного точней, а 1307 только для таймеров подходит.

АНТОНИМ 03.04.17 15:18

Намного точней - это на сколько именно? ИМХО точность часов определяется на 99,9999999 % точностью кварцевого резонатора.

Алексей 03.04.17 16:09

Ну не совсем. Человек наверное просто имел в виду термокомпенсацию, так как частота кварца зависит еще и от температуры.

ИгорьКазанце 31.07.19 16:54

Ситуация: Купил микруху DS1307. Спаял Вашу схему. Нужна единственная функция - выход секундных импульсов. Больше ничего не нужно. Что делать? Какой использовать программатор? [email protected]

Алексей 01.08.19 10:50

Программатор не нужен. Нужно написать программу под любой МК который передаст команду для задания частоты выходной ножки SQW/OUT. Далее пока есть напряжение на микросхеме, на выходе будет меандр в 1ГЦ.

Отзывы об этих часах в интернете самые противоречивые. Кто-то говорит что часы замечательные, а кто-то называет их убогой поделкой Далласа. И вот я, дабы развеять все недостоверные слухи, достал микруху из загашника начала экспериментировать.

Особенности:

Очень маленькое энергопотребление. Производитель обещает 10 лет работы часов от одной стандартной батарейки CR2032
56 байт памяти для хранения пользовательских данных. Думаю не особо нужная опция, но может кому-то и пригодится.
Программируемый вывод для тактирования внешних устройств. Может выдавать 1 Гц, 4.096 кГц, 8.192 кГц и 32.768 кГц.
24-х часовой и 12-ти часовой режим

Распиновка

Выводы часов расположены следующим образом:

X1, X2 — Выводы для подключения кварцевого резонатора на частоту 32.768 кГц
VBAT — Вывод для подключения 3-х вольтовой батареи резервного питания
GND — Земля
SDA — линия данных шины i2c
SCL — линия тактовых импульсов шины i2c
SQW/OUT – выходной сигнал для тактирования внешних устройств
VCC — питание 5 вольт

Подключение к контроллеру
Обвязка минимальна. Потребуется кварц 32.768 кГц, пара резисторов для работы шины i2c и батарейка на три вольта.

Правильная разводка платы
Точность хода да и вообще работоспособность часов, зависит от разводки печатной платы. Даллас в своем даташите рекомендует сократить до минимума длинну проводников от микросхемы до кварцевого резонатора и окружить эти проводники прямоугольником подключенным к земле. Кроме этого для надежности я припаял к корпусу кварца проводок идущий к земле и параллельно питанию поставил конденсатор на 0.1 мкф.

Кстати может работать и без кварца. Для этого на ногу X1 подают внешний тактовый сигнал с частотой 32.768 кГц, а X2 остаётся висеть в воздухе.

Организация памяти часов
Данная микруха наделена 64 байтами памяти. Первые восемь байт — рабочие. В них хранится время, дата, день недели. Остальные выделены под нужды пользователя. В них можно хранить например какие-нибудь настройки или еще что-нибудь. Естественно, когда резервное питание пропадает, вся информация в этой памяти разрушается. Вся работа с часами (чтение и установка времени/даты) сводится к тому, чтобы читать и записывать нужные ячейки памяти.

Все числа в памяти хранятся в двоично-десятичном формате. Это значит что в одном байте может хранится сразу две цифры. Например число 0x23 — содержит в себе цифру 2 и цифру 3. На каждую цифру выделяется по 4 бита. Зачем так сделано? Для удобства и экономии памяти. Кроме времени и даты в памяти хранятся несколько бит настроек:

Clock Halt — управляет часами. Когда бит установлен то часы стоят. Чтобы запустить ход часов необходимо записать в этот бит 0. После подключения батареи резервного питания, этот бит уставлен и часы не считают время! Об этом нужно помнить.
24/12 — этот бит выбора режима часов. Когда этот бит равен единице то используется 12-ти часовой режим. В противном случае 24-х часовой. Если используется 12-ти часовой режим то пятый бит показывает AM или PM сейчас. Если бит равен 1 то значит PM. В 24-х часовом режиме этот бит используется для хранения десятков часов совместно с битом 4.
Output — управляет состоянием ноги SQW/OUT. Бит установлен — на ноге лог 1. Сброшен — на ноге 0. Для управления таким образом, бит SQWE должен быть сброшен.
SQWE — когда бит установлен, на ноге SQW/OUT появляются прямоугольные импульсы.
RS1, RS0 — этими битами задается частота импульсов. Зависимость частоты от комбинации бит находится в таблице ниже:

Софт

Для работы с часами DS1307 была написана нехитрая библиотека содержащая следующие базовые функции:

DS_start — запускает часы. Запустить часы можно так же установив время.
DS_stop — останавливает часы
DS_set_time — Установка времени. Перед вызовом процедуры нужно поместить в tmp1 — секунды в tmp2 — минуты и в tmp3-часы. Часы в 24-х часовом формате.
DS_get_time: — считывание времени из часов. секунды будут записаны в tmp1, минуты в tmp2, часы в tmp3
DS_get_date: — считывание даты из часов. День будет записан в tmp1, месяц в tmp2, год в tmp3
DS_set_date: — установка даты. Перед вызовом процедуры нужно поместить в tmp1 — день в tmp2 — месяц и в tmp3-год (последние 2 цифры)

Процедуры установки/чтения времени и даты могут воспринимать/возвращать входные данные в двоично-десятичном формате и в десятичном. Для выбора желаемого формата нужно закомментировать или раскомментировать по три строчки в каждой процедуре (в коде есть примечания по этому поводу).

Тестовая программа позволяет управлять часами через UART (скорость 9600, контроллер работает на частоте 8 мГц). При запуске сразу выдаются время, дата и приглашение ввести команду от 1 до 3. При выборе варианта 1 происходит повторное считывание времени/даты. Вариант 2 позволяет установить время, а вариант 3 дату. Если хочется попробовать поиграть с часами в то в архив с исходником включён файл для симуляции.

Точность
Тут очень многое зависит от применяемого кварца и разводки платы. Даташит сообщает что емкость кварца должна быть 12.5 пф. Говорят, что лучше всего применять кварцы от материнских плат. Для коррекции хода можно подпаять к резонатору подстроечный конденсатором и при помощи него в небольших пределах менять частоту. Лично у меня эти часы работают вторые сутки и отстали на 3 секунды. Что-то мне подсказывает, что дело в ёмкости кварца, попробую другой отпишусь.

Вывод
Неплохие часы. Для любительского применения идеальный вариант. Хотя некоторые пишут о глюках, но я пока не столкнулся.

Эта библиотека была написана для легкого взаимодействия и использования модуля на микросхеме DS1307 с Arduino или chipKit без необходимости использования библиотеки Wire.
Данная библиотека использует по умолчанию режим Fast Mode (400 кГц) аппаратного интерфейса I2C.
Работа этой библиотека не гарантируется в режиме одновременной работы с библиотекой Wire и совместного использования контактов.

Структура:

Time;
Структура управления данными времени и даты.
Переменные :
hour, min, sec: Для определения данных времени
date, mon, year: Для определения данных даты
dow: День недели, начиная с понедельника
Пример: Time t; // Определяем структуру с именем t класса "время"

DS1307_RAM;
Буфер для использования совместно с ReadBuffer () и WriteBuffer ().
Переменные:
Cell : Байт-массив для хранения данных, с возможностью чтения или записи в ОЗУ микросхемы.
Пример: DS1307_RAM ramBuffer; // Объявляем буфер для использования

Определенные литералы:

Дни недели
Используется совместно с setDOW() и Time.dow
MONDAY: 1
TUESDAY: 2
WEDNESDAY : 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7

Длина названия
Используется совместно с getTimeStr(), getDateStr(), getDOWStr() and getMonthStr()
FORMAT_SHORT: 1 (полное название)
FORMAT_LONG: 2 (сокращенное (3 буквенное) название)

Формат даты
Используется совместно с getDateStr()
FORMAT_LITTLEENDIAN: 1 (дд.мм.гггг)
FORMAT_BIGENDIAN: 2 (гггг.мм.дд)
FORMAT_MIDDLEENDIAN: 3 (мм.дд.гггг)

Частота на выходе SQW

Используется совместно с setSQWRate()

SQW_RATE_1: 1 (1 Гц)

SQW_RATE_4K: 2 (4096 Гц)

SQW_RATE_8K: 3 (8192 Гц)

SQW_RATE_32K: 4 (32768 Гц)

Функции:

DS1307(SDA, SCL);
Инициализация библиотеки с помощью интерфейса I2C
Параметры:
SDA: Вывод подключения SDA-пина DS1307 (Вывод 5, данные)
SCL: Вывод подключения SCL-пина DS1307 (вывод 6, тактирование)
Пример: DS1307 rtc(SDA, SCL); // Инициализация библиотеки DS13071 с помощью интерфейса I2C
Примечание: DS1307 можно подключать с любым свободным выводам Arduino. Если в схеме уже используется шина I2C и Вы попытаетесь подключиться к тем же выводам, то данная библиотека работать не будет, т.к. любой TWI-совместимый протокол требует исключительного доступа к пинам.

begin();
Инициализация подключения к DS1307
Параметры: Нет
Возврат: Нет

Пример: rtc.begin(); //Инициализация подключения к DS1307

getTime();
Считать текущие данные из DS3231.
Параметры : Нет
Возврат: формат Time-structure
Пример: t = rtc.getTime(); // Считать текущую дату и время.

getTimeStr();
Считать текущее время в виде строковой переменной.
Параметры:
format: <необязательный параметр>
FORMAT_LONG "ЧЧ:ММ:СС" (По умолчанию)
FORMAT_SHORT "ЧЧ:ММ"
Возврат: Строковое значение, содержащее текущее время с секундами или без них.
Пример: Serial.print(rtc.getTimeStr()); // Отправить текущее время через последовательный порт

getDateStr(]]);
Считать текущую дату в виде строковой переменной.
Параметры:
slformat: <необязательный параметр>
FORMAT_LONG Год из 4х цифр (ГГГГ) (По умолчанию)
FORMAT_SHORT Год из 2х цифр (ГГ)
eformat: <необязательный параметр>
FORMAT_LITTLEENDIAN "ДД.ММ.ГГГГ" (По умолчанию)
FORMAT_BIGENDIAN "ГГГГ.ММ.ДД"
FORMAT_MIDDLEENDIAN "ММ.ДД.ГГГГ"
divider: <необязательный параметр>
Символ для разделения. По умолчанию "."
Возврат: Строковое значение, содержащее текущую дату в указанном формате.
Пример: Serial.print(rtc.getDateStr()); // Отправить текущую дату через последовательный порт (В формате "ДД.ММ.ГГГГ")

getDOWStr();
Считать текущий день недели в виде строковой переменной.
Параметры:
format: <необязательный параметр>
FORMAT_LONG День недели на английском языке (По умолчанию)
FORMAT_SHORT Сокращенное название дня недели на английском языке (3 символа)
Возврат: Строковое значение, содержащее текущий день день недели в полном или сокращенном формате.
Пример: Serial.print(rtc.getDOWStr(FORMAT_SHORT)); // Отправить сокращенное название текущего дня недели через последовательный порт

getMonthStr();
Считать текущий месяц в виде строковой переменной.
Параметры:
format: <необязательный параметр>
FORMAT_LONG название месяца на английском языке (По умолчанию)
FORMAT_SHORT Сокращенное название месяца на английском языке (3 символа)
Возврат: Строковое значение, содержащее текущий месяц в полном или сокращенном формате.
Пример: Serial.print(rtc.getMonthStr()); // Отправить название текущего месяца через последовательный порт

getUnixTime(time);
Преобразование значения времени и даты в формат Unix Time (UNIX-время).
Параметры:
Время: Переменная, содержащее дату и время для преобразования
Возврат : Unix Time для предоставленного значения времени
Пример: Serial.print(rtc.getUnixTime(rtc.getTime())); // Отправить текущее значение Unixtime через последовательный порт
Примечание: UNIX-время (англ. Unix time) или POSIX-время — система описания моментов во времени, принятая в UNIX и других POSIX-совместимых операционных системах. Определяется как количество секунд, прошедших с полуночи (00:00:00 UTC) 1 января 1970 года (четверг); время с этого момента называют «эрой UNIX» (англ. Unix Epoch).

setTime(hour, min, sec);
Установка времени.
Параметры:
hour: Часы (0-23)
min: Минуты (0-59)
sec: Секунды (0-59)
Пример: rtc.setTime(23, 59, 59); // Установка времени 23:59:59

setDate(date, mon, year);
Установка даты.
Параметры:
date: День (1-31)
mon: Месяц (1-12)
year: Год (2000-2099)
Пример: rtc.setDate(16, 5, 2016); // Установка даты 16 мая 2016г.
Примечание: Защиты от ввода неправильной даты нет. Т.е., возможно ввести 31 февраля, но результат будет не предсказуем

setDOW(dow);
Установка дня недели.
Параметры:
dow: <необязательный параметр> День недели (1-7)
Если параметр не задан, значение параметра будет рассчитываться на основе данных, хранящихся в настоящее время в DS3231.
Пример: rtc.setDOW(FRIDAY); // Установить день недели - Пятница
Примечание: Устанавливаются от понедельника (1) до воскресенья (7).

halt(value);
Установка или сброс флага запуска часов.
Параметры:
value: true: Установить CH флаг
false: Сбросить CH флаг
Возврат: Нет
Пример: rtc.halt(false); // Запустить часовой модуль в работу

setOutput(enable);
Установка на выводе SQW/OUT (вывод 7) микросхемы DS1307 высокого или низкого уровня. Данная команда не работает, если enableSQW() имеет значение TRUE.
Параметры:
enable: TRUE : Установить на выводе высокий уровень
FALSE: Установить на выводе низкий уровень.
Возврат: Нет
Пример: rtc.setOutput(true); // Установить на выводе SQW/OUT высокий уровень

enableSQW(enable);
Разрешение или запрет вывода прямоугольных импульсов заданной частоты на выводе SQW/OUT.
Параметры:
enable: TRUE: Разрешить прямоугольные импульсы на выводе
FALSE: Запретить прямоугольные импульсы на выводе
Возврат: Нет
Пример: rtc.enableSQW(true); // Использовать вывод SQW/OUT в качестве генератора прямоугольных импульсов

setSQWRate(rate);
Задание частоты прямоугольных импульсов на выводе SQW.
Параметры:
rate: SQW_RATE_1 - частота 1Гц
SQW_RATE_4K - частота 4.096кГц
SQW_RATE_8K - частота 8.192кГц
SQW_RATE_32K - частота 32.768кГц
Возврат: Нет
Пример: rtc.setSQWRate(SQW_RATE_1); // Задать частоту на выводе SQW равной 1Гц

writeBuffer(buffer);
Записать данные из буфера в ОЗУ микросхемы.
Параметры:
buffer: DS1307_RAM буфер
Возврат: Нет
Пример: rtc.writebuffer(ramBuffer); // Записать 56 байт из переменной ramBuffer в ОЗУ микросхемы

readBuffer();
Считать данные из ОЗУ микросхемы в буфер.
Параметры: Нет
Возврат: DS1307_RAM буфер
Пример: ramBuffer=rtc.readBuffer(); // Считать все 56 bytes из ОЗУ микросхемы в переменную ramBuffer

poke(address, value);
Записать 1 байт в ОЗУ микросхемы
Параметры:
address: Адрес для записи байта (0-55)
value: Значение для записи по адресу

(0-255)
Возврат: Нет
Пример: rtc.poke(15, 160); // Записать 160 по адресу 15

peek(address);
Считать 1 байт из ОЗУ микросхемы
Параметры:
address : Адрес для чтения байта (0-55)
Возврат: 1 байт данных, считанных из ОЗУ микросхемы
Пример: b=rtc.peek(18); // Считать 1 байт по адресу 18 и записать значение в переменную b

Во многих проектах Ардуино требуется отслеживать и фиксировать время наступления тех или иных событий. Модуль часов реального времени, оснащенный дополнительной батарей, позволяет хранить текущую дату, не завися от наличия питания на самом устройстве. В этой статье мы поговорим о наиболее часто встречающихся модулях RTC DS1307, DS1302, DS3231, которые можно использовать с платой Arduino.

Модуль часов представляет собой небольшую плату, содержащей, как правило, одну из микросхем DS1307, DS1302, DS3231.Кроме этого, на плате практически можно найти механизм установки батарейки питания. Такие платы часто применяется для учета времени, даты, дня недели и других хронометрических параметров. Модули работают от автономного питания – батареек, аккумуляторов, и продолжают проводить отсчет, даже если на Ардуино отключилось питание. Наиболее распространенными моделями часов являются DS1302, DS1307, DS3231. Они основаны на подключаемом к Arduino модуле RTC (часы реального времени).

Часы ведут отсчет в единицах, которые удобны обычному человеку – минуты, часы, дни недели и другие, в отличие от обычных счетчиков и тактовых генераторов, которые считывают «тики». В Ардуино имеется специальная функция millis(), которая также может считывать различные временные интервалы. Но основным недостатком этой функции является сбрасывание в ноль при включении таймера. С ее помощью можно считать только время, установить дату или день недели невозможно. Для решения этой проблемы и используются модули часов реального времени.

Электронная схема включает в себя микросхему, источник питания, кварцевый резонатор и резисторы. Кварцевый резонатор работает на частоте 32768 Гц, которая является удобной для обычного двоичного счетчика. В схеме DS3231 имеется встроенный кварц и термостабилизация, которые позволяют получить значения высокой точности.

Сравнение популярных модулей RTC DS1302, DS1307, DS3231

В этой таблице мы привели список наиболее популярных модулей и их основные характеристики.

Название	Частота	Точность	Поддерживаемые протоколы
DS1307	1 Гц, 4.096 кГц, 8.192 кГц, 32.768 кГц	Зависит от кварца – обычно значение достигает 2,5 секунды в сутки, добиться точности выше 1 секунды в сутки невозможно. Также точность зависит от температуры.	I2C
DS1302	32.768 кГц	5 секунд в сутки	I2C, SPI
DS3231	Два выхода – первый на 32.768 кГц, второй – программируемый от 1 Гц до 8.192 кГц	±2 ppm при температурах от 0С до 40С. ±3,5 ppm при температурах от -40С до 85С. Точность измерения температуры – ±3С	I2C

Модуль DS1307

DS1307 – это модуль, который используется для отсчета времени. Он собран на основе микросхемы DS1307ZN, питание поступает от литиевой батарейки для реализации автономной работы в течение длительного промежутка времени. Батарея на плате крепится на обратной стороне. На модуле имеется микросхема AT24C32 – это энергонезависимая память EEPROM на 32 Кбайт. Обе микросхемы связаны между собой шиной I2C. DS1307 обладает низким энергопотреблением и содержит часы и календарь по 2100 год.

Модуль обладает следующими параметрами:

Питание – 5В;
Диапазон рабочих температур от -40С до 85С;
56 байт памяти;
Литиевая батарейка LIR2032;
Реализует 12-ти и 24-х часовые режимы;
Поддержка интерфейса I2C.

Модуль оправдано использовать в случаях, когда данные считываются довольно редко, с интервалом в неделю и более. Это позволяет экономить на питании, так как при бесперебойном использовании придется больше тратить напряжения, даже при наличии батарейки. Наличие памяти позволяет регистрировать различные параметры (например, измерение температуры) и считывать полученную информацию из модуля.

Взаимодействие с другими устройствами и обмен с ними информацией производится с помощью интерфейса I2C с контактов SCL и SDA. В схеме установлены резисторы, которые позволяют обеспечивать необходимый уровень сигнала. Также на плате имеется специальное место для крепления датчика температуры DS18B20.Контакты распределены в 2 группы, шаг 2,54 мм. В первой группе контактов находятся следующие выводы:

DS – вывод для датчика DS18B20;
SCL – линия тактирования;
SDA – линия данных;
VCC – 5В;

Во второй группе контактов находятся:

SQ – 1 МГц;
BAT – вход для литиевой батареи.

Для подключения к плате Ардуино нужны сама плата (в данном случае рассматривается Arduino Uno), модуль часов реального времени RTC DS1307, провода и USB кабель.

Чтобы подключить контроллер к Ардуино, используются 4 пина – VCC, земля, SCL, SDA.. VCC с часов подключается к 5В на Ардуино, земля с часов – к земле с Ардуино, SDA – А4, SCL – А5.

Для начала работы с модулем часов нужно установить библиотеки DS1307RTC, TimeLib и Wire. Можно использовать для работы и RTCLib.

Проверка RTC модуля

При запуске первого кода программа будет считывать данные с модуля раз в секунду. Сначала можно посмотреть, как поведет себя программа, если достать из модуля батарейку и заменить на другую, пока плата Ардуино не присоединена к компьютеру. Нужно подождать несколько секунд и вытащить батарею, в итоге часы перезагрузятся. Затем нужно выбрать пример в меню Examples→RTClib→ds1307. Важно правильно поставить скорость передачи на 57600 bps.

При открытии окна серийного монитора должны появиться следующие строки:

Будет показывать время 0:0:0. Это связано с тем, что в часах пропадает питание, и отсчет времени прекратится. По этой причине нельзя вытаскивать батарею во время работы модуля.

Чтобы провести настройку времени на модуле, нужно в скетче найти строку

RTC.adjust(DateTime(__DATE__, __TIME__));

В этой строке будут находиться данные с компьютера, которые используются ля прошивки модуля часов реального времени. Для корректной работы нужно сначала проверить правильность даты и времени на компьютере, и только потом начинать прошивать модуль часов. После настройки в мониторе отобразятся следующие данные:

Настройка произведена корректно и дополнительно перенастраивать часы реального времени не придется.

Считывание времени. Как только модуль настроен, можно отправлять запросы на получение времени. Для этого используется функция now(), возвращающая объект DateTime, который содержит информацию о времени и дате. Существует ряд библиотек, которые используются для считывания времени. Например, RTC.year() и RTC.hour() – они отдельно получают информацию о годе и часе. При работе с ними может возникнуть проблема: например, запрос на вывод времени будет сделан в 1:19:59. Прежде чем показать время 1:20:00, часы выведут время 1:19:00, то есть, по сути, будет потеряна одна минута. Поэтому эти библиотеки целесообразно использовать в случаях, когда считывание происходит нечасто – раз в несколько дней. Существуют и другие функции для вызова времени, но если нужно уменьшить или избежать погрешностей, лучше использовать now() и из нее уже вытаскивать необходимые показания.

Пример проекта с i2C модулем часов и дисплеем

Проект представляет собой обычные часы, на индикатор будет выведено точное время, а двоеточие между цифрами будет мигать с интервалом раз в одну секунду. Для реализации проекта потребуются плата Arduino Uno, цифровой индикатор, часы реального времени (в данном случае вышеописанный модуль ds1307), шилд для подключения (в данном случае используется Troyka Shield), батарейка для часов и провода.

В проекте используется простой четырехразрядный индикатор на микросхеме TM1637. Устройство обладает двухпроводным интерфейсом и обеспечивает 8 уровней яркости монитора. Используется только для показа времени в формате часы:минуты. Индикатор прост в использовании и легко подключается. Его выгодно применять для проектов, когда не требуется поминутная или почасовая проверка данных. Для получения более полной информации о времени и дате используются жидкокристаллические мониторы.

Модуль часов подключается к контактам SCL/SDA, которые относятся к шине I2C. Также нужно подключить землю и питание. К Ардуино подключается так же, как описан выше: SDA – A4, SCL – A5, земля с модуля к земле с Ардуино, VCC -5V.

Индикатор подключается просто – выводы с него CLK и DIO подключаются к любым цифровым пинам на плате.

Скетч. Для написания кода используется функция setup, которая позволяет инициализировать часы и индикатор, записать время компиляции. Вывод времени на экран будет выполнен с помощью loop.

#include #include "TM1637.h" #include "DS1307.h" //нужно включить все необходимые библиотеки для работы с часами и дисплеем. char compileTime = __TIME__; //время компиляции. #define DISPLAY_CLK_PIN 10 #define DISPLAY_DIO_PIN 11 //номера с выходов Ардуино, к которым присоединяется экран; void setup() { display.set(); display.init(); //подключение и настройка экрана. clock.begin(); //включение часов. byte hour = getInt(compileTime, 0); byte minute = getInt(compileTime, 2); byte second = getInt(compileTime, 4); //получение времени. clock.fillByHMS(hour, minute, second); //подготовка для записывания в модуль времени. clock.setTime(); //происходит запись полученной информации во внутреннюю память, начало считывания времени. } void loop() { int8_t timeDisp; //отображение на каждом из четырех разрядов. clock.getTime();//запрос на получение времени. timeDisp = clock.hour / 10; timeDisp = clock.hour % 10; timeDisp = clock.minute / 10; timeDisp = clock.minute % 10; //различные операции для получения десятков, единиц часов, минут и так далее. display.display(timeDisp); //вывод времени на индикатор display.point(clock.second % 2 ? POINT_ON: POINT_OFF);//включение и выключение двоеточия через секунду. } char getInt(const char* string, int startIndex) { return int(string - "0") * 10 + int(string) - "0"; //действия для корректной записи времени в двухзначное целое число. В ином случае на экране будет отображена просто пара символов. }

После этого скетч нужно загрузить и на мониторе будет показано время.

Программу можно немного модернизировать. При отключении питания выше написанный скетч приведет к тому, что после включения на дисплее будет указано время, которое было установлено при компиляции. В функции setup каждый раз будет рассчитываться время, которое прошло с 00:00:00 до начала компиляции. Этот хэш будет сравниваться с тем, что хранятся в EEPROM, которые сохраняются при отключении питания.

Для записи и чтения времени в энергонезависимую память или из нее нужно добавить функции EEPROMWriteInt и EEPROMReadInt. Они нужны для проверки совпадения/несовпадения хэша с хэшем, записанным в EEPROM.

Можно усовершенствовать проект. Если использовать жидкокристаллический монитор, можно сделать проект, который будет отображать дату и время на экране. Подключение всех элементов показано на рисунке.

В результате в коде нужно будет указать новую библиотеку (для жидкокристаллических экранов это LiquidCrystal), и добавить в функцию loop() строки для получения даты.

Алгоритм работы следующий:

Подключение всех компонентов;
Проверка – на экране монитора должны меняться ежесекундно время и дата. Если на экране указано неправильное время, нужно добавить в скетч функцию RTC.write (tmElements_t tm). Проблемы с неправильно указанным временем связаны с тем, что модуль часов сбрасывает дату и время на 00:00:00 01/01/2000 при выключении.
Функция write позволяет получить дату и время с компьютера, после чего на экране будут указаны верные параметры.

Заключение

Модули часов используются во многих проектах. Они нужны для систем регистрации данных, при создании таймеров и управляющих устройств, которые работают по заданному расписанию, в бытовых приборах. С помощью широко распространенных и дешевых модулей вы можете создать такие проекты как будильник или регистратор данных с сенсоров, записывая информацию на SD-карту или показывая время на экране дисплея. В этой статье мы рассмотрели типичные сценарии использования и варианты подключения наиболее популярных видов модулей.