Делаем реальные часы при помощи чипа arduino ds3231 — arduino+

Arduino and DS3231 Real Time Clock Tutorial

In this Arduino Tutorial we will learn how to use the DS3231 Real Time Clock Module. You can watch the following video or read the written tutorial below.

The first question that comes here is why we actually need a separate RTC for our Arduino Project when the Arduino itself has built-in timekeeper. Well the point is that the RTC module runs on a battery and can keep track of the time even if we reprogram the microcontroller or disconnect the main power.

DS3231 Real Time Clock

The DS3231 is a low-cost, highly accurate Real Time Clock which can maintain hours, minutes and seconds, as well as, day, month and year information. Also, it has automatic compensation for leap-years and for months with fewer than 31 days.

The module can work on either 3.3 or 5 V which makes it suitable for many development platforms or microcontrollers. The battery input is 3V and a typical CR2032 3V battery can power the module and maintain the information for more than a year.

The module uses the I2C Communication Protocol which makes the connection to the Arduino Board very easy.

Here’s the circuit schematics:

So all we need is 4 wires, the VCC and the GND pins for powering the module, and the two I2C communication pins, SDA and SCL.

You can get the components needed for this Arduino Tutorial from the links below:

*Please note: These are affiliate links. I may make a commission if you buy the components through these links. I would appreciate your support in this way!

Programming

Once we connect the module we need to program the Arduino Board to work with the Real Time Clock. However, when it comes to programing a communication between Arduino and an I2C module the code isn’t that small and easy. Luckily, there are already several libraries for the DS3231 RTC which can be found on the internet.

For this tutorial I chose to use the Library made by Henning Karlsen which can be found and downloaded from his website, www.rinkydinkelectronics.com.

So once we download and install the library we can use its first demo example to initially activate the clock of the RTC module. In the setup section of the demo example code we can notice that there are three line that we need to uncomment in order to initially set the day of the week, the time and the data.

// Code from the Demo Example of the DS3231 Library void setup()
{ // Setup Serial connection Serial.begin(115200); // Uncomment the next line if you are using an Arduino Leonardo //while (!Serial) {} // Initialize the rtc object rtc.begin(); // The following lines can be uncommented to set the date and time //rtc.setDOW(WEDNESDAY); // Set Day-of-Week to SUNDAY //rtc.setTime(12, 0, 0); // Set the time to 12:00:00 (24hr format) //rtc.setDate(1, 1, 2014); // Set the date to January 1st, 2014
}

The first line is for setting the day of the week, the second line is for setting the time in hours, minutes and seconds, and the third line is for setting the date in days, months and years.

Once we upload this code we need to comment back the three lines and re-upload the code again.

// Code from the Demo Example of the DS3231 Library void loop()
{ // Send Day-of-Week Serial.print(rtc.getDOWStr()); Serial.print(» «); // Send date Serial.print(rtc.getDateStr()); Serial.print(» — «); // Send time Serial.println(rtc.getTimeStr()); // Wait one second before repeating delay (1000);
}

If we take a look at the loop section of the code we can see that now using the three custom functions we get the information from the RTC and print them in the Serial Monitor. Here’s how they appear in the Serial Monitor.

Now even if we disconnect the Arduino power and then reconnect it and run the Serial Monitor again we can notice that the time keeps going without being reset.

So now we have our Real Time Clock up and running and we can use in any Arduino Project. As a second example I connected an LCD to the Arduino and printed the time and the date on it.

Here’s the source code of this example:

/*
* Arduino DS3231 Real Time Clock Module Tutorial
*
* Crated by Dejan Nedelkovski,
* www.HowToMechatronics.com
*
* DS3231 Library made by Henning Karlsen which can be found and downloaded from his website, www.rinkydinkelectronics.com.
*
*/
#include
#include // includes the LiquidCrystal Library DS3231 rtc(SDA, SCL);
LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Creates an LC object. Parameters: (rs, enable, d4, d5, d6, d7) void setup() { rtc.begin(); // Initialize the rtc object lcd.begin(16,2); // Initializes the interface to the LCD screen, and specifies the dimensions (width and height) of the display } } void loop() { lcd.setCursor(0,0); lcd.print(«Time: «); lcd.print(rtc.getTimeStr()); lcd.setCursor(0,1); lcd.print(«Date: «); lcd.print(rtc.getDateStr()); delay(1000); }

That’s all for this Arduino Tutorial, feel free to ask any question in the comments section below.

Arduino Real Time ClockArduino TutorialDS3231DS3231 RTC

Related Posts

Источник: https://howtomechatronics.com/tutorials/arduino/arduino-ds3231-real-time-clock-tutorial/

Часы реального времени (RTC) и Arduino | РОБОТОША

Часы реального времени (Real Time Clock, RTC) — это электронная схема, специально предназначенная для учета текущего времени, даты, дня недели и прочих временных и календарных данных.

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

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

), в отличие от тактовых генераторов и счетчиков, которые создают и считают просто «тики». Можно сказать, что часы реального времени — это тактовый генератор, специально предназначенный для отсчета времени.

Зачастую, микроконтроллеры, включая и Arduino, имеют функции для хранения времени, такие как millis () и имеют аппаратные таймеры, которые могут отслеживать более длительные временные интервалы, например, минуты и дни. Так зачем же нужны отдельные схемы часов реального времени?

Основная причина кроется в том, что millis () отслеживает время, прошедшее с момента последнего включения Arduino, при включении таймер миллисекунд устанавливается в ноль. Arduino не знает «вторник» сегодня или «23 февраля», все что ему известно, так это то, что с момента последнего включения прошло, например, 14763 миллисекунды.

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

Именно это и  происходит в недорогих моделях будильников, когда при отключении питания начинает мигать «12:00». Для каких-то задач это вполне приемлемо, но в некоторых случаях важно продолжать отсчет времени, даже если питание пропадает.

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

Большинство схем часов реального времени использует кварцевый резонатор, работающий на частоте 32768 Гц. 32768 = 215 тактов в секунду, что очень удобно для простых двоичных счётчиков.

