社区首页
★ 社区积分制度 ★ 新手必读 ★ 申请版主★
 

论坛

切换旧版
返回列表 发新帖 回复
阅 3227|回 2
hh376158101

391

帖子

1

TA的资源

一粒金砂（高级）
楼主
发表于2015-1-5 22:55 只看该作者
 

【TI首届低功耗设计大赛】手持温度心电监测仪（综合帖） [复制链接]

本帖最后由 hh376158101 于 2015-1-5 23:59 编辑

说说我设计这个手持式监护仪的缘由吧。记得高考那年，因为身体原因住进了医院，在医院住了挺久，每天都要进行两次体温检测，使用的是常规的水银体温计，由于所在的是省里的大医院，所以病号特别多，每一层200多个病号。每一个病号都要分发、回收体温计。护士们都是通过纸笔记录测量数据，回到护士站一一输入系统。所以护士姐姐的工作量还是挺大的。难怪她们经常抱怨，医生动动嘴，护士跑断腿，呵呵。在医院住了挺久，换了好几个病友，又一次因为军区医院的干部病房告急，就把一个部队首长安排跟我一起住。待遇就是不一样啊，有专人服侍，而且心电检测等许多常规检查都是上门服务，同样都是病号，差别怎么就那么大呢，呵呵。那么问题来了，为了减轻护士工作负担，同时解决医疗资源合理分配的问题，我打算设计一款能够进行非接触式测温，能够测量保存多组数据，最后将数据通过蓝牙发送至护士站电脑的手持终端，稍后，还会拓展心电监测功能。

说说系统框架。
首先，本次大赛要求基于金刚狼套件，所以launchpad 的IO口对设计有一定的限制。下图为金刚狼launchpad的各类硬件接口示意图。

从接口示意图中，我们了解到该launchpad预留了一路硬件SPI、UART，已经两路模拟输入接口，I2C接口通过软件模拟。使用了这些接口之后，省下的IO已经不多，所以我们要考虑周全，好好利用这些接口。
                   通过网络查找相关资料，最终得到了如下图所示的系统框图。


非接触式测温：
我们使用的是MLX90615热电堆传感器。该传感器在人体体温范围内，精度达到0.02摄氏度。其通过I2C接口与单片机进行通信。
显示部分：
                   由于msp430fr5969没有提供段式LCD驱动器，而且对功耗的要求相对较高，所以我选择了cog12864低功耗点阵液晶。单片机通过SPI接口与其通信。
数据存储：
                   RF5969提供了64KBFRAM，用于温度、时间的存储足够，可是用于存储心电信号数据就捉襟见肘了,，所以我拓展了一片外置存储器，期初想使用富士通的1M的FRAM，看了下价格，却步了。最后我使用了512K的EEPROM，跟富士通I2C接口的FRAM存储器接口一样，日后，有需要可以随时更换。
键盘：
                   当初我考虑过普通的IO矩阵键盘、AD键盘。不过由于IO有限，第一种方案放弃。AD键盘存在一定的不确定性，对于医疗设备这种要求严苛的设备老说不太适合。所以最后，我选择了通过键盘芯片来拓展。我使用的是TI的TCA8418，其最大可支持80个按键，有键盘模式和普通IO模式可供我们配置，可向单片机提供中断信号，通过I2C接口与单片机通信。
蓝牙模块：
                   蓝牙模块通过串口与单片机通信。两个蓝牙模块使用透传模式。
电池电量检测：
                   电池电量检测使用TI的BQ27010，其通过I2C总线与单片机进行通信。
ECG心电监测：
                   心电监测模拟前端选择TI公司的ADS1294四通道模拟前端，可实现5导联的心电监测。


四肢电极RA\LA\LL经过差分放大器做差，分别得到四肢导联I、导联II、导联III、四肢电极RL作为电势零点、威尔逊中心终端电势为四肢电极RA\LA\LL的平均电势，其作为胸部导联的参考电势，经差分放大得到胸部导联V1。
电源部分：
电源使用锂电池供电，所以我使用了，TPS63021DCDC芯片。

以下是原理图：




