• GD32F10 串口通信

    1. 什么是通信

    通信，指人与人或人与自然之间通过某种行为或媒介进行的信息交流与传递，从广义上指需要信息的双方或多方在不违背各自意愿的情况下采用任意方法，任意媒质，将信息从某方准确安全地传送到另方。通信双方如果想正确传输数据就需要约定不违背的协议。

    通信在不同的环境下有不同的解释，在出现电波传递通信后通信(Communication)被单一解释为信息的传递，是指由一地向另一地进行信息的传输与交换，其目的是传输消息。

    然而，通信是在人类实践过程中随着社会生产力的发展对传递消息的要求不断提升使得人类文明不断进步。

    在各种各样的通信方式中，利用“电”来传递消息的通信方法称为电信(Telecommunication)，这种通信具有迅速、准确、可靠等特点，且几乎不受时间、地点、空间、距离的限制，因而得到了飞速发展和广泛应用；

    在现今因电波的快捷性使得从远古人类物质交换过程中就结合文化交流与实体经济不断积累进步的实物性通信（邮政通信）被人类理解为制约经济发展的阻碍。

    在古代，人类通过驿站、飞鸽传书、烽火报警、符号、身体语言、眼神、触碰等方式进行信息传递。

    在现代科学水平的飞速发展，相继出现了无线电、固定电话、移动电话、互联网甚至视频电话等各种通信方式。通信技术拉近了人与人之间的距离，提高了经济的效率，深刻地改变了人类的生活方式和社会面貌。

    1. 分类

    1． 按传输媒质分类

    有线通信：是指传输媒质为导线、电缆、光缆、波导、纳米材料等形式的通信，其特点是媒质能看得见，摸得着(明线通信、电缆通信、光缆通信、光纤光缆通信)。

    无线通信：是指传输媒质看不见、摸不着(如电磁波)的一种通信形式 [2]  。

    (微波通信、短波通信、移动通信、卫星通信、 散射通信)。

    2． 按信道中传输的信号分类

    模拟信号：凡信号的某一参量(如连续波的振幅、频率、相位，脉冲波的振幅、宽度、位置等)可以取无限多个数值，且直接与消息相对应的，模拟信号有时也称连续信号。 这个连续是指信号的某一参量可以连续变化。

    数字信号：凡信号的某一参量只能取有限个数值，并且常常不直接与消息相对应的，也称离散信号 [1]  。

    3． 按工作频段分类

    长波通信。

    中波通信。

    短波通信。

    微波通信。

    4． 按调制方式分类

    基带传输：是指信号没有经过调制而直接送到信道中去传输

    的通信方式。

    频带传输：是指信号经过调制后再送到信道中传输，接收端

    有相应解调措施的通信方式。

    5．按通信双方的分工及数据传输方向分类。

    对于点对点之间的通信，按消息传送的方向，通信方式可分为单工通信、半双工通信及全双工通信三种。

    所谓单工通信，是指消息只能单方向进行传输的一种通信工作方式。单工通信的例子很多，如广播、遥控、无线寻呼等。这里，信号（消息）只从广播发射台、遥控器和无线寻呼中心分别传到收音机、遥控对象和BP 机上。

    所谓半双工通信方式，是指通信双方都能收发消息，但不能同时进行收和发的工作方式。对讲机、收发报机等都是这种通信方式。

    所谓全双工通信，是指通信双方可同时进行双向传输消息的工作方式。在这种方式下，双方都可同时进行收发消息。很明显，全双工通信的信道必须是双向信道。生活中全双工通信的例子非常多，如普通电话、手机等。

    2. 组成

    实现信息传递所需的一切技术设备和传输媒质的合称为通信系统。

    信源：消息的产生地，其作用是把各种消息转换成原始电信号，称之为消息信号或基带信号。电话机、电视摄像机和电传机、计算机等各种数字终端设备就是信源。

    发送设备：将信源和信道匹配起来，即将信源产生的消息信号变换为适合在信道中搬移的场合，调制是最常见的变换方式。对需要频谱搬移场合，调制是最常见的变换方式。对数字通信系统来说，发送设备常常又分为信源编码与信道编码。

    信道：传输信号的物理媒质。

    噪声源：是通信系统中各种设备以及信道中所固有的，为了分析方便，把噪声源视为各处噪声的集中表现而抽象加入到信道。

    接收设备：完成发送设备的反变换，即进行解调、译码、解码等等。它的任务是从带有干扰的接收信号中正确恢复出相应的原始基带信号来。

    信宿：传输信息的归宿点，其作用是将复原的原始信号转换成相应的信息

     2. 通信的传输方式。

    现在普遍双工比较多。 

    3. 通信中的并行，串行

    现在普遍串行比较多。 

     4. 通信中的同步，异步。

     

    5. （USART）异步通信 的数据帧格式。

    1.接收方怎么知道你什么时候发送。当发送完怎么知道你发送结束。所以在发送一个字节时会先发送一个起始位。在空闲的时候因为是高电平。当发送起始位是0，当接收方收到0就知道你要发送数据了就准备好接收数据。当发完一个字节时。这时又会发送一个停止位1。当接收方接收到停止位1就知道你发送完了。发送一个字节需要发送10个位。起始位(一位）+ 一个字节（八位） + 起始位（一位）。如图：奇偶校验位可以先不考虑。
     

    2. 具体发送方多久发送一个bit呢？

    从而引出波特率。如果波特率是9600。那么1/9600s传输1bit。

    1s传输9600bit。但对于接收方以多大的速度去接收呢。如果速度慢会丢bit。一般采样频率是

    传输频率的16倍。这样才能保证稳定不丢。

    如果单片机是发送方。笔记本电脑是接收方。我们不需要考虑接收问题。笔记本电脑硬件会自己处理。但是显示接收的上位机软件要配置跟下位机一样波特率，停止位，数据位，是否有校验位。

    如果单片机是接收方。笔记本电脑是发送方。需要考虑采样频率的问题。

    3. 具体波特率怎么产生呢？

    在库函数里设置波特率参数。就可以产生。有相应的硬件电路。我们不需要管。如果像有些51单片机是没有波特率产生电路的。需要用一个定时器配置来产生。

    对于异步通信字节与字节传输是可以间隔传输的。接收方接收到起始就知道有数据来。接收到停止位知道一个字节接收完毕。等一下字节也是同样方式。

     

    6. USART的框图

    对于收发就看圈的部分即可

     7. dome （串口发送数据）

    使用串口0 RX:PA9 TX：PA10

    串口初始化步骤：(这个dome没用中断)

     

    usart_comm.h

    1. #ifndef USART_COMM_H
    2. #define USART_COMM_H
    3. /**
    4. @brief: 串口处理的模块
    5. */
    6.  
    7. #include "gd32f10x.h"
    8.  
    9. void usart0_init(uint32_t baudval);
    10.  
    11. void usart0_send_byte(uint8_t ch);
    12.  
    13. void usart0_send_string(uint8_t *ch);
    14.  
    15.  
    16. #endif

    usart_cmm.c

    1. #include "usart_comm.h"
    2.  
    3. /**
    4. *@brief: usart0的初始化
    5. *@param baudval： 波特率
    6. *@retval NONE
    7. */
    8. void usart0_init(uint32_t baudval){
    9. 	/* 初始化时钟和对应的io口 */
    10. 	rcu_periph_clock_enable(RCU_GPIOA);
    11. 	rcu_periph_clock_enable(RCU_USART0);
    12. 	
    13. 	gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9); /* TX 推挽复用 */
    14. 	gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10); /* RX 浮空输入 */
    15. 	
    16. 	// 配置usart0的工作参数
    17. 	usart_deinit(USART0); /* 重置初始化 */
    18.   
    19. 	usart_baudrate_set(USART0, baudval);        //波特率
    20. 	usart_parity_config(USART0, USART_PM_NONE); //无奇偶校验
    21. 	usart_word_length_set(USART0, USART_WL_8BIT); //bit长度
    22. 	usart_stop_bit_set(USART0, USART_STB_1BIT);   //停止位
    23. 	usart_transmit_config(USART0, USART_TRANSMIT_ENABLE); //使能发送
    24. 	usart_receive_config(USART0, USART_RECEIVE_ENABLE);   //使能接收
    25. 	
    26. 	usart_enable(USART0); /* 使能串口 */
    27. }
    28.  
    29.  
    30. /**
    31. *@brief: usart0发送一个字节
    32. *@param ch：待发送字节
    33. *@retval NONE
    34. */
    35. void usart0_send_byte(uint8_t ch){
    36. 	usart_data_transmit(USART0, ch);
    37. 	
    38. 	while(usart_flag_get(USART0, USART_FLAG_TBE)==RESET); /* 等待发送完成 */
    39. }
    40.  
    41. /**
    42. *@brief: usart0发送字符串
    43. *@param ch：待发送字符串指针
    44. *@retval NONE
    45. */
    46. void usart0_send_string(uint8_t *ch){
    47. 	uint32_t k = 0;
    48. 	while(*(ch+k) != '\0'){
    49. 		usart0_send_byte(*(ch+k));
    50. 		k++;
    51. 	}
    52. }

    main.c

    1. #include "systick.h"
    2. #include "usart_comm.h"
    3.  
    4. int main(){
    5. 	systick_config();
    6. 	usart0_init(9600);
    7. 	
    8. 	while(1){
    9. 		usart0_send_string((uint8_t *)"hello  UART.\n"); //自动会填充字符串结束符'\0'
    10. 		delay_1ms(1000);  //等待1s
    11. 	}
    12. }

    结果：

    8.  dome （串口发送接收数据中断）

    通过上位机发指令来控制下位机的LED,继电器的操作。

    继电器硬件图：

    J1接到PB15. 控制PB15来控制继电器是否工作。

    LED硬件图：

    具体上下位机的协议规定：

    一帧有5个字节：帧头（0xFF）,设备ID,设备号，设备指令，帧尾（0x00）.

     

     relay_ctrl.h(继电器）

    1. #ifndef RELAY_CTRL_H
    2. #define RELAY_CTRL_H
    3.  
    4. #include "gd32f10x.h"
    5.  
    6. //定义继电器序号的宏
    7. #define RELAY_1 0x01
    8.  
    9. void relay_init(void);
    10.  
    11. void relay_connect(uint8_t relay_num);
    12. void relay_disconnect(uint8_t relay_num);
    13.  
    14. #endif

     relay_ctrl.c(继电器）

    1. #include "relay_ctrl.h"
    2.  
    3. // 继电器控制io口的初始化
    4. void relay_init(void){
    5. 	rcu_periph_clock_enable(RCU_GPIOB);
    6. 	
    7. 	gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
    8. 	
    9. 	//默认让继电器断开
    10. 	relay_disconnect(RELAY_1);
    11. }
    12.  
    13. // 控制继电器吸合
    14. void relay_connect(uint8_t relay_num){
    15. 	switch(relay_num){
    16. 		case RELAY_1:
    17. 			gpio_bit_set(GPIOB, GPIO_PIN_15);
    18. 			break;
    19. 		default:
    20. 			break;
    21. 	}
    22. }
    23.  
    24. // 控制继电器断开
    25. void relay_disconnect(uint8_t relay_num){
    26. 	switch(relay_num){
    27. 		case RELAY_1:
    28. 			gpio_bit_reset(GPIOB, GPIO_PIN_15);
    29. 			break;
    30. 		default:
    31. 			break;
    32. 	}
    33. }

    led_ctrl.h(LED)

    1. #ifndef LED_CTRL_H
    2. #define LED_CTRL_H
    3.  
    4. #include "gd32f10x.h"
    5.  
    6. //LED序号的宏定义
    7. #define LED_1 0x01
    8. #define LED_2 0x02
    9.  
    10. void led_init(void);
    11.  
    12. void led_open(uint8_t led_num);   //led点亮
    13. void led_close(uint8_t led_num);  //led熄灭
    14.  
    15. #endif

     led_ctrl.c(LED)

    1. #include "led_ctrl.h"
    2.  
    3. void led_init(void){
    4. 	rcu_periph_clock_enable(RCU_GPIOB);
    5. 	
    6. 	gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_0|GPIO_PIN_1);
    7. 	
    8. 	led_close(LED_1);
    9. 	led_close(LED_2);
    10. 	
    11. }
    12.  
    13. //led点亮
    14. void led_open(uint8_t led_num){
    15. 	switch(led_num){
    16. 		case LED_1:
    17. 			gpio_bit_set(GPIOB, GPIO_PIN_0);
    18. 			break;
    19. 		case LED_2:
    20. 			gpio_bit_set(GPIOB, GPIO_PIN_1);
    21. 			break;
    22. 		default:
    23. 			break;
    24. 	}
    25. }
    26.  
    27. //led熄灭
    28. void led_close(uint8_t led_num){
    29. 	switch(led_num){
    30. 		case LED_1:
    31. 			gpio_bit_reset(GPIOB, GPIO_PIN_0);
    32. 			break;
    33. 		case LED_2:
    34. 			gpio_bit_reset(GPIOB, GPIO_PIN_1);
    35. 			break;
    36. 		default:
    37. 			break;
    38. 	}
    39. }

     usart_comm.h(串口）

    1. #ifndef USART_COMM_H
    2. #define USART_COMM_H
    3. /**
    4. @brief: 串口处理的模块
    5. */
    6.  
    7. #include "gd32f10x.h"
    8.  
    9. // 定义数据帧的宏
    10. #define HEX_HEAD 0xFF
    11. #define HEX_TAIL 0x00
    12. #define LED_ID 0x01
    13. #define RELAY_ID 0x02
    14.  
    15.  
    16. void usart0_init(uint32_t baudval);
    17.  
    18. void usart0_send_byte(uint8_t ch);
    19.  
    20. void usart0_send_string(uint8_t *ch);
    21.  
    22. void deal_rec_buff(void);  // 串口通信协议hex数据帧缓存处理函数
    23.  
    24. #endif

     usart_comm.c(串口）

    1. #include "usart_comm.h"
    2. #include "led_ctrl.h"
    3. #include "relay_ctrl.h"
    4.  
    5. uint8_t recv_buff[5]; /* 保存结束的数据 */
    6. uint8_t recv_buff_len = 0;
    7.  
    8. /**
    9. *@brief: usart0的初始化
    10. *@param baudval： 波特率
    11. *@retval NONE
    12. */
    13. void usart0_init(uint32_t baudval){
    14. 	/* 初始化时钟和对应的io口 */
    15. 	rcu_periph_clock_enable(RCU_GPIOA);
    16. 	rcu_periph_clock_enable(RCU_USART0);
    17. 	
    18. 	gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);  /* TX 推挽复用 */
    19. 	gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10); /* RX 浮空输入 */
    20. 	
    21. 	// 配置usart0的工作参数
    22. 	usart_deinit(USART0);
    23. 	usart_baudrate_set(USART0, baudval);        //波特率
    24. 	usart_parity_config(USART0, USART_PM_NONE); //无奇偶校验
    25. 	usart_word_length_set(USART0, USART_WL_8BIT); //bit长度
    26. 	usart_stop_bit_set(USART0, USART_STB_1BIT);   //停止位
    27.   
    28. 	usart_transmit_config(USART0, USART_TRANSMIT_ENABLE); //使能发送
    29. 	usart_receive_config(USART0, USART_RECEIVE_ENABLE);   //使能接收
    30. 	
    31. 	usart_enable(USART0); /* 使能串口 */
    32. 	
    33. 	// 使能usart0的中断
    34. 	usart_interrupt_enable(USART0, USART_INT_RBNE);
    35.   
    36.   /* 中断优先级 */
    37. 	nvic_irq_enable(USART0_IRQn, 2U, 2U);
    38. 	
    39. 	usart0_send_string((uint8_t *)"usart0 opened succeed.");
    40. 	
    41. }
    42.  
    43.  
    44. /**
    45. *@brief: usart0发送一个字节
    46. *@param ch：待发送字节
    47. *@retval NONE
    48. */
    49. void usart0_send_byte(uint8_t ch){
    50. 	usart_data_transmit(USART0, ch);
    51. 	
    52. 	while(usart_flag_get(USART0, USART_FLAG_TBE)==RESET); /* 等待发送完成 */
    53. }
    54.  
    55. /**
    56. *@brief: usart0发送字符串
    57. *@param ch：待发送字符串指针
    58. *@retval NONE
    59. */
    60. void usart0_send_string(uint8_t *ch){
    61. 	uint32_t k = 0;
    62. 	while(*(ch+k) != '\0'){
    63. 		usart0_send_byte(*(ch+k));
    64. 		k++;
    65. 	}
    66. }
    67.  
    68. // USART0的中断响应函数
    69. void USART0_IRQHandler(void){
    70. 	uint8_t temp;
    71. 	if(SET == usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)){
    72. 		usart_interrupt_flag_clear(USART0, USART_INT_FLAG_RBNE);
    73. 		temp = usart_data_receive(USART0);
    74. 		if(temp == HEX_HEAD){         //数据帧帧头
    75. 			recv_buff_len = 0;
    76. 			recv_buff[recv_buff_len] = temp;
    77. 			recv_buff_len++;			
    78. 		}else if(temp == HEX_TAIL){   //数据帧帧尾
    79. 			if(recv_buff_len == 4){
    80. 				recv_buff[recv_buff_len] = temp;
    81. 				deal_rec_buff();
    82. 			}else{
    83. 				usart0_send_string((uint8_t *)"error");
    84. 			}
    85. 		}else{
    86. 			if(recv_buff_len > 0 && recv_buff_len < 4){
    87. 				recv_buff[recv_buff_len] = temp;
    88. 				recv_buff_len++;
    89. 			}else{
    90. 				usart0_send_string((uint8_t *)"error");
    91. 			}
    92. 		}
    93. 	}
    94. }
    95.  
    96. // 串口通信协议hex数据帧缓存处理函数
    97. void deal_rec_buff(void){
    98. 	switch(recv_buff[1]){
    99. 		case LED_ID:    //LED的控制
    100. 			if(recv_buff[3] == 0x01){
    101. 				led_open(recv_buff[2]);
    102. 			}else if(recv_buff[3] == 0x02){
    103. 				led_close(recv_buff[2]);
    104. 			}
    105. 			break;
    106. 		case RELAY_ID:    //继电器的控制
    107. 			if(recv_buff[3] == 0x01){
    108. 				relay_connect(recv_buff[2]);
    109. 			}else if(recv_buff[3] == 0x02){
    110. 				relay_disconnect(recv_buff[2]);
    111. 			}
    112. 			break;
    113. 		default:      //出错
    114. 			usart0_send_string((uint8_t *)"error");
    115. 			break;
    116. 		
    117. 	}
    118. }

     main.c

    1. #include "systick.h"
    2. #include "usart_comm.h"
    3. #include "led_ctrl.h"
    4. #include "relay_ctrl.h"
    5.  
    6. int main(){
    7. 	systick_config();
    8. 	usart0_init(9600); /* 波特率：9600 */
    9. 	led_init();
    10. 	relay_init();
    11. 	
    12. 	while(1){
    13. 	}
    14. }

  • 相关阅读:
    React+Typescript+react-router 6 创建路由操作
    Android技术分享| 视频通话开发流程(一)
    【slam十四讲第二版】【课本例题代码向】【第十讲~后端2】
    用Rust开发一个类似SQL Server的数据库系统的步骤和关键技术
    Fabric v2.5区块链应用开发实战大纲
    Springboot @GetMapping 自动接收对象参数源码分析
    C++：程序在mian函数执行前后做了哪些工作？
    vue 第三方组件按需引入，最后项目的包体积真的变小了吗？
    防止员工私自拷贝公司资料
    多线程案例(单例、阻塞队列、生消模型、定时器)
  • 原文地址：https://blog.csdn.net/qq_41328470/article/details/133513263