21ic电子技术开发论坛 › 单片机与嵌入式系统 › 德州仪器MCU › 【MCU方案】基于MSP430F149 和 MSP430F425的简易智能电 ...
123下一页
返回列表 发新帖我要提问本帖赏金: 3.10元(功能说明)

【MCU方案】基于MSP430F149 和 MSP430F425的简易智能电动车设计

[复制链接]
5767|50
 楼主| hbzjt2011 发表于 2015-6-11 09:53 | 显示全部楼层 |阅读模式
智能电动车, MCU, msp430f149, AC, 信号
本帖最后由 hbzjt2011 于 2015-6-11 22:42 编辑

【MCU方案】基于MSP430F149 和 MSP430F425的简易智能电动车设计

功能介绍：
         本小车以MSP超低功耗单片机系列MSP430F149和MSP430FE425为核心，完成寻迹、检测金属、避障、寻光、测速等功能。在机械结构上，对普通的小车作了改进，即用一个万用轮来代替两个前轮，使小车的转向更加灵敏。采用PWM 驱动芯片控制电机，红外传感器检测黑线，金属传感器检测铁片，光敏器件检测光强，红外 LED 和一体化接收头来避障。
方案描述：
         【系统框图】
                本系统以 MSP430F149 和 MSP430F425 为控制核心。整个硬件框图如下图所示：

                         【主控模块】
                MSP430 系列单片机是美国TI公司1996 年开始推向市场的一种 16 位的超低功耗的混合信号处理器。其之所以称之为混合信号处理器，主要是由于其针对实际应用需求，把许多模拟电路、数字电路和微处理器集成在一个芯片上，以提供“单片”解决方案。MSP430 单片机更适合于低功耗、高速实时控制以及数据计算，它拥有更多的片上资源供设计使用，是设计的不错选择。 由于本小车实现功能较多， 因此我们选择了 MSP430F149 和 MSP430FE425为双核心的系统。通过编写通信协议，完成其之间的串行通信。
                其中MSP430F149 主要完成电机驱动、寻迹、避障、寻光等功能，MSP430FE425 主要完成金属检测、测速、液晶显示等功能。
         【电机驱动模块】   
                    电机的驱动芯片选用 L298N 作为驱动芯片。工作稳定电机驱动信号由单片机提供，信号经过光耦隔离后，传至 PWM 控制芯片 L298N，通过 L298N 的输出脚与两个电机相连。      
       【寻迹模块】
                 当小车在白色地面行驶时，装在车下的红外发射管发射红外线信号，经白色反射后，被接收管接收，一旦接收管接收到信号，输出端将输出低电平；当小车行驶到黑线时，红外线信号被黑色吸收后，将输出高电平，从而实现了通过红线检测信号的功能。将检测到的信号送到单片机的 I/O 口，当 I/O 口检测到的信号为高电平时，表明红外光被地上的黑线吸收了，表明小车处在黑色的引线上；同理，当 I/O 口检测到的信号为低电平时，表明小车行驶在白色地面上。                                 反射式红外传感器 ST188 采用高发射功率红外广电二极管和高灵敏度光电晶体管组成。检测距离可调整范围为 4－15mm；采用非接触检测方式。

        【金属检测模块】
                  采用市售的接近开关，无信号时，探头输出高电平。检测到金属时，电平跳变为低，单片机再进行相应处理。相应金属传感器型号为 LJ18A3 型。
          【寻光避障模块】
                  寻光避障模块均设计为环状传感器结构，共排布若干个传感器组，每个传感器组包含红外收发模块和光敏电阻。
                  光源检测模块，光敏电阻A组到E组从不同方向采光，每个光敏电阻的电压信号进入单片机片内ADC，利用F149系列内置的ADC12模块，实现了对五个方向光强的采集。由ADC的值，判断光强不同来确定小车的趋光方向；同理，可设定一个阈值比较，得出一开关信号调节最终小车停在车库内。 避障模块，利用单片机定时器发出可调制的 38KHz 红外线，利用一体化接收头判断，再由小车执行相应的避障动作。
        【测距和显示模块】
                  利用磁钢和干簧管，在车轮上均匀粘贴若干磁钢。每当车轮上磁钢转动至干簧管处，单片机进行一次计数，结合车轮半径就能求出小车行进距离。
                  显示模块采用段码液晶来实现， FE425 上有专门的液晶接口， 可以很方便地实现电路。液晶采用 4-MUX 输入方式的 7 位半段码液晶。
原理图：
          主控板原理图及PCB:
         
          寻迹原理图及PCB:
           
           趋光避障原理图及PCB：
           

实物照片：




本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

打赏榜单

liuxing4585 打赏了 0.10 元 2015-07-01

21ic小喇叭 打赏了 3.00 元 2015-06-15

相关帖子
 楼主| hbzjt2011 发表于 2015-6-11 11:01 | 显示全部楼层
源码程序：
          MSP430F149 程序：1、main.c
复制
  1. #include <msp430x14x.h>
    

  2. #include "Sensor.h"
    

  3. #include "Clock.h"
    

  4. #include "dianji.h"
    

  5. #include "Avoid.h"
    

  6. #include "mean.h"
    

  7. #include "ADC12.h"
    

  8. #include "Uart.h"
    


  9. 


  10. 

  11. Start()
    

  12. { int i;
    

  13. for (i=0;i<=30000;i++);
    

  14. }
    


  15. 

  16. void main(void)
    

  17. { WDTCTL = WDTPW + WDTHOLD;
    

  18. BCS_Init();
    

  19. TB_Init();
    

  20. TimerAInit();
    

  21. Init_PWM_Driver();
    

  22. ADC12_Init();
    

  23. InitSensor();
    

  24. Port_Init();
    

  25. UART_Init149();
    

  26. Start();
    

  27. _EINT();
    

  28. while(1)
    

  29. {
    

  30. if(Flag_Stop == 0x01)
    

  31. {
    

  32. UART0_PutChar(0x08); //结束了
    

  33. }
    

  34. }
    

  35. }
2、Sensor.c
复制
  1. #include <MSP430X14X.h>
    

  2. #include "Clock.h"
    


  3. 

  4. //P1.1
    

  5. #define PSEN14_H P1OUT |= (BIT1)
    

  6. #define PSEN14_L P1OUT &= ~(BIT1)
    


  7. 

  8. //P1.2
    

  9. #define PSEN25_H P1OUT |= (BIT2)
    

  10. #define PSEN25_L P1OUT &= ~(BIT2)
    


  11. 

  12. //P1.3
    

  13. #define PSEN36_H P1OUT |= (BIT3)
    

  14. #define PSEN36_L P1OUT &= ~(BIT3)
    


  15. 

  16. /*
    

  17. 硬件上，5个IO口分别控制着5组传感器的电源
    

  18. 用宏定义把IO口置高置低预先定义好，用起来
    

  19. 方便，比如 PSEN14_H表示打开1号和4号传感器
    

  20. 的电源。PSEN14_L表示关闭1、4号传感器电源。
    

  21. */
    


  22. 

  23. #define SEN1_IN (P1IN & BIT4) /*P1.4*/
    

  24. #define SEN2_IN (P2IN & BIT2) /*P2.2*/
    

  25. #define SEN3_IN (P1IN & BIT6) /*P1.6*/
    

  26. #define SEN4_IN (P1IN & BIT7) /*P1.7*/
    

  27. #define SEN5_IN (P2IN & BIT0) /*P2.0*/
    

  28. #define SEN6_IN (P2IN & BIT1) /*P2.1*/
    


  29. 

  30. //6只传感器的输入
    


  31. 

  32. #define P_coefficient 600
    

  33. #define I_coefficient 0
    

  34. #define D_coefficient 300
    

  35. #define High_v 1000
    

  36. #define Low_v 950
    

  37. #define No_black 5000//找不到黑线时的转弯量控制
    

  38. #define No_f_black 6000//前边找不到黑线时的转弯量控制
    


  39. 

  40. signed char Last_Position[10]; //声明数组，用于依次存放前5次的黑线位置。
    

  41. unsigned char SensorData[6];//声明8个字节的数组，用于存放6个传感器读回值
    

  42. signed int R_up=-600;//无黑线时初始旋转半径
    

  43. signed int R_add=100;//旋转半径增加量
    


  44. 

  45. signed char Go_On_Black();
    

  46. void Handle_No_Black();
    


  47. 

  48. void InitSensor() //初始化传感器
    

  49. {
    

  50. P1DIR |=(BIT1+BIT2+BIT3); //设为输出,控制传感器电源
    

  51. //P4DIR |=(BIT0+BIT1); //BEEP P4.1 LED P4.0
    

  52. //P4OUT &=~(BIT0 + BIT1);
    

  53. }
    


  54. 

  55. void Beep_On()//LED,蜂鸣器函数，用定时器控制，不占用CPU
    

  56. { //int i;
    

  57. // P4OUT |=BIT1; //蜂鸣器开始响
    

  58. //P4OUT |= BIT0; //发光
    

  59. //P4OUT |=BIT1;
    


  60. 

  61. }
    


  62. 


  63. 

  64. signed char Caculate_Position(unsigned char *SensData) //计算黑线位置的函数
    

  65. {
    

  66. //由存有6个传感器输入值的数祖，计算黑线位置。
    

  67. signed char i,j,SensorPosition;
    

  68. for(i=0;i<6;i++) //从左往右数，
    

  69. {
    

  70. if(SensData[i]!=0) break; //找第一个读到黑线的传感器编号i
    

  71. }
    

  72. for(j=5;j>=0;j--) //从右往左数，
    

  73. {
    

  74. if(SensData[j]!=0) break; //找第一个读到黑线的传感器编号j
    

  75. }
    

  76. SensorPosition=(i+j)*10/2-25; //黑线中心位置就是(i+j)/2
    

  77. //返回值为-25到+25
    

  78. if(i==6) return(0x80); //如果全白(找不到黑线)，就返回-128，作为出错标志。
    

  79. return(SensorPosition); //将计算结果返回
    

  80. }
    


  81. 

  82. signed char ReadSensor()//从传感器读取小车当前位置
    

  83. {
    

  84. unsigned char SensorData[6];//声明10个字节的数组，用于存放10个传感器读回值
    

  85. signed char position;
    

  86. unsigned char i;
    


  87. 

  88. PSEN14_H ; //打开1、4号传感器电源
    

  89. Delay(32); //略延迟，等待数据稳定
    

  90. SensorData[0]=SEN1_IN; //读1号传感器
    

  91. SensorData[3]=SEN4_IN; //读4号传感器(注意数组下标从0开始，编号少1)
    

  92. PSEN14_L ; //关闭1、4号传感器电源
    


  93. 

  94. PSEN25_H ; //打开2、5号传感器电源
    

  95. Delay(32); //略延迟，等待数据稳定
    

  96. SensorData[1]=SEN2_IN; //读2号传感器
    

  97. SensorData[4]=SEN5_IN; //读5号传感器
    

  98. PSEN25_L ; //关闭2、5号传感器电源
    


  99. 

  100. PSEN36_H ;
    

  101. Delay(32);
    

  102. SensorData[2]=SEN3_IN;
    

  103. SensorData[5]=SEN6_IN;
    

  104. PSEN36_L ;
    


  105. 

  106. //读取的6个传感器的状态，存入了SensorData[]里面
    

  107. for(i=0;i<6;i++) //这样读回的数据，0表示白线，不为0的其他数据表示黑线
    

  108. { //为表示方便，将不为0的其他数据统统变成1
    

  109. if(SensorData[i]==0)SensorData[i]=0;
    

  110. else SensorData[i]=1; //黑线对应的数组单元存1；白线存0。
    

  111. }
    

  112. position=Caculate_Position(SensorData);//调用Caculate_Position()函数，计算黑线位置
    

  113. return(position); //将黑线位置的计算结果返回
    

  114. }
    


  115. 

  116. /*PID(PD)控制算法*/
    

  117. int PID_Control(signed char Position)
    

  118. {
    

  119. //PID算法。这里只用了P和D。
    

  120. int Temp_P,Temp_D,Temp_PID,Temp_I,k; //声明三个变量，用于存放P、I、D三分量的运算结果(I没用上)
    

  121. if(Position==-128) return (No_black); //错误处理(值得改进的地方)
    

  122. else
    

  123. {
    

  124. Temp_I=Position;
    

  125. for(k=0;k<5;k++)Temp_I+=Last_Position[k];
    

  126. Temp_I*=I_coefficient;
    

  127. Temp_P=P_coefficient*Position; //计算比例分量(P)=比例系数*本次位置差
    

  128. Temp_D=D_coefficient*(Position-Last_Position[5]); //计算微分分量(D)=微分系数*(本次位置差-前3次的位置差)
    

  129. //注意由于采样比较快，用本次位置-前3次位置才有足够大的控制量
    

  130. Last_Position[9]=Last_Position[8];
    

  131. Last_Position[8]=Last_Position[7];
    

  132. Last_Position[7]=Last_Position[6];
    

  133. Last_Position[6]=Last_Position[5];
    

  134. Last_Position[4]=Last_Position[3]; //微分量会把随机噪音放大，如果采样间隔太小，得到的几乎全是噪音
    

  135. Last_Position[3]=Last_Position[2]; //如果单纯加大采样间隔，比例环节采样也会间隔加大，控制精度难以保证
    

  136. Last_Position[2]=Last_Position[1]; //所以采样还是用较高速采样，微分环节采用本次-　前K次的方法降低采样速率。
    

  137. Last_Position[1]=Last_Position[0]; /*这种方法还有一定的滤波降噪效果（同学们自己推算一下）。标准的实用PID程序微分环节前还要有一次滤波，这里就省去了(本次-前K次就是简易的均值虑波)。*/
    

  138. Last_Position[0]=Position; /*保存前5次的位置，以备用。同学们可以试验一下改变K值的效果，自己摸索最佳值。 */
    

  139. Temp_PID=Temp_P+Temp_D+Temp_I; //P分量和D分量相加，得到控制量。
    

  140. if(Temp_PID>5000) Temp_PID=5000; //防止控制量溢出
    

  141. if(Temp_PID<-5000) Temp_PID=-5000; //控制量-2500~2500作为左右满舵
    

  142. Temp_PID=Temp_PID*1/5; //-1000~+1000是左右满舵的输出，因此需要除以0.5
    

  143. /*单片机浮点运算非常慢，所以用乘2除5两次定点运算来替代定点数要先乘后除，才能保证精度，同时要防止溢出，用起来比较麻烦，但CPU和内存开销小。*/
    

  144. return (Temp_PID);
    

  145. }
    

  146. }
    


  147. 

  148. //右电机由CCR2,CCR3控制，CCR2高时为正转
    

  149. //左电机右CCR4,CCR5控制，CCR4高时为正转
    

  150. /*设置小车转弯量*/
    

  151. void Set_Rotation (int Rotation)
    

  152. //用-1000~+1000表示左转满舵~右转满舵
    

  153. {
    

  154. //if(Rotation==No_black)
    

  155. //Handle_No_Black();
    

  156. //else
    

  157. if(Rotation>0) //Rotation大于0是右转，
    

  158. {
    

  159. TBCCR2=High_v; //右轮减速,
    

  160. TBCCR3=0;
    

  161. TBCCR4=High_v-Rotation; //左轮全速前进,
    

  162. TBCCR5=0;
    

  163. }
    

  164. else //Rotation小于0是左转
    

  165. {
    

  166. TBCCR4=High_v; //左轮减速（注意Rotation是负值，加运算就是减速）
    

  167. TBCCR5=0;
    

  168. TBCCR3=0;
    

  169. TBCCR2=High_v+Rotation; //左轮全速
    


  170. 

  171. }
    


  172. 

  173. }
    


  174. 


  175. 

  176. /*错误处理 */
    

  177. void Handle_No_Black()
    

  178. {
    

  179. signed int j;
    

  180. signed char L_l,L_r;
    

  181. L_l=Last_Position[0];
    

  182. L_r=Last_Position[9];
    

  183. Last_Position[0]=0;Last_Position[1]=0;Last_Position[2]=0;Last_Position[3]=0;Last_Position[4]=0;
    

  184. Last_Position[5]=0;Last_Position[6]=0;Last_Position[7]=0;Last_Position[8]=0;Last_Position[9]=0;
    

  185. if(L_l<=L_r)
    

  186. {
    

  187. TBCCR4=High_v-30; //右轮全速前进
    

  188. TBCCR5=0;
    

  189. for(;R_up<=High_v;)
    

  190. {
    

  191. if(R_up<0)
    

  192. {
    

  193. TBCCR2=0;
    

  194. TBCCR3=-R_up; //左轮减速
    

  195. R_up+=(2*R_add);
    

  196. }
    

  197. else
    

  198. {
    

  199. TBCCR2=R_up;
    

  200. TBCCR3=0; //左轮减速
    

  201. R_up+=R_add;
    

  202. }
    

  203. if(R_up>High_v){R_up=-600;break;}
    

  204. for(j=0;j<(700+R_up)/2;j++)
    

  205. {
    

  206. if(Go_On_Black()==5)continue;
    

  207. else break;
    

  208. }
    

  209. if(Go_On_Black()==5)continue;
    

  210. else break;
    

  211. }
    

  212. }
    

  213. else
    

  214. {
    

  215. TBCCR2=High_v; //左轮全速前进
    

  216. TBCCR3=0;
    

  217. for(;R_up<=High_v;)
    

  218. {
    

  219. if(R_up<0)
    

  220. {
    

  221. TBCCR5=-R_up;
    

  222. TBCCR4=0; //右轮减速
    

  223. R_up+=(2*R_add);
    

  224. }
    

  225. else
    

  226. {
    

  227. TBCCR5=0;
    

  228. TBCCR4=R_up; //右轮减速
    

  229. R_up+=R_add;
    

  230. }
    

  231. if(R_up>High_v){R_up=-600;break;}
    

  232. //for(j=0;j<(700+R_up)/2;j++)
    

  233. //{
    

  234. // if(Go_On_Black()==5)continue;
    

  235. //else break;
    

  236. // }
    

  237. //if(Go_On_Black()==5)continue;
    

  238. else break;
    

  239. }
    

  240. }
    

  241. R_up=-600;
    

  242. }
    


  243. 

  244. signed char Go_On_Black()
    

  245. {
    

  246. signed char left;
    

  247. PSEN14_H ; //打开1、4号传感器电源
    

  248. Delay(30); //略延迟，等待数据稳定
    

  249. SensorData[0]=SEN1_IN;
    

  250. SensorData[3]=SEN4_IN; //读4号传感器(注意数组下标从0开始，编号少1)
    

  251. PSEN14_L ; //关闭1、4号传感器电源
    


  252. 

  253. PSEN25_H ; //打开2、5号传感器电源
    

  254. Delay(30); //略延迟，等待数据稳定
    

  255. SensorData[1]=SEN2_IN; //读2号传感器
    

  256. SensorData[4]=SEN5_IN; //读5号传感器
    

  257. PSEN25_L; //关闭2、4号传感器电源
    


  258. 

  259. PSEN36_H ; //打开3号传感器电源
    

  260. Delay(30); //略延迟，等待数据稳定
    

  261. SensorData[2]=SEN3_IN; //读3号传感器
    

  262. SensorData[5]=SEN5_IN;
    

  263. PSEN36_L ; //关闭3号传感器
    

  264. for (left=0;left<=5;left++)
    

  265. {
    

  266. if (SensorData[left]!=0) break; //找第一个读到黑线的传感器编号i
    

  267. }
    

  268. return left;
    

  269. }
