Arduino实时时钟的制作图解

步骤1：关于DS 1307

简介：

除了arduino，DS1307集成电路是该项目的核心因为它充当计时器，并告知arduino什么时候应该将设备保持打开状态。 DS 1307专为计时而设计，时间相当准确，每个月大约有1分钟的错误（时间漂移）。如果您想消除这种情况，您可以选择DS3234，它的时间漂移仅为每年1分钟。对于我们的特定应用，我们可以选择DS1307本身。

DS1307的优点在于它具有备用的纽扣电池。该纽扣电池通常为CR2032。这种电池对于IC来说绰绰有余，因为DS1307的功耗非常低，因此该电池的备用电池寿命至少约为9年。

因此，现在讨论这些规格让我们谈谈交流。 DS 1307使用I²C通信与arduino通信。只需将芯片以十进制形式发送数据，使得每个十进制形式都是4位二进制数据，也称为二进制编码十进制系统。

重要引脚：

5V引脚： ：当该引脚为高电平时，ds1307发送数据，为低电平时，它在备份按钮单元上运行。

GND： 这是模块的接地引脚。电池的接地和电源都连接在一起。

SCL： 这是i2c时钟引脚-与RTC通信。

SDA： 这是i2c数据引脚-与RTC进行通信。

现在，介绍已经完成。让我们开始实际制作模块。该指导书包含焊接步骤以及板上组件的放置位置。希望这种方法比仅仅提供电路图更好理解。

步骤2：组装和焊接-1

因此该模块只有2 x 3 cm的尺寸，非常紧凑。该模块具有电线连接器，但您也可以使用公头或母头接头，以便将其直接插入Arduino。无论如何，除了不焊接方波引脚之外，模块都具有所有功能。

制造模块：

步骤1：

将原型板切成上述尺寸，然后插入币形电池座。然后焊接底端以将电池固定在其位置。

第2步：

将DIP插座插入下一步固定到晶胞支架上，但如图所示，为晶振留出了空间。焊接一些引脚以将插座固定到位。

第3步：

现在将晶体振荡器插入第一个晶体振荡器附近。 DIP插座的第二个针脚，如图所示。然后如图所示进行焊接。

注意1：

此注释用于显示我的4针连接器的颜色代码仅供参考，因为您的颜色可能有所不同，请仔细检查是否已正确连接。

注2： p》

现在，我们需要使用如图所示的走线连接电池端子。这些连接提供备用电源。

步骤3：组装和焊接-2

第5步：

现在插入来自Arduino的电源引脚。正引脚连接到DS 1307的第八引脚。然后，IC和纽扣单元的接地是公共的。

步骤6：

在这一步中，我们连接来自Arduino的其他两个数据引脚，如图所示。很抱歉，因为我将模块做得很小，所以10k电阻没有孔。我将电阻器和导线都插入了相同的引脚，然后进行了焊接。

第7步：

因此，接下来插入电线，我们需要在两个引脚中分别插入10k电阻。两个电阻的另一端连接到DS 1307的电源引脚8。然后将导线焊接起来，以供参考。

步骤8：

由于我在此模块中使用了连接器，因此频繁使用会导致电线磨损。所以我用电阻器上的电线剪了一下。首先将电线插入一端并焊接以使其坚固。然后制作一个U形弯头，并使电线穿过该U形弯头，并拧紧U形弯头以获得良好的抓地力，然后再焊接另一端以形成接头。该图比文字更能说明该方法。

该模块最终完成，因此将电池和DS1307 IC都插入其插槽中。最终图显示了完整完整的模块。

步骤4：检查和设置模块

组装完模块后。将模块连接到Arduino，以便将引脚正确插入Arduino。下面给出了测试模块的程序。代码会不断通过串行端口更新时间。

为了运行模块，我们需要两个库，而在Arduino软件中则需要两个库。以下步骤使用所需的库和代码来设置Arduino软件。

导入库：

下载库“ RealTimeClockDS1307 ”并将其保存在桌面中。

打开Arduino，然后转到素描 =》 导入库 =》 添加库。

然后选择保存在桌面中的库，然后单击添加。

现在粘贴下面给出的示例代码，然后点击编译。如果编译成功，则跳过其余步骤。

如果没有导入第二个库“ Wire ”，重复相同的过程并编译代码，它将起作用。

代码正常工作：

代码是由“ David H. Brown”编写的，我只是用它来给你DS1307的简介。无论如何，Arduino与RTC模块通信并通过 Serial Monitor 每秒更新一次时间。创建者为我们提供了一个选项，用于设置发送命令“ ？”的时间。出现以下菜单。