Многие производители выпускают собственные микросхемы часов реального времени. Среди них Texas Instruments, Dallas Semocinductor, STMicroelectronics, Intersil, Maxim, Philips. Достаточно популярными являются микросхемы DS1307 от Dallas Semiconductor и ее полный, но более дешевый аналог M41T56 от STMicroelectronics.

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

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

Я некоторое время назад приобрел модуль MP1095 производства «Мастер Кит», основанный на микросхеме M41T56M6, поэтому я свои эксперименты буду проводить, используя именно этот модуль. Он полностью совместим с устройствами, в основе которых лежит DS1307, что позволяет использовать популярные библиотеки часов реального времени для последнего.

Принципиальная схема модуля MP1095:

Номиналы элементов:

  • C1 — 0.1 мкФ
  • R2 — 10 кОм
  • R3, R4 — 4.7
  • DD1 — M41T56M6
  • ZQ1 — 32.768 кГц

В качестве автономного источника питания используется литиевая батарейка типа CR2032. Почта Китая запретила к пересылке литиевые элементы питания, поэтому при покупках каких-либо модулей часов реального времени в китайских интернет-магазинах вы не обнаружите их в комплекте. Но это совсем небольшая проблема. «Мастер Кит» — компания российская и батарейка в комплекте шла.

Микросхема M41T56

Микросхема M41T56 представляет собой часы реального времени, с последовательным интерфейсом I2C и низким энергопотреблением с 56 байтами энергонезависимой памяти.

Встроенный генератор с частотой 32768 Гц (или же внешний стабилизированный кварцевый) и первые 8 байт ОЗУ используются для временных/календарных функций. Конфигурирование осуществляется в двоично-десятичном формате.

Адреса и данные передаются последовательно по двухпроводной двунаправленной шине. Встроенный адресный регистр инкрементируется автоматически после каждой операции WRITE или READ для байта данных.

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

Типичное время хранения данных превышает 10 лет с 50 мА·ч, 3 В литиевым элементом. M41T56 поставляется в 8-выводном пластиковом SOIC-корпусе.

Расположение и назначение выводов

  • OSCI — вход кварца
  • OCSO — выход кварца
  • FT/OUT — тест частоты/выходной драйвер (с открытым стоком)
  • SDA — адресная линия вход/выход
  • SCL — выход данных
  • VBAT — питание от батареи
  • VCC — внешний источник питания
  • VSS — земля

Блок-схема MT41T56

Операции

Часы реального времени M41T56 работают как ведомое устройство на последовательной шине. Доступ получается реализацие условия запуска, за которым следует правильный адрес ведомого (D0h). К 64 байтам памяти, имеющимся в устройстве, можно получить последовательно доступ в следующем порядке:

  1. Регистр секунд
  2. Регистр минут
  3. Регистр век/часы
  4. Регистр дня недели
  5. Регистр даты
  6. Регистр месяца
  7. Регистр года
  8. Управляющий регистр
  9. ОЗУ

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

Когда VCC падает ниже VBAT, устройство автоматически переключается на аккумулятор в режим с пониженным энергопотреблением для экономии заряда аккумулятора.

После подключения внешнего питания, устройство переключается с батарейного питания VBAT на VCC и считывает входы при превышении VCC в вольтах над VPFD.

В микросхеме имеется программируемый генератор прямоугольных импульсов, позволяющий вырабатывать одну из четырех частот (1 гц, 4096 Гц, 8192 Гц или 32768 Гц).

Полная версия datasheet на M41T56

Datasheet M41T56 datasheet_M41T56.pdf

Datasheet RTC M41T56

Category: Documents
Date:

Источник: http://robotosha.ru/arduino/rtc-and-arduino.html

Настройка модуля часов реального времени RTC для Arduino

Все, что вам нужно сделать, так это сконфигурировать RTC-чип в соответствии с текущей датой и временем … и сегодняшний проект поможет вам это сделать!

Проект

RTCSetup состоит из двух элементов:

  • графический интерфейс пользователя (GUI), написанный на языке C# и запущенный на ПК
  • скетч, запущенный на Arduino, к которому подключен модуль RTC

Графический интерфейс пользователя и скетч соединены по последовательному интерфейсу с помощью несложного протокола. Исходный код для них доступен в моем хранилище данных Github.

Arduino и часы реального времени

Для связи с чипом DS1307 я выбрал библиотеку RTClib хранилища Adafruit. Данный чип наиболее часто используется в модулях RTC энтузиастами со всего мира. Соединение между ИС и Arduino устанавливается с помощью шины I2C:

На рисунке показано соединение, организованное с помощью “новых” выводов I2C платы Arduino Uno; естественно вы можете использовать выводы A4 и A5.

Скетч Arduino получает команды от ПК, выполняет их и посылает назад ответный сигнал.

Протокол

Как я указал ранее, для связи между графическим интерфейсом пользователя и Arduino используется несложный протокол, созданный с помощью только 4-х команд:

Команда: ##

Первая команда, отправленная после установления соединения, используется ПК для подтверждения “совместимости” модуля, подключенного к последовательному порту. Arduino должен ответить командой «!!«

Команда: ?V

Данная команда используется для получения версии скетча. Arduino отвечает строковым параметром, определенным как константа в начале скетча:

Читайте также:  Аналоги микроконтроллеров: популярные модели, плюсы и минусы

#define VERSION   «1.0»

Команда: ?T

Данная команда, используемая для получения фактической даты и времени, считывается из модуля RTC. Плата Arduino отвечает строковым параметром в формате: dd/MM/yyyy hh:mm:ss.

Команда: !TddMMyyyyhhmmss

Данная команда используется для установки времени RTC. Arduino отвечает командой «OK».

Графический интерфейс пользователя (GUI)

Графический интерфейс пользователя, разработанный на C#, общается с Arduino по вышеуказанному протоколу и выполняет три функции:

  • устанавливает текущую дату и время
  • устанавливает требуемую дату и время, которые определяет пользователь
  • получает и отображает фактическую дату и время модуля RTC.

