RTCベースのクロック

必要なツールとマシン

>	はんだごて（汎用）
	マルチメーター すべてのプロジェクトにはマルチメーターが必要です。したがって、標準のペアに投資すると、少なくとも4年間は機能し、修復方法を知っていればさらに長くなる可能性があります。はんだ付けの接続性を確認し、回路によって引き込まれる電流を確認するために、これが必要になります。

アプリとオンラインサービス

>	Arduino IDE
	Arduino Fritzing

このプロジェクトについて

これは、RTC DS1307ICを使用して作成された非常にシンプルで組み立てが簡単なデジタル時計です。 LCDディスプレイ付き。 4桁の7セグメントディスプレイに時刻を表示するだけです。コードを簡単に調整して、アラームなどの追加機能を追加することもできます。必要なのは、少しの想像力と工夫だけです。このプロジェクトは、より良い、より複雑なものへの足がかりとして作成されました。さらに、自分の部屋に展示するために見栄えのするものを作りたかったのです。

十分に言われているので、PCBにはんだ付けするときに遭遇した問題や、これらの問題をどのように解決したかなど、この投稿には細部をすべて含めます。

ステップ1：コンポーネント

RTCモジュール

DS1307チップは、電源オフ時でも時間を追跡する機能を備えているため、非常に優れています。 Arduinoとのインターフェースは簡単で、このモジュールを操作するために利用できるライブラリがたくさんあります。 RTCは、I2Cプロトコルを介してArduinoとインターフェイスします。プロトコルの詳細について心配する必要はありません。ArduinonanoのピンA4とA5はI2C通信に使用されます。

• SDA-A4

• SCL-A5

このプロジェクトではDSピンは必要ありません。

唯一の欠点は、私たちが望むほど正確ではないということです。チップは時間ドリフトの影響を非常に受けやすく、温度によっては実際の時間から非常に簡単にドリフトします。

注-GNDピンとVccピンが正しく接続されていることを確認してください。 Vccは（モジュール内で）GNDピンの前に配置されます。私は逆極性で数回接続しました、そしてそれは非常に速く非常に熱くなります。したがって、極性を逆に接続する場合は、電源を入れるときにコイン電池に触れるだけで、熱くなったと感じたらすぐに電源を切ることができます。

シフトレジスタ（74HC595）

• シフトレジスタ74HC595は、多重化の技術のおかげでそれを可能にしたチップでした。初心者は、この恐ろしい見た目の用語が楽しいことを恐れないでください。あなたはそれを学んだことをうれしく思います。

• 595には16個のピンがあり、2つのシフトレジスタを使用して4桁の7セグメントディスプレイと対話します。

• 最初のシフトレジスタはセグメントを照らすために使用され、2番目のシフトレジスタはどの桁を照らすかを選択するために使用されます。

• 多重化の技術のおかげで、数字間の切り替えは非常に高速に行われます。すべての桁が同時に表示されているようです。

注：これらのチップは非常に信頼性がありますが、たまたまいくつかの欠陥のあるチップを入手しました。一部のチップでは、Q0とQ1が機能していませんでした。いくつかはQ3を内部的に接地しました（建設ミス）。私が今私のプロジェクトに持っているものも完全ではありません。そのうちの1つはQ7に欠陥があるため、それらを使用しているときは接続が正確であることを確認する必要があり、まだ機能していないときはマルチメーターの導通機能を使用してピンをチェックしました。プロジェクトをしている間に小さな障害を乗り越えることを学ぶことはすべての手段なので、全体として私は文句を言いません。

4桁の7セグメントディスプレイ

一般的な4桁のセグメント（共通アノード）を使用しました ）。番号は左下から始まり、左上のピンで終わる12本のピンがあります。各セグメントは、桁と小数点を表示できます。それで、私はデジタル時計に典型的なかっこいいコロンを持っていないので、私は2桁目の小数点でやらなければなりませんでした。これらは、主な目的が数値を表示することである場合に最適な表示です。

注：セグメントa〜gは同じ行にないため、これらは初心者にとっては非常に扱いにくい場合があります。注意して、電流制限抵抗なしで5V電源を接続しないでください。

私はこれとそのかなり自明の概略図を含めました。

回路図には、プロジェクトで使用したものと同じタイプの表示がないため、シフトレジスタからセグメントへのピン接続を次に示します。

セグメントピン番号ディスプレイ上シフトレジスタピン

A 11 15

B 7 1

C 4 2

D 2 3

E 1 4

F 10 5

G 5 6

10進数37

D1 12 15（2nd 595）

D2 9 1（2番目の595）

D3 8 2（2番目の595）

D4 6 3（2nd 595）

このプロジェクトは安価で簡単に作成できますが、少しの忍耐力と忍耐力が必要です（つまり、PCBにはんだ付けするためにさらに1マイル進んでいく場合）。楽しみのためだけに試してみたい場合は、2時間もかかりません。

私がこれをどのように改善できるかについて、そして投稿に明確に言及されていないことがあれば、フィードバックをお願いします。

コード

• 時計コード
• 時間を設定する
• RealTimeClockDS1307.cpp
• Readme
• RealTimeClockDS1307.h
• 別のファイル
• RTClibファイル
• library.properties（name）
• RTClib
• RTClib
• README.md
• RTClib.cpp
• RTClib.h

時計コード Arduino

 #include  #include  #include  RTC_DS1307 RTC; int temp、inc、hours1、minut、add =11; int HOUR、MINUT、SECOND; intlatchPin =3; // 595 o33intのピン12dataPin =4; // 595または4intclockPin =2のピン14; // 595または2のピン11intシフト=256; int単位、数十、数百、数千; int x; int y; const int alarmHour =17; const int alarmMinute =26; void setup（）{Serial.begin（9600 ）; pinMode（latchPin、OUTPUT）; pinMode（dataPin、OUTPUT）; pinMode（clockPin、OUTPUT）; pinMode（13、OUTPUT）; Wire.begin（）; RTC.begin（）; if（！RTC.isrunning（））{RTC.adjust（DateTime（__ DATE __、__ TIME__））; }} void loop（）{int temp =0、val =1、temp4; DateTime now =RTC.now（）; HOUR =now.hour（）; MINUT =now.minute（）; //Serial.println(MINUT）; if（HOUR <10）{百=HOUR;千=HOUR / 10; } else if（HOUR> =10 &&HOUR <24）{百=HOUR％10;千=時間/ 10; } if（MINUT <=9）{units =MINUT;十=分/ 10; } else if（MINUT> 9 &&MINUT <=60）{単位=MINUT％10;数十=分/ 10; } switch（units）{case 0：// 0 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 192）; digitalWrite（latchPin、HIGH）;壊す;ケース1：// 1 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 249）; digitalWrite（latchPin、HIGH）;壊す;ケース2：// 2 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 164）; digitalWrite（latchPin、HIGH）;壊す;ケース3：// 3 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 176）; digitalWrite（latchPin、HIGH）;壊す;ケース4：// 4 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 153）; digitalWrite（latchPin、HIGH）;壊す;ケース5：// 5 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 146）; digitalWrite（latchPin、HIGH）;壊す;ケース6：// 6 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 130）; digitalWrite（latchPin、HIGH）;壊す;ケース7：// 7 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 248）; digitalWrite（latchPin、HIGH）;壊す;ケース8：// 8 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 128）; digitalWrite（latchPin、HIGH）;壊す;ケース9：// 9 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 8 + 144）; digitalWrite（latchPin、HIGH）;壊す; } delay（1）; switch（tens）{case 0：// 0 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4 + 192）; digitalWrite（latchPin、HIGH）;壊す;ケース1：// 1 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4 + 249）; digitalWrite（latchPin、HIGH）;壊す;ケース2：// 2 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4 + 164）; digitalWrite（latchPin、HIGH）;壊す;ケース3：// 3 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4 + 176）; digitalWrite（latchPin、HIGH）;壊す;ケース4：// 4 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4 + 153）; digitalWrite（latchPin、HIGH）;壊す;ケース5：// 5 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 4 + 146）; digitalWrite（latchPin、HIGH）;壊す; } delay（1）;スイッチ（数百）{ケース0：// 0 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 64）; digitalWrite（latchPin、HIGH）;壊す;ケース1：// 1 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 121）; digitalWrite（latchPin、HIGH）;壊す;ケース2：// 2 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 36）; digitalWrite（latchPin、HIGH）;壊す;ケース3：// 3 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 48）; digitalWrite（latchPin、HIGH）;壊す;ケース4：// 4 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 25）; digitalWrite（latchPin、HIGH）;壊す;ケース5：// 5 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 18）; digitalWrite（latchPin、HIGH）;壊す;ケース6：// 6 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 2）; digitalWrite（latchPin、HIGH）;壊す;ケース7：// 7 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 120）; digitalWrite（latchPin、HIGH）;壊す;ケース8：// 8 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 0）; digitalWrite（latchPin、HIGH）;壊す;ケース9：// 9 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift * 2 + 16）; digitalWrite（latchPin、HIGH）;壊す; } delay（1）;スイッチ（数千）{ケース0：// 0 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 192）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース1：// 1 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 249）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース2：// 2 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 164）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース3：// 3 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 176）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース4：// 4 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 153）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース5：// 5 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 146）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース6：// 6 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 130）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース7：// 7 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 248）; digitalWrite（latchPin、HIGH）; // delay（500）;壊す;ケース8：// 8 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 128）; digitalWrite（latchPin、HIGH）;壊す;ケース9：// 9 digitalWrite（latchPin、LOW）; shiftOut（dataPin、clockPin、MSBFIRST、shift>> 8）; shiftOut（dataPin、clockPin、MSBFIRST、shift + 152）; digitalWrite（latchPin、HIGH）;壊す; } delay（1）; //アラームセクションif（HOUR ==alarmHour &&MINUT ==alarmMinute）{digitalWrite（13、HIGH）; } else {digitalWrite（13、LOW）; }} 

