datasheet
单片机
单片机>ARM单片机> stm32 串口通信

stm32 串口通信

发布者：龙腾少年最新更新时间：2017-10-25 来源: eefocus关键字：stm32  串口通信 手机看文章 扫描二维码
随时随地手机看文章
分享到
微博
QQ
微信
LinkedIn

这次讲讲利用串口收发中断来进行串口通讯。STM32 上为每个串口分配了一个中断。也就是说无论是发送完成还是收到数据或是数据溢出都产生同一个中断。程序需在中断处理函数中读取状态寄存器(USART_SR)来判断当前的是什么中断。下面的中断映像图给出了这些中断源是如何汇合成最终的中断信号的。图中也给出了如何控制每一个单独的中断源是否起作用。

另外，Cortex-M3 内核中还有个NVIC，可以控制这里的中断信号是否触发中断处理函数的执行，还有这些外部中断的级别。关于NVIC 可以参考《ARM CortexM3 权威指南》，里面讲解的非常详细。

简单的说，为了开启中断，我们需要如下的代码：


  1. NVIC_InitTypeDef NVIC_InitStructure;

  2. NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

  3. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  4. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

  5. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  6. NVIC_Init(&NVIC_InitStructure);

  7. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断

  8. USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断

这里多说一句，串口的发送中断有两个，分别是：

  1. l发送数据寄存器空中断（TXE）

  2. l发送完成中断（TC）

一般来说我们会使用发送数据寄存器空中断，用这个中断发送的效率会高一些。

中断处理函数的框架如下，如果检测到错误就清除错误，收到数了就处理。发完当前数据了就发下一个。


  1. void USART1_IRQHandler(void)

  2. {

  3. unsigned int data;

  4. if(USART1->SR & 0x0F)

  5. {

  6. // See if we have some kind of error, Clear interrupt

  7. data = USART1->DR;

  8. }

  9. else if(USART1->SR & USART_FLAG_RXNE) //Receive Data Reg Full Flag

  10. {

  11. data = USART1->DR;

  12. // 对收到的数据进行处理，或者干些其他的事

  13. }

  14. else if(USART1->SR & USART_FLAG_TXE)

  15. {

  16. { // 可以发送数据了，如果没有数据需要发送，就在这里关闭发送中断

  17. USART1->DR = something; // Yes, Send character

  18. }

  19. }

  20. }