Try these：

h## - set Hours ［range 1..12 or 0..24］

i## - set mInutes ［range 0..59］

s## - set Seconds ［range 0..59］

d## - set Date ［range 1..31］

m## - set Month ［range 1..12］

y## - set Year ［range 0..99］

w## - set arbitrary day of Week ［range 1..7］

t - toggle 24-hour mode

a - set AM p - set PM

z - start clock Z - stop clock

q - SQW/OUT = 1Hz Q - stop SQW/OUT

该代码将帮助您设置时间以及检查模块的备用电池供电是否正常。在下一个教程中，我将向您展示如何设置LCD显示器并显示RTC模块中的时间。这是用于测试模块及其附件的代码。

#include

#include

//RealTimeClock RTC;//=new RealTimeClock（）;

#define Display_Clock_Every_N_Seconds 10 // n.secs to show date/time

#define Display_ShortHelp_Every_N_Seconds 60 // n.secs to show hint for help

//#define TEST_Squarewave

//#define TEST_StopStart

//#define TEST_1224Switch

int count=0;

char formatted［］ = “00-00-00 00:00:00x”;

void setup（） {

// Wire.begin（）;

Serial.begin（9600）;

pinMode（A3， OUTPUT）; //*** pin 16 （Analog pin 2） as OUTPUT ***

digitalWrite（A3， HIGH）; //*** pin 16 （Analog pin 2） set to LOW ***

pinMode（A2， OUTPUT）; //*** pin 17 （Analog pin 3） as OUTPUT ***

digitalWrite（A2， LOW）; //*** pin 17 （Analog pin 3） set to HIGH ***

//*** Analog Pin settings to power RTC module ***

}

void loop（） {

if（Serial.available（））

{

processCommand（）;

}

RTC.readClock（）;

count++;

if（count % Display_Clock_Every_N_Seconds == 0）{

Serial.print（count）;

Serial.print（“： ”）;

RTC.getFormatted（formatted）;

Serial.print（formatted）;

Serial.println（）;

}

if（count % Display_ShortHelp_Every_N_Seconds == 0） {

Serial.println（“Send ？ for a list of commands.”）;

}

#ifdef TEST_Squarewave

if（count%10 == 0）

{

switch（count/10 % 6）

{

case 0：

Serial.print（“Squarewave disabled （low impedance）： ”）;

RTC.sqwDisable（0）;

Serial.println（（int） RTC.readData（7））;

break;

case 1：

Serial.print（“Squarewave disabled （high impedance）： ”）;

RTC.sqwDisable（1）;

Serial.println（（int） RTC.readData（7））;

break;

case 2：

Serial.println（“Squarewave enabled at 1 Hz”）;

RTC.sqwEnable（RTC.SQW_1Hz）;

break;

case 3：

Serial.println（“Squarewave enabled at 4.096 kHz”）;

RTC.sqwEnable（RTC.SQW_4kHz）;

break;

case 4：

Serial.println（“Squarewave enabled at 8.192 kHz”）;

RTC.sqwEnable（RTC.SQW_8kHz）;

break;

case 5：

Serial.println（“Squarewave enabled at 32.768 kHz”）;

RTC.sqwEnable（RTC.SQW_32kHz）;

break;

default：

Serial.println（“Squarewave test not defined”）;

}//switch

}

#endif

#ifdef TEST_StopStart

if（count%10 == 0）

{

if（！RTC.isStopped（））

{

if（RTC.getSeconds（） 《 45）

{

Serial.println（“Stopping clock for 10 seconds”）;

RTC.stop（）;

}//if we have enough time

} else {

RTC.setSeconds（RTC.getSeconds（）+11）;

RTC.start（）;

Serial.println（“Adding 11 seconds and restarting clock”）;

}

}//if on a multiple of 10 counts

#endif

#ifdef TEST_1224Switch

if（count%10 == 0）

{

if（count %20 == 0）

{

Serial.println（“switching to 12-hour time”）;

RTC.switchTo12h（）;

RTC.setClock（）;

}

else

{

Serial.println（“switching to 24-hour time”）;

RTC.switchTo24h（）;

RTC.setClock（）;

}

}

#endif

}