软件：
TCA8418驱动：
  1. /**************************************************************************************************************************************************
  2. *                                 Included Headers                                                                                                *
  3. **************************************************************************************************************************************************/
  4. #include "MSP430.h"                           // Empty header file to allow global changes in one header file
  5. #include "I2C.h"
  6. #include "TCA8418_Key_Scan.h"                 // Definition file for TCA8418 Registers





  12. /**************************************************************************************************************************************************
  13. *                                 External Variables                                                                                              *
  14. **************************************************************************************************************************************************/
  15. extern char   TCA8418_Packet_Data[];

  17. /**************************************************************************************************************************************************
  18. *                                 Initialize_Keyboard                                                                                         *
  19. **************************************************************************************************************************************************/
  20. /*!
  21. * @ingroup TCA8418_Functions_Public
  22. *
  23. * @brief Initializes the TCA8418 Keyboard
  24. *
  25. * @param[in]   device_slot     Location of the CC Radio on the MAVRK Motherboard
  26. *
  27. * @return      NONE   
  28. *
  29. **************************************************************************************************************************************************/
  30. void Initialize_Keyboard()
  31. {
  32.     Init_TCA8418(TCA8418_I2C_SLAVE_ADDRESS); // Initialize TCA8418 Component  
  33.    
  34.     //Initialize_Keylock ();
  35.    
  36.     Enable_TCA8418_Interrupts();
  37.       
  38. }   

  40. /**************************************************************************************************************************************************
  41. *                                 Initialize_Keylock                                                                                         *
  42. **************************************************************************************************************************************************/
  43. /*!
  44. * @ingroup TCA8418_Functions_Public
  45. *
  46. * @brief Initializes the TCA8418 Keyboard keypad lock/unlock feature
  47. *
  48. * @param[in]   device_slot     Location of the CC Radio on the MAVRK Motherboard
  49. *
  50. * @return      NONE   
  51. *
  52. **************************************************************************************************************************************************/
  53. void Initialize_Keylock ()
  54. {
  55.    
  56. // USe SHIFT Key & 0 Key as keypad unlock keys
  57.     Set_TCA8418_Keylock_Unlock_Values (SHIFT_SWITCH, SWITCH_0, TCA8418_I2C_SLAVE_ADDRESS);  

  59.    
  60. // 1 second timeout between 1st unlock key press and 2nd unlock key press
  61.     Set_TCA8418_Keylock_Timer_Value (TCA8418_1_SEC, TCA8418_I2C_SLAVE_ADDRESS);            

  63. // 1 second interrupt timer mask
  64.     Set_TCA8418_Keylock_Interrupt_Mask_Timer_Value (TCA8418_1_SEC, TCA8418_I2C_SLAVE_ADDRESS);  

  66. // This function can be used if the initial state desired is to have the keypad unlocked   
  67.     Disable_TCA8418_Keylock(TCA8418_I2C_SLAVE_ADDRESS);         

  69. // Enable Keypad Lock Interrupt which signals detection of correct unlock key1 and key2 which unlocks of keypad
  70.     Enable_TCA8418_Keypad_Lock_Interrupt (TCA8418_I2C_SLAVE_ADDRESS);
  71. }

  73. /**************************************************************************************************************************************************
  74. *                                 Enable_TCA8418_Interrupts                                                                                   *
  75. **************************************************************************************************************************************************/
  76. /*!
  77. * @ingroup TCA8418_Functions_Public
  78. *
  79. * @brief Enable TCA8418 Component Data_Ready Interrupt
  80. *
  81. * @param[in]   device_slot     Location of the CC Radio on the MAVRK Motherboard
  82. *
  83. * @return      NONE   
  84. *
  85. **************************************************************************************************************************************************/
  86. void Enable_TCA8418_Interrupts ()  
  87. {  
  88.     //写1清中断标志位
  89.     Clear_TCA8418_Interrupt_Status(TCA8418_ALL_INTERRUPT_FLAGS,  TCA8418_I2C_SLAVE_ADDRESS);   // Clear all interrupt status bits in TCA8418 device
  90.     Enable_TCA8418_Key_Event_Interrupt( TCA8418_I2C_SLAVE_ADDRESS); // Enable interrupt for Key press Events on Keypad

  92. }



  96. /*TCA8418使用指南*/

  98. //***************TCA8418初始化*******************/
  99. //配置寄存器清零
  100. //将FIFO内键值全部读出（清空FIFO）
  101. //配置键盘IO
  102. //设置MCU中断IO,负责接收TCA8418中断请求

  104. //**************键盘锁初始化********************/
  105. //设置键盘锁的值（两个组合键，解锁）
  106. //设置第一解锁键与第二解锁键的时间间隔
  107. //设置键盘锁中断屏蔽时间
  108. //不使能键盘锁（根据需要设置）
  109. //使能键盘锁中断

  111. /***************使能中断***********************/
  112. //清除中断状态寄存器的标志位
  113. //使能按键事件中断

  115. //**************按键检测及处理*****************/
  116. //关闭按键事件中断
  117. //读取中断状态寄存器，查看是什么引起的中断
  118. //如果是解锁中断，则打开键盘锁，停止键盘锁中断
  119. //如果是按键事件中断，则查看键盘锁状态寄存器，看键盘
  120. //是否处于锁定状态，如果是，不处理，如果不是，则读取
  121. //键值，之后清除中断状态寄存器，使能按键事件中断
  122. //这就完成里一个键值的读取工作


  125. unsigned char TCA8418_Key_Event_Buffer[TCA8418_KEY_EVENT_BUFFER_SIZE];
  126. unsigned char TCA8418_Key_Events_In_Buffer_Size;

  128. TCA8418_Interrupt_Status_register_type TCA8418_Interrupt_Status_register;
  129. /*************************************************************************************************************************************************/
  130. /*  This section of code contains public functions that are generally used by standard applications. The parameter sets for public API functions */
  131. /*  provide an abstraction layer that will be maintained throughout updates and changes to underlying processor functions.                       */
  132. /*                                                                                                                                               */   
  133. /*! \cond PUBLIC                                                                                                                                 */
  134. /*************************************************************************************************************************************************/

  136. /**************************************************************************************************************************************************
  137. *  Read_TCA8418_Register                                                                                                  
  138. **************************************************************************************************************************************************/
  139. /*!
  140. * @ingroup TCA8418_Functions_Public
  141. *
  142. * @brief Read an I2C register value from a TCA8418 Device
  143. *
  144. * The function will read an I2C register value from a TCA8418 Device.
  145. *
  146. * @param[in]   register_address        TCA8418 I2C register address to be read
  147. * @param[out]  read_data               Pointer to variable where data read from TCA8418 register is stored
  148. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  149. *
  150. * @return  I2C_OPERATION_SUCCESSFUL    Success
  151. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  152. **************************************************************************************************************************************************/
  153. unsigned char Read_TCA8418_Register (unsigned char register_address, unsigned char I2C_slave_address)
  154. {
  155.     return (IIC_ReadByte(I2C_slave_address, register_address));
  156. }

  158. /**************************************************************************************************************************************************
  159. *  Write_TCA8418_Register                                                                                                  
  160. **************************************************************************************************************************************************/
  161. /*!
  162. * @ingroup TCA8418_Functions_Public
  163. *
  164. * @brief Write a value to an I2C register in the TCA8418 Keypad Scan Device
  165. *
  166. * The function will write a value to an I2C register in the TCA8418 Keypad Scan Device.
  167. *
  168. * @param[in]   register_address        TCA8418 I2C register address to be written
  169. * @param[in]   write_data              Pointer to value to be written to the specified TCA8418 register
  170. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  171. *
  172. * @return  I2C_OPERATION_SUCCESSFUL    Success
  173. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  174. **************************************************************************************************************************************************/
  175. void Write_TCA8418_Register (unsigned char register_address, unsigned char write_data, unsigned char I2C_slave_address)
  176. {                                    
  177.      IIC_WriteByte(I2C_slave_address, register_address, write_data);
  178. }


  181. /**************************************************************************************************************************************************
  182. *  Config_TCA8418_Row_Col_Keyscan_GPIO_Function                                                                                                  
  183. **************************************************************************************************************************************************/
  184. /*!
  185. * @ingroup TCA8418_Functions_Public
  186. *
  187. * @brief Configure the TCA8418 Row Column Pin Function
  188. *
  189. * This function configures the TC8418 keyscan ROW-COLUMNS to the layout of key switches on RF-TCA8418-MVK module
  190. *
  191. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  192. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  193. *
  194. * @return  I2C_OPERATION_SUCCESSFUL    Success
  195. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  196. **************************************************************************************************************************************************/
  197. void Config_TCA8418_Row_Col_Keyscan_GPIO_Function (unsigned char I2C_slave_address)  
  198. {
  199.     Write_TCA8418_Register (TCA8418_KEYSCAN_GPIO_FUNCTION_1_REGISTER, 0X1F, I2C_slave_address);         

  201.     Write_TCA8418_Register (TCA8418_KEYSCAN_GPIO_FUNCTION_2_REGISTER, 0X0F, I2C_slave_address);         
  202.       
  203.     Write_TCA8418_Register (TCA8418_KEYSCAN_GPIO_FUNCTION_3_REGISTER, 0X00, I2C_slave_address);
  204. }
  205.   

  207. /**************************************************************************************************************************************************
  208. *  Enable_TCA8418_Key_Event_Interrupt                                                                                                  
  209. **************************************************************************************************************************************************/
  210. /*!
  211. * @ingroup TCA8418_Functions_Public
  212. *
  213. * @brief Enable the TCA8418 Key Event Interrupt
  214. *
  215. * This function sets the state of the TC8418 Key Event Interrupt to ENABLE
  216. *
  217. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  218. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  219. *
  220. * @return  I2C_OPERATION_SUCCESSFUL    Success
  221. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  222. **************************************************************************************************************************************************/
  223. void  Enable_TCA8418_Key_Event_Interrupt ( unsigned char I2C_slave_address)
  224. {
  225.     unsigned char TCA8418_Configuration = 0X00;
  226.     TCA8418_Configuration = Read_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER, I2C_slave_address);
  227.    
  228.     TCA8418_Configuration = TCA8418_Configuration | 0X01 ;
  229.    
  230.     Write_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER, TCA8418_Configuration, I2C_slave_address);
  231. }  

  233. /**************************************************************************************************************************************************
  234. *  Disable_TCA8418_Key_Event_Interrupt                                                                                                  
  235. **************************************************************************************************************************************************/
  236. /*!
  237. * @ingroup TCA8418_Functions_Public
  238. *
  239. * @brief Disable the TCA8418 Key Event Interrupt
  240. *
  241. * This function sets the state of the TC8418 Key Event Interrupt to DISABLE
  242. *
  243. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  244. *
  245. * @return  I2C_OPERATION_SUCCESSFUL    Success
  246. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  247. **************************************************************************************************************************************************/
  248. void  Disable_TCA8418_Key_Event_Interrupt ( unsigned char I2C_slave_address)
  249. {
  250.     unsigned char TCA8418_Configuration = 0X00 ;
  251.     TCA8418_Configuration = Read_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER,I2C_slave_address);
  252.    
  253.     TCA8418_Configuration = TCA8418_Configuration & 0XFE ;
  254.    
  255.     Write_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER, TCA8418_Configuration, I2C_slave_address);
  256. }  

  258. /**************************************************************************************************************************************************
  259. *  Get_TCA8418_Key_Event                                                                                                  
  260. **************************************************************************************************************************************************/
  261. /*!
  262. * @ingroup TCA8418_Functions_Public
  263. *
  264. * @brief Get the Key Event from the TCA8418 Key Event FIFO
  265. *
  266. * This function gets the data for  single key event data from the TC8418.
  267. *
  268. * @param[out]  key_event               Pointer to variable used to store key_event  data read from TCA8418 register
  269. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  270. *
  271. * @return  I2C_OPERATION_SUCCESSFUL    Success
  272. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  273. **************************************************************************************************************************************************/
  274. unsigned char  Get_TCA8418_Key_Event ( unsigned char I2C_slave_address)
  275. {  
  276.    
  277.     return Read_TCA8418_Register (TCA8418_KEY_EVENT_0_REGISTER,I2C_slave_address);
  278. }  

  280. /**************************************************************************************************************************************************
  281. *  Get_TCA8418_Key_Event_Count                                                                                                  
  282. **************************************************************************************************************************************************/
  283. /*!
  284. * @ingroup TCA8418_Functions_Public
  285. *
  286. * @brief Gets the number of Key Events stored in the TCA8418 Event FIFO
  287. *
  288. * This function gets the current Event Count (Number of Key and/or GPIO-Input Events in the ten deep FIFO)
  289. *
  290. * @param[out]  event_count             Pointer to variable used to store event_count
  291. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  292. *
  293. * @return  I2C_OPERATION_SUCCESSFUL    Success
  294. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  295. **************************************************************************************************************************************************/
  296. unsigned char Get_TCA8418_Key_Event_Count (unsigned char I2C_slave_address)
  297. {
  298.     return Read_TCA8418_Register (TCA8418_KEY_LOCK_AND_EVENT_COUNTER_REGISTER,I2C_slave_address);
  299. }


  302. /********************************************************************************************************************************
  303. *  Move_Key_Events_From_TCA8418_FIFO_To_Buffer
  304. ********************************************************************************************************************************/
  305. /*!
  306. * @ingroup TCA8418_Functions_Public
  307. *
  308. * @brief Drain TC8418 Key Event FIFO until empty, while storing Key Event data to Buffer
  309. *
  310. * This function will move all the Key_Events in the TCA8418 Key_Event FIFO into an application supplied key_event Buffer
  311. *                                      
  312. * @param[out]  key_event_buffer                Pointer to application supplied Key Event Buffer
  313. * @param[in]   key_event_buffer_size           Defines size of application key event buffer to prevent writing past end of buffers
  314. * @param[out]  number_of_key_events_in_buffer  Pointer to variable used to store the number of key events moved from the TCA8418 FIFO
  315. * @param[in]   I2C_slave_address               TCA8418 I2C slave address
  316. *
  317. * @return  I2C_OPERATION_SUCCESSFUL    Success
  318. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  319. ********************************************************************************************************************************/
  320. void Move_Key_Events_From_TCA8418_FIFO_To_Buffer (unsigned char* key_event_buffer,
  321.                                                                unsigned char  key_event_buffer_size,
  322.                                                                unsigned char number_of_key_events_in_buffer,
  323.                                                                unsigned char  I2C_slave_address)
  324. {
  325.     unsigned char buffer_index = 0;
  326.     unsigned char key_event;
  327.     unsigned char number_of_key_events_in_fifo;
  328.     unsigned char number_of_buffer_key_events = 0;
  329.             
  330.     // Get the current count of Key/GPIO Events in the Event FIFO  
  331.     number_of_key_events_in_fifo = Get_TCA8418_Key_Event_Count (I2C_slave_address);
  332.    
  333.     // Drain the TCA8418 Key/GPIO Event FIFO. The Event Count Register(Number of Events in FIFO)
  334.     // must be zero before the Interrupt Status Bit "K_INT" can be cleared  
  335.     do
  336.     {
  337.         Get_TCA8418_Key_Event (I2C_slave_address);
  338.         
  339.         // Copy Key_Event to output Key_Event Buffer
  340.         // Increment number of key events stored in output Buffer
  341.         // Increment outut buffer array index for storage of next key event
  342.         key_event_buffer [buffer_index] = key_event;
  343.         ++number_of_buffer_key_events;
  344.         ++buffer_index;
  345.         
  346.         // Get the current count of Key/GPIO Events in the Event FIFO
  347.         // It should be one less than previous count, unless a new key event occured
  348.         Get_TCA8418_Key_Event_Count (I2C_slave_address);

  350.       // Keep moving Key Event data from TCA8418 FIFO to Buffer until FIFO is drained
  351.       // or Output Buffer is Full based on defined size   
  352.     } while ((number_of_key_events_in_fifo > 0) && (buffer_index <= key_event_buffer_size));   
  353.    
  354.    
  355.     // Copy the number of key events that have been stored in the key_Event_Buffer for
  356.     // use by the calling function for retrieval/processing of key_events
  357.     number_of_key_events_in_buffer = number_of_buffer_key_events;         
  358. }  



  362. /********************************************************************************************************************************
  363. *  Enable_TCA8418_GP_Input_Event_Interrupt
  364. ********************************************************************************************************************************/
  365. /*!
  366. * @ingroup TCA8418_Functions_Public
  367. *
  368. * @brief Enables the GPIO Pin Event interrupt
  369. *
  370. * This function will enable the GPIO Input(Row or Col) Pin Event interrupt
  371. *                                      
  372. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  373. *
  374. * @return  I2C_OPERATION_SUCCESSFUL    Success
  375. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  376. ********************************************************************************************************************************/
  377. void Enable_TCA8418_GP_Input_Event_Interrupt (unsigned char I2C_slave_address)
  378. {  
  379.     unsigned char TCA8418_Configuration = 0X00 ;
  380.    
  381.     TCA8418_Configuration = Read_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER, I2C_slave_address);

  383.     TCA8418_Configuration = TCA8418_Configuration | 0X02 ;
  384.    
  385.     Write_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER, TCA8418_Configuration, I2C_slave_address);
  386. }  

  388. /********************************************************************************************************************************
  389. *  Disable_TCA8418_GP_Input_Event_Interrupt
  390. ********************************************************************************************************************************/
  391. /*!
  392. * @ingroup TCA8418_Functions_Public
  393. *
  394. * @brief Disables the GPIO Pin Event interrupt
  395. *
  396. * This function will disable the GPIO Input(Row or Col) Pin Event interrupt
  397. *                                      
  398. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  399. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  400. *
  401. * @return  I2C_OPERATION_SUCCESSFUL    Success
  402. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  403. ********************************************************************************************************************************/
  404. void Disable_TCA8418_GP_Input_Event_Interrupt ( unsigned char I2C_slave_address)
  405. {
  406.     unsigned char TCA8418_Configuration = 0X00 ;
  407.    
  408.     TCA8418_Configuration = Read_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER,I2C_slave_address);

  410.     TCA8418_Configuration = TCA8418_Configuration & 0XFD ;
  411.    
  412.     Write_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER, TCA8418_Configuration, I2C_slave_address);
  413. }  


  416. /********************************************************************************************************************************
  417. *  Set_TCA8418_Keylock_Timer_Value
  418. ********************************************************************************************************************************/
  419. /*!
  420. * @ingroup TCA8418_Functions_Public
  421. *
  422. * @brief Sets the Keylock Timer for delay "fill this in"
  423. *
  424. * This function will set the Keylock Timer Value for the Delay time between Key Unlock Press #1 and Key Unlock Press #2  
  425. *                                      
  426. * @param[in]   keypad_lock_timer_value         Sets time delay "fill this in Later"
  427. * @param[in]   device_slot                     Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  428. * @param[in]   I2C_slave_address               TCA8418 I2C slave address
  429. *
  430. * @return  I2C_OPERATION_SUCCESSFUL    Success
  431. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  432. ********************************************************************************************************************************/
  433. void Set_TCA8418_Keylock_Timer_Value (unsigned char keypad_lock_timer_value,
  434.                                                    unsigned char I2C_slave_address)
  435. {
  436.     unsigned char TCA8418_Keypad_Timer = 0x00;                                               // Zero out global variable  
  437.    
  438.     TCA8418_Keypad_Timer = Read_TCA8418_Register (TCA8418_KEYPAD_LOCK_TIMER_REGISTER, I2C_slave_address);
  439.    
  440.     TCA8418_Keypad_Timer = (keypad_lock_timer_value & 0XF8) | keypad_lock_timer_value;
  441.    
  442.     Write_TCA8418_Register (TCA8418_KEYPAD_LOCK_TIMER_REGISTER, TCA8418_Keypad_Timer, I2C_slave_address);

  444. }  


  447. /********************************************************************************************************************************
  448. *  Get_TCA8418_Keylock_Timer_Value
  449. ********************************************************************************************************************************/
  450. /*!
  451. * @ingroup TCA8418_Functions_Public
  452. *
  453. * @brief Gets the Keylock Timer for delay "fill this in"
  454. *
  455. * This function will get the Keylock Timer Value for the Delay time between Key Unlock Press #1 and Key Unlock Press #2  
  456. *                                      
  457. * @param[out]  keypad_lock_timer_value         Time delay "fill this in Later"
  458. * @param[in]   device_slot                     Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  459. * @param[in]   I2C_slave_address               TCA8418 I2C slave address
  460. *
  461. * @return  I2C_OPERATION_SUCCESSFUL    Success
  462. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  463. ********************************************************************************************************************************/
  464. void Get_TCA8418_Keylock_Timer_Value (unsigned char keypad_lock_timer_value,
  465.                                                    unsigned char I2C_slave_address)
  466. {   
  467.     unsigned char TCA8418_Keypad_Timer = 0x00;                                                // Zero out global variable  
  468.    
  469.     TCA8418_Keypad_Timer = Read_TCA8418_Register (TCA8418_KEYPAD_LOCK_TIMER_REGISTER,I2C_slave_address);
  470.    
  471.     keypad_lock_timer_value = TCA8418_Keypad_Timer & 0X07 ;
  472.    
  473. }  

  475. /********************************************************************************************************************************
  476. *  Set_TCA8418_Keylock_Interrupt_Mask_Timer_Value
  477. ********************************************************************************************************************************/
  478. /*!
  479. * @ingroup TCA8418_Functions_Public
  480. *
  481. * @brief Sets the Keylock Interrupt Mask Timer
  482. *
  483. * This function will set the Keylock Interrupt Mask Timer Value
  484. *                                      
  485. * @param[in]   keypad_lock_interrupt_mask_timer_value      Mask timer delay "fill this in Later"
  486. * @param[in]   device_slot                                 Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  487. * @param[in]   I2C_slave_address                           TCA8418 I2C slave address
  488. *
  489. * @return  I2C_OPERATION_SUCCESSFUL    Success
  490. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  491. ********************************************************************************************************************************/
  492. void Set_TCA8418_Keylock_Interrupt_Mask_Timer_Value (unsigned char keypad_lock_interrupt_mask_timer_value,
  493.                                                                   unsigned char I2C_slave_address)
  494. {
  495.     unsigned char TCA8418_Keypad_Timer = 0x00;                                               // Zero out global variable  
  496.    
  497.     TCA8418_Keypad_Timer = Read_TCA8418_Register (TCA8418_KEYPAD_LOCK_TIMER_REGISTER, I2C_slave_address);
  498.    
  499.     TCA8418_Keypad_Timer = (TCA8418_Keypad_Timer & 0X07) | keypad_lock_interrupt_mask_timer_value;

  501.     Write_TCA8418_Register (TCA8418_KEYPAD_LOCK_TIMER_REGISTER, TCA8418_Keypad_Timer,I2C_slave_address);
  502.    
  503. }  


  506. /********************************************************************************************************************************
  507. *  Get_TCA8418_Keylock_Interrupt_Mask_Timer_Value
  508. ********************************************************************************************************************************/
  509. /*!
  510. * @ingroup TCA8418_Functions_Public
  511. *
  512. * @brief Gets the Keylock Interrupt Mask Timer Value  
  513. *
  514. * This function will get the Keylock Interrupt Mask Timer Value
  515. *                                      
  516. * @param[out]  keypad_lock_interrupt_mask_timer_value      Mask timer delay "fill this in Later"
  517. * @param[in]   I2C_slave_address                           TCA8418 I2C slave address
  518. *
  519. * @return  I2C_OPERATION_SUCCESSFUL    Success
  520. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  521. ********************************************************************************************************************************/
  522. void Get_TCA8418_Keylock_Interrupt_Mask_Timer_Value (unsigned char keypad_lock_interrupt_mask_timer_value,
  523.                                                                   unsigned char I2C_slave_address)
  524. {
  525.     unsigned char TCA8418_Keypad_Timer = 0x00;  
  526.    
  527.     TCA8418_Keypad_Timer = Read_TCA8418_Register (TCA8418_KEYPAD_LOCK_TIMER_REGISTER, I2C_slave_address);
  528.                            
  529.     keypad_lock_interrupt_mask_timer_value = TCA8418_Keypad_Timer & 0XF8 ;
  530.    
  531. }  

  533. /********************************************************************************************************************************
  534. *  Set_TCA8418_Keylock_Unlock_Values
  535. ********************************************************************************************************************************/
  536. /*!
  537. * @ingroup TCA8418_Functions_Public
  538. *
  539. * @brief Sets the Unlock Key Values for Key 1 and Key 2
  540. *
  541. * This function will set the Unlock Key Values for Key 1 and Key 2
  542. *                                      
  543. * @param[in]   key_1_unlock_value              Key 1 unlock value
  544. * @param[in]   key_2_unlock_value              Key 2 unlock value
  545. * @param[in]   I2C_slave_address               TCA8418 I2C slave address
  546. *
  547. * @return  I2C_OPERATION_SUCCESSFUL    Success
  548. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  549. ********************************************************************************************************************************/
  550. void Set_TCA8418_Keylock_Unlock_Values (unsigned char key_1_unlock_value,
  551.                                                      unsigned char key_2_unlock_value,
  552.                                                      unsigned char I2C_slave_address)

  554. {
  555.     unsigned char I2C_key_1_unlock_value = key_1_unlock_value;
  556.     unsigned char I2C_key_2_unlock_value = key_2_unlock_value;
  557.    
  558.     Write_TCA8418_Register (TCA8418_UNLOCK_KEY_1_REGISTER, I2C_key_1_unlock_value, I2C_slave_address);
  559.    
  560.     Write_TCA8418_Register (TCA8418_UNLOCK_KEY_2_REGISTER, I2C_key_2_unlock_value, I2C_slave_address);
  561. }

  563. /********************************************************************************************************************************
  564. *  Set_TCA8418_Keylock_Unlock_Values
  565. ********************************************************************************************************************************/
  566. /*!
  567. * @ingroup TCA8418_Functions_Public
  568. *
  569. * @brief Gets the Unlock Key Values for Key 1 and Key 2
  570. *
  571. * This function will get the Unlock Key Values for Key 1 and Key 2
  572. *                                      
  573. * @param[out]  key_1_unlock_value              Key 1 unlock value
  574. * @param[out]  key_2_unlock_value              Key 2 unlock value
  575. * @param[in]   device_slot                     Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  576. * @param[in]   I2C_slave_address               TCA8418 I2C slave address
  577. *
  578. * @return  I2C_OPERATION_SUCCESSFUL    Success
  579. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  580. ********************************************************************************************************************************/
  581. void Get_TCA8418_Keylock_Unlock_Values (unsigned char key_1_unlock_value,
  582.                                                    unsigned char key_2_unlock_value,
  583.                                                    unsigned char  I2C_slave_address)
  584. {
  585.     unsigned char return_status;   
  586.     unsigned char I2C_key_1_unlock_value = 0X00;
  587.     unsigned char I2C_key_2_unlock_value = 0X00;
  588.    
  589.     I2C_key_1_unlock_value = Read_TCA8418_Register (TCA8418_UNLOCK_KEY_1_REGISTER, I2C_slave_address);
  590.    
  591.     I2C_key_2_unlock_value = Read_TCA8418_Register (TCA8418_UNLOCK_KEY_2_REGISTER, I2C_slave_address);
  592.    
  593.     key_1_unlock_value = I2C_key_1_unlock_value;
  594.     key_2_unlock_value = I2C_key_2_unlock_value;
  595. }

  597. /**************************************************************************************************************************************************
  598. *  Set_TCA8418_Keylock_State                                                                                                  
  599. **************************************************************************************************************************************************/
  600. /*!
  601. * @ingroup TCA8418_Functions_Public
  602. *
  603. * @brief Set(Enable or Disable) the Key Lock state
  604. *
  605. * This function sets the state of the TC8418 Key Lock (Enable or Disable)  
  606. *
  607. * @param[in]   keylock_state           Key Lock state can be set to ENABLE or DISABLE
  608. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  609. *
  610. * @return  I2C_OPERATION_SUCCESSFUL    Success
  611. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  612. **************************************************************************************************************************************************/
  613. void Set_TCA8418_Keylock_State(unsigned char  keylock_state,
  614.                                             unsigned char  I2C_slave_address)
  615. {
  616.    
  617.     unsigned char TCA8418_Key_Lock_Event_Counter = 0x00;                                     // Zero out global register
  618.   
  619.     TCA8418_Key_Lock_Event_Counter = Read_TCA8418_Register (TCA8418_KEY_LOCK_AND_EVENT_COUNTER_REGISTER,I2C_slave_address);
  620.    
  621.     TCA8418_Key_Lock_Event_Counter = (TCA8418_Key_Lock_Event_Counter & 0XCF) |  keylock_state ;

  623.     Write_TCA8418_Register (TCA8418_KEY_LOCK_AND_EVENT_COUNTER_REGISTER, TCA8418_Key_Lock_Event_Counter, I2C_slave_address);
  624. }

  626. /**************************************************************************************************************************************************
  627. *  Enable_TCA8418_Keylock                                                                                                  
  628. **************************************************************************************************************************************************/
  629. /*!
  630. * @ingroup TCA8418_Functions_Public
  631. *
  632. * @brief Enables the Key Lock state
  633. *
  634. * This function sets the state of the TC8418 Key Lock to ENABLE.  
  635. *
  636. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  637. *
  638. * @return  I2C_OPERATION_SUCCESSFUL    Success
  639. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  640. **************************************************************************************************************************************************/
  641. void Enable_TCA8418_Keylock( unsigned char I2C_slave_address)
  642. {   
  643.     Set_TCA8418_Keylock_State(0X00, I2C_slave_address);  // Enable Keylock Function
  644. }

  646. /**************************************************************************************************************************************************
  647. *  Disable_TCA8418_Keylock                                                                                                  
  648. **************************************************************************************************************************************************/
  649. /*!
  650. * @ingroup TCA8418_Functions_Public
  651. *
  652. * @brief Disables the Key Lock state
  653. *
  654. * This function sets the state of the TC8418 Key Lock to DISABLE.  
  655. *
  656. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  657. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  658. *
  659. * @return  I2C_OPERATION_SUCCESSFUL    Success
  660. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  661. **************************************************************************************************************************************************/
  662. void Disable_TCA8418_Keylock(unsigned char I2C_slave_address)
  663. {  
  664.     Set_TCA8418_Keylock_State(0X30, I2C_slave_address);  // Disable Keylock Function  
  665. }

  667. /**************************************************************************************************************************************************
  668. *  mvk_Get_TCA8418_Keylock_Status
  669. **************************************************************************************************************************************************/
  670. /*!
  671. * @ingroup TCA8418_Functions_Public
  672. *
  673. * @brief Get the Key Lock state (Enable or Disable)
  674. *
  675. * This function gets the state of the TC8418 Key Lock (Enable or Disable)  
  676. *
  677. * @param[out]  keypad_lock_status      Key Lock state can be set to ENABLE or DISABLE
  678. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  679. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  680. *
  681. * @return  I2C_OPERATION_SUCCESSFUL    Success
  682. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  683. **************************************************************************************************************************************************/
  684. void Get_TCA8418_Keypad_Lock_Status(unsigned char keypad_lock_status,
  685.                                                  unsigned char I2C_slave_address)
  686. {  
  687.     unsigned char TCA8418_Key_Lock_Event_Counter = 0x00;                                     // Zero out global variable
  688.    
  689.     TCA8418_Key_Lock_Event_Counter = Read_TCA8418_Register (TCA8418_KEY_LOCK_AND_EVENT_COUNTER_REGISTER, I2C_slave_address);
  690.    
  691.     keypad_lock_status = TCA8418_Key_Lock_Event_Counter;

  693. }

  695. /**************************************************************************************************************************************************
  696. *  Set_TCA8418_Keypad_Lock_Interrupt
  697. **************************************************************************************************************************************************/
  698. /*!
  699. * @ingroup TCA8418_Functions_Public
  700. *
  701. * @brief Set(Enable or Disable) the Key Lock Interrupt
  702. *
  703. * This function sets the Key Lock Interrupt register to ENABLE or DISABLE
  704. *
  705. * @param[in]   state                   Key Lock Interrupt state can be set to ENABLE or DISABLE
  706. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  707. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  708. *
  709. * @return  I2C_OPERATION_SUCCESSFUL    Success
  710. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  711. **************************************************************************************************************************************************/
  712. void Set_TCA8418_Keypad_Lock_Interrupt(unsigned char state, unsigned char I2C_slave_address)
  713. {
  714.     unsigned char TCA8418_Configuration = 0x00;                                              // Zero out global variable
  715.    
  716.     TCA8418_Configuration = Read_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER,I2C_slave_address);
  717.    
  718.     TCA8418_Configuration = (TCA8418_Configuration & 0XFB)| state;

  720.     Write_TCA8418_Register (TCA8418_CONFIGURATION_REGISTER, TCA8418_Configuration, I2C_slave_address);
  721. }     

  723. /**************************************************************************************************************************************************
  724. *  Enable_TCA8418_Keypad_Lock_Interrupt
  725. **************************************************************************************************************************************************/
  726. /*!
  727. * @ingroup TCA8418_Functions_Public
  728. *
  729. * @brief Enables the Key Lock Interrupt
  730. *
  731. * This function sets the Key Lock Interrupt register to ENABLE.
  732. *
  733. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  734. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  735. *
  736. * @return  I2C_OPERATION_SUCCESSFUL    Success
  737. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  738. **************************************************************************************************************************************************/
  739. void Enable_TCA8418_Keypad_Lock_Interrupt ( unsigned char I2C_slave_address)
  740. {   
  741.     Set_TCA8418_Keypad_Lock_Interrupt (0X04, I2C_slave_address);
  742. }  

  744. /**************************************************************************************************************************************************
  745. *  Disable_TCA8418_Keypad_Lock_Interrupt
  746. **************************************************************************************************************************************************/
  747. /*!
  748. * @ingroup TCA8418_Functions_Public
  749. *
  750. * @brief Disables the Key Lock Interrupt
  751. *
  752. * This function sets the Key Lock Interrupt register to DISABLE.
  753. *
  754. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  755. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  756. *
  757. * @return  I2C_OPERATION_SUCCESSFUL    Success
  758. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  759. **************************************************************************************************************************************************/
  760. void Disable_TCA8418_Keypad_Lock_Interrupt (unsigned char I2C_slave_address)
  761. {   
  762.     Set_TCA8418_Keypad_Lock_Interrupt (0X00, I2C_slave_address);
  763. }  

  765. /**************************************************************************************************************************************************
  766. *  Get_TCA8418_Interrupt_Status
  767. **************************************************************************************************************************************************/
  768. /*!
  769. * @ingroup TCA8418_Functions_Public
  770. *
  771. * @brief Get the TCA8418 Interrupt Status Register
  772. *
  773. * This function returns the TCA8418 interrupt status register containing individual bits (SET or CLEAR) for each interrupt in the status byte.
  774. *
  775. * @param[out]  interrupt_status        Contains individual bits for each current interrupt (SET or CLEAR)
  776. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  777. *
  778. * @return  I2C_OPERATION_SUCCESSFUL    Success
  779. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  780. **************************************************************************************************************************************************/
  781. unsigned char  Get_TCA8418_Interrupt_Status ( unsigned char  I2C_slave_address)
  782. {
  783.     return Read_TCA8418_Register (TCA8418_INTERRUPT_STATUS_REGISTER, I2C_slave_address);
  784. }

  786. /**************************************************************************************************************************************************
  787. *  Clear_TCA8418_Interrupt_Status
  788. **************************************************************************************************************************************************/
  789. /*!
  790. * @ingroup TCA8418_Functions_Public
  791. *
  792. * @brief Clears interrupts out of the TCA8418 Interrupt Register
  793. *
  794. * This function clears the indicated interrupts in the TCA8418.
  795. *
  796. * @param[in]   interrupt_status        Contains individual bits for each interrupt to clear
  797. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  798. *
  799. * @return  I2C_OPERATION_SUCCESSFUL    Success
  800. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  801. **************************************************************************************************************************************************/
  802. void Clear_TCA8418_Interrupt_Status (unsigned char interrupt_status,
  803.                                                   unsigned char I2C_slave_address)
  804. {
  805.     unsigned char TCA8418_interrupt_status = interrupt_status;
  806.    
  807.     Write_TCA8418_Register (TCA8418_INTERRUPT_STATUS_REGISTER, TCA8418_interrupt_status, I2C_slave_address);
  808. }

  810. /**************************************************************************************************************************************************
  811. *  Set_TCA8418_Debounce_State
  812. **************************************************************************************************************************************************/
  813. /*!
  814. * @ingroup TCA8418_Functions_Public
  815. *
  816. * @brief Sets the TCA8418 Debounce State
  817. *
  818. * This function sets the debounce state for the indicated row / columns
  819. *
  820. * @param[in]   row7_row0_state         Identifies the row settings
  821. * @param[in]   col9_col0_state         Identifies the column settings
  822. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  823. *
  824. * @return  I2C_OPERATION_SUCCESSFUL    Success
  825. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  826. **************************************************************************************************************************************************/
  827. void Set_TCA8418_Debounce_State (unsigned int row7_row0_state,
  828.                                               unsigned int col9_col0_state,
  829.                                               unsigned char I2C_slave_address)
  830. {
  831.     unsigned char TCA8418_row_debounce_state =  ~(unsigned char)row7_row0_state;             // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  832.     unsigned char TCA8418_col7_col0_debounce_state = ~(unsigned char)col9_col0_state;        // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  833.     unsigned char TCA8418_col9_col8_debounce_state = ~(unsigned char)(col9_col0_state >> 8); // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled

  835.     Write_TCA8418_Register (TCA8418_GPIO_DEBOUNCE_DISABLE_1_REGISTER, TCA8418_row_debounce_state, I2C_slave_address);

  837.     Write_TCA8418_Register (TCA8418_GPIO_DEBOUNCE_DISABLE_2_REGISTER, TCA8418_col7_col0_debounce_state, I2C_slave_address);
  838.       
  839.     Write_TCA8418_Register (TCA8418_GPIO_DEBOUNCE_DISABLE_3_REGISTER, TCA8418_col9_col8_debounce_state,  I2C_slave_address);

  841. }

  843. /**************************************************************************************************************************************************
  844. *  Get_TCA8418_Debounce_State
  845. **************************************************************************************************************************************************/
  846. /*!
  847. * @ingroup TCA8418_Functions_Public
  848. *
  849. * @brief Gets the TCA8418 Debounce State
  850. *
  851. * This function returns the debounce state for the indicated row / columns
  852. *
  853. * @param[out]  row7_row0_state         Location to place the row settings
  854. * @param[out]  col9_col0_state         Location to place the column settings
  855. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  856. *
  857. * @return  I2C_OPERATION_SUCCESSFUL    Success
  858. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  859. **************************************************************************************************************************************************/
  860. void Get_TCA8418_Debounce_State (unsigned int row7_row0_state,
  861.                                               unsigned int col9_col0_state,
  862.                                               unsigned char I2C_slave_address)
  863. {
  864.     unsigned char TCA8418_row_debounce_state;
  865.     unsigned char TCA8418_col7_col0_debounce_state;
  866.     unsigned char TCA8418_col9_col8_debounce_state;
  867.          
  868.     TCA8418_row_debounce_state = Read_TCA8418_Register (TCA8418_GPIO_DEBOUNCE_DISABLE_1_REGISTER,I2C_slave_address);
  869.      
  870.     TCA8418_col7_col0_debounce_state = Read_TCA8418_Register (TCA8418_GPIO_DEBOUNCE_DISABLE_2_REGISTER,I2C_slave_address);
  871.       
  872.     TCA8418_col9_col8_debounce_state = Read_TCA8418_Register (TCA8418_GPIO_DEBOUNCE_DISABLE_3_REGISTER,I2C_slave_address);

  874.    
  875.     row7_row0_state = ~TCA8418_row_debounce_state;                                    // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  876.     col9_col0_state = ~ ( ((unsigned int)TCA8418_col9_col8_debounce_state << 8) |     // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  877.                             (unsigned int)TCA8418_col7_col0_debounce_state);
  878. }

  880. /**************************************************************************************************************************************************
  881. *  Set_TCA8418_GPIO_Pullup_State
  882. **************************************************************************************************************************************************/
  883. /*!
  884. * @ingroup TCA8418_Functions_Public
  885. *
  886. * @brief Sets the TCA8418 GPIO pullup registers
  887. *
  888. * This function sets the GPIO pullup state for the indicated row / columns
  889. *
  890. * @param[in]   row7_row0_state         Identifies the row settings
  891. * @param[in]   col9_col0_state         Identifies the column settings
  892. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  893. *
  894. * @return  I2C_OPERATION_SUCCESSFUL    Success
  895. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  896. **************************************************************************************************************************************************/
  897. void Set_TCA8418_GPIO_Pullup_State (unsigned int row7_row0_state,
  898.                                                  unsigned int col9_col0_state,
  899.                                                  unsigned char I2C_slave_address)
  900. {
  901.     unsigned char TCA8418_row_pullup_state =  ~(unsigned char)row7_row0_state;             // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  902.     unsigned char TCA8418_col7_col0_pullup_state = ~(unsigned char)col9_col0_state;        // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  903.     unsigned char TCA8418_col9_col8_pullup_state = ~(unsigned char)(col9_col0_state >> 8); // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  904.    
  905.     Write_TCA8418_Register (TCA8418_GPIO_PULLUP_1_REGISTER, TCA8418_row_pullup_state, I2C_slave_address);
  906.    
  907.     Write_TCA8418_Register (TCA8418_GPIO_PULLUP_2_REGISTER, TCA8418_col7_col0_pullup_state, I2C_slave_address);

  909.     Write_TCA8418_Register (TCA8418_GPIO_PULLUP_3_REGISTER, TCA8418_col9_col8_pullup_state, I2C_slave_address);
  910. }

  912. /**************************************************************************************************************************************************
  913. *  Get_TCA8418_GPIO_Pullup_State
  914. **************************************************************************************************************************************************/
  915. /*!
  916. * @ingroup TCA8418_Functions_Public
  917. *
  918. * @brief Gets the TCA8418 GPIO pullup registers
  919. *
  920. * This function returns the GPIO pullup state for the indicated row / columns
  921. *
  922. * @param[out]  row7_row0_state         Location to place the row settings
  923. * @param[out]  col9_col0_state         Location to place the column settings
  924. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  925. *
  926. * @return  I2C_OPERATION_SUCCESSFUL    Success
  927. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  928. **************************************************************************************************************************************************/
  929. void Get_TCA8418_GPIO_Pullup_State (unsigned int row7_row0_state,
  930.                                                  unsigned int col9_col0_state,
  931.                                                  unsigned char I2C_slave_address)
  932. {
  933.     unsigned char TCA8418_row_pullup_state;
  934.     unsigned char TCA8418_col7_col0_pullup_state;
  935.     unsigned char TCA8418_col9_col8_pullup_state;
  936.       
  937.     TCA8418_row_pullup_state = Read_TCA8418_Register (TCA8418_GPIO_PULLUP_1_REGISTER, I2C_slave_address);
  938.   
  939.     TCA8418_col7_col0_pullup_state = Read_TCA8418_Register (TCA8418_GPIO_PULLUP_2_REGISTER,I2C_slave_address);
  940.       
  941.     TCA8418_col9_col8_pullup_state = Read_TCA8418_Register (TCA8418_GPIO_PULLUP_3_REGISTER,I2C_slave_address);
  942.    
  943.     row7_row0_state = ~TCA8418_row_pullup_state;                                    // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  944.     col9_col0_state = ~ ( ((unsigned int)TCA8418_col9_col8_pullup_state << 8) |     // Bitwise inversion Register bit defined 0=Enabled, 1=Disabled
  945.                             (unsigned int)TCA8418_col7_col0_pullup_state);  
  946. }


  949. /**************************************************************************************************************************************************
  950. *  Get_TCA8418_GPIO_Interrupt_Status
  951. **************************************************************************************************************************************************/
  952. /*!
  953. * @ingroup TCA8418_Functions_Public
  954. *
  955. * @brief Get the TCA8418 GPIO Interrupt Status Register
  956. *
  957. * This function returns the TCA8418 GPIO interrupt status register containing individual bits (SET or CLEAR) for each GPIO interrupt in the
  958. * status bytes.
  959. *
  960. * @param[out]  GPIO_interrupt_status_1 Contains individual bits for each current GPIO interrupt (SET or CLEAR)
  961. * @param[out]  GPIO_interrupt_status_2 Contains individual bits for each current GPIO interrupt (SET or CLEAR)
  962. * @param[out]  GPIO_interrupt_status_3 Contains individual bits for each current GPIO interrupt (SET or CLEAR)
  963. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  964. *
  965. * @return  I2C_OPERATION_SUCCESSFUL    Success
  966. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  967. **************************************************************************************************************************************************/
  968. void Get_TCA8418_GPIO_Interrupt_Status (unsigned char GPIO_interrupt_status_1,
  969.                                                      unsigned char GPIO_interrupt_status_2,
  970.                                                      unsigned char GPIO_interrupt_status_3,
  971.                                                      unsigned char I2C_slave_address)
  972. {
  973.      unsigned char TCA8418_GPIO_interrupt_status_1 = 0x00;
  974.      unsigned char TCA8418_GPIO_interrupt_status_2 = 0x00;
  975.      unsigned char TCA8418_GPIO_interrupt_status_3 = 0x00;
  976.      
  977.      TCA8418_GPIO_interrupt_status_1 = Read_TCA8418_Register (TCA8418_KEYSCAN_GPIO_FUNCTION_1_REGISTER, I2C_slave_address);

  979.      TCA8418_GPIO_interrupt_status_2 = Read_TCA8418_Register (TCA8418_KEYSCAN_GPIO_FUNCTION_2_REGISTER, I2C_slave_address);

  981.      TCA8418_GPIO_interrupt_status_3 = Read_TCA8418_Register (TCA8418_KEYSCAN_GPIO_FUNCTION_3_REGISTER, I2C_slave_address);
  982.      
  983.      GPIO_interrupt_status_1 = TCA8418_GPIO_interrupt_status_1;
  984.      GPIO_interrupt_status_2 = TCA8418_GPIO_interrupt_status_2;
  985.      GPIO_interrupt_status_3 = TCA8418_GPIO_interrupt_status_3;
  986.      
  987. }

  989. /**************************************************************************************************************************************************
  990. *  Get_TCA8418_GPIO_Data_Status
  991. **************************************************************************************************************************************************/
  992. /*!
  993. * @ingroup TCA8418_Functions_Public
  994. *
  995. * @brief Get the TCA8418 GPIO Data Status
  996. *
  997. * This function returns the TCA8418 GPIO datt bits for each GPIO pin in the TCA8418.
  998. *
  999. * @param[out]  GPIO_data_status_1      Contains individual bits with the data from each GPIO
  1000. * @param[out]  GPIO_data_status_2      Contains individual bits with the data from each GPIO
  1001. * @param[out]  GPIO_data_status_3      Contains individual bits with the data from each GPIO
  1002. * @param[in]   device_slot             Defines slot where RF-TCA8418-MVK module is plugged into MB-PRO-MVK motherboard
  1003. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  1004. *
  1005. * @return  I2C_OPERATION_SUCCESSFUL    Success
  1006. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  1007. **************************************************************************************************************************************************/
  1008. void Get_TCA8418_GPIO_Data_Status (unsigned char GPIO_data_status_1,
  1009.                                                 unsigned char GPIO_data_status_2,
  1010.                                                 unsigned char GPIO_data_status_3,
  1011.                                                 unsigned char I2C_slave_address)
  1012. {
  1013.      unsigned char TCA8418_GPIO_data_status_1 = 0x00;
  1014.      unsigned char TCA8418_GPIO_data_status_2 = 0x00;
  1015.      unsigned char TCA8418_GPIO_data_status_3 = 0x00;

  1017.      TCA8418_GPIO_data_status_1 = Read_TCA8418_Register (TCA8418_GPIO_DATA_STATUS_1_REGISTER, I2C_slave_address);

  1019.      TCA8418_GPIO_data_status_2 = Read_TCA8418_Register (TCA8418_GPIO_DATA_STATUS_2_REGISTER, I2C_slave_address);
  1020.      
  1021.      TCA8418_GPIO_data_status_3 = Read_TCA8418_Register (TCA8418_GPIO_DATA_STATUS_3_REGISTER, I2C_slave_address);
  1022.      
  1023.      GPIO_data_status_1 = TCA8418_GPIO_data_status_1;
  1024.      GPIO_data_status_2 = TCA8418_GPIO_data_status_2;
  1025.      GPIO_data_status_3 = TCA8418_GPIO_data_status_3;   
  1026. }  

  1028. /**************************************************************************************************************************************************
  1029. *  Process_TCA8418_Interrupt
  1030. **************************************************************************************************************************************************/
  1031. /*!
  1032. * @ingroup TCA8418_Functions_Public
  1033. *
  1034. * @brief Process TCA8418 Interrupt
  1035. *
  1036. * This function processes the various TCA8418 interrupts, including CTRL-ALT-DEL, KEY Lock, GPI events, Key buffer overflow, and general Key events
  1037. *
  1038. * @param[in]   I2C_slave_address       TCA8418 I2C slave address
  1039. *
  1040. * @return  I2C_OPERATION_SUCCESSFUL    Success
  1041. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  1042. **************************************************************************************************************************************************/
  1043. void Process_TCA8418_Interrupt ( unsigned char I2C_slave_address)
  1044. {
  1045.     unsigned char lock_status;
  1046.     unsigned char number_of_key_events_in_buffer;
  1047.     unsigned char interrupt_status = 0x00;
  1048.     volatile TCA8418_Interrupt_Status_register_type *TCA8418_Interrupt_Status_register = (TCA8418_Interrupt_Status_register_type*)&interrupt_status;

  1050.     Disable_TCA8418_Key_Event_Interrupt (I2C_slave_address);  // Prevent TCA8418 from generating additional interrupts until current one is processed  
  1051.         
  1052.     Get_TCA8418_Interrupt_Status (I2C_slave_address); // Find out what type of action is required by the TCA8418
  1053.      
  1054.      
  1055.     if (TCA8418_Interrupt_Status_register->Key_Event_Interrupt_Flag)
  1056.     {
  1057.         Move_Key_Events_From_TCA8418_FIFO_To_Buffer (TCA8418_Key_Event_Buffer,  // Globally allocated buffer array in TCA8418_Key_Scan.c
  1058.                                                                 TCA8418_KEY_EVENT_BUFFER_SIZE,        
  1059.                                                                 number_of_key_events_in_buffer,
  1060.                                                                 I2C_slave_address);
  1061.         
  1062.         
  1063.         // Prints Key Press/Realease to terminal  
  1064.         // Replace Print_Key_Event below below with call to process key events for your specific embedded system
  1065.         TCA8418_Print_Key_Event (TCA8418_Key_Event_Buffer,               
  1066.                                    number_of_key_events_in_buffer,
  1067.                                    I2C_slave_address);
  1068.          
  1069.         // Data is available to be packetized, if desired by the main program
  1070.         TCA8418_Key_Events_In_Buffer_Size = number_of_key_events_in_buffer;  // Provides user an indication of the number of events currently in the buffer
  1071.     }  
  1072.    
  1073.         
  1074.     Clear_TCA8418_Interrupt_Status (interrupt_status, I2C_slave_address);

  1076.     Enable_TCA8418_Key_Event_Interrupt (I2C_slave_address);
  1077. }


  1080. /**************************************************************************************************************************************************
  1081. *  TCA8418_Print_Key_Event
  1082. **************************************************************************************************************************************************/
  1083. /*!
  1084. * @ingroup TCA8418_Functions_Private
  1085. *
  1086. * @brief Prints the key event buffer out the UART Print buffer
  1087. *
  1088. * This function prints debug messages for all key events present in the buffer.
  1089. *
  1090. * @param[in]   TCA8418_key_event_buffer        Pointer to the key event buffer containing the key press events
  1091. * @param[in]   number_of_key_events_in_buffer  Number of characters in the event buffer
  1092. * @param[in]   I2C_slave_address               TCA8418 I2C slave address
  1093. *
  1094. * @return  I2C_OPERATION_SUCCESSFUL    Success
  1095. * @return  I2C_WRITE_FAILED_NACK       Failure as TCA8418 NAK a transmission on I2C            
  1096. **************************************************************************************************************************************************/
  1097. //void TCA8418_Print_Key_Event (unsigned char TCA8418_key_event_buffer,
  1098. //                                  unsigned char number_of_key_events_in_buffer,
  1099. //                                  unsigned char I2C_slave_address)
  1100. //{
  1101. //    unsigned char number_of_key_events = number_of_key_events_in_buffer;
  1102. //    unsigned char buffer_index= 0;
  1103. //    unsigned char keypad_locked;
  1104. //    unsigned char key;
  1105. //    unsigned char key_state;
  1106. //
  1107. //    Get_TCA8418_Keypad_Lock_Status(&keypad_locked, device_slot, I2C_slave_address);
  1108. //        
  1109. //    while(number_of_key_events > 0)
  1110. //    {  
  1111. //        TCA8418_Key_Event = TCA8418_key_event_buffer[buffer_index];
  1112. //        key = TCA8418_Key_Event_register->Key_Event;
  1113. //        key_state = TCA8418_Key_Event_register->Key_Press_State;
  1114. //      
  1115. //        if (!keypad_locked)
  1116. //        {  
  1117. //            switch(key)
  1118. //            {  
  1119. //                case SWITCH_1:
  1120. //                    mvk_UART_Debug_PrintF_Flush ("7", 1);
  1121. //                    break;
  1122. //        
  1123. //                case SWITCH_2:
  1124. //                    mvk_UART_Debug_PrintF_Flush ("8", 1);
  1125. //                    break;
  1126. //   
  1127. //                case SWITCH_3:
  1128. //                    mvk_UART_Debug_PrintF_Flush ("9", 1);
  1129. //                    break;
  1130. //        
  1131. //                case SWITCH_4:
  1132. //                    mvk_UART_Debug_PrintF_Flush ("4", 1);
  1133. //                    break;
  1134. //        
  1135. //                case SWITCH_5:
  1136. //                    mvk_UART_Debug_PrintF_Flush ("5", 1);
  1137. //                    break;            
  1138. //            
  1139. //                case SWITCH_6:
  1140. //                    mvk_UART_Debug_PrintF_Flush ("6", 1);
  1141. //                    break;      
  1142. //           
  1143. //                case SWITCH_7:
  1144. //                    mvk_UART_Debug_PrintF_Flush ("1", 1);
  1145. //                    break;   
  1146. //           
  1147. //                case SWITCH_8:
  1148. //                    mvk_UART_Debug_PrintF_Flush ("2", 1);
  1149. //                    break;   
  1150. //           
  1151. //                case SWITCH_9:
  1152. //                    mvk_UART_Debug_PrintF_Flush ("3", 1);
  1153. //                    break;   
  1154. //               
  1155. //                case SHIFT_SWITCH:
  1156. //                    mvk_UART_Debug_PrintF_Flush ("SHIFT", 5);
  1157. //                    break;   
  1158. //               
  1159. //                case SWITCH_0:
  1160. //                    mvk_UART_Debug_PrintF_Flush ("0", 1);
  1161. //                    break;   
  1162. //            
  1163. //                case ENTER_SWITCH: // ENTER_SWITCH used as a special Key to initiate keypad lock
  1164. //
  1165. //                    if(Is_TCA8418_Keylock_Available())
  1166. //                    {
  1167. //                        if (!keypad_locked)  // Remove if ENTER key is not used as Lock Keypad Key Event
  1168. //                        {  
  1169. //                            Enable_TCA8418_Keylock(I2C_slave_address);
  1170. //                            Enable_TCA8418_Keypad_Lock_Interrupt ( I2C_slave_address);
  1171. //                        }
  1172. //                    }
  1173. //                    else                  
  1174. //                    {
  1175. //                        mvk_UART_Debug_PrintF_Flush ("ENTER", 5);
  1176. //                    }
  1177. //                    break;        
  1178. //            
  1179. //                case NAVIGATION_UP:
  1180. //                    mvk_UART_Debug_PrintF_Flush ("NAV_UP", 6);
  1181. //                    break;   
  1182. //           
  1183. //                case NAVIGATION_DOWN:
  1184. //                    mvk_UART_Debug_PrintF_Flush ("NAV_DOWN", 8);
  1185. //                    break;   
  1186. //               
  1187. //                case NAVIGATION_RIGHT:
  1188. //                    mvk_UART_Debug_PrintF_Flush ("NAV_RIGHT", 9);
  1189. //                    break;   
  1190. //               
  1191. //                case NAVIGATION_LEFT:
  1192. //                    mvk_UART_Debug_PrintF_Flush ("NAV_LEFT", 8);
  1193. //                    break;   
  1194. //               
  1195. //                case NAVIGATION_SELECT:
  1196. //                    mvk_UART_Debug_PrintF_Flush ("NAV_SELECT", 10);
  1197. //                    break;               
  1198. //        
  1199. //                default:     
  1200. //                    mvk_UART_Debug_PrintF_Flush ("UNDEFINED_KEY_ERROR", 19);
  1201. //                break;
  1202. //            }
  1203. //        }// end of if (!keypad_locked)
  1204. //        
  1205. //        // Get current state of keypad locked, it could have changed if ENTER key processed above
  1206. //        Get_TCA8418_Keypad_Lock_Status(&keypad_locked, device_slot, I2C_slave_address);
  1207. //         
  1208. //        if (!keypad_locked)  
  1209. //        {
  1210. //            switch(key_state)
  1211. //            {  
  1212. //                case KEY_RELEASED:
  1213. //                    mvk_UART_Debug_PrintF_Flush ("_KEY_RELEASED \n\r", 16);
  1214. //                    break;
  1215. //        
  1216. //                case KEY_PRESSED:
  1217. //                    mvk_UART_Debug_PrintF_Flush ("_KEY_PRESSED \n\r", 15);
  1218. //                    break;        
  1219. //                default:     
  1220. //                    mvk_UART_Debug_PrintF_Flush ("_UNDEFINED_KEY_STATE_ERROR \n\r", 29);
  1221. //                    break;
  1222. //            }
  1223. //        }// end of if (!keypad_locked)
  1224. //        
  1225. //        ++buffer_index;
  1226. //        --number_of_key_events;  
  1227. //        
  1228. //    } // End While (Key_Events > 0)
  1229. //}



  1233. /*************************************************************************************************************************************************/
  1234. /* End of PUBLIC section                                                                                                                         */
  1235. /*                                                                                                                                               */
  1236. /*! \endcond                                                                                                                                     */
  1237. /*************************************************************************************************************************************************/