3、Clock.c
复制
  1. #ifndef _Clock_h
    

  2. #define _Clock_h
    

  3. //Clock.c
    

  4. #include "MSP430x14x.h"
    

  5. #include "Sensor.h"
    

  6. #include "Avoid.h"
    

  7. #include "Uart.h"
    

  8. #include "dianji.h"
    

  9. #include "mean.h"
    

  10. #include "ADC12.h"
    


  11. 

  12. unsigned int Parking5s=0;
    

  13. unsigned char Flag_Parking=0;
    

  14. unsigned long int interrupt_time1=0x00;
    

  15. unsigned long int interrupt_time2=0x00;
    

  16. int Rotation;
    

  17. signed char Position;
    


  18. 


  19. 

  20. // XT2高频晶振2失效标志检查
    

  21. void XT2_Init(void)
    

  22. {
    

  23. unsigned char i;
    

  24. BCSCTL1 &= ~(XT2OFF);
    

  25. do{
    

  26. IFG1 &= ~(OFIFG);
    

  27. for(i=0; i<100; i++)
    

  28. {
    

  29. _NOP();
    

  30. }
    

  31. }
    

  32. while((IFG1 & OFIFG) != 0);
    

  33. }
    


  34. 

  35. // 系统时钟初始化
    

  36. void BCS_Init(void)
    

  37. {
    

  38. XT2_Init();
    

  39. BCSCTL1 = DIVA_0 + RSEL0+ RSEL1 + RSEL2;//XT2开，XT1低频模式，高匹配电阻
    

  40. BCSCTL2 = SELM_2 + DIVM_0 + SELS + DIVS_0;//MCLK SMCLK选择XT2，不分频
    

  41. }
    


  42. 


  43. 

  44. void TimerAInit()
    

  45. { //设置数组，对应频率分别为38,41,44,48,54,60,67
    

  46. TACTL |= TASSEL_2 + TACLR + MC_1 ; //TIMER_A时钟源选为SMCLK,清TAR
    

  47. TACCR0 = 44; //产生约38KHZ的PWM输出,SMCLK=4M,105个时钟周期
    

  48. TACCTL0 |= OUTMOD_4; //翻转模式产生占空比为50％的PWM
    

  49. P1DIR |= BIT5; //从P1.5输出
    

  50. P1SEL |= BIT5;
    

  51. TACCR1=40; //10us中断一次
    

  52. TACCR2=40;
    

  53. TACCTL1|=CCIE; //两个中断，一个用于走黑线，一个避障，其它地方再打开
    

  54. TACCTL2&=~CCIE;
    


  55. 

  56. }
    


  57. 

  58. void Delay(unsigned char Time) //延迟程序
    

  59. {
    

  60. unsigned int i,k;
    

  61. for(k=0;k<Time;k++)
    

  62. for(i=0;i<Time;i++);
    

  63. }
    


  64. 


  65. 


  66. 


  67. 

  68. // TBCCO 中断服务
    

  69. #pragma vector = TIMERB0_VECTOR
    

  70. __interrupt void TBCC0_IRQ(void)
    

  71. { // unsigned char i;
    

  72. if(Flag_Parking == 1)
    

  73. Parking5s++;
    

  74. UART0_GetChar(Command);
    

  75. if(Command[0]==0x01)
    

  76. {
    

  77. //Delay5s();
    

  78. P4DIR|=BIT1;
    

  79. P4OUT&=~BIT1;
    

  80. Delay(100);
    

  81. P4OUT|=BIT1;
    

  82. Command[0]=0;
    

  83. }
    

  84. if(Command[0]==0x02) //02为检测到第三块时的停车命令，然后149自己延时5s
    

  85. {
    

  86. TACCTL1&=~CCIE;
    

  87. TACCTL2&=~CCIE;
    

  88. Flag_Parking =1;
    

  89. P4DIR|=BIT0;
    

  90. P4OUT|=BIT0;
    

  91. P4OUT|=BIT1;
    

  92. P4OUT&=~BIT1;
    

  93. Delay(100);
    

  94. P4OUT|=BIT1;
    

  95. //延时五秒函数
    

  96. Stop();
    


  97. 

  98. //TACCTL1&=~CCIE; //Unenable interrupt
    

  99. //TACCTL2&=~CCIE;
    


  100. 

  101. Command[0]=0;
    

  102. //
    

  103. }
    

  104. if(Flag_Stop == 0x01)
    

  105. {
    

  106. TACCTL1&= ~CCIE; //Unenable interrupt
    

  107. TACCTL2&= ~CCIE;
    

  108. Stop();
    


  109. 

  110. //for(i=0;i<5;i++)
    


  111. 

  112. }
    

  113. if(Parking5s == 160)
    

  114. {TACCTL2|=CCIE;
    

  115. P4OUT&=~BIT0;
    

  116. P4OUT&=~BIT1;
    

  117. Delay(100);
    

  118. P4OUT|=BIT1;
    

  119. Flag_Parking = 0;
    

  120. Parking5s++;
    

  121. }
    

  122. }
    


  123. 

  124. void TB_Init(void)
    

  125. {
    

  126. TBCTL = TBSSEL_1 + TBCLR + ID_0 + MC_0;
    

  127. TBCCR0 = 1024;
    

  128. TBCTL = TBSSEL_1 + TBCLR + ID_0 + MC_1;
    

  129. TBCCTL0 |= CCIE;
    


  130. 

  131. }
    


  132. 

  133. #pragma vector=TIMERA1_VECTOR //节拍控制
    

  134. __interrupt void Timer_A(void)
    

  135. {
    

  136. switch(TAIV)
    

  137. {
    

  138. case 2: interrupt_time1++;if(interrupt_time1==1000){Position=ReadSensor();// 检测黑线,计算位置
    

  139. Rotation=PID_Control(Position); // PID控制算法
    

  140. Set_Rotation(Rotation);//设置小车转弯量
    

  141. interrupt_time1=0x00;
    

  142. }
    

  143. break;
    

  144. case 4: interrupt_time2++;if(interrupt_time2==1000){ADC12_Deal();
    

  145. Measure_Light();
    

  146. Measure_Distance();
    

  147. FSM();
    

  148. //Find_Light();
    

  149. interrupt_time2=0x00;}
    

  150. break;
    

  151. default: break;
    

  152. }
    

  153. }
    


  154. 


  155. 

  156. void Interrupt_Stop()
    

  157. {
    

  158. TACCTL1&= ~CCIE; //Unenable interrupt
    

  159. TACCTL2&= ~CCIE;
    

  160. }
    


  161. 

  162. #endif