Сначала вам необходимо выбрать последовательный порт Arduino для установки соединения и нажать кнопку CONNECT. Если соединение установлено (команды ## и ?V), тогда в строке состояния будет отображаться версия скетча.

В первом окне будет показано фактическое время ПК. После нажатия правой кнопки мыши (на красной стрелке) вы сможете сконфигурировать модуль RTC с данным временем :

С помощью кнопки с зеленой стрелкой вы сможете получить фактическое время, хранимое в модуле RTC:

И, наконец, с помощью выпадающего списка даты в центре, вы сможете выбрать требуемое значение даты и времени, и затем отправить эти значения в модуль RTC:

Технические данные

Я использовал метод, описанный в данном учебном руководстве, для внедрения пользовательского шрифта в приложение.

Я измерил время (около 150 мс), которое необходимо скетчу для установки времени, после того как команда отправлена графическим интерфейсом пользователя: это причина почему в коде, который вы видите, команда !T отправляется, когда действительное число миллисекунд составляет 850 и пройденное время – это фактическое время + 1 секунда.

while (DateTime.Now.Millisecond != 850)
Thread.Sleep(1);
string command = «!T» + time.AddSeconds(1).ToString(«ddMMyyyyHHmmss»);
serialPort.WriteLine(command);

Оригинал статьи

Прикрепленные файлы:

  • RTCSetup-master.zip (164 Кб)

Источник: http://cxem.net/arduino/arduino108.php

Подключаем и разбираемся с ошибками часов DS1302 для arduino

Приветствую вас пользователи nookery.ru! Я уже не один год время от времени создаю проекты на arduino, для себя и друзей. У меня как и у многих из вас, возникают различные вопросы и проблемы, и это нормально ведь главное учиться и не останавливаться на достигнутом.

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

Пробежавшись по не скольким сайтам нашел схему, в основном она была одна и та же на всех сайта.

В моем проекте я подключил на цифровые выводы arduino 8 9 10, вы же можете их подключить как угодно, у меня они просто единственные остались свободные.

Установил множество различных библиотек для работы с часами, но рабочими в моем случаи было только две, остальные были либо принципиально с другим вариантом подключения, либо модифицированные, что меня абсолютно не устраивало.

Все хорошо, что хорошо кончается, кода я загрузил скетч:

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950 #include<\p>DS1302 rtc(8, 9, 10);  //инициализация платы DS1302Time t; объявляем ссылку на класс timevoid setup(){   // подключаемся к порту   Serial.begin(9600);  //инициализируем пины питания  //Установим время, и отключить защиту от записи  rtc.halt(false);  rtc.writeProtect(false);  // Если у вас в DS1302 уже сохранено установленное время, то нужно за комментировать  rtc.setDOW(FRIDAY);          // Устанавливаем день недели FRIDAY  rtc.setTime(20, 30, 10);     // Устанавливаем время 20:30:10 (24часа формат времени)  rtc.setDate(11, 06, 2017);   // Устанавливаем число месяц и год}void loop(){   t = rtc.getTime();  // Выводим день недели  Serial.print(rtc.getDOWStr());  Serial.print(» «);  // Выводим дату  Serial.print(rtc.getDateStr());  Serial.print(» — «);  // Выводим время  Serial.println(rtc.getTimeStr());  if(t.sec==30)  {    Serial.println(«Прошло 30 секунд»);  }  // Ставим задержку в 1 секунду  delay (1000);}

К моему разочарованию я увидел не то что хотел, а именно каждую секунду выводилось время как и положено дата и время, но в моем случаи выводилось реальное время и еще какое то левое,  2000-00-00 00:00:00 покапавший в библиотеке оказалось что это время вшито внутри нее. Но это никак не помогло мне, так как реальное и фейковое время поочередно выводились у меня на дисплей каждую секунду. Причем в lcd дисплее выводились не время с часов DS1302, а какие то иероглифы, по поочередно.  На многих сайтах упоминалось о том что час сломаны, плохая пропайка итд. Но я не опускал руки и все же нашел причину. Оказалось что все дело в не полной схеме, а точнее не хватала резистора 10 кОм на землю -5v. Которые снижали шум внутри цепи, и предотвращали вывод не верной информации с часов. Я накидал полную схему:

С этой схемой все стабилизировалось и часы DS1302 стали работать как надо. Ниже я выложил две библиотеки которые работали у меня, но написаны одна на C# другая на C++ так как же в них разные команды вывода информации, но в обоих есть скетч примеры в архиве с комментариями.

Скачать библиотеку DS1302

Скачать библиотеку DS1302RTC

Источник: http://www.nookery.ru/ds1302-in-arduino/

Собираем часы на Arduino. Часть 2 | GOLOS.io Блоги

Доброго времени суток уважаемые Голосяне заглянувшие в мой блог!

1 часть

Как и обещал, сегодня расскажу как привязать к ардуино часы реального времени, а также покажу кусок скетча, отвечающий за вывод мигающей точки 🙂 @samodelkin просит выложить скетч целиком — я не против, просто честно говоря не знаю куда.

Итак, приступим. В качестве часов реального времени (далее RTC) я использую китайскую плату ZS-042.

Она собрана на базе м/с DS3231. Раньше я пользовался платами на базе DS1307, но они ооочень неточные 🙂 Мне надоело мучатся с коррекцией и я заказал несколько плат с DS3231. Приятной неожиданностью оказалось то, что не нужно было даже корректировать скетч под них.

Библиотека под DS1307 великолепно с ними работает. Вполне возможно, что если вы будете использовать ее внутренние спец регистры, то это не прокатит. Но просто для вывода времени — все просто отлично.

У меня Arduino Nano, поэтому подключаем RTC последующей схеме:

SCL — A5

SDA — A4

VCC — +5V

GND — GND

RTC подключены. Импортируем в проект библиотеку для работы с ними. Их несколько штук, но я пользуюсь RTClib by Neiron. Для ее работы, а также для работы любых устройств на шине I2C также нужна библиотека Wire. Для первоначальной установки времени добавляем строку

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

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

Для вывода времени нам нужно выделить десятки часов и минут, а также их единицы. Ведь сами RTC выдают информацию в виде двузначного числа. За это отвечает этот кусочек кода:

int minutes_low = now.minute()%10;
int minutes_hi = now.minute()/10;
int hour_low = now.hour()%10;
int hour_hi = now.hour()/10;

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

Так как индикация у меня динамическая, то при зажигании точки притухала вся цифра, притом что точка горела ярко. Происходит это потому что в точке используется 1 led кристалл, а в каждом из сегментов по 2. А как известно ток идет по пути наименьшего сопротивления.

Проблема решилась включением резистора 300 Ом в цепь управления точкой. Теперь все горит и мигает равномерно. За частоту мигания отвечает этот кусочек

if ((millis() % 1000) < 500) {     Show(hour_low, 2, POINT); Clean();   }   else {     Show (hour_low, 2); Clean();   }

Функция Show как-раз и отвечает за формирование динамической индикации и вывод информации. Она достаточно объемная и приводить в тексте ее не буду. Кому будет интересно — заглянет в скетч.

Ну вот в общем и все. Кнопки я делать не буду, у меня подобные часы идут уже около года и в коррекции не нуждаются. Точность м/с DS3231 по паспорту 0.4 секунды в сутки (если не ошибаюсь).  Осталось все запаковать в корпус 🙂 С этим пока проблемка, но надеюсь я ее решу. Результат обязательно покажу вам.

ссылка на скетч

нашел ошибку с установкой времени, исправил и перезалил скетч, прошу прощения 🙂

Всем спасибо за внимание и не забывайте подписываться на мой блог!

Источник: https://golos.io/ru—tvorchestvo/%40kovatelj/sobiraem-chasy-na-arduino-chast-2

Часы реального времени — модуль для Arduino

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

К таким устройствам можно отнести не только всем известные «часы на микроконтроллере», которые существуют в бесчисленном множестве вариантов, но и различные схемы автоматизации от простой системы автоматического цветополива, до полноценного умного дома.

Разумеется, в продаже имеется достаточное количество различных специализированных микросхем реального времени [1]. Данный модуль был приобретен на Aliexpress.

Модуль поставляется в запаянном антистатическом пакете, габариты 45 х 23 х 15 мм, масса 8,8 г вместе с элементом питания CR2032.

На печатной плате устройства имеется три крепежных отверстия диаметром 2 мм. Для автономной работы часов на плате имеется колодка для установки элемента питания типоразмера CR2032. На плате модуля имеется светодиод для индикации внешнего питания.

Всего модуль имеет шесть основных выводов. VCC и GND питание +5 В (допустимо +3,3 В) и общий провод соответственно. SCL и SDA – контакты интерфейса I2C. Этот последовательный интерфейс позволяет организовать обмен информацией между 128 устройствами по двухпроводной линии [2-4].

Для платы Arduino UNO следует подключать SCL к А5, а SDA к А4.
SQW – программированный выход который можно использовать для генерации прерываний или генерации меандра с частотой 1 Гц, 1024 Гц, 4096 Гц или 8192 Гц.

32K – меандр с фиксированной частотой импульсов 32768 Гц [5-6]

Ток, потребляемый модулем от платы Arduino UNO, составляет 5,3 мА при напряжении 5В и 2 мА при 3.3 В.

Для работы с данным модулем можно использовать стандартные библиотеки «DS1307RTC» и «TimeLib» [7]. При первом включении необходимо установить текущее время и дату. Это можно сделать, например, с помощью программы time_set [8-9]. Визуализировать информацию о дате и времени, можно с помощью, к примеру, TimeRTCSet — стандартного примера из библиотеки «TimeLib».

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

Полезные ссылки

  1. https://arduinomaster.ru/datchiki-arduino/arduino-chasy-rtc-ds1307-ds1302-ds3231/
  2. Д. Изучаем Arduino: инструменты и методы технического волшебства: Пер. с англ. — СПб.: БХВ-Петербург, 2015. — 336 с.
  3. http://robocraft.ru/blog/communication/780.

    html

  4. http://cxem.net/mc/mc316.php
  5. http://radiolaba.ru/microcotrollers/ds3231-podklyuchenie-chasov-realnogo-vremeni.html
  6. http://www.avrki.ru/articles/content/ds3231/
  7. http://blog.rchip.

    ru/podklyuchenie-chasov-realnogo-vremeni-rtc-ds3231-k-arduino/

  8. https://voltiq.ru/connecting-ds3231-to-arduino/
  9. http://radiolis.pp.ua/arduino/24-chasy-realnogo-vremeni-ds3231sn-zs-042-podkljuchenie-k-arduino
  10. http://blog.rchip.

    ru/oled-chasy-termometr-na-arduino-i-ds3231/

Все файлы в архиве. Обзор подготовлен для 2Схемы.ру — Denev

35,00Загрузка…

НАЖМИТЕ ТУТ И ОТКРОЙТЕ КОММЕНТАРИИ

Источник: https://2shemi.ru/chasy-realnogo-vremeni-modul-dlya-arduino/

Библиотека DS3231

описание библиотеки для использования в Arduino модуля реального времени DS3231 на русском языке

Скачать:   на официальном сайте       зеркало1   зеркало2

Time;

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

Дни недели

Используется совместно с 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_1K:  2  (1024 Гц)

SQW_RATE_4K:  3  (4096 Гц)

SQW_RATE_8K:  4  (8192 Гц)

Логический уровень на выходе INT/SQW

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

OUTPUT_SQW:   1

OUTPUT_INT:      2

DS3231(SDA, SCL);

Инициализация библиотеки с помощью интерфейса I2C

Параметры:

SDA: Вывод подключения SDA-пина DS3231

SCL: Вывод подключения SCL-пина DS3231

Пример: DS3231 rtc(SDA, SCL); // Инициализация библиотеки DS3231 с помощью  интерфейса I2C

getTime();

Считать текущие данные из DS3231.

Параметры:Нет

Возврат: формат Time-structure

Пример:t = rtc.getTime(); // Считать текущую дату и время.

getTimeStr([format]);

Считать текущее время в виде строковой переменной.

Параметры:

format:

     FORMAT_LONG«ЧЧ:ММ:СС» (По умолчанию)

     FORMAT_SHORT «ЧЧ:ММ»

Возврат: Строковое значение, содержащее текущее время с секундами или без них.

Пример:Serial.print(rtc.getTimeStr()); // Отправить текущее время через последовательный порт

getDateStr([slformat[, eformat[, divider]]]);

Считать текущую дату в виде строковой переменной.

Параметры: 

slformat:

     FORMAT_LONGГод из 4х цифр (ГГГГ) (По умолчанию)

     FORMAT_SHORT Год из 2х цифр (ГГ)

eformat:

     FORMAT_LITTLEENDIAN «ДД.ММ.ГГГГ» (По умолчанию)

     FORMAT_BIGENDIAN«ГГГГ.ММ.ДД»

     FORMAT_MIDDLEENDIAN«ММ.ДД.ГГГГ»

divider:

Символ для разделения. По умолчанию '.'

Возврат: Строковое значение, содержащее текущую дату в указанном формате.

Пример:Serial.print(rtc.getDateStr()); // Отправить текущую дату через последовательный порт (В формате «ДД.ММ.ГГГГ»)

getDOWStr([format]);

Считать текущий день недели в виде строковой переменной.

Параметры:

format: 

     FORMAT_LONGДень недели на английском языке (По умолчанию)

     FORMAT_SHORTСокращенное название дня недели на английском языке (3 символа)

Возврат:Строковое значение, содержащее текущий день день недели в полном или сокращенном формате.

Пример:Serial.print(rtc.getDOWStr(FORMAT_SHORT)); // Отправить сокращенное название текущего дня недели через последовательный порт

getMonthStr([format]);

Считать текущий месяц в виде строковой переменной.

Параметры: 

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).