复制代码

LCD驱动：
  1. #include "msp430fr5969.h"
  2. #include "SPI.h"
  3. #include "IO_Define.h"
  4. #include "LCD.h"
  5. #include "zifu.h"
  6. #include "delay.h"


  9. void HDReset()
  10. {
  11.   //LCD_CS_0;
  12.   LCD_RSTB_0;
  13.   TimerDelay_ms(20);
  14.   LCD_RSTB_1;
  15.   TimerDelay_ms(40);
  16.   //LCD_CS_1;
  17. }


  20. void Init_ST7567()
  21. {
  22.   LCD_AO_0;                     //发指令
  23.   //SPI_SELECT_LCD;               //SELECT LCD
  24.   LCD_CS_0;
  25.   HDReset();
  26.   TimerDelay_ms(100);

  28.   UCB0TXBUF = 0xe2;          //SOFT RESET//寄存器复位
  29.   TimerDelay_us(64);
  30.   UCB0TXBUF = 0xaf;          //0xaf显示器开
  31.   TimerDelay_us(64);
  32.   UCB0TXBUF = 0x2f;          //0x2f升压电路,电压管理电路,
  33.   TimerDelay_us(64);             
  34.   UCB0TXBUF = 0x25;           //0x20-0x27为V5电压内部电阻调整设置
  35.   TimerDelay_us(64);
  36.   UCB0TXBUF = 0x81;           // SET EV 调对比度
  37.   TimerDelay_us(64);
  38.   UCB0TXBUF = 0x1F;           //0x01-0x3f电量寄存器设置模式
  39.   TimerDelay_us(64);
  40.   UCB0TXBUF = 0xa0;           //0xa0为Segment正向,0xa1 为Segment反向
  41.   TimerDelay_us(64);
  42.   UCB0TXBUF = 0xc8;           //0xc0正向扫描,0xc8反射扫描
  43.   TimerDelay_us(64);
  44.   UCB0TXBUF = 0xa6;           // //0xa6正向显示,0xa7反向显示
  45.   TimerDelay_us(64);
  46.   UCB0TXBUF = 0xa4;           // //0xa4正常显示,0xa5全屏点亮
  47.   TimerDelay_us(64);
  48.   UCB0TXBUF = 0xf8;           // //背压比设置
  49.   TimerDelay_us(64);
  50.   UCB0TXBUF = 0x00;                 //00--10
  51.   TimerDelay_us(64);
  52.   LCD_AO_0;
  53. //  Stop_SPI();
  54.   //LCD_CS_1;
  55. }


  58. /*-------------------------------------------
  59. LCD_set_XY: 设置LCD坐标函数
  60. 输入参数：X：0－128（column） Y：0－8（page）
  61. 编写日期：20140315
  62. ---------------------------------------------*/
  63. void LCD_set_XY(unsigned int X, unsigned char Y)
  64. {
  65.         unsigned char temp1 = 0,temp2 = 0;
  66. //        Star_SPI();
  67.         LCD_CS_0;
  68.         LCD_AO_0;
  69.         UCB0TXBUF = 0xb0+Y;   //设置page（页）地址
  70.         TimerDelay_us(64);
  71.         temp1 =( X & 0XF0)>>4;      //高四位
  72.         temp2 = X & 0X0F;           //低四位
  73.         UCB0TXBUF = 0x10|temp1;     //设置column（列）地址高4位  （共有131列）
  74.         TimerDelay_us(64);
  75.         UCB0TXBUF = temp2;     //设置column（列）地址低4位
  76.         TimerDelay_us(64);
  77.         LCD_AO_1;
  78. }

  80. /*-------------------------------------------
  81. Clear_Arrow: 清除箭头
  82. 输入参数：X：0－128（column） Y：0－8（page）
  83. 编写日期：20140315
  84. ---------------------------------------------*/
  85. void Clear_Arrow(unsigned char column,unsigned char page)
  86. {
  87.   LCD_write_word(column, page , 34);
  88. }

  90. /*-------------------------------------------
  91. Clear_Region: 清除区域
  92. 输入参数：column1：起始点横坐标
  93.             page1：起始点纵坐标      
  94.           column2：终点横坐标  
  95.             page2：终点纵坐标
  96.               xx : 填充内容
  97. 编写日期：20140315
  98. ---------------------------------------------*/
  99. void Clear_Region(unsigned char column1,unsigned char page1,unsigned char column2,unsigned char page2,unsigned char xx)
  100. {
  101.   unsigned char i,j;
  102.   LCD_CS_0;
  103.   for(i=page1;i<page2;i++)
  104.   {
  105.     LCD_AO_0;
  106.     UCB0TXBUF = 0xb0+i;   //设置page（页）地址         （共有8页）
  107.     TimerDelay_us(64);
  108.     UCB0TXBUF = 0x10;     //设置column（列）地址高4位  （共有131列）
  109.     TimerDelay_us(64);
  110.     UCB0TXBUF = 0x00;     //设置column（列）地址低4位
  111.     TimerDelay_us(64);
  112.     for(j=column1;j<column2;j++)
  113.     {
  114.       LCD_AO_1;
  115.       UCB0TXBUF = xx;
  116.       TimerDelay_us(64);
  117.     }
  118.   }
  119.   LCD_CS_1;
  120. }


  123. /*---------------------------------------------
  124. LCD_write_zimu: 显示6（宽）*12（高）点阵列数字字母符号等半角类
  125. 输入参数：c：显示的字符；
  126. 编写日期：20140315
  127. -----------------------------------------------*/
  128. void LCD_write_zimu(unsigned char column, unsigned char page,unsigned char c) //row:列 page:页 dd:字符
  129. {
  130.         unsigned char i;         
  131.        
  132.         LCD_set_XY(column, page);// 列，页
  133.         for(i=0; i<8;i++)
  134.         {
  135.                 UCB0TXBUF = zimu[c*16+i];
  136.                 TimerDelay_us(64);
  137.         }
  138.        
  139.         LCD_set_XY(column, page+1);// 列，页
  140.         for(i=8; i<16;i++)
  141.         {
  142.                 UCB0TXBUF = zimu[c*16+i];
  143.                 TimerDelay_us(64);
  144.         }
  145.         LCD_CS_1;
  146. }


  149. /*---------------------------------------------
  150. LCD_write_shu_6_8: 显示6（宽）*8（高）点阵列数字字母符号等半角类
  151. 输入参数：c：显示的字符；
  152. 编写日期：20140315
  153. -----------------------------------------------*/
  154. void LCD_write_shu_6_8(unsigned char column, unsigned char page,unsigned char c) //row:列 page:页 dd:字符
  155. {
  156.         unsigned char i;         
  157.        
  158.         LCD_set_XY(column, page);// 列，页
  159.         for(i=0; i<6;i++)
  160.         {
  161.                 UCB0TXBUF = shuzi_6_8[c*6+i];
  162.                 TimerDelay_us(64);
  163.         }
  164.         LCD_CS_1;
  165. }

  167. /*---------------------------------------------
  168. LCD_write_shu_6_8: 显示6（宽）*8（高）点阵列数字字母符号等半角类,支持反向显示
  169. 输入参数：c：显示的字符；
  170. 编写日期：20140315
  171. -----------------------------------------------*/
  172. void LCD_write_shu_6_8_opp(unsigned char column, unsigned char page,unsigned char c,unsigned char opposite) //row:列 page:页 dd:字符
  173. {
  174.         unsigned char i;         
  175.        
  176.         LCD_set_XY(column, page);// 列，页
  177.         if(opposite == 0)
  178.         {
  179.           for(i=0; i<6;i++)
  180.           {
  181.                   UCB0TXBUF = shuzi_6_8[c*6+i];
  182.                   TimerDelay_us(64);
  183.           }
  184.         }
  185.         else if(opposite == 1)
  186.         {
  187.           for(i=0; i<6;i++)
  188.           {
  189.                   UCB0TXBUF = ~shuzi_6_8[c*6+i];
  190.                   TimerDelay_us(64);
  191.           }
  192.         }
  193.         LCD_CS_1;
  194.          
  195. }


  198. /*---------------------------------------------
  199. LCD_write_shu_6_16: 显示6（宽）*16（高）点阵列数字字母符号等半角类
  200. 输入参数：c：显示的字符；
  201. 编写日期：20140315
  202. -----------------------------------------------*/
  203. void LCD_write_shu_6_16(unsigned char column, unsigned char page,unsigned char c) //row:列 page:页 dd:字符
  204. {
  205.         unsigned char i;         
  206.        
  207.         LCD_set_XY(column, page);// 列，页
  208.         for(i=0; i<6;i++)
  209.         {
  210.                 UCB0TXBUF = shuzi_6_16[c*12+i];
  211.                 TimerDelay_us(64);
  212.         }
  213.        
  214.         LCD_set_XY(column, page+1);// 列，页
  215.         for(i=6; i<12;i++)
  216.         {
  217.                 UCB0TXBUF = shuzi_6_16[c*12+i];
  218.                 TimerDelay_us(64);
  219.         }
  220.         LCD_CS_1;
  221. }


  224. /*---------------------------------------------
  225. LCD_write_shu_13_24: 显示13（宽）*24（高）点阵列数字字母符号等半角类
  226. 输入参数：c：显示的字符；
  227. 编写日期：20140315
  228. -----------------------------------------------*/
  229. void LCD_write_shu_13_24(unsigned char column, unsigned char page,unsigned char c) //row:列 page:页 dd:字符
  230. {
  231.         unsigned char i;         
  232.        
  233.         LCD_set_XY(column, page);// 列，页
  234.         for(i=0; i<13;i++)
  235.         {
  236.                 UCB0TXBUF = shuzi_13_24[c*39+i];
  237.                 TimerDelay_us(64);
  238.         }
  239.        
  240.         LCD_set_XY(column, page+1);// 列，页
  241.         for(i=13; i<26;i++)
  242.         {
  243.                 UCB0TXBUF = shuzi_13_24[c*39+i];
  244.                 TimerDelay_us(64);
  245.         }
  246.         LCD_set_XY(column, page+2);// 列，页
  247.         for(i=26; i<39;i++)
  248.         {
  249.                 UCB0TXBUF = shuzi_13_24[c*39+i];
  250.                 TimerDelay_us(64);
  251.         }
  252.         LCD_CS_1;
  253. }


  256. /*---------------------------------------------
  257. LCD_write_shu_digit: 显示9（宽）*16（高）点阵列数字字母符号等半角类
  258. 输入参数：c：显示的字符；
  259. 编写日期：20140315
  260. -----------------------------------------------*/
  261. void LCD_write_shu_digit(unsigned char column, unsigned char page,unsigned char c) //row:列 page:页 dd:字符
  262. {
  263.         unsigned char i;         
  264.        
  265.         LCD_set_XY(column, page);// 列，页
  266.         for(i=0; i<9;i++)
  267.         {
  268.                 UCB0TXBUF = shuzi[c*18+i];
  269.                 TimerDelay_us(64);
  270.         }
  271.        
  272.         LCD_set_XY(column, page+1);// 列，页
  273.         for(i=9; i<18;i++)
  274.         {
  275.                 UCB0TXBUF = shuzi[c*18+i];
  276.                 TimerDelay_us(64);
  277.         }
  278.         LCD_CS_1;
  279. }

  281. /*---------------------------------------------
  282. LCD_write_word: 显示16（宽）*16（高）点阵列数字字母符号等半角类
  283. 输入参数：c：显示的汉字；
  284. 编写日期：20140315
  285. -----------------------------------------------*/
  286. void LCD_write_word(unsigned char column, unsigned char page,unsigned char c) //row:列 page:页 dd:字符
  287. {
  288.         unsigned char i;         
  289.        
  290.         LCD_set_XY(column, page);// 列，页
  291.         for(i=0; i<16;i++)
  292.         {
  293.                 UCB0TXBUF = word[c*32+i];
  294.                 TimerDelay_us(64);
  295.         }
  296.        
  297.         LCD_set_XY(column, page+1);// 列，页
  298.         for(i=16; i<32;i++)
  299.         {
  300.                 UCB0TXBUF = word[c*32+i];
  301.                 TimerDelay_us(64);
  302.         }       
  303.         LCD_CS_1;
  304. }


  307. /*---------------------------------------------
  308. 函数名：LCD_write_Icon_Signal  显示信号强度图标
  309. 输入参数：c   信号强度等级   1最弱 5最强
  310. 编写日期：20141017
  311. -----------------------------------------------*/
  312. void LCD_write_Icon_Signal(unsigned char c) //row:列 page:页 dd:字符
  313. {
  314.         LCD_set_XY(0, 8);                            //天线图标
  315.         UCB0TXBUF = 0x01;
  316.         TimerDelay_us(64);
  317.         switch(c)
  318.         {
  319.         case 1:
  320.                 LCD_set_XY(10, 8);
  321.                 UCB0TXBUF = 0x01;
  322.                 TimerDelay_us(64);
  323.                 break;
  324.         case 2:
  325.                 LCD_set_XY(10, 8);
  326.                 UCB0TXBUF = 0x01;
  327.                 TimerDelay_us(64);
  328.                 LCD_set_XY(12, 8);
  329.                 UCB0TXBUF = 0x01;
  330.                 TimerDelay_us(64);
  331.                 break;
  332.         case 3:
  333.                 LCD_set_XY(10, 8);
  334.                 UCB0TXBUF = 0x01;
  335.                 TimerDelay_us(64);
  336.                 LCD_set_XY(12, 8);
  337.                 UCB0TXBUF = 0x01;
  338.                 TimerDelay_us(64);
  339.                 LCD_set_XY(16, 8);
  340.                 UCB0TXBUF = 0x01;
  341.                 TimerDelay_us(64);
  342.                 break;
  343.         case 4:
  344.                 LCD_set_XY(10, 8);
  345.                 UCB0TXBUF = 0x01;
  346.                 TimerDelay_us(64);
  347.                 LCD_set_XY(12, 8);
  348.                 UCB0TXBUF = 0x01;
  349.                 TimerDelay_us(64);
  350.                 LCD_set_XY(16, 8);
  351.                 UCB0TXBUF = 0x01;
  352.                 TimerDelay_us(64);
  353.                 LCD_set_XY(18, 8);
  354.                 UCB0TXBUF = 0x01;
  355.                 TimerDelay_us(64);
  356.                 break;
  357.         case 5:
  358.                 LCD_set_XY(10, 8);
  359.                 UCB0TXBUF = 0x01;
  360.                 TimerDelay_us(64);
  361.                 LCD_set_XY(12, 8);
  362.                 UCB0TXBUF = 0x01;
  363.                 TimerDelay_us(64);
  364.                 LCD_set_XY(16, 8);
  365.                 UCB0TXBUF = 0x01;
  366.                 TimerDelay_us(64);
  367.                 LCD_set_XY(18, 8);
  368.                 UCB0TXBUF = 0x01;
  369.                 TimerDelay_us(64);
  370.                 LCD_set_XY(20, 8);
  371.                 UCB0TXBUF = 0x01;
  372.                 TimerDelay_us(64);
  373.                 break;
  374.         default:
  375.                 LCD_set_XY(10, 8);
  376.                 UCB0TXBUF = 0x00;
  377.                 TimerDelay_us(64);
  378.                 LCD_set_XY(12, 8);
  379.                 UCB0TXBUF = 0x00;
  380.                 TimerDelay_us(64);
  381.                 LCD_set_XY(16, 8);
  382.                 UCB0TXBUF = 0x00;
  383.                 TimerDelay_us(64);
  384.                 LCD_set_XY(18, 8);
  385.                 UCB0TXBUF = 0x00;
  386.                 TimerDelay_us(64);
  387.                 LCD_set_XY(20, 8);
  388.                 UCB0TXBUF = 0x00;
  389.                 TimerDelay_us(64);
  390.                 break;
  391.         }
  392.         LCD_CS_1;
  393. }


  396. /*---------------------------------------------
  397. 函数名：LCD_write_Icon_DumpEnergy    显示剩余电量图标
  398. 输入参数：c   剩余电量等级   0 （无） 1（25%） 2（50%）3（75%）4（100%）
  399. 编写日期：20141017
  400. -----------------------------------------------*/
  401. void LCD_write_Icon_DumpEnergy(unsigned char c) //row:列 page:页 dd:字符
  402. {
  403.         LCD_set_XY(116, 8);                            //电池框图标
  404.         UCB0TXBUF = 0x01;
  405.         TimerDelay_us(64);
  406.         switch(c)
  407.         {
  408.         case 1:
  409.                 LCD_set_XY(120, 8);
  410.                 UCB0TXBUF = 0x01;
  411.                 TimerDelay_us(64);
  412.                 break;
  413.         case 2:
  414.                 LCD_set_XY(120, 8);
  415.                 UCB0TXBUF = 0x01;
  416.                 TimerDelay_us(64);
  417.                 LCD_set_XY(123, 8);
  418.                 UCB0TXBUF = 0x01;
  419.                 TimerDelay_us(64);
  420.                 break;
  421.         case 3:
  422.                 LCD_set_XY(120, 8);
  423.                 UCB0TXBUF = 0x01;
  424.                 TimerDelay_us(64);
  425.                 LCD_set_XY(123, 8);
  426.                 UCB0TXBUF = 0x01;
  427.                 TimerDelay_us(64);
  428.                 LCD_set_XY(127, 8);
  429.                 UCB0TXBUF = 0x01;
  430.                 TimerDelay_us(64);
  431.                 break;
  432.         case 4:
  433.                 LCD_set_XY(120, 8);
  434.                 UCB0TXBUF = 0x01;
  435.                 TimerDelay_us(64);
  436.                 LCD_set_XY(123, 8);
  437.                 UCB0TXBUF = 0x01;
  438.                 TimerDelay_us(64);
  439.                 LCD_set_XY(127, 8);
  440.                 UCB0TXBUF = 0x01;
  441.                 TimerDelay_us(64);
  442.                 LCD_set_XY(125, 8);
  443.                 UCB0TXBUF = 0x01;
  444.                 TimerDelay_us(64);
  445.                 break;
  446.         default:
  447.                 LCD_set_XY(120, 8);
  448.                 UCB0TXBUF = 0x00;
  449.                 TimerDelay_us(64);
  450.                 LCD_set_XY(123, 8);
  451.                 UCB0TXBUF = 0x00;
  452.                 TimerDelay_us(64);
  453.                 LCD_set_XY(125, 8);
  454.                 UCB0TXBUF = 0x00;
  455.                 TimerDelay_us(64);
  456.                 LCD_set_XY(127, 8);
  457.                 UCB0TXBUF = 0x00;
  458.                 TimerDelay_us(64);
  459.                 break;
  460.         }
  461.         LCD_CS_1;
  462. }

  464. /*---------------------------------------------
  465. 函数名：LCD_write_Icon_Voice    显示声音图标
  466. 输入参数：c   指示有无声   0 （无声） 1（有声）
  467. 编写日期：20141017
  468. -----------------------------------------------*/
  469. void LCD_write_Icon_Voice(unsigned char c) //row:列 page:页 dd:字符
  470. {
  471.         switch(c)
  472.         {
  473.         case 0:
  474.                 LCD_set_XY(74, 8);
  475.                 UCB0TXBUF = 0x01;
  476.                 TimerDelay_us(64);
  477.                 LCD_set_XY(79, 8);
  478.                 TimerDelay_us(64);
  479.                 UCB0TXBUF = 0x01;
  480.                 break;
  481.         case 1:
  482.                 LCD_set_XY(74, 8);
  483.                 UCB0TXBUF = 0x01;
  484.                 TimerDelay_us(64);
  485.                 LCD_set_XY(79, 8);
  486.                 UCB0TXBUF = 0x00;
  487.                 TimerDelay_us(64);
  488.                 break;
  489.         default:
  490.                 break;
  491.         }
  492.         LCD_CS_1;
  493. }

  495. /*---------------------------------------------
  496. 函数名：LCD_write_Icon_Alarm    显示闹铃图标
  497. 输入参数：c   指示有无闹铃   0 （无） 1（有）
  498. 编写日期：20141017
  499. -----------------------------------------------*/
  500. void LCD_write_Icon_Alarm(unsigned char c) //row:列 page:页 dd:字符
  501. {
  502.         switch(c)
  503.         {
  504.         case 0:
  505.                 LCD_set_XY(87, 8);
  506.                 UCB0TXBUF = 0x00;
  507.                 TimerDelay_us(64);
  508.                 break;
  509.         case 1:
  510.                 LCD_set_XY(87, 8);
  511.                 UCB0TXBUF = 0x01;
  512.                 TimerDelay_us(64);
  513.                 break;
  514.         default:
  515.                 break;
  516.         }
  517.         LCD_CS_1;
  518. }
  519. /*---------------------------------------------
  520. 函数名：Clear_Screen  清屏
  521. 输入参数：xx   填充
  522. 编写日期：20141017
  523. -----------------------------------------------*/
  524. void Clear_Screen( unsigned char xx)
  525. {
  526.   unsigned char i,j;
  527.   LCD_CS_0;
  528.   for(i=0;i<9;i++)
  529.   {
  530.     LCD_AO_0;
  531.     UCB0TXBUF = 0xb0+i;   //设置page（页）地址         （共有8页）
  532.     TimerDelay_us(64);
  533.     UCB0TXBUF = 0x10;     //设置column（列）地址高4位  （共有131列）
  534.     TimerDelay_us(64);
  535.     UCB0TXBUF = 0x00;     //设置column（列）地址低4位
  536.     TimerDelay_us(64);
  537.     for(j=0;j<128;j++)
  538.     {
  539.       LCD_AO_1;
  540.       UCB0TXBUF = xx;
  541.       TimerDelay_us(64);
  542.     }
  543.   }
  544.   LCD_CS_1;
  545. }

  547. /*---------------------------------------------
  548. 函数名：LCD_Display_Temprature  显示温度
  549. 输入参数：xx   填充
  550. 编写日期：20141017
  551. -----------------------------------------------*/
  552. void LCD_Display_Temprature(unsigned char column, unsigned char page,unsigned int number)
  553. {
  554.   unsigned int num_temp[5] = {0};
  555.   unsigned int temp = 0;
  556.   temp = number + number -27315;
  557.   
  558.   num_temp[0] = temp/10000;
  559.   num_temp[1] = temp/1000%10;
  560.   num_temp[2] = temp/100%10;
  561.   num_temp[3] = temp/10%10;
  562.   num_temp[4] = temp%10;
  563.   
  564.   if(num_temp[0] == 0)
  565.     num_temp[0] = 12;
  566.   if((num_temp[0] == 0) || (num_temp[1] == 0))
  567.     num_temp[1] = 12;
  568.   
  569.   LCD_write_shu_13_24(column,page,num_temp[0]);
  570.   LCD_write_shu_13_24(column+13,page,num_temp[1]);
  571.   LCD_write_shu_13_24(column+26,page,num_temp[2]);
  572.   LCD_write_shu_13_24(column+39,page,10);
  573.   LCD_write_shu_13_24(column+52,page,num_temp[3]);  
  574.   LCD_write_shu_13_24(column+65,page,num_temp[4]);
  575.   LCD_write_shu_13_24(column+80,page,11);
  576.   
  577.   
  578. //   while(!(UCA1IFG&UCTXIFG));
  579. //    UCA1TXBUF = num_temp[0] + '0';
  580. //     while(!(UCA1IFG&UCTXIFG));
  581. //    UCA1TXBUF = num_temp[1] + '0';
  582. //  while(!(UCA1IFG&UCTXIFG));
  583. //    UCA1TXBUF = num_temp[2] + '0';
  584. //  while(!(UCA1IFG&UCTXIFG));
  585. //    UCA1TXBUF = '.';   
  586. //  while(!(UCA1IFG&UCTXIFG));
  587. //    UCA1TXBUF = num_temp[3] + '0';   
  588. //  while(!(UCA1IFG&UCTXIFG));
  589. //    UCA1TXBUF = num_temp[4] + '0';
  590. //  while(!(UCA1IFG&UCTXIFG));
  591. //    UCA1TXBUF = '\n';   
  592. }



  596. /*---------------------------------------------
  597. 函数名：LCD_Display_ECG 显示心电波形
  598. 输入参数：xx   填充
  599. 编写日期：20141017
  600. -----------------------------------------------*/
  601. void LCD_Display_ECG(unsigned char column, unsigned char page,unsigned int number)
  602. {
  603.   unsigned int num_temp[5] = {0};
  604.   unsigned int temp = 0;
  605.   
  606.   num_temp[0] = temp/10000;
  607.   num_temp[1] = temp/1000%10;
  608.   num_temp[2] = temp/100%10;
  609.   num_temp[3] = temp/10%10;
  610.   num_temp[4] = temp%10;
  611.   
  612.   if(num_temp[0] == 0)
  613.     num_temp[0] = 12;
  614.   if((num_temp[0] == 0) && (num_temp[1] == 0))
  615.     num_temp[1] = 12;
  616.   
  617.   LCD_write_shu_13_24(column,page,num_temp[0]);
  618.   LCD_write_shu_13_24(column+13,page,num_temp[1]);
  619.   LCD_write_shu_13_24(column+26,page,num_temp[2]);
  620.   LCD_write_shu_13_24(column+39,page,10);
  621.   LCD_write_shu_13_24(column+52,page,num_temp[3]);  
  622.   LCD_write_shu_13_24(column+65,page,num_temp[4]);
  623.   LCD_write_shu_13_24(column+80,page,11);
  624. }


  627. /*---------------------------------------------
  628. 函数名：LCD_Display_BloodPresure 显示血压
  629. 输入参数：xx   填充
  630. 编写日期：20141017
  631. -----------------------------------------------*/
  632. void LCD_Display_BloodPresure(unsigned char column, unsigned char page, unsigned int Hi_Presure, unsigned int Low_Presure)
  633. {
  634.   unsigned char num_temp1[3] = {0};
  635.   unsigned char num_temp2[3] = {0};
  636.   //unsigned int temp = 0;
  637.   
  638.   num_temp1[0] = Hi_Presure/100%10;
  639.   num_temp1[1] = Hi_Presure/10%10;
  640.   num_temp1[2] = Hi_Presure%10;
  641.   
  642.   num_temp2[0] = Low_Presure/100%10;
  643.   num_temp2[1] = Low_Presure/10%10;
  644.   num_temp2[2] = Low_Presure%10;
  645.   
  646.   //消零
  647.   if(num_temp1[0] == 0)
  648.     num_temp1[0] = 12;
  649.   if((num_temp1[0] == 0) && (num_temp1[1] == 0))
  650.     num_temp1[1] = 12;
  651.   if(num_temp2[0] == 0)
  652.     num_temp2[0] = 12;
  653.   if((num_temp2[0] == 0) && (num_temp2[1] == 0))
  654.     num_temp2[1] = 12;
  655.   
  656.   LCD_write_shu_13_24(column,page,num_temp1[0]);
  657.   LCD_write_shu_13_24(column+13,page,num_temp1[1]);
  658.   LCD_write_shu_13_24(column+26,page,num_temp1[2]);

  660.   LCD_write_shu_13_24(column,page+2,num_temp2[0]);
  661.   LCD_write_shu_13_24(column+13,page+2,num_temp2[1]);
  662.   LCD_write_shu_13_24(column+26,page+2,num_temp2[2]);
  663.   
  664. }