4、dianji.c
复制
  1. //右电机由CCR2,CCR3控制，CCR2高时为正转
    

  2. //左电机右CCR4,CCR5控制，CCR4高时为正转
    

  3. //线的顺序白，黑，绿，黄
    

  4. #include <msp430x14x.h>
    

  5. #include "dianji.h"
    

  6. #include "Clock.h"
    

  7. void Init_PWM_Driver() // 初始化电机驱动电路
    

  8. {
    

  9. P4DIR |=BIT6; //p4.6为使能端ENA
    

  10. P4DIR |=BIT7; //p4.7为使能端ENB
    

  11. P4OUT |=BIT6;
    

  12. P4OUT |=BIT7;
    

  13. P4DIR |=BIT5+BIT2+BIT3+BIT4;
    

  14. P4SEL |=BIT5+BIT2+BIT3+BIT4;
    

  15. TBCCTL2 |= OUTMOD_7;//TBCCR2输出为模式7,RESET/SET
    

  16. TBCCR2 =0; //P4.2口输出TB1__L1
    

  17. TBCCTL3 |= OUTMOD_7; //TBCCR2输出为模式7,SET/RESET
    

  18. TBCCR3 =0; //P4.3口输出TB2__L2
    

  19. TBCCTL4 |= OUTMOD_7; //TBCCR4输出为模式7,RESET/SET
    

  20. TBCCR4 =0; //P4.4口输出TB3__R2
    

  21. TBCCTL5 |= OUTMOD_7; //TBCCR5输出为模式7,RESET/SET
    

  22. TBCCR5 =0; //P4.5口输出TB4__R1
    

  23. TBCTL |= MC_1; //TIMER_B工作于增计数方式
    

  24. }
    


  25. 

  26. /*转弯部分*/
    

  27. void Turn_Left() //左转函数
    

  28. {TBCCR2=0;
    

  29. TBCCR3=0;
    

  30. TBCCR4=1000;
    

  31. TBCCR5=0;
    

  32. }
    

  33. void Turn_Right()//右转函数
    

  34. {TBCCR2=1000;
    

  35. TBCCR3=0;
    

  36. TBCCR4=0;
    

  37. TBCCR5=0;
    


  38. 

  39. }
    

  40. void Turn_Normal()//直行函数
    

  41. {TBCCR2=1000;
    

  42. TBCCR3=0;
    

  43. TBCCR4=1000;
    

  44. TBCCR5=0;
    

  45. }
    


  46. 

  47. void Turn_Back()//直退函数
    

  48. {TBCCR2=0;
    

  49. TBCCR3=1000;
    

  50. TBCCR4=0;
    

  51. TBCCR5=1000;
    

  52. }
    


  53. 

  54. void Stop()//停止函数
    

  55. {TBCCR5=0;
    

  56. TBCCR2=0;
    

  57. TBCCR3=0;
    

  58. TBCCR4=0;
    

  59. }
    


  60. 

  61. void Test()//测试运行
    

  62. { int i = 0;
    

  63. Turn_Right();
    

  64. for(i=0;i<100;i++)
    

  65. Delay(100);
    


  66. 

  67. Turn_Left();
    

  68. for(i=0;i<100;i++)
    

  69. Delay(100);
    


  70. 

  71. //Turn_Back();
    


  72. 

  73. }


回复

收藏 举报

 楼主| hbzjt2011 发表于 2015-6-11 11:01 | 显示全部楼层
5、Avoid.c
复制

  1. 

  2. #include <msp430x14x.h>
    

  3. #include "avoid.h"
    

  4. #include "dianji.h"
    

  5. #include "Clock.h"
    

  6. #include "mean.h"
    


  7. 

  8. #define Obstacle 300 //避障权值大于光强
    


  9. 

  10. unsigned char Status = 0; //寻光，避障选择初始状态设为0
    

  11. #define Light_Status 1 //寻光状态为1
    

  12. #define Barrier_Status 2 //避障状态为2
    


  13. 

  14. static unsigned char BarrierData[5]={0,0,0,0,0}; // 用来表记是否检测到障碍物，若有则置1；否则就清零
    

  15. static unsigned char flag = 0;//障碍标志
    


  16. 

  17. unsigned int cnt = 0;
    


  18. 

  19. void Port_Init()
    

  20. {
    

  21. P2DIR |= BIT7 + BIT6 +BIT5 + BIT4+ BIT3;
    

  22. P2OUT |= BIT7 + BIT6 +BIT5 + BIT4+ BIT3;
    

  23. }
    


  24. 


  25. 

  26. /*测障碍物*/
    

  27. //BarrierData的值离障碍物越近，数值越大，5是距离最近的，为0说明没有检测到
    

  28. void Measure_Distance()
    

  29. {
    

  30. unsigned char flag_1=0,flag_2=0,flag_3=0,flag_4=0,flag_0=0;
    

  31. //unsigned char i,Frequency[5] = {29,36,44,47,51}; //66,54,44,42,38
    

  32. // 1
    

  33. if(flag_0==0)
    

  34. {
    

  35. Delay(34);
    

  36. PIRE1_H; // 打开1号传感器
    

  37. Delay(34); // 延迟，等待数据稳定
    

  38. if(IRE1_IN==0) // 如果接收到的信号为低电平，表明前方有障碍物
    

  39. {flag_0 = 1;BarrierData[0]=1;}
    

  40. else BarrierData[0]=0;
    

  41. PIRE1_L;
    

  42. }
    

  43. //2
    

  44. if(flag_1==0)
    

  45. {
    

  46. Delay(34);
    

  47. PIRE2_H; // 打开2号传感器
    

  48. Delay(34); // 延迟，等待数据稳定
    

  49. if(IRE1_IN==0) // 如果接收到的信号为低电平，表明前方有障碍物
    

  50. {flag_1 = 1;BarrierData[1]=1;}
    

  51. else BarrierData[1]=0;
    

  52. PIRE2_L;
    

  53. }
    

  54. // 3
    

  55. if(flag_2==0)
    

  56. {
    

  57. PIRE3_H ; // 打开3号传感器　　　　
    

  58. Delay(34); // 延迟，等待数据稳定
    


  59. 


  60. 

  61. if(IRE3_IN==0) // 如果接收到的信号为低电平，表明右前方有障碍物
    

  62. {flag_2 = 1;BarrierData[2]=1;}
    

  63. else {BarrierData[2]=0;}
    

  64. PIRE3_L;
    

  65. // 关闭3号传感器
    

  66. }
    

  67. // 4
    


  68. 

  69. if(flag_3==0)
    

  70. {
    

  71. PIRE4_H ; // 打开4号传感器　　　　
    

  72. Delay(34); // 延迟，等待数据稳定
    


  73. 

  74. if(IRE4_IN==0) // 如果接收到的信号为低电平，表明右前方有障碍物
    

  75. {flag_3 = 1;BarrierData[3]=1;}
    

  76. else BarrierData[3]=0;
    

  77. PIRE4_L; // 关闭4号传感器
    

  78. }
    

  79. // 5
    

  80. if(flag_4==0)
    

  81. {
    

  82. Delay(34);
    

  83. PIRE5_H ; // 打开5号传感器　　　　
    

  84. Delay(34); // 延迟，等待数据稳定
    


  85. 

  86. if(IRE5_IN==0) // 如果接收到的信号为低电平，表明右前方有障碍物
    

  87. {flag_4 = 1;BarrierData[4]=1;}
    

  88. else BarrierData[4]=0;
    

  89. PIRE5_L; // 关闭5号传感器
    

  90. }
    


  91. 

  92. if(flag_0||flag_1||flag_2||flag_3||flag_4) //寻光与避障的切换
    

  93. {Status=2;flag=1;}
    

  94. else Status=Light_Status; //寻光
    

  95. }
    


  96. 


  97. 

  98. //
    


  99. 

  100. void Avoid_Obstacle()//采用矢量合成，与寻光不同，避障的推力为负，所以坐标取反
    

  101. { if(flag == 1)
    

  102. {
    

  103. if((BarrierData[3]+BarrierData[4])>0) //
    

  104. {
    

  105. Turn_Left();
    

  106. }
    

  107. else if((BarrierData[0]+BarrierData[1])>0)//右边没有障碍
    

  108. {
    

  109. Turn_Right();
    

  110. }
    

  111. else
    

  112. {
    

  113. Turn_Left();
    

  114. }
    


  115. 

  116. }
    

  117. else
    

  118. {
    

  119. Turn_Normal();
    

  120. }
    

  121. }
    


  122. 

  123. void FSM()
    

  124. { //Find_Light();
    

  125. switch (Status)
    

  126. {case Light_Status : Find_Light(); break;
    

  127. case Barrier_Status : Avoid_Obstacle(); break;
    

  128. default: break;
    

  129. }
    


  130. 

  131. }
    


  132. 

  133. //避障矢量合成的备份
    

  134. /*void Avoid_Obstacle()//采用矢量合成，与寻光不同，避障的推力为负，所以坐标取反
    

  135. { if(flag == 0) return;
    


  136. 

  137. else
    

  138. {
    

  139. //1号红外，X轴正向，Y为0
    

  140. x=x+Barrier[0]*BarrierData[0];
    

  141. //2号，X为正，Y为负，45°
    

  142. x=x+707*Barrier[1]*BarrierData[1]/1000;
    

  143. y=y-707*Barrier[1]*BarrierData[1]/1000;
    

  144. //3号，X为0，Y为负
    

  145. y=y-Barrier[2]*BarrierData[2];
    

  146. //4号，X为负，Y为负，45°
    

  147. x=x-707*Barrier[3]*BarrierData[3]/1000;
    

  148. y=y-707*Barrier[3]*BarrierData[3]/1000;
    

  149. //5号，Y为0，X为负
    

  150. x=x-Barrier[4]*BarrierData[4];
    

  151. }
    

  152. if (flag_ahead==0) y=1000;
    

  153. }
    

  154. */
    


  155. 

  156. /*带45°处理备份
    

  157. void Avoid_Obstacle()//采用矢量合成，与寻光不同，避障的推力为负，所以坐标取反
    

  158. { if(flag == 1)
    

  159. {
    

  160. if((BarrierData[0]==0)&&(BarrierData[1]==0))//左边没有障碍
    

  161. {
    

  162. Turn_Left();
    

  163. }
    

  164. else
    

  165. {
    

  166. if((BarrierData[4]==0)&&(BarrierData[3]==0))//右边没有障碍
    

  167. {
    

  168. Turn_Right();
    

  169. }
    

  170. else
    

  171. {
    

  172. Turn_Back();
    

  173. }
    

  174. }
    

  175. }
    

  176. else
    

  177. {
    

  178. Turn_Normal();
    

  179. }
    

  180. }
    

  181. */