時刻を設定する Arduino

 / * RealTimeClockDS1307-DS1307 RTCモジュールを制御するライブラリCopyright（c）2011 David H.Brown。 All rights reserved JohnWatersとMauriceRibbleの以前の非常に有益な作業に感謝します（コードを使用しなかった場合でも）：-http：//combustory.com/wiki/index.php/RTC1307_ -_Real_Time_Clock-http：//www.glacialwanderer.com/hobbyrobotics/？p =12このライブラリはフリーソフトウェアです。フリーソフトウェアファウンデーションによって公開されているGNULesser General Public Licenseの条件の下で、再配布および/または変更することができます。ライセンスのバージョン2.1、または（オプションで）それ以降のバージョン。このライブラリは、役立つことを期待して配布されていますが、いかなる保証もありません。商品性または特定目的への適合性の黙示の保証もありません。詳細については、GNU劣等一般公衆利用許諾契約書を参照してください。このライブラリと一緒にGNU劣等一般公衆利用許諾契約書のコピーを受け取っているはずです。そうでない場合は、Free Software Foundation、Inc.、51 Franklin St、Fifth Floor、Boston、MA 02110-1301 USA * /＃include  #include  // RealTimeClock RTC; // =new RealTimeClock（）; #define Display_Clock_Every_N_Seconds 1＃define Display_ShortHelp_Every_N_Seconds 25 //＃define TEST_Squarewave //＃define TEST_StopStart //＃define TEST_1224Switchint count =0; char formated [] ="00-00-00 00：00：00x"; void setup（）{// Wire.begin（）; Serial.begin（9600）;} void loop（）{if（Serial.available（））{processCommand（）; } delay（1000）; RTC.readClock（）; count ++; if（count％Display_Clock_Every_N_Seconds ==0）{Serial.print（count）; Serial.print（ "："）; RTC.getFormatted（formatted）; Serial.print（フォーマット済み）; Serial.println（）; } if（count％Display_ShortHelp_Every_N_Seconds ==0）{Serial.println（ "コマンドのリストを送信します。"）; } #ifdef TEST_Squarewaveif（count％10 ==0）{switch（count / 10％6）{ケース0：Serial.print（ "方形波無効（低インピーダンス）："）; RTC.sqwDisable（0）; Serial.println（（int）RTC.readData（7））;壊す;ケース1：Serial.print（ "方形波無効（高インピーダンス）："）; RTC.sqwDisable（1）; Serial.println（（int）RTC.readData（7））;壊す;ケース2：Serial.println（ "方形波は1Hzで有効"）; RTC.sqwEnable（RTC.SQW_1Hz）;壊す;ケース3：Serial.println（ "4.096 kHzで方形波が有効"）; RTC.sqwEnable（RTC.SQW_4kHz）;壊す;ケース4：Serial.println（ "8.192 kHzで方形波が有効になっています"）; RTC.sqwEnable（RTC.SQW_8kHz）;壊す;ケース5：Serial.println（ "32.768 kHzで方形波が有効になっています"）; RTC.sqwEnable（RTC.SQW_32kHz）;壊す;デフォルト：Serial.println（ "方形波テストが定義されていません"）; } // switch}＃endif＃ifdef TEST_StopStartif（count％10 ==0）{if（！RTC.isStopped（））{if（RTC.getSeconds（）<45）{Serial.println（ "10秒間クロックを停止"）; RTC.stop（）; } //十分な時間があれば} else {RTC.setSeconds（RTC.getSeconds（）+ 11）; RTC.start（）; Serial.println（ "11秒を追加して時計を再起動する"）; }} // if 10カウントの倍数＃endif＃ifdef TEST_1224Switch if（count％10 ==0）{if（count％20 ==0）{Serial.println（ "12時間の時間に切り替える"）; RTC.switchTo12h（）; RTC.setClock（）; } else {Serial.println（ "24時間制に切り替え"）; 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（ "時間を設定する"）; Serial.println（in）;壊す;ケース 'I'：ケース 'i'：in =SerialReadPosInt（）; RTC.setMinutes（in）; RTC.setClock（）; Serial.print（ "分を設定する"）; Serial.println（in）;壊す;ケース 'S'：ケース 's'：in =SerialReadPosInt（）; RTC.setSeconds（in）; RTC.setClock（）; Serial.print（ "秒を"に設定）; Serial.println（in）;壊す;ケース 'Y'：ケース 'y'：in =SerialReadPosInt（）; RTC.setYear（in）; RTC.setClock（）; Serial.print（ "年を"に設定）; Serial.println（in）;壊す;ケース 'M'：ケース 'm'：in =SerialReadPosInt（）; RTC.setMonth（in）; RTC.setClock（）; Serial.print（ "月を"に設定）; Serial.println（in）;壊す;ケース 'D'：ケース 'd'：in =SerialReadPosInt（）; RTC.setDate（in）; RTC.setClock（）; Serial.print（ "日付を"に設定）; Serial.println（in）;壊す;ケース 'W'：Serial.print（ "曜日は"）; Serial.println（（int）RTC.getDayOfWeek（））;壊す;ケース 'w'：in =SerialReadPosInt（）; RTC.setDayOfWeek（in）; RTC.setClock（）; Serial.print（ "曜日を"に設定）; Serial.println（in）;壊す;ケース 't'：ケース 'T'：if（RTC.is12hour（））{RTC.switchTo24h（）; Serial.println（ "24時間制に切り替えます。"）; } else {RTC.switchTo12h（）; Serial.println（ "12時間制に切り替えます。"）; } RTC.setClock（）;壊す;ケース 'A'：ケース 'a'：if（RTC.is12hour（））{RTC.setAM（）; RTC.setClock（）; Serial.println（ "Set AM。"）; } else {Serial.println（ "（24時間モードでのみ時間を設定します。）"）; } 壊す;ケース 'P'：ケース 'p'：if（RTC.is12hour（））{RTC.setPM（）; RTC.setClock（）; Serial.println（ "Set PM。"）; } else {Serial.println（ "（24時間モードでのみ時間を設定します。）"）; } 壊す;ケース 'q'：RTC.sqwEnable（RTC.SQW_1Hz）; Serial.println（ "方形波出力を1Hzに設定"）;壊す;ケース 'Q'：RTC.sqwDisable（0）; Serial.println（ "方形波出力が無効（低）"）;壊す;ケース 'z'：RTC.start（）; Serial.println（ "クロックオシレーターが開始しました。"）;壊す;ケース 'Z'：RTC.stop（）; Serial.println（ "クロック発振器が停止しました。"）;壊す;ケース '>'：in =SerialReadPosInt（）; in2 =SerialReadPosInt（）; RTC.writeData（in、in2）; Serial.print（ "レジスタへの書き込み"）; Serial.print（in）; Serial.print（ "値"）; Serial.println（in2）;壊す;ケース '<'：in =SerialReadPosInt（）; in2 =RTC.readData（in）; Serial.print（ "レジスタから読み取る"）; Serial.print（in）; Serial.print（ "値"）; Serial.println（in2）;壊す;デフォルト：Serial.println（ "不明なコマンド。これらを試してください："）; Serial.println（ "h ##-時間の設定d ##-日付の設定"）; Serial.println（ "i ## --set mInutes m ## --set Month"）; Serial.println（ "s ##-秒を設定y ##-年を設定"）; Serial.println（ "w ##-任意の曜日を設定"）; Serial.println（ "t-24時間モードを切り替えます"）; Serial.println（ "a --set AM p --set PM"）; Serial.println（）; Serial.println（ "z-開始クロックZ-停止クロック"）; Serial.println（ "q-SQW / OUT =1HzQ-停止SQW / OUT"）; Serial.println（）; Serial.println（ "> ##、###-レジスタ##に値###"）;を書き込みます。 Serial.println（ "<##-レジスタ##"）;の値を読み取ります。 } //コマンドをオンにします} //他の何かが利用できるようになるまで数字を読み取ります//または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;} 