下面给一个利用环形缓冲区的串口驱动程序。


  1. #ifndef _COM_BUFFERED_H_

  2. #define _COM_BUFFERED_H_

  3. #define COM1 0

  4. #define COM2 1

  5. #define COM_RX_BUF_SIZE 64

  6. #define COM_TX_BUF_SIZE 64

  7. #define COM_NO_ERR 0

  8. #define COM_BAD_CH 1

  9. #define COM_RX_EMPTY 2

  10. #define COM_TX_FULL 3

  11. #define COM_TX_EMPTY 4

  13. unsigned char COMGetCharB (unsigned char ch, unsigned char *err);

  15. unsigned char COMPutCharB (unsigned char port, unsigned char c);

  17. void COMBufferInit (void);

  19. unsigned char COMBufferIsEmpty (unsigned char port);

  21. unsigned char COMBufferIsFull (unsigned char port);

  22. #endif



  2. #include "stm32f10x_usart.h"

  3. #include "com_buffered.h"

  4. #define OS_ENTER_CRITICAL() __set_PRIMASK(1)

  5. #define OS_EXIT_CRITICAL() __set_PRIMASK(0)

  7. static void COMEnableTxInt(unsigned char port)

  8. {

  9. static USART_TypeDef* map[2] = {USART1, USART2};

  10. USART_ITConfig(map[port], USART_IT_TXE, ENABLE);

  11. }

  13. typedef struct {

  14. short RingBufRxCtr;

  15. unsigned char *RingBufRxInPtr;

  16. unsigned char *RingBufRxOutPtr;

  17. unsigned char RingBufRx[COM_RX_BUF_SIZE];

  18. short RingBufTxCtr;

  19. unsigned char *RingBufTxInPtr;

  20. unsigned char *RingBufTxOutPtr;

  21. unsigned char RingBufTx[COM_TX_BUF_SIZE];

  22. } COM_RING_BUF;

  24. COM_RING_BUF COM1Buf;

  25. COM_RING_BUF COM2Buf;

  27. unsigned char COMGetCharB (unsigned char port, unsigned char *err)

  28. {

  29. // unsigned char cpu_sr;

  30. unsigned char c;

  31. COM_RING_BUF *pbuf;

  32. switch (port)

  33. {

  34. case COM1:

  35. pbuf = &COM1Buf;

  36. break;

  37. case COM2:

  38. pbuf = &COM2Buf;

  39. break;

  40. default:

  41. *err = COM_BAD_CH;

  42. return (0);

  43. }

  44. OS_ENTER_CRITICAL();

  45. if (pbuf->RingBufRxCtr > 0)

  46. {

  47. pbuf->RingBufRxCtr--;

  48. c = *pbuf->RingBufRxOutPtr++;

  49. if (pbuf->RingBufRxOutPtr == &pbuf->RingBufRx[COM_RX_BUF_SIZE])

  50. {

  51. pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];

  52. }

  53. OS_EXIT_CRITICAL();

  54. *err = COM_NO_ERR;

  55. return (c);

  56. } else {

  57. OS_EXIT_CRITICAL();

  58. *err = COM_RX_EMPTY;

  59. c = 0;

  60. return (c);

  61. }

  62. }

  64. unsigned char COMPutCharB (unsigned char port, unsigned char c)

  65. {

  66. // unsigned char cpu_sr;

  67. COM_RING_BUF *pbuf;

  68. switch (port)

  69. {

  70. case COM1:

  71. pbuf = &COM1Buf;

  72. break;

  73. case COM2:

  74. pbuf = &COM2Buf;

  75. break;

  76. default:

  77. return (COM_BAD_CH);

  78. }

  79. OS_ENTER_CRITICAL();

  80. if (pbuf->RingBufTxCtr < COM_TX_BUF_SIZE) {

  81. pbuf->RingBufTxCtr++;

  82. *pbuf->RingBufTxInPtr++ = c;

  83. if (pbuf->RingBufTxInPtr == &pbuf->RingBufTx[COM_TX_BUF_SIZE]) {

  84. pbuf->RingBufTxInPtr = &pbuf->RingBufTx[0];

  85. }

  86. if (pbuf->RingBufTxCtr == 1) {

  87. COMEnableTxInt(port);

  88. OS_EXIT_CRITICAL();

  89. } else {

  90. OS_EXIT_CRITICAL();

  91. }

  92. return (COM_NO_ERR);

  93. } else {

  94. OS_EXIT_CRITICAL();

  95. return (COM_TX_FULL);

  96. }

  97. }

  99. void COMBufferInit (void)

  100. {

  101. COM_RING_BUF *pbuf;

  102. pbuf = &COM1Buf;

  103. pbuf->RingBufRxCtr = 0;

  104. pbuf->RingBufRxInPtr = &pbuf->RingBufRx[0];

  105. pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];

  106. pbuf->RingBufTxCtr = 0;

  107. pbuf->RingBufTxInPtr = &pbuf->RingBufTx[0];

  108. pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];

  109. pbuf = &COM2Buf;

  110. pbuf->RingBufRxCtr = 0;

  111. pbuf->RingBufRxInPtr = &pbuf->RingBufRx[0];

  112. pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];

  113. pbuf->RingBufTxCtr = 0;

  114. pbuf->RingBufTxInPtr = &pbuf->RingBufTx[0];

  115. pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];

  116. }

  118. unsigned char COMBufferIsEmpty (unsigned char port)

  119. {

  120. // unsigned char cpu_sr;

  121. unsigned char empty;

  122. COM_RING_BUF *pbuf;

  123. switch (port)

  124. {

  125. case COM1:

  126. pbuf = &COM1Buf;

  127. break;

  128. case COM2:

  129. pbuf = &COM2Buf;

  130. break;

  131. default:

  132. return (1);

  133. }

  134. OS_ENTER_CRITICAL();

  135. if (pbuf->RingBufRxCtr > 0)

  136. {

  137. empty = 0;

  138. }

  139. else

  140. {

  141. empty = 1;

  142. }

  143. OS_EXIT_CRITICAL();

  144. return (empty);

  145. }

  147. unsigned char COMBufferIsFull (unsigned char port)

  148. {

  149. // unsigned char cpu_sr;

  150. char full;

  151. COM_RING_BUF *pbuf;

  152. switch (port)

  153. {

  154. case COM1:

  155. pbuf = &COM1Buf;

  156. break;

  157. case COM2:

  158. pbuf = &COM2Buf;

  159. break;

  160. default:

  161. return (1);

  162. }

  163. OS_ENTER_CRITICAL();

  164. if (pbuf->RingBufTxCtr < COM_TX_BUF_SIZE) {

  165. full = 0;

  166. } else {

  167. full = 1;

  168. }

  169. OS_EXIT_CRITICAL();

  170. return (full);

  171. }

  172. // This function is called by the Rx ISR to insert a character into the receive ring buffer.

  173. static void COMPutRxChar (unsigned char port, unsigned char c)

  174. {

  175. COM_RING_BUF *pbuf;

  176. switch (port)

  177. {

  178. case COM1:

  179. pbuf = &COM1Buf;

  180. break;

  181. case COM2:

  182. pbuf = &COM2Buf;

  183. break;

  184. default:

  185. return;

  186. }

  187. if (pbuf->RingBufRxCtr < COM_RX_BUF_SIZE) {

  188. pbuf->RingBufRxCtr++;

  189. *pbuf->RingBufRxInPtr++ = c;

  190. if (pbuf->RingBufRxInPtr == &pbuf->RingBufRx[COM_RX_BUF_SIZE]) {

  191. pbuf->RingBufRxInPtr = &pbuf->RingBufRx[0];

  192. }

  193. }

  194. }

  195. // This function is called by the Tx ISR to extract the next character from the Tx buffer.

  196. // The function returns FALSE if the buffer is empty after the character is extracted from

  197. // the buffer. This is done to signal the Tx ISR to disable interrupts because this is the

  198. // last character to send.

  199. static unsigned char COMGetTxChar (unsigned char port, unsigned char *err)

  200. {

  201. unsigned char c;

  202. COM_RING_BUF *pbuf;

  203. switch (port)

  204. {

  205. case COM1:

  206. pbuf = &COM1Buf;

  207. break;

  208. case COM2:

  209. pbuf = &COM2Buf;

  210. break;

  211. default:

  212. *err = COM_BAD_CH;

  213. return (0);

  214. }

  215. if (pbuf->RingBufTxCtr > 0) {

  216. pbuf->RingBufTxCtr--;

  217. c = *pbuf->RingBufTxOutPtr++;

  218. if (pbuf->RingBufTxOutPtr == &pbuf->RingBufTx[COM_TX_BUF_SIZE])

  219. {

  220. pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];

  221. }

  222. *err = COM_NO_ERR;

  223. return (c);

  224. } else {

  225. *err = COM_TX_EMPTY;

  226. return (0);

  227. }

  228. }

  229. void USART1_IRQHandler(void)

  230. {

  231. unsigned int data;

  232. unsigned char err;

  233. if(USART1->SR & 0x0F)

  234. {

  235. // See if we have some kind of error

  236. // Clear interrupt (do nothing about it!)

  237. data = USART1->DR;

  238. }

  239. else if(USART1->SR & USART_FLAG_RXNE) //Receive Data Reg Full Flag

  240. {

  241. data = USART1->DR;

  242. COMPutRxChar(COM1, data); // Insert received character into buffer

  243. }

  244. else if(USART1->SR & USART_FLAG_TXE)

  245. {

  246. data = COMGetTxChar(COM1, &err); // Get next character to send.

  247. if (err == COM_TX_EMPTY)

  248. { // Do we have anymore characters to send ?

  249. // No, Disable Tx interrupts

  250. //USART_ITConfig(USART1, USART_IT_TXE| USART_IT_TC, ENABLE);

  251. USART1->CR1 &= ~USART_FLAG_TXE | USART_FLAG_TC;

  252. }

  253. else

  254. {

  255. USART1->DR = data; // Yes, Send character

  256. }

  257. }

  258. }

  259. void USART2_IRQHandler(void)

  260. {

  261. unsigned int data;

  262. unsigned char err;

  263. if(USART2->SR & 0x0F)

  264. {

  265. // See if we have some kind of error

  266. // Clear interrupt (do nothing about it!)

  267. data = USART2->DR;

  268. }

  269. else if(USART2->SR & USART_FLAG_RXNE) //Receive Data Reg Full Flag

  270. {

  271. data = USART2->DR;

  272. COMPutRxChar(COM2, data); // Insert received character into buffer

  273. }

  274. else if(USART2->SR & USART_FLAG_TXE)

  275. {

  276. data = COMGetTxChar(COM2, &err); // Get next character to send.

  277. if (err == COM_TX_EMPTY)

  278. { // Do we have anymore characters to send ?

  279. // No, Disable Tx interrupts

  280. //USART_ITConfig(USART2, USART_IT_TXE| USART_IT_TC, ENABLE);

  281. USART2->CR1 &= ~USART_FLAG_TXE | USART_FLAG_TC;

  282. }

  283. else

  284. {

  285. USART2->DR = data; // Yes, Send character

  286. }

  287. }

  288. }