6、mean.c
复制
  1. #include <msp430x14x.h>
    

  2. #include "ADC12.h"
    

  3. #include "Clock.h"
    

  4. #include "dianji.h"
    

  5. #define Intensity 150 //光强权值
    


  6. 


  7. 

  8. unsigned char Light[5]; //定义归一化光强值
    

  9. signed long int x=0,y=0; //调CCRx值时候的参数
    

  10. signed long int XY;
    

  11. unsigned char Flag_Stop;
    


  12. 

  13. void Measure_Light()
    

  14. { //归一化光强，从0-4906分为25档,
    

  15. unsigned char i;
    

  16. unsigned char Minimum;//记录最小光强
    

  17. for(i=0;i<5;i++)
    

  18. { if(AccessResult[i]<200) Light[i]=25;
    

  19. else if(AccessResult[i]<400) Light[i]=24;
    

  20. else if(AccessResult[i]<600) Light[i]=23;
    

  21. else if(AccessResult[i]<800) Light[i]=22;
    

  22. else if(AccessResult[i]<1000) Light[i]=21;
    

  23. else if(AccessResult[i]<1200) Light[i]=20;
    

  24. else if(AccessResult[i]<1400) Light[i]=19;
    

  25. else if(AccessResult[i]<1600) Light[i]=18;
    

  26. else if(AccessResult[i]<1800) Light[i]=17;
    

  27. else if(AccessResult[i]<2000) Light[i]=16;
    

  28. else if(AccessResult[i]<2200) Light[i]=15;
    

  29. else if(AccessResult[i]<2400) Light[i]=14;
    

  30. else if(AccessResult[i]<2600) Light[i]=13;
    

  31. else if(AccessResult[i]<2800) Light[i]=12;
    

  32. else if(AccessResult[i]<3000) Light[i]=11;
    

  33. else if(AccessResult[i]<3200) Light[i]=10;
    

  34. else if(AccessResult[i]<3400) Light[i]=9;
    

  35. else if(AccessResult[i]<3600) Light[i]=8;
    

  36. else if(AccessResult[i]<3800) Light[i]=7;
    

  37. else if(AccessResult[i]<4000) Light[i]=6;
    

  38. else if(AccessResult[i]<4200) Light[i]=5;
    

  39. else if(AccessResult[i]<4400) Light[i]=4;
    

  40. else if(AccessResult[i]<4600) Light[i]=3;
    

  41. else if(AccessResult[i]<4800) Light[i]=2;
    

  42. else if(AccessResult[i]<4096) Light[i]=1;
    

  43. else Light[i]=0;
    

  44. }
    

  45. if((AccessResult[2]<=250)||((AccessResult[0]<=250))||(AccessResult[1]<=250))
    

  46. {Flag_Stop = 1;
    


  47. 

  48. }
    

  49. Minimum = Light[0];
    

  50. for(i=1;i<5;i++)
    

  51. { if(Minimum > Light[i])
    

  52. Minimum = Light[i];
    

  53. }
    

  54. for(i=0;i<5;i++)
    

  55. Light[i] = Light[i] - Minimum;
    


  56. 

  57. //矢量合成，X,Y两个轴，
    

  58. x=0;
    

  59. y=0;
    

  60. //1号光敏电阻，无Y轴，X为负
    

  61. x=x-Intensity*Light[0];
    


  62. 

  63. //2号光敏电阻，X为-0.707，Y为0.707,45度
    

  64. x=x-(Intensity *Light[1]*707)/1000;
    

  65. y=y+(Intensity *Light[1]*707)/1000;
    

  66. //3号光敏电阻，X为0，Y为正
    


  67. 

  68. y=y+Intensity * Light[2];
    

  69. //4号光敏电阻，X,Y都为+0.707，45度
    

  70. x=x+(Intensity*Light[3]*707)/1000;
    

  71. y=y+(Intensity*Light[3]*707)/1000;
    

  72. //5号光敏电阻，Y为0，X为正
    

  73. x=x+Intensity*Light[4];
    

  74. y=y;
    

  75. if(x>1000) x=1000;
    

  76. if(y>1000) y=1000;
    

  77. if(x<-1000) x=-1000;
    


  78. 

  79. }
    


  80. 

  81. //寻光控制运动函数
    

  82. /*
    

  83. void Find_Light()
    

  84. { int XY; //防止越界
    

  85. if (y<0) y=0;
    

  86. if (x>0) //右转，y为共同速度
    

  87. { if(x+y>1000)
    

  88. XY = 1000;
    

  89. else
    

  90. {XY = x+y;}
    

  91. TBCCR4=y;
    

  92. TBCCR5=0;
    

  93. TBCCR3=0;
    

  94. TBCCR2=XY;
    

  95. }
    

  96. if(x<0) //左转
    

  97. { x = -x;
    

  98. ; if(x+y>1000)
    

  99. XY = 1000;
    

  100. else
    

  101. XY = x+y;
    

  102. TBCCR4=XY;
    

  103. TBCCR5=0;
    

  104. TBCCR3=0;
    

  105. TBCCR2=y;
    

  106. }
    


  107. 

  108. }
    

  109. */
    

  110. //备份
    

  111. //寻光控制运动函数
    

  112. void Find_Light()
    

  113. { int XY; //防止越界
    

  114. if (y<0) y=0;
    

  115. if (x>0) //右转，y为共同速度
    

  116. { if(x+y/4>1000)
    

  117. XY = 1000;
    

  118. else
    

  119. {XY = x+y/3;}
    

  120. TBCCR4=(y/2); //1.10 8:15把Y从y/3改为y/2
    

  121. TBCCR5=0;
    

  122. TBCCR3=0;
    

  123. TBCCR2=XY;
    

  124. }
    

  125. if(x<0) //左转
    

  126. { x = -x;
    

  127. ; if(x+y/4>1000)
    

  128. XY = 1000;
    

  129. else
    

  130. {XY = x+y/3;}
    

  131. TBCCR4=XY;
    

  132. TBCCR5=0;
    

  133. TBCCR3=0;
    

  134. TBCCR2=(y/2);
    

  135. }
    

  136. }

7、ADC12.c
复制
  1. #include "msp430x14x.h"
    


  2. 


  3. 


  4. 

  5. #define RESISTANCE_SAMPLING (100) // 采样电阻, 单位:欧姆
    

  6. #define VOLTAGE_REF (2500) // 参考电压, 单位:10毫伏+
    

  7. #define MAX_SAMPLE_TIMES (5) //最大采样次数
    


  8. 

  9. unsigned int Cnt_ADC12;
    

  10. unsigned long int Sum_results[8];
    

  11. unsigned int results[8]; //转换结果临时寄存器
    

  12. unsigned int AccessResult[9];
    

  13. unsigned char TransmitResult[16];
    

  14. unsigned char FLAG_END = 0;
    


  15. 


  16. 


  17. 

  18. void ADC12_Init(void)
    

  19. { unsigned char i;
    

  20. P6SEL |= 0xff; //设置P6为模拟输入通道
    

  21. ADC12CTL0 = ADC12ON + MSC + SHT0_2 + REF2_5V + REFON;
    

  22. ADC12CTL1 = CSTARTADD_0 + ADC12SSEL_0 + SHP + CONSEQ_1 ; //序列通道单次转换模式
    

  23. ADC12MCTL0 = SREF_1 + INCH_0 ; //通道A0参考电压:V+=Vref+,V-=AVss
    

  24. ADC12MCTL1 = SREF_1 + INCH_1 ; //通道A1
    

  25. ADC12MCTL2 = SREF_1 + INCH_2 ; //通道A2
    

  26. ADC12MCTL3 = SREF_1 + INCH_3 ; //通道A3
    

  27. ADC12MCTL4 = SREF_1 + INCH_4+ EOS ; //通道A4
    

  28. //ADC12MCTL5 = SREF_1 + INCH_5 ; //通道A5
    

  29. //ADC12MCTL6 = SREF_1 + INCH_6 ; //通道A6
    

  30. //ADC12MCTL7 = SREF_1 + INCH_7 ; //通道A7，最后序列
    

  31. ADC12IE = 0x10 ; //使能中断ADC12IFG.7
    

  32. //ADC12CTL0 |= ENC ; //使能转换
    

  33. for (i=0;i<5;i++)
    

  34. AccessResult[i]=0xff;
    

  35. }
    


  36. 


  37. 


  38. 

  39. void ADC12_Deal(void)
    

  40. {
    

  41. ADC12CTL0 |= ADC12SC + ENC; //开始转换
    

  42. }
    


  43. 


  44. 


  45. 

  46. #pragma vector = ADC_VECTOR
    

  47. __interrupt void ADC12_IRQ(void)
    

  48. {
    


  49. 

  50. ADC12CTL0 &= ~ENC ; //关闭转换
    

  51. Cnt_ADC12++ ;
    

  52. results[0] = ADC12MEM0 ; //存结果,清除IFG
    

  53. results[1] = ADC12MEM1 ;
    

  54. results[2] = ADC12MEM2 ;
    

  55. results[3] = ADC12MEM3 ;
    

  56. results[4] = ADC12MEM4 ;
    

  57. //results[5] = ADC12MEM5 ;
    

  58. //results[6] = ADC12MEM6 ;
    

  59. //results[7] = ADC12MEM7 ;
    

  60. if( Cnt_ADC12 >= (MAX_SAMPLE_TIMES+1) )
    

  61. {
    

  62. Cnt_ADC12=1;
    

  63. Sum_results[0] = 0;
    

  64. Sum_results[1] = 0;
    

  65. Sum_results[2] = 0;
    

  66. Sum_results[3] = 0;
    

  67. Sum_results[4] = 0;
    

  68. //Sum_results[5] = 0;
    

  69. //Sum_results[6] = 0;
    

  70. //Sum_results[7] = 0;
    

  71. }
    

  72. if (Cnt_ADC12 <= MAX_SAMPLE_TIMES)
    

  73. {
    


  74. 

  75. Sum_results[0] += results[0];
    

  76. Sum_results[1] += results[1];
    

  77. Sum_results[2] += results[2];
    

  78. Sum_results[3] += results[3];
    

  79. Sum_results[4] += results[4];
    

  80. // Sum_results[5] += results[5];
    

  81. //Sum_results[6] += results[6];
    

  82. //Sum_results[7] += results[7];
    

  83. }
    

  84. if (Cnt_ADC12 == MAX_SAMPLE_TIMES)
    

  85. {
    

  86. AccessResult[0] = Sum_results[0] / MAX_SAMPLE_TIMES;
    

  87. AccessResult[1] = Sum_results[1] / MAX_SAMPLE_TIMES;
    

  88. AccessResult[2] = Sum_results[2] / MAX_SAMPLE_TIMES;
    

  89. AccessResult[3] = Sum_results[3] / MAX_SAMPLE_TIMES;
    

  90. AccessResult[4] = Sum_results[4] / MAX_SAMPLE_TIMES;
    

  91. //AccessResult[5] = Sum_results[5] / MAX_SAMPLE_TIMES;
    

  92. //AccessResult[6] = Sum_results[6] / MAX_SAMPLE_TIMES;
    

  93. //AccessResult[7] = Sum_results[7] / MAX_SAMPLE_TIMES;
    

  94. }
    


  95. 

  96. }
8、Uart.c
复制
  1. #include <msp430x14x.h>
    

  2. #define RXBUF_SIZE 32
    

  3. #define TXBUF_SIZE 32 //发送FIFO的最大容量
    


  4. 

  5. unsigned char RX_BUFF[RXBUF_SIZE];
    

  6. unsigned int UART_InpLen = 0;
    

  7. unsigned int RX_IndexR = 0;
    

  8. unsigned int RX_IndexW = 0;
    

  9. unsigned char TX_BUFF[TXBUF_SIZE]; //发送FIFO缓冲区数据
    

  10. unsigned int UART_OutLen=0; //发送FIFO内等待发出的字节数
    

  11. unsigned int TX_IndexR=0; //发送FIFO的读指针
    

  12. unsigned int TX_IndexW=0; //发送FIFO的写指针
    

  13. unsigned char Command[10];
    


  14. 

  15. //149串口初始化
    

  16. UART_Init149()
    

  17. {
    

  18. U0CTL |= CHAR; //异步通讯模式，8位数据，无校验，1位停止位
    

  19. ME1 |= UTXE0 + URXE0; //开启串口0收发模块
    

  20. U0TCTL |= SSEL0; //选择ACLK作为串口波特率时钟源
    

  21. U0BR1 = 0; //
    

  22. U0BR0 = 13; //分频系数整数部分=13
    

  23. U0MCTL = 0X6B; //分频系数小数部分调制=5/8.（2400bps）
    

  24. P3SEL |= BIT4 + BIT5;
    

  25. U0CTL &=~ SWRST; //启动串口
    

  26. IE1 |= URXIE0;
    

  27. }
    


  28. 

  29. UART_Init425()
    

  30. {
    

  31. U0CTL |= CHAR; //异步通讯模式，8位数据，无校验，1位停止位
    

  32. ME1 |= UTXE0 + URXE0; //开启串口0收发模块
    

  33. U0TCTL |= SSEL0; //选择ACLK作为串口波特率时钟源
    

  34. U0BR1 = 0; //
    

  35. U0BR0 = 13; //分频系数整数部分=13
    

  36. U0MCTL = 0X6B; //分频系数小数部分调制=5/8.（2400bps）
    

  37. P2SEL |= BIT4 + BIT5; //
    

  38. U0CTL &=~ SWRST; //启动串口
    

  39. IE1 |= URXIE0;
    

  40. }
    


  41. 

  42. /*********************************************************
    

  43. 名称： UART0_GetChar()
    

  44. 功能： 从串口读一个字节数据
    

  45. 入口参数： 数据存放的地址指针
    

  46. 出口参数： 0表示失败，1表示成功
    

  47. 说明： 读取过程不阻塞CPU运行
    

  48. *********************************************************/
    


  49. 

  50. char UART0_GetChar(unsigned char *Chr)
    

  51. {
    

  52. if(UART_InpLen == 0) return (0);
    

  53. _DINT();
    

  54. UART_InpLen--;
    

  55. *Chr = RX_BUFF[RX_IndexR];
    

  56. if (++RX_IndexR >= RXBUF_SIZE)
    

  57. { RX_IndexR = 0;
    

  58. }
    

  59. _EINT();
    

  60. return (1);
    

  61. }
    


  62. 

  63. /*********************************************************
    

  64. 名称： UART0_GetCharsInRxBuf()
    

  65. 功能：
    

  66. 入口参数：
    

  67. 出口参数： 待读取的字节数
    

  68. *********************************************************/
    

  69. unsigned int UART0_GetCharsInRxBuf()
    

  70. {
    

  71. return (UART_InpLen);
    

  72. }
    

  73. /*********************************************************
    

  74. 名称： UART0_ClrRxBuf()
    

  75. 功能： 清除接收队列
    

  76. 入口参数：
    

  77. 出口参数：
    

  78. *********************************************************/
    


  79. 

  80. void UART0_ClrRxBuf()
    

  81. {
    

  82. _DINT();
    

  83. UART_InpLen = 0;
    

  84. RX_IndexR = 0;
    

  85. RX_IndexW = 0;
    

  86. _EINT();
    

  87. }
    


  88. 

  89. //串口接收中断
    

  90. #pragma vector= UART0RX_VECTOR
    

  91. __interrupt void UART0_RX (void)
    

  92. {
    

  93. UART_InpLen ++;
    

  94. RX_BUFF[RX_IndexW] =U0RXBUF;
    

  95. if (++RX_IndexW >= RXBUF_SIZE)
    

  96. {
    

  97. RX_IndexW = 0;
    

  98. }
    

  99. }
    


  100. 

  101. /********************************************************************
    

  102. 名称：char UART0_PutChar()
    

  103. 功能：向串口发送一字节
    

  104. 入口参数： Chr，待发字节
    

  105. 出口参数： 返回1成功，0失败
    

  106. ********************************************************************/
    

  107. char UART0_PutChar(unsigned char Chr)
    

  108. {
    

  109. if(UART_OutLen == TXBUF_SIZE)
    

  110. {
    

  111. return(0);
    

  112. }
    

  113. if(UART_OutLen == 0)
    

  114. {
    

  115. IFG1 |= UTXIFG0;
    

  116. }
    

  117. _DINT();
    

  118. UART_OutLen++;
    

  119. TX_BUFF[TX_IndexW] = Chr;
    

  120. if (++TX_IndexW >= TXBUF_SIZE)
    

  121. {
    

  122. TX_IndexW = 0;
    

  123. }
    

  124. IE1 |= UTXIE0;
    

  125. _EINT();
    

  126. return (1);
    

  127. }
    


  128. 


  129. 

  130. //串口发送中断
    

  131. #pragma vector=UART0TX_VECTOR
    

  132. __interrupt void UART0_TX (void)
    

  133. {
    

  134. if(UART_OutLen>0)
    

  135. {
    

  136. UART_OutLen--;
    

  137. U0TXBUF = TX_BUFF[TX_IndexR];
    

  138. if(++TX_IndexR >= TXBUF_SIZE)
    

  139. {
    

  140. TX_IndexR = 0;
    

  141. }
    

  142. }
    

  143. else IE1 &=~ UTXIE0;
    

  144. }


