21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 谁有PCA5555的历程
返回列表 发新帖我要提问

[STM32F1] 谁有PCA5555的历程

[复制链接]
1151|9
 楼主| dsh1989 发表于 2017-11-28 13:13 | 显示全部楼层 |阅读模式
pc
求助
回复

收藏1 举报

相关帖子
dongnanxibei 发表于 2017-11-28 13:57 | 显示全部楼层
这个是什么，都没听说过，百度都没找到。
回复

收藏1 举报

 楼主| dsh1989 发表于 2017-11-28 19:07 | 显示全部楼层
错了，是PCA9555
回复

收藏1 举报

Houtz 发表于 2017-11-29 09:16 | 显示全部楼层
这个非常简单的，I2C总线转换为16线并口，以前就做过。
回复

收藏1 举报

643757107 发表于 2017-11-29 09:33 | 显示全部楼层
1.德州仪器PCA9555-简化PCB布线，对处理器有限的IO口进行补充。


2.带中断，不带重启


3.24 引脚的CMOS器件，提供I2C/SMBus16位通用并行（GPIO）的扩展

4.地址：总共1字节（八位），前四位固定，（A0，A1，A2自定，最后一位，0为写，1为读。
回复

收藏1 举报

643757107 发表于 2017-11-29 09:34 | 显示全部楼层
pca9555.h
复制
  1. #ifndef __PCA9555_H
    

  2. #define __PCA9555_H         
    


  3. 

  4. extern u8 value_keep0_l,value_keep0_h,value_keep1_l,value_keep1_h,value_keep2_l,value_keep2_h;
    

  5. extern u8 parameters;
    

  6. extern u16 led_buf[5];
    

  7. extern u8 value_feedback0[2],value_feedback1[2],value_feedback2[2]; 
    

  8. extern u16 auto_off_time_count;
    

  9. extern u16 auto_open_off_time_count[16];
    

  10. extern u16 auto_close_off_time_count[16];
    

  11. extern u8 doorstate[16];
    

  12. extern u8 powerstate[8];
    

  13. extern u8 Refresh_Led;
    

  14. extern u8 Refresh_Power;
    


  15. 

  16. void delay(u32 conut);
    


  17. 

  18. void IIC_SDA_DIR_SET(u8 io_dir);
    

  19. void IIC_Ready(void); 
    

  20. void IIC_PORT_INIT(void);
    

  21. void IIC_Start(void);
    

  22. void IIC_Stop(void);
    

  23. void IIC_Ack(void);
    

  24. void IIC_Send_Ack(void);
    

  25. void IIC_Send_NoAck(void);
    

  26. void IIC_Write_Byte(u8 a);
    

  27. u8 IIC_Read_Byte(void);
    

  28. void IIC_Write_Pca9555(u8 addr,u8 reg_addr,u8 low_byte,u8 high_byte);
    

  29. void IIC_Read_Pca9555(u8 addr,u8 reg_addr,u8* pBuffer,u16 num);
    


  30. 

  31. void IIC_SDA_DIR_SET_LED(u8 io_dir);
    

  32. void IIC_Ready_LED(void); 
    

  33. void IIC_PORT_INIT_LED(void);
    

  34. void IIC_Start_LED(void);
    

  35. void IIC_Stop_LED(void);
    

  36. void IIC_Ack_LED(void);
    

  37. void IIC_Send_Ack_LED(void);
    

  38. void IIC_Send_NoAck_LED(void);
    

  39. void IIC_Write_Byte_LED(u8 a);
    

  40. u8 IIC_Read_Byte_LED(void);
    

  41. void IIC_Write_Pca9555_LED(u8 addr,u8 reg_addr,u8 low_byte,u8 high_byte);
    

  42. void IIC_Read_Pca9555_LED(u8 addr,u8 reg_addr,u8* pBuffer,u16 num);
    


  43. 

  44. void write1(u8 PCA9555_dengban_ADDR,u8 pro2,u8 pro3);         //控制灯板上的pca芯片
    

  45. void write2(u8 PCA9555_zkb_ADDR,u8 pro0,u8 pro1);                 //控制主控板的上pca芯片
    


  46. 


  47. 

  48. void I2C_ReadS_PCA9555(u8 PCA9555_zhukong_ADDR,u8 PCA9555_REG_IN,u8* pBuffer,u16 no);
    

  49. void I2C_ReadS_PCA95552(u8 PCA9555_dengban_ADDR,u8 PCA9555_REG_IN,u8* pBuffer,u16 no);
    

  50. void PCA9555_Init(void);
    

  51. void I2CM_Init(void) ;        
    


  52. 

  53. void Set_Value_To_Output(u8 num);
    

  54. void Clear_Value_To_Output(u8 num);
    

  55. void Change_Value_To_Output(u8 num,u8 value);
    

  56. void All_Off__To_Output(void);
    

  57. void All_On__To_Output(void);
    

  58. void All_Off__To_OpenDoor_Output(void);
    

  59. void All_On__To_OpenDoor_Output(void);
    

  60. void All_Off__To_Power_Output(void);
    

  61. void All_On__To_Power_Output(void);
    

  62. void All_Off__To_CloseDoor_Output(void);
    

  63. void All_On__To_CloseDoor_Output(void);
    

  64. u16 uart_deal_function(void);
    


  65. 

  66. void Led_Off_RGB(u8 num,u16 value);
    

  67. void Led_On_RGB(u8 num,u16 value);
    

  68. void Led_Off_R(u8 num);
    

  69. void Led_On_R(u8 num);
    

  70. void Led_Off_G(u8 num);
    

  71. void Led_On_G(u8 num);
    

  72. void Led_Off_B(u8 num);
    

  73. void Led_On_B(u8 num);         
    

  74. void All_Led_On(void);
    

  75. void All_Led_Off(void);
    


  76. 

  77. void Refresh_Door_Condition(void);
    

  78. void Refresh_Power_Condition(void);
    

  79. void Refresh_Door_Condition_Led(void);
    

  80. void Refresh_Power_Condition_Led(void);
    

  81. void PowerOn_Auto_CloseOff(void);                                    
    

  82. #endif
回复

收藏1 举报