下面给个例子主程序，来演示如何使用上面的串口驱动代码。


  1. #include "misc.h"

  2. #include "stm32f10x.h"

  3. #include "com_buffered.h"

  4. void UART_PutStrB (unsigned char port, uint8_t *str)

  5. {

  6. while (0 != *str)

  7. {

  8. COMPutCharB(port, *str);

  9. str++;

  10. }

  11. }

  12. void USART1_Init(void)

  13. {

  14. GPIO_InitTypeDef GPIO_InitStructure;

  15. USART_InitTypeDef USART_InitStructure;

  16. NVIC_InitTypeDef NVIC_InitStructure;

  17. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);

  19. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  20. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

  21. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  22. GPIO_Init(GPIOA, &GPIO_InitStructure);

  24. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

  25. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

  26. GPIO_Init(GPIOA, &GPIO_InitStructure);

  27. USART_InitStructure.USART_BaudRate = 9600;

  28. USART_InitStructure.USART_WordLength = USART_WordLength_8b;

  29. USART_InitStructure.USART_StopBits = USART_StopBits_1;

  30. USART_InitStructure.USART_Parity = USART_Parity_No;

  31. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

  32. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  33. USART_Init(USART1, &USART_InitStructure );

  34. USART_Cmd(USART1, ENABLE);

  35. NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

  36. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  37. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

  38. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  39. NVIC_Init(&NVIC_InitStructure);

  40. }

  41. void USART2_Init(void)

  42. {

  43. GPIO_InitTypeDef GPIO_InitStructure;

  44. USART_InitTypeDef USART_InitStructure;

  45. NVIC_InitTypeDef NVIC_InitStructure;

  46. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_AFIO, ENABLE);

  48. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  49. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;

  50. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  51. GPIO_Init(GPIOD, &GPIO_InitStructure);

  53. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

  54. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;

  55. GPIO_Init(GPIOD, &GPIO_InitStructure);

  56. GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);

  57. RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

  58. USART_InitStructure.USART_BaudRate = 9600;

  59. USART_InitStructure.USART_WordLength = USART_WordLength_8b;

  60. USART_InitStructure.USART_StopBits = USART_StopBits_1;

  61. USART_InitStructure.USART_Parity = USART_Parity_No;

  62. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

  63. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  64. USART_Init(USART2, &USART_InitStructure );

  65. USART_Cmd(USART2, ENABLE);

  66. NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;

  67. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

  68. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

  69. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  70. NVIC_Init(&NVIC_InitStructure);

  71. }

  72. int main(void)

  73. {

  74. unsigned char c;

  75. unsigned char err;

  76. USART1_Init();

  77. USART2_Init();

  78. COMBufferInit();

  79. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

  80. USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

  81. UART_PutStrB(COM1, "Hello World!\n");

  82. for(;;)

  83. {

  84. c = COMGetCharB(COM1, &err);

  85. if(err == COM_NO_ERR)

  86. {

  87. COMPutCharB(COM1, c);

  88. }

  89. }

  90. }