RealTimeClockDS1307.cpp C / C ++

 / * RealTimeClockDS1307-DS1307 RTCモジュールを制御するためのライブラリCopyright（c）2011 David H.Brown。 All rights reserved v0.92 Arduino1.00用に更新。以前のバージョンでは再テストされていませんJohnWatersとMauriceRibbleの以前の非常に役立つ作業に感謝します（コードを使用しなかった場合でも）：-http：//combustory.com/wiki/index .php / RTC1307 _-_ Real_Time_Clock-http：//www.glacialwanderer.com/hobbyrobotics/？p =12このライブラリはフリーソフトウェアです。フリーソフトウェアファウンデーションによって公開されているGNULesser General Public Licenseの条件の下で、再配布および/または変更することができます。ライセンスのバージョン2.1、または（オプションで）それ以降のバージョン。このライブラリは、役立つことを期待して配布されていますが、いかなる保証もありません。商品性または特定目的への適合性の黙示の保証もありません。詳細については、GNU劣等一般公衆利用許諾契約書を参照してください。このライブラリと一緒にGNU劣等一般公衆利用許諾契約書のコピーを受け取っているはずです。そうでない場合は、Free Software Foundation、Inc.、51 Franklin St、Fifth Floor、Boston、MA 02110-1301 USA * / / ******************** ************************************************** *********含まれています**************************************** ************************************** /＃include "RealTimeClockDS1307.h" #include  / ********************************************** *********************************定義**************** ************************************************** ************ /＃define DS1307_I2C_ADDRESS 0x68 //これはI2Cアドレスです/ ************************* ************************************************** ****コンストラクター********************************************* ********************************* / RealTimeClockDS1307 ::RealTimeClockDS1307（）{Wire.begin（）; // Wire.begin（）が呼び出されない前に、時計の読み取りを試みてはなりません。 readClock（）がハングします。 //幸い、Wire.begin（）を//複数回呼び出しても悪影響はないようです。} / *********************** ************************************************** ******ユーザーAPI ****************************************** ************************************ // *****チップの読み取り/書き込み*** *** / void RealTimeClockDS1307 ::readClock（）{//レジスタポインタをリセットしますWire.beginTransmission（DS1307_I2C_ADDRESS）; Wire.write（（uint8_t）0x00）; Wire.endTransmission（）; Wire.requestFrom（DS1307_I2C_ADDRESS、8）; _reg0_sec =Wire.read（）; _reg1_min =Wire.read（）; _reg2_hour =Wire.read（）; _reg3_day =Wire.read（）; _reg4_date =Wire.read（）; _reg5_month =Wire.read（）; _reg6_year =Wire.read（）; _reg7_sqw =Wire.read（）;} void RealTimeClockDS1307 ::setClock（）{//偏執的になるために、最初に時計を停止して//書き込み中にロールオーバーが発生しないようにします。 writeData（0,0x80）; //ここで、2番目のWire.beginTransmission（DS1307_I2C_ADDRESS）;を除くすべてを書き込みます。 Wire.write（（uint8_t）0x01）; Wire.write（_reg1_min）; Wire.write（_reg2_hour）; Wire.write（_reg3_day）; Wire.write（_reg4_date）; Wire.write（_reg5_month）; Wire.write（_reg6_year）; Wire.endTransmission（）; //ここで、秒を記述します。 // _ reg0_secは時計が何になりたいかをすでに知っているので、//時計がすでに実行されているかどうかを追跡する必要はありませんでした。これは//新しい秒の値を書き込むときに時計を再開します。 writeData（0、_reg0_sec）; } void RealTimeClockDS1307 ::stop（）{// "レジスタ0のビット7はクロック停止（CH）ビットです。//このビットが1に設定されると、発振器は無効になります。" _reg0_sec =_reg0_sec | 0x80; writeData（0、_reg0_sec）;} void RealTimeClockDS1307 ::start（）{// "レジスタ0のビット7はクロック停止（CH）ビットです。//このビットが1に設定されると、発振器は無効になります。" _reg0_sec =_reg0_sec＆〜0x80; writeData（0、_reg0_sec）;} void RealTimeClockDS1307 ::writeData（byte regNo、byte value）{if（regNo> 0x3F）{return; } Wire.beginTransmission（DS1307_I2C_ADDRESS）; Wire.write（regNo）; Wire.write（value）; Wire.endTransmission（）;} void RealTimeClockDS1307 ::writeData（byte regNo、void * source、int length）{char * p =（char *）source; if（regNo> 0x3F ||長さ> 0x3F）{return; } Wire.beginTransmission（DS1307_I2C_ADDRESS）; Wire.write（regNo）; for（int i =0; i  0x3F）{return 0xff; } Wire.beginTransmission（DS1307_I2C_ADDRESS）; Wire.write（regNo）; Wire.endTransmission（）; Wire.requestFrom（DS1307_I2C_ADDRESS、1）; return Wire.read（）;} void RealTimeClockDS1307 ::readData（byte regNo、void * dest、int length）{char * p =（char *）dest; if（regNo> 0x3F ||長さ> 0x3F）{return; } Wire.beginTransmission（DS1307_I2C_ADDRESS）; Wire.write（regNo）; Wire.endTransmission（）; Wire.requestFrom（DS1307_I2C_ADDRESS、長さ）; for（int i =0; i  3）{return; } //ビット4は有効（0x10）; //無効にした場合、ビット7は現在の出力状態です_reg7_sqw =_reg7_sqw＆0x80 | 0x10 |周波数; writeData（0x07、_reg7_sqw）;} void RealTimeClockDS1307 ::sqwDisable（boolean outputLevel）{//ビット70x80出力+ビット40x10両方をゼロに有効にします。//ブール値をビット7にシフトしたOR_reg7_sqw =_reg7_sqw＆〜 0x90 | （outputLevel <<7）; writeData（0x07、_reg7_sqw）; //注：データシートによると、「OUT（出力制御）：このビットは//方形波出力が無効な場合のSQW / OUTピンの出力レベルを制御します。//出力が無効です。SQWE=0の場合、 // SQW / OUTピンはOUT =1の場合は1、OUT =0の場合は0です。」 // "SQW / OUTピンはオープンドレインであり、//外部プルアップ抵抗が必要です。" // Sparkfunブレークアウトボードでは、// BOB-00099、抵抗を介してSQWピンに接続されたLEDが// Vcc + 5Vに接続され、OUT =0の場合は点灯し、OUT =1の場合は暗くなります。 /それがオープンドレインであることを思い出すまで、私が期待していたものの反対です（必要に応じてグーグルで検索してください）。基本的に、それらは//グランド（ドレイン）への//高いまたは低い*インピーダンス*を意味するので、//論理レベル（たとえば、+ 3.3V rel Gnd）を意味しません。つまり、Highは基本的に//オープンスイッチです。 Lowはグランドに接続します。} / *****ゲッター****** / boolean RealTimeClockDS1307 ::is12hour（）{// 12時間モードでは、時間レジスタのビット6が高リターンに設定されます（（_reg2_hour＆0x40） ==0x40）;} boolean RealTimeClockDS1307 ::isPM（）{// 12時間モードの場合、ただし5時間レジスタはPMを示しますif（is12hour（））{return（（_ reg2_hour＆0x20）==0x20）; } //それ以外の場合は、時間> 11の任意の時間をPMと見なします：return（getHours（）> 11）;} boolean RealTimeClockDS1307 ::isStopped（）{//秒レジスタのビット7は、高リターン時にクロックを停止します（（_reg0_sec＆0x80）==0x80）;} int RealTimeClockDS1307 ::getHours（）{if（is12hour（））{//ビット5を含めない、am / pmインジケーターreturnbcdToDec（_reg2_hour＆0x1f）; } //ビット4〜5は数十時間return bcdToDec（_reg2_hour＆0x3f）;} int RealTimeClockDS1307 ::getMinutes（）{// 0x7fでマスクできますが、bcdToDec（_reg1_min）;} intRealTimeClockDS1307を返す必要はありません。 ：getSeconds（）{//オシレーターの開始/停止ビット7をマスクする必要があるreturn bcdToDec（_reg0_sec＆0x7f）;} int RealTimeClockDS1307 ::getYear（）{return bcdToDec（_reg6_year）;} int RealTimeClockDS1307 ::getMonth（）{// 0x1fでマスクできますが、bcdToDec（_reg5_month）;} int RealTimeClockDS1307 ::getDate（）{// 0x3fでマスクできますが、bcdToDec（_reg4_date）;} int RealTimeClockDS1307 ::getDay（）を返す必要はありません。 ）{return getDate（）;} int RealTimeClockDS1307 ::getDayOfWeek（）{// 0x07でマスクできますが、bcdToDec（_reg3_day）;} void RealTimeClockDS1307 ::getFormatted（char * buffer）{int i =0を返す必要はありません; //ターゲット文字列形式：YY-MM-DD HH：II：SS buffer [i ++] =highNybbleToASCII（_reg6_year）; buffer [i ++] =lowNybbleToASCII（_reg6_year）; buffer [i ++] ='-'; buffer [i ++] =highNybbleToASCII（_reg5_month＆0x1f）; buffer [i ++] =lowNybbleToASCII（_reg5_month）; buffer [i ++] ='-'; buffer [i ++] =highNybbleToASCII（_reg4_date＆0x3f）; buffer [i ++] =lowNybbleToASCII（_reg4_date）; buffer [i ++] =''; if（is12hour（））{buffer [i ++] =highNybbleToASCII（_reg2_hour＆0x1f）; } else {buffer [i ++] =highNybbleToASCII（_reg2_hour＆0x3f）; } buffer [i ++] =lowNybbleToASCII（_reg2_hour）; buffer [i ++] ='：'; buffer [i ++] =highNybbleToASCII（_reg1_min＆0x7f）; buffer [i ++] =lowNybbleToASCII（_reg1_min）; buffer [i ++] ='：'; buffer [i ++] =highNybbleToASCII（_reg0_sec＆0x7f）; buffer [i ++] =lowNybbleToASCII（_reg0_sec）; if（is12hour（））{if（isPM（））{buffer [i ++] ='P'; } else {buffer [i ++] ='A'; }} buffer [i ++] =0x00;} void RealTimeClockDS1307 ::getFormatted2k（char * buffer）{buffer [0] ='2'; buffer [1] ='0'; getFormatted（＆buffer [2]）;} / **** SETTERS ***** / void RealTimeClockDS1307 ::setSeconds（int s）{if（s <60 &&s> =0）{//オシレータービットを保持する必要がある_reg0_sec =decToBcd（s）| （_reg0_sec＆0x80）; }} void RealTimeClockDS1307 ::setMinutes（int m）{if（m <60 &&m> =0）{_ reg1_min =decToBcd（m）; }} void RealTimeClockDS1307 ::setHours（int h）{if（is12hour（））{if（h> =1 &&h <=12）{// 12/24およびAM / PMビットを保持_reg2_hour =decToBcd（h）| （_reg2_hour＆0x60）; }} else {if（h> =0 &&h <=24）{// 12/24ビットを保持_reg2_hour =decToBcd（h）| （_reg2_hour＆0x40）; }} // else} // setHoursvoid RealTimeClockDS1307 ::set24h（）{// "時間レジスタのビット6は、//" 12時間または24時間モード選択ビットとして定義されます。 // "ハイの場合、12時間モードが選択されます" //したがって、現在の値をマスクして、そのビットをオフにする補数を使用します。_reg2_hour=_reg2_hour＆〜0x40; } void RealTimeClockDS1307 ::setAM（）{// "12時間モードでは、ビット5はAM / PMビットであり、ロジックハイはPMです" //したがって、12時間モードを設定するには0x40とORする必要があります。 //補数でマスキングしてPMビットをオフにします_reg2_hour =_reg2_hour＆〜0x20 | 0x40;} void RealTimeClockDS1307 ::setPM（）{// "12時間モードでは、ビット5はAM / PMビットであり、ロジックハイはPMです" //したがって、12を設定するには0x40および0x20とORする必要があります-時間モードおよび// PMビットをオンにします：_reg2_hour =_reg2_hour | 0x60;} void RealTimeClockDS1307 ::switchTo12h（）{if（is12hour（））{return; } int h =getHours（）; if（h <12）{setAM（）; } else {h =h-12; setPM（）; } if（h ==0）{h =12; } setHours（h）;} void RealTimeClockDS1307 ::switchTo24h（）{if（！is12hour（））{return; } int h =getHours（）; if（h ==12）{// 12PMはちょうど12です。午前12時は0時間です。 h =0; } if（isPM（））{//午後12時の場合、上記のh =0であるため、12に戻ります。h=h + 12; } set24h（）; setHours（h）;} void RealTimeClockDS1307 ::setDayOfWeek（int d）{if（d> 0 &&d <8）{_ reg3_day =decToBcd（d）; }} void RealTimeClockDS1307 ::setDate（int d）{if（d> 0 &&d <32）{_ reg4_date =decToBcd（d）; }} void RealTimeClockDS1307 ::setDay（int d）{setDate（d）;} void RealTimeClockDS1307 ::setMonth（int m）{if（m> 0 &&m <13）{_ reg5_month =decToBcd（m）; }} void RealTimeClockDS1307 ::setYear（int y）{if（y> =0 &&y <100）{_ reg6_year =decToBcd（y）; }} / ******************************************プライベートメソッド*** ************************************** / byte RealTimeClockDS1307 ::decToBcd（byte b）{return （（（b / 10）<<4）+（b％10））;} //バイナリコード化された10進数を通常の10進数に変換するbyteRealTimeClockDS1307 ::bcdToDec（byte b）{return（（（b>> 4）* 10 ）+（b％16））;} char RealTimeClockDS1307 ::lowNybbleToASCII（byte b）{b =b＆0x0f; if（b <10）{// 0はASCII48 return 48 + b; } // AはASCII55 return 55 + b;} char RealTimeClockDS1307 ::highNybbleToASCII（byte b）{return lowNybbleToASCII（b>> 4）;} / ***** INSTANCE ******* / RealTimeClockDS1307 RTC =RealTimeClockDS1307（）; 