getTemp();

Получить текущую температуру от внутреннего термометра DS3231.

Параметры: Нет

Возврат: Значение текущей температуры  (с плавающей точкой) микросхемы DS3231 в ° Цельсия

Пример:Serial.print(rtc.getTemp()); // Отправить значение температуры через последовательный порт

Примечание: Внутренняя температура измеряется и обновляются каждые 64 секунд.

https://www.youtube.com/watch?v=t9AcsxQv-5k

Температура измеряется с точностью 0,25° C.

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).

Источник: http://mynobook.blogspot.com/2016/05/ds3231.html

Подключение часов реального времени DS1302 к Arduino и дисплея 1602 i2C — часы на ардуино !

  • Отличительные особенности:
  • Подсчет реального времени в секундах, минутах, часах, датах месяца, месяцах, днях недели и годах с учетом высокосности текущего года вплоть до 2100 г.
  • Дополнительное ОЗУ 31 x 8 для хранения данных
  • Последовательный ввод – вывод информации для сокращения выводов микросхемы
  • Выполнение всех функций при напряжении питания 2.0-5.5 В    — выполнение всех функций при напряжении 2.0-5.5 В на дополнительном выводе питания
  • Потребление не более 300 нA при 2.5 В питания
  • Чтение и запись информации по одному байту или потоком
  • Исполнение в 8-ми выводном корпусе DIP, а также по заказу в 8-ми выводном SOIC корпусе для поверхностного монтажа
  • Простой 3-проводной интерфейс
  • Совместимость с TTL-микросхемами (Vcc= 5V)
  • Возможность поставки в промышленном диапазоне температур: от -40°C до+85°C
  • Совместимость с DS1202
  • Отличия от DS1202:    возможность подключения встроенной цепи подзарядки к выводу Vcc1    два вывода питания для подключения основного и резервного источника питания    увеличено ОЗУ на 7 байт