回复

收藏 举报

 楼主| hbzjt2011 发表于 2015-6-11 11:03 | 显示全部楼层
MSP430F149 程序：
1、main.c
复制
  1. #include "msp430x42x.h"
    

  2. #include "RTC.h"
    

  3. #include "BasicTimer.h"
    

  4. #include "LCD_Display.h"
    

  5. #include "Key.h"
    

  6. #include "jinshu.h"
    

  7. #include "UART.h"
    

  8. char Hour;
    

  9. char Minute;
    

  10. char Second;
    

  11. unsigned char Command149[5];
    


  12. 

  13. void main( void )
    

  14. {
    

  15. WDTCTL=WDTPW+WDTHOLD; //停止看门狗
    

  16. FLL_CTL0|=XCAP18PF;         //配置晶振负载电容
    

  17. //P1DIR|=BIT0+BIT1+BIT2+BIT3+BIT4;
    

  18. P2DIR|=BIT0+BIT1+BIT2+BIT3; //悬空的IO口要置为输出
    

  19. //P1OUT =0; //不确定电平会造成IO耗电
    

  20. P2OUT =0;
    

  21. jinshu_Init();//金属检测初始化程序
    

  22. BT_Init(64); //BasicTimer设为1/64秒中断一次
    

  23. LCD_Init(); //LCD初始化
    

  24. TACTL=TASSEL_1+MC_2+TAIE+TACLR;
    

  25. UART_Init425();
    

  26. //RTC_SetVal('h',12);
    

  27. _EINT();
    

  28. RTC_SetVal('m',0); //设置时间为12:30
    


  29. 

  30. unsigned int i;
    

  31. while(1)
    

  32. { for(i=0;i<20;i++)
    

  33. UART0_GetChar(Command149);
    

  34. if(Command149[0]==0x08)
    

  35. { Dis_Shu[3]=Dis ;
    

  36. _DINT();
    

  37. for(i=0;i<2000;i++)
    

  38. {
    

  39. Hour=RTC_GetVal('h'); //获取"时"
    

  40. Minute=RTC_GetVal('m'); //获取"分"
    

  41. Second=RTC_GetVal('s'); //获取"秒"
    

  42. LCD_DisplayChar(Minute/10,3);
    

  43. LCD_DisplayChar(Minute%10,2); //显示"分"
    

  44. LCD_DisplayChar(Second/10,1);
    

  45. LCD_DisplayChar(Second%10,0); //显示"秒"
    

  46. LCDM3|=0x10; //显
    

  47. LCD_DisplayChar(3,5);
    

  48. }
    

  49. for(i=0;i<1000;i++)
    

  50. { LCD_DisplayDecimal(Dis_Shu[3],2);
    

  51. }
    

  52. for(i=0;i<1000;i++)
    

  53. {LCD_DisplayDecimal(Dis_Shu[0],2);
    

  54. LCD_DisplayChar(1,5);
    

  55. }
    

  56. for(i=0;i<1000;i++)
    

  57. {LCD_DisplayDecimal(Dis_Shu[1],2);
    

  58. LCD_DisplayChar(2,5);
    

  59. }
    

  60. for(i=0;i<1000;i++)
    

  61. {LCD_DisplayDecimal(Dis_Shu[2],2);
    

  62. LCD_DisplayChar(3,5);
    

  63. }
    

  64. LCD_Clear();
    

  65. for(i=0;i<500;i++);
    

  66. }
    


  67. 

  68. else
    

  69. {
    


  70. 

  71. Hour=RTC_GetVal('h'); //获取"时"
    

  72. Minute=RTC_GetVal('m'); //获取"分"
    

  73. Second=RTC_GetVal('s'); //获取"秒"
    

  74. LCD_DisplayChar(Minute/10,3);
    

  75. LCD_DisplayChar(Minute%10,2); //显示"分"
    

  76. LCD_DisplayChar(Second/10,1);
    

  77. LCD_DisplayChar(Second%10,0); //显示"秒"
    

  78. LCDM3|=0x10; //显示小数点
    


  79. 

  80. }
    


  81. 

  82. }
    

  83. }
2、RTC.c
复制
  1. #include "msp430x42x.h"
    


  2. 

  3. unsigned char RTC_Time[7]={0,1,1,0,0,0};
    

  4. #define YEAR RTC_Time[0]
    

  5. #define MONTH RTC_Time[1]
    

  6. #define DATE RTC_Time[2]
    

  7. #define HOUR RTC_Time[3]
    

  8. #define MINUTE RTC_Time[4]
    

  9. #define SECOND RTC_Time[5]
    

  10. int DSEC=0;
    

  11. unsigned char const MONTH_Table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
    

  12. unsigned char RTC_SR;
    

  13. #define DISABLE_INT; RTC_SR=__get_SR_register();_DINT(); /*关闭中断的宏定义*/
    

  14. #define RESTORE_INT; if(RTC_SR & GIE) _EINT(); /*恢复中断的宏定义*/
    

  15. /****************************************************************************
    

  16. * 名 称：RTC_Tick()
    

  17. * 功 能：对实时钟进行走时和刷新
    

  18. * 入口参数：Div_Sec: 定时器每秒中断的次数
    

  19. * 出口参数：无
    

  20. * 说 明: 该函数需要被周期性调用。最好放在定时中断内执行。建议使用
    

  21. BasicTimer定时器产生所需的定时中断。
    

  22. * 范 例: 在1/16秒中断内调用 RTC_Tick(16);
    

  23. 在5ms定时中断内调用 RTC_Tick(200);
    

  24. ****************************************************************************/
    

  25. void RTC_Tick(int DivSec)
    

  26. { char Days;
    

  27. DSEC++;
    

  28. DISABLE_INT; //关闭中断以免运算到一半时被中断内其他函数读取。
    

  29. if(DSEC >=DivSec) {SECOND++;DSEC=0;} //1秒一次
    

  30. if(SECOND>=60) {MINUTE++;SECOND=0;} //60秒一次
    

  31. if(MINUTE>=60) {HOUR++;MINUTE=0;} //60分一次
    

  32. if(HOUR >=24) {DATE++;HOUR=0;} //24小时一次
    

  33. if(MONTH==2) //处理润年2月份问题
    

  34. {
    

  35. if(YEAR%4==0) Days=29; //逢4年润二月
    

  36. else Days=28; 
    

  37. } 
    

  38. else Days=MONTH_Table[MONTH-1]; //正常月份，查表得到当月天数
    

  39. if(DATE >Days) {MONTH++;DATE=1;} //一个月一次
    

  40. if(MONTH >12) {YEAR++;MONTH=1;} //一年一次
    

  41. if(YEAR>=100) {YEAR=0;} //100年一次
    

  42. RESTORE_INT;//恢复中断
    

  43. }
    

  44. /****************************************************************************
    

  45. * 名 称：RTC_SetVal()
    

  46. * 功 能：对实时钟某个参数进行设置
    

  47. * 入口参数：Index: 设置内容 'Y'=年 'M'=月 'Y'=日 'h'=时 'm'=分 's'=秒
    

  48. Value: 设置值. 年(0~99) 月(1~12) 日(1~31) 时(0~23) 分秒(0~59)
    

  49. * 出口参数：返回1表示设置成功 返回0表示参数错误，设置失败
    

  50. * 范 例: RTC_Set('h',13); //将"时"设为13 
    

  51. RTC_Set('m',35); //将"分"设为35
    

  52. ****************************************************************************/
    

  53. char RTC_SetVal(unsigned char Index,unsigned char Value)
    

  54. {
    

  55. switch(Index) //根据当前设置内容选择程序分支
    

  56. {
    

  57. case 'Y': if(Value>99) return(0); //设置"年"
    

  58. YEAR=Value; break;
    

  59. case 'M': if(Value>12) return(0); //设置"月"
    

  60. if(Value<1 ) return(0);
    

  61. MONTH=Value; break;
    

  62. case 'D': if(Value>31) return(0); //设置"日"
    

  63. if(Value<1 ) return(0); 
    

  64. DATE=Value; break;
    

  65. case 'h': if(Value>23) return(0); //设置"时"
    

  66. HOUR=Value; break;
    

  67. case 'm': if(Value>59) return(0); //设置"分" 
    

  68. MINUTE=Value; break;
    

  69. case 's': if(Value>59) return(0); //设置"秒"
    

  70. SECOND=Value; break; 
    

  71. default: return(0);
    

  72. }
    

  73. return(1);
    

  74. }
    

  75. /****************************************************************************
    

  76. * 名 称：RTC_SetAll()
    

  77. * 功 能：对实时钟全部参数进行设置
    

  78. * 入口参数：Ptr : 数组[年月日时分秒]
    

  79. * 出口参数：返回1表示设置成功 返回0表示参数错误，设置失败
    

  80. * 范 例: RTC_SetAll(RTC_TimeArray);
    

  81. RTC_TimeArray是一个unsigned char 型数组，RTC_TimeArrar[0]到RTC_TimeArrar[5]
    

  82. 依次存放着年、月、日、时、分、秒 数据
    

  83. ****************************************************************************/
    

  84. char RTC_SetAll(unsigned char* Ptr)
    

  85. {
    

  86. char i;
    

  87. if(Ptr[0]>99) return(0);
    

  88. if(Ptr[1]>12) return(0);
    

  89. if(Ptr[1]<1 ) return(0);
    

  90. if(Ptr[2]>31) return(0);
    

  91. if(Ptr[2]<1 ) return(0); 
    

  92. if(Ptr[3]>23) return(0); //排除错误参数
    

  93. if(Ptr[4]>59) return(0); 
    

  94. if(Ptr[5]>59) return(0); 
    

  95. for(i=0;i<6;i++) RTC_Time[i]=Ptr[i]; //全部复制
    

  96. return(1); //参数正确，返回1
    

  97. }
    

  98. /****************************************************************************
    

  99. * 名 称：RTC_GetVal()
    

  100. * 功 能：读取实时钟的某个参数
    

  101. * 入口参数：Index: 读取内容 'Y'=年 'M'=月 'Y'=日 'h'=时 'm'=分 's'=秒
    

  102. * 出口参数：读取结果。
    

  103. * 范 例: Hour=RTC_Get('h'); //读取当前"时" 
    

  104. Minute=RTC_Set('m'); //读取当前"分"
    

  105. ****************************************************************************/
    

  106. char RTC_GetVal(char Index)
    

  107. { char Value;
    

  108. switch(Index) //根据当前读取内容选择程序分支
    

  109. {
    

  110. case 'Y': Value=YEAR; break; //读取"年"
    

  111. case 'M': Value=MONTH; break; //读取"月"
    

  112. case 'D': Value=DATE; break; //读取"日"
    

  113. case 'h': Value=HOUR; break; //读取"时"
    

  114. case 'm': Value=MINUTE; break; //读取"分"
    

  115. case 's': Value=SECOND; break; //读取"秒"
    

  116. default: return(255); //读取参数错误，返回255(-1)
    

  117. }
    

  118. return(Value);
    

  119. }
    

  120. /****************************************************************************
    

  121. * 名 称：RTC_GetAll()
    

  122. * 功 能：读取实时钟全部参数
    

  123. * 入口参数：Ptr : 数组
    

  124. * 出口参数：无
    

  125. * 说 明: 读取结果按照年月日时分秒顺序存放在传入的数组中。
    

  126. * 范 例: RTC_GetAll(RTC_TimeArray);
    

  127. RTC_TimeArray是一个unsigned char 型数组，执行后，RTC_TimeArrar[0]到
    

  128. RTC_TimeArrar[5] 依次存放读取的 年、月、日、时、分、秒 数据
    

  129. ****************************************************************************/
    

  130. void RTC_GetAll(char* Ptr)
    

  131. {
    

  132. char i;
    

  133. for(i=0;i<6;i++) Ptr[i]=RTC_Time[i]; //全部读取
    

  134. }