关键字：stm32  串口通信 引用地址：stm32 串口通信

上一篇：STM32的GPIO中断例子
下一篇：STM32启动文件简单分析

推荐阅读最新更新时间：2024-03-16 15:41

基于CC2541蓝牙模块与单片机的串口通信
一、CC2541器件概述 CC2541是一款针对低能耗以及私有2.4GHz应用的功率优化的真正片载系统（SoC）解决方案。它使得使用低总体物料清单成本建立强健网络节点成为可能。CC2541将领先RF收发器的出色性能和一个业界标准的增强型8051MCU、系统内可编程闪存存储器、8kBRAM和很多其它功能强大的特性和外设组合在一起。CC2541非常适合应用于需要超低能耗的系统。这由多种不同的运行模式指定。运行模式间较短的转换时间进一步使低能耗变为可能 二、CC2541芯片的特性参数 CC2541是一款针对蓝牙低能耗以及私有2.4GHz应用的功率优化的真正片载系统（SoC）解决方案。它使得使用低总体物料清单成本建立强健网络节点成为可
[单片机]
基于CC2541蓝牙模块与单片机的<font color='red'>串口通信</font>
STM32串口接收中断溢出问题解决
在使用一个串口发数据的传感器过程中，发现程序第一次进入串口中断之后不再执行主函数的内容，中断中的内容也不执行。查询大量资料后发现：串口在接收数据过多时，会出现串口溢出错误，并进入溢出中断（ORE中断）。接下来是错误产生原因以及解决方法。 （1）什么是ORE中断？为什么会产生？ 产生原因如上所述。 ORE标志位在USART_SR寄存器，但值得注意的是，当我们打开串口接收中断时，同时也就打开了ORE中断。 （2）如何解决？ 看了上面的资料之后，我知道程序是死在了串口溢出中断。处理中断时，我首先想到的是清除这个中断标志位，但是遇到了很多麻烦。 清除ORE位的方法：顺序执行对USART_SR和USART_DR寄存器的读操作
[单片机]
STM32的下载及调试模式 接口
使用的最多的调试方式莫过于 JTAG 和SWD方式。 JTAG： JTAG （Joint Test Action Group，联合测试行动小组）是一种国际标准测试协议（IEEE 1149.1兼容），主要用于芯片内部测试。现在多数的高级器件都支持JTAG协议，如ARM、DSP、FPGA器件等。标准的JTAG接口是4线：TMS、 TCK、TDI、TDO，分别为模式选择、时钟、数据输入和数据输出线。相关JTAG引脚的定义为： TMS：模式选择，TMS用来设置JTAG接口处于某种特定的测试模式； TCK：时钟输入； TDI：数据输入，数据通过TDI引脚输入JTAG接口； TDO：数据输出，数据通过TDO引脚从JTAG接
[单片机]
stm32单片机GPIO端口的特点及应用解析
一、GPIO的综合描述 stm32每一个GPIO端口拥有2个32bits的configuration寄存器（GPIOx_CRL，GPIOx_CRH），2个32bits的数据寄存器（GPIOx_IDR，GPIOx_ODR），1个32bits的set/reset寄存器（GPIOx_BSRR），1个16bits的reset寄存器（GPIOx_BRR）和1个32bits的Lock寄存器（GPIOx_LCKR）。 （一）每一个IO引脚都可以使用软件配置为以下几种模式： 1. 浮空输入 2. 带上拉输入 3. 带下拉输入 4. 模拟输入 5. 开漏输出——（此模式可实现hotpower说的真双向IO） 6. 推挽输出 7. 复用功能的推挽
[单片机]
STM32单片机基础03——使用GPIO点亮一个LED
本篇文章主要介绍如何使用STM32CubeMX初始化STM32L431RCT6的GPIO，并点亮一个LED。 1. 准备工作 硬件准备 开发板 首先需要准备一个开发板，这里我准备的是 STM32L4的开发板（BearPi） ： 软件准备 需要安装好Keil - MDK及芯片对应的包，以便编译和下载生成的代码； Keil MDK和串口助手的安装包都可以关注“小熊派开源社区”微信公众号，在资料教程一栏中可获取安装包。 2.生成MDK工程 选择芯片型号 打开STM32CubeMX，打开MCU选择器： 搜索并选中芯片STM32L431RCT6: 配置时钟源 如果选择使用外部高速
[单片机]
<font color='red'>STM32</font>单片机基础03——使用GPIO点亮一个LED
STM32学习之路之入门篇
2006年ARM公司推出了基于ARMV7架构的cortex系列的标准体系结构，以满足各种技术得不同性能要求，包含了A,R,M三个分工明确的系列 其中A系列面向复杂的尖端应用程序，用于运行开放式的复杂操作系统；R系列适合实时操作系统，M系列专门针对低成本的微控制领域。而我们今天要学习的STM32就是M3的处理器 STM32（M3）处理器的基本结构,基本结构如图所示，主要包括处理器核cortex-m3 core，NVIC,BUS MATRIS,FLASH转换，及断点单元，DWT,ITM,MPU,ETM,TPIU,ROM Table SW/SWJ-DP等模块，其中MPU和ETM单元是可选单元。 这些单元可分为内外两个层次，
[单片机]
<font color='red'>STM32</font>学习之路之入门篇
STM32的串口中断
总的来说，STM32单片机的串口还是很好理解的，编程也不算复杂。当然我更愿意希望其中断系统和51单片机一样的简单。 对于接收终端，就是RXNE了，这只在接收完成后才产生，在执行USART_ITConfig(USART1, USART_IT_RXNE, ENABLE)代码时不会进入ISR。但麻烦的就是发送有关的中断了：TXE或者TC，根据资料和测试的结果，TXE在复位后就是置1的，即在执行USART_ITConfig(USART1, USART_IT_TXE, ENABLE)后会立即产生中断请求。因此这造成一个麻烦的问题：如果没有真正的发送数据，TXE中断都会发生，而且没有休止，这将占用很大部分的CPU时间，甚至影响其他程
[单片机]
单片机串口通信控制步进电机
这是一个来自单片机开发板的源程序，原理图的下载地址: http://www.51hei.com/f/ks51.pdf 下面是源代码： /** ************************************************************************************************* * @file main.c * @author xr * @date 2014年3月18日20:00:03 * @note 步进电机的参数：减速比：1:64 步进角：5.625/64 启动频率： =550 启动时间最小：1.08ms * @brief 串口通信控制步进电
[单片机]
热门资源推荐
热门放大器推荐
更多
小广播
添点儿料...
无论热点新闻、行业分析、技术干货……
热门活动
换一批
更多
免费申请 | 上百份MPS MIE模块，免费试用还有礼！
设计资源 培训 开发板 精华推荐

最新单片机文章
何立民专栏 单片机及嵌入式宝典

北京航空航天大学教授，20余年来致力于单片机与嵌入式系统推广工作。

更多精选电路图
换一换 更多 相关热搜器件
更多热门文章
更多每日新闻
更多往期活动
11月13日历史上的今天
厂商技术中心
随便看看

About Us 关于我们 客户服务 联系方式 器件索引 网站地图 最新更新 手机版

站点相关： 综合资讯 51单片机 PIC单片机 AVR单片机 ARM单片机 嵌入式系统 汽车电子 消费电子 数据处理 视频教程 电子百科 其他技术 STM32 MSP430 单片机资源下载 单片机习题与教程

词云： 1 2 3 4 5 6 7 8 9 10

北京市海淀区中关村大街18号B座15层1530室 电话:(010)82350740 邮编：100190

电子工程世界版权所有 京B2-20211791 京ICP备10001474号-1 电信业务审批[2006]字第258号函 京公网安备 11010802033920号 Copyright © 2005-2024 EEWORLD.com.cn, Inc. All rights reserved