Описание выводов:

X1, X2 подключение кварцевого резонатора 32.768 кГц
GND общий
RST сброс
I/O ввод — вывод данных
SCLK синхронизация последовательной связи
VCC1, VCC2 выводы питания

Структурная схема DS1302:

Расположение выводов DS1302:

Общее описание:

Микросхема DS1302 содержит часы реального времени с календарем и 31 байт статического ОЗУ. Она общается с микропроцессором через простой последовательный интерфейс. Информация о реальном времени и календаре представляется в секундах минутах, часах, дне, дате, месяце и годе.

Если текущий месяц содержит менее 31 дня, то микросхема автоматически определит количество дней в месяце с учетом высокосности текущего года. Часы работают или в 24-часовом или 12-часовом формате с индикатором AM/PM (до полудня/ после полудня).

Подключение DS1302 к микропроцессу упрощено за счет синхронной последовательной связи. Для этого требуется только 3 провода: (1) RST (сброс), (2) I/O (линия данных) и (3) SCLK (синхронизация последовательной связи). Данные могут передаваться по одному байту или последовательностью байтов до 31.

DS1302 разработан, чтобы потреблять малую мощность и сохранять данные и информацию часов при потреблении менее 1 мкВт. DS1302 — преемник DS1202.

В дополнение к основным функциям хранения времени DS1202, DS1302 имеет два вывода питания для подключения основного и резервного источника питания, возможность подключения программируемой цепи заряда к выводу VCC1 и семь дополнительных байтов ОЗУ.

Подключение:

Подключение DS1307 к Arduino:

RTC DS1307Arduino UNO
GND GND
VCC +5V
SDA A4
SCL A5

Подключение DS1302 к Arduino:

RTC DS1302Arduino UNO
GND GND
VCC +5V
RST 6 (Можно изменить на другие в скетче)
CLK 7 (Можно изменить на другие в скетче)
DAT 8(Можно изменить на другие в скетче)

Подключение DS3231 к Arduino:

RTC DS3231Arduino UNO
GND GND
VCC +5V
SDA A4
SCL A5

Код программы для модуля 1302 и дисплей 1602 I2C

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

Для DS1302

time.begin(RTC_DS1302,10,13,12);

Так же не забываем о экономии при покупке товаров на Алиєкспресс с помощью кэшбэка 

Преимущества библиотеки:

— библиотека имеет внутренние функции аппаратной обработки протоколов передачи данных I2C и SPI, а следовательно не требует подключения дополнительных библиотек, но и не конфликтует с ними, если таковые всё же подключены.

— библиотека имеет внутренние функции программой обработки протокола передачи данных 3-Wire

— для инициализации модуля необходимо вызвать функцию begin с названием модуля.

— подключение модулей осуществляется к аппаратным выводам arduino используемой шины (за исключением 3-Wire)

— простота установки и чтения времени функциями settime и gettime