复制代码

MLX90615驱动：
  1. #include "msp430.h"
  2. #include "MLX90615.h"
  3. #include "I2C.h"

  5. void MLX90615_init(void)
  6. {
  7.   Init();
  8. }


  11. unsigned int MemRead(unsigned char SlaveAddress,unsigned char command)
  12. {
  13.         unsigned int  data;                        // Data storage (DataH:DataL)
  14.         unsigned char Pec;                        // PEC byte storage
  15.         unsigned char DataL;                        // Low data byte storage
  16.         unsigned char DataH;                        // High data byte storage
  17.         unsigned char arr[6];                        // Buffer for the sent bytes
  18.         unsigned char PecReg;                        // Calculated PEC byte storage
  19.         unsigned char ErrorCounter;                // Defines the number of the attempts for communication with MLX90615
  20.        
  21.         ErrorCounter=0x00;                        // Initialising of ErrorCounter
  22.        
  23.         //do{
  24. //                Stop();                                //If slave send NACK stop comunication       
  25. //                --ErrorCounter;                        //Pre-decrement ErrorCounter
  26. //                if(!ErrorCounter){                //ErrorCounter=0?
  27. //                        break;                        //Yes,go out from do-while{}
  28. //                }
  29.                 Start();                        //Start condition
  30.                
  31.                 WriteByte(SlaveAddress);        //Send SlaveAddress
  32.                 ReceiveAck();       
  33.                 WriteByte(command);                //Send command       
  34.                 ReceiveAck();
  35.                 Start();                        //Repeated Start condition
  36.                
  37.                 WriteByte(SlaveAddress);        //Send SlaveAddress-------------------???
  38.                 ReceiveAck();
  39.                
  40.                 DataL=ReadByte();                //Read low data,master must send ACK
  41.                 TransferAckOrNack(0);
  42.                 DataH=ReadByte();                 //Read high data,master must send ACK
  43.                 TransferAckOrNack(0);
  44.                 Pec=ReadByte();                        //Read PEC byte, master must send NACK
  45.                 TransferAckOrNack(1);
  46.                 Stop();                                // condition
  47.                
  48.                
  49.                 arr[5]=SlaveAddress;                //
  50.                 arr[4]=command;                        //
  51.                 arr[3]=SlaveAddress;                //Load array arr
  52.                 arr[2]=DataL;                        //
  53.                 arr[1]=DataH;                        //
  54.                 arr[0]=0;                        //
  55.                 PecReg=PEC_calculation(arr);//Calculate CRC
  56.                         
  57.         //}while(PecReg != Pec);                //If received and calculated CRC are equal go out from do-while{}
  58.                
  59.         *((unsigned char *)(&data))=DataL;        //
  60.         *((unsigned char *)(&data)+1)=DataH ; //data=DataH:DataL
  61.        
  62.         return data;                                                       
  63. }
  64. //---------------------------------------------------------------------------------------------

  66. //---------------------------------------------------------------------------------------------
  67. void DummyCommand(unsigned char byte)         //test
  68. {
  69.         Start();                             //Start condition
  70.         WriteByte(byte);                             //Send Slave Address or whatever,no need ACK checking
  71.         Stop();                             // condition
  72. }
  73. //---------------------------------------------------------------------------------------------
  74. float CalcTemp(unsigned int value)
  75. {
  76.         float temp;
  77.        
  78.         temp=(value*0.02)-273.15;
  79.         _NOP();
  80.        
  81.         return temp;
  82. }
  83. unsigned char PEC_calculation(unsigned char pec[])
  84. {
  85.         unsigned char         crc[6];
  86.         unsigned char        BitPosition=47;
  87.         unsigned char        shift;
  88.         unsigned char        i;
  89.         unsigned char        j;
  90.         unsigned char        temp;

  92.         do{
  93.                 crc[5]=0;                        /* Load CRC value 0x000000000107 */
  94.                 crc[4]=0;
  95.                 crc[3]=0;
  96.                 crc[2]=0;
  97.                 crc[1]=0x01;
  98.                 crc[0]=0x07;
  99.                 BitPosition=47;                        /* Set maximum bit position at 47 */
  100.                 shift=0;
  101.                                
  102.                 //Find first 1 in the transmited message
  103.                 i=5;                                        /* Set highest index */
  104.                 j=0;
  105.                 while((pec[i]&(0x80>>j))==0 && i>0){
  106.                         BitPosition--;
  107.                         if(j<7){
  108.                                 j++;
  109.                         }
  110.                         else{
  111.                                 j=0x00;
  112.                                 i--;
  113.                         }
  114.                 }/*End of while */
  115.                
  116.                 shift=BitPosition-8;        /*Get shift value for crc value*/
  117.                
  118.                
  119.                 //Shift crc value
  120.                 while(shift){
  121.                         for(i=5; i<0xFF; i--){
  122.                                 if((crc[i-1]&0x80) && (i>0)){
  123.                                         temp=1;
  124.                                 }
  125.                                 else{
  126.                                         temp=0;
  127.                                 }
  128.                                 crc[i]<<=1;
  129.                                 crc[i]+=temp;
  130.                         }/*End of for*/
  131.                         shift--;
  132.                 }/*End of while*/
  133.                
  134.                
  135.                 //Exclusive OR between pec and crc               
  136.                 for(i=0; i<=5; i++){
  137.                         pec[i] ^=crc[i];
  138.                 }/*End of for*/
  139.         }while(BitPosition>8);/*End of do-while*/
  140.        
  141.         return pec[0];
  142. }/*End of PEC_calculation*/
