51单片机

分享刚刚调试成功的RX8025T的读写代码

2020-01-13 18:22发布

站内问答 / 51单片机
7498 8 8
本帖最后由 wxdn 于 2019-5-22 04:46 编辑

调试了好久没有调出来，实在是没有办法，用STC8的内置IIC，一次通过了，后来才在STC15里面用端口模拟出来，分享给大家。
/**********************************************************************
主芯片：STC15W4K32S4   QFP-48  芯片供电：3.30V  时钟：内置11.0592M  工程建立日期:2019.05.22                       
**********************************************************************/
#include"RX8025.h"
#include "STC15F2K60S2.H"
#include"delays.h"
sbit scl  = P2^4;//
sbit sda  = P2^5;//
/*                 秒        分钟      小时      日       月      星期    */
unsigned char TIM_Second,TIM_Minute,TIM_Hour,TIM_Date,TIM_Month,TIM_Week;
unsigned int TIM_Year; //年

void Delay_us(unsigned char i)
{
    while(i--);
}

void start(void)
{
    scl=1;
        Delay_us(5);
        sda=0;   
    Delay_us(5);
        scl=0;
}

void stop(void)
{
    sda=0;
    Delay_us(5);
    scl=1;
    Delay_us(5);
    sda=1;
    Delay_us(5);
}

void iicinit(void)
{
        scl=1;
        Delay_us(5);
        sda=1;       
}

unsigned char iicwr_byte(unsigned char dat)//写数据
{
        unsigned char i;
        sda=1;       
        for(i=0;i<8;i++)
        {
                scl=0;
                Delay_us(2);
                if(dat&0x80)
                {
                        sda=1;
                }
                else
                {
                        sda=0;
                }

                dat<<=1;               
                scl=1;
                Delay_us(5);
        }
        scl=0;
        Delay_us(5);
        sda=1;
        scl=1;
        Delay_us(5);
        scl=0;
        i=sda;
        return i;
}

unsigned char iicre_byte(unsigned char x)//读数据 x:1为ACK，x:0为NACK
{
        unsigned char i,dat;
        sda=1;
        for(i=0;i<8;i++)
        {
                scl=0;
                Delay_us(2);
                dat<<=1;
                dat|=sda;
                scl=1;
                Delay_us(5);
        }
        scl=0;       
        if(x)
        {
                sda=0;       
        }
        else
        {
                sda=1;
        }
        Delay_us(5);
        scl=1;
        Delay_us(5);
        scl=0;
        return dat;
}

void READ_TIM(void)
{
        start();
        iicwr_byte(0x64);
        Delay_us(50);
        iicwr_byte(0x00);
        Delay_us(50);
        start();                  
        iicwr_byte(0x65);
        Delay_us(50);
        TIM_Second=iicre_byte(1);
        Delay_us(50);
        TIM_Minute=iicre_byte(1);
        Delay_us(50);
        TIM_Hour=iicre_byte(0);
        Delay_us(50);
        stop();                       
}

void READ_Date(void)
{
        start();                 
        iicwr_byte(0x64);  
        Delay_us(50);
        iicwr_byte(0x03);
        Delay_us(50);
        start();                  
        iicwr_byte(0x65);  
        Delay_us(50);
        TIM_Week=iicre_byte(1);
        Delay_us(50);
        TIM_Date=iicre_byte(1);
        Delay_us(50);
        TIM_Month=iicre_byte(0);
        Delay_us(50);
        stop();
}
void SET_YEAR(unsigned char YE)
{
        start();                  
        iicwr_byte(0x64);  
        Delay_us(50);
        iicwr_byte(0x06);
        Delay_us(50);
        iicwr_byte(YE);
        Delay_us(50);
        stop();
}
void SET_DAY(unsigned char M,unsigned char D)
{
        start();                  
        iicwr_byte(0x64);  
        Delay_us(50);
        iicwr_byte(0x04);  
        Delay_us(50);
        iicwr_byte(D);  
        Delay_us(50);
        iicwr_byte(M);  
        Delay_us(50);
        stop();
}
void SET_WEEK(unsigned char W)
{
        start();                  
        iicwr_byte(0x64);  
        Delay_us(50);
        iicwr_byte(0x03);  
        Delay_us(50);
        iicwr_byte(W);
        Delay_us(50);
        stop();
}
void SET_TIME(unsigned char H,unsigned char M,unsigned char S)
{
        start();                  
        iicwr_byte(0x64);
        Delay_us(50);
        iicwr_byte(0x00);
        Delay_us(50);
        iicwr_byte(S);  
        Delay_us(50);
        iicwr_byte(M);
        Delay_us(50);
        iicwr_byte(H);
        Delay_us(50);
        stop();
}
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
8条回答
meirenai
2020-01-14 11:35
分享个软件 I2C 代码吧，不同的I2C芯片很好移植，我用这个代码驱动了好多I2C器件了。AT24Cxx、MPU6050、PCF8563、SE8025、DS3231、SHT31