Readme Clojure

さらに別のDS1307ライブラリを作成する目的は、チップから必要な他の機能、特に方形波出力とバッテリに簡単にアクセスできるようにすることでした。 backedRAM。## Documentation @todo主に `RealTimeClockDS1307.h` ##のコメント例（/ examplesフォルダー内）-`RealTimeClockDS1307_Test.pde`を使用すると、クロックのオン/オフ、日付/時刻の設定、12 / 24hの設定が可能です。 、[非]方形波をアクティブにし、シリアルモニターからメモリの読み取り/書き込みを行います。-`RealTimeClockDS1307.fz`は、SparkfunRTCモジュールのArduinoへの基本的な接続を示すFritzingブレッドボードレイアウトです。オプションの抵抗+ LEDを含めて、方形波を表示します（ドレインが開いているため、ピン13とはかなり異なる方法で接続することに注意してください）。## Changelog #####バージョン0.95 *の名前の変更を逆にgetDate（）およびsetDate（）、現在getDay（）はgetDate（）を呼び出し、setDay（）はsetDate（）を呼び出しています* Readmeの改善#####バージョン0.94 * getDate（）をgetDay（）およびsetDate（）に変更しましたsetDay（）*更新されたkeywords.txt *更新されたexample #####バージョン0.93 *構文の強調表示のためにkeywords.txtを追加しました#####バージョン0.92RC * Arduino1.00用に更新されました。 Andreas Giemza（hurik）によるテスト#####バージョン0.91 *マルチバイト読み取り/書き込みを追加#####バージョン0.9RC *初期リリース##将来-Webページのドキュメント##クレジットJohnWatersとMauriceRibbleに感謝します彼らの初期の非常に有益な仕事のために（私が彼らのコードのどれも使用していなかったとしても）：-[http://combustory.com/wiki/index.php/RTC1307_-_Real_Time_Clock]（http://combustory.com/ wiki / index.php / RTC1307 _-_ Real_Time_Clock）-[http://www.glacialwanderer.com/hobbyrobotics/?p=12]（http://www.glacialwanderer.com/hobbyrobotics/?p=12）## CopyrightRealTimeClockDS1307 -DS1307 RTCモジュールを制御するライブラリCopyright（c）2011 David H.Brown。 All rights reserved ##ライセンスこのライブラリは無料のソフトウェアです。フリーソフトウェアファウンデーションによって公開されているGNULesser General Public Licenseの条件の下で、再配布および/または変更することができます。ライセンスのバージョン2.1、または（オプションで）それ以降のバージョン。このライブラリは、役立つことを期待して配布されていますが、いかなる保証もありません。商品性または特定目的への適合性の黙示の保証もありません。詳細については、GNU劣等一般公衆利用許諾契約書を参照してください。このライブラリと一緒にGNU劣等一般公衆利用許諾契約書のコピーを受け取っているはずです。そうでない場合は、Free Software Foundation、Inc.、51 Franklin St、Fifth Floor、Boston、MA 02110-1301 USA 

RealTimeClockDS1307.h C / C ++

 / * RealTimeClockDS1307-DS1307 RTCモジュールを制御するライブラリCopyright（c）2011 DavidH.Brown。Allrightsreserved v0.92 Arduino1.00用に更新。以前のバージョンでは再テストされていません。JohnWatersに感謝します。とMauriceRibbleは、以前の非常に役立つ作業をしてくれました（コードを使用していなくても）：-http：//combustory.com/wiki/index.php/RTC1307_-_Real_Time_Clock-http：// www .glacialwanderer.com / hobbyrobotics /？p =12このライブラリは無料のソフトウェアです。FreeSoftwareFoundationによって公開されているGNULesser General PublicLicenseの条件の下で再配布および/または変更できます。ライセンスのバージョン2.1のいずれかです。 、または（オプションで）それ以降のバージョン。このライブラリは、使用されることを期待して配布されます。 ul、ただし保証はありません。商品性または特定目的への適合性の黙示の保証もありません。詳細については、GNU劣等一般公衆利用許諾契約書を参照してください。このライブラリと一緒にGNU劣等一般公衆利用許諾契約書のコピーを受け取っているはずです。そうでない場合は、Free Software Foundation、Inc.、51 Franklin St、Fifth Floor、Boston、MA 02110-1301 USA * /＃ifndef RealTimeClockDS1307_h＃define RealTimeClockDS1307_h #if defined（ARDUINO）&&ARDUINO> =100 #include "Arduino .h "#else #include" WProgram.h "＃endif //＃include  //＃include  // Arduinoで使用される 'boolean'および 'byte'タイプが必要/必要// #undef roundは、math.h // see：http：//www.arduino.cc/cgi-bin/yabb2/YaBBのコンパイル時//「expectedunqualified-id before'double '」エラーを回避するために必要です。 pl？num =1247924528/3＃undef round #include  #define ARDUINO_PIN_T uint8_tclass RealTimeClockDS1307 {private：byte _reg0_sec;バイト_reg1_min;バイト_reg2_hour;バイト_reg3_day;バイト_reg4_date;バイト_reg5_month;バイト_reg6_year;バイト_reg7_sqw;バイトdecToBcd（バイト）;バイトbcdToDec（バイト）; char lowNybbleToASCII（byte）; char highNybbleToASCII（byte）; public：RealTimeClockDS1307（）; void readClock（）; //レジスタ（sqwを含む）をローカルストアに読み取りますvoid setClock（）; //ローカルストアからクロックレジスタを更新しますvoidstop（）; //即時; setClock（）;は必要ありません。 void start（）; //即時; setClock（）;は必要ありません。 void sqwEnable（byte）; //指定された周波数で方形波を有効にするvoidsqwDisable（boolean）; //方形波を無効にし、出力を高または低に設定void writeData（byte、byte）; //単一の値をレジスタvoidwriteData（byte、void *、int）; //複数の値を連続して書き込むbytereadData（byte）; //レジスタから単一の値を読み取るvoidreadData（byte、void *、int）; //複数の値を読み取るバッファにintgetHours（）; int getMinutes（）; int getSeconds（）; int getYear（）; int getMonth（）; int getDate（）; int getDay（）; int getDayOfWeek（）;ブールis12hour（）;ブールisPM（）;ブールisStopped（）; // getFormattedは、指定されたchar配列に書き込みます。形式は次のとおりです。//YY-MM-DDHH：II：SS ...プラス「A」または「P」（12時間モードの場合）//そしてもちろんNULLターミネータ。したがって、[18]は24時間、[19]は12時間void getFormatted（char *）; //上記のコメントを参照voidgetFormatted2k（char *）; // getFormattedとして、ただし「20」を前に付けて// setClock（ ）これらのいずれかの後//次のreadClock（）の前。 //無効な日付は時計によって修正されないことに注意してください。時計が知っているのは、//同じ月の次の日付ではなく、次の月にロールオーバーするタイミングだけです。 void setSeconds（int）; void setMinutes（int）; // setHoursは、現在の12/24モードの範囲外の値を拒否しますvoid setHours（int）; void setAM（）; //時間を考慮しません; switchTo24（）を参照してください。voidsetPM（）; //時間を考慮しません。 switchTo24（）を参照してください。voidset24h（）; //時間を考慮しません。 switchTo24（）を参照void switchTo24h（）; //すでに24時間の場合はすぐに戻るvoidswitchTo12h（）; //すでに12時間の場合はすぐに戻るvoidsetDayOfWeek（int）; //深夜にインクリメント;日付で設定されない（固定の意味はありません）void setDate（int）; // *すべての*月に1-31を許可します。 void setDay（int）; void setMonth（int）; void setYear（int）; //方形波周波数：静的定数バイトSQW_1Hz =0x00; static const byte SQW_4kHz =0x01; //実際には4.096kHzstatic const byte SQW_8kHz =0x02; //実際には8.192kHzstatic const byte SQW_32kHz =0x03; //実際には32.768kHz}; extern RealTimeClockDS1307 RTC; #endif 

別のファイル C / C ++

 ###################################### ####構文カラーマップRealTimeClockDS1307 ########################################## #######################################インスタンス（KEYWORD2）####### ################################ RTC KEYWORD2 ################ ##########################メソッドと関数（KEYWORD2）################## ####################### readClock KEYWORD2setClock KEYWORD2stop KEYWORD2start KEYWORD2sqwEnable KEYWORD2sqwDisable KEYWORD2writeData KEYWORD2readData KEYWORD2getHours KEYWORD2getMinutes KEYWORD2getSeconds KEYWORD2getYear KEYWORD2getMonth KEYWORD2getDate KEYWORD2getDay KEYWORD2getDayOfWeek KEYWORD2is12hour KEYWORD2isPM KEYWORD2isStopped KEYWORD2getFormatted KEYWORD2getFormatted2k KEYWORD2setSeconds KEYWORD2setMinutes KEYWORD2setHours KEYWORD2setAM KEYWORD2setPM KEYWORD2set24h KEYWORD2switchTo24h KEYWORD2switchTo12h KEYWORD2setDayOfWeek KEYWORD2setDate KEYWORD2setDay KEYWORD2setMonth KEYWORD2setYear KEYWORD2 ########## ################################定数（LITERAL1）############## ########################### SQW_1Hz LITERAL1SQW_4kHz LITERAL1SQW_8kHz LITERAL1SQW_32kHz LITERAL1 

