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

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

[复制链接]
1581|0
 楼主| noctor 发表于 2018-11-20 13:08 | 显示全部楼层 |阅读模式
iic, 学习笔记, I2c, pi
     上回我们说到了MG32F02A的UART0 SPI的使用。帖子详情：https://bbs.21ic.com/icview-2586596-1-1.html

      突然发现原来IIC还没挂上来。。
由于代码比较多，就先只挂主机的吧：
复制

  1. 

  2. #include "MG32x02z_DRV.H"
    

  3. #include "iic.h"
    

  4. #include <stdio.h>
    

  5. #include "MG32x02z_I2C_DRV.h"
    


  6. 

  7. I2C_Struct* I2Cx;
    


  8. 

  9. typedef uint8_t u8;
    

  10. typedef uint16_t u16;
    

  11. typedef uint32_t u32;
    

  12. typedef uint64_t u64;
    


  13. 

  14. #define URTX URT0
    

  15. #define MYBINARYIMAGE2_LENGTH 20
    


  16. 

  17. I2C_HandleTypeDef gSI2C0_Handle;
    

  18. I2C_HandleTypeDef gSI2C1_Handle;
    


  19. 

  20. uint8_t SendBuf[MYBINARYIMAGE2_LENGTH]={0};
    

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

  22. uint8_t lDataBuffer[80];
    


  23. 

  24. void SysTick_Handler(void)
    

  25. {
    

  26.     //to do......
    

  27.         IncTick();
    

  28. }
    


  29. 

  30. void CSC_Init (void)
    

  31. {
    

  32.         CSC_PLL_TyprDef CSC_PLL_CFG;
    

  33.     
    

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

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

  36.   ProtectModuleReg(MEMprotect);
    


  37. 

  38.   UnProtectModuleReg(CSCprotect);
    

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

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


  41. 

  42.         
    

  43.         /* CK_HS selection */
    

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

  45.         CSC_IHRCO_Cmd(ENABLE);
    

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

  47.         CSC_ClearFlag(CSC_IHRCOF);
    

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


  49. 


  50. 

  51.         /* PLL */
    

  52.         /**********************************************************/
    

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

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

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

  56.         CSC_PLL_Config(&CSC_PLL_CFG);
    

  57.         CSC_PLL_Cmd(ENABLE);
    

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

  59.         CSC_ClearFlag(CSC_PLLF);
    

  60.         /**********************************************************/
    


  61. 

  62.         
    

  63.         /* CK_MAIN */ 
    

  64.         CSC_CK_MAIN_Select(MAIN_CK_HS);        
    


  65. 


  66. 

  67.         /* Configure ICKO function */
    

  68.                 
    

  69.         /* Configure peripheral clock */
    

  70.         CSC_PeriphProcessClockSource_Config(CSC_I2C0_CKS, CK_APB);
    

  71.         CSC_PeriphProcessClockSource_Config(CSC_UART0_CKS, CK_APB);
    

  72.          CSC_PeriphOnModeClock_Config(CSC_ON_I2C0,ENABLE);
    

  73.         CSC_PeriphOnModeClock_Config(CSC_ON_UART0,ENABLE);
    

  74.          CSC_PeriphOnModeClock_Config(CSC_ON_PortB,ENABLE);
    

  75.         CSC_PeriphOnModeClock_Config(CSC_ON_PortE,ENABLE);
    

  76.         
    

  77.   ProtectModuleReg(CSCprotect);
    

  78.     
    

  79. }
    


  80. 


  81. 

  82. void I2C0_ByteMode_Master_Init(void)
    

  83. {
    

  84.     I2C_InitTypeDef SI2C0_Init;
    


  85. 

  86.     SI2C0_Init.Instance = I2C0;
    

  87.     SI2C0_Init.CK_I2C_PR_Frequency = 12000000;
    

  88.     SI2C0_Init.SCL_Clock = 400000;    
    

  89.     I2C_ByteMode_Init(&SI2C0_Init);
    


  90. 

  91.     gSI2C0_Handle.Instance = I2C0;
    

  92.     printf("I2C_IsDeviceReady\n\r");
    

  93.         
    

  94.                                 
    

  95. }
    


  96. 

  97. DRV_Return I2C_ByteMode_Init(I2C_InitTypeDef *SI2C)
    

  98. {
    


  99. 

  100.     uint16_t lI2C_Pre = 1;
    

  101.     uint16_t lI2C_DIV = 1;
    

  102.     uint16_t lI2C_HT_LT = 0;
    

  103.     uint16_t lI2C_LT;
    

  104.     uint16_t lI2C_HT;
    

  105.                 PIN_InitTypeDef PINX_InitStruct;
    

  106.     //===== Check I2C Busy =====//
    

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

  108.         return DRV_Busy;
    


  109. 

  110.     __I2C_Disable(SI2C->Instance);
    


  111. 

  112.     //===== GPIO Initial =====//
    

  113.       //===== CSC for GPIO Config =====//
    

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

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


  116. 

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


  118. 

  119. //      //===== GPIO Config =====//
    

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

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

  122.     PINX_InitStruct.PINX_Speed              = PINX_Speed_High;           
    

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

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

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

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


  127. 

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

  129.     {
    

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

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


  132. 

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

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


  135. 

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

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


  138. 

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

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


  141. 

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

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

  144.     }
    


  145. 

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

  147.     {
    

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

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


  150. 

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

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


  153. 

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

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

  156.     }
    


  157. 

  158.     //===== I2C Initial =====//
    

  159.       //=== CSC for I2C Config ===//
    

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

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

  162.                         
    

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

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

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

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


  167. 

  168.       //=== I2C Config ===//
    

  169.     //===== I2C Output Clock Config =====//
    

  170.     // CK_I2C_PR
    

  171.     // SCL Output Clock
    

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


  173. 

  174.     do{
    

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

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

  177.         {
    

  178.             lI2C_Pre ++;
    

  179.             if(lI2C_Pre > 8)
    

  180.             {
    

  181.                 lI2C_Pre = 1;
    

  182.                 lI2C_DIV ++;
    

  183.             }
    

  184.         }
    

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


  186. 

  187.     lI2C_LT = (lI2C_HT_LT >> 1);
    

  188.     lI2C_HT = lI2C_HT_LT - lI2C_LT;
    


  189. 

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

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

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

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

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


  195. 

  196.     //===== I2C Opration Mode Config =====//
    

  197.     __I2C_GeneralCallAddress_Disable(SI2C->Instance);
    

  198.     __I2C_SlaveAddressDetect_Disable(SI2C->Instance, (I2C_SADR_1 | I2C_SADR_2));
    

  199.     
    

  200.     //===== I2C Interrupt Config =====//
    

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

  202.     {
    

  203.         NVIC_EnableIRQ(I2C0_IRQn);
    

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

  205.                                                                                 //           Other Priority > 0
    

  206.     }
    


  207. 

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

  209.     {
    

  210.         NVIC_EnableIRQ(I2Cx_IRQn);
    

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

  212.                                                                                 //           Other Priority > 0
    

  213.     }
    


  214. 

  215.     __I2C_ITEA_Disable(SI2C->Instance);
    

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

  217.                 
    


  218. 


  219. 

  220.     //===== I2C Timeout Config =====//
    

  221.     __I2C_TMO_Disable(SI2C->Instance);
    

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

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

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


  225. 

  226.     //===== I2C Enable =====//
    

  227.     __I2C_Enable(SI2C->Instance);
    

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

  229.     return DRV_Success;
    

  230. }
    


  231. 

  232. void I2C_Delay(uint32_t Delay)
    

  233. {
    


  234. 

  235.         
    

  236. }
    


  237. 

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

  239. {
    

  240. //-----Check I2C Busy ------------------
    

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

  242.         return DRV_Busy;
    


  243. 

  244. //-----Set_Config-----------------------
    

  245.     SI2C->State.W = 0;
    

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

  247.     SI2C->pData = 0x00000000;
    

  248.     SI2C->Count = 0;
    

  249.     SI2C->Control.W = I2C_XferNext_STOP;
    


  250. 

  251. //-----Start----------------------------
    

  252.     do{
    

  253.         SI2C->State.W = 0;
    

  254.         Set_STA_STO_AA_100(SI2C->Instance);
    

  255.         do{
    

  256.             I2C_ByteMode_Handle(SI2C);
    

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


  258. 

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

  260.                                    I2C_State_ArbitrationLost | \
    

  261.                                    I2C_State_NACK)) == 0)
    

  262.             return DRV_Success;
    


  263. 

  264.         I2C_Delay(1);
    

  265.         
    

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


  267. 

  268.     return DRV_Failure;
    

  269. }
    


  270. 

  271. void I2C_ByteMode_Handle(I2C_HandleTypeDef *SI2C)
    

  272. {
    

  273.     uint8_t lState;
    


  274. 

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

  276.         return;
    


  277. 

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

  279.     switch(lState){
    

  280.         case 0x00:  // Bus Error 
    

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

  282.                                    I2C_State_Done;;
    

  283.             break;
    


  284. 

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

  286.         case 0x10:  // Repeated start condition
    

  287.             Set_STA_STO_AA_000(SI2C->Instance);
    

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

  289.             break;
    


  290. 

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

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

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

  294.             {
    

  295.                 Set_STA_STO_AA_010(SI2C->Instance);
    

  296.                 __I2C_ClearStateFlag(SI2C->Instance);
    

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

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

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

  300.                 return;
    

  301.             }
    

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

  303.             SI2C->pData ++;
    

  304.             SI2C->Count --;
    

  305.             break;
    


  306. 

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

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

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

  310.             Set_STA_STO_AA_010(SI2C->Instance);
    

  311.             __I2C_ClearStateFlag(SI2C->Instance);
    

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

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

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

  315.                                    I2C_State_Done;
    

  316.             return;
    


  317. 

  318.         case 0x38:  // Arbitration lost
    

  319.             Set_STA_STO_AA_000(SI2C->Instance);
    

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

  321.                                    I2C_State_Done;
    

  322.             break;
    


  323. 

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

  325.             Set_STA_STO_AA_001(SI2C->Instance);
    

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

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

  328.                 Set_STA_STO_AA_000(SI2C->Instance);
    

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

  330.             SI2C->Count--;
    

  331.             SI2C->pData++;
    

  332.             break;
    


  333. 

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

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

  336.                 Set_STA_STO_AA_100(SI2C->Instance);
    

  337.             else
    

  338.                 Set_STA_STO_AA_010(SI2C->Instance);
    


  339. 

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

  341.             break;
    


  342. 

  343. //-------------------------------------
    

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


  345. 

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

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


  348. 

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


  350. 

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

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


  353. 

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


  355. 

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


  357. 

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

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


  360. 

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

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


  363. 

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


  365. 

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


  367. 

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

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


  370. 

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


  372. 

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


  374. 

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


  376. 

  377.         case 0xD0: 
    

  378.         case 0xD8:
    

  379.         case 0xE0:
    

  380.         case 0xE8:
    

  381.         case 0xF0:
    

  382.                     
    

  383.         case 0xF8:  // Bus Idle
    


  384. 

  385.         default:
    

  386.             break;
    

  387.     }
    

  388.     __I2C_ClearStateFlag(SI2C->Instance);
    

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

  390. }
    


  391. 

  392. DRV_Return I2C_ByteMode_MasterTransmit(I2C_HandleTypeDef *SI2C, uint16_t DevAddress, uint8_t *pData, uint16_t Lenth)
    

  393. {
    

  394. //-----Check----------------------------
    

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

  396.         return DRV_Busy;
    


  397. 

  398. //-----Set_Config-----------------------
    

  399.     SI2C->State.W = 0;
    

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

  401.     SI2C->pData = pData;
    

  402.     SI2C->Count = Lenth;
    

  403.     SI2C->Control.W = I2C_XferNext_STOP;
    


  404. 

  405. //-----Start----------------------------
    

  406.     Set_STA_STO_AA_100(SI2C->Instance);
    

  407.     do{
    

  408.         I2C_ByteMode_Handle(SI2C);
    

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


  410. 

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

  412.                                I2C_State_ArbitrationLost | \
    

  413.                                I2C_State_NACK)) != 0)
    

  414.         return DRV_Failure;
    


  415. 

  416.     return DRV_Success;
    

  417. }
    


  418. 

  419. DRV_Return I2C_ByteMode_MasterReceive(I2C_HandleTypeDef *SI2C, uint16_t DevAddress, uint8_t *pData, uint16_t Lenth)
    

  420. {
    

  421. //-----Check----------------------------
    

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

  423.         return DRV_Busy;
    


  424. 

  425. //-----Set_Config-----------------------
    

  426.     SI2C->State.W = 0;
    

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

  428.     SI2C->pData = pData;
    

  429.     SI2C->Count = Lenth;
    

  430.     SI2C->Control.W = I2C_XferNext_STOP;
    


  431. 

  432. //-----Start----------------------------
    

  433.     Set_STA_STO_AA_100(SI2C->Instance);
    

  434.     do{
    

  435.         I2C_ByteMode_Handle(SI2C);
    

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


  437. 

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

  439.                                I2C_State_ArbitrationLost | \
    

  440.                                I2C_State_NACK)) != 0)
    

  441.         return DRV_Failure;
    


  442. 

  443.     return DRV_Success;
    

  444.                 
    

  445. }
    


  446. 

  447. void Sample_URT0_Init(void)
    

  448. {
    

  449.     URT_BRG_TypeDef  URT_BRG;
    

  450.     URT_Data_TypeDef DataDef;
    

  451.             PIN_InitTypeDef PINX_InitStruct;
    

  452.     //==Set CSC init
    

  453.     //MG32x02z_CSC_Init.h(Configuration Wizard)
    

  454.     //Select CK_HS source = CK_IHRCO
    

  455.     //Select IHRCO = 11.0592M
    

  456.     //Select CK_MAIN Source = CK_HS
    

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

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

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

  460.     
    

  461.     //==Set GPIO init
    

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

  463.     //GPIO port initial is 0xFFFF
    

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

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

  466.     //Pin8/9 function URT0_TX/RX
    

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

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

  469.         PINX_InitStruct.PINX_Speed                                   = PINX_Speed_Low;                         
    

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

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

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

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

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


  475. 

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

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

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

  479.         
    

  480.         
    

  481.     
    

  482.     //=====Set Clock=====//
    

  483.     //---Set BaudRate---//
    

  484.     URT_BRG.URT_InteranlClockSource = URT_BDClock_PROC;
    

  485.     URT_BRG.URT_BaudRateMode = URT_BDMode_Separated;
    

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

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

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

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

  490.     //---TX/RX Clock---//
    

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

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

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

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

  495.     URT_RXOverSamplingMode_Select(URTX, URT_RXSMP_3TIME);
    

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

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

  498.     
    

  499.     
    


  500. 

  501.     //=====Set Mode=====//
    

  502.     //---Set Data character config---//
    

  503.     DataDef.URT_TX_DataLength  = URT_DataLength_8;
    

  504.     DataDef.URT_RX_DataLength  = URT_DataLength_8;
    

  505.     DataDef.URT_TX_DataOrder   = URT_DataTyped_LSB;
    

  506.     DataDef.URT_RX_DataOrder   = URT_DataTyped_LSB;
    

  507.     DataDef.URT_TX_Parity      = URT_Parity_No;
    

  508.     DataDef.URT_RX_Parity      = URT_Parity_No;
    

  509.     DataDef.URT_TX_StopBits    = URT_StopBits_1_0;
    

  510.     DataDef.URT_RX_StopBits    = URT_StopBits_1_0;
    

  511.     DataDef.URT_TX_DataInverse = DISABLE;
    

  512.     DataDef.URT_RX_DataInverse = DISABLE;
    

  513.     URT_DataCharacter_Config(URTX, &DataDef);
    

  514.     //---Set Mode Select---//
    

  515.     URT_Mode_Select(URTX, URT_URT_mode);
    

  516.     //---Set DataLine Select---//
    

  517.     URT_DataLine_Select(URTX, URT_DataLine_2);
    

  518.     
    

  519.     //=====Set Error Control=====//
    

  520.     // to do...
    

  521.     
    

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

  523.     // to do...
    

  524.     
    

  525.     //=====Set Data Control=====//
    

  526.     URT_RXShadowBufferThreshold_Select(URTX, URT_RXTH_1BYTE);
    

  527.     URT_IdlehandleMode_Select(URTX, URT_IDLEMode_No);
    

  528.     URT_TXGaudTime_Select(URTX, 0);
    

  529.     
    

  530.     //=====Enable URT Interrupt=====//
    

  531.     URT_IT_Cmd(URTX, URT_IT_RX, ENABLE);
    

  532.     URT_ITEA_Cmd(URTX, ENABLE);
    

  533.     NVIC_EnableIRQ(URT0_IRQn);
    


  534. 

  535.     //=====Enable URT=====//
    

  536.     URT_Cmd(URTX, ENABLE);
    

  537.                 
    

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

  539. }
    


  540. 

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

  542. {
    

  543.         
    

  544.         URT_SetTXData(URTX,1,ch);
    

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

  546.         URT_ClearITFlag(URTX,URT_IT_TC);
    

  547.         
    

  548.         return ch;
    

  549. }
    


  550. 

  551. void UartSendByte(int ch)
    

  552. {
    

  553.         
    

  554.         URT_SetTXData(URTX,1,ch);
    

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

  556.         URT_ClearITFlag(URTX,URT_IT_TC);
    

  557.         
    

  558. }
    


  559. 

  560. void DMA_Init(void)
    

  561. {
    

  562.          DMA_BaseInitTypeDef DMATestPattern;
    


  563. 

  564.     // ------------------------------------------------------------------------
    

  565.     // 1.Enable DMA
    

  566.     DMA_Cmd(ENABLE);
    

  567.     
    

  568.     // ------------------------------------------------------------------------
    

  569.     // 2.Enable Channel0
    

  570.     DMA_Channel_Cmd(DMAChannel0, ENABLE);
    

  571.     
    

  572.     // ------------------------------------------------------------------------
    

  573.     DMA_BaseInitStructure_Init(&DMATestPattern);
    

  574.     
    

  575.     // 3.initial & modify parameter
    

  576.        
    

  577.         // DMA channel select
    

  578.         DMATestPattern.DMAChx = DMAChannel0;
    

  579.         
    

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

  581.         DMATestPattern.SrcSINCSel = ENABLE;
    

  582.         DMATestPattern.DestDINCSel = DISABLE;
    

  583.         
    

  584.         // DMA source peripheral config
    

  585.         DMATestPattern.SrcSymSel = DMA_MEM_Read;
    

  586.         
    

  587.         // DMA destination peripheral config
    

  588.         DMATestPattern.DestSymSel = DMA_SPI0_TX;
    

  589.         
    

  590.         // DMA Burst size config
    

  591.         DMATestPattern.BurstDataSize = DMA_BurstSize_1Byte;
    

  592.         
    

  593.         // DMA transfer data count initial number
    

  594.         DMATestPattern.DMATransferNUM = MYBINARYIMAGE2_LENGTH;
    

  595.     
    

  596.         // source/destination config
    

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

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

  599.                                 
    

  600.                                 SPI_DMASend_Cmd(SPI0, ENABLE);
    

  601.                                 DMA_Channel_Cmd(DMAChannel0, ENABLE);
    

  602.                                 DMA_Base_Init(&DMATestPattern);
    

  603. }
    


  604. 


  605. 

  606. int main()
    

  607. {
    

  608.         u32 i;
    

  609.         char RxData;
    

  610.         uint8_t AddrTemp;
    

  611.         PIN_InitTypeDef PINX_InitStruct;
    

  612.         CSC_Init();
    

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

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

  615.         PINX_InitStruct.PINX_Speed                                   = PINX_Speed_Low;                         
    

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

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

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

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

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

  621.         Sample_URT0_Init();
    

  622.         printf("hello\n");
    

  623.         I2C0_ByteMode_Master_Init();
    

  624.         i=0;
    

  625.     while(1)
    

  626.     {
    

  627.                    
    

  628.             i++;
    

  629.             if(i>=500000)
    

  630.             {
    

  631.                                 i=0;
    

  632.                                 PE15=0;
    


  633. 

  634.       if(I2C_IsDeviceReady(&gSI2C0_Handle, 0xA0, 10) != DRV_Success)
    

  635.       printf("Target device is not ready\n\r");
    


  636. 

  637.                   if(I2C_ByteMode_MasterTransmit(&gSI2C0_Handle, 0xA0, (uint8_t *)String0, (sizeof(String0)-1)) != DRV_Success)
    

  638.       printf("Mater transmited data fail\n\r");
    

  639.                                 
    

  640.                         if(I2C_ByteMode_MasterReceive(&gSI2C0_Handle, (uint16_t)0xA0, (uint8_t *)lDataBuffer, (sizeof(String0)-1)) != DRV_Success)
    

  641.       printf("Mater received data fail\n\r");
    

  642.                                 RxData=I2C_ReceiveSBUF(I2C0);
    

  643.                                 printf("receive:0x%02X\n",RxData);
    

  644.                 PE15=1;                        
    

  645.                         }
    

  646.     }
    

  647. }
    


  648.


回复

收藏 举报

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

本版积分规则

noctor

26

主题

82

帖子

3

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