复制代码


EEPROM驱动：
  1. #include <msp430.h>
  2. #include "I2C.h"
  3. #include "24C512.h"


  6. void AT24C512_Byte_Write(unsigned char Device_Address,unsigned int Address,unsigned char data)
  7. {
  8.   Start();
  9.   WriteByte(Device_Address);
  10.   ReceiveAck();
  11.   WriteByte((unsigned char)((Address&0xff00)>>8));
  12.   ReceiveAck();
  13.   WriteByte((unsigned char)(Address&0x00ff));
  14.   ReceiveAck();
  15.   WriteByte(data);
  16.   ReceiveAck();
  17.   Stop();
  18. }

  20. unsigned char  AT24C512_Byte_Read(unsigned char Device_Address,unsigned int Address)
  21. {
  22.   unsigned char TempData = 0;
  23.   Start();
  24.   WriteByte(Device_Address);
  25.   ReceiveAck();
  26.   WriteByte((unsigned char)((Address&0xff00)>>8));
  27.   ReceiveAck();
  28.   WriteByte((unsigned char)(Address&0x00ff));
  29.   ReceiveAck();
  30.   Start();
  31.   WriteByte(Device_Address|0x01);
  32.   ReceiveAck();
  33.   TempData  = ReadByte();
  34.   TransferAckOrNack(1);
  35.   Stop();
  36.   //Delay_us(66);
  37.   return(TempData);
  38. }