RTClibファイル C＃

 ################################# #########構文カラーマップRealTimeClockDS1307 ###################################### ############################################インスタンス（KEYWORD2）## ##################################### RTC KEYWORD2 ########### ###############################メソッドと関数（KEYWORD2）############## ############################ readClock KEYWORD2setClock KEYWORD2stop KEYWORD2start KEYWORD2sqwEnable KEYWORD2sqwDisable KEYWORD2writeData KEYWORD2readData KEYWORD2getHours KEYWORD2getMinutes KEYWORD2getSeconds KEYWORD2getYear KEYWORD2getMonth KEYWORD2getDate KEYWORD2getDay KEYWORD2getDayOfWeek KEYWORD2is12hour KEYWORD2isPM KEYWORD2isStopped KEYWORD2getFormatted KEYWORD2getFormatted2k KEYWORD2setSeconds KEYWORD2setMinutes KEYWORD2setHours KEYWORD2setAM KEYWORD2setPM KEYWORD2set24h KEYWORD2switchTo24h KEYWORD2switchTo12h KEYWORD2setDayOfWeek KEYWORD2setDate KEYWORD2setDay KEYWORD2setMonth KEYWORD2setYe ar KEYWORD2 ##########################################定数（LITERAL1）## ####################################### SQW_1Hz LITERAL1SQW_4kHz LITERAL1SQW_8kHz LITERAL1SQW_32kHz LITERAL1 

library.properties（name） C / C ++

さらに別のDS1307ライブラリを作成する私の目標は、チップから必要な他の機能、特に方形波出力とバッテリバックアップRAMに簡単にアクセスできるようにすることでした。## Documentation @ todo主に `RealTimeClockDS1307.h` ##のコメント例（/ examplesフォルダー内）-`RealTimeClockDS1307_Test.pde`を使用すると、クロックのオン/オフ、日付/時刻の設定、12 / 24hの設定、方形波の[非アクティブ化]を有効にできます。 、シリアルモニターからの読み取り/書き込みメモリ。-`RealTimeClockDS1307.fz`は、SparkfunRTCモジュールのArduinoへの基本的な接続を示すFritzingブレッドボードレイアウトです。オプションの抵抗+ LEDを含めて、方形波を表示します（ドレインが開いているため、ピン13とはかなり異なる方法で接続することに注意してください）。## Changelog #####バージョン0.95 *の名前の変更を逆にgetDate（）およびsetDate（）、現在getDay（）はgetDate（）を呼び出し、setDay（）はsetDate（）を呼び出しています* Readmeの改善#####バージョン0.94 * getDate（）をgetDay（）およびsetDate（）に変更しましたsetDay（）*更新されたkeywords.txt *更新されたexample #####バージョン0.93 *構文の強調表示のためにkeywords.txtを追加しました#####バージョン0.92RC * Arduino1.00用に更新されました。 Andreas Giemza（hurik）によるテスト#####バージョン0.91 *マルチバイト読み取り/書き込みを追加#####バージョン0.9RC *初期リリース##将来-Webページのドキュメント##クレジットJohnWatersとMauriceRibbleに感謝します彼らの初期の非常に有益な仕事のために（私が彼らのコードのどれも使用していなかったとしても）：-[http://combustory.com/wiki/index.php/RTC1307_-_Real_Time_Clock]（http://combustory.com/ wiki / index.php / RTC1307 _-_ Real_Time_Clock）-[http://www.glacialwanderer.com/hobbyrobotics/?p=12]（http://www.glacialwanderer.com/hobbyrobotics/?p=12）## CopyrightRealTimeClockDS1307 -DS1307 RTCモジュールを制御するライブラリCopyright（c）2011 David H.Brown。 All rights reserved ##ライセンスこのライブラリは無料のソフトウェアです。フリーソフトウェアファウンデーションによって公開されているGNULesser General Public Licenseの条件の下で、再配布および/または変更することができます。ライセンスのバージョン2.1、または（オプションで）それ以降のバージョン。このライブラリは、役立つことを期待して配布されていますが、いかなる保証もありません。商品性または特定目的への適合性の黙示の保証もありません。詳細については、GNU劣等一般公衆利用許諾契約書を参照してください。このライブラリと一緒にGNU劣等一般公衆利用許諾契約書のコピーを受け取っているはずです。そうでない場合は、Free Software Foundation、Inc.、51 Franklin St、Fifth Floor、Boston、MA 02110-1301 USA 