функция settime может устанавливать дату и время, как полностью, так и частично (например только минуты, или только день, и т.д.)

функция gettime работает как функция date в php, возвращая строку со временем, но если её вызвать без параметра, то функция ничего не вернёт, а время можно прочитать из переменных в виде чисел.

— библиотека расширяемая, то есть для того, чтоб она работала с новым модулем, нужно указать параметры этого модуля в уже существующих массивах файла RTC.h (тип шины, частота шины в кГц, режимы работы, адреса регистров и т.д.), как всё это сделать, описано в файле extension.txt

Таким образом добавив новый модуль в библиотеку, мы лишь увеличим область занимаемой динамической памяти на ~ 36 байт, при этом не затронув область памяти программ.

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

— при работе с модулем DS1302 не нужны никакие резисторы на выводе GND (которые нужны для его работы с другими библиотеками этого модуля), это достигнуто тем, что для шины 3-Wire указана конкретная частота 10кГц, не зависимо от частоты CPU arduino.

— в библиотеке реализована еще одна не обязательная функция period, принимающая в качестве единственного аргумента — количество минут (от 1 до 255)

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

Функцию period достаточно вызвать один раз.

Подробное описание:

}// ОПИСАНИЯ ПАРАМЕТРОВ ФУНКЦИЙ: // // Подключение библиотеки: // #include // iarduino_RTC time(название модуля [, вывод SS/RST [, вывод CLK [, вывод DAT]]]); // если модуль работает на шине I2C или SPI, то достаточно указать 1 параметр, например: iarduino_RTC time(RTC_DS3231); // если модуль работает на шине SPI, а аппаратный вывод SS занят, то номер назначенного вывода SS для модуля указывается вторым параметром, например: iarduino_RTC time(RTC_DS1305,22); // если модуль работает на трехпроводной шине, то указываются номера всех выводов, например: iarduino_RTC time(RTC_DS1302, 1, 2, 3); // RST, CLK, DAT // // Для работы с модулями, в библиотеке реализованы 5 функции: // инициировать модуль begin(); // указать время settime(секунды [, минуты [, часы [, день [, месяц [, год [, день недели]]]]]]); // получить время gettime(«строка с параметрами»); // мигать времем blinktime(0-не_мигать / 1-мигают_сек / 2-мигают_мин / 3-мигают_час / 4-мигают_дни / 5-мигают_мес / 6-мигает_год / 7-мигают_дни_недели / 8-мигает_полдень) // разгрузить шину period (минуты); // // Функция begin(): // функция инициирует модуль: проверяет регистры модуля, запускает генератор модуля и т.д. // // Функция settime(секунды [, минуты [, часы [, день [, месяц [, год [, день недели]]]]]]): // записывает время в модуль // год указывается без учёта века, в формате 0-99 // часы указываются в 24-часовом формате, от 0 до 23 // день недели указывается в виде числа от 0-воскресенье до 6-суббота // если предыдущий параметр надо оставить без изменений, то можно указать отрицательное или заведомо большее значение // пример: settime(-1, 10); установит 10 минут, а секунды, часы и дату, оставит без изменений // пример: settime(0, 5, 13); установит 13 часов, 5 минут, 0 секунд, а дату оставит без изменений // пример: settime(-1, -1, -1, 1, 10, 15); установит дату 01.10.2015 , а время и день недели оставит без изменений // // Функция gettime(«строка с параметрами»): // функция получает и выводит строку заменяя описанные ниже символы на текущее время // пример: gettime(«d-m-Y, H:i:s, D»); ответит строкой «01-10-2015, 14:00:05, Thu» // пример: gettime(«s»); ответит строкой «05» // указанные символы идентичны символам для функции date() в PHP // s секунды от 00 до 59 (два знака) // i минуты от 00 до 59 (два знака) // h часы в 12-часовом формате от 01 до 12 (два знака) // H часы в 24-часовом формате от 00 до 23 (два знака) // d день месяца от 01 до 31 (два знака) // w день недели от 0 до 6 (один знак: 0-воскресенье, 6-суббота) // D день недели наименование от Mon до Sun (три знака: Mon Tue Wed Thu Fri Sat Sun) // m месяц от 01 до 12 (два знака) // M месяц наименование от Jan до Dec (три знака: Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec) // Y год от 2000 до 2099 (четыре знака) // y год от 00 до 99 (два знака) // a полдень am или pm (два знака, в нижнем регистре) // A полдень AM или PM (два знака, в верхнем регистре) // строка не должна превышать 50 символов // // если требуется получить время в виде цифр, то можно вызвать функцию gettime() без параметра, после чего получить время из переменных // seconds секунды 0-59 // minutes минуты 0-59 // hours часы 1-12 // Hours часы 0-23

Источник: http://www.electronica52.in.ua/proekty-arduino/podkluchenie-chasov-realnogo-vremeni-ds1302—k-arduino-i-displeya-1602-i2c—chasy-na-arduino—

Синхронизируем время на модуле DS3231 с компьютером

Доброго дня любителям самоделок и просто точных и качественных вещей вроде модуля часов реального времени DS3231. Пора поделиться с вами опытом синхронизации времени между модулем часов и компьютером – чуть ли не единственным способом выставить время более или менее точно. Заходите, почитайте (ну, или видео работы девайса посмотрите).

Начну с вопроса, ответ на который очевиден: что самое важное в любых часах? Разумеется, это точность хода. Какими бы многофункциональными и эстетичными не были любые часы, они – барахло, если идут неточно.

Поэтому, если говорить о точности, ни для кого не секрет, что на данный момент модуль DS3231 – один из самых конкурентоспособных модулей на рынке: он относительно дёшев, достаточно точен, в отличие от, например, «доисторического» DS3107, и относительно невелик. Поэтому применение этого модуля в самоделках – абсолютно логичный и предсказуемый шаг.

Осталась мелочь – научиться выставлять на нём время достаточно точно и с минимальными трудозатратами. Этим я и хочу поделиться. Давайте прикинем: модуль часов имеет заявленную точность до 2 ppm в диапазоне температур от 0 до 40 градусов Цельсия (а в большинстве жилищ температура именно такая).

