开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
i2cM41T81Clock.c
资源名称：mpc8548.rar　[点击查看]
上传用户：dqzhongke1
上传日期：2022-06-26
资源大小：667k
文件大小：9k
源码类别：

VxWorks

开发平台：

C/C++

i2cM41T81Clock.c：源码内容
  1. /*
  2.  * $Id: i2cM41T81Clock.c,v 1.3 Broadcom SDK $
  3.  * $Copyright: Copyright 2008 Broadcom Corporation.
  4.  * This program is the proprietary software of Broadcom Corporation
  5.  * and/or its licensors, and may only be used, duplicated, modified
  6.  * or distributed pursuant to the terms and conditions of a separate,
  7.  * written license agreement executed between you and Broadcom
  8.  * (an "Authorized License").  Except as set forth in an Authorized
  9.  * License, Broadcom grants no license (express or implied), right
  10.  * to use, or waiver of any kind with respect to the Software, and
  11.  * Broadcom expressly reserves all rights in and to the Software
  12.  * and all intellectual property rights therein.  IF YOU HAVE
  13.  * NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS SOFTWARE
  14.  * IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE
  15.  * ALL USE OF THE SOFTWARE.  
  16.  *  
  17.  * Except as expressly set forth in the Authorized License,
  18.  *  
  19.  * 1.     This program, including its structure, sequence and organization,
  20.  * constitutes the valuable trade secrets of Broadcom, and you shall use
  21.  * all reasonable efforts to protect the confidentiality thereof,
  22.  * and to use this information only in connection with your use of
  23.  * Broadcom integrated circuit products.
  24.  *  
  25.  * 2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS
  26.  * PROVIDED "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES,
  27.  * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY,
  28.  * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE.  BROADCOM SPECIFICALLY
  29.  * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY,
  30.  * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES,
  31.  * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR
  32.  * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING
  33.  * OUT OF USE OR PERFORMANCE OF THE SOFTWARE.
  34.  * 
  35.  * 3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL
  36.  * BROADCOM OR ITS LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL,
  37.  * INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY DAMAGES WHATSOEVER
  38.  * ARISING OUT OF OR IN ANY WAY RELATING TO YOUR USE OF OR INABILITY
  39.  * TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF THE
  40.  * POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF
  41.  * THE AMOUNT ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1,
  42.  * WHICHEVER IS GREATER. THESE LIMITATIONS SHALL APPLY NOTWITHSTANDING
  43.  * ANY FAILURE OF ESSENTIAL PURPOSE OF ANY LIMITED REMEDY.$
  44.  */
  46. #include "vxWorks.h"
  47. #include "taskLib.h"
  48. #include "stdlib.h"
  49. #include "stdio.h"
  50. #include "string.h"
  51. #include "ctype.h"
  52. #include "config.h"
  53. #include "sysMotI2c.h"
  54. #include "i2cM41T81Clock.h"
  56. /*
  57.  * Get RTC ready
  58.  */
  59. STATUS
  60. m41t81_tod_init(void)
  61. {
  62.     char byte;
  63.     int polls;
  64.     int status;
  66.     /*
  67.      * Reset HT bit to "0" to update registers with current time.
  68.      */
  69.     status = i2cRead(M41T81_SMBUS_CHAN,
  70.                      M41T81_CCR_ADDRESS,
  71.                      I2C_DEVICE_TYPE_RTC_M41T48,
  72.                      M41T81REG_AHR,
  73.                      1, 
  74.                      &byte);
  75.     byte &= ~M41T81REG_AHR_HT;
  76.     status = i2cWrite(M41T81_SMBUS_CHAN,
  77.                      M41T81_CCR_ADDRESS,
  78.                      I2C_DEVICE_TYPE_RTC_M41T48,
  79.                      M41T81REG_AHR,
  80.                      1, 
  81.                      &byte);
  83.     /*
  84.      * Try to read from the device.  If it does not
  85.      * respond, fail.  We may need to do this for up to 300ms.
  86.      */
  87.     for (polls = 0; polls < 300; polls++) {
  88.         taskDelay(1);
  89.         status = i2cRead(M41T81_SMBUS_CHAN,
  90.                      M41T81_CCR_ADDRESS,
  91.                      I2C_DEVICE_TYPE_RTC_M41T48,
  92.                      0,
  93.                      1, 
  94.                      &byte);
  95.         if (status == OK) break;              /* read is ok */
  96.     }
  98.     return 0;
  99. }
  101. int
  102. m41t81_tod_get_second(void)
  103. {
  104.     int second;
  105.     char  byte;
  107.     second = 0;
  108.     if (i2cRead(M41T81_SMBUS_CHAN,
  109.                      M41T81_CCR_ADDRESS,
  110.                      I2C_DEVICE_TYPE_RTC_M41T48,
  111.                      M41T81REG_SC,
  112.                      1,
  113.                      &byte) == 0) {
  114.         byte &= ~(M41T81REG_SC_ST);
  115.         second = (UINT8) FROM_BCD(byte);
  116.     }
  118.     return second;
  119. }
  121. STATUS
  122. m41t81_tod_get(int *year,        /* 1980-2079 */
  123.                int *month,       /* 01-12 */
  124.                int *date,        /* 01-31 */
  125.                int *hour,        /* 00-23 */
  126.                int *minute,      /* 00-59 */
  127.                int *second)      /* 00-59 */
  128. {
  129.     int   status;
  130.     char  byte;
  131.     int   y2k;
  133.     status = i2cRead(M41T81_SMBUS_CHAN,
  134.                      M41T81_CCR_ADDRESS,
  135.                      I2C_DEVICE_TYPE_RTC_M41T48,
  136.                      M41T81REG_HR,
  137.                      1, 
  138.                      &byte);
  139.     y2k = ((byte & M41T81REG_HR_CB) == M41T81REG_HR_CB);
  140.     byte &= ~(M41T81REG_HR_CB | M41T81REG_HR_CEB);
  141.     *hour = (UINT8) FROM_BCD(byte);
  143.     status = i2cRead(M41T81_SMBUS_CHAN,
  144.                      M41T81_CCR_ADDRESS,
  145.                      I2C_DEVICE_TYPE_RTC_M41T48,
  146.                      M41T81REG_MN,
  147.                      1,
  148.                      &byte);
  149.     *minute = (UINT8) FROM_BCD(byte);
  151.     status = i2cRead(M41T81_SMBUS_CHAN,
  152.                      M41T81_CCR_ADDRESS,
  153.                      I2C_DEVICE_TYPE_RTC_M41T48,
  154.                      M41T81REG_SC,
  155.                      1,
  156.                      &byte);
  157.     byte &= ~(M41T81REG_SC_ST);
  158.     *second = (UINT8) FROM_BCD(byte);
  160.     status = i2cRead(M41T81_SMBUS_CHAN,
  161.                      M41T81_CCR_ADDRESS,
  162.                      I2C_DEVICE_TYPE_RTC_M41T48,
  163.                      M41T81REG_MO,
  164.                      1,
  165.                      &byte);
  166.     *month = (UINT8) byte;
  168.     status = i2cRead(M41T81_SMBUS_CHAN,
  169.                      M41T81_CCR_ADDRESS,
  170.                      I2C_DEVICE_TYPE_RTC_M41T48,
  171.                      M41T81REG_DT,
  172.                      1,
  173.                      &byte);
  174.     *date = (UINT8) FROM_BCD(byte);
  175. #if 0
  176.     status = i2cRead(M41T81_SMBUS_CHAN,
  177.                      M41T81_CCR_ADDRESS,
  178.                      I2C_DEVICE_TYPE_RTC_M41T48,
  179.                      M41T81REG_DY,
  180.                      1,
  181.                      &byte);
  182.     *day = (UINT8) byte;
  183. #endif
  184.     status = i2cRead(M41T81_SMBUS_CHAN,
  185.                      M41T81_CCR_ADDRESS,
  186.                      I2C_DEVICE_TYPE_RTC_M41T48,
  187.                      M41T81REG_YR,
  188.                      1,
  189.                      &byte);
  190.     *year = (UINT8) byte;
  191.     if (y2k) {
  192.         *year += 2000;                   /*Year 20xx*/
  193.     } else {
  194.         *year += 1900;                   /*Year 19xx*/
  195.     }
  197.     return 0;
  198. }
  200. /*
  201.  * Note: the TOD should store the current GMT
  202.  */
  203. STATUS
  204. m41t81_tod_set(int year,            /* 1980-2079 */
  205.                int month,           /* 01-12 */
  206.                int day,             /* 01-31 */
  207.                int hour,            /* 00-23 */
  208.                int minute,          /* 00-59 */
  209.                int second)          /* 00-59 */
  210. {
  211.     UINT8 y2k;
  212.     int   status;
  213.     char  buffer;
  215.     /* write time */
  216.     /*
  217.      * M41T81 does not have a century byte, so we don't need to write y2k
  218.      * But we should flip the century bit (CB) to "1" for year 20xx and to "0"
  219.      * for year 19xx.
  220.      */
  221.     y2k = (year >= 2000) ? 0x20 : 0x19;
  222.     buffer = 0;
  223.     if (y2k == 0x20) {
  224.         buffer = M41T81REG_HR_CB;
  225.     }
  226.     buffer |= (char) (TO_BCD(hour) & 0xff);
  227.     status = i2cWrite(M41T81_SMBUS_CHAN,
  228.                    M41T81_CCR_ADDRESS,
  229.                    I2C_DEVICE_TYPE_RTC_M41T48,
  230.                    M41T81REG_HR, 
  231.                    1,
  232.                    &buffer);
  234.     buffer = (char) (TO_BCD(minute) & 0xff);
  235.     status = i2cWrite(M41T81_SMBUS_CHAN,
  236.                    M41T81_CCR_ADDRESS,
  237.                    I2C_DEVICE_TYPE_RTC_M41T48,
  238.                    M41T81REG_MN, 
  239.                    1,
  240.                    &buffer);
  242.     buffer  = (char) (TO_BCD(second) & 0xff);
  243.     buffer &= ~M41T81REG_SC_ST;
  244.     status = i2cWrite(M41T81_SMBUS_CHAN,
  245.                    M41T81_CCR_ADDRESS,
  246.                    I2C_DEVICE_TYPE_RTC_M41T48,
  247.                    M41T81REG_SC,
  248.                    1,
  249.                    &buffer);
  251.     /* write date */
  252.     buffer = (char) (TO_BCD(month) & 0xff);
  253.     status = i2cWrite(M41T81_SMBUS_CHAN,
  254.                    M41T81_CCR_ADDRESS,
  255.                    I2C_DEVICE_TYPE_RTC_M41T48,
  256.                    M41T81REG_MO,
  257.                    1,
  258.                    &buffer);
  260.     buffer = (char) (TO_BCD(day) & 0xff);
  261.     status = i2cWrite(M41T81_SMBUS_CHAN,
  262.                    M41T81_CCR_ADDRESS,
  263.                    I2C_DEVICE_TYPE_RTC_M41T48,
  264.                    M41T81REG_DT,
  265.                    1,
  266.                    &buffer);
  268.     year %= 100;
  269.     buffer = (char) (TO_BCD(year) & 0xff);
  270.     status = i2cWrite(M41T81_SMBUS_CHAN,
  271.                    M41T81_CCR_ADDRESS,
  272.                    I2C_DEVICE_TYPE_RTC_M41T48,
  273.                    M41T81REG_YR,
  274.                    1,
  275.                    &buffer);                  
  277.     return 0;
  278. }
  280. #ifdef INCLUDE_I2C_DEBUG
  281. void
  282. m41t81_tod_show() {
  283.     int    year, month, date, hour, minute, second;
  284.     m41t81_tod_init();
  286.     if (m41t81_tod_get(&year, &month, &date, &hour, &minute, &second) == 0) {
  287.         printf("%d/%d/%d %d:%d:%dn", 
  288.                year, month, date, hour, minute, second);
  289.     } else {
  290.         printf("m41t81_tod_get() failedn");
  291.     }
  292. }
  293. #endif /* INCLUDE_I2C_DEBUG */