RTClib C / C ++

 / * RealTimeClockDS1307-DS1307RTCモジュールを制御するライブラリCopyright（c）2011 David H.Brown。 All rights reserved v0.92 Arduino1.00用に更新。以前のバージョンでは再テストされていませんJohnWatersとMauriceRibbleの以前の非常に役立つ作業に感謝します（コードを使用しなかった場合でも）：-http：//combustory.com/wiki/index .php / RTC1307 _-_ Real_Time_Clock-http：//www.glacialwanderer.com/hobbyrobotics/？p =12このライブラリはフリーソフトウェアです。フリーソフトウェアファウンデーションによって公開されているGNULesser General Public Licenseの条件の下で、再配布および/または変更することができます。ライセンスのバージョン2.1、または（オプションで）それ以降のバージョン。このライブラリは、役立つことを期待して配布されていますが、いかなる保証もありません。商品性または特定目的への適合性の黙示の保証もありません。詳細については、GNU劣等一般公衆利用許諾契約書を参照してください。このライブラリと一緒にGNU劣等一般公衆利用許諾契約書のコピーを受け取っているはずです。そうでない場合は、Free Software Foundation、Inc.、51 Franklin St、Fifth Floor、Boston、MA 02110-1301 USA * / / ******************** ************************************************** *********含まれています**************************************** ************************************** /＃include "RealTimeClockDS1307.h" #include  / ********************************************** *********************************定義**************** ************************************************** ************ /＃define DS1307_I2C_ADDRESS 0x68 //これはI2Cアドレスです/ ************************* ************************************************** ****コンストラクター********************************************* ********************************* / RealTimeClockDS1307 ::RealTimeClockDS1307（）{Wire.begin（）; //must NOT attempt to read the clock before //Wire.begin() has not been called; readClock（）がハングします。 //Fortunately, it seems that you can call Wire.begin() //multiple times with no adverse effect).} /****************************************************************************** * User API ******************************************************************************//***** CHIP READ/WRITE ******/void RealTimeClockDS1307::readClock(){ // Reset the register pointer Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write（（uint8_t）0x00）; Wire.endTransmission（）; Wire.requestFrom（DS1307_I2C_ADDRESS、8）; _reg0_sec =Wire.read（）; _reg1_min =Wire.read（）; _reg2_hour =Wire.read（）; _reg3_day =Wire.read（）; _reg4_date =Wire.read（）; _reg5_month =Wire.read（）; _reg6_year =Wire.read（）; _reg7_sqw =Wire.read();}void RealTimeClockDS1307::setClock(){ //to be paranoid, we're going to first stop the clock //to ensure we don't have rollovers while we're //writing:writeData(0,0x80); //now, we'll write everything *except* the second Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write（（uint8_t）0x01）; Wire.write（_reg1_min）; Wire.write（_reg2_hour）; Wire.write（_reg3_day）; Wire.write（_reg4_date）; Wire.write（_reg5_month）; Wire.write（_reg6_year）; Wire.endTransmission（）; //ここで、秒を記述します。 we didn't have to keep //track of whether the clock was already running, because //_reg0_sec already knows what we want it to be. This //will restart the clock as it writes the new seconds value. writeData（0、_reg0_sec）; }void RealTimeClockDS1307::stop(){ //"Bit 7 of register 0 is the clock halt (CH) bit. //When this bit is set to a 1, the oscillator is disabled." _reg0_sec =_reg0_sec | 0x80; writeData(0,_reg0_sec);}void RealTimeClockDS1307::start(){ //"Bit 7 of register 0 is the clock halt (CH) bit. //When this bit is set to a 1, the oscillator is disabled." _reg0_sec =_reg0_sec＆〜0x80; writeData(0,_reg0_sec);}void RealTimeClockDS1307::writeData(byte regNo, byte value){ if(regNo> 0x3F) { return; } Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write（regNo）; Wire.write（value）; Wire.endTransmission();}void RealTimeClockDS1307::writeData(byte regNo, void * source, int length){ char * p =(char*) source; if（regNo> 0x3F ||長さ> 0x3F）{return; } Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write（regNo）; for(int i=0; i 0x3F) { return 0xff; } Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write（regNo）; Wire.endTransmission（）; Wire.requestFrom（DS1307_I2C_ADDRESS、1）; return Wire.read();}void RealTimeClockDS1307::readData(byte regNo, void * dest, int length){ char * p =(char*) dest; if（regNo> 0x3F ||長さ> 0x3F）{return; } Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write（regNo）; Wire.endTransmission（）; Wire.requestFrom（DS1307_I2C_ADDRESS、長さ）; for(int i=0; i 3) { return; } //bit 4 is enable (0x10); //bit 7 is current output state if disabled _reg7_sqw =_reg7_sqw &0x80 | 0x10 |周波数; writeData(0x07, _reg7_sqw);}void RealTimeClockDS1307::sqwDisable(boolean outputLevel){ //bit 7 0x80 output + bit 4 0x10 enable both to zero, //the OR with the boolean shifted up to bit 7 _reg7_sqw =_reg7_sqw &~0x90 | （outputLevel <<7）; writeData（0x07、_reg7_sqw）; //note:per the data sheet, "OUT (Output control):This bit controls //the output level of the SQW/OUT pin when the square wave //output is disabled. If SQWE =0, the logic level on the //SQW/OUT pin is 1 if OUT =1 and is 0 if OUT =0." //"The SQW/OUT pin is open drain and requires an external //pull-up resistor." //It is worth mentioning that on the Sparkfun breakout board, //BOB-00099, a LED connected to the SQW pin through a resistor to //Vcc+5V illuminated when OUT=0 and was dark when OUT=1, the //opposite of what I expected until I remembered that it is //an open drain (google it if you need to). Basically, they don't //so much mean a logic level (e.g., +3.3V rel Gnd) as they mean //high or low *impeadance* to ground (drain). So High is basically //an open switch. Low connects to ground.}/***** GETTERS ******/boolean RealTimeClockDS1307::is12hour() { //12-hour mode has bit 6 of the hour register set high return ((_reg2_hour &0x40) ==0x40);}boolean RealTimeClockDS1307::isPM(){ //if in 12-hour mode, but 5 of the hour register indicates PM if(is12hour()) { return ((_reg2_hour &0x20) ==0x20); } //otherwise, let's consider any time with the hour>11 to be PM:return (getHours()> 11);}boolean RealTimeClockDS1307::isStopped(){ //bit 7 of the seconds register stopps the clock when high return ((_reg0_sec &0x80) ==0x80);}int RealTimeClockDS1307::getHours(){ if(is12hour()) { //do not include bit 5, the am/pm indicator return bcdToDec(_reg2_hour &0x1f); } //bits 4-5 are tens of hours return bcdToDec(_reg2_hour &0x3f);}int RealTimeClockDS1307::getMinutes(){ //could mask with 0x7f but shouldn't need to return bcdToDec(_reg1_min);}int RealTimeClockDS1307::getSeconds(){ //need to mask oscillator start/stop bit 7 return bcdToDec(_reg0_sec &0x7f);}int RealTimeClockDS1307::getYear(){ return bcdToDec(_reg6_year);}int RealTimeClockDS1307::getMonth(){ //could mask with 0x1f but shouldn't need to return bcdToDec(_reg5_month);}int RealTimeClockDS1307::getDate(){ //could mask with 0x3f but shouldn't need to return bcdToDec(_reg4_date);}int RealTimeClockDS1307::getDay(){ return getDate();}int RealTimeClockDS1307::getDayOfWeek(){ //could mask with 0x07 but shouldn't need to return bcdToDec(_reg3_day);}void RealTimeClockDS1307::getFormatted(char * buffer){ int i=0; //target string format:YY-MM-DD HH:II:SS buffer[i++]=highNybbleToASCII(_reg6_year); buffer [i ++] =lowNybbleToASCII（_reg6_year）; buffer [i ++] ='-'; buffer [i ++] =highNybbleToASCII（_reg5_month＆0x1f）; buffer [i ++] =lowNybbleToASCII（_reg5_month）; buffer [i ++] ='-'; buffer [i ++] =highNybbleToASCII（_reg4_date＆0x3f）; buffer [i ++] =lowNybbleToASCII（_reg4_date）; buffer [i ++] =''; if(is12hour()) { buffer[i++]=highNybbleToASCII(_reg2_hour &0x1f); } else { buffer[i++]=highNybbleToASCII(_reg2_hour &0x3f); } buffer[i++]=lowNybbleToASCII(_reg2_hour); buffer [i ++] ='：'; buffer [i ++] =highNybbleToASCII（_reg1_min＆0x7f）; buffer [i ++] =lowNybbleToASCII（_reg1_min）; buffer [i ++] ='：'; buffer [i ++] =highNybbleToASCII（_reg0_sec＆0x7f）; buffer [i ++] =lowNybbleToASCII（_reg0_sec）; if(is12hour()) { if(isPM()) { buffer[i++]='P'; } else { buffer[i++]='A'; } } buffer[i++]=0x00;}void RealTimeClockDS1307::getFormatted2k(char * buffer){ buffer[0]='2'; buffer [1] ='0'; getFormatted(&buffer[2]);}/**** SETTERS *****/void RealTimeClockDS1307::setSeconds(int s){ if (s <60 &&s>=0) { //need to preserve oscillator bit _reg0_sec =decToBcd(s) | (_reg0_sec &0x80); }}void RealTimeClockDS1307::setMinutes(int m){ if (m <60 &&m>=0) { _reg1_min =decToBcd(m); }}void RealTimeClockDS1307::setHours(int h){ if (is12hour()) { if (h>=1 &&h <=12) { //preserve 12/24 and AM/PM bits _reg2_hour =decToBcd(h) | (_reg2_hour &0x60); } } else { if (h>=0 &&h <=24) { //preserve 12/24 bit _reg2_hour =decToBcd(h) | (_reg2_hour &0x40); } }//else}//setHoursvoid RealTimeClockDS1307::set24h(){ //"Bit 6 of the hours register is defined as the //"12- or 24-hour mode select bit. //"When high, the 12-hour mode is selected" //So, mask the curent value with the complement turn off that bit:_reg2_hour =_reg2_hour &~0x40; }void RealTimeClockDS1307::setAM(){ //"In the 12-hour mode, bit 5 is the AM/PM bit with logic high being PM" //so we need to OR with 0x40 to set 12-hour mode and also //turn off the PM bit by masking with the complement _reg2_hour =_reg2_hour &~0x20 | 0x40;}void RealTimeClockDS1307::setPM(){ //"In the 12-hour mode, bit 5 is the AM/PM bit with logic high being PM" //so we need to OR with 0x40 and 0x20 to set 12-hour mode and also //turn on the PM bit:_reg2_hour =_reg2_hour | 0x60;}void RealTimeClockDS1307::switchTo12h(){ if(is12hour()) { return; } int h =getHours(); if (h <12) { setAM(); } else { h =h-12; setPM(); } if (h==0) { h=12; } setHours(h);}void RealTimeClockDS1307::switchTo24h(){ if(!is12hour()) { return; } int h =getHours(); if(h==12) {//12 PM is just 12; 12 AM is 0 hours. h =0; } if (isPM()) {//if it was 12 PM, then h=0 above and so we're back to 12:h =h+12; } set24h(); setHours(h);}void RealTimeClockDS1307::setDayOfWeek(int d){ if (d> 0 &&d <8) { _reg3_day =decToBcd(d); }}void RealTimeClockDS1307::setDate(int d){ if (d> 0 &&d <32) { _reg4_date =decToBcd(d); }}void RealTimeClockDS1307::setDay(int d){ setDate(d);}void RealTimeClockDS1307::setMonth(int m){ if (m> 0 &&m <13) { _reg5_month =decToBcd(m); }}void RealTimeClockDS1307::setYear(int y){ if (y>=0 &&y <100) { _reg6_year =decToBcd(y); }}/***************************************** * Private methods *****************************************/byte RealTimeClockDS1307::decToBcd(byte b){ return ( ((b/10) <<4) + (b%10) );}// Convert binary coded decimal to normal decimal numbersbyte RealTimeClockDS1307::bcdToDec(byte b){ return ( ((b>> 4)*10) + (b%16) );}char RealTimeClockDS1307::lowNybbleToASCII(byte b) { b =b &0x0f; if(b <10) { //0 is ASCII 48 return 48+b; } //A is ASCII 55 return 55+b;}char RealTimeClockDS1307::highNybbleToASCII(byte b){ return lowNybbleToASCII(b>> 4);}/***** INSTANCE *******/RealTimeClockDS1307 RTC =RealTimeClockDS1307();

RTClibC/C++

/* RealTimeClockDS1307 - library to control a DS1307 RTC module Copyright (c) 2011 David H. Brown. All rights reserved v0.92 Updated for Arduino 1.00; not re-tested on earlier versions Much thanks to John Waters and Maurice Ribble for their earlier and very helpful work (even if I didn't wind up using any of their code):- http://combustory.com/wiki/index.php/RTC1307_-_Real_Time_Clock - http://www.glacialwanderer.com/hobbyrobotics/?p=12 This library is free software;フリーソフトウェアファウンデーションによって公開されているGNULesser General Public Licenseの条件の下で、再配布および/または変更することができます。ライセンスのバージョン2.1、または（オプションで）それ以降のバージョン。このライブラリは、役立つことを期待して配布されていますが、いかなる保証もありません。商品性または特定目的への適合性の黙示の保証もありません。詳細については、GNU劣等一般公衆利用許諾契約書を参照してください。このライブラリと一緒にGNU劣等一般公衆利用許諾契約書のコピーを受け取っているはずです。 if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA*/#ifndef RealTimeClockDS1307_h#define RealTimeClockDS1307_h #if defined(ARDUINO) &&ARDUINO>=100 #include "Arduino.h" #else #include "WProgram.h" #endif//#include //#include  //need/want 'boolean' and 'byte' types used by Arduino//#undef round is required to avoid a compile-time//"expected unqualified-id before 'double'" error in math.h//see:http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1247924528/3#undef round #include #define ARDUINO_PIN_T uint8_tclass RealTimeClockDS1307{ private:byte _reg0_sec; byte _reg1_min; byte _reg2_hour; byte _reg3_day; byte _reg4_date; byte _reg5_month; byte _reg6_year; byte _reg7_sqw; byte decToBcd(byte); byte bcdToDec(byte); char lowNybbleToASCII(byte); char highNybbleToASCII(byte); public:RealTimeClockDS1307(); void readClock();//read registers (incl sqw) to local store void setClock();//update clock registers from local store void stop();//immediate; does not require setClock(); void start();//immediate; does not require setClock(); void sqwEnable(byte);//enable the square wave with the specified frequency void sqwDisable(boolean);//disable the square wave, setting output either high or low void writeData(byte, byte);//write a single value to a register void writeData(byte, void *, int);//write several values consecutively byte readData(byte);//read a single value from a register void readData(byte, void *, int);//read several values into a buffer int getHours(); int getMinutes(); int getSeconds(); int getYear(); int getMonth(); int getDate(); int getDay(); int getDayOfWeek(); boolean is12hour(); boolean isPM(); boolean isStopped(); //getFormatted writes into a char array provided by you. Format is:// YY-MM-DD HH:II:SS ... plus "A" or "P" if in 12-hour mode //and of course a NULL terminator. So, [18] for 24h or [19] for 12h void getFormatted(char *);//see comment above void getFormatted2k(char *);//as getFormatted, but with "20" prepended //must also call setClock() after any of these //before next readClock(). Note that invalid dates are not //corrected by the clock. All the clock knows is when it should //roll over to the next month rather than the next date in the same month. void setSeconds(int); void setMinutes(int); //setHours rejects values out of range for the current 12/24 mode void setHours(int); void setAM();//does not consider hours; see switchTo24() void setPM();//does not consider hours; see switchTo24() void set24h();//does not consider hours; see switchTo24() void switchTo24h();//returns immediately if already 24h void switchTo12h();//returns immediately if already 12h void setDayOfWeek(int);//incremented at midnight; not set by date (no fixed meaning) void setDate(int);//allows 1-31 for *all* months. void setDay(int); void setMonth(int); void setYear(int); //squarewave frequencies:static const byte SQW_1Hz=0x00; static const byte SQW_4kHz=0x01;//actually 4.096kHz static const byte SQW_8kHz=0x02;//actually 8.192kHz static const byte SQW_32kHz=0x03;//actually 32.768kHz};extern RealTimeClockDS1307 RTC;#endif

