开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
autouart.c
资源名称：msp430.rar　[点击查看]
上传用户：xs588588
上传日期：2021-03-30
资源大小：242k
文件大小：5k
源码类别：

DSP编程

开发平台：

C/C++

autouart.c：源码内容
  1. #include <msp430x14x.h>
  3. //定义串口操作变量
  4. // 串口 1 的接收标志
  5. char nRev_UART1;
  6. // 串口 1 的发送缓冲区
  7. char UART1_TX_BUF[60];
  8. // 串口 1 的接收缓冲区
  9. char UART1_RX_BUF[60];
  10. int nTX1_Len;
  11. char nRX1_Len;
  12. char nRX1_Len_temp;
  13. char nTX1_Flag;
  14. char nTime_Flag;
  15. int nSend_TX1;
  16. char GetChar(void);
  18. typedef enum  
  19. { BAUD115200, BAUD57600,BAUD38400, BAUD19200,
  20.   BAUD14400,  BAUD9600, BAUD4800,  BAUD2400, 
  21.   BAUD1200       
  22. } baudrates;
  24. typedef struct {
  25.   char ubr00;
  26.   char ubr01;
  27.   char umctl0;
  28.   char *desc;
  29. } baudreg;
  31. // 串口寄存器的值 (UBR0_1, UBR1_1, UMCTL_1, Descr)
  32. const baudreg baudregs[] =
  33. {
  34.     0x45, 0x00, 0x00, "115200",    // BAUD115K
  35.     0x8b, 0x00, 0x00, "57600",     // BAUD57600
  36.     0xd0, 0x00, 0x00, "38400",     // BAUD38400
  37.     0xa0, 0x01, 0x00, "19200",     // BAUD19200
  38.     0x2c, 0x02, 0x00, "14400",     // BAUD14400
  39.     0x41, 0x03, 0x00, "9600",      // BAUD9600
  40.     0x83, 0x06, 0x00, "4800",      // BAUD4800
  41.     0x05, 0x0d, 0x00, "2400",      // BAUD2400
  42.     0x0b, 0x1a, 0x00, "1200"       // BAUD1200
  43. };
  45. void SetBaud(int baud);
  46. void Delay_8_33ms(void);
  47. void Init_UART1(void);
  48. void Init_CLK(void);
  49. void Init_TimerA(void);
  51. void Init_UART1(void)
  52. {
  53. //将寄存器的内容清零
  54.     U1CTL = 0X00;
  55. //数据位为8bit
  56.     U1CTL += CHAR;
  57.     
  58. //将寄存器的内容清零
  59.     U1TCTL = 0X00;
  60. //波特率发生器选择SMCLK
  61.     U1TCTL += SSEL1;     
  62. //波特率为115200
  63.     UBR0_1 = 0X45;
  64.     UBR1_1 = 0X00;
  65. //调整寄存器
  66.     UMCTL_1 = 0X00;
  68. //使能UART1的TXD和RXD
  69.     ME2 |= UTXE1 + URXE1; 
  70. //使能UART1的RX中断
  71.     IE2 |= URXIE1;
  72. //使能UART1的TX中断
  73.     IE2 |= UTXIE1;
  74.     
  75. //设置P3.6为UART1的TXD
  76.     P3SEL |= BIT6;
  77. //设置P3.7为UART1的RXD
  78.     P3SEL |= BIT7;     
  79. //P3.6为输出管脚
  80.     P3DIR |= BIT6;
  81.     return;
  82. }
  83. void Init_Port(void)
  84. {
  85.     //将所有的管脚在初始化的时候设置为输入方式
  86.     P3DIR = 0;
  87.     //将所有的管脚设置为一般I/O口
  88.     P3SEL = 0;
  89.     return;
  90. }
  91. // 初始定时器模块
  92. void Init_TimerA(void)
  93. {
  94. // 选择SMCLK，清除TAR
  95.     TACTL = TASSEL1 + TACLR;  
  96. // 1/8 SMCLK
  97.     TACTL += ID1;
  98.     TACTL += ID0; 
  99. // CCR0 中断允许
  100.     CCTL0 = CCIE;
  101. // 时间间隔为 33.8ms
  102.     CCR0 = 33800;
  103. // 增记数模式
  104.     TACTL |= MC0;     
  105. }
  106. void Init_CLK(void)
  107. {
  108.     unsigned int i;
  109. //将寄存器的内容清零
  110. //XT2震荡器开启
  111. //LFTX1工作在低频模式
  112. //ACLK的分频因子为1
  113.     BCSCTL1 = 0X00;
  115.     do 
  116.     {
  117. IFG1 &= ~OFIFG;                       // 清除OSCFault标志
  118. for (i = 0x20; i > 0; i--);                
  119.     }
  120.     while ((IFG1 & OFIFG) == OFIFG);      // 如果OSCFault =1   
  122.     BCSCTL2 = 0X00; //将寄存器的内容清零
  123.     BCSCTL2 += SELM1; //MCLK的时钟源为TX2CLK，分频因子为1
  124.     BCSCTL2 += SELS; //SMCLK的时钟源为TX2CLK，分频因子为1
  125. }
  126. ///////////////////////////////////////
  127. // 处理来自串口 1 的接收中断
  128. interrupt [UART1RX_VECTOR] void UART1_RX_ISR(void)
  129. {
  130.     //接收来自的数据 
  131.     UART1_RX_BUF[nRX1_Len_temp] = RXBUF1;
  132.     nRX1_Len_temp += 1;        
  133.     if(UART1_RX_BUF[nRX1_Len_temp - 1] == 13)
  134.     {
  135.      nRX1_Len = nRX1_Len_temp;
  136.      nRev_UART1 = 1;
  137.      nRX1_Len_temp = 0;
  138.     }
  139. }
  140. ///////////////////////////////////////
  141. // 处理来自串口 1 的发送中断
  142. interrupt [UART1TX_VECTOR] void UART1_TX_ISR(void)
  143. {
  144.     if(nTX1_Len != 0)
  145.     {
  146. // 表示缓冲区里的数据没有发送完
  147.      nTX1_Flag = 0;     
  148.      TXBUF1 = UART1_TX_BUF[nSend_TX1];
  149.      nSend_TX1 += 1;    
  150.      if(nSend_TX1 >= nTX1_Len)
  151.      {
  152.          nSend_TX1 = 0;
  153.          nTX1_Len = 0;
  154.          nTX1_Flag = 1;
  155.      }
  156.     }
  157. }
  158. // 定时器中断
  159. interrupt [TIMERA0_VECTOR] void TimerA_ISR(void)
  160. {
  161.     nTime_Flag = 1;
  162. // CCR0 不中断允许
  163.     CCTL0 &= ~CCIE;
  164. }
  165. void SetBaud(int baud)
  166. {
  167. //停止UART
  168. U1CTL |= SWRST;
  169. //禁止中断
  170. ME2 &= ~(UTXE0 + URXE0); 
  172. //设置寄存器
  173. UBR0_1 = baudregs[baud].ubr00;
  174. UBR1_1 = baudregs[baud].ubr01;
  175. UMCTL_1 = baudregs[baud].umctl0;
  176. //使能中断
  177. ME2 |= UTXE0 + URXE0;
  178. //UART模块允许
  179. U1CTL &= ~SWRST;
  180. }
  181. int AutoBaud(void)
  182. {
  183. baudrates rate;
  185. //UART复位
  186. U1CTL |= SWRST;
  187. //接收出错中断允许位
  188. URCTL1 = URXEIE; 
  189. //UART模块允许
  190. U1CTL &= ~SWRST; 
  191. //设置速率位115200
  192. SetBaud(BAUD115200);
  193. //接收字符
  194. switch (GetChar()) 
  195. {
  196. case 0x0d :
  197. rate = BAUD115200;
  198. break;
  199. case 0xe6 :
  200. rate = BAUD57600;
  201. break;
  202. case 0x1c :
  203. rate = BAUD38400;
  204. break;
  205. case 0xe0 :
  206. rate = BAUD19200;
  207. break;
  208. case 0x80 :
  209. rate = BAUD14400;
  210. break;
  211. case 0x00 :
  212. {
  213. // CCR0 中断允许
  214.         CCTL0 = CCIE;
  215. //延时33.8ms
  216. while(1)
  217. {
  218. if(nTime_Flag == 1)
  219. {
  220. nTime_Flag = 0;
  221. break;
  222. }
  223. }
  224. //设置速率位9600
  225. SetBaud(BAUD9600);
  226. //接收字符
  227. switch (GetChar())  
  228. {
  229. case 0x0d : 
  230. rate = BAUD9600;
  231. break;
  232. case 0xe6 :
  233. rate = BAUD4800;
  234. break;
  235. case 0x78 :
  236. rate = BAUD2400;
  237. break;
  238. case 0x80 :
  239. rate = BAUD1200;
  240. break;
  241. default :
  242. return -1;
  243. }
  244. break;
  245. }
  246. default :
  247. return -1;
  248. }
  250. // CCR0 中断允许
  251.     CCTL0 = CCIE;
  252. //延时33.8ms
  253. while(1)
  254. {
  255. if(nTime_Flag == 1)
  256. {
  257. nTime_Flag = 0;
  258. break;
  259. }
  260. }
  261. SetBaud(rate);
  262. return 0;
  263. }
  264. char GetChar(void)
  265. {
  266.   while (!(IFG2 & URXIFG1));
  267.   return RXBUF1;
  268. }