softiic.h
  1. #ifndef _SOFT_IIC_H_
  2. #define _SOFT_IIC_H_

  4. #ifdef __cplusplus
  5. extern "C"
  6. {
  7. #endif

  9. #include <stdint.h>

  11.     typedef struct
  12.     {
  13.         uint8_t dev_addr;

  15.         //配置clk dat 端口操作接口
  16.         void (*clk)(uint8_t chByte);
  17.         void (*dat)(uint8_t chByte);
  18.         uint8_t (*get_dat)(void);

  20.         void (*delay)(void); //延时函数
  21.     } softiic_t;

  23.     extern void softiic_interface_register(softiic_t *iic,
  24.                                            uint8_t dev_addr,
  25.                                            void (*clk)(uint8_t chByte),
  26.                                            void (*dat)(uint8_t chByte),
  27.                                            uint8_t (*get_dat)(void),
  28.                                            void (*delay)(void));

  30.     extern void softiic_start(softiic_t *iic);
  31.     extern void softiic_stop(softiic_t *iic);
  32.     extern void softiic_tack(softiic_t *iic);
  33.     extern void softiic_tnack(softiic_t *iic);
  34.     extern int softiic_ckack(softiic_t *iic);

  36.     extern void softiic_write_byte(softiic_t *iic, uint8_t chByte);
  37.     extern void softiic_read_byte(softiic_t *iic, uint8_t *pchByte);

  39.     extern void softiic_write_buff(softiic_t *iic, uint8_t addr, uint16_t len, uint8_t *buff);
  40.     extern void softiic_read_buff(softiic_t *iic, uint8_t addr, uint16_t len, uint8_t *buff);

  42.     extern void softiic_write_bits(softiic_t *iic, uint8_t addr, uint8_t mask, uint8_t data);
  43.     extern void softiic_read_bits(softiic_t *iic, uint8_t addr, uint8_t mask, uint8_t *data);

  45. #ifdef __cplusplus
  46. }
  47. #endif

  49. #endif
复制代码