3、BasicTimer.c
复制
  1. #include "msp430x42x.h" /*单片机寄存器头文件*/
    

  2. #include "RTC.h" /*实时钟头文件*/
    

  3. char BT_Flag=0;
    

  4. /****************************************************************************
    

  5. * 名 称：BT_Init()
    

  6. * 功 能：对BasicTimer进行初始化设置
    

  7. * 入口参数：Div_Sec: 定时器每秒产生中断次数。
    

  8. * 出口参数：无
    

  9. * 说 明: 如需使用后面的函数，在主循环之前必须先调用该初始化函数
    

  10. ****************************************************************************/
    

  11. char BT_Init(int Div_Sec)
    

  12. {
    

  13. switch(Div_Sec)
    

  14. {
    

  15. case 20: BTCTL = BTDIV+BT_fCLK2_DIV256;break; // 2s BT Int
    

  16. case 1: BTCTL = BTDIV+BT_fCLK2_DIV128;break; // 1s BT Int
    

  17. case 2: BTCTL = BTDIV+BT_fCLK2_DIV64;break; // 1/2s BT Int
    

  18. case 4: BTCTL = BTDIV+BT_fCLK2_DIV32;break; // 1/4s BT Int
    

  19. case 8: BTCTL = BTDIV+BT_fCLK2_DIV16;break; // 1/8s BT Int
    

  20. case 16: BTCTL = BTDIV+BT_fCLK2_DIV8;break; // 1/16s BT Int
    

  21. case 32: BTCTL = BTDIV+BT_fCLK2_DIV4;break; // 1/32s BT Int
    

  22. case 64: BTCTL = BTDIV+BT_fCLK2_DIV2;break; // 1/64s BT Int
    

  23. case 128:BTCTL = BT_fCLK2_DIV256;break; // 1/128s BT Int
    

  24. case 256:BTCTL = BT_fCLK2_DIV128;break; // 1/256s BT Int
    

  25. case 512:BTCTL = BT_fCLK2_DIV64;break; // 1/512s BT Int
    

  26. case 1024:BTCTL = BT_fCLK2_DIV32;break; // 1/1024s BT Int
    

  27. case 2048:BTCTL = BT_fCLK2_DIV16;break; // 1/2048s BT Int
    

  28. case 4096:BTCTL = BT_fCLK2_DIV8;break; // 1/4096s BT Int
    

  29. case 8192:BTCTL = BT_fCLK2_DIV4;break; // 1/8192s BT Int
    

  30. case 16384:BTCTL =BT_fCLK2_DIV2;break; // 1/16384s BT Int
    

  31. default : return(0);
    

  32. }
    

  33. IE2 |= BTIE; // Enable Basic Timer interrupt
    

  34. _EINT();
    

  35. return(1);
    

  36. }
    

  37. /****************************************************************************
    

  38. * 名 称：Cpu_SleepDelay()
    

  39. * 功 能：靠CPU休眠实现延迟。
    

  40. * 入口参数：BT_Time: BasicTimer中断次数
    

  41. * 出口参数：无
    

  42. * 说 明: 需要设置BasicTimer定时器，并开启中断。该延迟函数极省电
    

  43. ****************************************************************************/
    

  44. void Cpu_SleepDelay(int BT_Time)
    

  45. {
    

  46. for(;BT_Time>0;BT_Time--)
    

  47. {
    

  48. BT_Flag=0;
    

  49. while(BT_Flag==0) ;//LPM3; //只有BT中断才能唤醒CPU
    

  50. BT_Flag=0;
    

  51. }
    

  52. }
    

  53. /****************************************************************************
    

  54. * 名 称：Cpu_SleepWaitBT()
    

  55. * 功 能：CPU休眠,等待BT中断唤醒。
    

  56. * 入口参数：无
    

  57. * 出口参数：无
    

  58. * 说 明: 需要设置BasicTimer定时器，并开启中断。该函数极省电
    

  59. ****************************************************************************/
    

  60. void Cpu_SleepWaitBT()
    

  61. {
    

  62. BT_Flag=0;
    

  63. while(BT_Flag==0) ;//LPM3; //只有BT中断才能唤醒CPU
    

  64. BT_Flag=0;
    

  65. }
    

  66. /****************************************************************************
    

  67. * 名 称：BT_ISR()
    

  68. * 功 能：定时唤醒CPU。
    

  69. * 入口参数：无
    

  70. * 出口参数：无
    

  71. ****************************************************************************/
    

  72. #pragma vector = BASICTIMER_VECTOR
    

  73. __interrupt void BT_ISR(void) // 1/Div_Sec 秒一次中断（由BasicTimer所产生）
    

  74. {
    

  75. BT_Flag=1;
    

  76. /*
    

  77. 在这里写中断服务程序，如扫描键盘、实时钟走时等。
    

  78. */
    

  79. RTC_Tick(64); //RTC走时函数
    

  80. //__low_power_mode_off_on_exit(); //唤醒CPU
    

  81. }
复制

  1.


回复

收藏 举报

 楼主| hbzjt2011 发表于 2015-6-11 11:05 | 显示全部楼层
4、LCD_Display.c
复制
  1. #include "msp430x42x.h"
    


  2. 

  3. /*宏定义，数码管a-g各段对应的比特，更换硬件只用改动以下8行*/
    

  4. #define d 0x01 // AAAA
    

  5. #define g 0x02 // F B
    

  6. #define b 0x04 // F B
    

  7. #define a 0x08 // GGGG
    

  8. #define DOTSEG 0x10 // E C
    

  9. #define e 0x20 // E C
    

  10. #define f 0x40 // DDDD
    

  11. #define c 0x80
    

  12. #define NEGSEG 0x02 
    

  13. /*用宏定义自动生成段码表，很好的写法，值得学习*/
    

  14. /*更换硬件无需重写段码表*/
    

  15. const char LCD_Tab[] = {
    

  16. a + b + c + d + e + f, // Displays "0"
    

  17. b + c, // Displays "1"
    

  18. a + b + d + e + g, // Displays "2"
    

  19. a + b + c + d + g, // Displays "3"
    

  20. b + c + f + g, // Displays "4"
    

  21. a + c + d + f +g, // Displays "5"
    

  22. a + c + d + e + f + g, // Displays "6"
    

  23. a + b + c, // Displays "7"
    

  24. a + b + c + d + e + f + g, // Displays "8"
    

  25. a + b + c + d + f + g, // Displays "9"
    

  26. a + b + c + e + f + g, // Displays "A"
    

  27. c + d + e + f + g, // Displays "B" 
    

  28. a + d + e + f,         // Displays "C"
    

  29. b + c + d + e + g, // Displays "D"
    

  30. a + d + e + f + g, // Displays "E"
    

  31. a + e + f + g,         // Displays "F"
    

  32. a + c + d + e + f, // Displays "G"
    

  33. b + c + e + f + g, // Displays "H" 
    

  34. e + f, // Displays "I"
    

  35. b + c + d + e, // Displays "J"
    

  36. b + d + e + f + g, // Displays "K"
    

  37. d + e + f, // Displays "L" 
    

  38. a + c + e + g, // Displays "M" 
    

  39. a + b + c + e + f, // Displays "N" 
    

  40. c + e + g, // Displays "n"
    

  41. c + d + e + g, // Displays "o"
    

  42. a + b + c + d + e + f, // Displays "O"
    

  43. a + b + e + f + g, // Displays "P"
    

  44. a + b + c + f + g, // Displays "Q" 
    

  45. e + g,         // Displays "r"
    

  46. a + c + d + f +g, // Displays "S"
    

  47. d + e + f + g, // Displays "t"
    

  48. a + e + f , // Displays "T" 
    

  49. b + c + d + e + f, // Displays "U"
    

  50. c + d + e, // Displays "v" 
    

  51. b + d + f + g, // Displays "W"
    

  52. b + c + d + f + g, // Displays "Y" 
    

  53. a + b + d + e + g, // Displays "Z"
    

  54. g, // Displays "-"
    

  55. b, // Displays "'" 
    

  56. 0         // Displays " "
    

  57. }; 
    

  58. #undef a
    

  59. #undef b
    

  60. #undef c
    

  61. #undef d
    

  62. #undef e
    

  63. #undef f
    

  64. #undef g 
    


  65. 

  66. #define AA 10
    

  67. #define BB AA+1
    

  68. #define CC BB+1
    

  69. #define DD CC+1
    

  70. #define EE DD+1
    

  71. #define FF EE+1
    

  72. #define GG FF+1
    

  73. #define HH GG+1
    

  74. #define II HH+1
    

  75. #define JJ II+1
    

  76. #define KK JJ+1
    

  77. #define LL KK+1
    

  78. #define mm LL+1
    

  79. #define NN mm+1
    

  80. #define nn NN+1
    

  81. #define oo nn+1
    

  82. #define OO oo+1
    

  83. #define PP OO+1
    

  84. #define QQ PP+1
    

  85. #define rr QQ+1
    

  86. #define SS rr+1
    

  87. #define tt SS+1
    

  88. #define TT tt+1
    

  89. #define UU TT+1
    

  90. #define VV UU+1
    

  91. #define WW VV+1
    

  92. #define YY WW+1
    

  93. #define ZZ YY+1
    

  94. #define BR ZZ+1 /* - */
    

  95. #define DT BR+1 /* ' */
    

  96. #define SP DT+1 /* 空白 */
    


  97. 

  98. /****************************************************************************
    

  99. * 名 称：LCD_Init()
    

  100. * 功 能：初始化LCD显示屏。
    

  101. * 入口参数：无
    

  102. * 出口参数：无
    

  103. * 说 明: 在主程序LCD操作之前，需要调用该函数设置LCD参数。
    

  104. ****************************************************************************/
    

  105. void LCD_Init() 
    

  106. { char i;
    

  107. char *pLCD = (char *)&LCDM1; // 取LCDM1寄存器(最低位)的地址
    

  108. for (i = 0; i < 8; i++) // Clear LCD memory
    

  109. *pLCD++ = 0; // 清屏
    

  110. LCDCTL = LCDSG0_1 + LCD4MUX + LCDON; // LCD模式:4mux LCD, segs0-15
    

  111. BTCTL |= BT_fLCD_DIV128; // 设置 LCD 刷新率
    

  112. /*刷新率越慢功耗越低，但速度太慢LCD会闪烁*/ 
    

  113. }
    


  114. 

  115. /****************************************************************************
    

  116. * 名 称：LCD_DisplayLongDecimal()
    

  117. * 功 能：在LCD上显示一个带有小数点的长数据。
    

  118. * 入口参数：Number:显示数值 (-999999~9999999)
    

  119. DOT :小数点位数(0~3)
    

  120. * 出口参数：无
    

  121. * 范 例: LCD_DisplayDecimal( 123456,2); 显示结果: 1234.56 (2位小数)
    

  122. LCD_DisplayDecimal(-123456,1); 显示结果:-12345.6 (1位小数)
    

  123. * 说 明: 该函数能够显示满屏7位数字，但执行时间较长，耗电大。
    

  124. ****************************************************************************/
    

  125. void LCD_DisplayLongDecimal( long int Number, char DOT)
    

  126. {
    

  127. char Neg;
    

  128. char i;unsigned char temp;
    

  129. char *pLCD = (char *)&LCDM1;
    

  130. char PolarLocate;
    

  131. char DispBuff[8];
    


  132. 

  133. if(Number<0) {Number=-Number; Neg=1;} //处理负数
    

  134. else Neg=0;
    

  135. for(i=0;i<7;i++) //拆分数字
    

  136. {
    

  137. DispBuff[i]=Number%10;
    

  138. Number/=10;
    

  139. }
    

  140. for(i=6;i>DOT;i--) //消隐无效"0"
    

  141. {
    

  142. if (DispBuff[i]==0) DispBuff[i]=SP; 
    

  143. else break;
    

  144. }
    

  145. PolarLocate=i+1; // 负号显示在第一个有效数字左边 
    

  146. if(DOT>3) DOT=255; // 无效的小数点不显示
    

  147. if(DOT<1) DOT=255; // LCD048段码中只有123位数字有小数点 
    

  148. for(i=0;i<7;i++)
    

  149. { 
    

  150. temp=LCD_Tab[DispBuff[i]]; //查表
    

  151. if (DOT==i) temp|=DOTSEG;//显示小数点
    

  152. if ((PolarLocate==i)&&(Neg)) temp|=NEGSEG;//负号
    

  153. pLCD[i]=temp; //写入显存
    

  154. }
    

  155. }
    

  156. /****************************************************************************
    

  157. * 名 称：LCD_DisplayDecimal()
    

  158. * 功 能：在LCD上显示一个带有小数点的短整型数据。
    

  159. * 入口参数：Number:显示数值 (-32768~32767)
    

  160. DOT :小数点位数(0~3)
    

  161. * 出口参数：无
    

  162. * 范 例: LCD_DisplayDecimal( 12345,2); 显示结果: 123.45 (2位小数)
    

  163. LCD_DisplayDecimal(-12345,1); 显示结果:-1234.5 (1位小数)
    

  164. * 说 明: 该函数显示数值范围小，但执行时间短，耗电小。
    

  165. ****************************************************************************/
    

  166. void LCD_DisplayDecimal( int Number, char DOT)
    

  167. {
    

  168. char Neg;
    

  169. char i;unsigned char temp;
    

  170. char *pLCD = (char *)&LCDM1;
    

  171. char PolarLocate;
    

  172. char DispBuff[8];
    


  173. 

  174. if(Number<0) {Number=-Number; Neg=1;} //处理负数
    

  175. else Neg=0;
    

  176. for(i=0;i<7;i++) //拆分数字
    

  177. {
    

  178. DispBuff[i]=Number%10;
    

  179. Number/=10;
    

  180. }
    

  181. for(i=6;i>DOT;i--) //消隐无效"0"
    

  182. {
    

  183. if (DispBuff[i]==0) DispBuff[i]=SP; 
    

  184. else break;
    

  185. }
    

  186. PolarLocate=i+1; // 负号显示在第一个有效数字左边 
    

  187. if(DOT>3) DOT=255; // 无效的小数点不显示
    

  188. if(DOT<1) DOT=255; // LCD048段码中只有123位数字有小数点 
    

  189. for(i=0;i<7;i++)
    

  190. { 
    

  191. temp=LCD_Tab[DispBuff[i]]; //查表
    

  192. if (DOT==i) temp|=DOTSEG;//显示小数点
    

  193. if ((PolarLocate==i)&&(Neg)) temp|=NEGSEG;//负号
    

  194. pLCD[i]=temp; //写入显存
    

  195. }
    

  196. }
    


  197. 

  198. /****************************************************************************
    

  199. * 名 称：LCD_DisplayLongNumber()
    

  200. * 功 能：在LCD上显示一个长整数。
    

  201. * 入口参数：Number:显示数值 (-999999~9999999)
    

  202. * 出口参数：无
    

  203. * 范 例: LCD_DisplayNumber( 123456); 显示结果: 123456
    

  204. LCD_DisplayNumber(-123456); 显示结果:-123456
    

  205. * 说 明: 该函数能够显示满屏7位数字，但执行时间较长，耗电大。
    

  206. ****************************************************************************/
    

  207. void LCD_DisplayLongNumber(long int Number)
    

  208. {
    

  209. LCD_DisplayLongDecimal(Number,0) ;//整数没有小数点
    

  210. }
    

  211. /****************************************************************************
    

  212. * 名 称：LCD_DisplayNumber()
    

  213. * 功 能：在LCD上显示一个短整数。
    

  214. * 入口参数：Number:显示数值 (-32768~32767)
    

  215. * 出口参数：无
    

  216. * 范 例: LCD_DisplayNumber( 12345); 显示结果: 12345
    

  217. LCD_DisplayNumber(-12345); 显示结果:-12345
    

  218. ****************************************************************************/
    

  219. void LCD_DisplayNumber(int Number)
    

  220. {
    

  221. LCD_DisplayDecimal(Number,0) ;//整数没有小数点
    

  222. }
    

  223. /****************************************************************************
    

  224. * 名 称：LCD_DisplayChar()
    

  225. * 功 能：在LCD上显示一个字符。
    

  226. * 入口参数：ch :显示内容 可显示字母请参考LCD_Display.h中的宏定义
    

  227. Location:显示位置 从左至右对应76543210
    

  228. * 出口参数：无
    

  229. * 说 明: 调用该函数不影响LCD其他位的显示。但显示数字的函数会覆盖该函数的结
    

  230. 果，因此该函数要在显示数据函数之后调用。
    

  231. * 范 例: LCD_DisplayChar(AA,4); 
    

  232. LCD_DisplayChar(PP,5);
    

  233. LCD_DisplayChar(2 ,6); 显示结果: 2PAXXXX
    

  234. ****************************************************************************/
    

  235. void LCD_DisplayChar(char ch,char Location)
    

  236. {
    

  237. char *pLCD = (char *)&LCDM1; 
    

  238. pLCD[Location]=LCD_Tab[ch];
    

  239. }
    

  240. /****************************************************************************
    

  241. * 名 称：LCD_InsertChar()
    

  242. * 功 能：在LCD最右端插入一个字符。
    

  243. * 入口参数：ch :插入字符 可显示字母请参考LCD_Display.h中的宏定义
    

  244. * 出口参数：无
    

  245. * 说 明: 调用该函数后，LCD所有已显示字符左移一位，新的字符插入在最右端一位。
    

  246. 该函数可以实现滚屏动画效果，或用于在数据后面显示单位。
    

  247. * 范 例: LCD_DisplayDecimal(1234,1); 
    

  248. LCD_InsertChar(PP);
    

  249. LCD_InsertChar(FF);显示结果: 123.4PF
    


  250. 

  251. ****************************************************************************/
    

  252. void LCD_InsertChar(char ch)
    

  253. { char i;
    

  254. char *pLCD = (char *)&LCDM1; 
    

  255. for(i=6;i>=1;i--) pLCD[i]=pLCD[i-1];
    

  256. pLCD[0]=LCD_Tab[ch];
    

  257. }
    

  258. /****************************************************************************
    

  259. * 名 称：LCD_ON()
    

  260. * 功 能：开启LCD显示
    

  261. * 入口参数：无
    

  262. * 出口参数：无
    

  263. * 说 明: 调用该函数将开启LCD显示。开启后LCD仍显示最后一次显示内容
    

  264. ****************************************************************************/
    

  265. void LCD_ON()
    

  266. {
    

  267. LCDCTL |= LCDON;
    

  268. }
    

  269. /****************************************************************************
    

  270. * 名 称：LCD_ON()
    

  271. * 功 能：关闭LCD显示
    

  272. * 入口参数：无
    

  273. * 出口参数：无
    

  274. * 说 明: 调用该函数将关闭LCD显示，可节省3~5uA电流。该函数不清除显示内容。
    

  275. ****************************************************************************/
    

  276. void LCD_OFF()
    

  277. {
    

  278. LCDCTL &=~ LCDON;
    

  279. }
    


  280. 

  281. /****************************************************************************
    

  282. * 名 称：LCD_Clear()
    

  283. * 功 能: 清除LCD显示
    

  284. * 入口参数：无
    

  285. * 出口参数：无
    

  286. * 说 明: 调用该函数将LCD显示清除，但并不关闭LCD模块。
    

  287. ****************************************************************************/
    

  288. void LCD_Clear()
    

  289. { char i;
    

  290. char *pLCD = (char *)&LCDM1; // 取LCDM1寄存器(最低位)的地址
    

  291. for (i = 0; i < 8; i++) // Clear LCD memory
    

  292. {
    

  293. *pLCD++ = 0; //清屏
    

  294. }
    

  295. }