README.mdC/C++

This is a fork of JeeLab's fantastic real time clock library for Arduino.For details on using this library with an RTC module like the DS1307, see the guide at:https://learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit/overviewTo download. click the DOWNLOADS button to the right, and rename the uncompressed folder RTClib.Place the RTClib folder in your *arduinosketchfolder*/libraries/ folder. You may need to create the libraries subfolder if its your first library. Restart the IDE.## CompatibilityMCU | Tested Works | Doesn't Work | Not Tested | Notes------------------ | :----------:| :----------:| :---------:| -----Atmega328 @ 16MHz | X | | | Atmega328 @ 12MHz | X | | | Atmega32u4 @ 16MHz | X | | | Use SDA/SCL on pins D3 & D2Atmega32u4 @ 8MHz | X | | | Use SDA/SCL on pins D3 & D2ESP8266 | X | | | SDA/SCL default to pins 4 & 5 but any two pins can be assigned as SDA/SCL using Wire.begin(SDA,SCL)Atmega2560 @ 16MHz | X | | | Use SDA/SCL on Pins 20 & 21ATSAM3X8E | X | | | Use SDA1 and SCL1ATSAM21D | X | | | ATtiny85 @ 16MHz | X | | | ATtiny85 @ 8MHz | X | | | Intel Curie @ 32MHz | | | X | STM32F2 | | | X | * ATmega328 @ 16MHz :Arduino UNO, Adafruit Pro Trinket 5V, Adafruit Metro 328, Adafruit Metro Mini * ATmega328 @ 12MHz :Adafruit Pro Trinket 3V * ATmega32u4 @ 16MHz :Arduino Leonardo, Arduino Micro, Arduino Yun, Teensy 2.0 * ATmega32u4 @ 8MHz :Adafruit Flora, Bluefruit Micro * ESP8266 :Adafruit Huzzah * ATmega2560 @ 16MHz :Arduino Mega * ATSAM3X8E :Arduino Due * ATSAM21D :Arduino Zero, M0 Pro * ATtiny85 @ 16MHz :Adafruit Trinket 5V * ATtiny85 @ 8MHz :Adafruit Gemma, Arduino Gemma, Adafruit Trinket 3V

RTClib.cppC/C++

// Code by JeeLabs http://news.jeelabs.org/code/// Released to the public domain! Enjoy!#include #include "RTClib.h"#ifdef __AVR__ #include #elif defined(ESP8266) #include #elif defined(ARDUINO_ARCH_SAMD)// nothing special needed#elif defined(ARDUINO_SAM_DUE) #define PROGMEM #define pgm_read_byte(addr) (*(const unsigned char *)(addr)) #define Wire Wire1#endif#if (ARDUINO>=100) #include  // capital A so it is error prone on case-sensitive filesystems // Macro to deal with the difference in I2C write functions from old and new Arduino versions. #define _I2C_WRITE write #define _I2C_READ read#else #include  #define _I2C_WRITE send #define _I2C_READ receive#endifstatic uint8_t read_i2c_register(uint8_t addr, uint8_t reg) { Wire.beginTransmission(addr); Wire._I2C_WRITE((byte)reg); Wire.endTransmission（）; Wire.requestFrom(addr, (byte)1); return Wire._I2C_READ();}static void write_i2c_register(uint8_t addr, uint8_t reg, uint8_t val) { Wire.beginTransmission(addr); Wire._I2C_WRITE((byte)reg); Wire._I2C_WRITE((byte)val); Wire.endTransmission();}////////////////////////////////////////////////////////////////////////////////// utility code, some of this could be exposed in the DateTime API if neededconst uint8_t daysInMonth [] PROGMEM ={ 31,28,31,30,31,30,31,31,30,31,30,31 };// number of days since 2000/01/01, valid for 2001..2099static uint16_t date2days(uint16_t y, uint8_t m, uint8_t d) { if (y>=2000) y -=2000; uint16_t days =d; for (uint8_t i =1; i  2 &&y % 4 ==0) ++days; return days + 365 * y + (y + 3) / 4 - 1;}static long time2long(uint16_t days, uint8_t h, uint8_t m, uint8_t s) { return ((days * 24L + h) * 60 + m) * 60 + s;}////////////////////////////////////////////////////////////////////////////////// DateTime implementation - ignores time zones and DST changes// NOTE:also ignores leap seconds, see http://en.wikipedia.org/wiki/Leap_secondDateTime::DateTime (uint32_t t) { t -=SECONDS_FROM_1970_TO_2000; // bring to 2000 timestamp from 1970 ss =t % 60; t /=60; mm =t % 60; t /=60; hh =t % 24; uint16_t days =t / 24; uint8_t leap; for (yOff =0;; ++yOff) { leap =yOff % 4 ==0; if (days <365 + leap) break; days -=365 + leap; } for (m =1;; ++m) { uint8_t daysPerMonth =pgm_read_byte(daysInMonth + m - 1); if (leap &&m ==2) ++daysPerMonth; if (days =2000) year -=2000; yOff =year; m =month; d =day; hh =hour; mm =min; ss =sec;}DateTime::DateTime (const DateTime©):yOff(copy.yOff), m(copy.m), d(copy.d), hh(copy.hh), mm(copy.mm), ss(copy.ss){}static uint8_t conv2d(const char* p) { uint8_t v =0; if ('0' <=*p &&*p <='9') v =*p - '0'; return 10 * v + *++p - '0';}// A convenient constructor for using "the compiler's time":// DateTime now (__DATE__, __TIME__);// NOTE:using F() would further reduce the RAM footprint, see below.DateTime::DateTime (const char* date, const char* time) { // sample input:date ="Dec 26 2009", time ="12:34:56" yOff =conv2d(date + 9); // Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec switch (date[0]) { case 'J':m =date[1] =='a' ? 1 :m =date[2] =='n' ? 6 :7;壊す; case 'F':m =2;壊す; case 'A':m =date[2] =='r' ? 4 :8;壊す; case 'M':m =date[2] =='r' ? 3 :5;壊す; case 'S':m =9;壊す; case 'O':m =10;壊す; case 'N':m =11;壊す; case 'D':m =12;壊す; } d =conv2d(date + 4); hh =conv2d(time); mm =conv2d(time + 3); ss =conv2d(time + 6);}// A convenient constructor for using "the compiler's time":// This version will save RAM by using PROGMEM to store it by using the F macro.// DateTime now (F(__DATE__), F(__TIME__));DateTime::DateTime (const __FlashStringHelper* date, const __FlashStringHelper* time) { // sample input:date ="Dec 26 2009", time ="12:34:56" char buff[11]; memcpy_P(buff, date, 11); yOff =conv2d(buff + 9); // Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec switch (buff[0]) { case 'J':m =buff[1] =='a' ? 1 :m =buff[2] =='n' ? 6 :7;壊す; case 'F':m =2;壊す; case 'A':m =buff[2] =='r' ? 4 :8;壊す; case 'M':m =buff[2] =='r' ? 3 :5;壊す; case 'S':m =9;壊す; case 'O':m =10;壊す; case 'N':m =11;壊す; case 'D':m =12;壊す; } d =conv2d(buff + 4); memcpy_P(buff, time, 8); hh =conv2d(buff); mm =conv2d(buff + 3); ss =conv2d(buff + 6);}uint8_t DateTime::dayOfTheWeek() const { uint16_t day =date2days(yOff, m, d); return (day + 6) % 7; // Jan 1, 2000 is a Saturday, i.e. returns 6}uint32_t DateTime::unixtime(void) const { uint32_t t; uint16_t days =date2days(yOff, m, d); t =time2long(days, hh, mm, ss); t +=SECONDS_FROM_1970_TO_2000; // seconds from 1970 to 2000 return t;}long DateTime::secondstime(void) const { long t; uint16_t days =date2days(yOff, m, d); t =time2long(days, hh, mm, ss); return t;}DateTime DateTime::operator+(const TimeSpan&span) { return DateTime(unixtime()+span.totalseconds());}DateTime DateTime::operator-(const TimeSpan&span) { return DateTime(unixtime()-span.totalseconds());}TimeSpan DateTime::operator-(const DateTime&right) { return TimeSpan(unixtime()-right.unixtime());}////////////////////////////////////////////////////////////////////////////////// TimeSpan implementationTimeSpan::TimeSpan (int32_t seconds):_seconds(seconds){}TimeSpan::TimeSpan (int16_t days, int8_t hours, int8_t minutes, int8_t seconds):_seconds((int32_t)days*86400L + (int32_t)hours*3600 + (int32_t)minutes*60 + seconds){}TimeSpan::TimeSpan (const TimeSpan©):_seconds(copy._seconds){}TimeSpan TimeSpan::operator+(const TimeSpan&right) { return TimeSpan(_seconds+right._seconds);}TimeSpan TimeSpan::operator-(const TimeSpan&right) { return TimeSpan(_seconds-right._seconds);}////////////////////////////////////////////////////////////////////////////////// RTC_D S1307 implementationstatic uint8_t bcd2bin (uint8_t val) { return val - 6 * (val>> 4); }static uint8_t bin2bcd (uint8_t val) { return val + 6 * (val / 10); }boolean RTC_DS1307::begin(void) { Wire.begin(); return true;}uint8_t RTC_DS1307::isrunning(void) { Wire.beginTransmission(DS1307_ADDRESS); Wire._I2C_WRITE((byte)0); Wire.endTransmission（）; Wire.requestFrom(DS1307_ADDRESS, 1); uint8_t ss =Wire._I2C_READ(); return !(ss>>7);}void RTC_DS1307::adjust(const DateTime&dt) { Wire.beginTransmission(DS1307_ADDRESS); Wire._I2C_WRITE((byte)0); // start at location 0 Wire._I2C_WRITE(bin2bcd(dt.second())); Wire._I2C_WRITE(bin2bcd(dt.minute())); Wire._I2C_WRITE(bin2bcd(dt.hour())); Wire._I2C_WRITE(bin2bcd(0)); Wire._I2C_WRITE(bin2bcd(dt.day())); Wire._I2C_WRITE(bin2bcd(dt.month())); Wire._I2C_WRITE(bin2bcd(dt.year() - 2000)); Wire.endTransmission();}DateTime RTC_DS1307::now() { Wire.beginTransmission(DS1307_ADDRESS); Wire._I2C_WRITE((byte)0); Wire.endTransmission（）; Wire.requestFrom(DS1307_ADDRESS, 7); uint8_t ss =bcd2bin(Wire._I2C_READ() &0x7F); uint8_t mm =bcd2bin(Wire._I2C_READ()); uint8_t hh =bcd2bin(Wire._I2C_READ()); Wire._I2C_READ(); uint8_t d =bcd2bin(Wire._I2C_READ()); uint8_t m =bcd2bin(Wire._I2C_READ()); uint16_t y =bcd2bin(Wire._I2C_READ()) + 2000; return DateTime (y, m, d, hh, mm, ss);}Ds1307SqwPinMode RTC_DS1307::readSqwPinMode() { int mode; Wire.beginTransmission(DS1307_ADDRESS); Wire._I2C_WRITE(DS1307_CONTROL); Wire.endTransmission（）; Wire.requestFrom((uint8_t)DS1307_ADDRESS, (uint8_t)1); mode =Wire._I2C_READ(); mode &=0x93; return static_cast(mode);}void RTC_DS1307::writeSqwPinMode(Ds1307SqwPinMode mode) { Wire.beginTransmission(DS1307_ADDRESS); Wire._I2C_WRITE(DS1307_CONTROL); Wire._I2C_WRITE(mode); Wire.endTransmission();}void RTC_DS1307::readnvram(uint8_t* buf, uint8_t size, uint8_t address) { int addrByte =DS1307_NVRAM + address; Wire.beginTransmission(DS1307_ADDRESS); Wire._I2C_WRITE(addrByte); Wire.endTransmission（）; Wire.requestFrom((uint8_t) DS1307_ADDRESS, size); for (uint8_t pos =0; pos >=3; mode &=0x7; return static_cast(mode);}void RTC_PCF8523::writeSqwPinMode(Pcf8523SqwPinMode mode) { Wire.beginTransmission(PCF8523_ADDRESS); Wire._I2C_WRITE(PCF8523_CLKOUTCONTROL); Wire._I2C_WRITE(mode <<3); Wire.endTransmission();}////////////////////////////////////////////////////////////////////////////////// RTC_DS3231 implementationboolean RTC_DS3231::begin(void) { Wire.begin(); return true;}bool RTC_DS3231::lostPower(void) { return (read_i2c_register(DS3231_ADDRESS, DS3231_STATUSREG)>> 7);}void RTC_DS3231::adjust(const DateTime&dt) { Wire.beginTransmission(DS3231_ADDRESS); Wire._I2C_WRITE((byte)0); // start at location 0 Wire._I2C_WRITE(bin2bcd(dt.second())); Wire._I2C_WRITE(bin2bcd(dt.minute())); Wire._I2C_WRITE(bin2bcd(dt.hour())); Wire._I2C_WRITE(bin2bcd(0)); Wire._I2C_WRITE(bin2bcd(dt.day())); Wire._I2C_WRITE(bin2bcd(dt.month())); Wire._I2C_WRITE(bin2bcd(dt.year() - 2000)); Wire.endTransmission（）; uint8_t statreg =read_i2c_register(DS3231_ADDRESS, DS3231_STATUSREG); statreg &=~0x80; // flip OSF bit write_i2c_register(DS3231_ADDRESS, DS3231_STATUSREG, statreg);}DateTime RTC_DS3231::now() { Wire.beginTransmission(DS3231_ADDRESS); Wire._I2C_WRITE((byte)0); Wire.endTransmission（）; Wire.requestFrom(DS3231_ADDRESS, 7); uint8_t ss =bcd2bin(Wire._I2C_READ() &0x7F); uint8_t mm =bcd2bin(Wire._I2C_READ()); uint8_t hh =bcd2bin(Wire._I2C_READ()); Wire._I2C_READ(); uint8_t d =bcd2bin(Wire._I2C_READ()); uint8_t m =bcd2bin(Wire._I2C_READ()); uint16_t y =bcd2bin(Wire._I2C_READ()) + 2000; return DateTime (y, m, d, hh, mm, ss);}Ds3231SqwPinMode RTC_DS3231::readSqwPinMode() { int mode; Wire.beginTransmission(DS3231_ADDRESS); Wire._I2C_WRITE(DS3231_CONTROL); Wire.endTransmission（）; Wire.requestFrom((uint8_t)DS3231_ADDRESS, (uint8_t)1); mode =Wire._I2C_READ(); mode &=0x93; return static_cast(mode);}void RTC_DS3231::writeSqwPinMode(Ds3231SqwPinMode mode) { uint8_t ctrl; ctrl =read_i2c_register(DS3231_ADDRESS, DS3231_CONTROL); ctrl &=~0x04; // turn off INTCON ctrl &=~0x18; // set freq bits to 0 if (mode ==DS3231_OFF) { ctrl |=0x04; // turn on INTCN } else { ctrl |=mode; } write_i2c_register(DS3231_ADDRESS, DS3231_CONTROL, ctrl); //Serial.println( read_i2c_register(DS3231_ADDRESS, DS3231_CONTROL), HEX);}