softiic.c
  1. #include "softiic.h"

  3. void softiic_start(softiic_t *iic)
  4. {
  5.     //  iic->clk(0);
  6.     //  iic->delay();
  7.     iic->dat(1);
  8.     iic->delay();
  9.     iic->clk(1);
  10.     iic->delay();
  11.     iic->dat(0);
  12.     iic->delay();
  13.     iic->clk(0);
  14.     iic->delay();
  15. }

  17. void softiic_stop(softiic_t *iic)
  18. {
  19.     iic->dat(0);
  20.     iic->delay();
  21.     iic->clk(1);
  22.     iic->delay();
  23.     iic->dat(1);
  24.     iic->delay();
  25.     //  iic->dat(0);
  26.     //  iic->delay();
  27.     iic->clk(0);
  28.     iic->delay();
  29. }

  31. void softiic_tack(softiic_t *iic)
  32. {
  33.     iic->clk(0);
  34.     iic->delay();
  35.     iic->dat(0);
  36.     iic->delay();
  37.     iic->clk(1);
  38.     iic->delay();
  39.     iic->clk(0);
  40.     iic->delay();
  41. }

  43. void softiic_tnack(softiic_t *iic)
  44. {
  45.     iic->clk(0);
  46.     iic->delay();
  47.     iic->dat(1);
  48.     iic->delay();
  49.     iic->clk(1);
  50.     iic->delay();
  51.     iic->clk(0);
  52.     iic->delay();
  53. }

  55. // NOTE 注意检测延时
  56. int softiic_ckack(softiic_t *iic)
  57. {
  58.     uint16_t timeout = 0;

  60.     iic->dat(1);
  61.     iic->delay();
  62.     iic->clk(1);
  63.     iic->delay();
  64.     while (iic->get_dat()) {
  65.         timeout++;
  66.         if (timeout >= 10) {
  67.             iic->clk(0);
  68.             iic->delay();
  69.             return 1;
  70.         }
  71.     }
  72.     iic->clk(0);
  73.     iic->delay();

  75.     return 0;
  76. }

  78. void softiic_write_byte(softiic_t *iic, uint8_t chByte)
  79. {
  80.     uint8_t i;

  82.     for (i = 0; i < 8; i++) {
  83.         if (chByte & 0x80) {
  84.             iic->dat(1);
  85.         } else {
  86.             iic->dat(0);
  87.         }
  88.         iic->delay();
  89.         iic->clk(1);
  90.         iic->delay();
  91.         iic->clk(0);
  92.         iic->delay();
  93.         chByte = chByte << 1;
  94.     }
  95. }

  97. void softiic_read_byte(softiic_t *iic, uint8_t *pchByte)
  98. {
  99.     uint8_t i;

  101.     for (i = 0; i < 8; i++) {
  102.         iic->dat(1);
  103.         iic->delay();
  104.         iic->clk(1);
  105.         iic->delay();
  106.         *pchByte = *pchByte << 1;
  107.         if (iic->get_dat()) {
  108.             *pchByte = *pchByte | 0x01;
  109.         }
  110.         iic->delay();
  111.         iic->clk(0);
  112.         iic->delay();
  113.     }
  114. }

  116. void softiic_read_buff(softiic_t *iic, uint8_t addr, uint16_t len, uint8_t *buff)
  117. {
  118.     uint8_t chByte;

  120.     softiic_start(iic);
  121.     softiic_write_byte(iic, iic->dev_addr);
  122.     softiic_ckack(iic);

  124.     softiic_write_byte(iic, addr);
  125.     softiic_ckack(iic);

  127.     softiic_start(iic);
  128.     softiic_write_byte(iic, iic->dev_addr | 0x01);
  129.     softiic_ckack(iic);
  130.     while (len) {
  131.         softiic_read_byte(iic, &chByte);
  132.         *buff = chByte;
  133.         if (len == 1) {
  134.             softiic_tnack(iic);
  135.         } else {
  136.             softiic_tack(iic);
  137.         }
  138.         buff++;
  139.         len--;
  140.     }
  141.     softiic_stop(iic);
  142. }

  144. void softiic_write_buff(softiic_t *iic, uint8_t addr, uint16_t len, uint8_t *buff)
  145. {
  146.     softiic_start(iic);
  147.     softiic_write_byte(iic, iic->dev_addr);
  148.     softiic_ckack(iic);

  150.     softiic_write_byte(iic, addr);
  151.     softiic_ckack(iic);

  153.     while (len) {
  154.         softiic_write_byte(iic, *buff);
  155.         softiic_ckack(iic);
  156.         buff++;
  157.         len--;
  158.     }
  159.     softiic_stop(iic);
  160. }

  162. void softiic_write_bits(softiic_t *iic, uint8_t addr, uint8_t mask, uint8_t data)
  163. {
  164.     uint8_t chByte;

  166.     softiic_read_buff(iic, addr, 1, &chByte);
  167.     chByte &= ~mask;
  168.     chByte |= data;
  169.     softiic_write_buff(iic, addr, 1, &chByte);
  170. }

  172. void softiic_read_bits(softiic_t *iic, uint8_t addr, uint8_t mask, uint8_t *data)
  173. {
  174.     uint8_t chByte;

  176.     softiic_read_buff(iic, addr, 1, &chByte);
  177.     chByte &= mask;
  178.     *data = chByte;
  179. }

  181. /**
  182. * @brief  IIC接口注册函数
  183. * @note
  184. * @param  *iic:
  185. * @param  (*clk:
  186. * @retval None
  187. */
  188. void softiic_interface_register(softiic_t *iic,
  189.                                 uint8_t dev_addr,
  190.                                 void (*clk)(uint8_t chByte),
  191.                                 void (*dat)(uint8_t chByte),
  192.                                 uint8_t (*get_dat)(void),
  193.                                 void (*delay)(void))
  194. {
  195.     iic->clk = clk;
  196.     iic->dat = dat;
  197.     iic->get_dat = get_dat;
  198.     iic->delay = delay;

  200.     iic->dev_addr = dev_addr;
  201. }
复制代码

rtc_se8025.h
  1. #ifndef __RTC_SE8025_H__
  2. #define __RTC_SE8025_H__

  4. #include "app.h"
  5. #include "softiic.h"

  7. extern void rtc_se8025_init(void);
  8. extern void rtc_se8025_task(void);

  10. extern void rtc_se8025_set_time(uint8_t *buff);

  12. #endif
复制代码

