21ic电子技术开发论坛 › 单片机与嵌入式系统 › Megawin(笙泉)单片机 › 【M0】 MG32F02A 学习笔记⑳ IIC从机模式
返回列表 发新帖我要提问

[范例教程] 【M0】 MG32F02A 学习笔记⑳ IIC从机模式

[复制链接]
1521|0
 楼主| noctor 发表于 2018-11-22 09:05 | 显示全部楼层 |阅读模式
iic, 学习笔记, I2c, se
     上回我们说到了MG32F02A的IIC主机的使用。帖子详情：https://bbs.21ic.com/icview-2588642-1-1.html

      这次该说从机了。

      其实从机与主机区别不大，只是在初始化多一小段代码
复制

  1. 

  2. #include "MG32x02z_DRV.H"
    

  3. #include "iic.h"
    

  4. #include <stdio.h>
    


  5. 

  6. I2C_Struct* I2Cx;
    


  7. 

  8. typedef uint8_t u8;
    

  9. typedef uint16_t u16;
    

  10. typedef uint32_t u32;
    

  11. typedef uint64_t u64;
    


  12. 

  13. #define URTX URT0
    

  14. #define MYBINARYIMAGE2_LENGTH 20
    


  15. 

  16. I2C_HandleTypeDef gSI2C0_Handle;
    

  17. I2C_HandleTypeDef gSI2C1_Handle;
    


  18. 

  19. uint8_t SendBuf[MYBINARYIMAGE2_LENGTH]={0};//__attribute__((at(0x20001000)));
    

  20. //uint8_t RcvBuf[MYBINARYIMAGE2_LENGTH] __attribute__((at(0x20003800)));
    

  21. uint8_t const String0[] = {"X"};
    

  22. uint8_t lDataBuffer[80];
    


  23. 

  24. void CSC_Init (void)
    

  25. {
    

  26.         CSC_PLL_TyprDef CSC_PLL_CFG;
    

  27.     
    

  28.   UnProtectModuleReg(MEMprotect);             // Setting flash wait state
    

  29.   MEM_SetFlashWaitState(MEM_FWAIT_ONE);        // 50MHz> Sysclk >=25MHz
    

  30.   ProtectModuleReg(MEMprotect);
    


  31. 

  32.   UnProtectModuleReg(CSCprotect);
    

  33.         CSC_CK_APB_Divider_Select(APB_DIV_1);        // Modify CK_APB divider        APB=CK_MAIN/1
    

  34.         CSC_CK_AHB_Divider_Select(AHB_DIV_1);        // Modify CK_AHB divider        AHB=APB/1
    


  35. 

  36.         
    

  37.         /* CK_HS selection */
    

  38.         CSC_IHRCO_Select(IHRCO_12MHz);                        // IHRCO Sel 12MHz
    

  39.         CSC_IHRCO_Cmd(ENABLE);
    

  40.         while(CSC_GetSingleFlagStatus(CSC_IHRCOF) == DRV_Normal);
    

  41.         CSC_ClearFlag(CSC_IHRCOF);
    

  42.         CSC_CK_HS_Select(HS_CK_IHRCO);                        // CK_HS select IHRCO
    


  43. 


  44. 

  45.         /* PLL */
    

  46.         /**********************************************************/
    

  47.         CSC_PLL_CFG.InputDivider=PLLI_DIV_2;        // 12M/2=6M
    

  48.         CSC_PLL_CFG.Multiplication=PLLIx16;                // 6M*16=96M
    

  49.         CSC_PLL_CFG.OutputDivider=PLLO_DIV_2;        // PLLO=96M/2=48M
    

  50.         CSC_PLL_Config(&CSC_PLL_CFG);
    

  51.         CSC_PLL_Cmd(ENABLE);
    

  52.         while(CSC_GetSingleFlagStatus(CSC_PLLF) == DRV_Normal);
    

  53.         CSC_ClearFlag(CSC_PLLF);
    

  54.         /**********************************************************/
    


  55. 

  56.         
    

  57.         /* CK_MAIN */ 
    

  58.         CSC_CK_MAIN_Select(MAIN_CK_HS);        
    


  59. 


  60. 

  61.         /* Configure ICKO function */
    

  62.                 
    

  63.         /* Configure peripheral clock */
    

  64.         CSC_PeriphProcessClockSource_Config(CSC_I2C0_CKS, CK_APB);
    

  65.         CSC_PeriphProcessClockSource_Config(CSC_UART0_CKS, CK_APB);
    

  66.          CSC_PeriphOnModeClock_Config(CSC_ON_I2C0,ENABLE);
    

  67.         CSC_PeriphOnModeClock_Config(CSC_ON_UART0,ENABLE);
    

  68.          CSC_PeriphOnModeClock_Config(CSC_ON_PortB,ENABLE);
    

  69.         CSC_PeriphOnModeClock_Config(CSC_ON_PortE,ENABLE);
    

  70.         
    

  71.   ProtectModuleReg(CSCprotect);
    

  72.     
    

  73. }
    


  74. 


  75. 

  76. void I2C0_ByteMode_Slave_Init(void)
    

  77. {
    

  78.     I2C_InitTypeDef SI2C0_Init;
    


  79. 

  80.     SI2C0_Init.Instance = I2C0;
    

  81.     SI2C0_Init.CK_I2C_PR_Frequency = 12000000;
    

  82.     SI2C0_Init.SCL_Clock = 400000;    
    

  83.     I2C_ByteMode_Init(&SI2C0_Init);
    

  84.     gSI2C0_Handle.Instance = I2C0;
    

  85.     printf("I2C_SlaveDeviceReady\n\r");
    

  86.                 
    

  87.                 Set_STA_STO_AA_001(I2C0);
    

  88.                                 
    

  89. }
    


  90. 

  91. DRV_Return I2C_ByteMode_Init(I2C_InitTypeDef *SI2C)
    

  92. {
    

  93. //    PIN_InitTypeDef PINX_InitStruct;
    

  94.     uint16_t lI2C_Pre = 1;
    

  95.     uint16_t lI2C_DIV = 1;
    

  96.     uint16_t lI2C_HT_LT = 0;
    

  97.     uint16_t lI2C_LT;
    

  98.     uint16_t lI2C_HT;
    

  99.                 PIN_InitTypeDef PINX_InitStruct;
    

  100.     //===== Check I2C Busy =====//
    

  101.     if(__I2C_GetFlagStatus(SI2C->Instance, I2C_FLAG_BUSYF))
    

  102.         return DRV_Busy;
    


  103. 

  104.     __I2C_Disable(SI2C->Instance);
    


  105. 

  106. //    //===== GPIO Initial =====//
    

  107. //      //===== CSC for GPIO Config =====//
    

  108.     UnProtectModuleReg(CSCprotect);                                             // Unprotect CSC module
    

  109.     CSC_PeriphOnModeClock_Config(CSC_ON_PortB, ENABLE);                                    // Enable PortB clock
    


  110. 

  111.     ProtectModuleReg(CSCprotect);                                               // protect CSC module
    


  112. 

  113. //      //===== GPIO Config =====//
    

  114.     PINX_InitStruct.PINX_Mode                      = PINX_Mode_OpenDrain_O;//PINX_Mode_Digital_I;            // Pin select pusu pull mode
    

  115.     PINX_InitStruct.PINX_PUResistant        = PINX_PUResistant_Enable;         // Enable pull up resistor
    

  116.     PINX_InitStruct.PINX_Speed              = PINX_Speed_High;           
    

  117.     PINX_InitStruct.PINX_OUTDrive           = PINX_OUTDrive_Level0;             // Pin output driver full strength.
    

  118.     PINX_InitStruct.PINX_FilterDivider      = PINX_FilterDivider_Bypass;        // Pin input deglitch filter clock divider bypass
    

  119.     PINX_InitStruct.PINX_Inverse            = PINX_Inverse_Disable;             // Pin input data not inverse
    

  120.     PINX_InitStruct.PINX_Alternate_Function = 2;                                // Pin AFS = 2
    


  121. 

  122.     if(SI2C->Instance == I2C0)
    

  123.     {
    

  124.     GPIO_PinMode_Config(PINB(10),&PINX_InitStruct);                                            // I2C0 SCL setup at PB10           
    

  125.     GPIO_PinMode_Config(PINB(11),&PINX_InitStruct);                         // I2C0 SDA setup at PB11
    


  126. 


  127. 

  128.  //       GPIO_PinMode_Config(PINC(4),&PINX_InitStruct);                          // I2C0 SCL setup at PC4
    

  129.  //       GPIO_PinMode_Config(PINC(5),&PINX_InitStruct);                          // I2C0 SDA setup at PC5
    


  130. 

  131.  //       GPIO_PinMode_Config(PINC(8),&PINX_InitStruct);                          // I2C0 SCL setup at PC8
    

  132.  //       GPIO_PinMode_Config(PINC(9),&PINX_InitStruct);                          // I2C0 SDA setup at PC9
    


  133. 

  134.  //       GPIO_PinMode_Config(PIND(5),&PINX_InitStruct);                          // I2C0 SCL setup at PD5
    

  135.  //       GPIO_PinMode_Config(PIND(6),&PINX_InitStruct);                          // I2C0 SDA setup at PD6
    


  136. 

  137.  //       GPIO_PinMode_Config(PINE(0),&PINX_InitStruct);                          // I2C0 SCL setup at PE0
    

  138.  //       GPIO_PinMode_Config(PINE(1),&PINX_InitStruct);                          // I2C0 SDA setup at PE1
    

  139.     }
    


  140. 

  141.     if(SI2C->Instance == I2C1)
    

  142.     {
    

  143.         GPIO_PinMode_Config(PINC(10),&PINX_InitStruct);                         // I2C1 SCL setup at PC10
    

  144.         GPIO_PinMode_Config(PINC(11),&PINX_InitStruct);                         // I2C1 SDA setup at PC11
    


  145. 

  146.         GPIO_PinMode_Config(PIND(8),&PINX_InitStruct);                          // I2C1 SCL setup at PD8
    

  147.         GPIO_PinMode_Config(PIND(9),&PINX_InitStruct);                          // I2C1 SDA setup at PD9
    


  148. 

  149.         GPIO_PinMode_Config(PINE(2),&PINX_InitStruct);                          // I2C1 SCL setup at PE2
    

  150.         GPIO_PinMode_Config(PINE(3),&PINX_InitStruct);                          // I2C1 SDA setup at PE3
    

  151.     }
    


  152. 

  153.     //===== I2C Initial =====//
    

  154.       //=== CSC for I2C Config ===//
    

  155.     UnProtectModuleReg(CSCprotect);                                             // Unprotect CSC module
    

  156.     if(SI2C->Instance == I2C0)
    

  157.                         
    

  158.         CSC_PeriphOnModeClock_Config(CSC_ON_I2C0, ENABLE);                      // Enable I2C0 module clock
    

  159.     if(SI2C->Instance == I2C1)
    

  160.         CSC_PeriphOnModeClock_Config(CSC_ON_I2C1, ENABLE);                      // Enable I2C1 module clock
    

  161.     ProtectModuleReg(CSCprotect);                                               // protect CSC module
    


  162. 

  163.       //=== I2C Config ===//
    

  164.     //===== I2C Output Clock Config =====//
    

  165.     // CK_I2C_PR
    

  166.     // SCL Output Clock
    

  167.     // HT + LT, <= 32 >=9, CK_I2C_PR / SCL Clock / Prescaler / DIV
    


  168. 

  169.     do{
    

  170.         lI2C_HT_LT = SI2C->CK_I2C_PR_Frequency / SI2C->SCL_Clock / lI2C_Pre / lI2C_DIV;
    

  171.         if((lI2C_HT_LT >= 32) || (lI2C_HT_LT <=9)) 
    

  172.         {
    

  173.             lI2C_Pre ++;
    

  174.             if(lI2C_Pre > 8)
    

  175.             {
    

  176.                 lI2C_Pre = 1;
    

  177.                 lI2C_DIV ++;
    

  178.             }
    

  179.         }
    

  180.     }while((lI2C_HT_LT >= 32) || (lI2C_HT_LT <=9));
    


  181. 

  182.     lI2C_LT = (lI2C_HT_LT >> 1);
    

  183.     lI2C_HT = lI2C_HT_LT - lI2C_LT;
    


  184. 

  185.     __I2C_SetClockSource(SI2C->Instance, I2C_CLK_SRC_PROC);
    

  186.     __I2C_SetClockPrescaler(SI2C->Instance, lI2C_Pre - 1);
    

  187.     __I2C_SetClockDivider(SI2C->Instance, lI2C_DIV - 1);
    

  188.     __I2C_SetSCLHighTime(SI2C->Instance, lI2C_HT - 1);
    

  189.     __I2C_SetSCLLowTime(SI2C->Instance, lI2C_HT - 1);
    


  190. 

  191.     //===== I2C Opration Mode Config =====//
    

  192.     __I2C_GeneralCallAddress_Disable(SI2C->Instance);
    

  193.     __I2C_SlaveAddressDetect_Enable(SI2C->Instance, (I2C_SADR_1 | I2C_SADR_2));
    

  194.     I2C_SetSlaveAddress(I2C0, I2C_SADR_1, 0xA0);
    

  195.                 I2C_SetSlaveAddress(I2C0, I2C_SADR_2, 0x05);
    

  196.     //===== I2C Interrupt Config =====//
    

  197.     if(SI2C->Instance == I2C0)
    

  198.     {
    

  199.         NVIC_EnableIRQ(I2C0_IRQn);
    

  200.         NVIC_SetPriority(I2C0_IRQn, 1);                                         // Suggest SYSTICK Priority = 0
    

  201.                                                                                 //           Other Priority > 0
    

  202.     }
    


  203. 

  204.     if(SI2C->Instance == I2C1)
    

  205.     {
    

  206.         NVIC_EnableIRQ(I2Cx_IRQn);
    

  207.         NVIC_SetPriority(I2Cx_IRQn, 1);                                         // Suggest SYSTICK Priority = 0
    

  208.                                                                                 //           Other Priority > 0
    

  209.     }
    


  210. 

  211.     __I2C_ITEA_Disable(SI2C->Instance);
    

  212.     __I2C_IT_Disable(SI2C->Instance, (I2C_IT_TMOUT | I2C_IT_EVENT | I2C_IT_ERR | I2C_IT_BUF | I2C_IT_WUP));
    


  213. 

  214.     __I2C_IT_Enable(SI2C->Instance, ( I2C_IT_EVENT ));
    

  215.     __I2C_ITEA_Enable(SI2C->Instance);
    


  216. 

  217.                 
    

  218.     //===== I2C Timeout Config =====//
    

  219.     __I2C_TMO_Disable(SI2C->Instance);
    

  220.     __I2C_SetTimeOutClockSource(SI2C->Instance, I2C_TMO_CKS_DIV64);
    

  221.     __I2C_SetTimeOutDetectionMode(SI2C->Instance, I2C_TMO_MDS_GENERAL);
    

  222.     __I2C_SetTimeOutCount(SI2C->Instance, I2C_TMO_MDS_GENERAL);
    

  223.                 
    

  224.     //===== I2C Enable =====//
    

  225.     __I2C_Enable(SI2C->Instance);
    

  226.         //        I2Cx->CR0.B[0] |= I2C_CR0_BUF_EN_enable_b0;
    

  227.     return DRV_Success;
    

  228. }
    


  229. 

  230. void I2C_Delay(uint32_t Delay)
    

  231. {
    

  232.         int i;
    

  233.            while(i*10)
    

  234.    {
    

  235.      i--;
    

  236.    } 
    

  237.         
    

  238. }
    


  239. 

  240. DRV_Return I2C_IsDeviceReady(I2C_HandleTypeDef *SI2C, uint16_t DevAddress, uint32_t Trials)
    

  241. {
    

  242. //-----Check I2C Busy ------------------
    

  243.     if(__I2C_GetFlagStatus(SI2C->Instance, I2C_FLAG_BUSYF) != CLR)
    

  244.         return DRV_Busy;
    


  245. 

  246. //-----Set_Config-----------------------
    

  247.     SI2C->State.W = 0;
    

  248.     SI2C->SlaveAddress = DevAddress & 0xFFFE;
    

  249.     SI2C->pData = 0x00000000;
    

  250.     SI2C->Count = 0;
    

  251.     SI2C->Control.W = I2C_XferNext_STOP;
    


  252. 

  253. //-----Start----------------------------
    

  254.     do{
    

  255.         SI2C->State.W = 0;
    

  256.         Set_STA_STO_AA_100(SI2C->Instance);
    

  257.         do{
    

  258.             I2C_ByteMode_Handle(SI2C);
    

  259.         }while(SI2C->State.MBit.Done == 0);
    


  260. 

  261.         if((SI2C->State.W & (I2C_State_BusError | \
    

  262.                                    I2C_State_ArbitrationLost | \
    

  263.                                    I2C_State_NACK)) == 0)
    

  264.             return DRV_Success;
    


  265. 

  266.         I2C_Delay(1);
    

  267.         
    

  268.     }while(-- Trials > 0);
    


  269. 

  270.     return DRV_Failure;
    

  271. }
    


  272. 

  273. void I2C_ByteMode_Handle(I2C_HandleTypeDef *SI2C)
    

  274. {
    

  275.     uint8_t lState;
    


  276. 

  277.     if(__I2C_GetStateFlag(SI2C->Instance) == 0)
    

  278.         return;
    


  279. 

  280.     lState = __I2C_GetStatusCode(SI2C->Instance);
    

  281.     switch(lState){
    

  282.         case 0x00:  // Bus Error 
    

  283.             SI2C->State.W |= I2C_State_BusError | \
    

  284.                                    I2C_State_Done;;
    

  285.             break;
    


  286. 

  287.         case 0x08:  // SLA+W sent and ACK received 
    

  288.         case 0x10:  // Repeated start condition
    

  289.             Set_STA_STO_AA_000(SI2C->Instance);
    

  290.             __I2C_SendSBUF(SI2C->Instance, ((uint8_t)SI2C->SlaveAddress));
    

  291.             break;
    


  292. 

  293.         case 0x18:  // MT SLA+W sent and ACK received
    

  294.         case 0x28:  // MT DATA sent and ACK received
    

  295.             if(SI2C->Count == 0)
    

  296.             {
    

  297.                 Set_STA_STO_AA_010(SI2C->Instance);
    

  298.                 __I2C_ClearStateFlag(SI2C->Instance);
    

  299.                 while(__I2C_GetStatusCode(SI2C->Instance) == lState);
    

  300.                 lState = __I2C_GetStatusCode(SI2C->Instance);
    

  301.                 SI2C->State.W |= I2C_State_Done;
    

  302.                 return;
    

  303.             }
    

  304.             __I2C_SendSBUF(SI2C->Instance, ((uint8_t)*SI2C->pData));
    

  305.             SI2C->pData ++;
    

  306.             SI2C->Count --;
    

  307.             break;
    


  308. 

  309.         case 0x20:  // MT SLA+W sent NACK received 
    

  310.         case 0x30:  // MT DATA sent NACK received
    

  311.         case 0x48:  // MR SLA+R sent NACK received
    

  312.             Set_STA_STO_AA_010(SI2C->Instance);
    

  313.             __I2C_ClearStateFlag(SI2C->Instance);
    

  314.             while(__I2C_GetStatusCode(SI2C->Instance) == lState);
    

  315.             lState = __I2C_GetStatusCode(SI2C->Instance);
    

  316.             SI2C->State.W |= I2C_State_NACK | \
    

  317.                                    I2C_State_Done;
    

  318.             return;
    


  319. 

  320.         case 0x38:  // Arbitration lost
    

  321.             Set_STA_STO_AA_000(SI2C->Instance);
    

  322.             SI2C->State.W |= I2C_State_ArbitrationLost | \
    

  323.                                    I2C_State_Done;
    

  324.             break;
    


  325. 

  326.         case 0x40:  // SLA+R sent and ACK received
    

  327.             Set_STA_STO_AA_001(SI2C->Instance);
    

  328.         case 0x50:  // Data Received and ACK sent
    

  329.             if(SI2C->Count <= 1)
    

  330.                 Set_STA_STO_AA_000(SI2C->Instance);
    

  331.             *SI2C->pData = __I2C_ReceiveSBUF(SI2C->Instance);
    

  332.             SI2C->Count--;
    

  333.             SI2C->pData++;
    

  334.             break;
    


  335. 

  336.         case 0x58:  // Data Received and NACK sent
    

  337.             if((SI2C->Control.W & I2C_XferNext_Mask) == I2C_XferNext_RepeatStart)
    

  338.                 Set_STA_STO_AA_100(SI2C->Instance);
    

  339.             else
    

  340.                 Set_STA_STO_AA_010(SI2C->Instance);
    


  341. 

  342.             SI2C->State.W |= I2C_State_Done;
    

  343.             break;
    


  344. 

  345. //-------------------------------------
    

  346.         case 0x60:  // Own SLA+W has bee Received ACK has been returned
    


  347. 

  348.         case 0x68:  // Arbitration lost in SLA+R/W as master,
    

  349.                     // Own SLA+W has been Received ACK has bee returned
    


  350. 

  351.         case 0x70:  // General Call address has been received ACK has been returned
    


  352. 

  353.         case 0x78:  // Arbitration lost in SLA+R/W as master,
    

  354.                     // General Call address has been received ACK has been returned
    


  355. 

  356.         case 0x80:  // Data byte has been received ACK has been return
    


  357. 

  358.         case 0x88:  // Data byte has been received Not ACK has been return
    


  359. 

  360.         case 0x90:  // Previously address with General Call address
    

  361.                     // Data byte has been received ACK has been return
    


  362. 

  363.         case 0x98:  // Previously address with General Call address
    

  364.                     // Data byte has been received Not ACK has been return
    


  365. 

  366.         case 0xA0:  // A STOP or repeated START has been received while will addressed as SLV/REC
    


  367. 

  368.         case 0xA8:  // Own SLA+R has bee Received ACK has been returned
    


  369. 

  370.         case 0xB0:  // Arbitration lost in SLA+R/W as master,
    

  371.                     // Own SLA+R has been Received ACK has bee returned
    


  372. 

  373.         case 0xB8:  // Data byte in SIDAT has been transmitted ACK has been received
    


  374. 

  375.         case 0xC0:  // Data byte or Last data byte in SIDAT has been transmitted Not ACK has been received
    


  376. 

  377.         case 0xC8:  // Last Data byte in SIDAT has been transmitted ACK has been received
    


  378. 

  379.         case 0xD0: 
    

  380.         case 0xD8:
    

  381.         case 0xE0:
    

  382.         case 0xE8:
    

  383.         case 0xF0:
    

  384.                     
    

  385.         case 0xF8:  // Bus Idle
    


  386. 

  387.         default:
    

  388.             break;
    

  389.     }
    

  390.     __I2C_ClearStateFlag(SI2C->Instance);
    

  391.     while(__I2C_GetStateFlag(SI2C->Instance) != 0);
    

  392. }
    


  393. 

  394. DRV_Return I2C_ByteMode_SlaveTransmit(I2C_HandleTypeDef *SI2C, uint16_t DevAddress, uint8_t *pData, uint16_t Lenth)
    

  395. {
    

  396. //-----Check----------------------------
    

  397.     if(__I2C_GetFlagStatus(SI2C->Instance, I2C_FLAG_BUSYF) != CLR)
    

  398.         return DRV_Busy;
    


  399. 

  400. //-----Set_Config-----------------------
    

  401.     SI2C->State.W = 0;
    

  402.     SI2C->SlaveAddress = DevAddress & 0xFFFE;
    

  403.     SI2C->pData = pData;
    

  404.     SI2C->Count = Lenth;
    

  405.     SI2C->Control.W = I2C_XferNext_STOP;
    


  406. 

  407. //-----Start----------------------------
    

  408.     Set_STA_STO_AA_100(SI2C->Instance);
    

  409.     do{
    

  410.         I2C_ByteMode_Handle(SI2C);
    

  411.     }while(SI2C->State.MBit.Done == 0);
    


  412. 

  413.     if((SI2C->State.W & (I2C_State_BusError | \
    

  414.                                I2C_State_ArbitrationLost | \
    

  415.                                I2C_State_NACK)) != 0)
    

  416.         return DRV_Failure;
    


  417. 

  418.     return DRV_Success;
    

  419. }
    


  420. 

  421. DRV_Return I2C_ByteMode_SlaveReceive(I2C_HandleTypeDef *SI2C, uint16_t DevAddress, uint8_t *pData, uint16_t Lenth)
    

  422. {
    

  423. //-----Check----------------------------
    

  424.     if(__I2C_GetFlagStatus(SI2C->Instance, I2C_FLAG_BUSYF) != CLR)
    

  425.         return DRV_Busy;
    


  426. 

  427. //-----Set_Config-----------------------
    

  428.     SI2C->State.W = 0;
    

  429.     SI2C->SlaveAddress = DevAddress | 0x0001;
    

  430.     SI2C->pData = pData;
    

  431.     SI2C->Count = Lenth;
    

  432.     SI2C->Control.W = I2C_XferNext_STOP;
    


  433. 

  434. //-----Start----------------------------
    

  435.     Set_STA_STO_AA_100(SI2C->Instance);
    

  436.     do{
    

  437.         I2C_ByteMode_Handle(SI2C);
    

  438.     }while(SI2C->State.MBit.Done == 0);
    


  439. 

  440.     if((SI2C->State.W & (I2C_State_BusError | \
    

  441.                                I2C_State_ArbitrationLost | \
    

  442.                                I2C_State_NACK)) != 0)
    

  443.         return DRV_Failure;
    


  444. 

  445.     return DRV_Success;
    

  446.                 
    

  447. }
    


  448. 

  449. void Sample_URT0_Init(void)
    

  450. {
    

  451.     URT_BRG_TypeDef  URT_BRG;
    

  452.     URT_Data_TypeDef DataDef;
    

  453.             PIN_InitTypeDef PINX_InitStruct;
    

  454.     //==Set CSC init
    

  455.     //MG32x02z_CSC_Init.h(Configuration Wizard)
    

  456.     //Select CK_HS source = CK_IHRCO
    

  457.     //Select IHRCO = 11.0592M
    

  458.     //Select CK_MAIN Source = CK_HS
    

  459.     //Configure PLL->Select APB Prescaler = CK_MAIN/1
    

  460.     //Configure Peripheral On Mode Clock->Port B/URT0 = Enable
    

  461.     //Configure Peripheral On Mode Clock->URT0->Select URT0_PR Source = CK_APB(11.0592)
    

  462.     
    

  463.     //==Set GPIO init
    

  464.     //MG32x02z_GPIO_Init.h(Configuration Wizard)->Use GPIOB->Pin8/9
    

  465.     //GPIO port initial is 0xFFFF
    

  466.     //Pin8 mode is PPO/Pin9 mode is ODO
    

  467.     //Pin8/9 pull-up resister Enable
    

  468.     //Pin8/9 function URT0_TX/RX
    

  469.           PINX_InitStruct.PINX_Mode                                 = PINX_Mode_PushPull_O;                  // Pin select Push Pull mode
    

  470.         PINX_InitStruct.PINX_PUResistant                 = PINX_PUResistant_Enable;          // Enable pull up resistor
    

  471.         PINX_InitStruct.PINX_Speed                                   = PINX_Speed_Low;                         
    

  472.         PINX_InitStruct.PINX_OUTDrive                         = PINX_OUTDrive_Level0;                 // Pin output driver full strength.
    

  473.         PINX_InitStruct.PINX_FilterDivider                   = PINX_FilterDivider_Bypass;        // Pin input deglitch filter clock divider bypass
    

  474.         PINX_InitStruct.PINX_Inverse                         = PINX_Inverse_Disable;                 // Pin input data not inverse
    

  475.         PINX_InitStruct.PINX_Alternate_Function  = 3;                                // Pin AFS = URT0_TX
    

  476.         GPIO_PinMode_Config(PINB(8),&PINX_InitStruct);                                                          // TXD at PB8
    


  477. 

  478.         PINX_InitStruct.PINX_Mode                                 = PINX_Mode_OpenDrain_O;                 // Pin select Open Drain mode
    

  479.         PINX_InitStruct.PINX_Alternate_Function  = 3;                                // Pin AFS = URT0_RX
    

  480.         GPIO_PinMode_Config(PINB(9),&PINX_InitStruct);                                                          // RXD at PB9  
    

  481.         
    

  482.         
    

  483.     
    

  484.     //=====Set Clock=====//
    

  485.     //---Set BaudRate---//
    

  486.     URT_BRG.URT_InteranlClockSource = URT_BDClock_PROC;
    

  487.     URT_BRG.URT_BaudRateMode = URT_BDMode_Separated;
    

  488.     URT_BRG.URT_PrescalerCounterReload = 0;                        //Set PSR
    

  489.     URT_BRG.URT_BaudRateCounterReload = 3;                        //Set RLR
    

  490.     URT_BaudRateGenerator_Config(URTX, &URT_BRG);                    //BR115200 = f(CK_URTx)/(PSR+1)/(RLR+1)/(OS_NUM+1)
    

  491.     URT_BaudRateGenerator_Cmd(URTX, ENABLE);                    //Enable BaudRateGenerator
    

  492.     //---TX/RX Clock---//
    

  493.     URT_TXClockSource_Select(URTX, URT_TXClock_Internal);        //URT_TX use BaudRateGenerator
    

  494.     URT_RXClockSource_Select(URTX, URT_RXClock_Internal);        //URT_RX use BaudRateGenerator
    

  495.     URT_TXOverSamplingSampleNumber_Select(URTX, 25);                //Set TX OS_NUM
    

  496.     URT_RXOverSamplingSampleNumber_Select(URTX, 25);                //Set RX OS_NUM
    

  497.     URT_RXOverSamplingMode_Select(URTX, URT_RXSMP_3TIME);
    

  498.     URT_TX_Cmd(URTX, ENABLE);                                    //Enable TX
    

  499.     URT_RX_Cmd(URTX, ENABLE);                                    //Enable RX
    

  500.     
    

  501.     
    


  502. 

  503.     //=====Set Mode=====//
    

  504.     //---Set Data character config---//
    

  505.     DataDef.URT_TX_DataLength  = URT_DataLength_8;
    

  506.     DataDef.URT_RX_DataLength  = URT_DataLength_8;
    

  507.     DataDef.URT_TX_DataOrder   = URT_DataTyped_LSB;
    

  508.     DataDef.URT_RX_DataOrder   = URT_DataTyped_LSB;
    

  509.     DataDef.URT_TX_Parity      = URT_Parity_No;
    

  510.     DataDef.URT_RX_Parity      = URT_Parity_No;
    

  511.     DataDef.URT_TX_StopBits    = URT_StopBits_1_0;
    

  512.     DataDef.URT_RX_StopBits    = URT_StopBits_1_0;
    

  513.     DataDef.URT_TX_DataInverse = DISABLE;
    

  514.     DataDef.URT_RX_DataInverse = DISABLE;
    

  515.     URT_DataCharacter_Config(URTX, &DataDef);
    

  516.     //---Set Mode Select---//
    

  517.     URT_Mode_Select(URTX, URT_URT_mode);
    

  518.     //---Set DataLine Select---//
    

  519.     URT_DataLine_Select(URTX, URT_DataLine_2);
    

  520.     
    

  521.     //=====Set Error Control=====//
    

  522.     // to do...
    

  523.     
    

  524.     //=====Set Bus Status Detect Control=====//
    

  525.     // to do...
    

  526.     
    

  527.     //=====Set Data Control=====//
    

  528.     URT_RXShadowBufferThreshold_Select(URTX, URT_RXTH_1BYTE);
    

  529.     URT_IdlehandleMode_Select(URTX, URT_IDLEMode_No);
    

  530.     URT_TXGaudTime_Select(URTX, 0);
    

  531.     
    

  532.     //=====Enable URT Interrupt=====//
    

  533.     URT_IT_Cmd(URTX, URT_IT_RX, ENABLE);
    

  534.     URT_ITEA_Cmd(URTX, ENABLE);
    

  535.     NVIC_EnableIRQ(URT0_IRQn);
    


  536. 

  537.     //=====Enable URT=====//
    

  538.     URT_Cmd(URTX, ENABLE);
    

  539.                 
    

  540.         //==See MG32x02z_URT0_IRQ.c when interrupt in
    

  541. }
    


  542. 

  543. int fputc(int ch,FILE *f)
    

  544. {
    

  545.         
    

  546.         URT_SetTXData(URTX,1,ch);
    

  547.         while(URT_GetITSingleFlagStatus(URTX,URT_IT_TC)==DRV_UnHappened);
    

  548.         URT_ClearITFlag(URTX,URT_IT_TC);
    

  549.         
    

  550.         return ch;
    

  551. }
    


  552. 

  553. void UartSendByte(int ch)
    

  554. {
    

  555.         
    

  556.         URT_SetTXData(URTX,1,ch);
    

  557.         while(URT_GetITSingleFlagStatus(URTX,URT_IT_TC)==DRV_UnHappened);
    

  558.         URT_ClearITFlag(URTX,URT_IT_TC);
    

  559.         
    

  560. }
    


  561. 

  562. void DMA_Init(void)
    

  563. {
    

  564.          DMA_BaseInitTypeDef DMATestPattern;
    


  565. 

  566.     // ------------------------------------------------------------------------
    

  567.     // 1.Enable DMA
    

  568.     DMA_Cmd(ENABLE);
    

  569.     
    

  570.     // ------------------------------------------------------------------------
    

  571.     // 2.Enable Channel0
    

  572.     DMA_Channel_Cmd(DMAChannel0, ENABLE);
    

  573.     
    

  574.     // ------------------------------------------------------------------------
    

  575.     DMA_BaseInitStructure_Init(&DMATestPattern);
    

  576.     
    

  577.     // 3.initial & modify parameter
    

  578.        
    

  579.         // DMA channel select
    

  580.         DMATestPattern.DMAChx = DMAChannel0;
    

  581.         
    

  582.         // channel x source/destination auto increase address
    

  583.         DMATestPattern.SrcSINCSel = ENABLE;
    

  584.         DMATestPattern.DestDINCSel = DISABLE;
    

  585.         
    

  586.         // DMA source peripheral config
    

  587.         DMATestPattern.SrcSymSel = DMA_MEM_Read;
    

  588.         
    

  589.         // DMA destination peripheral config
    

  590.         DMATestPattern.DestSymSel = DMA_SPI0_TX;
    

  591.         
    

  592.         // DMA Burst size config
    

  593.         DMATestPattern.BurstDataSize = DMA_BurstSize_1Byte;
    

  594.         
    

  595.         // DMA transfer data count initial number
    

  596.         DMATestPattern.DMATransferNUM = MYBINARYIMAGE2_LENGTH;
    

  597.     
    

  598.         // source/destination config
    

  599.         DMATestPattern.DMASourceAddr = (uint32_t *)&SendBuf;
    

  600.         DMATestPattern.DMADestinationAddr = &SPI0->TDAT;//DMA_URT0_TX;// (uint8_t *)&RcvBuf;
    

  601.                                 
    

  602.                                 SPI_DMASend_Cmd(SPI0, ENABLE);
    

  603.                                 DMA_Channel_Cmd(DMAChannel0, ENABLE);
    

  604.                                 DMA_Base_Init(&DMATestPattern);
    

  605. }
    


  606. 

  607. void I2C0_IRQHandler(void)
    

  608. {
    

  609.            
    

  610.         char RxData=0;
    

  611.     if(I2C_GetFlagStatus(I2C0, I2C_FLAG_EVENTF))
    

  612.     {
    

  613.         // I2C status event interrupt.
    

  614.         // to do..
    

  615.         switch(I2C_GetEventCode(I2C0)){
    

  616.             case 0x00:  // Bus error during MASTER or selected slave modes, due to an illegal START or STOP condition. State 0x00 can also occur when interference causes the I2C block to enter an undefined state.
    

  617.                     // to do..
    

  618.                 
    


  619. 

  620.             case 0x08:  // A START condition has been transmitted.
    

  621.                     // to do..
    

  622.                
    


  623. 

  624.             case 0x10:  // A repeated START condition has been transmitted.
    

  625.                     // to do..
    

  626.              
    


  627. 

  628.             case 0x18:  // SLA+W has been transmitted; ACK has been received.
    

  629.                     // to do..
    

  630.                
    


  631. 

  632.             case 0x20:  // SLA+W has been transmitted; NOT ACK has been received.
    

  633.                     // to do..
    

  634.               
    


  635. 

  636.             case 0x28:  // Data byte in DAT has been transmitted; ACK has been received.
    

  637.                     // to do..
    

  638.                
    


  639. 

  640.             case 0x30:  // Data byte in DAT has been transmitted; NOT ACK has been received.
    

  641.                     // to do..
    

  642.                 
    


  643. 

  644.             case 0x38:  // Arbitration lost in SLA+R/W or Data bytes.
    

  645.                     // to do..
    

  646.                
    


  647. 

  648.             case 0x40:  // SLA+R has been transmitted; ACK has been received.
    

  649.                     // to do..
    

  650.               
    


  651. 

  652.             case 0x48:  // SLA+R has been transmitted; NOT ACK has been received.
    

  653.                     // to do..
    

  654.                
    


  655. 

  656.             case 0x50:  // Data byte has been received; ACK has been returned.
    

  657.                     // to do..
    

  658.                 
    


  659. 

  660.             case 0x58:  // Data byte has been received; NOT ACK has been returned.
    

  661.               break;      // to do..
    

  662.               
    


  663. 

  664.             case 0x60:  // Own SLA+W has been received; ACK has been returned.
    

  665.                     // to do..
    

  666.                 
    


  667. 

  668.             case 0x68:  // Arbitration lost in SLA+R/W as master; Own SLA+W has been received, ACK returned.
    

  669.                 break;    // to do..
    

  670.                
    


  671. 

  672.             case 0x70:  // General Call address (0x00) has been received; ACK has been returned.
    

  673.                     // to do..
    

  674.                 
    


  675. 

  676.             case 0x78:  // Arbitration lost in SLA+R/W as master; General Call address has been received, ACK has been returned.
    

  677.                break;     // to do..
    

  678.                
    


  679. 

  680.             case 0x80:  // Previously addressed with own SLA address; DATA has been received; ACK has been returned.
    

  681.                     // to do..
    

  682.                
    


  683. 

  684.             case 0x88:  // Previously addressed with own SLA; DATA byte has been received; NOT ACK has been returned.
    

  685.            
    

  686.                                                 RxData=I2C_ReceiveSBUF(I2C0);
    

  687.                                                 printf("%c\n",RxData); // to do..
    

  688.                 break;
    


  689. 

  690.             case 0x90:  // Previously addressed with General Call; DATA byte has been received; ACK has been returned.
    

  691.                     // to do..
    

  692.                
    


  693. 

  694.             case 0x98:  // Previously addressed with General Call; DATA byte has been received; NOT ACK has been returned.
    

  695.                     // to do..
    

  696.                
    


  697. 

  698.             case 0xA0:  // A STOP condition or condition has been received while still addressed as Slave Receiver or Slave Transmitter.
    

  699.                 break;    // to do..
    

  700.                
    


  701. 

  702.             case 0xA8:  // Own SLA+R has been received; ACK has been returned.
    

  703.                  
    

  704.                                                 I2C_SendSBUF(I2C0,0x66); // to do..
    

  705.                 
    


  706. 

  707.             case 0xB0:  // Arbitration lost in SLA+R/W as master; Own SLA+R has been received, ACK has been returned.
    

  708.                     // to do..
    

  709.                 
    


  710. 

  711.             case 0xB8:  // Data byte in DAT has been transmitted; ACK has been received.
    

  712.                     // to do..
    

  713.               
    


  714. 

  715.             case 0xC0:  // Data byte in DAT has been transmitted; NOT ACK has been received.
    

  716.                     // to do..
    

  717.                
    


  718. 

  719.             case 0xC8:  // Last data byte in DAT has been transmitted (AA = 0); ACK has been received.
    

  720.                 break;    // to do..
    

  721.              
    


  722. 

  723.             case 0xF8:  // No relevant state information available; Bus is released ; EVENTF = 0 and no interrupt asserted.(Default)
    

  724.                     // to do..
    

  725.                 break;
    

  726.         }
    

  727.         // to do..
    

  728.         I2C_ClearFlag(I2C0, I2C_FLAG_EVENTF);
    

  729.     }
    

  730.         
    

  731. }
    


  732. 


  733. 


  734. 

  735. int main()
    

  736. {
    

  737.         u32 i;
    

  738.         
    

  739.         PIN_InitTypeDef PINX_InitStruct;
    

  740.         CSC_Init();
    

  741.         PINX_InitStruct.PINX_Mode                                 = PINX_Mode_PushPull_O;          // Pin select digital input mode
    

  742.         PINX_InitStruct.PINX_PUResistant                 = PINX_PUResistant_Enable;  // Enable pull up resistor
    

  743.         PINX_InitStruct.PINX_Speed                                   = PINX_Speed_Low;                         
    

  744.         PINX_InitStruct.PINX_OUTDrive                         = PINX_OUTDrive_Level0;         // Pin output driver full strength.
    

  745.         PINX_InitStruct.PINX_FilterDivider                   = PINX_FilterDivider_Bypass;// Pin input deglitch filter clock divider bypass
    

  746.         PINX_InitStruct.PINX_Inverse                         = PINX_Inverse_Disable;         // Pin input data not inverse
    

  747.         PINX_InitStruct.PINX_Alternate_Function = 0;                                                 // Pin AFS = 0
    

  748.         GPIO_PinMode_Config(PINE(15),&PINX_InitStruct);                                          // D6 setup at PE15
    

  749.         Sample_URT0_Init();
    

  750.         printf("hello\n");
    

  751.         NVIC_EnableIRQ(I2C0_IRQn);
    

  752.         I2C0_ByteMode_Slave_Init();
    

  753.         
    

  754.         i=0;
    

  755.     while(1)
    

  756.     {
    

  757.                    
    

  758.             i++;
    

  759.             if(i>=500000)
    

  760.             {
    

  761.                                 i=0;
    

  762.                                 PE15=~PE15;                                
    

  763.                         }
    

  764.     }
    


  765. 

  766.                 
    

  767. }


回复

收藏 举报

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

本版积分规则

noctor

26

主题

82

帖子

3

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