21ic电子技术开发论坛 › 单片机与嵌入式系统 › 国民技术MCU › N32G430 评测
返回列表 发新帖我要提问

[N32G430] N32G430 评测

[复制链接]
 楼主| 一路向北lm 发表于 2024-4-23 08:48 | 显示全部楼层 |阅读模式
ni, GPIO, gp, IO, pi, N32G430
本帖最后由 一路向北lm 于 2024-4-24 18:54 编辑

拿到了N32G430开发板已经有一段时间了，由于最近一段时间经历离职/换工作，一直没有开箱评测，最近几天有空，给大家做一个分享汇报。

1.芯片功能：
       N32G430系列采用32-bit Arm® Cortex®-M4F内核，最高工作主频128MHz，支持浮点运算和DSP指令，集成高达 64KB嵌入式加密Flash，16KB SRAM，集成丰富的高性能模拟器件，内置1个12bit 4.7Msps ADC，3个高速比较 器，集成多路U(S)ART、I²C、SPI、CAN等数字通信接口。

2.资料下载：
国民技术官网：https://www.nationstech.com/zlxz369/

3.gpio-led 测试
复制
  1. void LED_Initialize(GPIO_Module* GPIOx, uint16_t pin)
    

  2. {
    

  3.         GPIO_InitType GPIO_InitStructure;
    

  4.         if(GPIOx == GPIOA)
    

  5.         {
    

  6.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOA);
    

  7.         }
    

  8.         else if(GPIOx == GPIOB)
    

  9.         {
    

  10.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
    

  11.         }
    

  12.         else if(GPIOx == GPIOC)
    

  13.         {
    

  14.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOC);
    

  15.         }
    

  16.         else
    

  17.         {
    

  18.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOD);
    

  19.         }
    

  20.         
    

  21.         if(pin < GPIO_PIN_ALL)
    

  22.         {
    

  23.                 GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  24.                 GPIO_InitStructure.Pin          = pin;
    

  25.                 GPIO_InitStructure.GPIO_Mode    = GPIO_MODE_OUT_PP;
    

  26.                 GPIO_InitStructure.GPIO_Current = GPIO_DS_4MA;
    

  27.                 GPIO_Peripheral_Initialize(GPIOx, &GPIO_InitStructure);
    

  28.         }
    

  29. }
    


  30. 

  31. void LED_Toggle(GPIO_Module* GPIOx, uint16_t pin)
    

  32. {
    

  33.     GPIO_Pin_Toggle(GPIOx, pin);;
    

  34. }
    


  35. 

  36. {
    

  37.     GPIO_Pins_Set(GPIOx, pin);
    

  38. }
    


  39. 

  40. void LED_Off(GPIO_Module* GPIOx,uint16_t pin)
    

  41. {
    

  42.     GPIO_Pins_Reset(GPIOx, pin);
    

  43. }
    


  44. 


  45. 

  46. // mian test
    

  47. int main(void)
    

  48. {
    

  49.         LED_Initialize(LED1_GPIO_PORT, LED1_GPIO_PIN | LED2_GPIO_PIN | LED3_GPIO_PIN);
    

  50.         LED_Off(LED1_GPIO_PORT, LED1_GPIO_PIN | LED2_GPIO_PIN | LED3_GPIO_PIN);     
    

  51.         while(1)
    

  52.         {
    

  53.                 LED_Toggle(LED1_GPIO_PORT, LED1_GPIO_PIN);   
    

  54.                 LED_Toggle(LED2_GPIO_PORT, LED2_GPIO_PIN);
    

  55.                 LED_Toggle(LED3_GPIO_PORT, LED3_GPIO_PIN);
    

  56.                 SysTick_Delay_Ms(1000);
    

  57.         }
    

  58. }
