• STM32实现PMBus从机程序

    最近在野火的STM32F103VET6开发板上实现PMBus从机程序，这个程序参考了以下这篇博客的关于使用中断法实现I2C从机程序：STM32设置为I2C从机模式_iic从机_柒壹漆的博客-CSDN博客 ，实测这个程序是可以正常运行的，感谢博主的分享！

    另外我还参考了德州仪器的一篇基于TMS320F2803x系列单片机PMBus协议的实现，包括主机和从机程序（源程序和文档下载地址：http://www.ti.com/lit/zip/SPRABJ6，文档的截图如下）。

     PMBus协议的详细内容我就不说了，这里我主要说下PMBusSlave.c这个文件，代码和主要函数如下：

    1、PMBusSlave_Init：初始化I2C，这里使用STM32的硬件I2C，主要配置好引脚模式为开漏输出，时钟为100K-400K之间都可以，还有从机地址和中断，另外要使能自动应答，这样从机在收到每个数据时在第9个时钟周期会把SDA拉低作为应答。

    2、PMBusSlave_DecodeCommand：该函数主要是根据主机发送来的命令在数组中找到对应的命令索引从而对命令进行分组处理。如果发送的命令无效，则根据自己程序的需要进行异常处理。

    3、PMBusSlave_Crc8MakeBitwise：因为绝大部分PMBus通信都使用CRC8校验，这个函数的用于检测接收到的数据是否CRC校验正确以及对发送的数据进行CRC计算。

    4、I2C1_EV_IRQHandler：I2C的事件中断处理程序，这是最主要最核心的部分，绝大部分的PMBus的收发都是在此进行的。主要的几个事件分别介绍如下：

    a) I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED(0x00020002):

    这是主机在发出START信号后，接着发送I2C从机地址（从机地址+最低位的读写位置0），如果发送的地址与当前从机的地址匹配则会产生此中断事件，此处基本不用处理，根据需要做一些变量的初始化也是可以的。

    b) I2C_EVENT_SLAVE_BYTE_RECEIVED(0x00020040):

    这是主机要写数据到从机时，从机接收到了数据就会产生此中断事件。在此处我们应该调用I2C_ReceiveData(I2Cx)函数保存所接收到的数据。如果主机有多个数据要发送，这个事件会多次触发。总之这个地方的主要工作就将数据保存在数据缓冲中。

    c) I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED(0x00060082):

    当主机发送读操作指令时（从机地址+最低位的读写位置1），如果地址与本机地址匹配则会产生该中断事件，在该事件中我们可以开始调用函数I2C_SendData(I2Cx, data[ptr++]);发送第一个数据（可能有多个数据要发送）。此时对发送数据指针进行适当调整，以便后面的中断事件中继续发送数据。

    d) I2C_EVENT_SLAVE_BYTE_TRANSMITTED(0x00060084):

    当主机需要读到多个数据并且从机成功发送了一个数据后就会产生此中断事件，此处我们就根据数据指针继续调用函数2C_SendData(I2Cx, data[ptr++]发送数据，直到所有的数据都发送完成。

    e) I2C_EVENT_SLAVE_STOP_DETECTED(0x00000010):

    当从机检测到主机发送了STOP信号后就会产生该中断事件。此中断中一般会根据主机发送的写指令和要写入的数据进行相应的操作，例如：主机发送VOUT_COMMAND(0x21)对电源的输出电压进行设置，另外当主机读取完所有数据后也会发送STOP信号，此处我们可以对发送操作做一些清理工作，主要看自己程序的要求。

    其实程序中最主要的是要知道在哪个中断事件编写相应的代码，其他像PMBus协议稍微看下资料就明白了，如果不使用STM32，换了一个别的单片机，只需要按照单片机对应的寄存器和事件处理程序写程序就可以了。之前我也写过ATmega16A和PIC16F系列的I2C从机程序，大同小异。

    这个程序有一个问题我一直不明白，就是当主机（我使用的USB转I2C设备）进行从机扫描时会出现多个从机地址，可我明明只连接了一个I2C从机，而且执行主机扫描之后这个程序会死机，我调试发现主机发送从机扫描时，I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED中断事件产生了，不明白为何这里会死机，到时我再调试下卡在哪里了。下图显示的就是主机扫描时出现的多个从机地址（我的从机地址是0x54，7位地址格式）。

    main函数中只需要调用PMBusSlave_Init函数进行初始化设置就可以进入while循环，等待中断事件触发了。

    好了，欢迎大家指出我的代码中存在的问题，我好改进，使程序更加健壮可靠。

    1. /*******************************************************************************
    2.  *
    3.  * PMBusSlave.c -	This program is a software implementation of PMBus over I2C, 
    4.  *					with the Piccolo device acting as the PMBus slave.
    5.  *
    6.  * Copyright (c) 2011 Texas Instruments Incorporated.  All rights reserved.
    7.  * Software License Agreement
    8.  * 
    9.  * Texas Instruments (TI) is supplying this software for use solely and
    10.  * exclusively on TI's microcontroller products. The software is owned by
    11.  * TI and/or its suppliers, and is protected under applicable copyright
    12.  * laws. You may not combine this software with "viral" open-source
    13.  * software in order to form a larger program.
    14.  * 
    15.  * THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
    16.  * NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
    17.  * NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    18.  * A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
    19.  * CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
    20.  * DAMAGES, FOR ANY REASON WHATSOEVER.
    21.  * 
    22.  ******************************************************************************/
    23. //#include "DSP2803x_Device.h"     // DSP280x Headerfile Include File
    24. //#include "DSP2803x_Examples.h"   // DSP280x Examples Include File
    25. //#include "DSP2803x_I2C_defines.h"
    26. #include "stm32f10x.h"
    27. #include "stm32f10x_gpio.h"
    28. #include "stm32f10x_i2c.h"
    29. #include "PMBusSlave.h"
    30. #include "PMBus.h"
    31. #include "i2c_slave.h"
    32.  
    33. #define I2C1_CLOCK_FRQ          100000     // I2C-Frq in Hz (100 kHz)
    34.  
    35. struct STATUS_REGS StatusRegs;
    36.  
    37. //This array contains all of the PMBus command bytes (according to the PMBus spec)
    38. //indexed by the command indeces defined in PMBus.h
    39. const unsigned char PMBus_Commands[120] = 
    40. {
    41. 	0x00, // dummy byte  
    42. 	0x19,0x78,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,0x81,0x82,0x98,
    43. 	0x79,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,
    44. 	0x93,0x94,0x95,0x96,0x97,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,
    45. 	0xA7,0xA8,0xA9,0x13,0x14,0x17,0x18,0x3 ,0x11,0x12,0x15,0x16,
    46. 	0x0 ,0x1 ,0x2 ,0x4 ,0x10,0x20,0x3A,0x3D,0x41,0x45,0x47,0x49,
    47. 	0x4C,0x50,0x54,0x56,0x5A,0x5C,0x63,0x69,0x21,0x22,0x23,0x24,
    48. 	0x25,0x26,0x27,0x28,0x29,0x2A,0x31,0x32,0x33,0x35,0x36,0x37,
    49. 	0x38,0x39,0x3B,0x3C,0x3E,0x3F,0x40,0x42,0x43,0x44,0x46,0x48,
    50. 	0x4A,0x4B,0x4F,0x51,0x52,0x53,0x55,0x57,0x58,0x59,0x5B,0x5D,
    51. 	0x5E,0x5F,0x60,0x61,0x62,0x64,0x65,0x66,0x68,0x6A,0x6B
    52. };
    53.  
    54. static unsigned char slave_address;
    55.  
    56. static uint8_t i2c1_mode = I2C1_MODE_WAITING;
    57. //static uint8_t i2c_rcv_finish_flag = 0;//got received all data
    58. static uint8_t i2c_rcv_cnt = 0;
    59. static uint8_t i2c_transmit_cnt = 0;
    60.  
    61. unsigned char PMBusSlave_ReceiveBuffer[4] = {0,0,0,0};
    62. unsigned char PMBusSlave_TransmitBuffer[5] = {0xDF,0xC5,0x18,0x9F,0xB7};
    63. unsigned char PMBusSlave_Index = 0;
    64. unsigned char PMBusSlave_DummyCommand = 0;
    65.  
    66. USER CODE
    67. //Example variables, should be changed by user to be application specific
    68. #warning	"User should declare application specific PMBus registers or variables."
    69. //initial values
    70. unsigned char Temperature = 0x88;	//0x12,STATUS_TEMPERATURE command (R byte)
    71. unsigned char Default_Code = 0;		//STORE_DEFAULT_CODE command (W byte)
    72. unsigned char Operation = 0x34;		//OPERATION command (R/W byte)
    73. unsigned int Status_Word = 0x5678;	//STATUS_WORD command (R word)
    74. unsigned char Status_Byte = 0x00;	//STATUS_BYTE command (R byte)
    75. unsigned char Status_Cml = 0x00;	//STATUS_CML command (R byte)
    76. unsigned int Vout_Command = 0x90AB;	//VOUT_COMMAND command (R/W word)
    77. END USER CODE
    78.  
    79. /***************************************************************************//**
    80.  * @brief   Initialize I2C module in slave mode.
    81.  * @param   I2CSlave_OwnAddress The slave device's own address.
    82.  * @return  None
    83.  ******************************************************************************/
    84. void I2CSlave_Init(uint16_t I2CSlave_OwnAddress)
    85. {
    86. 	GPIO_InitTypeDef  GPIO_InitStructure;
    87.     NVIC_InitTypeDef NVIC_InitStructure;
    88.     I2C_InitTypeDef  I2C_InitStructure;
    89.  
    90.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
    91.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    92.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    93.  
    94.     /* Configure I2C_EE pins: SCL and SDA */
    95.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6 | GPIO_Pin_7;
    96.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    97.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
    98.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    99.  
    100.     /* Configure the I2C event priority */
    101.     NVIC_InitStructure.NVIC_IRQChannel                   = I2C1_EV_IRQn;
    102.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    103.     NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 0;
    104.     NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    105.     NVIC_Init(&NVIC_InitStructure);
    106.  
    107.     /* Configure I2C error interrupt to have the higher priority */
    108.     NVIC_InitStructure.NVIC_IRQChannel = I2C1_ER_IRQn;
    109.     NVIC_Init(&NVIC_InitStructure);
    110.  
    111.     /* I2C configuration */
    112.     I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
    113.     I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
    114.     I2C_InitStructure.I2C_OwnAddress1 = I2CSLAVE_ADDR;
    115.     I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
    116.     I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    117.     I2C_InitStructure.I2C_ClockSpeed = I2C1_CLOCK_FRQ;
    118. 	//I2C_OwnAddress2Config(I2C1, 0x00);//configure the second I2C address
    119.  
    120.     /* I2C Peripheral Enable */
    121.     I2C_Cmd(I2C1, ENABLE);
    122.  
    123.     /* Apply I2C configuration after enabling it */
    124.     I2C_Init(I2C1, &I2C_InitStructure);
    125.  
    126.     I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE); //Part of the STM32 I2C driver
    127.     I2C_ITConfig(I2C1, I2C_IT_BUF, ENABLE);
    128.     I2C_ITConfig(I2C1, I2C_IT_ERR, ENABLE); //Part of the STM32 I2C driver	
    129. 	
    130. 	//======================= the original codes ============================
    131. 	/*
    132. 	//Setup Cpu Timer 0 interrupt
    133. 	EALLOW;	// This is needed to write to EALLOW protected registers
    134. 	PieVectTable.TINT0 = &cpu_timer0_isr;
    135. 	EDIS;   // This is needed to disable write to EALLOW protected registers 
    136. 	// Enable TINT0 in the PIE: Group 1 interrupt 7
    137.    	PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
    138. 	// Enable CPU int1 which is connected to CPU-Timer 0
    139.    	IER |= M_INT1;
    140.    
    141. 	InitI2CGpio();
    142. 	InitCpuTimers();
    143. 	
    144. 	ConfigCpuTimer(&CpuTimer0, 60, 35000);	//CPU Timer 0 interrupt after 35 ms (at 60MHz CPU freq.)
    145. 	
    146. 	// Initialize I2C
    147. 	I2caRegs.I2COAR = I2CSlave_OwnAddress;		// Own address
    148. 	I2caRegs.I2CPSC.all = 9;		// Prescaler - need 7-12 Mhz on module clk
    149. 	I2caRegs.I2CCLKL = 10;			// NOTE: must be non zero
    150. 	I2caRegs.I2CCLKH = 5;			// NOTE: must be non zero
    152. 	I2caRegs.I2CIER.all = 0x00;		// Clear interrupts - polling based method
    154. 	I2caRegs.I2CMDR.all = 0x0020;	// Take I2C out of reset
    155.    									// Stop I2C when suspended
    156. 	return; 
    157. 	*/
    158. }
    159.  
    160. /***************************************************************************//**
    161.  * @brief   Configure the C2000 device as a PMBus slave.
    162.  * @param   PMBusSlave_DeviceAddress The slave device's own address.
    163.  * @return  None
    164.  ******************************************************************************/
    165. #warning "Change the GPIOs used for Alert and Control lines to match the desired GPIOs for the application."
    166. void PMBusSlave_Init(unsigned char PMBusSlave_DeviceAddress)
    167. {	
    168. 	StatusRegs.StatusWord.all = 0;			//Clear status bits for the status registers we are using
    169. 	StatusRegs.StatusCml.all = 0;
    170. 	
    171. 	/*
    172. 	// Control Line functionality GPIO0
    173. 	GpioCtrlRegs.GPAPUD.bit.GPIO0 = 0;		//Enable pullup on GPIO0
    174. 	GpioDataRegs.GPASET.bit.GPIO0 = 1;		//Drive line high
    175. 	GpioCtrlRegs.GPAQSEL1.bit.GPIO0 = 0;	//SYNC to SYSCLKOUT
    176. 	GpioCtrlRegs.GPACTRL.bit.QUALPRD0 = 0;	//no qualification (SYNC to SYSCLKOUT)
    177. 	GpioCtrlRegs.GPAMUX1.bit.GPIO0 = 0;		//GPIO0 = GPIO0
    178. 	GpioCtrlRegs.GPADIR.bit.GPIO0 = 0;		//GPIO0 = input
    179. 	 
    180. 	// SMBUS Alert functionality (GPIO2 = Alert line)
    181. 	GpioCtrlRegs.GPAPUD.bit.GPIO2 = 0;		//Enable pullup on GPIO2
    182. 	GpioDataRegs.GPASET.bit.GPIO2 = 1;		//Drive line high
    183. 	GpioCtrlRegs.GPAMUX1.bit.GPIO2 = 0;		//GPIO2 = GPIO2
    184. 	GpioCtrlRegs.GPADIR.bit.GPIO2 = 1;		//GPIO2 = output
    185. 	*/
    186. 	
    187. 	slave_address = PMBusSlave_DeviceAddress;
    188. 	I2CSlave_Init(PMBusSlave_DeviceAddress);     // Initialize USCI module
    189. }
    190.  
    191. /***************************************************************************//**
    192.  * @brief   Determine what type of PMBus command was received from the master.
    193.  * 
    194.  * 			The function also prepares data in the transmit buffer to send to 
    195.  * 			the master for supported READ and READ/WRITE commands. Users should modify
    196.  * 			the code to implement their application's supported PMBus commands.
    197.  * @param   PMBusSlave_RxCommand The command byte received from the master.
    198.  * @return  Command group of the received command.
    199.  ******************************************************************************/
    200. unsigned char PMBusSlave_DecodeCommand(unsigned char PMBusSlave_RxCommand)
    201. {
    202. 	unsigned char PMBusSlave_CommandGroup;	
    203. 	
    204. 	for(PMBusSlave_Index = 0; PMBusSlave_Index < 120; PMBusSlave_Index++)
    205. 	{
    206. 		if(PMBus_Commands[PMBusSlave_Index] == PMBusSlave_RxCommand)
    207. 			break;
    208. 	}
    209. 	
    210. 	USER CODE
    211. 	#warning	"User should change code to implement their application's supported PMBus commands."
    212. 	switch (PMBusSlave_Index)	//should include all user supported commands
    213. 	{
    214. 		case STATUS_TEMPERATURE:
    215. 				PMBusSlave_TransmitBuffer[0] = Temperature;
    216. 				break;
    217. 		case READ_POUT://output power for example
    218. 				PMBusSlave_TransmitBuffer[0] = Vout_Command;	//lower byte
    219. 				PMBusSlave_TransmitBuffer[1] = Vout_Command >> 8;	//upper byte
    220. 				break;
    221. 		case STORE_DEFAULT_CODE:
    222. 				break;
    223. 		case OPERATION:
    224. 				PMBusSlave_TransmitBuffer[0] = Operation;
    225. 				break;
    226. 		case STATUS_WORD:
    227. 				PMBusSlave_TransmitBuffer[0] = Status_Word;	//lower byte
    228. 				PMBusSlave_TransmitBuffer[1] = Status_Word >> 8;	//upper byte
    229. 				break;
    230. 		case VOUT_COMMAND://0x21 command
    231. 				PMBusSlave_TransmitBuffer[0] = Vout_Command;	//lower byte
    232. 				PMBusSlave_TransmitBuffer[1] = Vout_Command >> 8;	//upper byte
    233. 				break;
    234. 		default:
    235. 				PMBusSlave_DummyCommand = 1;	//command not supported by this slave
    236. 				break;
    237. 	}
    238. 	END USER CODE	
    239. 	
    240. 	if(PMBusSlave_Index == 0)//dummy byte to check if slave is present
    241. 		PMBusSlave_DummyCommand = 1;
    242. 	if(PMBusSlave_Index > 0 && PMBusSlave_Index < 13)                  //read byte from slave device
    243. 		PMBusSlave_CommandGroup = READBYTE;
    244. 	if(PMBusSlave_Index > 12 && PMBusSlave_Index < 40)                 // read word from slave device
    245. 		PMBusSlave_CommandGroup = READWORD;
    246. 	if(PMBusSlave_Index > 39 && PMBusSlave_Index < 44)                 // write byte to slave device
    247. 		PMBusSlave_CommandGroup = WRITEBYTE;
    248. 	if(PMBusSlave_Index > 43 && PMBusSlave_Index < 49)                 // send byte to slave device
    249. 		PMBusSlave_CommandGroup = SENDBYTE;
    250. 	/* Read or write one byte of data. R/W oprn. decided based on RWFlag *******/
    251. 	if(PMBusSlave_Index > 48 && PMBusSlave_Index < 69) 
    252. 	{
    253. 	    PMBusSlave_CommandGroup = RWBYTE;
    254. 	}
    255. 	/* Read or write one word of data. R/W oprn. decided based on RWFlag *******/
    256. 	if(PMBusSlave_Index > 68 && PMBusSlave_Index < 120)                // R/W Word
    257. 	{
    258. 	    PMBusSlave_CommandGroup = RWWORD;
    259. 	}	
    260. 	
    261. 	//*****************************************
    262. 	//illegal index - invalid command trap
    263. 	//===Here we don't enter dead loop===
    264. 	//if(PMBusSlave_Index >= 120)
    265. 		//while(1); 
    266. 	//*****************************************
    267. 		
    268. 	return PMBusSlave_CommandGroup;
    269. }
    270.  
    271. static void PMBus_ClearFlag(void) 
    272. {
    273.     /* ADDR Flag clear */
    274.     while((I2C1->SR1 & I2C_SR1_ADDR) == I2C_SR1_ADDR) 
    275.     {
    276.         I2C1->SR1;
    277.         I2C1->SR2;
    278.     }
    279.  
    280.     /* STOPF Flag clear */
    281.     while((I2C1->SR1&I2C_SR1_STOPF) == I2C_SR1_STOPF) 
    282.     {
    283.         I2C1->SR1;
    284.         I2C1->CR1 |= 0x1;
    285.     }
    286. }
    287.  
    288. void I2C1_ER_IRQHandler(void) 
    289. {
    290.     if (I2C_GetITStatus(I2C1, I2C_IT_AF)) 
    291.     {
    292.         I2C_ClearITPendingBit(I2C1, I2C_IT_AF);
    293.     }
    294. }
    295.  
    296. /***************************************************************************//**
    297.  * @brief   Receives a command from the master and performs reads and writes accordingly.
    298.  * 
    299.  * 			This function should be modified by the user for their application's 
    300.  * 			supported commands to make function calls to carry out the commands
    301.  * 			(e.g. adjusting fan speed)
    302.  * @param   None
    303.  * @return  None
    304.  ******************************************************************************/
    305. //void PMBusSlave(void)
    306. void I2C1_EV_IRQHandler(void) 
    307. {
    308. 	unsigned char PMBusSlave_Command = 0, PMBusSlave_CommandType = 0;
    309. 	uint8_t wert;
    310.     uint32_t event;	
    311. 	unsigned char PMBusSlave_CrcMsgSize = 0;
    312. 	unsigned char PMBusSlave_CrcMsg[5];
    313. 	unsigned char PMBusSlave_CrcMasterGenerated = 0;
    314. 	unsigned char PMBusSlave_CrcSlaveGenerated = 0;
    315. 	PMBusSlave_CrcMsg[0] = slave_address << 1; 
    316.  
    317.     //Reading last event
    318.     event = I2C_GetLastEvent(I2C1);	
    319. 	switch(event)
    320. 	{
    321. 		//Master has sent the slave address and prepared to send data to the slave
    322. 		//and the slave address is matched the slave device.
    323. 		//There is a problem that once the master sends out a broadcast address, 
    324. 		//this system is halted on this event. 
    325. 		case I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED:			
    326. 			i2c1_mode = I2C1_MODE_SLAVE_ADR_WR;
    327. 			break;
    328. 		
    329. 		// Master has sent a byte to the slave
    330. 		case I2C_EVENT_SLAVE_BYTE_RECEIVED:
    331. 			wert = I2C_ReceiveData(I2C1);
    332. 			PMBusSlave_ReceiveBuffer[i2c_rcv_cnt] = wert;
    333. 			i2c_rcv_cnt++;
    334. 			break;
    335. 		
    336. 		//Master has sent the slave address(R) and the slave prepares to send data to the master
    337. 		case I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED:
    338. 			i2c1_mode = I2C1_MODE_SLAVE_ADR_RD;
    339. 			PMBusSlave_ReceiveBuffer[0] = I2C_ReceiveData(I2C1); 
    340. 			PMBusSlave_Command = PMBusSlave_ReceiveBuffer[0];	//get register value received prior to this step	
    341. 			PMBusSlave_CommandType = PMBusSlave_DecodeCommand(PMBusSlave_Command);			
    342. 			switch(PMBusSlave_CommandType)
    343. 			{
    344. 				//Implementation with Packet Error Checking
    345. 				case READBYTE: // master reading byte from slave
    346. 					//setup PEC byte
    347. 					i2c_transmit_cnt = 0;
    348. 					PMBusSlave_TransmitBuffer[0] = 0x99;//example data
    349. 					PMBusSlave_CrcMsg[1] = PMBusSlave_Command;  			// store first rx byte
    350. 					PMBusSlave_CrcMsg[2] = (slave_address << 1) + 1;		// store slave address + R/W=1
    351. 					PMBusSlave_CrcMsg[3] = PMBusSlave_TransmitBuffer[0];	// store tx byte 1
    352. 					PMBusSlave_CrcMsgSize = 4;
    353. 					PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);
    354. 					PMBusSlave_TransmitBuffer[1] = PMBusSlave_CrcSlaveGenerated;
    355. 					I2C_SendData(I2C1, PMBusSlave_TransmitBuffer[i2c_transmit_cnt]);					
    356. 					i2c_transmit_cnt++;
    357. 					break;           
    358. 						   
    359. 				case READWORD:  // master reading word from slave
    360. 					//setup PEC byte
    361. 					i2c_transmit_cnt = 0;
    362. 					PMBusSlave_TransmitBuffer[0] = 0xAB;	//lower byte
    363. 					PMBusSlave_TransmitBuffer[1] = 0x90;	//upper byte
    364. 					PMBusSlave_CrcMsg[1] = PMBusSlave_Command;  			// store first rx byte
    365. 					PMBusSlave_CrcMsg[2] = (slave_address << 1) + 1;		// store slave address + R/W=1
    366. 					PMBusSlave_CrcMsg[3] = PMBusSlave_TransmitBuffer[0];	// store tx byte 1
    367. 					PMBusSlave_CrcMsg[4] = PMBusSlave_TransmitBuffer[1];   	// store tx byte 2
    368. 					PMBusSlave_CrcMsgSize = 5;
    369. 					PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);
    370. 					PMBusSlave_TransmitBuffer[2] = PMBusSlave_CrcSlaveGenerated;
    371. 					I2C_SendData(I2C1, PMBusSlave_TransmitBuffer[i2c_transmit_cnt]);					
    372. 					i2c_transmit_cnt++;
    373. 					break;
    374. 				
    375. 				case RWWORD:	//read/write word
    376. 					//setup PEC byte
    377. 					i2c_transmit_cnt = 0;
    378. 					PMBusSlave_TransmitBuffer[0] = 0xF8;	//lower byte of example data
    379. 					PMBusSlave_TransmitBuffer[1] = 0xD9;	//upper byte
    380. 					PMBusSlave_CrcMsg[1] = PMBusSlave_Command;  			// store first rx byte
    381. 					PMBusSlave_CrcMsg[2] = (slave_address << 1) + 1;		// store slave address + R/W=1
    382. 					PMBusSlave_CrcMsg[3] = PMBusSlave_TransmitBuffer[0];	// store tx byte 1
    383. 					PMBusSlave_CrcMsg[4] = PMBusSlave_TransmitBuffer[1];   	// store tx byte 2
    384. 					PMBusSlave_CrcMsgSize = 5;
    385. 					PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);
    386. 					PMBusSlave_TransmitBuffer[2] = PMBusSlave_CrcSlaveGenerated;
    387. 					I2C_SendData(I2C1, PMBusSlave_TransmitBuffer[i2c_transmit_cnt]);					
    388. 					i2c_transmit_cnt++;
    389. 					break;
    390. 				
    391. 				//used to send error message if the command can't be recognized
    392. 				default:
    393. 					//setup PEC byte
    394. 					i2c_transmit_cnt = 0;
    395. 					PMBusSlave_TransmitBuffer[0] = 0xFF;	//lower byte
    396. 					PMBusSlave_TransmitBuffer[1] = 0xEE;	//upper byte
    397. 					PMBusSlave_CrcMsg[1] = PMBusSlave_Command;  			// store first rx byte
    398. 					PMBusSlave_CrcMsg[2] = (slave_address << 1) + 1;		// store slave address + R/W=1
    399. 					PMBusSlave_CrcMsg[3] = PMBusSlave_TransmitBuffer[0];	// store tx byte 1
    400. 					PMBusSlave_CrcMsg[4] = PMBusSlave_TransmitBuffer[1];   	// store tx byte 2
    401. 					PMBusSlave_CrcMsgSize = 5;
    402. 					PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);
    403. 					PMBusSlave_TransmitBuffer[2] = PMBusSlave_CrcSlaveGenerated;
    404. 					I2C_SendData(I2C1, PMBusSlave_TransmitBuffer[i2c_transmit_cnt]);					
    405. 					i2c_transmit_cnt++;
    406. 					break;
    407. 			}
    408. 			break;
    409. 			
    410. 		//The slave device has to send the next byte to the master if needed
    411. 		case I2C_EVENT_SLAVE_BYTE_TRANSMITTED:
    412. 			//I2C_SendData(I2C1, PMBusSlave_TransmitBuffer[i2c_transmit_cnt]);
    413. 			//i2c_transmit_cnt++;
    414. 			i2c1_mode = I2C1_MODE_DATA_BYTE_RD;
    415. 			if(i2c_transmit_cnt < sizeof(PMBusSlave_TransmitBuffer))
    416. 			{
    417. 				I2C_SendData(I2C1, PMBusSlave_TransmitBuffer[i2c_transmit_cnt]);
    418. 				i2c_transmit_cnt++;
    419. 			}
    420. 			else
    421. 			{
    422. 				i2c_transmit_cnt = 0;	
    423. 			}			
    424. 			break;
    425. 		
    426. 		//The slave has received all data from the master and then prepares to write data or other operations accordingly.
    427. 		case I2C_EVENT_SLAVE_STOP_DETECTED:			
    428. 			if(i2c_rcv_cnt > 0)
    429. 			{
    430. 				PMBusSlave_Command = PMBusSlave_ReceiveBuffer[0];	//get the received data		
    431. 				PMBusSlave_CommandType = PMBusSlave_DecodeCommand(PMBusSlave_Command);
    432. 				switch(PMBusSlave_CommandType)
    433. 				{
    434. 					case WRITEWORD:  // master writing word to slave							
    435. 							PMBusSlave_CrcMasterGenerated = PMBusSlave_ReceiveBuffer[3];	//get the received PEC byte from master							
    436. 							//calculate PEC byte for comparison
    437. 							PMBusSlave_CrcMsg[1] = PMBusSlave_Command;			// store first rx byte
    438. 							PMBusSlave_CrcMsg[2] = PMBusSlave_ReceiveBuffer[1];	// store rx byte
    439. 							PMBusSlave_CrcMsg[3] = PMBusSlave_ReceiveBuffer[2];	// store rx byte
    440. 							PMBusSlave_CrcMsgSize = 4;                 			// # of bytes
    441. 							PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);          			        
    442. 							
    443. 							//if the bytes do not match, respond according to the PMBus Spec.
    444. 							if(PMBusSlave_CrcSlaveGenerated != PMBusSlave_CrcMasterGenerated)	//compare received PEC byte with calculated PEC byte
    445. 							{			   			
    446. 								//Flush the received command byte and any received data
    447. 								PMBusSlave_Command = 0;				//flush command byte
    448. 								PMBusSlave_Index = 0;				//clear index so no data is stored
    449. 								PMBusSlave_ReceiveBuffer[0] = 0;	//flush received data bytes
    450. 								PMBusSlave_ReceiveBuffer[1] = 0;
    451. 								PMBusSlave_ReceiveBuffer[2] = 0;
    452. 								PMBusSlave_ReceiveBuffer[3] = 0;
    453. 								//ERROR process if needed
    454. 							}
    455. 							break;
    456. 					case RWWORD:	//read/write word
    457. 				  		//while(!I2caRegs.I2CSTR.bit.AAS);	//wait until addressed by master
    458. 				  		//if (I2caRegs.I2CSTR.bit.SDIR == 0)	//determine if slave should send/receive
    459. 				  		{	//slave receiver			  				
    460. 					        PMBusSlave_CrcMasterGenerated = PMBusSlave_ReceiveBuffer[3];//get the received PEC byte from master
    461. 					        
    462. 					        //calculate PEC byte for comparison
    463. 				            PMBusSlave_CrcMsg[1] = PMBusSlave_Command;			// store first rx byte
    464. 				            PMBusSlave_CrcMsg[2] = PMBusSlave_ReceiveBuffer[1];	// store rx byte
    465. 				            PMBusSlave_CrcMsg[3] = PMBusSlave_ReceiveBuffer[2];	// store rx byte
    466. 				            PMBusSlave_CrcMsgSize = 4;                 			// # of bytes
    467. 				            PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);          			        
    468. 					        
    469. 					        //if the bytes do not match, respond according to the PMBus Spec.
    470. 					        if(PMBusSlave_CrcSlaveGenerated != PMBusSlave_CrcMasterGenerated)	//compare received PEC byte with calculated PEC byte
    471. 					   		{			   			
    472. 					   			//Flush the received command byte and any received data
    473. 					   			PMBusSlave_Command = 0;				//flush command byte
    474. 					   			PMBusSlave_Index = 0;				//clear index so no data is stored
    475. 					   			PMBusSlave_ReceiveBuffer[0] = 0;	//flush received data bytes
    476. 					   			PMBusSlave_ReceiveBuffer[1] = 0;
    477. 								PMBusSlave_ReceiveBuffer[2] = 0;
    478. 					   			PMBusSlave_ReceiveBuffer[3] = 0;
    479. 					   			//ERROR process if needed
    480. 					   		}
    481. 							else//TODO according to the command
    482. 							{
    483. 								switch(PMBusSlave_Command)
    484. 								{
    485. 									default:
    486. 										break;
    487. 								}
    488. 							}
    489. 			  			}
    490. 						break;
    491. 						
    492. 					case WRITEBYTE: // master writing single byte to slave
    493. 						PMBusSlave_CrcMasterGenerated = PMBusSlave_ReceiveBuffer[2];	//get the received PEC byte from master							
    494. 						//calculate PEC byte for comparison
    495. 						PMBusSlave_CrcMsg[1] = PMBusSlave_Command;			// store first rx byte
    496. 						PMBusSlave_CrcMsg[2] = PMBusSlave_ReceiveBuffer[1];	// store rx byte						
    497. 						PMBusSlave_CrcMsgSize = 3;                 			// # of bytes
    498. 						PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);          			        
    499. 						
    500. 						//if the bytes do not match, respond according to the PMBus Spec.
    501. 						if(PMBusSlave_CrcSlaveGenerated != PMBusSlave_CrcMasterGenerated)	//compare received PEC byte with calculated PEC byte
    502. 						{			   			
    503. 							//Flush the received command byte and any received data
    504. 							PMBusSlave_Command = 0;				//flush command byte
    505. 							PMBusSlave_Index = 0;				//clear index so no data is stored
    506. 							PMBusSlave_ReceiveBuffer[0] = 0;	//flush received data bytes
    507. 							PMBusSlave_ReceiveBuffer[1] = 0;
    508. 							PMBusSlave_ReceiveBuffer[2] = 0;
    509. 							//ERROR process if needed
    510. 						}
    511. 						break;					
    512. 					
    513. 					case SENDBYTE:  	//we already received the command.
    514. 						//while(!I2caRegs.I2CSTR.bit.RRDY);					//wait for the data
    515. 						//PMBusSlave_CrcMasterGenerated = I2caRegs.I2CDRR;	//get the received PEC byte from master
    516. 						//StopCpuTimer0();				//No timeout, so stop the timer
    517. 						//ReloadCpuTimer0();				//Reload the period value (35 ms timeout)
    518. 						
    519. 						//calculate PEC byte for comparison
    520. 						PMBusSlave_CrcMsg[1] = PMBusSlave_Command;	// store first rx byte
    521. 						PMBusSlave_CrcMsgSize = 2;                 	// # of bytes
    522. 						PMBusSlave_CrcSlaveGenerated = PMBusSlave_Crc8MakeBitwise(CRC8_INIT_REM, CRC8_POLY, PMBusSlave_CrcMsg, PMBusSlave_CrcMsgSize);         
    523. 						
    524. 						//if the bytes do not match, respond according to the PMBus Spec.
    525. 						if(PMBusSlave_CrcSlaveGenerated != PMBusSlave_CrcMasterGenerated)	//compare received PEC byte with calculated PEC byte
    526. 						{			   			
    527. 							//Flush the received command byte
    528. 							PMBusSlave_Command = 0;			//flush command byte
    529. 							PMBusSlave_Index = 0;			//clear index so no data is stored
    530. 							
    531. 							//Set status bits
    532. 							//StatusRegs.StatusWord.StatusByte.bit.CML = 1;				//set the CML bit
    533. 							//StatusRegs.StatusCml.bit.PACKET_ERROR_CHECK_FAILED = 1;		//set the PEC failed bit
    534. 							
    535. 							//signal the master via the Alert line
    536. 							//GpioDataRegs.GPACLEAR.bit.GPIO2 = 1;		//Drive line low
    537. 						}		        
    538. 						break;	//User could insert handling code here.							
    539. 							
    540. 					default:
    541. 							break;
    542. 				}
    543. 				i2c_rcv_cnt = 0;
    544. 			}
    545. 			PMBus_ClearFlag();
    546. 			i2c1_mode = I2C1_MODE_WAITING;
    547. 			break;
    548. 			
    549. 		default:
    550. 			break;
    551. 	}
    552. 	
    553. 	//    //Event handle
    554. 	//    if(event == I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED) 
    555. 	//    {
    556. 	//        // Master has sent the slave address to send data to the slave
    557. 	//        i2c1_mode = I2C1_MODE_SLAVE_ADR_WR;
    558. 	//    }
    559. 	//    else if(event == I2C_EVENT_SLAVE_BYTE_RECEIVED) 
    560. 	//    {
    561. 	//        // Master has sent a byte to the slave
    562. 	//        wert = I2C_ReceiveData(I2C1);
    563. 	//		PMBusSlave_ReceiveBuffer[i2c_rcv_cnt] = wert;
    564. 	//		i2c_rcv_cnt++;
    565. 	//		
    566. 	//		/*=========== the old statements ================
    567. 	//        // Check address
    568. 	//        if(i2c1_mode == I2C1_MODE_SLAVE_ADR_WR) 
    569. 	//        {
    570. 	//            i2c1_mode = I2C1_MODE_ADR_BYTE;
    571. 	//            // Set current ram address
    572. 	//            i2c1_ram_adr = wert;
    573. 	//        }
    574. 	//        else 
    575. 	//        {
    576. 	//            i2c1_mode = I2C1_MODE_DATA_BYTE_WR;
    577. 	//            // Store data in RAM
    578. 	//            Set_I2C1_Ram(i2c1_ram_adr, wert);			
    579. 	//            // Next ram adress
    580. 	//            i2c1_ram_adr++;			
    581. 	//        }*/
    582. 	//    }
    583. 	//    else if(event == I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED) 
    584. 	//    {
    585. 	//        // Master has sent the slave address to read data from the slave
    586. 	//        i2c1_mode = I2C1_MODE_SLAVE_ADR_RD;
    587. 	//        // Read data from RAM
    588. 	//        wert = Get_I2C1_Ram(i2c1_ram_adr);
    589. 	//        // Send data to the master
    590. 	//        I2C_SendData(I2C1, wert);
    591. 	//        // Next ram adress
    592. 	//        i2c1_ram_adr++;
    593. 	//    }
    594. 	//    else if(event == I2C_EVENT_SLAVE_BYTE_TRANSMITTED) 
    595. 	//    {
    596. 	//        // Master wants to read another byte of data from the slave
    597. 	//        i2c1_mode = I2C1_MODE_DATA_BYTE_RD;
    598. 	//        // Read data from RAM
    599. 	//        wert = Get_I2C1_Ram(i2c1_ram_adr);
    600. 	//        // Send data to the master
    601. 	//        I2C_SendData(I2C1, wert);
    602. 	//        // Next ram adress
    603. 	//        i2c1_ram_adr++;
    604. 	//    }
    605. 	//    else if(event == I2C_EVENT_SLAVE_STOP_DETECTED) 
    606. 	//    {
    607. 	//        // Master has STOP sent
    608. 	//		if(i2c_rcv_cnt)
    609. 	//		{
    610. 	//			i2c_rcv_finish_flag = 1;
    611. 	//		}
    612. 	//        PMBus_ClearFlag();
    613. 	//        i2c1_mode = I2C1_MODE_WAITING;
    614. 	//    }
    615. 	
    616. 	//I2C error check
    617. 	if (I2C_GetITStatus(I2C1, I2C_IT_AF)) 
    618.     {
    619.         I2C_ClearITPendingBit(I2C1, I2C_IT_AF);
    620. 		//i2c_rcv_finish_flag = 0;
    621.     }
    622. 		
    623. 	  
    624. 	USER CODE
    625. 	//contains what actions to take after getting information from the master,
    626. 	//usually where to store received data and what functions to call in response
    627. 	#warning	"User should modify code to implement their application's supported PMBus commands."
    628. 	switch (PMBusSlave_Index)	//should include all user supported commands
    629. 	{
    630. 		case STATUS_TEMPERATURE:
    631. 				break;
    632. 		case STORE_DEFAULT_CODE:
    633. 				Default_Code = PMBusSlave_ReceiveBuffer[0];
    634. 				break;
    635. 		case OPERATION:
    636. 				Operation = PMBusSlave_ReceiveBuffer[0];
    637. 				break;
    638. 		case STATUS_WORD:
    639. 				break;
    640. 		case VOUT_COMMAND:
    641. 				Vout_Command = (PMBusSlave_ReceiveBuffer[1] << 8) | PMBusSlave_ReceiveBuffer[0];
    642. 				break;
    643. 		default:	//command not supported by this slave
    644. 				break;
    645. 	}
    646. 	END USER CODE
    647. 		
    648. }
    649.  
    650.  
    651.  
    652. #if PEC
    653. /***************************************************************************//**
    654.  * @brief   Calculate the Packet Error Checking byte.
    655.  * @param   PMBusSlave_CRC Initial value.
    656.  * @param	PMBusSlave_Poly The polynomial to use for the calculation.
    657.  * @param	*PMBusSlave_PMsg Pointer to the bytes from the PMBus transaction.
    658.  * @param	PMBusSlave_MsgSize Number of bytes in the last transaction.
    659.  * @return  The PEC byte.
    660.  ******************************************************************************/
    661. static unsigned short PMBusSlave_Crc8MakeBitwise(unsigned char PMBusSlave_CRC, unsigned char PMBusSlave_Poly, unsigned char *PMBusSlave_Pmsg, unsigned int PMBusSlave_MsgSize)
    662. {
    663.     unsigned int i, j, carry;
    664.     unsigned char msg;
    665.  
    666.     PMBusSlave_CRC = *PMBusSlave_Pmsg++;        	// first byte loaded in "crc"		
    667.     for(i = 0 ; i < PMBusSlave_MsgSize-1 ; i ++)
    668.     {
    669.         msg = *PMBusSlave_Pmsg++;                   // next byte loaded in "msg"
    670.         
    671. 		for(j = 0 ; j < 8 ; j++)
    672. 	    {
    673. 	  		carry = PMBusSlave_CRC & 0x80;               			// check if MSB=1			
    674.           	PMBusSlave_CRC = (PMBusSlave_CRC << 1) | (msg >> 7);    // Shift 1 bit of next byte into crc
    675.             if(carry) PMBusSlave_CRC ^= PMBusSlave_Poly;      		// If MSB = 1, perform XOR
    676. 			msg <<= 1;                  							// Shift left msg byte by 1
    677. 			msg &= 0x00FF;
    678.         }
    679.     }
    680. 	// The previous loop computes the CRC of the input bit stream. To this, 
    681.     // 8 trailing zeros are padded and the CRC of the resultant value is 
    682.     // computed. This gives the final CRC of the input bit stream.
    683. 	for(j = 0 ; j < 8 ; j++)
    684.     {
    685. 		carry = PMBusSlave_CRC & 0x80;
    686. 		PMBusSlave_CRC <<= 1;
    687. 		if(carry) PMBusSlave_CRC ^= PMBusSlave_Poly;
    688.     }	
    689.         
    690.     PMBusSlave_CRC &= 0x00FF;	//We only want one byte (lower)
    691.     
    692.     return(PMBusSlave_CRC);
    693. }
    694. #endif
    695.  
    696. /***************************************************************************//**
    697.  * @brief   Handles timeouts. Triggered if clock held low > 35ms.
    698.  * @param   None
    699.  * @return  None
    700.  ******************************************************************************/
    701. /*
    702. interrupt void cpu_timer0_isr(void)
    703. {
    704. 	// Timed out. Reset module.
    705. 	I2caRegs.I2CMDR.bit.IRS = 0;	//reset
    706.    	// Acknowledge this interrupt to receive more interrupts from group 1
    707.    	PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
    708. }
    709. */

  • 相关阅读:
    夜天之书 #68 开源码力圆桌文字稿
    Chrome访问剪切板实现右键复制粘贴
    使用CountDownLatch解决接口循环网络请求造成的耗时问题
    vue实现轮播图详解
    uniapp实现多行文本溢出超过指定行数 展开 收起
    用python的mako模板库写一个自动生成.c/.h文件generate_code功能
    Unity-特殊文件夹
    Redis缓存篇：高频问题横扫核心知识点，面试高级工程师必备知识体系
    工商银行卡安全码怎么看
    游戏道具平台|基于Springboot+Vue实现游戏道具平台系统
  • 原文地址：https://blog.csdn.net/jmmx/article/details/133039123