Что такое «ppm»? PPM – аббревиатура от «Parts Per Million» – «частей на миллион». Возьмём за единицу измерения секунду и посчитаем: 60сек * 60мин *24 часа * 365 дней = 31 536 000 секунд в году. На каждый из этих миллионов 2 секунды может уходить в ту или иную сторону. 31,5 миллион делим на миллион и умножаем на 2: получаем 63 секунды в год (максимум).

Приемлемый вариант? Весьма. Но 1 раз в полгода я бы синхронизировал время, чтобы оно укладывалось в 1 минуту. Традиционно, начиная с модуля DS3107, время устанавливалось при помощи скетча для Arduino из числа примеров использования библиотеки. Алгоритм такой: открываем скетч, жмём «компилировать и закачать», и при первом запуске контроллера время устанавливается.

Остался вопрос: какое время? Откуда Arduino может узнать, какое именно время устанавливать? А очень просто – время компиляции скетча.

Однако с таким подходом я вижу несколько недостатков:

  • время компиляции зависит от «мощи» компьютера;
  • время закачивания зависит от скорости передачи скомпилированного скетча в плату Arduino;
  • закачанный скетч – «одноразовый» (устаревает сразу же после закачивания в Arduino).

Как можно «извернуться», чтобы обойти эти ограничения? Ну, например, зная (экспериментально установив) время компилирования, можно «загнать» часы на компьютере на это время вперёд. Потом запустить компиляцию, прошить плату, и время установится. Плюс метода – относительная простота. Минусы – относительно неудобно, относительно неточно, одноразовый способ.

Что ещё можно придумать? Можно, например, выставлять требуемое время в скетче вручную, предусмотреть кнопку, нажатие на которую в нужный момент выставит «руками» указанное время, например, через 2 минуты от текущего момента: пока «зальётся» скетч, пока подготовимся отследить вручную тот самый нужный момент нажатия кнопки, как раз та пара минут и пройдёт. А дальше, глядя на часы в компьютере, дожидаться «того самого» момента, чтобы нажать кнопку. Плюсы – сложнее предыдущего способа, но всё ещё относительно просто, однако точнее, чем первый способ. Минусы – этот способ ещё неудобнее, дольше, всё равно скетч «одноразовый».

Задав себе эти два риторических вопроса, я полез в Интернет искать, кто уже написал синхронизацию времени модуля часов с компьютером. И, как известно, кто ищет – тот всегда находит. Нашёлся вариант с Instructables.

В теории всё просто: обычный «батник» парсит текущее полное время, полученное «первым» способом (потому что кроме самого времени нужна ещё и дата), увеличивает время на 2 секунды, и «гоняет» пустой цикл до момента, когда настанет это новое, «плюс_две_секундное», время, чтобы «вышвырнуть» данные в COM порт.

Причём «новое плюс_две_секундное» время отслеживается другим способом (через %time%, если кому интересно). Но о «косяках» такого решения позже. Данные, «вышвырнутые» в COM порт, Arduino парсит и после этого устанавливает время в модуле. Вроде всё просто, логично и удобно. Но есть очень нехорошее слово «НО».

Всё это писал вроде бы немец, и региональные стандарты в Windows у него отличаются от «наших», а в частности, дробная часть отделяется точкой, а не запятой. При запуске с отечественными региональными стандартами «батник» не работает, потому что в нём время выхода из пустого цикла описывается условием сравнения с XX:XX:XX.xxx.

Ну так надо вместо точки поставить запятую – и всё, «я всё починил». А вот и не всё (можете проверить, кто ещё помнит, что за такое зло – программировать в «батниках»). Нужно исправлять «батник» более серьёзно. И я его исправил, используя «маты-перематы» и «мануалку» для DOS. «Батник» исправил, но скетч всё равно не работал – время не устанавливалось.

То есть данные в порт слались, Arduino их видел, но «что-то пошло не так». Давайте взглянем, что шлёт «батник» в Arduino и в каком формате (справочно).

case 83: //S = second case 68: //D = Minute (Daghigheh in Persian) case 72: //H = Hour case 84: //T = Day Of Month (Tag in German) case 77: /// M = Month case 74: /// J = Year (Jahr in German)Данные шлются в формате S**~D**~H**~T*~M**~J****~, где ~ — 2 байта перевода каретки. Итого, 31 байт. Вроде немного, пришлются данные быстро.

Однако есть и неудобство – как видим, не шлётся день недели. Только день месяца. Для реализации часов с будильниками, зависящими от дней недели, будет «косяк». День недели придётся выставлять «ручками» в скетче, что опять намекает на некоторую «одноразовость» скетча, его неполноценность.

Складывая факторы – неполноценность скетча «с завода», его отказ нормально работать, необходимость исправления «батника» для «наших» широт – я решил разрабатывать всё свое. А раз так, то я могу устранять недостатки и оптимизировать формат данных. Для того, чтобы всё заработало, нужны 2 составляющие: программа для Windows и аппаратно-программная связка Arduino.

Сначала общие данные по протоколу обмена. Коль скоро я стал волен выбирать формат данных для пересылки, я решил, что пересылка 31 байта информации не рациональна, и сократил передаваемые данные до 4 байт. И что, хватило? Что можно поместить в 4 байта? Да, хватило. Поместилось все, что надо. Уверен, многие догадались, что это за 4 байта.

Кто не догадался – процитирую фрагмент статьи из Википедии:

Итак, целое число, хранящее UNIX время, занимает 4 байта, чего хватит до 2 147 483 648 секунд. А потом возможны потенциальные проблемы. Почему потенциальные? Потому что это порог, при достижении которого число может быть интерпретировано, как отрицательное (что и произошло с айфонами многих любопытных товарищей в своё время). Может, но не обязательно будет – зависит от того, растут ли руки программистов из места, предусмотренного природой. Указанное число секунд соответствует 03:14:08 19-янв-2038. До этого времени можно неспешно переходить на 64-битную версию ОС, где время станет храниться в 8-байтной переменной, чего без проблем хватит на следующие 292 миллиарда лет. Существует вероятность, что на наш век этого хватит. А потом придётся обновляться до 128-битной версии UNIX.