void processCommand（） {

if（！Serial.available（）） { return; }

char command = Serial.read（）;

int in，in2;

switch（command）

{

case ‘H’：

case ‘h’：

in=SerialReadPosInt（）;

RTC.setHours（in）;

RTC.setClock（）;

Serial.print（“Setting hours to ”）;

Serial.println（in）;

break;

case ‘I’：

case ‘i’：

in=SerialReadPosInt（）;

RTC.setMinutes（in）;

RTC.setClock（）;

Serial.print（“Setting minutes to ”）;

Serial.println（in）;

break;

case ‘S’：

case ‘s’：

in=SerialReadPosInt（）;

RTC.setSeconds（in）;

RTC.setClock（）;

Serial.print（“Setting seconds to ”）;

Serial.println（in）;

break;

case ‘Y’：

case ‘y’：

in=SerialReadPosInt（）;

RTC.setYear（in）;

RTC.setClock（）;

Serial.print（“Setting year to ”）;

Serial.println（in）;

break;

case ‘M’：

case ‘m’：

in=SerialReadPosInt（）;

RTC.setMonth（in）;

RTC.setClock（）;

Serial.print（“Setting month to ”）;

Serial.println（in）;

break;

case ‘D’：

case ‘d’：

in=SerialReadPosInt（）;

RTC.setDate（in）;

RTC.setClock（）;

Serial.print（“Setting date to ”）;

Serial.println（in）;

break;

case ‘W’：

Serial.print（“Day of week is ”）;

Serial.println（（int） RTC.getDayOfWeek（））;

break;

case ‘w’：

in=SerialReadPosInt（）;

RTC.setDayOfWeek（in）;

RTC.setClock（）;

Serial.print（“Setting day of week to ”）;

Serial.println（in）;

break;

case ‘t’：

case ‘T’：

if（RTC.is12hour（）） {

RTC.switchTo24h（）;

Serial.println（“Switching to 24-hour clock.”）;

} else {

RTC.switchTo12h（）;

Serial.println（“Switching to 12-hour clock.”）;

}

RTC.setClock（）;

break;

case ‘A’：

case ‘a’：

if（RTC.is12hour（）） {

RTC.setAM（）;

RTC.setClock（）;

Serial.println（“Set AM.”）;

} else {

Serial.println（“（Set hours only in 24-hour mode.）”）;

}

break;

case ‘P’：

case ‘p’：

if（RTC.is12hour（）） {

RTC.setPM（）;

RTC.setClock（）;

Serial.println（“Set PM.”）;

} else {

Serial.println（“（Set hours only in 24-hour mode.）”）;

}

break;

case ‘q’：

RTC.sqwEnable（RTC.SQW_1Hz）;

Serial.println（“Square wave output set to 1Hz”）;

break;

case ‘Q’：

RTC.sqwDisable（0）;

Serial.println（“Square wave output disabled （low）”）;

break;

case ‘z’：

RTC.start（）;

Serial.println（“Clock oscillator started.”）;

break;

case ‘Z’：

RTC.stop（）;

Serial.println（“Clock oscillator stopped.”）;

break;

case ‘》’：

in=SerialReadPosInt（）;

in2=SerialReadPosInt（）;

RTC.writeData（in， in2）;

Serial.print（“Write to register ”）;

Serial.print（in）;

Serial.print（“ the value ”）;

Serial.println（in2）;

break;

case ‘《’：

in=SerialReadPosInt（）;

in2=RTC.readData（in）;

Serial.print（“Read from register ”）;

Serial.print（in）;

Serial.print（“ the value ”）;

Serial.println（in2）;

break;

default：

Serial.println（“Unknown command. Try these：”）;

Serial.println（“ h## - set Hours ［range 1..12 or 0..24］”）;

Serial.println（“ i## - set mInutes ［range 0..59］”）;

Serial.println（“ s## - set Seconds ［range 0..59］”）;

Serial.println（“ d## - set Date ［range 1..31］”）;

Serial.println（“ m## - set Month ［range 1..12］”）;

Serial.println（“ y## - set Year ［range 0..99］”）;

Serial.println（“ w## - set arbitrary day of Week ［range 1..7］”）;

Serial.println（“ t - toggle 24-hour mode”）;

Serial.println（“ a - set AM p - set PM”）;

Serial.println（）;

Serial.println（“ z - start clock Z - stop clock”）;

Serial.println（“ q - SQW/OUT = 1Hz Q - stop SQW/OUT”）;

Serial.println（）;

Serial.println（“ 》##，### - write to register ## the value ###”）;

Serial.println（“ 《## - read the value in register ##”）;

}//switch on command

}

//read in numeric characters until something else

//or no more data is available on serial.