643757107 发表于 2017-11-29 09:34 | 显示全部楼层
pca9555.c
复制

  1. 

  2. #include "stm32f10x.h"
    

  3. #include "pca9555.h"
    

  4. #include "usart.h"
    

  5. #include "timer2.h"
    

  6. #include "wdg.h"
    


  7. 

  8. #define SCL           GPIO_Pin_6
    

  9. #define SDA           GPIO_Pin_7
    

  10. #define SCL_LED           GPIO_Pin_10
    

  11. #define SDA_LED           GPIO_Pin_11
    

  12. #define IIC_BIT_DELAY           5
    

  13. #define DELAY                        delay(100)
    


  14. 

  15. //  定义PCA9555（NXP半导体I/O扩展芯片，I2C接口）    
    

  16. #define  PCA9555_SLA             (0x40 >> 1)                 //  定义PAC9555的器件地址    
    

  17. #define  PCA9555_REG_IN0         0x00                        //  定义输入寄存器0地址    
    

  18. #define  PCA9555_REG_IN1         0x01                        //  定义输入寄存器1地址    
    

  19. #define  PCA9555_REG_OUT0        0x02                        //  定义输出寄存器0地址    
    

  20. #define  PCA9555_REG_OUT1        0x03                        //  定义输出寄存器1地址    
    

  21. #define  PCA9555_REG_POL0        0x04                        //  定义极性反转寄存器0地址    
    

  22. #define  PCA9555_REG_POL1        0x05                        //  定义极性反转寄存器1地址 
    

  23. #define  PCA9555_REG_CFG0        0x06                        //  定义方向配置寄存器0地址    
    

  24. #define  PCA9555_REG_CFG1        0x07                        //  定义方向配置寄存器1地址      
    

  25. #define  PCA9555_DEVICE_ADDR     0x40                        //  定义PCA9555地址 
    


  26. 

  27. #define  LOOP_COUNT     10000
    


  28. 

  29. u8 pro0=0xff,pro1=0xff,pro2=0xff,pro3=0xff,PCA9555_dengban_ADDR,PCA9555_zkb_ADDR;
    


  30. 

  31. u8 value_keep0_l,value_keep0_h,value_keep1_l,value_keep1_h,value_keep2_l,value_keep2_h;
    

  32. u8 parameters;
    

  33. u16 led_buf[5];
    

  34. u8 value_feedback0[2],value_feedback1[2],value_feedback2[2];
    

  35. u16 auto_off_time_count; 
    

  36. u16 auto_open_off_time_count[16];
    

  37. u16 auto_close_off_time_count[16]; 
    

  38. u8 doorstate[16];
    

  39. u8 powerstate[8];
    

  40. u8 Refresh_Led=0;
    

  41. u8 Refresh_Power=0;
    

  42. /*//  定义全局变量    
    

  43. static unsigned long I2CM_BASE = I2C0_MASTER_BASE;  //  定义I2C主机基址，并初始化    
    

  44. static tI2CM_DEVICE gtDevice;                       //  器件数据接口    
    

  45. static unsigned short gusStatus = STAT_IDLE;        //  工作状态    
    

  46. //static tBoolean gbSendRecv;                         //  收发操作标志，false发送，true接收    
    

  47. static char gcAddr[4];                              //  数据地址数组    
    

  48. static unsigned short gusAddrIndex;                 //  数据地址数组索引变量    
    

  49. static unsigned short gusDataIndex;                 //  数据缓冲区索引变量    
    

  50.  */ 
    


  51. 

  52. void delay(u32 conut)
    

  53. {
    

  54.                 while(conut -- > 0);
    

  55. }
    


  56. 


  57. 

  58. void IIC_SDA_DIR_SET(u8 io_dir) //SDA引脚输入输出设置
    

  59. {
    

  60.         GPIO_InitTypeDef GPIO_InitStructure;
    

  61.         if(io_dir==0)
    

  62.         {
    

  63.                 GPIO_InitStructure.GPIO_Pin = SDA;
    

  64.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;//output
    

  65.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  66.                 GPIO_Init(GPIOB, &GPIO_InitStructure); 
    

  67.         }
    

  68.         else if(io_dir==1)
    

  69.         {
    

  70.                 GPIO_InitStructure.GPIO_Pin = SDA; 
    

  71.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//input  pull_up
    

  72.                 GPIO_Init(GPIOB, &GPIO_InitStructure); 
    

  73.         }
    

  74. }
    


  75. 

  76. void IIC_SDA_DIR_SET_LED(u8 io_dir) //SDA_LED引脚输入输出设置
    

  77. {
    

  78.         GPIO_InitTypeDef GPIO_InitStructure;
    

  79.         if(io_dir==0)
    

  80.         {
    

  81.                 GPIO_InitStructure.GPIO_Pin = SDA_LED;
    

  82.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;//output
    

  83.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  84.                 GPIO_Init(GPIOB, &GPIO_InitStructure); 
    

  85.         }
    

  86.         else if(io_dir==1)
    

  87.         {
    

  88.                 GPIO_InitStructure.GPIO_Pin = SDA_LED; 
    

  89.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//input  pull_up
    

  90.                 GPIO_Init(GPIOB, &GPIO_InitStructure); 
    

  91.         }
    

  92. }
    


  93. 

  94. void IIC_Ready(void)
    

  95. {
    

  96.    
    

  97.            GPIO_SetBits(GPIOB,SCL);
    

  98.           DELAY;
    

  99.            GPIO_SetBits(GPIOB,SDA);
    

  100.            DELAY;
    

  101. }
    

  102.  
    

  103. void IIC_PORT_INIT(void)
    

  104. {
    

  105.         GPIO_InitTypeDef GPIO_InitStructure;
    

  106.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE); 
    


  107. 

  108.          GPIO_InitStructure.GPIO_Pin = SCL|SDA;
    

  109.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    

  110.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  111.           GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  112.         
    

  113.         IIC_Ready(); 
    

  114. } 
    


  115. 

  116. void IIC_Start(void)
    

  117. {
    

  118.         GPIO_SetBits(GPIOB,SDA);
    

  119.         DELAY;
    

  120.         GPIO_SetBits(GPIOB,SCL);
    

  121.         DELAY;
    

  122.         GPIO_ResetBits(GPIOB, SDA);
    

  123.         DELAY;
    

  124. }
    


  125. 

  126. void IIC_Stop(void)
    


  127. 

  128. {
    

  129.         GPIO_ResetBits(GPIOB, SDA);
    

  130.         DELAY;
    

  131.         GPIO_SetBits(GPIOB,SCL);
    

  132.         DELAY;
    

  133.         GPIO_SetBits(GPIOB,SDA);
    

  134.         DELAY;
    

  135. }
    


  136. 

  137. void IIC_Ack(void)
    


  138. 

  139. {
    

  140.         u16 i;
    

  141.         GPIO_SetBits(GPIOB,SCL);
    

  142.         DELAY;
    

  143.         IIC_SDA_DIR_SET(1);
    

  144.         while(GPIO_ReadInputDataBit(GPIOB,SDA)&&(i<0x2b0)) {i++;}
    

  145.         IIC_SDA_DIR_SET(0);
    

  146.         GPIO_ResetBits(GPIOB,SCL);
    

  147.         DELAY;
    

  148. }
    


  149. 

  150. void IIC_Send_Ack(void)
    


  151. 

  152. {
    

  153.         GPIO_ResetBits(GPIOB,SDA);
    

  154.         DELAY;
    

  155.         GPIO_SetBits(GPIOB,SCL);
    

  156.         DELAY;
    

  157.         GPIO_ResetBits(GPIOB,SCL);
    

  158.         DELAY;
    

  159. }
    


  160. 

  161. void IIC_Send_NoAck(void)
    


  162. 

  163. {
    

  164.         GPIO_SetBits(GPIOB,SDA);
    

  165.         DELAY;
    

  166.         GPIO_SetBits(GPIOB,SCL);
    

  167.         DELAY;
    

  168.         GPIO_ResetBits(GPIOB,SCL);
    

  169.         DELAY;
    

  170. }
    


  171. 


  172. 

  173. void IIC_Write_Byte(u8 a)
    

  174. {
    

  175.         u16 i;
    

  176.         GPIO_ResetBits(GPIOB,SCL); //scl=0;
    

  177.         DELAY;
    

  178.         for(i=0;i<8;i++)
    

  179.         {
    

  180.                 if(a&0x80)
    

  181.                 GPIO_SetBits(GPIOB,SDA);//sda=1;
    

  182.                 else
    

  183.                 GPIO_ResetBits(GPIOB,SDA);
    


  184. 

  185.                 a=a<<1;
    

  186.                 GPIO_SetBits(GPIOB,SCL);//scl=1;
    

  187.                 DELAY;
    

  188.                 GPIO_ResetBits(GPIOB,SCL);//scl=0;
    

  189.                 DELAY;
    

  190.         }
    

  191.         GPIO_SetBits(GPIOB,SDA);//sda=1;
    

  192.         DELAY;
    

  193. }
    


  194. 

  195. u8 IIC_Read_Byte(void)
    

  196. {
    

  197.         u8 i,temp;
    

  198.         temp=0;
    

  199.         GPIO_SetBits(GPIOB,SDA);//sda=1;
    

  200.         DELAY;
    

  201.         GPIO_ResetBits(GPIOB,SCL); //scl=0;
    

  202.         DELAY;
    

  203.         IIC_SDA_DIR_SET(1);
    

  204.         for(i=0;i<8;i++)
    

  205.         {
    

  206.                 GPIO_SetBits(GPIOB,SCL); //scl=1;
    

  207.                 DELAY;
    

  208.                 DELAY;
    

  209.                 temp=(temp<<1)|GPIO_ReadInputDataBit(GPIOB,SDA);
    

  210.                 DELAY;
    

  211.                 GPIO_ResetBits(GPIOB,SCL); //scl=0;
    

  212.                 DELAY;
    

  213.         }
    

  214.         IIC_SDA_DIR_SET(0);
    

  215.         GPIO_SetBits(GPIOB,SDA);//sda=1;
    

  216.         DELAY;
    

  217.         //GPIO_ResetBits(GPIOB,SCL);//scl=0;
    

  218.         //DELAY;
    

  219.         return temp;
    

  220. }
    

  221. ////////////////////////////////////////////////////////////////////////////////
    

  222. /////////////////////////////////////////////////////////////////////////////////
    

  223. /////////////////////////////////////////////////////////////////////////////////
    

  224. void IIC_Ready_LED(void)
    

  225. {
    

  226.    
    

  227.            GPIO_SetBits(GPIOB,SCL_LED);
    

  228.           DELAY;
    

  229.            GPIO_SetBits(GPIOB,SDA_LED);
    

  230.            DELAY;
    

  231. }
    

  232.  
    

  233. void IIC_PORT_INIT_LED(void)
    

  234. {
    

  235.         GPIO_InitTypeDef GPIO_InitStructure;
    

  236.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE); 
    


  237. 

  238.          GPIO_InitStructure.GPIO_Pin = SCL_LED|SDA_LED;
    

  239.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    

  240.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  241.           GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  242.         
    

  243.         IIC_Ready_LED(); 
    

  244. } 
    


  245. 

  246. void IIC_Start_LED(void)
    

  247. {
    

  248.         GPIO_SetBits(GPIOB,SDA_LED);
    

  249.         DELAY;
    

  250.         GPIO_SetBits(GPIOB,SCL_LED);
    

  251.         DELAY;
    

  252.         GPIO_ResetBits(GPIOB, SDA_LED);
    

  253.         DELAY;
    

  254. }
    


  255. 

  256. void IIC_Stop_LED(void)
    


  257. 

  258. {
    

  259.         GPIO_ResetBits(GPIOB, SDA_LED);
    

  260.         DELAY;
    

  261.         GPIO_SetBits(GPIOB,SCL_LED);
    

  262.         DELAY;
    

  263.         GPIO_SetBits(GPIOB,SDA_LED);
    

  264.         DELAY;
    

  265. }
    


  266. 

  267. void IIC_Ack_LED(void)
    


  268. 

  269. {
    

  270.         u16 i;
    

  271.         GPIO_SetBits(GPIOB,SCL_LED);
    

  272.         DELAY;
    

  273.         IIC_SDA_DIR_SET_LED(1);
    

  274.         while(GPIO_ReadInputDataBit(GPIOB,SDA_LED)&&(i<0x2b0)) {i++;}
    

  275.         IIC_SDA_DIR_SET_LED(0);
    

  276.         GPIO_ResetBits(GPIOB,SCL_LED);
    

  277.         DELAY;
    

  278. }
    


  279. 

  280. void IIC_Send_Ack_LED(void)
    


  281. 

  282. {
    

  283.         GPIO_ResetBits(GPIOB,SDA_LED);
    

  284.         DELAY;
    

  285.         GPIO_SetBits(GPIOB,SCL_LED);
    

  286.         DELAY;
    

  287.         GPIO_ResetBits(GPIOB,SCL_LED);
    

  288.         DELAY;
    

  289. }
    


  290. 

  291. void IIC_Send_NoAck_LED(void)
    


  292. 

  293. {
    

  294.         GPIO_SetBits(GPIOB,SDA_LED);
    

  295.         DELAY;
    

  296.         GPIO_SetBits(GPIOB,SCL_LED);
    

  297.         DELAY;
    

  298.         GPIO_ResetBits(GPIOB,SCL_LED);
    

  299.         DELAY;
    

  300. }
    


  301. 

  302. void IIC_Write_Byte_LED(u8 a)
    

  303. {
    

  304.         u16 i;
    

  305.         GPIO_ResetBits(GPIOB,SCL_LED); //scl=0;
    

  306.         DELAY;
    

  307.         for(i=0;i<8;i++)
    

  308.         {
    

  309.                 if(a&0x80)
    

  310.                 GPIO_SetBits(GPIOB,SDA_LED);//sda=1;
    

  311.                 else
    

  312.                 GPIO_ResetBits(GPIOB,SDA_LED);
    


  313. 

  314.                 a=a<<1;
    

  315.                 GPIO_SetBits(GPIOB,SCL_LED);//scl=1;
    

  316.                 DELAY;
    

  317.                 GPIO_ResetBits(GPIOB,SCL_LED);//scl=0;
    

  318.                 DELAY;
    

  319.         }
    

  320.         GPIO_SetBits(GPIOB,SDA_LED);//sda=1;
    

  321.         DELAY;
    

  322. }
    


  323. 

  324. u8 IIC_Read_Byte_LED(void)
    

  325. {
    

  326.         u8 i,temp;
    

  327.         temp=0;
    

  328.         GPIO_SetBits(GPIOB,SDA_LED);//sda=1;
    

  329.         DELAY;
    

  330.         GPIO_ResetBits(GPIOB,SCL_LED); //scl=0;
    

  331.         DELAY;
    

  332.         IIC_SDA_DIR_SET_LED(1);
    

  333.         for(i=0;i<8;i++)
    

  334.         {
    

  335.                 GPIO_SetBits(GPIOB,SCL_LED); //scl=1;
    

  336.                 DELAY;
    

  337.                 DELAY;
    

  338.                 temp=(temp<<1)|GPIO_ReadInputDataBit(GPIOB,SDA_LED);
    

  339.                 DELAY;
    

  340.                 GPIO_ResetBits(GPIOB,SCL_LED); //scl=0;
    

  341.                 DELAY;
    

  342.         }
    

  343.         IIC_SDA_DIR_SET_LED(0);
    

  344.         GPIO_SetBits(GPIOB,SDA_LED);//sda=1;
    

  345.         DELAY;
    

  346.         //GPIO_ResetBits(GPIOB,SCL_LED);//scl=0;
    

  347.         //DELAY;
    

  348.         return temp;
    

  349. }
    


  350. 

  351. void IIC_Write_Pca9555(u8 addr,u8 reg_addr,u8 low_byte,u8 high_byte)
    

  352. {
    

  353.           IIC_Start();
    

  354.           IIC_Write_Byte(addr & 0xfe);
    

  355.           IIC_Ack();
    

  356.           IIC_Write_Byte(reg_addr);
    

  357.           IIC_Ack();
    

  358.           IIC_Write_Byte(low_byte);
    

  359.           IIC_Ack();
    

  360.           IIC_Write_Byte(high_byte);
    

  361.           IIC_Ack();
    

  362.           IIC_Stop();
    

  363. }
    


  364. 

  365. void IIC_Write_Pca9555_LED(u8 addr,u8 reg_addr,u8 low_byte,u8 high_byte)
    

  366. {
    

  367.           IIC_Start_LED();
    

  368.           IIC_Write_Byte_LED(addr & 0xfe);
    

  369.           IIC_Ack_LED();
    

  370.           IIC_Write_Byte_LED(reg_addr);
    

  371.           IIC_Ack_LED();
    

  372.           IIC_Write_Byte_LED(low_byte);
    

  373.           IIC_Ack_LED();
    

  374.           IIC_Write_Byte_LED(high_byte);
    

  375.           IIC_Ack_LED();
    

  376.           IIC_Stop_LED();
    

  377. }
    


  378. 

  379. void IIC_Read_Pca9555(u8 addr,u8 reg_addr,u8* pBuffer,u16 num)
    

  380. {
    

  381.           IIC_Start();
    

  382.           IIC_Write_Byte(addr & 0xfe);
    

  383.           IIC_Ack();
    

  384.           IIC_Write_Byte(reg_addr);
    

  385.           IIC_Ack();
    


  386. 

  387.           IIC_Start();
    

  388.           IIC_Write_Byte(addr | 0x01);
    

  389.           IIC_Ack();
    

  390.           while (num)
    

  391.           {
    

  392.                     *pBuffer = IIC_Read_Byte();
    

  393.                         if (num == 1)
    

  394.                         {
    

  395.                                 IIC_Send_NoAck();
    

  396.                         }
    

  397.                         else
    

  398.                         { 
    

  399.                                 IIC_Send_Ack();
    

  400.                         }        
    

  401.                     pBuffer++;
    

  402.                         num--;
    

  403.           }
    

  404.           IIC_Stop();
    

  405. }
    


  406. 

  407. void IIC_Read_Pca9555_LED(u8 addr,u8 reg_addr,u8* pBuffer,u16 num)
    

  408. {
    

  409.           IIC_Start_LED();
    

  410.           IIC_Write_Byte_LED(addr & 0xfe);
    

  411.           IIC_Ack_LED();
    

  412.           IIC_Write_Byte_LED(reg_addr);
    

  413.           IIC_Ack_LED();
    


  414. 

  415.           IIC_Start_LED();
    

  416.           IIC_Write_Byte_LED(addr | 0x01);
    

  417.           IIC_Ack_LED();
    

  418.           while (num)
    

  419.           {
    

  420.                     *pBuffer = IIC_Read_Byte_LED();
    

  421.                         if (num == 1)
    

  422.                         {
    

  423.                                 IIC_Send_NoAck_LED();
    

  424.                         }
    

  425.                         else
    

  426.                         { 
    

  427.                                 IIC_Send_Ack_LED();
    

  428.                         }        
    

  429.                     pBuffer++;
    

  430.                         num--;
    

  431.           }
    

  432.           IIC_Stop_LED();
    

  433. }
    


  434. 

  435. //  I2C主机初始化    
    

  436. void I2CM_Init(void)   
    

  437. {   
    

  438. //    I2CM_DeviceInitSet(>Device, 0, 0, 0, (void *)0, 0);   
    

  439.    
    

  440.             I2C_InitTypeDef  I2C_InitStructure;
    

  441.                   GPIO_InitTypeDef  GPIO_InitStructure; 
    


  442. 

  443.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2 | RCC_APB1Periph_I2C1,ENABLE);
    

  444.             RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    

  445.     
    


  446. 

  447.                 /* PB6,7 SCL and SDA */
    

  448.                 GPIO_InitStructure.GPIO_Pin =GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_10 | GPIO_Pin_11;
    

  449.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    

  450.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;         //设置管脚为复用功能开漏输出
    

  451.                 GPIO_Init(GPIOB, &GPIO_InitStructure);                  //
    

  452.         
    


  453. 

  454.                 I2C_DeInit(I2C2);
    

  455.                 I2C_DeInit(I2C1);
    

  456.             I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;                 //
    

  457.             I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;        //
    

  458.             I2C_InitStructure.I2C_OwnAddress1 = 0x30;                  //
    

  459.             I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;                //
    

  460.             I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    

  461.             I2C_InitStructure.I2C_ClockSpeed = 400000;                //
    

  462.     
    

  463.                 I2C_Cmd(I2C2, ENABLE);
    

  464.                 I2C_Cmd(I2C1, ENABLE);                                    //
    

  465.                 I2C_Init(I2C2, &I2C_InitStructure);                       //
    

  466.                 I2C_Init(I2C1, &I2C_InitStructure);
    

  467.                 I2C_AcknowledgeConfig(I2C2, ENABLE); 
    

  468.                 I2C_AcknowledgeConfig(I2C1, ENABLE); 
    

  469. }   
    


  470. 


  471. 

  472. //写主控板上的pca9555
    

  473. /*
    

  474.   u8 PCA9555_dengban_ADDR  芯片地址，0x40表示第一个芯片地址
    

  475.   u8 pro2  写入芯片的前八位数据
    

  476.   u8 pro3   写入芯片的前后位数据
    


  477. 

  478. */
    

  479. void write1(u8 PCA9555_dengban_ADDR,u8 pro2,u8 pro3)
    


  480. 

  481. {                         
    

  482. //__disable_irq ; 
    

  483.         
    

  484.         IIC_Write_Pca9555_LED(PCA9555_dengban_ADDR,0x02,pro2,pro3);
    

  485.         //IIC_Write_Pca9555_LED(PCA9555_dengban_ADDR,0x06,0x00,0x00);
    


  486. 

  487. //__enable_irq ;                            
    


  488. 


  489. 

  490. }
    


  491. 


  492. 

  493.  /********************************主控板上的pca555控制程序*********************************************/
    

  494.     
    

  495.   //////////////////////////////////////////////////////////////////写命令 i2c1操作的是主控板上的pca555
    

  496. void write2(u8 PCA9555_zkb_ADDR,u8 pro0,u8 pro1)
    

  497. {                        
    

  498. //__disable_irq ; 
    


  499. 

  500.         IIC_Write_Pca9555(PCA9555_zkb_ADDR,0x02,pro0,pro1);
    

  501.         //IIC_Write_Pca9555(PCA9555_zkb_ADDR,0x06,0x00,0x00);
    


  502. 

  503. //__enable_irq ;                            
    


  504. 

  505. }
    


  506. 


  507. 


  508. 


  509. 

  510. /*****************************读命令主控板*****************************************/
    


  511. 

  512. void I2C_ReadS_PCA9555(u8 PCA9555_zhukong_ADDR,u8 PCA9555_REG_IN,u8* pBuffer,u16 no)
    


  513. 

  514. {
    

  515. /*
    

  516.  *Read from register
    

  517.  */    
    

  518. //__disable_irq ;
    

  519.         //IIC_Write_Pca9555(PCA9555_zhukong_ADDR,0x06,0xff,0xff);         
    

  520.         IIC_Read_Pca9555(PCA9555_zhukong_ADDR,PCA9555_REG_IN,pBuffer,no);
    

  521. //__enable_irq ;   //开中断
    

  522. }
    


  523. 


  524. 


  525. 

  526.   /*****************************读命令灯板*****************************************/
    


  527. 

  528. void I2C_ReadS_PCA95552(u8 PCA9555_dengban_ADDR,u8 PCA9555_REG_IN,u8* pBuffer,u16 no)
    


  529. 

  530. {
    

  531. /*
    

  532.  *Read from register
    


  533. 

  534.  */
    

  535.                         
    

  536. //__disable_irq ; 
    

  537.          IIC_Read_Pca9555_LED(PCA9555_dengban_ADDR,PCA9555_REG_IN,pBuffer,no);
    

  538. //__enable_irq ;                            
    


  539. 

  540. }
    


  541. 


  542. 

  543. void Set_Value_To_Output(u8 num)
    

  544. {
    

  545.          if (num <17)
    

  546.          {
    

  547.                          if  (num <9)
    

  548.                         {
    

  549.                                    value_keep0_l |= 0x01<<(num - 1);
    

  550.                                    write2(0x44,value_keep0_l,value_keep0_h);
    

  551.                                    return;
    

  552.                         }
    

  553.                         else
    

  554.                         {
    

  555.                                    value_keep0_h |= 0x01<<(num - 9);
    

  556.                                    write2(0x44,value_keep0_l,value_keep0_h);
    

  557.                                    return;
    

  558.                         }
    

  559.          }
    

  560.          else if (num >16 && num <33)
    

  561.          {
    

  562.                          if  (num <25)
    

  563.                         {
    

  564.                                    value_keep1_l |= 0x01<<(num - 17);
    

  565.                                    write2(0x46,value_keep1_l,value_keep1_h);
    

  566.                                    return;
    

  567.                         }
    

  568.                         else
    

  569.                         {
    

  570.                                    value_keep1_h |= 0x01<<(num - 25);
    

  571.                                    write2(0x46,value_keep1_l,value_keep1_h);
    

  572.                                    return;
    

  573.                         }
    

  574.          }
    

  575.          else if (num <41)
    

  576.          {
    

  577.                          value_keep2_l |= 0x01<<(num - 33);
    

  578.                         write2(0x4a,value_keep2_l,value_keep2_h);
    

  579.                         return;
    

  580.          }
    

  581.          else
    

  582.          {
    

  583.                          //error
    

  584.          }
    

  585. }
    


  586. 

  587. void Clear_Value_To_Output(u8 num)
    

  588. {
    

  589.          if (num <17)
    

  590.          {
    

  591.                          if  (num <9)
    

  592.                         {
    

  593.                                    value_keep0_l &= ~(0x01<<(num - 1));
    

  594.                                    write2(0x44,value_keep0_l,value_keep0_h);
    

  595.                                    return;
    

  596.                         }
    

  597.                         else
    

  598.                         {
    

  599.                                    value_keep0_h &= ~(0x01<<(num - 9));
    

  600.                                    write2(0x44,value_keep0_l,value_keep0_h);
    

  601.                                    return;
    

  602.                         }
    

  603.          }
    

  604.          else if (num >16 && num <33)
    

  605.          {
    

  606.                          if  (num <25)
    

  607.                         {
    

  608.                                    value_keep1_l &= ~(0x01<<(num - 17));
    

  609.                                    write2(0x46,value_keep1_l,value_keep1_h);
    

  610.                                    return;
    

  611.                         }
    

  612.                         else
    

  613.                         {
    

  614.                                    value_keep1_h &= ~(0x01<<(num - 25));
    

  615.                                    write2(0x46,value_keep1_l,value_keep1_h);
    

  616.                                    return;
    

  617.                         }
    

  618.          }
    

  619.          else if (num <41)
    

  620.          {
    

  621.                          value_keep2_l &= ~(0x01<<(num - 33));
    

  622.                         write2(0x4a,value_keep2_l,value_keep2_h);
    

  623.                         return;
    

  624.          }
    

  625.          else
    

  626.          {
    

  627.                          //error
    

  628.          }
    

  629. }
    


  630. 

  631. void Change_Value_To_Output(u8 num,u8 value)
    

  632. {
    

  633.                 if (value == 0)
    

  634.                          Clear_Value_To_Output(num);
    

  635.                 else
    

  636.                          Set_Value_To_Output(num);
    

  637. }
    


  638. 

  639. void All_Off__To_Output(void)
    

  640. {
    

  641.                 write2(0x44,0,0);
    

  642.                 write2(0x46,0,0);
    

  643.                 write2(0x4a,0,0);
    

  644.                 value_keep0_l = 0;value_keep0_h = 0;
    

  645.                 value_keep1_l = 0;value_keep1_h = 0;
    

  646.                 value_keep2_l = 0;value_keep2_h = 0;
    

  647. }        
    


  648. 

  649. void All_On__To_Output(void)
    

  650. {
    

  651.                 write2(0x44,0xff,0xff);//delay(100000);
    

  652.                 write2(0x46,0xff,0xff);//delay(100000);
    

  653.                 write2(0x4a,0xff,0xff);//delay(100000);
    

  654.                 value_keep0_l = 0xff;value_keep0_h = 0xff;
    

  655.                 value_keep1_l = 0xff;value_keep1_h = 0xff;
    

  656.                 value_keep2_l = 0xff;value_keep2_h = 0xff;
    

  657. }
    


  658. 

  659. void All_Off__To_OpenDoor_Output(void)
    

  660. {                
    

  661.                 write2(0x46,0,0);
    

  662.                 write2(0x44,0,0);
    

  663.                 value_keep0_l = 0;value_keep0_h = 0;
    

  664.                 value_keep1_l = 0;value_keep1_h = 0;
    

  665. }        
    


  666. 

  667. void All_On__To_OpenDoor_Output(void)
    

  668. {
    

  669.                 write2(0x44,0xff,0xff);
    

  670.                 write2(0x46,0xff,0xff);
    

  671.                 value_keep0_l = 0xff;value_keep0_h = 0xff;
    

  672.                 value_keep1_l = 0xff;value_keep1_h = 0xff;
    


  673. 

  674. }
    

  675. void All_Off__To_CloseDoor_Output(void)
    

  676. {                
    

  677.                 write2(0x46,0,0);
    

  678.                 write2(0x44,0,0);
    

  679.                 value_keep0_l = 0;value_keep0_h = 0;
    

  680.                 value_keep1_l = 0;value_keep1_h = 0;
    

  681. }        
    


  682. 

  683. void All_On__To_CloseDoor_Output(void)
    

  684. {
    

  685.                 write2(0x44,0,0);
    

  686.                 write2(0x46,0xff,0xff);
    

  687.                 value_keep0_l = 0;value_keep0_h = 0;
    

  688.                 value_keep1_l = 0xff;value_keep1_h = 0xff;
    


  689. 

  690. }
    

  691. void All_Off__To_Power_Output(void)
    

  692. {
    

  693.                 write2(0x4a,0,0);
    

  694.                 value_keep2_l = 0;value_keep2_h = 0;
    

  695. }        
    


  696. 

  697. void All_On__To_Power_Output(void)
    

  698. {
    

  699.                 write2(0x4a,0xff,0xff);
    

  700.                 value_keep2_l = 0xff;value_keep2_h = 0xff;
    


  701. 

  702. }
    


  703. 

  704. u16 uart_deal_function(void)
    

  705. {
    

  706.         u8 i;
    

  707.         u8 temp_data[BUFFER_LEN],temp_data_length;
    

  708.         u8 state=0;
    

  709.         if (uart_data_length > 0 && uart_timerout_count == 0)
    

  710.         {
    

  711.                 //__disable_irq ;
    

  712.                 for (i=0;i<uart_data_length;i++)
    

  713.                 {
    

  714.                         temp_data[i] = uart_data485[i];
    

  715.                 }
    

  716.                 temp_data_length =         uart_data_length;
    

  717.         
    

  718.                 uart_data_length = 0;
    

  719.                 //__enable_irq ;
    

  720.                 for (i=0;i<temp_data_length;i++)
    

  721.                 {
    

  722.                         //Send_Byte(temp_data[i]);
    

  723.                         switch(state)
    

  724.                         {
    

  725.                                 case 0:        
    

  726.                                         if (temp_data[i] == 'o')
    

  727.                                         {
    

  728.                                                 state = 10;
    

  729.                                         }
    

  730.                                         else if (temp_data[i] == 'c')
    

  731.                                         {
    

  732.                                                 state = 20;
    

  733.                                         }
    

  734.                                         else if (temp_data[i] == 't')
    

  735.                                         {
    

  736.                                                 state = 30;
    

  737.                                         }
    

  738.                                         else if (temp_data[i] == 'd')
    

  739.                                         {
    

  740.                                                 if (temp_data_length - i > 8)
    

  741.                                                 {
    

  742.                                                         if (temp_data[i+1] == 'o')
    

  743.                                                                 if (temp_data[i+2] == 'o')
    

  744.                                                                         if (temp_data[i+3] == 'r')
    

  745.                                                                                 if (temp_data[i+4] == 's')
    

  746.                                                                                         if (temp_data[i+5] == 't')
    

  747.                                                                                                 if (temp_data[i+6] == 'a')
    

  748.                                                                                                         if (temp_data[i+7] == 't')
    

  749.                                                                                                                 if (temp_data[i+8] == 'e')
    

  750.                                                                                                                 {
    

  751.                                                                                                                         return 10;//doorstate
    

  752.                                                                                                                 }
    


  753. 


  754. 

  755.                                                         state = 0;
    

  756.                                                 }
    

  757.                                         }
    

  758.                                         else if (temp_data[i] == 'p')
    

  759.                                         {
    

  760.                                                 if (temp_data_length - i > 9)
    

  761.                                                 {
    

  762.                                                         if (temp_data[i+1] == 'o')
    

  763.                                                                 if (temp_data[i+2] == 'w')
    

  764.                                                                         if (temp_data[i+3] == 'e')
    

  765.                                                                                 if (temp_data[i+4] == 'r')
    

  766.                                                                                         if (temp_data[i+5] == 's')
    

  767.                                                                                                 if (temp_data[i+6] == 't')
    

  768.                                                                                                         if (temp_data[i+7] == 'a')
    

  769.                                                                                                                 if (temp_data[i+8] == 't')
    

  770.                                                                                                                         if (temp_data[i+9] == 'e')
    

  771.                                                                                                                         {
    

  772.                                                                                                                                 return 11;//powerstate
    

  773.                                                                                                                         }
    


  774. 


  775. 

  776.                                                         state = 0;
    

  777.                                                 }
    

  778.                                         }
    

  779.                                         else
    

  780.                                         {
    

  781.                                         }
    

  782.                                         break;
    

  783.                                 case 10:
    

  784.                                         if (temp_data[i] == 'p')
    

  785.                                         {
    

  786.                                                 state = 11;
    

  787.                                         }
    

  788.                                         else if (temp_data[i] == 'n')
    

  789.                                         {
    

  790.                                                 if (i + 1 == temp_data_length)
    

  791.                                                 {
    

  792.                                                         return 3;//on
    

  793.                                                 }
    

  794.                                                 else
    

  795.                                                 {
    

  796.                                                         if (temp_data_length - i > 1)
    

  797.                                                         {
    

  798.                                                                    if (temp_data[i+1] > 0x2f && temp_data[i+1] < 0x3a )
    

  799.                                                                    {
    

  800.                                                                                    parameters = temp_data[i+1] - 0x30;
    

  801.                                                                                    return 4 + (parameters<<8);//onx
    

  802.                                                                    }
    

  803.                                                                    else
    

  804.                                                                                    state = 0;
    

  805.                                                         }
    

  806.                                                         else
    

  807.                                                                 return 0;
    

  808.                                                 }
    

  809.                                         }
    

  810.                                         else if (temp_data[i] == 'f')
    

  811.                                         {
    

  812.                                                 state = 13;
    

  813.                                         }
    

  814.                                         else
    

  815.                                         {
    

  816.                                                 state = 0;
    

  817.                                         }
    

  818.                                         break;
    

  819.                                 case 11:
    

  820.                                         if (temp_data[i] == 'e')
    

  821.                                         {
    

  822.                                                 state = 14;
    

  823.                                         }
    

  824.                                         else
    

  825.                                         {
    

  826.                                                 state = 0;
    

  827.                                         }
    

  828.                                         break;
    

  829.                                 case 12:
    

  830.                                         break;
    

  831.                                 case 13:
    

  832.                                         if (temp_data[i] == 'f')
    

  833.                                         {
    

  834.                                                 if (i + 1 == temp_data_length)
    

  835.                                                 {
    

  836.                                                         return 5;//off
    

  837.                                                 }
    

  838.                                                 else
    

  839.                                                 {
    

  840.                                                         if (temp_data_length - i > 1)
    

  841.                                                         {
    

  842.                                                                    if (temp_data[i+1] > 0x2f && temp_data[i+1] < 0x3a )
    

  843.                                                                    {
    

  844.                                                                                    parameters = temp_data[i+1] - 0x30;
    

  845.                                                                                    return 6 + (parameters<<8);//offx
    

  846.                                                                    }
    

  847.                                                                    else
    

  848.                                                                                    state = 0;
    

  849.                                                         }
    

  850.                                                         else
    

  851.                                                                 return 0;
    

  852.                                                 }
    

  853.                                         }
    

  854.                                         else
    

  855.                                         {
    

  856.                                                 state = 0;
    

  857.                                         }
    

  858.                                         break;
    

  859.                                 case 14:
    

  860.                                         if (temp_data[i] == 'n')
    

  861.                                         {
    

  862.                                                 if (i + 1 == temp_data_length)
    

  863.                                                 {
    

  864.                                                         return 1;//open
    

  865.                                                 }
    

  866.                                                 else
    

  867.                                                 {
    

  868.                                                         if (temp_data_length - i > 2)
    

  869.                                                         {
    

  870.                                                                    if (temp_data[i+1] > 0x2f && temp_data[i+1] < 0x3a && temp_data[i+2] > 0x2f && temp_data[i+2] < 0x3a)
    

  871.                                                                    {
    

  872.                                                                                    parameters = (temp_data[i+1] - 0x30) * 10 + (temp_data[i+2] - 0x30);
    

  873.                                                                                    return 2 + (parameters<<8);//openxx
    

  874.                                                                    }
    

  875.                                                                    else
    

  876.                                                                                    state = 0;
    

  877.                                                         }
    

  878.                                                         else
    

  879.                                                                 return 0;
    

  880.                                                 }
    

  881.                                         }
    

  882.                                         else
    

  883.                                         {
    

  884.                                                 state = 0;
    

  885.                                         }
    

  886.                                         break;
    

  887.                                 case 20:
    

  888.                                         if (temp_data[i] == 'l')
    

  889.                                         {
    

  890.                                                 state = 21;
    

  891.                                         }
    

  892.                                         else
    

  893.                                         {
    

  894.                                                 state = 0;
    

  895.                                         }
    

  896.                                         break;
    

  897.                                 case 21:
    

  898.                                         if (temp_data[i] == 'o')
    

  899.                                         {
    

  900.                                                 state = 22;
    

  901.                                         }
    

  902.                                         else
    

  903.                                         {
    

  904.                                                 state = 0;
    

  905.                                         }
    

  906.                                         break;
    

  907.                                 case 22:
    

  908.                                         if (temp_data[i] == 's')
    

  909.                                         {
    

  910.                                                 state = 23;
    

  911.                                         }
    

  912.                                         else
    

  913.                                         {
    

  914.                                                 state = 0;
    

  915.                                         }
    

  916.                                         break;
    

  917.                                 case 23:
    

  918.                                         if (temp_data[i] == 'e')
    

  919.                                         {
    

  920.                                                 if (i + 1 == temp_data_length)
    

  921.                                                 {
    

  922.                                                         return 7;//close
    

  923.                                                 }
    

  924.                                                 else
    

  925.                                                 {
    

  926.                                                         if (temp_data_length - i > 2)
    

  927.                                                         {
    

  928.                                                                    if (temp_data[i+1] > 0x2f && temp_data[i+1] < 0x3a && temp_data[i+2] > 0x2f && temp_data[i+2] < 0x3a)
    

  929.                                                                    {
    

  930.                                                                                    parameters = (temp_data[i+1] - 0x30) * 10 + (temp_data[i+2] - 0x30);
    

  931.                                                                                    return 8 + (parameters<<8);//closexx
    

  932.                                                                    }
    

  933.                                                                    else
    

  934.                                                                                    state = 0;
    

  935.                                                         }
    

  936.                                                         else
    

  937.                                                                 return 0;
    

  938.                                                 }
    

  939.                                         }
    

  940.                                         else
    

  941.                                         {
    

  942.                                                 state = 0;
    

  943.                                         }
    

  944.                                         break;
    

  945.                                 case 30:
    

  946.                                         if (temp_data[i] == 'i')
    

  947.                                         {
    

  948.                                                 state = 31;
    

  949.                                         }
    

  950.                                         else
    

  951.                                         {
    

  952.                                                 state = 0;
    

  953.                                         }
    

  954.                                         break;
    

  955.                                 case 31:
    

  956.                                         if (temp_data[i] == 'm')
    

  957.                                         {
    

  958.                                                 state = 32;
    

  959.                                         }
    

  960.                                         else
    

  961.                                         {
    

  962.                                                 state = 0;
    

  963.                                         }
    

  964.                                         break;
    

  965.                                 case 32:
    

  966.                                         if (temp_data[i] == 'e')
    

  967.                                         {
    

  968.                                                 
    

  969.                                                 if (temp_data_length - i > 2)
    

  970.                                                 {
    

  971.                                                            if (temp_data[i+2] == 's')
    

  972.                                                            {
    

  973.                                                                            if (temp_data[i+1] > 0x30 && temp_data[i+1] < 0x3a)
    

  974.                                                                         {
    

  975.                                                                                    parameters = temp_data[i+1] - 0x30;
    

  976.                                                                                    return 9 + (parameters<<8);//timexs
    

  977.                                                                         }
    

  978.                                                                         else if (temp_data[i+1] == 0x41)
    

  979.                                                                         {
    

  980.                                                                                 parameters = 0x0a;
    

  981.                                                                                    return 9 + (parameters<<8);//timexs
    

  982.                                                                         }
    

  983.                                                                         else
    

  984.                                                                                 state = 0;
    

  985.                                                            }
    

  986.                                                            else
    

  987.                                                                            state = 0;
    

  988.                                                 }
    

  989.                                                 else
    

  990.                                                         return 0;
    

  991.                                         }
    

  992.                                         else
    

  993.                                         {
    

  994.                                                 state = 0;
    

  995.                                         }
    

  996.                                         break;
    

  997.                         }
    

  998.                 }
    

  999.                 return 0;
    

  1000.         }
    

  1001.         else
    

  1002.                 return 0;
    


  1003. 

  1004. }
    


  1005. 

  1006. void Led_On_RGB(u8 num,u16 value)
    

  1007. {
    

  1008.                 if (num < 6)
    

  1009.                 {
    

  1010.                         led_buf[0] &= (~(value<<((num-1)*3)));
    

  1011.                         write1(0x40,led_buf[0],led_buf[0] >> 8);
    

  1012.                 }
    

  1013.                 else if(num > 6 && num <11)
    

  1014.                 {
    

  1015.                         led_buf[1] &= (~(value<<((num-7)*3+2)));
    

  1016.                         write1(0x42,led_buf[1],led_buf[1] >> 8);
    

  1017.                 }
    

  1018.                 else if(num > 11 && num <17)
    

  1019.                 {
    

  1020.                         led_buf[2] &= (~(value<<((num-12)*3+1)));
    

  1021.                         write1(0x44,led_buf[2],led_buf[2] >> 8);
    

  1022.                 }
    

  1023.                 else if(num > 16 && num <22)
    

  1024.                 {
    

  1025.                         led_buf[3] &=( ~(value<<((num-17)*3)));
    

  1026.                         write1(0x46,led_buf[3],led_buf[3] >> 8);
    

  1027.                 }
    

  1028.                 else if(num > 22 && num <25)
    

  1029.                 {
    

  1030.                         led_buf[4] &= (~(value<<((num-23)*3+2)));
    

  1031.                         write1(0x48,led_buf[4],led_buf[4] >> 8);
    

  1032.                 }
    

  1033.                 else if (num == 6)
    

  1034.                 {
    

  1035.                         led_buf[0] &= (~(value<<15));
    

  1036.                         led_buf[1] &= (0xfffc | (~(value>>1)));
    

  1037.                         write1(0x40,led_buf[0],led_buf[0] >> 8);
    

  1038.                         write1(0x42,led_buf[1],led_buf[1] >> 8);
    

  1039.                 }
    

  1040.                 else if (num == 11)
    

  1041.                 {
    

  1042.                         led_buf[1] &= (~(value<<14));
    

  1043.                         led_buf[2] &= (0xfffe | (~(value>>2)));
    

  1044.                         write1(0x42,led_buf[1],led_buf[1] >> 8);
    

  1045.                         write1(0x44,led_buf[2],led_buf[2] >> 8);
    

  1046.                 }
    

  1047.                 else if (num == 22)
    

  1048.                 {
    

  1049.                         led_buf[3] &= (~(value<<15));
    

  1050.                         led_buf[4] &= (0xfffc | (~(value>>1)));
    

  1051.                         write1(0x46,led_buf[3],led_buf[3] >> 8);
    

  1052.                         write1(0x48,led_buf[4],led_buf[4] >> 8);
    

  1053.                 }        
    

  1054. }
    


  1055. 

  1056. void Led_Off_RGB(u8 num,u16 value)
    

  1057. {
    

  1058.                 if (num < 6)
    

  1059.                 {
    

  1060.                         led_buf[0] |= (value<<((num-1)*3));
    

  1061.                         write1(0x40,led_buf[0],led_buf[0] >> 8);
    

  1062.                 }
    

  1063.                 else if(num > 6 && num <11)
    

  1064.                 {
    

  1065.                         led_buf[1] |= (value<<((num-7)*3+2));
    

  1066.                         write1(0x42,led_buf[1],led_buf[1] >> 8);
    

  1067.                 }
    

  1068.                 else if(num > 11 && num <17)
    

  1069.                 {
    

  1070.                         led_buf[2] |= (value<<((num-12)*3+1));
    

  1071.                         write1(0x44,led_buf[2],led_buf[2] >> 8);
    

  1072.                 }
    

  1073.                 else if(num > 16 && num <22)
    

  1074.                 {
    

  1075.                         led_buf[3] |= (value<<((num-17)*3));
    

  1076.                         write1(0x46,led_buf[3],led_buf[3] >> 8);
    

  1077.                 }
    

  1078.                 else if(num > 22 && num <25)
    

  1079.                 {
    

  1080.                         led_buf[4] |= (value<<((num-23)*3+2));
    

  1081.                         write1(0x48,led_buf[4],led_buf[4] >> 8);
    

  1082.                 }
    

  1083.                 else if (num == 6)
    

  1084.                 {
    

  1085.                         led_buf[0] |= ((~0x7fff) & (value<<15));
    

  1086.                         led_buf[1] |= ((~0xfffc) & ((value>>1)& 0x7fff));
    

  1087.                         write1(0x40,led_buf[0],led_buf[0] >> 8);
    

  1088.                         write1(0x42,led_buf[1],led_buf[1] >> 8);
    

  1089.                 }
    

  1090.                 else if (num == 11)
    

  1091.                 {
    

  1092.                         led_buf[1] |= ((~0x3fff) & (value<<14));
    

  1093.                         led_buf[2] |= ((~0xfffe) & ((value>>2)&0x3fff));
    

  1094.                         write1(0x42,led_buf[1],led_buf[1] >> 8);
    

  1095.                         write1(0x44,led_buf[2],led_buf[2] >> 8);
    

  1096.                 }
    

  1097.                 else if (num == 22)
    

  1098.                 {
    

  1099.                         led_buf[3] |= ((~0x7fff) & (value<<15));
    

  1100.                         led_buf[4] |= ((~0xfffc) & ((value>>1)& 0x7fff));
    

  1101.                         write1(0x46,led_buf[3],led_buf[3] >> 8);
    

  1102.                         write1(0x48,led_buf[4],led_buf[4] >> 8);
    

  1103.                 }        
    

  1104. }
    


  1105. 

  1106. void Led_Off_R(u8 num)
    

  1107. {
    

  1108.         Led_Off_RGB(num,0x0004);
    

  1109. }
    

  1110. void Led_On_R(u8 num)
    

  1111. {
    

  1112.         Led_On_RGB(num,0x0004);
    

  1113. }
    

  1114. void Led_Off_G(u8 num)
    

  1115. {
    

  1116.         Led_Off_RGB(num,0x0002);
    

  1117. }
    

  1118. void Led_On_G(u8 num)
    

  1119. {
    

  1120.         Led_On_RGB(num,0x0002);
    

  1121. }
    

  1122. void Led_Off_B(u8 num)
    

  1123. {
    

  1124.         Led_Off_RGB(num,0x0001);
    

  1125. }
    

  1126. void Led_On_B(u8 num)
    

  1127. {
    

  1128.         Led_On_RGB(num,0x0001);
    

  1129. }
    

  1130. void All_Led_Off(void)
    

  1131. {
    

  1132.                 write1(0x40,0xff,0xff);
    

  1133.                 write1(0x42,0xff,0xff);
    

  1134.                 write1(0x44,0xff,0xff);
    

  1135.                 write1(0x46,0xff,0xff);
    

  1136.                 write1(0x48,0xff,0xff);
    

  1137.                 led_buf[0] = ~0;
    

  1138.                 led_buf[1] = ~0;
    

  1139.                 led_buf[2] = ~0;
    

  1140.                 led_buf[3] = ~0;
    

  1141.                 led_buf[4] = ~0;
    

  1142. }
    

  1143. void All_Led_On(void)
    

  1144. {
    

  1145.                 write1(0x40,0x00,0x00);
    

  1146.                 write1(0x42,0x00,0x00);
    

  1147.                 write1(0x44,0x00,0x00);
    

  1148.                 write1(0x46,0x00,0x00);
    

  1149.                 write1(0x48,0x00,0x00);
    

  1150.                 led_buf[0] = 0x00;
    

  1151.                 led_buf[1] = 0x00;
    

  1152.                 led_buf[2] = 0x00;
    

  1153.                 led_buf[3] = 0x00;
    

  1154.                 led_buf[4] = 0x00;
    

  1155. }
    


  1156. 

  1157. void Refresh_Power_Condition(void)
    

  1158. {
    

  1159.         I2C_ReadS_PCA9555(0x4d,0,value_feedback2,2);
    

  1160.         Refresh_Power = 1;
    

  1161. }
    


  1162. 

  1163. void Refresh_Power_Condition_Led(void)
    

  1164. {
    

  1165.         u8 i;
    

  1166.         for (i=0;i<8;i++)
    

  1167.         {
    

  1168.                 if (value_feedback2[0] & (0x01<<i))
    

  1169.                 {
    

  1170.                         Led_Off_G(i+1);Led_On_R(i+1);
    

  1171.                         powerstate[i] = 0x30;
    

  1172.                 }
    

  1173.                 else
    

  1174.                 {
    

  1175.                         Led_Off_R(i+1);Led_On_G(i+1);
    

  1176.                         powerstate[i] = 0x31;
    

  1177.                 }
    

  1178.         }
    

  1179. }
    


  1180. 

  1181. void Refresh_Door_Condition(void)
    

  1182. {
    

  1183.         u8 i;         
    

  1184.         I2C_ReadS_PCA9555(0x40,0,value_feedback0,2);
    

  1185.         I2C_ReadS_PCA9555(0x42,0,value_feedback1,2);
    

  1186.         
    

  1187.         for (i=0;i<8;i++)
    

  1188.         {
    

  1189.                 if ((value_feedback0[0] & (0x01<<i)) == (value_feedback1[0] & (0x01<<i)))
    

  1190.                 {
    

  1191.                         //Led_Off_G(i+9);Led_Off_R(i+9);Led_On_B(i+9);
    

  1192.                         //doorstate[i] = 0x32;
    

  1193.                 }
    

  1194.                 else if ((value_feedback0[0] & (0x01<<i)) == 0 )
    

  1195.                 {
    

  1196.                         if (auto_open_off_time_count[i]!= 0xffff)
    

  1197.                         {
    

  1198.                                 //auto_open_off_time_count[i] = 0;
    

  1199.                                 Clear_Value_To_Output(17+i);
    

  1200.                                 Clear_Value_To_Output(1+i);                                                           
    

  1201.                                 auto_open_off_time_count[i] = 0xffff;
    

  1202.                         }
    

  1203.                         //Led_Off_B(i+9);Led_Off_R(i+9);Led_On_G(i+9);
    

  1204.                         //doorstate[i] = 0x31;
    

  1205.                 }
    

  1206.                 else
    

  1207.                 {
    

  1208.                         if (auto_close_off_time_count[i]!= 0xffff)
    

  1209.                         {
    

  1210.                                 //auto_close_off_time_count[i] = 0;
    

  1211.                                 Clear_Value_To_Output(17+i);
    

  1212.                                 Clear_Value_To_Output(1+i);
    

  1213.                                 auto_close_off_time_count[i] = 0xffff;
    

  1214.                         }
    

  1215.                         //Led_Off_G(i+9);Led_Off_B(i+9);Led_On_R(i+9);
    

  1216.                         //doorstate[i] = 0x30;
    

  1217.                 }
    

  1218.         }
    

  1219.         for (i=0;i<8;i++)
    

  1220.         {
    

  1221.                 if ((value_feedback0[1] & (0x01<<i)) == (value_feedback1[1] & (0x01<<i)))
    

  1222.                 {
    

  1223.                         //Led_Off_G(i+17);Led_Off_R(i+17);Led_On_B(i+17);
    

  1224.                         //doorstate[i+8] = 0x32;
    

  1225.                 }
    

  1226.                 else if ((value_feedback0[1] & (0x01<<i)) == 0 )
    

  1227.                 {
    

  1228.                         if (auto_open_off_time_count[i+8]!= 0xffff)
    

  1229.                         {
    

  1230.                                 //auto_open_off_time_count[i+8] = 0;
    

  1231.                                 Clear_Value_To_Output(25+i);
    

  1232.                                 Clear_Value_To_Output(9+i);
    

  1233.                                 auto_open_off_time_count[i+8] = 0xffff;
    

  1234.                         }
    

  1235.                         //Led_Off_B(i+17);Led_Off_R(i+17);Led_On_G(i+17);
    

  1236.                         //doorstate[i+8] = 0x31;
    

  1237.                 }
    

  1238.                 else
    

  1239.                 {
    

  1240.                         if (auto_close_off_time_count[i+8] != 0xffff)
    

  1241.                         {
    

  1242.                                 //auto_close_off_time_count[i+8] = 0;
    

  1243.                                 Clear_Value_To_Output(25+i);
    

  1244.                                 Clear_Value_To_Output(9+i);
    

  1245.                                 auto_close_off_time_count[i+8] = 0xffff;
    

  1246.                         }
    

  1247.                         //Led_Off_G(i+17);Led_Off_B(i+17);Led_On_R(i+17);
    

  1248.                         //doorstate[i+8] = 0x30;
    

  1249.                 }
    

  1250.         }
    

  1251.         Refresh_Led = 1;
    

  1252. }
    


  1253. 

  1254. void Refresh_Door_Condition_Led(void)
    

  1255. {
    

  1256.         u8 i;                 
    

  1257.         for (i=0;i<8;i++)
    

  1258.         {
    

  1259.                 if ((value_feedback0[0] & (0x01<<i)) == (value_feedback1[0] & (0x01<<i)))         //value_feedback0[0]反馈数据  16路
    

  1260.                 {
    

  1261.                         Led_Off_G(i+9);Led_Off_R(i+9);Led_On_B(i+9);
    

  1262.                         doorstate[i] = 0x32;        //ascii码的字符为2 表示异常
    

  1263.                 }
    

  1264.                 else if ((value_feedback0[0] & (0x01<<i)) == 0 )
    

  1265.                 {
    

  1266.                         Led_Off_B(i+9);Led_Off_R(i+9);Led_On_G(i+9);
    

  1267.                         doorstate[i] = 0x31;
    

  1268.                 }
    

  1269.                 else
    

  1270.                 {
    

  1271.                         Led_Off_G(i+9);Led_Off_B(i+9);Led_On_R(i+9);
    

  1272.                         doorstate[i] = 0x30;
    

  1273.                 }
    

  1274.         }
    

  1275.         for (i=0;i<8;i++)
    

  1276.         {
    

  1277.                 if ((value_feedback0[1] & (0x01<<i)) == (value_feedback1[1] & (0x01<<i)))
    

  1278.                 {
    

  1279.                         Led_Off_G(i+17);Led_Off_R(i+17);Led_On_B(i+17);
    

  1280.                         doorstate[i+8] = 0x32;
    

  1281.                 }
    

  1282.                 else if ((value_feedback0[1] & (0x01<<i)) == 0 )
    

  1283.                 {
    

  1284.                         Led_Off_B(i+17);Led_Off_R(i+17);Led_On_G(i+17);
    

  1285.                         doorstate[i+8] = 0x31;
    

  1286.                 }
    

  1287.                 else
    

  1288.                 {
    

  1289.                         Led_Off_G(i+17);Led_Off_B(i+17);Led_On_R(i+17);
    

  1290.                         doorstate[i+8] = 0x30;
    

  1291.                 }
    

  1292.         }
    

  1293. }
    


  1294. 

  1295. void PowerOn_Auto_CloseOff(void)
    

  1296. {
    

  1297.         u8 i;
    

  1298.         for (i=0;i<16;i++)
    

  1299.         {
    

  1300.                 if (doorstate[i] != 0x30)
    

  1301.                 {
    

  1302.                         Clear_Value_To_Output(1+i);
    

  1303.                         Set_Value_To_Output(17+i);
    

  1304.                         auto_close_off_time_count[i] = auto_off_time_count;
    

  1305.                 }
    

  1306.         }
    

  1307. }
回复

收藏1 举报

643757107 发表于 2017-11-29 09:35 | 显示全部楼层
你把上面两个文件保存一下，就可以用了。
回复

收藏1 举报

643757107 发表于 2017-11-29 09:38 | 显示全部楼层
PCA9555驱动.zip (5.83 KB, 下载次数: 15)

还是直接给你提供好吧
回复

收藏1 举报

 楼主| dsh1989 发表于 2017-11-29 14:38 | 显示全部楼层
谢谢各位
回复

收藏1 举报

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

本版积分规则

dsh1989

2

主题

5

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部