5、Key.c
复制
  1. #include "MSP430x42x.h"
    

  2. #define KEYBUFF_SIZE 8 /*键盘缓冲区大小,根据程序需要自行调整*/
    

  3. char KeyBuff[KEYBUFF_SIZE]; //定义键盘缓冲队列数组(FIFO)
    

  4. char Key_IndexW=0; //键盘缓冲队列写入指针(头指针)
    

  5. char Key_IndexR=0; //键盘缓冲队列读取指针(尾指针
    

  6. char Key_Count=0; //键盘缓冲队列内记录的按键次数 
    


  7. 

  8. char P_KEY1=255; //存放KEY1前一次状态的变量
    

  9. char N_KEY1=255; //存放KEY1当前状态的变量
    

  10. char P_KEY2=255; //存放KEY2前一次状态的变量
    

  11. char N_KEY2=255; //存放KEY2当前状态的变量
    

  12. char P_KEY3=255; //存放KEY3前一次状态的变量
    

  13. char N_KEY3=255; //存放KEY3当前状态的变量
    


  14. 


  15. 


  16. 

  17. #define KEY1_IN (P1IN&BIT5) //KEY1输入IO的定义(P1.5)
    

  18. #define KEY2_IN (P1IN&BIT6) //KEY2输入IO的定义(P1.6)
    

  19. #define KEY3_IN (P1IN&BIT7) //KEY3输入IO的定义(P1.7)
    


  20. 

  21. #define PUSH_KEY1 0x01
    

  22. #define PUSH_KEY2 0x02 /*键值宏定义*/
    

  23. #define PUSH_KEY3 0x04
    


  24. 

  25. unsigned char KEY_SR;
    

  26. #define DISABLE_INT; KEY_SR=__get_SR_register();_DINT();
    

  27. #define RESTORE_INT; if(KEY_SR & GIE) _EINT();
    

  28. /****************************************************************************
    

  29. * 名 称：Key_Init()
    

  30. * 功 能：初始化键盘所在的IO口
    

  31. * 入口参数：无
    

  32. * 出口参数：无
    

  33. ****************************************************************************/
    

  34. void Key_Init()
    

  35. {
    

  36. P1DIR&=~(BIT5+BIT6+BIT7); //P1.5/6/7作为输入
    

  37. }
    

  38. /****************************************************************************
    

  39. * 名 称：Key_InBuff()
    

  40. * 功 能：将一次键值压入键盘缓冲队列
    

  41. * 入口参数：Key:被压入缓冲队列的键值
    

  42. * 出口参数：无
    

  43. ****************************************************************************/
    

  44. void Key_InBuff(char Key) 
    

  45. {
    

  46. if(Key_Count>=KEYBUFF_SIZE) return;//若缓冲区已满，放弃本次按键
    

  47. DISABLE_INT;
    

  48. Key_Count++; //按键次数计数增加
    

  49. KeyBuff[Key_IndexW] = Key; //从队列头部追加新的数据
    

  50. if (++Key_IndexW >= KEYBUFF_SIZE) //循环队列，如果队列头指针越界
    

  51. { 
    

  52. Key_IndexW = 0; //队列头指针回到数组起始位置
    

  53. }
    

  54. RESTORE_INT;
    

  55. }
    

  56. /****************************************************************************
    

  57. * 名 称：Key_GetKey()
    

  58. * 功 能：从键盘缓冲队列内读取一次键值
    

  59. * 入口参数：无
    

  60. * 出口参数：若无按键，返回0，否则返回一次按键键值。
    

  61. * 说 明: 调用一次该函数，会自动删除缓冲队列里一次按键键值。
    

  62. ****************************************************************************/
    

  63. char Key_GetKey()
    

  64. { char Key;
    

  65. if(Key_Count==0) return(0); //若无按键，返回0 
    

  66. DISABLE_INT;//队列操作过程中不允许被定时中断执行ScanIO函数，保护全局变量正确
    

  67. Key_Count--; //按键次数计数减1
    

  68. Key=KeyBuff[Key_IndexR]; //从缓冲区尾部读取一个按键值
    

  69. if (++Key_IndexR >= KEYBUFF_SIZE)//循环队列，如果队列尾指针越界
    

  70. { 
    

  71. Key_IndexR = 0; //队列尾指针回到数组起始位置
    

  72. }
    

  73. RESTORE_INT; //恢复中断允许
    

  74. return(Key); 
    

  75. }
    

  76. /****************************************************************************
    

  77. * 名 称：Key_WaitKey()
    

  78. * 功 能：从键盘缓冲队列内读取一次键值
    

  79. * 入口参数：无
    

  80. * 出口参数：若有按键，返回键值，否则等待按键。
    

  81. * 说 明: 该函数会阻塞CPU继续执行后面的程序，应用时需注意。
    

  82. ****************************************************************************/
    

  83. char Key_WaitKey()
    

  84. { char Key;
    

  85. while(1)
    

  86. {
    

  87. Key=Key_GetKey(); //从键盘缓冲队列读取一次键值
    

  88. if(Key==0) LPM3; //如果没按键，则停止CPU，等待被唤醒继续读按键
    

  89. else return(Key); //如果有按键，则返回键值
    

  90. } 
    

  91. }
    


  92. 

  93. /****************************************************************************
    

  94. * 名 称：Key_ScanIO()
    

  95. * 功 能：扫描键盘IO口并判断按键事件
    

  96. * 入口参数：无
    

  97. * 出口参数：无，键值压入缓冲队列
    

  98. * 说 明: 该函数需要每隔1/16秒至1/128秒调用一次。最好放在定时中断内执行。
    

  99. 如果中断间隔太长，可能丢键;间隔太短不能消除抖动。
    

  100. ****************************************************************************/
    

  101. void Key_ScanIO()
    

  102. {
    

  103. P_KEY1=N_KEY1; //保存KEY1前一次的状态
    

  104. N_KEY1=KEY1_IN; //读取KEY1当前的状态
    


  105. 

  106. P_KEY2=N_KEY2; //保存KEY2前一次的状态
    

  107. N_KEY2=KEY2_IN; //读取KEY2当前的状态
    


  108. 

  109. P_KEY3=N_KEY3; //保存KEY3前一次的状态
    

  110. N_KEY3=KEY3_IN; //读取KEY3当前的状态
    


  111. 

  112. if((P_KEY1!=0)&&(N_KEY1==0)) Key_InBuff(PUSH_KEY1);
    

  113. if((P_KEY2!=0)&&(N_KEY2==0)) Key_InBuff(PUSH_KEY2);
    

  114. if((P_KEY3!=0)&&(N_KEY3==0)) Key_InBuff(PUSH_KEY3); 
    


  115. 

  116. }