int SerialReadPosInt（） {

int i = 0;

boolean done=false;

while（Serial.available（） && ！done）

{

char c = Serial.read（）;

if （c 》= ‘0’ && c 《=‘9’）

{

i = i * 10 + （c-‘0’）;

}

else

{

done = true;

}

}

return i;

}

步骤5：关于库

开始之前在液晶显示屏上显示时间。我想讨论一下我们导入的库。我省略了需要方波数据的库，因为该模块没有方波输出引脚。让我们通过一些示例来讨论该库中涉及的各种关键字。

关键字：

起始时钟：

RTC.start（）;

此时钟可用于启动时钟，它将从停止时开始计时。首次使用该模块以启动模块时，应使用此命令。

停止时钟：

RTC.stop（）;

使用此行，可以暂停该模块，并且在给出启动命令之前，时钟不会计时。它与开始时钟命令一起使用以控制模块的状态。

读取时钟：

RTC.readClock（）;

使用“开始”命令打开时钟后。您需要从RTC模块读取数据。这是通过readClock函数完成的。在使用后面的命令之前，此功能必不可少。

读取时间：

//integers for holding the various time values.

int hours = 0;

int minutes = 0;

int seconds = 0;

int dates = 0;

int months = 0;

int years = 0;

int date = 0;

//syntax for setting the values to the integers

RTC.readClock（）; //This line is essential for the other commands to work.

//Commands for getting the individual time values.

hours = RTC.getHours（）;

minutes = RTC.getMinutes（）;

seconds = RTC.getSeconds（）;

dates = RTC.getDate（）;

months = RTC.getMonth（）;

years = RTC.getYear（）;

date = RTC.getDayofWeek（）;

//finally just print the stored data （refer next step）。

因此一旦readClock被调用。接下来，我们需要将各个值存储为整数。我们创建整数来保存值。 getDayofWeek函数提供星期几。第一天为星期一，最后一天为星期日。请注意，与前面步骤中的代码相比，此方法效率很低，但这将有助于您了解库中各种功能的工作。

注意：

//extra code for finding out whether its AM or PM when the clock is in 12h mode.

//declare an integer and string.

int AP = 0;

String TZ;

//then read the data from the module.

ampm = RTC.isPM（）;

//use an if loop to find out whether its AM or PM.

if（ampm == 1）

{

am = “PM”;

}

else

{

am =“AM”;

}

此额外的代码行将在12小时模式下显示其上午还是下午。当您将其设置为24小时制时，请删除此代码。

写时间：

RTC.setHours（4）;

RTC.setMinutes（35）;

RTC.setSeconds（14）;

RTC.setDate（9）;

RTC.setMonth（6）;

RTC.setYear（14）;

RTC.set24h（）;

//RTC.setAM（）;

RTC.setPM（）;

RTC.setDayofWeek（1）;

因此，这些是用于设置模块时间的命令。如您所见，我已经设置了 4:35:14 PM 的时间，日期为 9/6/14 。除了这些命令外，还有set24h命令，直接将时钟设置为24小时模式，并将AM和PM设置为12小时模式。 setDayofWeek用于设置日期。

时间命令：

//These commands deal with the settings in the module.

//Checks whether the clock is running.

RTC.isStopped（）;

//Check whether it is AM or PM depending on the output（given above）。

RTC.isPM（）;

//Checks whether the clock is in 24hour mode.

RTC.is12hour（）;

//Toggles between the 12hour mode and 24hour mode.

RTC.switchTo24h（）;

以下是这些命令：控制时钟内的设置。

我已经尽我所能解释了这个库。如果发现任何缺陷或我错过的东西，请对其进行评论，以使其尽可能准确。

步骤6：显示时间（简单方法）

现在检查了模块，现在让我们开始获取要在LCD上显示的时间数据。 LCD模块可以轻松连接到Arduino。显示了用于连接LCD模块的电路图。下面显示了用于显示时间的代码。

在我制作了此代码的两个版本之前。其中一个将普通LCD连接到Arduino。这是最简单的版本，但是它将占用Arduino中的大多数引脚。因此，我想出了一个替代方案，使用移位寄存器仅使用2个引脚将数据发送到LCD模块。因此，您可以选择更方便的方式。

普通版：

更多的引脚，但是更简单！

因此，如面包板图所示，连接LCD。然后将代码上传到Arduino，日期和时间将显示在LCD显示屏中。因此，这是代码。

代码：

#include

#include

#include

LiquidCrystal lcd（12， 11， 5， 4， 3， 2）;

#define Display_Clock_Every_N_Seconds 10

