设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › Arduino › ds3231的Arduino库文件及程序示例
返回列表 发新帖
查看: 8873|回复: 2
收起左侧

ds3231的Arduino库文件及程序示例

[复制链接]
ID:301234 发表于 2018-4-2 23:51 | 显示全部楼层 |阅读模式
发个ds3231高精度时钟模块的库文件及示例，用于Arduino开发版，精度不错。
0.png

单片机源程序如下:
  1. /*
  2. DS3231.cpp: DS3231 Real-Time Clock library
  3. original code by
  4. Eric Ayars
  5. 4/1/11

  7. updated to Arduino 1.0
  8. John Hubert
  9. Feb 7, 2012

  11. Released into the public domain.
  12. */

  14. #include <DS3231.h>

  16. #define CLOCK_ADDRESS 0x68

  18. // Constructor
  19. DS3231::DS3231() {
  20.         // nothing to do for this constructor.
  21. }

  23. /*****************************************
  24.         Public Functions
  25. *****************************************/

  27. void DS3231::getTime(byte& year, byte& month, byte& date, byte& DoW, byte& hour, byte& minute, byte& second) {
  28.         byte tempBuffer;
  29.         bool PM;
  30.         bool h12;

  32.         Wire.beginTransmission(CLOCK_ADDRESS);
  33.         Wire.write(uint8_t(0x00));
  34.         Wire.endTransmission();
  35.        
  36.         Wire.requestFrom(CLOCK_ADDRESS, 7);

  38.         second = bcdToDec(Wire.read());
  39.         minute = bcdToDec(Wire.read());
  40.         tempBuffer = bcdToDec(Wire.read());
  41.         h12 = tempBuffer & 0b01000000;
  42.         if (h12) {
  43.                 PM = tempBuffer & 0b00100000;
  44.                 hour = bcdToDec(tempBuffer & 0b00011111);
  45.         } else {
  46.                 hour = bcdToDec(tempBuffer & 0b00111111);
  47.         }
  48.         DoW = bcdToDec(Wire.read());
  49.         date = bcdToDec(Wire.read());
  50.         month = bcdToDec(Wire.read() & 0b01111111);
  51.         year = bcdToDec(Wire.read());
  52. }

  54. byte DS3231::getSecond() {
  55.         Wire.beginTransmission(CLOCK_ADDRESS);
  56.         Wire.write(uint8_t(0x00));
  57.         Wire.endTransmission();

  59.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  60.         return bcdToDec(Wire.read());
  61. }

  63. byte DS3231::getMinute() {
  64.         Wire.beginTransmission(CLOCK_ADDRESS);
  65.         Wire.write(0x01);
  66.         Wire.endTransmission();

  68.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  69.         return bcdToDec(Wire.read());
  70. }

  72. byte DS3231::getHour(bool& h12, bool& PM) {
  73.         byte temp_buffer;
  74.         byte hour;
  75.         Wire.beginTransmission(CLOCK_ADDRESS);
  76.         Wire.write(0x02);
  77.         Wire.endTransmission();

  79.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  80.         temp_buffer = Wire.read();
  81.         h12 = temp_buffer & 0b01000000;
  82.         if (h12) {
  83.                 PM = temp_buffer & 0b00100000;
  84.                 hour = bcdToDec(temp_buffer & 0b00011111);
  85.         } else {
  86.                 hour = bcdToDec(temp_buffer & 0b00111111);
  87.         }
  88.         return hour;
  89. }

  91. byte DS3231::getDoW() {
  92.         Wire.beginTransmission(CLOCK_ADDRESS);
  93.         Wire.write(uint8_t(0x03));
  94.         Wire.endTransmission();

  96.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  97.         return bcdToDec(Wire.read());
  98. }

  100. byte DS3231::getDate() {
  101.         Wire.beginTransmission(CLOCK_ADDRESS);
  102.         Wire.write(uint8_t(0x04));
  103.         Wire.endTransmission();

  105.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  106.         return bcdToDec(Wire.read());
  107. }

  109. byte DS3231::getMonth(bool& Century) {
  110.         byte temp_buffer;
  111.         byte hour;
  112.         Wire.beginTransmission(CLOCK_ADDRESS);
  113.         Wire.write(uint8_t(0x05));
  114.         Wire.endTransmission();

  116.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  117.         temp_buffer = Wire.read();
  118.         Century = temp_buffer & 0b10000000;
  119.         return (bcdToDec(temp_buffer & 0b01111111)) ;
  120. }

  122. byte DS3231::getYear() {
  123.         Wire.beginTransmission(CLOCK_ADDRESS);
  124.         Wire.write(uint8_t(0x06));
  125.         Wire.endTransmission();

  127.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  128.         return bcdToDec(Wire.read());
  129. }

  131. void DS3231::setSecond(byte Second) {
  132.         // Sets the seconds
  133.         // This function also resets the Oscillator Stop Flag, which is set
  134.         // whenever power is interrupted.
  135.         Wire.beginTransmission(CLOCK_ADDRESS);
  136.         Wire.write(uint8_t(0x00));
  137.         Wire.write(decToBcd(Second));       
  138.         Wire.endTransmission();
  139.         // Clear OSF flag
  140.         byte temp_buffer = readControlByte(1);
  141.         writeControlByte((temp_buffer & 0b01111111), 1);
  142. }

  144. void DS3231::setMinute(byte Minute) {
  145.         // Sets the minutes
  146.         Wire.beginTransmission(CLOCK_ADDRESS);
  147.         Wire.write(uint8_t(0x01));
  148.         Wire.write(decToBcd(Minute));       
  149.         Wire.endTransmission();
  150. }

  152. void DS3231::setHour(byte Hour) {
  153.         // Sets the hour, without changing 12/24h mode.
  154.         // The hour must be in 24h format.

  156.         bool h12;

  158.         // Start by figuring out what the 12/24 mode is
  159.         Wire.beginTransmission(CLOCK_ADDRESS);
  160.         Wire.write(uint8_t(0x02));
  161.         Wire.endTransmission();
  162.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  163.         h12 = (Wire.read() & 0b01000000);
  164.         // if h12 is true, it's 12h mode; false is 24h.

  166.         if (h12) {
  167.                 // 12 hour
  168.                 if (Hour > 12) {
  169.                         Hour = decToBcd(Hour-12) | 0b01100000;
  170.                 } else {
  171.                         Hour = decToBcd(Hour) & 0b11011111;
  172.                 }
  173.         } else {
  174.                 // 24 hour
  175.                 Hour = decToBcd(Hour) & 0b10111111;
  176.         }

  178.         Wire.beginTransmission(CLOCK_ADDRESS);
  179.         Wire.write(uint8_t(0x02));
  180.         Wire.write(Hour);
  181.         Wire.endTransmission();
  182. }

  184. void DS3231::setDoW(byte DoW) {
  185.         // Sets the Day of Week
  186.         Wire.beginTransmission(CLOCK_ADDRESS);
  187.         Wire.write(uint8_t(0x03));
  188.         Wire.write(decToBcd(DoW));       
  189.         Wire.endTransmission();
  190. }

  192. void DS3231::setDate(byte Date) {
  193.         // Sets the Date
  194.         Wire.beginTransmission(CLOCK_ADDRESS);
  195.         Wire.write(uint8_t(0x04));
  196.         Wire.write(decToBcd(Date));       
  197.         Wire.endTransmission();
  198. }

  200. void DS3231::setMonth(byte Month) {
  201.         // Sets the month
  202.         Wire.beginTransmission(CLOCK_ADDRESS);
  203.         Wire.write(uint8_t(0x05));
  204.         Wire.write(decToBcd(Month));       
  205.         Wire.endTransmission();
  206. }

  208. void DS3231::setYear(byte Year) {
  209.         // Sets the year
  210.         Wire.beginTransmission(CLOCK_ADDRESS);
  211.         Wire.write(uint8_t(0x06));
  212.         Wire.write(decToBcd(Year));       
  213.         Wire.endTransmission();
  214. }

  216. void DS3231::setClockMode(bool h12) {
  217.         // sets the mode to 12-hour (true) or 24-hour (false).
  218.         // One thing that bothers me about how I've written this is that
  219.         // if the read and right happen at the right hourly millisecnd,
  220.         // the clock will be set back an hour. Not sure how to do it better,
  221.         // though, and as long as one doesn't set the mode frequently it's
  222.         // a very minimal risk.
  223.         // It's zero risk if you call this BEFORE setting the hour, since
  224.         // the setHour() function doesn't change this mode.
  225.        
  226.         byte temp_buffer;

  228.         // Start by reading byte 0x02.
  229.         Wire.beginTransmission(CLOCK_ADDRESS);
  230.         Wire.write(uint8_t(0x02));
  231.         Wire.endTransmission();
  232.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  233.         temp_buffer = Wire.read();

  235.         // Set the flag to the requested value:
  236.         if (h12) {
  237.                 temp_buffer = temp_buffer | 0b01000000;
  238.         } else {
  239.                 temp_buffer = temp_buffer & 0b10111111;
  240.         }

  242.         // Write the byte
  243.         Wire.beginTransmission(CLOCK_ADDRESS);
  244.         Wire.write(uint8_t(0x02));
  245.         Wire.write(temp_buffer);
  246.         Wire.endTransmission();
  247. }

  249. float DS3231::getTemperature() {
  250.         // Checks the internal thermometer on the DS3231 and returns the
  251.         // temperature as a floating-point value.
  252.         byte temp;
  253.         Wire.beginTransmission(CLOCK_ADDRESS);
  254.         Wire.write(uint8_t(0x11));
  255.         Wire.endTransmission();

  257.         Wire.requestFrom(CLOCK_ADDRESS, 2);
  258.         temp = Wire.read();        // Here's the MSB
  259.         return float(temp) + 0.25*(Wire.read()>>6);
  260. }

  262. void DS3231::getA1Time(byte& A1Day, byte& A1Hour, byte& A1Minute, byte& A1Second, byte& AlarmBits, bool& A1Dy, bool& A1h12, bool& A1PM) {
  263.         byte temp_buffer;
  264.         Wire.beginTransmission(CLOCK_ADDRESS);
  265.         Wire.write(uint8_t(0x07));
  266.         Wire.endTransmission();

  268.         Wire.requestFrom(CLOCK_ADDRESS, 4);

  270.         temp_buffer        = Wire.read();        // Get A1M1 and A1 Seconds
  271.         A1Second        = bcdToDec(temp_buffer & 0b01111111);
  272.         // put A1M1 bit in position 0 of DS3231_AlarmBits.
  273.         AlarmBits        = AlarmBits | (temp_buffer & 0b10000000)>>7;

  275.         temp_buffer                = Wire.read();        // Get A1M2 and A1 minutes
  276.         A1Minute        = bcdToDec(temp_buffer & 0b01111111);
  277.         // put A1M2 bit in position 1 of DS3231_AlarmBits.
  278.         AlarmBits        = AlarmBits | (temp_buffer & 0b10000000)>>6;

  280.         temp_buffer        = Wire.read();        // Get A1M3 and A1 Hour
  281.         // put A1M3 bit in position 2 of DS3231_AlarmBits.
  282.         AlarmBits        = AlarmBits | (temp_buffer & 0b10000000)>>5;
  283.         // determine A1 12/24 mode
  284.         A1h12                = temp_buffer & 0b01000000;
  285.         if (A1h12) {
  286.                 A1PM        = temp_buffer & 0b00100000;                        // determine am/pm
  287.                 A1Hour        = bcdToDec(temp_buffer & 0b00011111);        // 12-hour
  288.         } else {
  289.                 A1Hour        = bcdToDec(temp_buffer & 0b00111111);        // 24-hour
  290.         }

  292.         temp_buffer        = Wire.read();        // Get A1M4 and A1 Day/Date
  293.         // put A1M3 bit in position 3 of DS3231_AlarmBits.
  294.         AlarmBits        = AlarmBits | (temp_buffer & 0b10000000)>>4;
  295.         // determine A1 day or date flag
  296.         A1Dy                = (temp_buffer & 0b01000000)>>6;
  297.         if (A1Dy) {
  298.                 // alarm is by day of week, not date.
  299.                 A1Day        = bcdToDec(temp_buffer & 0b00001111);
  300.         } else {
  301.                 // alarm is by date, not day of week.
  302.                 A1Day        = bcdToDec(temp_buffer & 0b00111111);
  303.         }
  304. }

  306. void DS3231::getA2Time(byte& A2Day, byte& A2Hour, byte& A2Minute, byte& AlarmBits, bool& A2Dy, bool& A2h12, bool& A2PM) {
  307.         byte temp_buffer;
  308.         Wire.beginTransmission(CLOCK_ADDRESS);
  309.         Wire.write(uint8_t(0x0b));
  310.         Wire.endTransmission();

  312.         Wire.requestFrom(CLOCK_ADDRESS, 3);
  313.         temp_buffer        = Wire.read();        // Get A2M2 and A2 Minutes
  314.         A2Minute        = bcdToDec(temp_buffer & 0b01111111);
  315.         // put A2M2 bit in position 4 of DS3231_AlarmBits.
  316.         AlarmBits        = AlarmBits | (temp_buffer & 0b10000000)>>3;

  318.         temp_buffer        = Wire.read();        // Get A2M3 and A2 Hour
  319.         // put A2M3 bit in position 5 of DS3231_AlarmBits.
  320.         AlarmBits        = AlarmBits | (temp_buffer & 0b10000000)>>2;
  321.         // determine A2 12/24 mode
  322.         A2h12                = temp_buffer & 0b01000000;
  323.         if (A2h12) {
  324.                 A2PM        = temp_buffer & 0b00100000;                        // determine am/pm
  325.                 A2Hour        = bcdToDec(temp_buffer & 0b00011111);        // 12-hour
  326.         } else {
  327.                 A2Hour        = bcdToDec(temp_buffer & 0b00111111);        // 24-hour
  328.         }

  330.         temp_buffer        = Wire.read();        // Get A2M4 and A1 Day/Date
  331.         // put A2M4 bit in position 6 of DS3231_AlarmBits.
  332.         AlarmBits        = AlarmBits | (temp_buffer & 0b10000000)>>1;
  333.         // determine A2 day or date flag
  334.         A2Dy                = (temp_buffer & 0b01000000)>>6;
  335.         if (A2Dy) {
  336.                 // alarm is by day of week, not date.
  337.                 A2Day        = bcdToDec(temp_buffer & 0b00001111);
  338.         } else {
  339.                 // alarm is by date, not day of week.
  340.                 A2Day        = bcdToDec(temp_buffer & 0b00111111);
  341.         }
  342. }

  344. void DS3231::setA1Time(byte A1Day, byte A1Hour, byte A1Minute, byte A1Second, byte AlarmBits, bool A1Dy, bool A1h12, bool A1PM) {
  345.         //        Sets the alarm-1 date and time on the DS3231, using A1* information
  346.         byte temp_buffer;
  347.         Wire.beginTransmission(CLOCK_ADDRESS);
  348.         Wire.write(uint8_t(0x07));        // A1 starts at 07h
  349.         // Send A1 second and A1M1
  350.         Wire.write(decToBcd(A1Second) | ((AlarmBits & 0b00000001) << 7));
  351.         // Send A1 Minute and A1M2
  352.         Wire.write(decToBcd(A1Minute) | ((AlarmBits & 0b00000010) << 6));
  353.         // Figure out A1 hour
  354.         if (A1h12) {
  355.                 // Start by converting existing time to h12 if it was given in 24h.
  356.                 if (A1Hour > 12) {
  357.                         // well, then, this obviously isn't a h12 time, is it?
  358.                         A1Hour = A1Hour - 12;
  359.                         A1PM = true;
  360.                 }
  361.                 if (A1PM) {
  362.                         // Afternoon
  363.                         // Convert the hour to BCD and add appropriate flags.
  364.                         temp_buffer = decToBcd(A1Hour) | 0b01100000;
  365.                 } else {
  366.                         // Morning
  367.                         // Convert the hour to BCD and add appropriate flags.
  368.                         temp_buffer = decToBcd(A1Hour) | 0b01000000;
  369.                 }
  370.         } else {
  371.                 // Now for 24h
  372.                 temp_buffer = decToBcd(A1Hour);
  373.         }
  374.         temp_buffer = temp_buffer | ((AlarmBits & 0b00000100)<<5);
  375.         // A1 hour is figured out, send it
  376.         Wire.write(temp_buffer);
  377.         // Figure out A1 day/date and A1M4
  378.         temp_buffer = ((AlarmBits & 0b00001000)<<4) | decToBcd(A1Day);
  379.         if (A1Dy) {
  380.                 // Set A1 Day/Date flag (Otherwise it's zero)
  381.                 temp_buffer = temp_buffer | 0b01000000;
  382.         }
  383.         Wire.write(temp_buffer);
  384.         // All done!
  385.         Wire.endTransmission();
  386. }

  388. void DS3231::setA2Time(byte A2Day, byte A2Hour, byte A2Minute, byte AlarmBits, bool A2Dy, bool A2h12, bool A2PM) {
  389.         //        Sets the alarm-2 date and time on the DS3231, using A2* information
  390.         byte temp_buffer;
  391.         Wire.beginTransmission(CLOCK_ADDRESS);
  392.         Wire.write(uint8_t(0x0b));        // A1 starts at 0bh
  393.         // Send A2 Minute and A2M2
  394.         Wire.write(decToBcd(A2Minute) | ((AlarmBits & 0b00010000) << 3));
  395.         // Figure out A2 hour
  396.         if (A2h12) {
  397.                 // Start by converting existing time to h12 if it was given in 24h.
  398.                 if (A2Hour > 12) {
  399.                         // well, then, this obviously isn't a h12 time, is it?
  400.                         A2Hour = A2Hour - 12;
  401.                         A2PM = true;
  402.                 }
  403.                 if (A2PM) {
  404.                         // Afternoon
  405.                         // Convert the hour to BCD and add appropriate flags.
  406.                         temp_buffer = decToBcd(A2Hour) | 0b01100000;
  407.                 } else {
  408.                         // Morning
  409.                         // Convert the hour to BCD and add appropriate flags.
  410.                         temp_buffer = decToBcd(A2Hour) | 0b01000000;
  411.                 }
  412.         } else {
  413.                 // Now for 24h
  414.                 temp_buffer = decToBcd(A2Hour);
  415.         }
  416.         // add in A2M3 bit
  417.         temp_buffer = temp_buffer | ((AlarmBits & 0b00100000)<<2);
  418.         // A2 hour is figured out, send it
  419.         Wire.write(temp_buffer);
  420.         // Figure out A2 day/date and A2M4
  421.         temp_buffer = ((AlarmBits & 0b01000000)<<1) | decToBcd(A2Day);
  422.         if (A2Dy) {
  423.                 // Set A2 Day/Date flag (Otherwise it's zero)
  424.                 temp_buffer = temp_buffer | 0b01000000;
  425.         }
  426.         Wire.write(temp_buffer);
  427.         // All done!
  428.         Wire.endTransmission();
  429. }

  431. void DS3231::turnOnAlarm(byte Alarm) {
  432.         // turns on alarm number "Alarm". Defaults to 2 if Alarm is not 1.
  433.         byte temp_buffer = readControlByte(0);
  434.         // modify control byte
  435.         if (Alarm == 1) {
  436.                 temp_buffer = temp_buffer | 0b00000101;
  437.         } else {
  438.                 temp_buffer = temp_buffer | 0b00000110;
  439.         }
  440.         writeControlByte(temp_buffer, 0);
  441. }

  443. void DS3231::turnOffAlarm(byte Alarm) {
  444.         // turns off alarm number "Alarm". Defaults to 2 if Alarm is not 1.
  445.         // Leaves interrupt pin alone.
  446.         byte temp_buffer = readControlByte(0);
  447.         // modify control byte
  448.         if (Alarm == 1) {
  449.                 temp_buffer = temp_buffer & 0b11111110;
  450.         } else {
  451.                 temp_buffer = temp_buffer & 0b11111101;
  452.         }
  453.         writeControlByte(temp_buffer, 0);
  454. }

  456. bool DS3231::checkAlarmEnabled(byte Alarm) {
  457.         // Checks whether the given alarm is enabled.
  458.         byte result = 0x0;
  459.         byte temp_buffer = readControlByte(0);
  460.         if (Alarm == 1) {
  461.                 result = temp_buffer & 0b00000001;
  462.         } else {
  463.                 result = temp_buffer & 0b00000010;
  464.         }
  465.         return result;
  466. }

  468. bool DS3231::checkIfAlarm(byte Alarm) {
  469.         // Checks whether alarm 1 or alarm 2 flag is on, returns T/F accordingly.
  470.         // Turns flag off, also.
  471.         // defaults to checking alarm 2, unless Alarm == 1.
  472.         byte result;
  473.         byte temp_buffer = readControlByte(1);
  474.         if (Alarm == 1) {
  475.                 // Did alarm 1 go off?
  476.                 result = temp_buffer & 0b00000001;
  477.                 // clear flag
  478.                 temp_buffer = temp_buffer & 0b11111110;
  479.         } else {
  480.                 // Did alarm 2 go off?
  481.                 result = temp_buffer & 0b00000010;
  482.                 // clear flag
  483.                 temp_buffer = temp_buffer & 0b11111101;
  484.         }
  485.         writeControlByte(temp_buffer, 1);
  486.         return result;
  487. }

  489. void DS3231::enableOscillator(bool TF, bool battery, byte frequency) {
  490.         // turns oscillator on or off. True is on, false is off.
  491.         // if battery is true, turns on even for battery-only operation,
  492.         // otherwise turns off if Vcc is off.
  493.         // frequency must be 0, 1, 2, or 3.
  494.         // 0 = 1 Hz
  495.         // 1 = 1.024 kHz
  496.         // 2 = 4.096 kHz
  497.         // 3 = 8.192 kHz (Default if frequency byte is out of range)
  498.         if (frequency > 3) frequency = 3;
  499.         // read control byte in, but zero out current state of RS2 and RS1.
  500.         byte temp_buffer = readControlByte(0) & 0b11100111;
  501.         if (battery) {
  502.                 // turn on BBSQW flag
  503.                 temp_buffer = temp_buffer | 0b01000000;
  504.         } else {
  505.                 // turn off BBSQW flag
  506.                 temp_buffer = temp_buffer & 0b10111111;
  507.         }
  508.         if (TF) {
  509.                 // set ~EOSC to 0 and INTCN to zero.
  510.                 temp_buffer = temp_buffer & 0b01111011;
  511.         } else {
  512.                 // set ~EOSC to 1, leave INTCN as is.
  513.                 temp_buffer = temp_buffer | 0b10000000;
  514.         }
  515.         // shift frequency into bits 3 and 4 and set.
  516.         frequency = frequency << 3;
  517.         temp_buffer = temp_buffer | frequency;
  518.         // And write the control bits
  519.         writeControlByte(temp_buffer, 0);
  520. }

  522. void DS3231::enable32kHz(bool TF) {
  523.         // turn 32kHz pin on or off
  524.         byte temp_buffer = readControlByte(1);
  525.         if (TF) {
  526.                 // turn on 32kHz pin
  527.                 temp_buffer = temp_buffer | 0b00001000;
  528.         } else {
  529.                 // turn off 32kHz pin
  530.                 temp_buffer = temp_buffer & 0b11110111;
  531.         }
  532.         writeControlByte(temp_buffer, 1);
  533. }

  535. bool DS3231::oscillatorCheck() {
  536.         // Returns false if the oscillator has been off for some reason.
  537.         // If this is the case, the time is probably not correct.
  538.         byte temp_buffer = readControlByte(1);
  539.         bool result = true;
  540.         if (temp_buffer & 0b10000000) {
  541.                 // Oscillator Stop Flag (OSF) is set, so return false.
  542.                 result = false;
  543.         }
  544.         return result;
  545. }

  547. /*****************************************
  548.         Private Functions
  549. *****************************************/

  551. byte DS3231::decToBcd(byte val) {
  552. // Convert normal decimal numbers to binary coded decimal
  553.         return ( (val/10*16) + (val%10) );
  554. }

  556. byte DS3231::bcdToDec(byte val) {
  557. // Convert binary coded decimal to normal decimal numbers
  558.         return ( (val/16*10) + (val%16) );
  559. }

  561. byte DS3231::readControlByte(bool which) {
  562.         // Read selected control byte
  563.         // first byte (0) is 0x0e, second (1) is 0x0f
  564.         Wire.beginTransmission(CLOCK_ADDRESS);
  565.         if (which) {
  566.                 // second control byte
  567.                 Wire.write(uint8_t(0x0f));
  568.         } else {
  569.                 // first control byte
  570.                 Wire.write(uint8_t(0x0e));
  571.         }
  572.         Wire.endTransmission();
  573.         Wire.requestFrom(CLOCK_ADDRESS, 1);
  574.         return Wire.read();       
  575. }

  577. void DS3231::writeControlByte(byte control, bool which) {
  578.         // Write the selected control byte.
  579.         // which=false -> 0x0e, true->0x0f.
  580.         Wire.beginTransmission(CLOCK_ADDRESS);
  581.         if (which) {
  582.                 Wire.write(uint8_t(0x0f));
  583.         } else {
  584.                 Wire.write(uint8_t(0x0e));
  585.         }
  586.         Wire.write(control);
  587.         Wire.endTransmission();
  588. }

复制代码

所有资料51hei提供下载:
DS3231.rar (498.21 KB, 下载次数: 159)
回复

使用道具 举报

ID:762132 发表于 2020-5-27 06:55 | 显示全部楼层
谢谢楼主提供
回复

使用道具 举报

ID:279488 发表于 2020-6-7 05:32 | 显示全部楼层
好东西，感谢分享!!
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表