RTClib.hC/C++

// Code by JeeLabs http://news.jeelabs.org/code/// Released to the public domain! Enjoy!#ifndef _RTCLIB_H_#define _RTCLIB_H_#include class TimeSpan;#define PCF8523_ADDRESS 0x68#define PCF8523_CLKOUTCONTROL 0x0F#define PCF8523_CONTROL_3 0x02#define DS1307_ADDRESS 0x68#define DS1307_CONTROL 0x07#define DS1307_NVRAM 0x08#define DS3231_ADDRESS 0x68#define DS3231_CONTROL 0x0E#define DS3231_STATUSREG 0x0F#define SECONDS_PER_DAY 86400L#define SECONDS_FROM_1970_TO_2000 946684800// Simple general-purpose date/time class (no TZ / DST / leap second handling!)class DateTime {public:DateTime (uint32_t t =0); DateTime (uint16_t year, uint8_t month, uint8_t day, uint8_t hour =0, uint8_t min =0, uint8_t sec =0); DateTime (const DateTime©); DateTime (const char* date, const char* time); DateTime (const __FlashStringHelper* date, const __FlashStringHelper* time); uint16_t year() const { return 2000 + yOff; } uint8_t month() const { return m; } uint8_t day() const { return d; } uint8_t hour() const { return hh; } uint8_t minute() const { return mm; } uint8_t second() const { return ss; } uint8_t dayOfTheWeek() const; // 32-bit times as seconds since 1/1/2000 long secondstime() const; // 32-bit times as seconds since 1/1/1970 uint32_t unixtime(void) const; DateTime operator+(const TimeSpan&span); DateTime operator-(const TimeSpan&span); TimeSpan operator-(const DateTime&right);protected:uint8_t yOff, m, d, hh, mm, ss;};// Timespan which can represent changes in time with seconds accuracy.class TimeSpan {public:TimeSpan (int32_t seconds =0); TimeSpan (int16_t days, int8_t hours, int8_t minutes, int8_t seconds); TimeSpan (const TimeSpan©); int16_t days() const { return _seconds / 86400L; } int8_t hours() const { return _seconds / 3600 % 24; } int8_t minutes() const { return _seconds / 60 % 60; } int8_t seconds() const { return _seconds % 60; } int32_t totalseconds() const { return _seconds; } TimeSpan operator+(const TimeSpan&right); TimeSpan operator-(const TimeSpan&right);protected:int32_t _seconds;};// RTC based on the DS1307 chip connected via I2C and the Wire libraryenum Ds1307SqwPinMode { OFF =0x00, ON =0x80, SquareWave1HZ =0x10, SquareWave4kHz =0x11, SquareWave8kHz =0x12, SquareWave32kHz =0x13 };class RTC_DS1307 {public:boolean begin(void); static void adjust(const DateTime&dt); uint8_t isrunning(void); static DateTime now(); static Ds1307SqwPinMode readSqwPinMode(); static void writeSqwPinMode(Ds1307SqwPinMode mode); uint8_t readnvram(uint8_t address); void readnvram(uint8_t* buf, uint8_t size, uint8_t address); void writenvram(uint8_t address, uint8_t data); void writenvram(uint8_t address, uint8_t* buf, uint8_t size);};// RTC based on the DS3231 chip connected via I2C and the Wire libraryenum Ds3231SqwPinMode { DS3231_OFF =0x01, DS3231_SquareWave1Hz =0x00, DS3231_SquareWave1kHz =0x08, DS3231_SquareWave4kHz =0x10, DS3231_SquareWave8kHz =0x18 };class RTC_DS3231 {public:boolean begin(void); static void adjust(const DateTime&dt); bool lostPower(void); static DateTime now(); static Ds3231SqwPinMode readSqwPinMode(); static void writeSqwPinMode(Ds3231SqwPinMode mode);};// RTC based on the PCF8523 chip connected via I2C and the Wire libraryenum Pcf8523SqwPinMode { PCF8523_OFF =7, PCF8523_SquareWave1HZ =6, PCF8523_SquareWave32HZ =5, PCF8523_SquareWave1kHz =4, PCF8523_SquareWave4kHz =3, PCF8523_SquareWave8kHz =2, PCF8523_SquareWave16kHz =1, PCF8523_SquareWave32kHz =0 };class RTC_PCF8523 {public:boolean begin(void); void adjust(const DateTime&dt); boolean initialized(void); static DateTime now(); Pcf8523SqwPinMode readSqwPinMode(); void writeSqwPinMode(Pcf8523SqwPinMode mode);};// RTC using the internal millis() clock, has to be initialized before use// NOTE:this clock won't be correct once the millis() timer rolls over (>49d?)class RTC_Millis {public:static void begin(const DateTime&dt) { adjust(dt); } static void adjust(const DateTime&dt); static DateTime now();protected:static long offset;};#endif // _RTCLIB_H_

回路図