6、jinshu.c
复制
  1. #include "msp430x42x.h"
    

  2. #include "Uart.h"
    

  3. #include "LCD_Display.h"
    

  4. #include "RTC.h"
    


  5. 

  6. #define Circle 46
    

  7. char Jinshu_Shu;//定义检测到金属的片数
    

  8. unsigned int TA_Overflowcnt;
    

  9. unsigned long int period;
    

  10. unsigned int Dis;
    

  11. unsigned int cnt;
    

  12. extern char Second;
    

  13. unsigned int Dis_Shu[4];
    

  14. void jinshu_Init(void) //金属检测初始化程序
    

  15. {
    

  16. Jinshu_Shu=0; //初始化 检测到金属的片数为零
    


  17. 

  18. // 初始化 测速 金属检测初始化程序
    

  19. P1DIR&=~(BIT3+BIT5); //把P1^2,P1.5初始化为输入
    

  20. P1IES|=BIT3+BIT5; //把其定义为初始化下降沿触发中断
    

  21. P1IE|=BIT3+BIT5; //p1.3,P1.5中断允许
    

  22. TACTL=TASSEL_1+MC_2+TAIE+TACLR;
    

  23. BTCTL=0;
    

  24. }
    


  25. 

  26. #pragma vector =PORT1_VECTOR
    

  27. __interrupt void PORT1_ISR(void) //p1口中断服务程序
    

  28. {
    

  29. unsigned int i;
    

  30. unsigned int j;
    

  31. for(i=2000;i>0;i--);//延时进行消除抖动
    

  32. if (P1IFG & BIT3)
    

  33. {
    

  34. //表示小车可能将要进铁片入区域
    

  35. if((P1IN&BIT3)==0) //表示小车刚进入铁片区域
    

  36. { Dis_Shu[Jinshu_Shu]= Dis ;
    

  37. Jinshu_Shu++; //铁片数目加1
    

  38. LCD_DisplayChar(Jinshu_Shu,5);
    


  39. 

  40. P1IFG=0;
    

  41. if(Jinshu_Shu==3)
    

  42. {for(i=0;i<5;i++)
    

  43. UART0_PutChar(0x02); //停车
    

  44. }
    

  45. else
    

  46. {for(i=0;i<5;i++)
    

  47. UART0_PutChar(0x01);
    

  48. }
    

  49. //LCD_DisplayDecimal(Dis,2);
    


  50. 

  51. //可以在这里调用串口通信程序，向MSP149发送信息，打开声光指示程序
    

  52. }
    

  53. }
    

  54. // 与测速有关的部分
    

  55. _BIC_SR(SCG0);
    

  56. if((P1IN&BIT5)==BIT5)
    

  57. {
    

  58. P1IFG=0;
    

  59. //return;
    

  60. }
    

  61. if (P1IFG & BIT5);
    

  62. for(j=0;j<2000;j++)
    

  63. if (P1IFG & BIT5);
    

  64. {
    

  65. cnt++;
    

  66. Dis = cnt * Circle;
    

  67. //LCD_DisplayDecimal(Dis,1);
    


  68. 

  69. }
    

  70. P1IFG=0;
    


  71. 

  72. }
    


  73. 

  74. #pragma vector=TIMERA1_VECTOR
    

  75. __interrupt void TA_ISR(void)
    

  76. {
    

  77. switch(TAIV)
    

  78. {
    

  79. case 2:break;
    

  80. case 4:break;
    

  81. case 10:TA_Overflowcnt++;
    

  82. break;
    

  83. }
    

  84. }
7、UART.c
复制
  1. #include <msp430x14x.h>
    

  2. #define RXBUF_SIZE 32
    

  3. #define TXBUF_SIZE 32 //发送FIFO的最大容量
    


  4. 

  5. unsigned char RX_BUFF[RXBUF_SIZE];
    

  6. unsigned int UART_InpLen = 0;
    

  7. unsigned int RX_IndexR = 0;
    

  8. unsigned int RX_IndexW = 0;
    

  9. unsigned char TX_BUFF[TXBUF_SIZE]; //发送FIFO缓冲区数据
    

  10. unsigned int UART_OutLen=0; //发送FIFO内等待发出的字节数
    

  11. unsigned int TX_IndexR=0; //发送FIFO的读指针
    

  12. unsigned int TX_IndexW=0; //发送FIFO的写指针
    

  13. unsigned char Command[5];
    


  14. 

  15. //149串口初始化
    

  16. UART_Init149()
    

  17. {
    

  18. U0CTL |= CHAR; //异步通讯模式，8位数据，无校验，1位停止位
    

  19. ME1 |= UTXE0 + URXE0; //开启串口0收发模块
    

  20. U0TCTL |= SSEL0; //选择ACLK作为串口波特率时钟源
    

  21. U0BR1 = 0; //
    

  22. U0BR0 = 13; //分频系数整数部分=13
    

  23. U0MCTL = 0X6B; //分频系数小数部分调制=5/8.（2400bps）
    

  24. P3SEL |= BIT4 + BIT5;
    

  25. U0CTL &=~ SWRST; //启动串口
    

  26. IE1 |= URXIE0;
    

  27. }
    


  28. 

  29. UART_Init425()
    

  30. {
    

  31. U0CTL |= CHAR; //异步通讯模式，8位数据，无校验，1位停止位
    

  32. ME1 |= UTXE0 + URXE0; //开启串口0收发模块
    

  33. U0TCTL |= SSEL0; //选择ACLK作为串口波特率时钟源
    

  34. U0BR1 = 0; //
    

  35. U0BR0 = 13; //分频系数整数部分=13
    

  36. U0MCTL = 0X6B; //分频系数小数部分调制=5/8.（2400bps）
    

  37. P2SEL |= BIT4 + BIT5; //
    

  38. U0CTL &=~ SWRST; //启动串口
    

  39. IE1 |= URXIE0;
    

  40. }
    


  41. 

  42. /*********************************************************
    

  43. 名称： UART0_GetChar()
    

  44. 功能： 从串口读一个字节数据
    

  45. 入口参数： 数据存放的地址指针
    

  46. 出口参数： 0表示失败，1表示成功
    

  47. 说明： 读取过程不阻塞CPU运行
    

  48. *********************************************************/
    


  49. 

  50. char UART0_GetChar(unsigned char *Chr)
    

  51. {
    

  52. if(UART_InpLen == 0) return (0);
    

  53. _DINT();
    

  54. UART_InpLen--;
    

  55. *Chr = RX_BUFF[RX_IndexR];
    

  56. if (++RX_IndexR >= RXBUF_SIZE)
    

  57. { RX_IndexR = 0;
    

  58. }
    

  59. _EINT();
    

  60. return (1);
    

  61. }
    


  62. 

  63. /*********************************************************
    

  64. 名称： UART0_GetCharsInRxBuf()
    

  65. 功能：
    

  66. 入口参数：
    

  67. 出口参数： 待读取的字节数
    

  68. *********************************************************/
    

  69. unsigned int UART0_GetCharsInRxBuf()
    

  70. {
    

  71. return (UART_InpLen);
    

  72. }
    

  73. /*********************************************************
    

  74. 名称： UART0_ClrRxBuf()
    

  75. 功能： 清除接收队列
    

  76. 入口参数：
    

  77. 出口参数：
    

  78. *********************************************************/
    


  79. 

  80. void UART0_ClrRxBuf()
    

  81. {
    

  82. _DINT();
    

  83. UART_InpLen = 0;
    

  84. RX_IndexR = 0;
    

  85. RX_IndexW = 0;
    

  86. _EINT();
    

  87. }
    


  88. 

  89. //串口接收中断
    

  90. #pragma vector= UART0RX_VECTOR
    

  91. __interrupt void UART0_RX (void)
    

  92. {
    

  93. UART_InpLen ++;
    

  94. RX_BUFF[RX_IndexW] =U0RXBUF;
    

  95. if (++RX_IndexW >= RXBUF_SIZE)
    

  96. {
    

  97. RX_IndexW = 0;
    

  98. }
    

  99. }
    


  100. 

  101. /********************************************************************
    

  102. 名称：char UART0_PutChar()
    

  103. 功能：向串口发送一字节
    

  104. 入口参数： Chr，待发字节
    

  105. 出口参数： 返回1成功，0失败
    

  106. ********************************************************************/
    

  107. char UART0_PutChar(unsigned char Chr)
    

  108. {
    

  109. if(UART_OutLen == TXBUF_SIZE)
    

  110. {
    

  111. return(0);
    

  112. }
    

  113. if(UART_OutLen == 0)
    

  114. {
    

  115. IFG1 |= UTXIFG0;
    

  116. }
    

  117. _DINT();
    

  118. UART_OutLen++;
    

  119. TX_BUFF[TX_IndexW] = Chr;
    

  120. if (++TX_IndexW >= TXBUF_SIZE)
    

  121. {
    

  122. TX_IndexW = 0;
    

  123. }
    

  124. IE1 |= UTXIE0;
    

  125. _EINT();
    

  126. return (1);
    

  127. }
    


  128. 


  129. 

  130. //串口发送中断
    

  131. #pragma vector=UART0TX_VECTOR
    

  132. __interrupt void UART0_TX (void)
    

  133. {
    

  134. if(UART_OutLen>0)
    

  135. {
    

  136. UART_OutLen--;
    

  137. U0TXBUF = TX_BUFF[TX_IndexR];
    

  138. if(++TX_IndexR >= TXBUF_SIZE)
    

  139. {
    

  140. TX_IndexR = 0;
    

  141. }
    

  142. }
    

  143. else IE1 &=~ UTXIE0;
    

  144. }


回复

收藏 举报

FireRiver9 发表于 2015-6-11 21:05 | 显示全部楼层
楼主大神，mark
回复

收藏 举报

 楼主| hbzjt2011 发表于 2015-6-11 21:41 | 显示全部楼层
FireRiver9 发表于 2015-6-11 21:05
楼主大神，mark

共同学习，共同进步！
回复

收藏 举报

冰河w 发表于 2015-6-12 20:30 | 显示全部楼层
好资料，必须mark
回复

收藏 举报

comeon201208 发表于 2015-6-13 20:30 | 显示全部楼层
以MSP超低功耗单片机系列MSP430F149和MSP430FE425为核心，完成小车的寻迹、检测金属、避障、寻光、测速等功能。
回复

收藏 举报

comeon201208 发表于 2015-6-13 20:31 | 显示全部楼层
在机械结构上，对普通的小车作了改进，即用一个万用轮来代替两个前轮，使小车的转向更加灵敏。采用PWM 驱动芯片控制电机，红外传感器检测黑线，金属传感器检测铁片，光敏器件检测光强，红外 LED 和一体化接收头来避障。
回复

收藏 举报

lwsn 发表于 2015-6-25 21:25 | 显示全部楼层
楼主的检测金属模块是怎么做的
回复

收藏 举报

yf201306 发表于 2016-4-10 16:46 | 显示全部楼层
楼主能不能将原理图发给我，详细一点的（主要是付的图片不清晰），还有就是那两个单片机怎么通信，邮箱：1913874509@qq.com
回复

收藏 举报

蔬木果 发表于 2018-7-7 00:13 | 显示全部楼层
学习了，mark。
回复

收藏 举报

pmp 发表于 2018-7-13 13:41 | 显示全部楼层
以为是平衡车的设计呢。
回复

收藏 举报

vivilzb1985 发表于 2018-7-16 10:11 | 显示全部楼层
以MSP超低功耗单片机系列MSP430F149和MSP430FE425为核心，完成寻迹、检测金属、避障、寻光、测速等功能。
回复

收藏 举报

shenmu2012 发表于 2018-7-16 22:03 | 显示全部楼层
采用PWM 驱动芯片控制电机，红外传感器检测黑线，金属传感器检测铁片，光敏器件检测光强，红外 LED 和一体化接收头来避障。
回复

收藏 举报

shenmu2012 发表于 2018-7-16 22:03 | 显示全部楼层
对电机的控制还是采用PWM的信号的哈
回复

收藏 举报

quickman 发表于 2018-7-16 22:08 | 显示全部楼层
回复

收藏 举报

jstgotodo 发表于 2018-7-16 22:08 | 显示全部楼层
做个平衡车吧。
回复

收藏 举报

iamaiqiyi 发表于 2018-7-16 22:08 | 显示全部楼层
简易智能电动怎样
回复

收藏 举报

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

本版积分规则

hbzjt2011
个人签名：欢迎参与LabVIEW版块的讨论学习！ 点我一键即达

323

主题

2908

帖子

45

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