Какие проблемы я решил, придя к такому варианту? Первое, сильно снизил количество передаваемых байт, что на миллисекунды увеличивает точность установки времени. Здорово, правда? И второе: я (вероятно) облегчил совместимость с Linux. К моему стыду, я никак не могу привыкнуть к Linux, и пользуюсь в основном только Windows.

Для этой самой Windows я могу написать программу пересылки, а для Linux – нет. Но полагаю, что в Linux можно получить значение UNIX-времени намного легче, чем в Windows, и переслать это число в COM порт.

Никаких дополнительных данных, вроде дня недели и так далее, передавать не требуется. Только UNIX время.

Всё остальное делается в Arduino.

Теперь немного конкретики непосредственно о первой составляющей – программе для Windows. Программа написана в старой-доброй Delphi. При запуске всплывающее окно просит выбрать COM порт для отправки данных. Выбираем. Остальные настройки следует оставить «дефолтными».

Как работает программа? Она пересчитывает из формата времени Windows данные для формата UNIX, то есть число секунд с полуночи 1 января 1970 года.

Затем добавляет 3 секунды и «впадает» в пустой цикл (очевидно, длительностью уже менее тех самых добавочных 3 секунд), выход из которого происходит в нужное количество секунд, как можно ближе к 000 миллисекундам. Иначе говоря, отслеживается наступление самого начала той секунды времени, значение которого должно будет переслаться в Arduino.

Согласитесь, пересылать данные о том, что, например, сейчас XXXXXXXXX5 секунд тогда, когда на самом деле уже, например, XXXXXXXXX5 и 756 тысячных (например) секунд, было бы не правильным. Именно для этого нужно отслеживать самое начало секунды для старта передачи данных. После передачи данных программа дружелюбно сообщает статус «Done :)».

На этом миссия программы завершается.
Вторая составляющая – аппаратно-программная часть – Arduino. Существует 2 разновидности «железа» для этого проекта: «полная» версия с экраном и кнопкой, и «урезанная» версия для быстрой установки времени модуля, собранная из «г**на и палок». Про их отличия – ниже.

«Полная» версия состоит из Arduino Nano, экрана 1602 с «переходником» с I2C в экран, опциональной кнопкой ресета Arduino и пин-хедера(female) для подключения модуля часов. Также, опционально, из корпуса девайса с «няшной» наклейкой.

«Урезанная» версия состоит из Arduino (Uno, Nano, Pro Mini + «правильный» переходник на USB с DTR) и 4 проводов для подключения модуля часов.Как видно из схем, «полная» версия, в дополнение к «урезанной», содержит кнопку для reset'а и экран 1602 с «переходником». Обе версии абсолютно одинаковы по основному функционалу – устанавливать время.

Экран нужен лишь для отображения этапов процесса и, по окончании процесса установки времени, отображения свежеустановленных времени, даты и дня недели. Причём данные к тому времени будут уже считываться из самого модуля часов.

В «урезанной» версии роль экрана выполняет встроенный в плату Arduino светодиод: по окончании процесса установки нового времени он начнет светиться. Вот и вся индикация.

Для чего же кнопка ресет? Для того, что в полной версии после установки времени Arduino войдёт в бесконечный цикл по отображению того самого свежеустановленного времени, то есть, по сути, станет часами.

Причём часами, сделанными на скорую руку, в связи с чем они не смогут заменить нормальные часы в силу нескольких причин (выборка секунд реализована через delay, пропадёт отображение времени при отключении питания). Ведь цель – убедиться, что время синхронизировано верно, не более того. Следовательно, для синхронизации следующего модуля часов без ресета не обойтись (точнее, можно обойтись, если «передёрнуть» USB кабель). Другими словами, назначение кнопки – сугубо утилитарное. При желании, можно обойтись и без неё.

Как же прошивать Arduino, ведь версии «железа» две, а скетч один? Для компиляции «правильной» версии прошивки в заголовке скетча нужно установить желаемое значение параметра fullVersion: true для «полной» версии, или false — для «урезанной». Компилятор таким образом определит, для какой версии «железа» компилировать прошивку.

Итак, схема подключения есть, нужен код скетча.

Обратите внимание, что для нормальной работы скетча с «полной» версией нужна библиотека LiquidCrystal I2C by Frank de Brabander (устанавливается из репозитория при помощи Менеджера Библиотек).

Также нужна библиотека для поддержки модуля часов, причём не любая :). Качать здесь: https://github.com/jarzebski/Arduino-DS3231. С библиотеками разобрались.

Вот код скетча:

//======================================== настройка, доступная для изменения ======================================== #define fullVersion true //true = «полная» версия с экраном; false = «урезанная» версия со встроенным светодиодом //================================= используемые библиотеки и объявление переменных ================================== #include #include #if (fullVersion) #include #endif unsigned long t1 = 0; //переменная для полученного времени unsigned long t2 = 0; //переменная для полученного времени byte b[4]; //буфер для получения данных из COM порта #if (fullVersion) byte day = 0; #endif DS3231 clock; RTCDateTime dat1; #if (fullVersion) LiquidCrystal_I2C lcd(0x3F,16,2); //китайси полюбили новый адрес для «переходников» с i2c в экран #endif //==================================================================================================================== void setup(){ #if (!fullVersion) //актуально только для «урезанной» версии — начало участка кода pinMode(13, OUTPUT); digitalWrite(13,LOW); #endif //актуально только для «урезанной» версии — конец участка кода clock.begin(); Serial.begin(9600); #if (fullVersion) //актуально только для «полной» версии — начало участка кода lcd.init(); lcd.backlight(); lcd.setCursor(0,0); lcd.print(«COMport 9600 8N1»); //подсказка, какие параметры COM порта выбирать в программе lcd.setCursor(0,1); lcd.print(«Ready to sync»); //сообщение статуса — готовы к синхронизации delay(1000); #endif //актуально только для «полной» версии — конец участка кода } void loop(){ if (Serial.available()){ //если есть «порох в пороховницах» COM порта Serial.readBytes(b,4); //считаем все 4 байта (другого мы и не ждём) t1=b[0]; t2=(t1

Источник: https://mysku.ru/blog/ebay/49229.html

Ссылка на основную публикацию