rtc_se8025.c
  1. #include "rtc_se8025.h"

  3. #define RTC_TIME(n) ((n) / 100)

  5. #if 1
  6. #define SE8025_DEBUG(...)
  7. #else
  8. #define SE8025_DEBUG(...)                                                                                             
  9.     do {                                                                                                               
  10.         debug_printf("[RTC]");                                                                                         
  11.         debug_printf(__VA_ARGS__);                                                                                    
  12.     } while (0)
  13. #endif

  15. #define BCD2CONVER(__VALUE, __MAST) ((__VALUE & (__MAST)) >> 4) * 10 + ((__VALUE)&0X0F) // BCD转HEX

  17. #define SCL_H()                                                                                                        
  18.     do {                                                                                                               
  19.         HAL_GPIO_WritePin(RTC_CLK_PIN_GPIO_Port, RTC_CLK_PIN_Pin, GPIO_PIN_SET);                                       
  20.     } while (0)
  21. #define SCL_L()                                                                                                        
  22.     do {                                                                                                               
  23.         HAL_GPIO_WritePin(RTC_CLK_PIN_GPIO_Port, RTC_CLK_PIN_Pin, GPIO_PIN_RESET);                                    
  24.     } while (0)
  25. #define SDA_H()                                                                                                        
  26.     do {                                                                                                               
  27.         HAL_GPIO_WritePin(RTC_DAT_PIN_GPIO_Port, RTC_DAT_PIN_Pin, GPIO_PIN_SET);                                       
  28.     } while (0)
  29. #define SDA_L()                                                                                                        
  30.     do {                                                                                                               
  31.         HAL_GPIO_WritePin(RTC_DAT_PIN_GPIO_Port, RTC_DAT_PIN_Pin, GPIO_PIN_RESET);                                    
  32.     } while (0)
  33. #define SDA_IS_H() (HAL_GPIO_ReadPin(RTC_DAT_PIN_GPIO_Port, RTC_DAT_PIN_Pin) != GPIO_PIN_RESET)

  35. static void clk(uint8_t chByte)
  36. {
  37.     if (chByte) {
  38.         SCL_H();
  39.     } else {
  40.         SCL_L();
  41.     }
  42. }

  44. static void dat(uint8_t chByte)
  45. {
  46.     if (chByte) {
  47.         SDA_H();
  48.     } else {
  49.         SDA_L();
  50.     }
  51. }

  53. static uint8_t get_dat(void)
  54. {
  55.     if (SDA_IS_H()) {
  56.         return 1;
  57.     } else {
  58.         return 0;
  59.     }
  60. }

  62. static void delay()
  63. {
  64.     uint16_t i = 2;
  65.     while (i--)
  66.         ;
  67. }

  69. softiic_t se8025;

  71. void rtc_se8025_set_time(uint8_t *buff)
  72. {
  73.     uint8_t array[7];

  75.     array[6] = (buff[0] / 10 * 16) + (buff[0] % 10);
  76.     array[5] = (buff[1] / 10 * 16) + (buff[1] % 10);
  77.     array[4] = (buff[2] / 10 * 16) + (buff[2] % 10);
  78.     array[2] = (buff[3] / 10 * 16) + (buff[3] % 10);
  79.     array[1] = (buff[4] / 10 * 16) + (buff[4] % 10);
  80.     array[0] = (buff[5] / 10 * 16) + (buff[5] % 10);
  81.     array[3] = 0;
  82.     softiic_write_buff(&se8025, 0, 7, array);
  83. }

  85. void rtc_se8025_read_time()
  86. {
  87.     uint8_t buff[16];

  89.     softiic_read_buff(&se8025, 0, 16, buff);

  91.     run_param.dateTime[5] = BCD2CONVER(buff[0], 0X70); //秒
  92.     run_param.dateTime[4] = BCD2CONVER(buff[1], 0X70); //分
  93.     run_param.dateTime[3] = BCD2CONVER(buff[2], 0X30); //时

  95.     // run_param.dateTime[6] = buff[3];                   //星期
  96.     run_param.dateTime[2] = BCD2CONVER(buff[4], 0X30); //日
  97.     run_param.dateTime[1] = BCD2CONVER(buff[5], 0X10); //月
  98.     run_param.dateTime[0] = BCD2CONVER(buff[6], 0XF0); //年
  99. }

  101. void rtc_se8025_init(void)
  102. {
  103.     softiic_interface_register(&se8025, 0x64, clk, dat, get_dat, delay);

  105.     rtc_se8025_read_time();

  107.     debug_printf("[RTC]20%02d-%02d-%02d %02d:%02d:%02d ", run_param.dateTime[0], run_param.dateTime[1],
  108.                  run_param.dateTime[2], run_param.dateTime[3], run_param.dateTime[4], run_param.dateTime[5]);
  109. }

  111. void rtc_se8025_task(void)
  112. {
  113.     static uint16_t s_hwTimeCnt = 0;

  115.     rtc_se8025_read_time();

  117.     if (++s_hwTimeCnt >= RTC_TIME(1000)) {
  118.         s_hwTimeCnt = 0;
  119.         if (run_param.timeSyncCntDown) {
  120.             run_param.timeSyncCntDown--;
  121.         }

  123.         SE8025_DEBUG("20%02d-%02d-%02d %02d:%02d:%02d ", run_param.dateTime[0], run_param.dateTime[1],
  124.                      run_param.dateTime[2], run_param.dateTime[3], run_param.dateTime[4], run_param.dateTime[5]);

  126.         LED_FB_TOGGLE(LED_DBG2_PIN_GPIO_Port, LED_DBG2_PIN_Pin);
  127.     }
  128. }
复制代码

一周热门 更多>