#define Display_ShortHelp_Every_N_Seconds 60

String tz;

int hours = 0;

int minutes = 0;

int seconds = 0;

int dates = 0;

int months = 0;

int years = 0;

int ap = 0;

void setup（） {

Serial.begin（9600）;

lcd.begin（16，2）;

pinMode（A3， OUTPUT）;

digitalWrite（A3， HIGH）;

pinMode（A2， OUTPUT）;

digitalWrite（A2， LOW）;

}

void loop（） {

RTC.readClock（）;

if（ap == 1）

{

tz = “PM”;

}

else

{

tz =“AM”;

}

lcd.home（）;

hours = RTC.getHours（）;

minutes = RTC.getMinutes（）;

seconds = RTC.getSeconds（）;

ap = RTC.isPM（）;

dates = RTC.getDate（）;

months = RTC.getMonth（）;

years = RTC.getYear（）;

lcd.print（hours）;

lcd.print（“：”）;

lcd.print（minutes）;

lcd.print（“：”）;

lcd.print（seconds）;

lcd.print（“ ”）;

lcd.print（tz）;

lcd.setCursor（0， 1）;

lcd.print（dates）;

lcd.print（“：”）;

lcd.print（months）;

lcd.print（“：”）;

lcd.print（years）;

delay（250）;

lcd.clear（）;

lcd.home（）;

lcd.print（hours）;

lcd.print（“ ”）;

lcd.print（minutes）;

lcd.print（“ ”）;

lcd.print（seconds）;

lcd.print（“ ”）;

lcd.print（tz）;

lcd.setCursor（0， 1）;

lcd.print（dates）;

lcd.print（“ ”）;

lcd.print（months）;

lcd.print（“ ”）;

lcd.print（years）;

delay（250）;

lcd.clear（）;

}

在连接RTC模块并上传代码后。液晶显示屏将在顶部显示时间，在底部显示日期。此版本对于学习基本命令很有用，并允许您在将来的项目中使用这些命令。

步骤7：显示时间（移位寄存器版本）

移位寄存器LCD版本：

此版本使用的移位寄存器模块仅使用两个就可以将数据发送到LCD引脚而不是六个引脚。可以购买此模块，但我想制造它。即将发布的链接中提供了制作模块的完整说明！因此，只需将Arduino的两个引脚连接到模块，然后上传下面给出的代码，就可以像在简单版本中一样观察到相同的输出。

CODE：

#include

#include

#include

LiquidCrystal_SR lcd（8，7，TWO_WIRE）;

#define Display_Clock_Every_N_Seconds 10

#define Display_ShortHelp_Every_N_Seconds 60

String tz;

int hours = 0;

int minutes = 0;

int seconds = 0;

int dates = 0;

int months = 0;

int years = 0;

int ap = 0;

void setup（） {

// Wire.begin（）;

Serial.begin（9600）;

lcd.begin（16，2）;

pinMode（A3， OUTPUT）;

digitalWrite（A3， HIGH）;

pinMode（A2， OUTPUT）;

digitalWrite（A2， LOW）;

}

void loop（） {

RTC.readClock（）;

ap = RTC.isPM（）;

if（ap == 1）

{

tz = “PM”;

}

else

{

tz =“AM”;

}

lcd.home（）;

hours = RTC.getHours（）;

minutes = RTC.getMinutes（）;

seconds = RTC.getSeconds（）;

dates = RTC.getDate（）;

months = RTC.getMonth（）;

years = RTC.getYear（）;

lcd.print（hours）;

lcd.print（“：”）;

lcd.print（minutes）;

lcd.print（“：”）;

lcd.print（seconds）;

lcd.print（“ ”）;

lcd.print（tz）;

lcd.setCursor（0， 1）;

lcd.print（dates）;

lcd.print（“：”）;

lcd.print（months）;

lcd.print（“：”）;

lcd.print（years）;

delay（250）;

lcd.clear（）;

lcd.home（）;

lcd.print（hours）;

lcd.print（“ ”）;

lcd.print（minutes）;

lcd.print（“ ”）;

lcd.print（seconds）;

lcd.print（“ ”）;

lcd.print（tz）;

lcd.setCursor（0， 1）;

lcd.print（dates）;

lcd.print（“ ”）;

lcd.print（months）;

lcd.print（“ ”）;

lcd.print（years）;

delay（250）;

lcd.clear（）;

}

如果您已经有了此模块，则第二个代码使用另一个库，请使用该库使上面的代码正常工作。