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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机驱动温湿度芯片AHT20和RX8025时钟芯片
返回列表 发新帖
查看: 516|回复: 0
打印 上一主题 下一主题
收起左侧

51单片机驱动温湿度芯片AHT20和RX8025时钟芯片

[复制链接]
跳转到指定楼层
楼主
ID:1059811 发表于 2023-12-8 16:07 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
//新时钟芯片搞定,读写都可以,在OLED屏和串口正常显示,温湿度参数和时间日期参数

制作出来的实物图如下：



电路原理图如下：


STC15W4K56S4单片机源程序如下:
  1. //** Descriptions:                       
  2. //------------------------------------------------------------------------------------
  3. #define MAIN_Fosc        11059200L    //定义主时钟
  4. #include    "15W4KxxS4.H"
  5. #include <intrins.h>         // 加入此头文件后,可使用_nop_库函数
  6. #include <string.h>           // 加入此头文件后,可使用strstr库函数
  7. #include "oled.h"
  8. #include "bmp.h"
  9. #include "AHT20.h"
  10. #include "stdio.h"
  11. #define  uint8 unsigned char  //0-256
  12. #define  uint16  unsigned int //0-65535
  13. #define  uint32  unsigned long  //-100亿--+100亿


  16. #define BAUD 9600               
  17. #define TM (65536 - (MAIN_Fosc/4/BAUD))   
  18. #define Buf_Max 20    //串口7S1这里要设定到34，日期就可以正常显示了
  19. #define S2_S  0x01   

  21. #define S2RI 0x01
  22. #define S2TI 0x02

  24. #define S3RI 0x01
  25. #define S3TI 0x02

  27. #define S4RI 0x01
  28. #define S4TI 0x02

  30. #define Write 0X64
  31. #define Read  0X65

  33. uint8 xdata Rec_Buf1[Buf_Max];//4个串口的接收缓存     
  34. uint8 xdata Rec_Buf2[Buf_Max];     
  35. uint8 xdata Rec_Buf3[Buf_Max];      
  36. uint8 xdata Rec_Buf4[Buf_Max];

  38. uint8 i = 0; //串口3数组计数器            
  39. uint8 j = 0; //串口4数组计数器

  41. #define ACK 0
  42. #define NOACK 1
  43. sbit RX8025SCL = P0^2;
  44. sbit RX8025SDA = P0^3;

  46. //extern u8 xdata RX8025TimeBuffH[];RX8025SDA        

  48. u8 xdata RX8025YMD[]="2020-12-07"; //这里不设定参数,下面数组设
  49. u8 xdata RX8025HMS[]="12:34:56";

  51. u8 xdata RX8025TimeBuffH[]={11,24,9,4,8,12,23};//修改日期时钟,中间的是星期
  52. u8 xdata RX8025TImeBuffB[]={0X01,0X02,0X03,0X04,0X05,0X06,0X07};

  54. //----------------------------------------------------------------------------------------
  55. //-----------------------串口1初始化函数.注意该芯片有4个串口,1口中断优先级最高
  56. void Uart1_Init(void)
  57. {   
  58.            SCON = 0x50;                //8位数据,可变波特率
  59.         AUXR |= 0x40;                //定时器时钟1T模式
  60.         AUXR &= 0xFE;                //串口1选择定时器1为波特率发生器
  61.         TMOD &= 0x0F;                //设置定时器模式
  62.         TL1 = 0xE0;                        //设置定时初始值
  63.         TH1 = 0xFE;                        //设置定时初始值
  64.         ET1 = 0;                        //禁止定时器中断
  65.         TR1 = 1;                        //定时器
  66. }
  67. //---------------------------------- 串口1发送数据函数
  68. void SendDataByUart1(uint8 dat)
  69. {
  70.     SBUF = dat;                 //写数据到UART数据寄存器
  71.         while(TI == 0);             //在停止位没有发送时，TI为0即一直等待
  72.         TI = 0;                     //清除TI位（该位必须软件清零）
  73. }
  74. //------------------------===========串口1发送字符串函数

  76. void SendStringByUart1(uint8 *s)
  77. {
  78.     while(*s)
  79.     {
  80.         SendDataByUart1(*s++);//将字符串中的字符一个一个发送
  81.     }
  82. }
  83. //----------------------清除串口1缓存内容函数

  85. void CLR_Buf1(void)
  86. {
  87.     uint8 k;
  88.     for(k=0;k<Buf_Max;k++)      //将串口1缓存数组的值都清为零
  89.         {
  90.                Rec_Buf1[k] = 0;
  91.           }
  92.     i = 0;                    
  93. }
  94. //-----------------------------------串口1握手判断函数
  95. bit Hand1(uint8 *a)
  96. {
  97.     if(strstr(Rec_Buf1,a)!=NULL)     //判断字符串a是否是字符串Rec_Buf1的子串
  98.         return 1;                      //如果字符串a是字符串Rec_Buf1的子串
  99.       else
  100.           return 0;                      //如果字符串a不是字符串Rec_Buf1的子串
  101. }

  103. //------------------------------------下面串口1接收中断-----------------------

  105. void Uart1() interrupt UART1_VECTOR using 1
  106. {
  107.     ES = 0;                       // 串口1中断关闭
  108.     if (RI)                       //串行接收到停止位的中间时刻时，该位置1
  109.   {
  110.       RI = 0;                     //清除RI位 （该位必须软件清零）
  111.             Rec_Buf1[i] = SBUF;       //把串口1缓存SBUF寄存器数据依次存放到数组Rec_Buf1中
  112.             i++;                     
  113.         if(i>Buf_Max)             //接收数大于定义接收数组最大个数时，覆盖接收数组之前值
  114.                 {   

  116.                     i = 0;                 
  117.                 }           
  118.    }

  120.      ES =  1;                   // 串口1中断打开
  121. }
  122. //================================================================================
  123. //----------------------------------------------------------------------------------------
  124. /*********BCD码转十六进制************/
  125. u8 BCDtoHEX(u8 BCD )
  126. {
  127.         return ( ( (BCD/16)*10) +BCD%16 );
  128. }

  130. /**********十六进制转BCD码*************/
  131. u8  HEXtoBCD(u8 Hex)
  132. {
  133.         return  ( ((Hex/10)<<4) +Hex%10 );
  134. }

  136. /*********I2C延时***********/
  137. void I2CWait()
  138. {        
  139.         u8 i;
  140.         for(i=0;i<10;i++)
  141.         {
  142.                 _nop_();_nop_();_nop_();_nop_();
  143.         }
  144. }

  146. bit I2C_Start2()
  147. {
  148.         RX8025SDA = 1;        //释放总线
  149.         RX8025SCL = 1;
  150.         I2CWait();
  151.         if(!RX8025SDA)        return 0;        //总线忙退出
  152.         RX8025SDA = 0;
  153.         I2CWait();
  154.         while(RX8025SDA) return 0;        //总线为高电平则总线出错，退出
  155.         RX8025SCL = 0;
  156.         I2CWait();
  157.         //return 1;
  158. }

  160. void I2C_Stop()
  161. {
  162.         RX8025SCL = 0;
  163.         RX8025SDA = 0;
  164.         I2CWait();
  165.         RX8025SCL = 1;
  166.         I2CWait();
  167.         RX8025SDA = 1;        
  168. }

  170. /********主机向从机发送ACK****
  171. a=0,发送ACk        a=1,发送NO ACK
  172. ******************************/
  173. void I2CSendACK(u8 a)
  174. {
  175.         RX8025SDA = a;
  176.         RX8025SCL = 0;
  177.         I2CWait();
  178.         RX8025SCL = 1;
  179.         I2CWait();
  180.         RX8025SCL = 0;
  181. }

  183. /*********主机读取从机ACK信号***/
  184. bit I2CReceivedACK()
  185. {
  186.         u8 errtime=255;
  187.         RX8025SCL = 0;
  188.         RX8025SDA = 1;        //释放总线
  189.         I2CWait();
  190.         RX8025SCL = 1;
  191.         I2CWait();
  192.         while(RX8025SDA)        //读取 SDA上的电平，变为低电平，即有从机回复ACK信号
  193.         {
  194.                 errtime--;
  195.                 if(!errtime)        //超时退出
  196.                 {
  197.                         RX8025SCL=0;
  198.                         return 0;
  199.                 }
  200.         }
  201.         RX8025SCL=0;
  202.         return 1;
  203. }

  205. /******************************************
  206. 主机向从机发送一字节数据-->dat
  207. order=0:先发送LSB，最后发送MSB
  208. order=1:先发送MSB；最后发送LSB
  209. 之所以设置order这个入口参数，是为了程序方便
  210. 移植，适应多个IIC芯片，只需设置order就能改变
  211. 数据传输方向，RX8025芯片 order 一直为 1
  212. ******************************************/
  213. void IIC_Send_Byte(u8 dat, bit order)
  214. {
  215.         u8 i;
  216.         if(order)
  217.         {
  218.                 for(i=0;i<8;i++)
  219.                 {
  220.                         RX8025SDA = dat&0X80;
  221.                         RX8025SCL = 1;
  222.                         I2CWait();
  223.                         RX8025SCL = 0;
  224.                         dat<<=1;
  225.                         I2CWait();
  226.                 }
  227.         }
  228.         else
  229.         {
  230.                 for(i=0;i<8;i++)
  231.                 {
  232.                         RX8025SDA = dat&0X01;
  233.                         RX8025SCL = 1;
  234.                         I2CWait();
  235.                         RX8025SCL = 0;
  236.                         dat>>=1;
  237.                         I2CWait();
  238.                 }
  239.         }
  240. }

  242. /*********读取一字节数据*********
  243. order=0:先读取LSB，最后读取MSB
  244. order=1:先去读MSB，最后读取LSB
  245. ********************************/
  246. u8 IIC_Receive_Byte(bit order)
  247. {
  248.         u8 i,j,Rdat;
  249.         RX8025SDA = 1;        //释放总线
  250.         if(order)        //MSB-->LSB
  251.         {
  252.                 for(i=0;i<8;i++)
  253.                 {
  254.                         RX8025SCL = 0;
  255.                         I2CWait();
  256.                         Rdat =( Rdat<<1 )| RX8025SDA;
  257.                         RX8025SCL = 1;
  258.                         I2CWait();
  259.                 }
  260.         }
  261.         else        //LSB-->MSB
  262.         {
  263.                 for(i=0;i<8;i++)
  264.                 {
  265.                         RX8025SCL = 0;
  266.                         I2CWait();
  267.                         j=RX8025SDA;
  268.                         Rdat =( Rdat>>1 )| (j<<7);
  269.                         RX8025SCL = 1;
  270.                         I2CWait();
  271.                 }
  272.         }
  273.         RX8025SCL=0;
  274.         return Rdat;
  275. }

  277. /******读取RX8025一个寄存器的数据*****/
  278. //u8 Read_RX8025_Byte(u8 add)
  279. //{
  280. //        u8 Ridat;
  281. //        I2C_Start2();
  282. //        IIC_Send_Byte(Write,1);
  283. //        if(!I2CReceivedACK())        //判断有无ACK信号
  284. //                I2C_Stop();
  285. //        IIC_Send_Byte(add,1);
  286. //        if(!I2CReceivedACK())        //判断有无ACK信号
  287. //                I2C_Stop();
  288. //        
  289. //        I2C_Start2();
  290. //        IIC_Send_Byte(Read,1);
  291. //        if(!I2CReceivedACK())        //判断有无ACK信号
  292. //                I2C_Stop();
  293. //        Ridat = IIC_Receive_Byte(1);        //读取数据
  294. //        I2CSendACK(1);
  295. //        I2C_Stop();
  296. //        return Ridat;
  297. //}

  299. //--单独向一个寄存器写数据
  300. void Write_RX8025_Byt(u8 add,u8 dat)
  301. {
  302.         u8 Bdat;
  303.         Bdat = dat;
  304.         //Bdat = HEXtoBCD(dat);        //将十六进制转换为BCD码
  305. //---开始写入数据               
  306.         I2C_Start2();
  307.         IIC_Send_Byte(Write,1);
  308.         if(!I2CReceivedACK())        //判断有无ACK信号
  309.                 I2C_Stop();
  310.         IIC_Send_Byte(add<<4,1);        //--根据手册在写入时地址要右移4位
  311.         if(!I2CReceivedACK())        //判断有无ACK信号
  312.                 I2C_Stop();
  313.         IIC_Send_Byte(Bdat,1);
  314.         I2CReceivedACK();
  315.         I2C_Stop();
  316. }

  318. //--连续读取时间、日历数据--
  319. //--add:读取的起始地址
  320. //--Num:读取数据的个数
  321. //--标准IIC连续读寄存器时序
  322. void Read_RX8025_Dat(u8 add, u8 Num)
  323. {
  324.         u8 i;
  325. //---先写读寄存器地址
  326.         I2C_Start2();
  327.         IIC_Send_Byte(Write,1);
  328.         if(!I2CReceivedACK())        //判断有无ACK信号
  329.                 I2C_Stop();
  330.         IIC_Send_Byte(add,1);        //秒寄存器地址
  331.         if(!I2CReceivedACK())        //判断有无ACK信号
  332.                 I2C_Stop();
  333. //---连续读取数据        
  334.         I2C_Start2();
  335.         IIC_Send_Byte(Read,1);
  336.         if(!I2CReceivedACK())        //判断有无ACK信号
  337.                 I2C_Stop();
  338.         for(i=0;i<Num;i++)
  339.         {
  340.                 RX8025TImeBuffB[i] = IIC_Receive_Byte(1);        //读取数据
  341.                 if(i!=6)I2CSendACK(0);
  342.         }
  343.         I2CSendACK(1);
  344.         I2C_Stop();
  345.         for(i=0;i<Num;i++)
  346.         {
  347.                 RX8025TimeBuffH[i] = BCDtoHEX(RX8025TImeBuffB[i]);
  348.         }
  349. }

  351. /*****向RX8025连续写num个数据******/
  352. void Write_RX8025_Byte(u8 add,u8 *Buff)
  353. {
  354.         u8 i;
  355. //---先写读寄存器地址
  356.         I2C_Start2();
  357.         IIC_Send_Byte(Write,1);
  358.         if(!I2CReceivedACK())        //判断有无ACK信号
  359.                 I2C_Stop();
  360.         IIC_Send_Byte(add<<4,1);
  361.         if(!I2CReceivedACK())        //判断有无ACK信号
  362.                 I2C_Stop();
  363.         for(i=0;i<7;i++)        //--连续写入7个时间日历数据
  364.         {
  365.                 Buff[i] = HEXtoBCD(Buff[i]);
  366.                 IIC_Send_Byte(Buff[i],1);
  367.                 I2CReceivedACK();
  368.         }
  369.         I2C_Stop();
  370. }

  372. void RX8025_Init()
  373. {
  374. //--12/24小时寄存器地址为0X0E,
  375.         Write_RX8025_Byt(0X0E,0X20);                //RX8025-T                24小时制
  376. //        Write_RX8025_Byt(0X0E,0X00);                //RX8025-T                12小时制
  377. }

  379. void DisplayTime()
  380. {

  382. //--显示RX8025的时间
  383.         Read_RX8025_Dat(0,7);        

  385.         RX8025YMD[2] = RX8025TimeBuffH[6]/10; //+0X30; 年
  386.         RX8025YMD[3] = RX8025TimeBuffH[6]%10; //+0X30;
  387.         
  388.         RX8025YMD[5] = RX8025TimeBuffH[5]/10; //+0X30;         月
  389.         RX8025YMD[6] = RX8025TimeBuffH[5]%10; //+0X30;
  390.         
  391.         RX8025YMD[8] = RX8025TimeBuffH[4]/10;// +0X30; 日
  392.         RX8025YMD[9] = RX8025TimeBuffH[4]%10; //+0X30;
  393.         
  394.         RX8025HMS[0] = RX8025TimeBuffH[2]/10;// +0X30;         时
  395.         RX8025HMS[1] = RX8025TimeBuffH[2]%10; //+0X30;
  396.         
  397.         RX8025HMS[3] = RX8025TimeBuffH[1]%100/10; //+0X30; 分
  398.         RX8025HMS[4] = RX8025TimeBuffH[1]%10;// +0X30;
  399.         
  400.         RX8025HMS[6] = RX8025TimeBuffH[0]%100/10; //+0X30; 秒
  401.         RX8025HMS[7] = RX8025TimeBuffH[0]%10; //+0X30;        

  403. //        Write_ASCII3X16_N(0,7,0,"T3:RX8025");
  404. //        Write_ASCII3X16_N(0,8,0,RX8025YMD);        
  405. //        Write_ASCII3X16_N(2,9,0,RX8025HMS);        Write_6x16Font_N(12,9,0,WeekD);

  407. }   

  409. //==============================================================================
  410. int main()
  411. {
  412.   uint32 CT_data[2];
  413.         volatile float  c1,t1;
  414.         //
  415.         P0M0=0x00,P0M1=0x00;//我自己加的代码 3
  416.         P2M0=0x00,P2M1=0x00;//我自己加的代码 3
  417.         P1M0=0x00,P1M1=0x00;//我自己加的代码 3
  418.         P4M0=0x00,P4M1=0x00;//我自己加的代码 3
  419.         P5M0=0x00,P5M1=0x00;//我自己加的代码

  421.         Uart1_Init();
  422.         delay_msT(500);//①刚上电，产品芯片内部就绪需要时间，延时100~500ms,建议500ms
  423.          WDT_CONTR = 0x35;//        
  424.          OLED_Init(); //注意OLED的数据线正好在15W4K56的P06,P07端口，先等这两个IO打开才能正常启动OLED   
  425.      RX8025_Init();
  426.          Write_RX8025_Byte(0,RX8025TimeBuffH);//RX8025时钟芯片里写入日期时间参数,2020-5-1-12:00:00,

  428.         if((AHT20_Read_Status()&0x18)!=0x18)//②上电第一次发0x71读取状态字，判断状态字是否为0x18,如果不是0x18,进行寄存器初始化
  429.         {
  430.         AHT20_Start_Init(); //重新初始化寄存器
  431.         delay_msT(10);
  432.         }
  433.         

  435.         while(1)//③根据客户自己需求发测量命令读取温湿度数据，当前while（1）循环发测量命令读取温湿度数据，仅供参考
  436.         {          WDT_CONTR = 0x35;//

  438.       AHT20_Read_CTdata_crc(CT_data);  //crc校验后，读取AHT20的温度和湿度数据
  439.           c1 = ((float)CT_data[0]/1024/1024)*100;  //计算得到湿度值c1放大10倍
  440.       t1 = ((float)CT_data[1]/1024/1024)*200-50;//计算得到温度值t1放大10倍
  441.            
  442.                DisplayTime();

  444.           OLED_ShowString(0,0,"T=",8);//
  445.       OLED_ShowString(60,0,"H=",8);//
  446.             OLED_ShowNum(16,0,t1,4,12);//温度        
  447.           OLED_ShowNum(76,0,c1,4,12);//湿度        
  448.         
  449.          
  450.           OLED_ShowNum(0,1,2,1,12);// 年 2
  451.       OLED_ShowNum(8,1,0,1,12);// 年 0
  452.           OLED_ShowNum(16,1,RX8025YMD[2],1,12);// 年 2
  453.           OLED_ShowNum(24,1,RX8025YMD[3],1,12);// 年 3
  454.          
  455.       OLED_ShowNum(32,1,RX8025YMD[5],1,12);// 月
  456.           OLED_ShowNum(40,1,RX8025YMD[6],1,12);// 月

  458.           OLED_ShowNum(48,1,RX8025YMD[8],1,12);// 日 3         
  459.       OLED_ShowNum(56,1,RX8025YMD[9],1,12);// 日 3
  460.             OLED_ShowString(64,1,"-",8);//
  461.          
  462.           OLED_ShowNum(76,1,RX8025HMS[0],1,12);// 时 十位 1         
  463.           OLED_ShowNum(84,1,RX8025HMS[1],1,12);// 时 个位 2
  464.           OLED_ShowNum(92,1,RX8025HMS[3],1,12);// 分 十位 3         
  465.           OLED_ShowNum(100,1,RX8025HMS[4],1,12);//分 个位 4
  466.           OLED_ShowNum(108,1,RX8025HMS[6],1,12);//秒 十位 5         
  467.           OLED_ShowNum(116,1,RX8025HMS[7],1,12);//秒 个位 6
  468.          
  469.           SendDataByUart1(0x32);
  470.           SendDataByUart1(0x30);
  471.           SendDataByUart1(RX8025YMD[2]+0x30);//串口发 年        
  472.           SendDataByUart1(RX8025YMD[3]+0x30);
  473.                 SendDataByUart1(0x20);//发空格
  474.       SendDataByUart1(RX8025YMD[5]+0x30);//串口发 月        
  475.           SendDataByUart1(RX8025YMD[6]+0x30);
  476.                   SendDataByUart1(0x20);
  477.           SendDataByUart1(RX8025YMD[8]+0x30);//串口发 日        
  478.           SendDataByUart1(RX8025YMD[9]+0x30);
  479.                 SendDataByUart1(0x20);

  481.           SendDataByUart1(RX8025HMS[0]+0x30);//串口发 时
  482.           SendDataByUart1(RX8025HMS[1]+0x30);//
  483.                  SendDataByUart1(0x3a);//发冒号
  484.           SendDataByUart1(RX8025HMS[3]+0x30);//串口发 分
  485.           SendDataByUart1(RX8025HMS[4]+0x30);//
  486.                  SendDataByUart1(0x3a);
  487.           SendDataByUart1(RX8025HMS[6]+0x30);//串口发 秒
  488.           SendDataByUart1(RX8025HMS[7]+0x30);//
  489.                                  
  490.                
  491.                 delay_msT(4000);
  492.                  delay_msT(4000);
  493.          }

  495. }
复制代码
STC15W单片机同时驱动温湿度AHT20 时钟RX8025
原理图: 无
仿真: 无
代码: 程序.7z (74.71 KB, 下载次数: 31)
本主题由 admin 执行 审核通过

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶顶 踩踩
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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