4.gpio-key 测试
复制
  1. void Key_Input_Initialize(GPIO_Module* GPIOx, uint16_t pin)
    

  2. {
    

  3.         GPIO_InitType GPIO_InitStructure;
    

  4.         if(GPIOx == GPIOA)
    

  5.         {
    

  6.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOA);
    

  7.         }
    

  8.         else if(GPIOx == GPIOB)
    

  9.         {
    

  10.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
    

  11.         }
    

  12.         else if(GPIOx == GPIOC)
    

  13.         {
    

  14.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOC);
    

  15.         }
    

  16.         else
    

  17.         {
    

  18.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOD);
    

  19.         }
    

  20.         
    

  21.         if(pin < GPIO_PIN_ALL)
    

  22.         {
    

  23.                 GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  24.                 GPIO_InitStructure.Pin       = pin;
    

  25.                 GPIO_InitStructure.GPIO_Mode = GPIO_MODE_INPUT;
    

  26.                 GPIO_InitStructure.GPIO_Pull = GPIO_PULL_UP;
    

  27.                 /* Initialize GPIO */
    

  28.                 GPIO_Peripheral_Initialize(GPIOx, &GPIO_InitStructure);
    

  29.         }
    

  30. }
    


  31. 

  32. void Key_Input_Initialize(GPIO_Module* GPIOx, uint16_t pin)
    

  33. {
    

  34.         /* Define a structure of type GPIO_InitType */
    

  35.         GPIO_InitType GPIO_InitStructure;
    

  36.         
    

  37.         /* Enable KEY related GPIO peripheral clock */
    

  38.         if(GPIOx == GPIOA)
    

  39.         {
    

  40.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOA);
    

  41.         }
    

  42.         else if(GPIOx == GPIOB)
    

  43.         {
    

  44.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
    

  45.         }
    

  46.         else if(GPIOx == GPIOC)
    

  47.         {
    

  48.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOC);
    

  49.         }
    

  50.         else
    

  51.         {
    

  52.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOD);
    

  53.         }
    

  54.         
    

  55.         if(pin < GPIO_PIN_ALL)
    

  56.         {
    

  57.                 GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  58.                 GPIO_InitStructure.Pin       = pin;
    

  59.                 GPIO_InitStructure.GPIO_Mode = GPIO_MODE_INPUT;
    

  60.                 GPIO_InitStructure.GPIO_Pull = GPIO_PULL_UP;
    

  61.                 GPIO_Peripheral_Initialize(GPIOx, &GPIO_InitStructure);
    

  62.         }
    

  63. }
    


  64. 

  65. // main test
    

  66. int main(void)
    

  67. {
    

  68.         LED_Initialize(LED1_GPIO_PORT, LED1_GPIO_PIN | LED2_GPIO_PIN);
    

  69.         Key_Input_Initialize(KEY3_PORT, KEY3_PIN);
    

  70.         while(1)
    

  71.         {
    

  72.                 if(GPIO_Input_Pin_Data_Get(KEY3_PORT, KEY3_PIN) == PIN_RESET)
    

  73.                 {
    

  74.                         LED_On(LED1_GPIO_PORT, LED1_GPIO_PIN);
    

  75.                         LED_Off(LED2_GPIO_PORT, LED2_GPIO_PIN);
    

  76.                         LED_Off(LED3_GPIO_PORT, LED3_GPIO_PIN);
    

  77.                 }  
    

  78. }
5.timer-gpio-toggle 测试
复制
  1. uint32_t BSTIMClockFrequency = 0;
    


  2. 

  3. void GPIO_Config(void)
    

  4. {
    

  5.     GPIO_InitType GPIO_InitStructure;
    

  6.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  7.     GPIO_InitStructure.Pin = GPIO_PIN_6;
    

  8.     GPIO_InitStructure.GPIO_Mode  = GPIO_MODE_OUT_PP;
    

  9.     GPIO_InitStructure.GPIO_Slew_Rate = GPIO_SLEW_RATE_FAST;
    

  10.     GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
    

  11. }
    


  12. 


  13. 

  14. int main(void)
    

  15. { 
    

  16.     GPIO_Config();
    

  17.     BSTIMClockFrequency = Common_BSTIM_RCC_Initialize(TIM6, RCC_HCLK_DIV4);
    

  18.     Common_TIM_NVIC_Initialize(TIM6_IRQn, ENABLE);
    

  19.     Common_TIM_Base_Initialize(TIM6, 65535, 0);
    

  20.     TIM_Base_Reload_Mode_Set(TIM6, TIM_PSC_RELOAD_MODE_IMMEDIATE);
    

  21.     TIM_Interrupt_Enable(TIM6, TIM_INT_UPDATE);
    

  22.     TIM_On(TIM6);
    

  23. }
    


  24. 


  25. 

  26. void TIM6_IRQHandler(void)
    

  27. {
    

  28.     if (TIM_Interrupt_Status_Get(TIM6, TIM_INT_UPDATE) != RESET)
    

  29.     {
    

  30.         TIM_Interrupt_Status_Clear(TIM6, TIM_INT_UPDATE);
    

  31.         GPIO_Pin_Toggle(GPIOB, GPIO_PIN_6);
    

  32.     }
    

  33. }
6.uart-printf 测试
复制
  1. void GPIO_Configuration(void)
    

  2. {
    

  3.     GPIO_InitType GPIO_InitStructure;
    

  4.     GPIO_Structure_Initialize(&GPIO_InitStructure);    
    


  5. 

  6.     GPIO_InitStructure.Pin            = USARTx_TxPin;
    

  7.     GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    

  8.     GPIO_InitStructure.GPIO_Alternate = USARTx_Tx_GPIO_AF;
    

  9.     GPIO_Peripheral_Initialize(USARTx_GPIO, &GPIO_InitStructure);   
    


  10. 

  11.     GPIO_InitStructure.Pin            = USARTx_RxPin;
    

  12.     GPIO_InitStructure.GPIO_Alternate = USARTx_Rx_GPIO_AF;
    

  13.     GPIO_Peripheral_Initialize(USARTx_GPIO, &GPIO_InitStructure); 
    

  14. }
    


  15. 

  16. void RCC_Configuration(void)
    

  17. {
    

  18.     GPIO_AHBClkCmd(USARTx_GPIO_CLK);
    

  19.     USART_APBxClkCmd(USARTx_CLK);
    

  20. }
    


  21. 

  22. void  UART_Configuration(void)
    

  23. {
    

  24.    USART_InitType USART_InitStructure;
    

  25.     USART_InitStructure.BaudRate            = 115200;
    

  26.     USART_InitStructure.WordLength          = USART_WL_8B;
    

  27.     USART_InitStructure.StopBits            = USART_STPB_1;
    

  28.     USART_InitStructure.Parity              = USART_PE_NO;
    

  29.     USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;
    

  30.     USART_InitStructure.Mode                = USART_MODE_RX | USART_MODE_TX;
    


  31. 

  32.     /* Configure USARTx */
    

  33.     USART_Initializes(USARTx, &USART_InitStructure);
    

  34.     /* Enable the USARTx */
    

  35.     USART_Enable(USARTx);
    

  36. }
    


  37. 

  38. int main(void)
    

  39. {
    

  40.     RCC_ClocksType RCC_ClocksStatus;
    

  41.     RCC_Configuration();
    

  42.     GPIO_Configuration();
    

  43.     UART_Configuration(void);
    

  44.     RCC_Clocks_Frequencies_Value_Get(&RCC_ClocksStatus);
    

  45.     printf("\n\rUSART Printf Example: retarget the C library printf function to the USART\n\r");
    


  46. 

  47.     while (1)
    

  48.     {
    

  49.     }
    

  50. }
    


  51. 

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

  53. {
    

  54.     USART_Data_Send(USARTx, (uint8_t)ch);
    

  55.     while (USART_Flag_Status_Get(USARTx, USART_FLAG_TXDE) == RESET)；
    

  56.     return (ch);
    

  57. }
    


  58. 

  59. #ifdef USE_FULL_ASSERT
    

  60. void assert_failed(const uint8_t* expr, const uint8_t* file, uint32_t line)
    

  61. {
    

  62.     /* User can add his own implementation to report the file name and line number,
    

  63.        ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
    

  64.     /* Infinite loop */
    

  65.     while (1)
    

  66.     {
    

  67.     }
    

  68. }
    


  69. 

  70. #endif
7.can-loop测试，N32G430集成了can外设，也就意味着它具备胜任工业网络canopen协议的可能，can迈出大门第一步，回环自测
复制
  1. void CAN_CONFIG(void)
    

  2. {
    

  3.     RCC_APB1_Peripheral_Clock_Enable(RCC_APB1_PERIPH_CAN);
    

  4.     CAN_NVIC_Configuration();
    

  5.     CAN_GPIO_Configuration();
    

  6.     
    

  7.     CAN_Reset(CAN);
    

  8.     CAN_Structure_Initializes(&CAN_InitStructure);
    

  9.     CAN_InitStructure.TTCM          = DISABLE;
    

  10.     CAN_InitStructure.ABOM          = DISABLE;
    

  11.     CAN_InitStructure.AWKUM         = DISABLE;
    

  12.     CAN_InitStructure.NART          = DISABLE;
    

  13.     CAN_InitStructure.RFLM          = DISABLE;
    

  14.     CAN_InitStructure.TXFP          = ENABLE;
    

  15.     CAN_InitStructure.OperatingMode = CAN_LOOPBACK_MODE;
    

  16.     CAN_InitStructure.RSJW          = CAN_RSJW_1TQ;
    

  17.     CAN_InitStructure.TBS1          = CAN_TBS1_8TQ;
    

  18.     CAN_InitStructure.TBS2          = CAN_TBS2_7TQ;   
    

  19.     CAN_InitStructure.BaudRatePrescaler = 4; 
    

  20.     CAN_Initializes(CAN, &CAN_InitStructure); 
    

  21.     CAN_FilterInitStructure.Filter_Num            = 0;
    

  22.     CAN_FilterInitStructure.Filter_Mode           = CAN_FILTER_IDLISTMODE;
    

  23.     CAN_FilterInitStructure.Filter_Scale          = CAN_FILTER_32BITSCALE;
    

  24.     CAN_FilterInitStructure.Filter_HighId         = 0x8000;
    

  25.     CAN_FilterInitStructure.Filter_LowId          = 0x0000;
    

  26.     CAN_FilterInitStructure.FilterMask_HighId     = 0x4000;
    

  27.     CAN_FilterInitStructure.FilterMask_LowId      = 0x0000;
    

  28.     CAN_FilterInitStructure.Filter_FIFOAssignment = CAN_FIFO0;
    

  29.     CAN_FilterInitStructure.Filter_Act            = ENABLE;
    

  30.     CAN_Filter_Initializes(&CAN_FilterInitStructure);
    

  31.     CAN_Config_Interrupt_Enable(CAN, CAN_INT_FMP0);
    

  32. }
    


  33. 


  34. 

  35. void CAN_NVIC_Configuration(void)
    

  36. {
    

  37.     NVIC_InitType NVIC_InitStructure;
    

  38.     NVIC_Initializes(&NVIC_InitStructure);
    

  39.     NVIC_InitStructure.NVIC_IRQChannel                   = CAN_RX0_IRQn;
    

  40.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0;
    

  41.     NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 0x1;
    

  42.     NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    

  43.     NVIC_Initializes(&NVIC_InitStructure);
    

  44. }
    


  45. 


  46. 


  47. 

  48. void CAN_GPIO_Configuration(void)
    

  49. {
    

  50.     GPIO_InitType GPIO_InitStructure;
    

  51.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  52.     
    

  53.         RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
    

  54.         RCC_APB2_Peripheral_Clock_Enable(RCC_APB2_PERIPH_AFIO);
    


  55. 

  56.     GPIO_InitStructure.Pin            = GPIO_PIN_8;
    

  57.     GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    

  58.     GPIO_InitStructure.GPIO_Alternate = GPIO_AF6_CAN;
    

  59.     GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
    

  60.     GPIO_InitStructure.Pin             = GPIO_PIN_9;
    

  61.     GPIO_InitStructure.GPIO_Alternate  = GPIO_AF6_CAN;
    

  62.     GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
    

  63. }
    


  64. 


  65. 


  66. 

  67. uint8_t Check_CanRecData(CanRxMessage* RxMessage, uint32_t StdId, uint32_t ExtId, uint8_t IDE, uint8_t RTR, uint8_t DLC,
    

  68.                          uint8_t Data0, uint8_t Data1, uint8_t Data2, uint8_t Data3,
    

  69.                          uint8_t Data4, uint8_t Data5, uint8_t Data6, uint8_t Data7, uint8_t FMI)
    

  70. {
    

  71.     if(IDE == CAN_EXTENDED_ID)
    

  72.     {
    

  73.         if(RxMessage->ExtId   != ExtId)          
    

  74.         {
    

  75.             return Fail;
    

  76.         }
    

  77.     }
    

  78.     else if(IDE == CAN_STANDARD_ID)
    

  79.     {
    

  80.         if(RxMessage->StdId   != StdId)  
    

  81.         {
    

  82.             return Fail;
    

  83.         }
    

  84.     }
    

  85.     if( (RxMessage->IDE     != IDE)   ||         /* CAN_ID_STD / CAN_ID_EXT */
    

  86.         (RxMessage->RTR     != RTR)   ||         /* CAN_RTR_DATA / CAN_RTR_REMOTE */
    

  87.         (RxMessage->DLC     != DLC)              /* 0 to 8 */
    

  88.     )
    

  89.     {
    

  90.         return Fail;
    

  91.     }
    

  92.     if(RTR == CAN_RTRQ_DATA)
    

  93.     {
    

  94.         if(DLC >= 1)
    

  95.         {
    

  96.             if(RxMessage->Data[0] != Data0)
    

  97.             {
    

  98.                 return Fail;
    

  99.             }
    

  100.         }
    

  101.         if(DLC >= 2)
    

  102.         {
    

  103.             if(RxMessage->Data[1] != Data1)
    

  104.             {
    

  105.                 return Fail;
    

  106.             }
    

  107.         }
    

  108.         if(DLC >= 3)
    

  109.         {
    

  110.             if(RxMessage->Data[2] != Data2)
    

  111.             {
    

  112.                 return Fail;
    

  113.             }
    

  114.         }
    

  115.         if(DLC >= 4)
    

  116.         {
    

  117.             if(RxMessage->Data[3] != Data3)
    

  118.             {
    

  119.                 return Fail;
    

  120.             }
    

  121.         }
    

  122.         if(DLC >= 5)
    

  123.         {
    

  124.             if(RxMessage->Data[4] != Data4)
    

  125.             {
    

  126.                 return Fail;
    

  127.             }
    

  128.         }
    

  129.         if(DLC >= 6)
    

  130.         {
    

  131.             if(RxMessage->Data[5] != Data5)
    

  132.             {
    

  133.                 return Fail;
    

  134.             }
    

  135.         }
    

  136.         if(DLC >= 7)
    

  137.         {
    

  138.             if(RxMessage->Data[6] != Data6)
    

  139.             {
    

  140.                 return Fail;
    

  141.             }
    

  142.         }
    

  143.         if(DLC == 8)
    

  144.         {
    

  145.             if(RxMessage->Data[7] != Data7)
    

  146.             {
    

  147.                 return Fail;
    

  148.             }
    

  149.         }
    

  150.         if(DLC > 8)
    

  151.         {
    

  152.             return Fail;
    

  153.         }
    

  154.     }
    

  155.     else if(RTR == CAN_RTRQ_REMOTE)
    

  156.     {
    

  157.         
    

  158.     }
    

  159.     if(RxMessage->FMI != FMI)           
    

  160.     {
    

  161.         return Fail;
    

  162.     }
    


  163. 

  164.     return Pass;
    

  165. }
    


  166. 

  167. uint16_t Rx_Flag = DISABLE;
    

  168. int main(void)
    

  169. {
    

  170.     uint32_t wait_slak;
    

  171.     NVIC_Priority_Group_Set(NVIC_PER2_SUB2_PRIORITYGROUP);
    


  172. 

  173.     CAN_CONFIG();
    

  174.     
    

  175.     CAN_TxMessage.StdId   = 0x0400;        
    

  176.     CAN_TxMessage.ExtId   = 0x00;        
    

  177.     CAN_TxMessage.IDE     = CAN_STANDARD_ID;           /* CAN_ID_STD / CAN_ID_EXT */
    

  178.     CAN_TxMessage.RTR     = CAN_RTRQ_DATA;           /* CAN_RTR_DATA / CAN_RTR_REMOTE */
    

  179.     CAN_TxMessage.DLC     = 8;           /* 0 to 8 */
    

  180.     CAN_TxMessage.Data[0] = 0x00;
    

  181.     CAN_TxMessage.Data[1] = 0x01;
    

  182.     CAN_TxMessage.Data[2] = 0x02;
    

  183.     CAN_TxMessage.Data[3] = 0x03;
    

  184.     CAN_TxMessage.Data[4] = 0x04;
    

  185.     CAN_TxMessage.Data[5] = 0x05;
    

  186.     CAN_TxMessage.Data[6] = 0x06;
    

  187.     CAN_TxMessage.Data[7] = 0x07;
    

  188.     while(1)
    

  189.     {
    

  190.         CAN_Transmit_Message_initializes(CAN,&CAN_TxMessage);
    

  191.         while(Rx_Flag == DISABLE)
    

  192.         {
    

  193.             Rx_Flag = Check_CanRecData(&CAN_RxMessage, 0x0400, 0x00, CAN_STANDARD_ID, CAN_RTRQ_DATA, 8,
    

  194.                          0x00,0x01, 0x02, 0x03, 
    

  195.                          0x04,0x05, 0x06, 0x07, 0);
    

  196.         }
    

  197.         
    

  198.         wait_slak = 0xFFFF;
    

  199.         while(wait_slak>0)
    

  200.         {
    

  201.             wait_slak--;
    

  202.         }
    

  203.         Rx_Flag = DISABLE;
    

  204.     }
    

  205. }

8.内置boot-loader测试，测试内部的boot，是我这次测试的重点，在汇川工作的时候，遇到过国民其它系列芯片内置boot的bug问题，本次再来体验一下，看国民官方是否修复。

8.1 N32G430内置boot功能强大，具体支持功能如下：
1.png
8.2 N32G430 系列芯片的固件程序 BOOT，支持通过 USART 接口下载用户程序和数据。 相关命令格式如下：


上下层指令数据结构

1、上层指令结构：
<CMD_H + CMD_L + LEN + Par> + (DAT)。
CMD_H 代表一级命令字段， CMD_L 代表二级命令字段； LEN 代表发送数据长度； Par代表 4 个字节命令参数； DAT 代表上层指令往下层发送的具体数据；
2、下层应答结构：
< CMD_H + CMD_L + LEN > + (DAT) + <CR1+CR2>。
CMD_H 代表一级命令字段， CMD_L 代表二级命令字段，下层的命令字段和对应上层的命令字段相同； LEN 代表发送数据长度； DAT 代表下层向上层应答的具体数据； CR1+CR2代表向上层返回的指令执行结果，若上层发送命令一级、二级命令字段不属于任何命令， BOOT 回复 CR1=0xBB， CR2 = 0xCC。


串口支持的命令数据结构：
1、 上位机下发上层指令：
STA1 + STA2 + {上层指令结构} + XOR。
STA1 和 STA2 是串口发送命令的起始字节， STA1=0xAA， STA2=0x55。用于芯片识别上位机发送串口数据流。
XOR 代表之前命令字节的异或运算值（STA1 + STA2 + {上层指令结构}）。
2、 上位机接收下层应答：
STA1 + STA2 + {下层应答结构} + XOR。
STA1 和 STA2 是串口发送命令的起始字节， STA1=0xAA， STA2=0x55。用于上位机识别芯片发送串口数据流
XOR 代表之前命令字节的异或运算值（STA1 + STA2 + {下层应答结构}）。

8.3 命令列表 2.png


8.4 命令说明和实例修改串口波特率
3.png
Par[0~3]，串口波特率协商设置值可以设定最大，设定范围为 2.4Kbps ~ 4Mbps，默认波特率为 9600bps；

状态字节(CR1、 CR2)根据命令执行情况分为：
1. 返回成功：状态标志位(0xA0、 0x00)。
2. 返回失败：状态标志位(0xB0、 0x00)。

4.png
回复 赏

举报

相关帖子
呐咯密密 发表于 2024-4-24 13:52 | 显示全部楼层
n32g430的性价比真的高
回复 赏

举报

 楼主| 一路向北lm 发表于 2024-4-24 18:29 | 显示全部楼层
呐咯密密 发表于 2024-4-24 13:52
n32g430的性价比真的高

是的，拿来做canopen设备一点问题没有的
回复 赏

举报

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

本版积分规则

一路向北lm Image

293

主题

3837

帖子

81

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