复制代码


调试：






最新回复

强仔00001
好长的代码   详情 回复 发表于 2015-1-6 11:48
 
点赞 关注
TI MCU论坛  TI MSP430论坛  MSP430技术讨论
回复
举报
maylove

6066

帖子

92

TA的资源

裸片初长成（初级）
沙发
发表于2015-1-6 11:14 只看该作者
 
能否加一个视频演示一下呢
 
 
MSP430设计资料  msp430单片机   智能家居控制系统
回复
举报
强仔00001

1291

帖子

0

TA的资源

纯净的硅（中级）
板凳
发表于2015-1-6 11:48 只看该作者
 
好长的代码
 
 
 
回复
举报
返回列表 发新帖 回复
您需要登录后才可以回帖 登录 | 注册

活动 更多>>
开源项目 更多>>
随便看看
查找数据手册?
搜索

EEWorld Datasheet 技术支持

热门标签
相关文章 更多>>
新帖速递
关闭
站长推荐上一条 1/9 下一条

 
EEWorld订阅号

 
EEWorld服务号

 
汽车开发圈

About Us 关于我们 客户服务 联系方式 器件索引 网站地图 最新更新 手机版

站点相关： 国产芯 安防电子 汽车电子 手机便携 工业控制 家用电子 医疗电子 测试测量 网络通信 物联网

用户热搜：

北京市海淀区中关村大街18号B座15层1530室 电话:(010)82350740 邮编：100190

电子工程世界版权所有 京B2-20211791 京ICP备10001474号-1 电信业务审批[2006]字第258号函 京公网安备 11010802033920号 Copyright © 2005-2025 EEWORLD.com.cn, Inc. All rights reserved
快速回复 返回顶部 返回列表