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

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

DSP编程

开发平台：

C/C++

motor.c：源码内容
  1. #include  <msp430x14x.h>
  3. #define DCO_FREQ        1000000      // DCO frequency
  4. #define ONE_SEC_CNT     512          // Number of WDT interrupts in 1 second
  5. #define DEBOUNCE_CNT    0x05         // (1/512)*5 = ~10 msec debounce
  7. #define DIR_MASK        0x01         // 0x01 is clockwise, 0x00 is counter-clockwise
  8. #define STEP_MASK       0x02         // 0x00 is full-stepping, 0x02 is half-stepping
  9. #define MOTION_MASK     0x04         // 0x00 is continuous, 0x04 is single-step
  11. #define DEFAULT_RATE     0x8000      // Default stepping rate
  12. #define MIN_RATE         0x8000      // Minimum stepping rate
  13. #define MAX_RATE         0x0800      // Maximum stepping rate
  15. // Default state is full-stepping, clockwise, continuous
  16. unsigned char state = 1;             // State variable
  17. unsigned char stepIndex = 0;         // State table index
  18. unsigned int  rate = DEFAULT_RATE;   // Stepping rate
  19. unsigned char change_rate_flag = 0;  // Flag indicating rate change
  20. unsigned int  max_rate = MAX_RATE;   // Maximum stepping rate
  21. unsigned int  min_rate = MIN_RATE;   // Minimum stepping rate
  23. unsigned int SW[4]; 
  26. void sys_init(void);
  27. void Set_DCO(unsigned long freq);
  28. void timerA_Init(void);
  29. void uart0_Init(void);
  30. void wdt_Init(void);
  32. void toggle_stepping_mode(void);
  33. void increase_stepping_rate(void);
  34. void decrease_stepping_rate(void);
  35. void toggle_motion(void);
  36. void toggle_direction(void);
  38. //定义串口操作变量
  39. char nRev_UART0; // 串口 0 的接收标志
  40. char UART0_TX_BUF[10]; // 串口 0 的发送缓冲区
  41. char UART1_RX_Temp[10];
  42. char UART0_RX_BUF[10]; // 串口 0 的接收缓冲区
  43. int nTX0_Len;
  44. int nRX0_Len;
  45. int nRX0_Len_temp;
  46. char nTX0_Flag;
  47. int nSend_TX0;
  50. // 整步状态表A
  51. static const unsigned char fullStepA[] =
  52. {
  53. 0x00,
  54. 0x00,
  55. 0x01,
  56. 0x01
  57. };
  58. //  半步状态表B
  59. static const unsigned char fullStepB[] =
  60. {
  61. 0x01,
  62. 0x00,
  63. 0x00,
  64. 0x01
  65. };
  66. // 半步状态表A
  67. static const unsigned char HalfStepA[] =
  68. {
  69. 0x01,   // 001   1
  70. 0x06,   // 110   2
  71. 0x00,   // 000   3
  72. 0x00,   // 000   4
  73. 0x00,   // 000   5
  74. 0x07,   // 111   6
  75. 0x01,   // 001   7
  76. 0x01    // 001   8
  77. };
  78. // 逆时钟、半步状态表B
  79. static const unsigned char CcwHalfStepB[] =
  80. {
  81. 0x01,   // 001   1
  82. 0x01,   // 001   2
  83. 0x01,   // 001   3
  84. 0x06,   // 110   4
  85. 0x00,   // 000   5
  86. 0x00,   // 000   6
  87. 0x00,   // 000   7
  88. 0x07    // 111   8
  89. };
  92. // 顺时钟、半步状态表B
  93. static const unsigned char CwHalfStepB[] =
  94. {
  95. 0x00,   // 000   1
  96. 0x00,   // 000   2
  97. 0x00,   // 000   3
  98. 0x07,   // 111   4
  99. 0x01,   // 001   5
  100. 0x01,   // 001   6
  101. 0x01,   // 001   7
  102. 0x06    // 110   8
  103. };
  104. void main(void)
  105. {
  106. int i;
  107. // 停止WDT
  108. WDTCTL = WDTPW + WDTHOLD;
  109. sys_init();
  111. _EINT();
  113. for(;;)
  114. {
  115. if(nRev_UART0 == 1)
  116.      {
  117.          nRev_UART0 = 0;
  118. for(i = 0;i < nRX0_Len;i++) UART1_RX_Temp[i] = UART0_RX_BUF[i];
  119. if((UART1_RX_Temp[0] == 'A') && (UART1_RX_Temp[1] == 'T'))
  120. {
  121. UART0_TX_BUF[0] = 'O';
  122. UART0_TX_BUF[1] = 'K';
  123. UART0_TX_BUF[2] = 13;
  124. nTX0_Len = 3;
  125. switch(UART1_RX_Temp[2])
  126. {
  127. case 'D': // 方向
  128. toggle_direction();
  129. break;
  130. case 'C': // 运动模式
  131. toggle_motion();
  132. break;
  133. case 'M': // 步进模式
  134. toggle_stepping_mode();
  135. break;
  136. case 'F': // 增加速率
  137. increase_stepping_rate();
  138. break;
  139. case 'S': // 降低速率
  140. decrease_stepping_rate();
  141. break;
  142. default: break;
  143. }
  144. }
  145. else
  146. {
  147. UART0_TX_BUF[0] = 'E';
  148. UART0_TX_BUF[1] = 'R';
  149. UART0_TX_BUF[2] = 'O';
  150. UART0_TX_BUF[3] = 'R';
  151. UART0_TX_BUF[4] = 'R';
  152. UART0_TX_BUF[5] = 13;
  153. nTX0_Len = 6;
  154. }
  155. // 设置中断标志，进入发送中断程序
  156. IFG1 |= UTXIFG0;
  157.      nRX0_Len = 0;
  158. }
  159. }
  160. }
  162. void sys_init(void)
  163. {
  164. // 设置下降沿触发中断
  165. P1IES = 0x0f;
  166. P1IFG = 0x00;
  167. P1IE = 0x0f;
  169. // 设置 P2.3,2,1,0 为输出
  170. // 设置 P3.3,2,1,0 为输出
  171. P2OUT = 0x00;
  172. P3OUT = 0x00;
  173. P2DIR |= 0x0f;
  174. P3DIR |= 0x0f;
  176. // 设置DCO
  177. Set_DCO(DCO_FREQ);
  179. // 初始化 Timer A
  180. timerA_Init();
  182. // 初始化 UART0
  183. uart0_Init();
  185. // 初始化 WDT
  186. wdt_Init();
  187. }
  188. void Set_DCO(unsigned long freq)
  189. {
  190. unsigned int clkCnt;
  191. unsigned int numDcoClks;
  192. unsigned int prevCnt = 0;
  194. // ACLK = LFXT1CLK/8 = 4096 Hz
  195. BCSCTL1 |= DIVA_3;                   
  196. numDcoClks = freq/4096;              
  198. TACCTL2 = CM_1 + CCIS_1 + CAP;
  199. TACTL = TASSEL_2 + MC_2 + TACLR;     
  200. while(1)
  201. {
  202. while( !(TACCTL2 & CCIFG) )
  203. {
  204. }
  206. TACCTL2 &= ~CCIFG;
  207. clkCnt = TACCR2 - prevCnt;
  208. prevCnt = TACCR2;
  210. if( numDcoClks == clkCnt )
  211. {
  212. break;
  213. }
  214. else if( clkCnt > numDcoClks )
  215. {
  216. DCOCTL--;
  218. if( DCOCTL == 0xFF )
  219. {
  220. if( BCSCTL1 & 0x07 )
  221. {
  222. BCSCTL1--;
  223. }
  224. else
  225. {
  226. break;
  227. }
  228. }
  229. }
  230. else
  231. {
  232. DCOCTL++;
  233. if( DCOCTL == 0x00 )
  234. {
  235. if( (BCSCTL1 & 0x07) != 0x07 )
  236. {
  237. BCSCTL1++;                   
  238. }
  239. else
  240. {
  241. break;
  242. }
  243. }
  244. }
  245. }
  246. // ACLK = LFXT1CLK/1 = 32768 Hz
  247. BCSCTL1 &= ~DIVA_3;                  
  249. TACCTL2 = 0; 
  250. TACTL = 0;
  251. }
  252. void wdt_Init(void)
  253. {
  254. // 设置时钟源为ACLK，1秒内产生512此
  255. WDTCTL = WDTPW + WDTTMSEL + WDTCNTCL + WDTSSEL + WDTIS0 + WDTIS1;
  256. }
  258. void uart0_Init(void)
  259. {
  260.     //将寄存器的内容清零
  261.     U0CTL = 0X00;
  262. //数据位为8bit
  263.     U0CTL += CHAR;
  264.     
  265.     U0TCTL = 0X00;
  266. //波特率发生器选择ACLK
  267.     U0TCTL += SSEL0;
  268.     
  269. //波特率为9600
  270.     UBR0_0 = 0X03;
  271.     UBR1_0 = 0X00;
  272.     UMCTL_0 = 0x4A;
  273.     //使能UART0的TXD和RXD
  274.     ME1 |= UTXE0 + URXE0; 
  275. //使能UART0的RX中断
  276.     IE1 |= URXIE0;
  277. //使能UART0的TX中断
  278.     IE1 |= UTXIE0;
  279.     
  280. //设置P3.4为UART0的TXD
  281.     P3SEL |= BIT4;
  282. //设置P3.5为UART0的RXD
  283.     P3SEL |= BIT5;
  284.     //P3.4为输出管脚
  285.     P3DIR |= BIT4;
  286. }
  288. void timerA_Init(void)
  289. {
  290. TACCR0 = rate;
  291. TACCTL0 = CCIE;
  292. TACTL = TASSEL_2 + MC_1 + TACLR;
  293. }
  294. interrupt [TIMERA0_VECTOR] void TimerA_ISR(void)
  295. {
  296. unsigned char index;
  297. unsigned char p2 = 0;
  298. unsigned char p3 = 0;
  300. // 判断步进速率是否需要改变
  301. if( change_rate_flag )
  302. {
  303. TACCR0 = rate;
  304. change_rate_flag = 0;
  305. }
  307. // 判断状态
  308. switch( (state & 0x3) )
  309. {
  310. case 0x00:  // 整步、逆时钟方向
  311. index = stepIndex & 0x03;
  312. p2 |= fullStepA[index];
  313. p3 |= fullStepB[index];
  314. P2OUT = p2;
  315. P3OUT = p3;
  316. ++stepIndex;
  317. break;
  318. case 0x01:  // 整步、顺时钟方向
  319. index = stepIndex & 0x03;
  320. p3 |= fullStepA[index];
  321. p2 |= fullStepB[index];
  322. P3OUT = p3;
  323. P2OUT = p2;
  324. ++stepIndex;
  325. break;
  326. case 0x02:  // 半步、逆时钟方向
  327. index = stepIndex & 0x07;
  328. p2 |= HalfStepA[index];
  329. p3 |= CcwHalfStepB[index];
  330. P2OUT = p2;
  331. P3OUT = p3;
  332. ++stepIndex;
  333. break;
  334. case 0x03:  // 半步、顺时钟方向
  335. index = stepIndex & 0x07;
  336. p3 |= CwHalfStepB[index];
  337. p2 |= HalfStepA[index];
  338. P3OUT = p3;
  339. P2OUT = p2;
  340. ++stepIndex;
  341. break;
  342. default: break;
  343. }
  345. // 如果单步状态下，禁止定时器中断
  346. if( state & MOTION_MASK )
  347. {
  348. TACCTL0 &= ~CCIE;
  349. }
  350. }
  351. ////////////////////////////////////////
  352. // 处理来自串口 0 的接收中断
  353. interrupt [UART0RX_VECTOR] void UART0_RX_ISR(void)
  354. {
  355. //接收来自的数据
  356.     UART0_RX_BUF[nRX0_Len_temp] = RXBUF0;
  357.     
  358.     nRX0_Len_temp += 1;
  359.         
  360.     if(nRX0_Len_temp >= 2)
  361.     if(UART0_RX_BUF[nRX0_Len_temp - 2] == 'r' && 
  362. UART0_RX_BUF[nRX0_Len_temp - 1] == 'n')
  363.     {
  364. // 过滤掉回车换行(rn)
  365.      if(nRX0_Len_temp == 2)
  366.      {
  367.          nRX0_Len_temp = 0;
  368.      }
  369.      else if(nRX0_Len_temp > 2)
  370.      {
  371.          nRX0_Len = nRX0_Len_temp;
  372.          nRev_UART0 = 1;
  373.          nRX0_Len_temp = 0;
  374.      }    
  375.     }
  377. }
  378. ////////////////////////////////////////
  379. // 处理来自串口 0 的发送中断
  380. interrupt [UART0TX_VECTOR] void UART0_TX_ISR(void)
  381. {
  382.     if(nTX0_Len != 0)
  383.     {
  384. // 表示缓冲区里的数据没有发送完
  385.      nTX0_Flag = 0;
  386.     
  387.      TXBUF0 = UART0_TX_BUF[nSend_TX0];
  388.      nSend_TX0 += 1;    
  389.      if(nSend_TX0 >= nTX0_Len)
  390.      {
  391.          nSend_TX0 = 0;
  392.          nTX0_Len = 0;
  393.          nTX0_Flag = 1;
  394.      }
  395.     }
  396. }
  397. interrupt [WDT_VECTOR] void WDT_ISR(void)
  398. {
  399. unsigned char sw_state;
  400. static unsigned char one_sec_flag = 0;
  402. // 获得P1口的输入
  403. sw_state = ~P1IN & 0x0f;
  405. // 判断是否有键按下
  406. if( sw_state == 0x00 )
  407. {
  408. // 禁止看门狗中断
  409. IE1 &= ~WDTIE;
  411. // 判断是否S2的激活状态小于1秒
  412. if( !one_sec_flag && (SW[1] >= DEBOUNCE_CNT) )
  413. {
  414. toggle_motion();
  415. }
  417. // 复位状态计数器
  418. SW[0] = 0;
  419. SW[1] = 0;
  420. SW[2] = 0;
  421. SW[3] = 0;
  423. // 复位标志
  424. one_sec_flag = 0;
  426. // 使能P1口的中断功能
  427. P1IFG = 0x00;
  428. P1IE = 0x0f;
  429. }
  430. else
  431. {
  432. // 检查是否是S1状态
  433. if( sw_state & 0x01 )
  434. {
  435. if( SW[0] < ONE_SEC_CNT )
  436. {
  437. // 增加状态计数器
  438. ++SW[0];
  439. }
  441. if( SW[0] == DEBOUNCE_CNT )
  442. {
  443. toggle_direction();
  444. }
  445. }
  446. else
  447. {
  448. SW[0] = 0;
  449. }
  451. // 检查是否是S2状态
  452. if( sw_state & 0x02 )
  453. {
  454. if( SW[1] < ONE_SEC_CNT )
  455. {
  456. // 增加状态计数器
  457. ++SW[1];
  458. }
  460. if( SW[1] == ONE_SEC_CNT )
  461. {
  462. toggle_stepping_mode();
  463. one_sec_flag = 1;
  464. SW[1] = 0;
  465. }
  466. }
  467. else
  468. {
  469. // 判断是否S2的激活状态小于1秒
  470. if( !one_sec_flag && (SW[1] >= DEBOUNCE_CNT) )
  471. {
  472. toggle_motion();
  473. }
  475. one_sec_flag = 0;
  476. SW[1] = 0;
  477. }
  479. // 检查是否是S3状态
  480. if( sw_state & 0x04 )
  481. {
  482. // 检查是否是连续模式
  483. if( (state & MOTION_MASK) == 0 )
  484. {
  485. if( SW[2] < ONE_SEC_CNT )
  486. {
  487. // 增加状态计数器
  488. ++SW[2];
  489. }
  491. if( SW[2] == DEBOUNCE_CNT )
  492. {
  493. increase_stepping_rate();
  494. }
  495. }
  496. else // 单步模式
  497. {
  498. // 增加状态计数器
  499. ++SW[2];
  501. if( (SW[2] % DEBOUNCE_CNT) == 0 )
  502. {
  503. increase_stepping_rate();
  504. }
  505. }
  506. }
  507. else  
  508. {
  509. SW[2] = 0;
  510. }
  512. // 检查是否是S4状态
  513. if( sw_state & 0x08 )
  514. {
  515. if( SW[3] < ONE_SEC_CNT )
  516. {
  517. // 增加状态计数器
  518. ++SW[3];
  519. }
  521. if( SW[3] == DEBOUNCE_CNT )
  522. {
  523. decrease_stepping_rate();
  524. }
  525. }
  526. else
  527. {
  528. SW[3] = 0;
  529. }
  530. }
  531. }
  532. interrupt [PORT1_VECTOR] void PORT1_ISR(void)
  533. {
  534. // 禁止端口1的中断
  535. P1IE = 0x00;
  537. // 清除端口1的中断标志
  538. P1IFG = 0x00;
  540. // 使能看门狗中断
  541. IE1 |= WDTIE;
  542. }
  543. void increase_stepping_rate(void)
  544. {
  545. unsigned int new_rate;
  547. // 检查是否是连续模式
  548. if( (state & MOTION_MASK) == 0 )
  549. {
  550. new_rate = rate >> 1;
  552. if( new_rate >= max_rate )
  553. {
  554. rate = new_rate;
  555. change_rate_flag = 1;
  556. }
  557. }
  559. //使能定时器A的中断
  560. TACCTL0 |= CCIE;
  561. }
  562. void decrease_stepping_rate(void)
  563. {
  564. // 检查是否是连续模式
  565. if( (state & MOTION_MASK) == 0 )
  566. {
  567. if( rate <= (min_rate >> 1) )
  568. {
  569. rate <<= 1;
  570. change_rate_flag = 1;
  571. }
  572. }
  574. // 使能定时器A的中断
  575. TACCTL0 |= CCIE;
  576. }
  577. void toggle_stepping_mode(void)
  578. {
  579. // 切换步进模式
  580. state ^= STEP_MASK;
  582. // 检查是否是半步模式
  583. if( state & STEP_MASK )
  584. {
  585. // 从整步模式切换到半步模式
  586. // 定时器的频率加倍
  587. rate = (rate >> 1);
  588. change_rate_flag = 1;
  589. max_rate = (MAX_RATE >> 1);
  590. min_rate = (MIN_RATE >> 1);
  591. }
  592. else // 整步模式
  593. {
  594. // 从半步模式切换到整步模式
  595. // 定时器的频率减半
  596. rate = (rate << 1);
  597. change_rate_flag = 1;
  598. max_rate = MAX_RATE;
  599. min_rate = MIN_RATE;
  600. }
  601. }
  603. void toggle_motion(void)
  604. {
  605. state ^= MOTION_MASK;
  607. // 检查是否是连续步进模式
  608. if( (state & MOTION_MASK) == 0 )
  609. {
  610. // 使能定时器中断
  611. TACCTL0 |= CCIE;
  612. }
  613. }
  614. void toggle_direction(void)
  615. {
  616. state ^= DIR_MASK;
  617. }