07年国赛电动车上跷跷板程序源码

07年国赛电动车上跷跷板程序源码,大家可以参考一下:
 
  1. #include <mega16.h>
  2. #include <delay.h>
  3.  
  4. // USART控制和状态寄存器的标志位定义
  5. #define RXC  7          // UCSRA位定义
  6. #define TXC  6
  7. #define UDRE 5
  8. #define FE   4
  9. #define DOR  3
  10. #define PE   2
  11. #define U2X  1
  12. #define MPCM 0
  13. #define RXCIE 7         // UCSRB位定义
  14. #define TXCIE 6
  15. #define UDRIE 5
  16. #define RXEN  4
  17. #define TXEN  3
  18. #define UCSZ2 2
  19. #define RXB8  1
  20. #define TXB8  0
  21. #define URSEL 7         // UCSRC位定义
  22. #define UMSEL 6
  23. #define UPM1  5
  24. #define UPM0  4
  25. #define USBS  3
  26. #define UCSZ1 2
  27. #define UCSZ0 1
  28. #define UCPOL 0
  29.  
  30. #define FRAMING_ERROR (1<<FE)
  31. #define PARITY_ERROR (1<<PE)
  32. #define DATA_OVERRUN (1<<DOR)
  33. #define DATA_REGISTER_EMPTY (1<<UDRE)
  34.  
  35. #define MOTOR_L1 PORTB.0       //电机
  36. #define MOTOR_L2 PORTB.1
  37. #define MOTOR_R1 PORTB.2
  38. #define MOTOR_R2 PORTB.3
  39.  
  40. #define BW_LEFT  PINA.0        //黑白线
  41. #define BW_RIGHT PINA.1
  42.  
  43. #define BUZZER   PORTA.3        //蜂鸣器
  44.  
  45.  
  46. #define NULL        0x00
  47. #define LEFT        0x01
  48. #define RIGHT       0x02
  49. #define BAL_START   0x03
  50. #define BAL         0x04
  51. #define BAL_OK      0x05
  52. #define GET_B       0x06
  53. #define B_OK        0x07
  54. #define A_OK        0x08
  55. #define MODE_B      0x09
  56. #define MODE_P      0x0A
  57. #define BAL_AGAIN   0x0B
  58. #define FULL        0xFF
  59.  
  60. unsigned char tran = 5; //USART数据
  61. bit receive_ok = 0;
  62. bit dir = 0;
  63. bit mode2 = 0;
  64. unsigned char delay_dir = 0;
  65.  
  66. interrupt [USART_RXC] void usart_rx_isr(void)   // USART接收中断服务
  67. {
  68.     unsigned char status,data;
  69.     status = UCSRA;
  70.     data = UDR;
  71.     if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
  72.         {
  73.         tran = data;
  74.         receive_ok = 1;
  75.         }
  76. }
  77.  
  78. void USART_Transmit(unsigned char data)
  79. {
  80.         while (!(UCSRA & DATA_REGISTER_EMPTY));    // 等待发送寄存器空                                       
  81.         UDR = data;                                 // 发送数据                                
  82. }
  83.  
  84.  
  85. void motor_direct(unsigned char direct)          //电机换向
  86. {
  87. if(direct == 0)
  88.     {
  89.     MOTOR_L1 = 0;
  90.     MOTOR_L2 = 1;
  91.     MOTOR_R1 = 0;
  92.     MOTOR_R2 = 1;
  93.     }
  94. if(direct == 1)
  95.     {
  96.     MOTOR_L1 = 1;
  97.     MOTOR_L2 = 0;
  98.     MOTOR_R1 = 1;
  99.     MOTOR_R2 = 0;
  100.     }
  101. }
  102.  
  103. void motor_start(void)                            //电机启动
  104. {
  105. if(dir == 0)
  106.     {
  107.     MOTOR_L1 = 0;
  108.     MOTOR_L2 = 1;
  109.     MOTOR_R1 = 0;
  110.     MOTOR_R2 = 1;
  111.     }
  112. if(dir == 1)
  113.     {
  114.     MOTOR_L1 = 1;
  115.     MOTOR_L2 = 0;
  116.     MOTOR_R1 = 1;
  117.     MOTOR_R2 = 0;
  118.     }
  119. }
  120.                                                       
  121. void motor_stop(void)                             //电机停止
  122. {
  123. MOTOR_L1 = 1;
  124. MOTOR_L2 = 1;
  125. MOTOR_R1 = 1;
  126. MOTOR_R2 = 1;
  127. }
  128.  
  129. void motor_jerk(unsigned int time ,unsigned char direct_stop)
  130. {
  131.     motor_direct(direct_stop);
  132.     delay_ms(time);
  133.     motor_stop();
  134. }
  135.  
  136. void buzzer_voice(void)
  137. {
  138. BUZZER = 1;                     
  139. delay_ms(500);
  140. BUZZER = 0;
  141. }
  142.  
  143. void mode_pro(void)
  144. {
  145. unsigned char cache = 0;
  146. bit once = 0,balance_again = 0;
  147.  
  148. //buzzer_voice();
  149. motor_start();                //电机开启
  150.  
  151. delay_ms(500);
  152. motor_stop();
  153.  
  154. while(1)
  155.      {
  156.      if(BW_RIGHT == 1 && BW_LEFT == 0)
  157.          {
  158.          OCR1AH=0xef;
  159.          OCR1AL=0xFF;
  160.          OCR1BH=0xaf;
  161.          OCR1BL=0xFF;
  162.          delay_ms(300);
  163.          motor_jerk(150,0);
  164.          OCR1BH=0xef;
  165.          OCR1BL=0xFF;
  166.          OCR1AH=0x00;
  167.          OCR1AL=0xFF;
  168.          delay_ms(300);
  169.          motor_jerk(200,1);
  170.          delay_dir = 1;
  171.          }
  172.      else if(BW_RIGHT == 0 && BW_LEFT == 1)
  173.          {
  174.          OCR1BH=0xef;
  175.          OCR1BL=0xFF;
  176.          OCR1AH=0xaf;
  177.          OCR1AL=0xFF;
  178.          delay_ms(300);
  179.          motor_jerk(150,0);
  180.          OCR1AH=0xef;
  181.          OCR1AL=0xFF;
  182.          OCR1BH=0x00;
  183.          OCR1BL=0xFF;
  184.          delay_ms(300);
  185.          motor_jerk(200,1);
  186.          delay_dir = 2;
  187.          }
  188.      else if(BW_RIGHT == 0 && BW_LEFT == 0)
  189.          {
  190.          OCR1AH=0xc0;
  191.          OCR1AL=0xFF;
  192.          OCR1BH=0xf0;
  193.          OCR1BL=0xFF;
  194.          motor_jerk(30,0);
  195.          }
  196.      else if(BW_RIGHT == 1 && BW_LEFT == 1)
  197.          {
  198.          /*if(delay_dir == 1)
  199.               {
  200.               OCR1AH=0xef;
  201.               OCR1AL=0xFF;
  202.               OCR1BH=0xaf;
  203.               OCR1BL=0xFF;
  204.               delay_ms(300);
  205.               motor_jerk(150,0);
  206.               OCR1BH=0xef;
  207.               OCR1BL=0xFF;
  208.               OCR1AH=0x00;
  209.               OCR1AL=0xFF;
  210.               delay_ms(300);
  211.               motor_jerk(200,1);
  212.               }
  213.          else if(delay_dir == 2)
  214.               {
  215.               OCR1BH=0xef;
  216.               OCR1BL=0xFF;
  217.               OCR1AH=0xaf;
  218.               OCR1AL=0xFF;
  219.               delay_ms(300);
  220.               motor_jerk(150,0);
  221.               OCR1AH=0xef;
  222.               OCR1AL=0xFF;
  223.               OCR1BH=0x00;
  224.               OCR1BL=0xFF;
  225.               delay_ms(300);
  226.               motor_jerk(200,1);
  227.               }*/
  228.          break;
  229.          }
  230.      delay_ms(400);
  231.      };
  232.  
  233. OCR1AH=0xef;
  234. OCR1AL=0xFF;
  235. OCR1BH=0xef;
  236. OCR1BL=0xFF;
  237.  
  238. buzzer_voice();
  239. motor_start();                //电机开启
  240.  
  241. delay_ms(1000);
  242. motor_stop();
  243.  
  244. again:
  245.  
  246. delay_ms(1000);
  247.  
  248. USART_Transmit(BAL_START);
  249. USART_Transmit(BAL_START);
  250. USART_Transmit(BAL_START);
  251. USART_Transmit(BAL_START);
  252. USART_Transmit(BAL_START);
  253.  
  254. while (1)                       //找平衡
  255. {
  256. cache = tran;
  257. if(receive_ok == 1 && cache == LEFT)
  258.     {
  259.     motor_jerk(30,1);
  260.     delay_ms(800);
  261.     }
  262. else if(receive_ok == 1 && cache == RIGHT)
  263.     {
  264.     motor_jerk(30,0);
  265.     delay_ms(800);
  266.     }
  267. else
  268.     {
  269.     motor_stop();
  270.     if(cache == BAL && once == 0)
  271.         {
  272.         buzzer_voice();
  273.         once = 1;
  274.         }
  275.     if(cache == BAL_OK)
  276.         {
  277.         buzzer_voice();
  278.         break;
  279.         }
  280.     }
  281. }
  282.  
  283. if(balance_again == 0)
  284.    {
  285.    while(1)
  286.        {
  287.        if(tran == BAL_AGAIN)
  288.            break;
  289.        delay_ms(100);
  290.        }
  291.    balance_again = 1;
  292.    once = 0;
  293.    receive_ok = 0;
  294.    goto again;
  295.    }
  296.  
  297. motor_jerk(150,0);
  298.                                                                        
  299. while (1)
  300.       {
  301.       if(BW_LEFT == 1 && BW_RIGHT == 1)
  302.           {
  303.           USART_Transmit(GET_B);
  304.           USART_Transmit(GET_B);
  305.           USART_Transmit(GET_B);
  306.           USART_Transmit(GET_B);
  307.           USART_Transmit(GET_B);
  308.           break;
  309.           }
  310.       else
  311.           {
  312.           motor_jerk(30,0);
  313.           delay_ms(800);
  314.           }
  315.       }
  316.  
  317. while (1)
  318.       {
  319.        if(tran == B_OK)
  320.            break;                                       
  321.       };
  322.  
  323. motor_jerk(1200,1);
  324.       
  325. while (1)
  326.       {
  327.        if(BW_LEFT == 1 && BW_RIGHT == 1)
  328.           {
  329.           motor_jerk(30,1);
  330.           delay_ms(500);
  331.           motor_jerk(30,1);
  332.           delay_ms(500);
  333.           motor_jerk(30,1);
  334.           break;
  335.           }
  336.       else
  337.           {
  338.           motor_jerk(40,1);
  339.           delay_ms(800);
  340.           }                                       
  341.       };
  342.       
  343. USART_Transmit(A_OK);
  344. USART_Transmit(A_OK);
  345. USART_Transmit(A_OK);
  346. USART_Transmit(A_OK);
  347. USART_Transmit(A_OK);
  348.       
  349. while (1)
  350.       {
  351.       
  352.       };      
  353. }
  354.  
  355. void main(void)
  356. {
  357. unsigned char cache = 0;
  358. bit once = 0;
  359.  
  360. //unsigned char middle,balance,B,A;
  361. //unsigned char time_h[10] = {0},time_m[10] = {0},time_s[10] = {0};
  362. //unsigned char *mid = ""
  363.  
  364. // Input/Output Ports initialization
  365. // Port A initialization
  366. // Func7=In Func6=In Func5=In Func4=In Func3=Out Func2=In Func1=In Func0=In
  367. // State7=T State6=T State5=T State4=T State3=0 State2=P State1=P State0=P
  368. PORTA=0x07;
  369. DDRA=0x08;
  370.  
  371. // Port B initialization
  372. // Func7=In Func6=In Func5=In Func4=In Func3=Out Func2=Out Func1=Out Func0=Out
  373. // State7=T State6=T State5=T State4=T State3=0 State2=0 State1=0 State0=0
  374. PORTB = 0x00;
  375. DDRB=0x0F;
  376.  
  377. // Port C initialization
  378. // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
  379. // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
  380. PORTC=0x00;
  381. DDRC=0x00;
  382.  
  383. // Port D initialization
  384. // Func7=In Func6=Out Func5=Out Func4=Out Func3=In Func2=In Func1=In Func0=In
  385. // State7=T State6=1 State5=0 State4=0 State3=T State2=T State1=T State0=T
  386. PORTD=0x40;
  387. DDRD=0x70;
  388.  
  389. // Timer/Counter 0 initialization
  390. // Clock source: System Clock
  391. // Clock value: 14.400 kHz
  392. // Mode: Normal top=FFh
  393. // OC0 output: Disconnected
  394. TCCR0=0x00;
  395. TCNT0=0x00;
  396. OCR0=0x00;
  397.  
  398. // Timer/Counter 1 initialization
  399. // Clock source: System Clock
  400. // Clock value: 14745.600 kHz
  401. // Mode: Fast PWM top=ICR1
  402. // OC1A output: Non-Inv.
  403. // OC1B output: Non-Inv.
  404. // Noise Canceler: Off
  405. // Input Capture on Falling Edge
  406. // Timer 1 Overflow Interrupt: Off
  407. // Input Capture Interrupt: Off
  408. // Compare A Match Interrupt: Off
  409. // Compare B Match Interrupt: Off
  410. TCCR1A=0xA2;
  411. TCCR1B=0x19;
  412. TCNT1H=0x00;
  413. TCNT1L=0x00;
  414. ICR1H=0xFF;
  415. ICR1L=0xFF;
  416. OCR1AH=0xef;
  417. OCR1AL=0xFF;
  418. OCR1BH=0xef;
  419. OCR1BL=0xFF;
  420.  
  421.  
  422. // Timer/Counter 2 initialization
  423. // Clock source: System Clock
  424. // Clock value: Timer 2 Stopped
  425. // Mode: Normal top=FFh
  426. // OC2 output: Disconnected
  427. ASSR=0x00;
  428. TCCR2=0x00;
  429. TCNT2=0x00;
  430. OCR2=0x00;
  431.  
  432. // USART initialization
  433. // Communication Parameters: 8 Data, 1 Stop, No Parity
  434. // USART Receiver: On
  435. // USART Transmitter: On
  436. // USART Mode: Asynchronous
  437. // USART Baud Rate: 19200
  438. UCSRA=0x00;
  439. UCSRB=0x98;
  440. UCSRC=0x86;
  441. UBRRH=0x00;
  442. UBRRL=0x2F;
  443.  
  444. // External Interrupt(s) initialization
  445. // INT0: Off
  446. // INT1: Off
  447. // INT2: Off
  448. MCUCR=0x00;
  449. MCUCSR=0x00;
  450.  
  451. // Timer(s)/Counter(s) Interrupt(s) initialization
  452. TIMSK=0x01;
  453.  
  454. // Analog Comparator initialization
  455. // Analog Comparator: Off
  456. // Analog Comparator Input Capture by Timer/Counter 1: Off
  457. ACSR=0x80;
  458. SFIOR=0x00;
  459.  
  460. // Global enable interrupts
  461. #asm("sei")
  462.  
  463. if(BW_LEFT == 1 && BW_RIGHT == 1)
  464.     {
  465.     mode2 = 1;
  466.     USART_Transmit(MODE_P);
  467.     USART_Transmit(MODE_P);
  468.     delay_ms(400);
  469.     USART_Transmit(MODE_P);
  470.     USART_Transmit(MODE_P);
  471.     delay_ms(400);
  472.     USART_Transmit(MODE_P);
  473.     mode_pro();
  474.     }
  475.      
  476. USART_Transmit(MODE_B);
  477. USART_Transmit(MODE_B);
  478. delay_ms(400);
  479. USART_Transmit(MODE_B);
  480. USART_Transmit(MODE_B);
  481. delay_ms(400);
  482. USART_Transmit(MODE_B);
  483.  
  484. buzzer_voice();
  485. motor_start();                //电机开启
  486.  
  487. delay_ms(1000);
  488. motor_stop();
  489.  
  490. delay_ms(1000);
  491.  
  492. USART_Transmit(BAL_START);
  493. USART_Transmit(BAL_START);
  494. USART_Transmit(BAL_START);
  495. USART_Transmit(BAL_START);
  496. USART_Transmit(BAL_START);
  497.  
  498. while (1)                       //找平衡
  499. {
  500. cache = tran;
  501. if(receive_ok == 1 && cache == LEFT)
  502.     {
  503.     motor_jerk(30,1);
  504.     delay_ms(800);
  505.     }
  506. else if(receive_ok == 1 && cache == RIGHT)
  507.     {
  508.     motor_jerk(30,0);
  509.     delay_ms(800);
  510.     }
  511. else
  512.     {
  513.     motor_stop();
  514.     if(cache == BAL && once == 0)
  515.         {
  516.         buzzer_voice();
  517.         once = 1;
  518.         }
  519.     if(cache == BAL_OK)
  520.         {
  521.         buzzer_voice();
  522.         break;
  523.         }
  524.     }
  525. }
  526.  
  527. motor_jerk(200,0);
  528.                                                                        
  529. while (1)
  530.       {
  531.       if(BW_LEFT == 1 && BW_RIGHT == 1)
  532.           {
  533.           USART_Transmit(GET_B);
  534.           USART_Transmit(GET_B);
  535.           USART_Transmit(GET_B);
  536.           USART_Transmit(GET_B);
  537.           USART_Transmit(GET_B);
  538.           break;
  539.           }
  540.       else
  541.           {
  542.           motor_jerk(30,0);
  543.           delay_ms(800);
  544.           }
  545.       }
  546.  
  547. while (1)
  548.       {
  549.        if(tran == B_OK)
  550.            break;                                       
  551.       };
  552.  
  553. motor_jerk(1200,1);
  554.       
  555. while (1)
  556.       {
  557.        if(BW_LEFT == 1 && BW_RIGHT == 1)
  558.           {
  559.           motor_jerk(30,1);
  560.           delay_ms(500);
  561.           motor_jerk(30,1);
  562.           delay_ms(500);
  563.           motor_jerk(30,1);
  564.           break;
  565.           }
  566.       else
  567.           {
  568.           motor_jerk(40,1);
  569.           delay_ms(800);
  570.           }                                       
  571.       };
  572.       
  573. USART_Transmit(A_OK);
  574. USART_Transmit(A_OK);
  575. USART_Transmit(A_OK);
  576. USART_Transmit(A_OK);
  577. USART_Transmit(A_OK);
  578.       
  579. while (1)
  580.       {
  581.       
  582.       };      
  583. }
  584.  
复制代码




 
 
 

文件到原文下载,原文出自:https://bbs.usoftchina.com/thread-208655-1-1.html"

  • 1
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: STM32电动车跷跷板程序是指使用STM32微控制器来控制电动车跷跷板功能。跷跷板功能是指通过控制电机的转速和方向,实现电动车前后行驶的功能。 首先,通过STM32微控制器与电动车的电机进行连接,并将电机控制引脚连接到STM32的GPIO引脚上。接着,在STM32的程序中,需要配置GPIO引脚和电机控制信号的相关参数,例如引脚方向(输入或输出)、引脚电平(高或低)、引脚模式(推挽输出或开漏输出)等。 然后,在STM32的程序中,需要编写一个函数来控制电动车跷跷板功能。这个函数会根据输入的命令,来控制电机的转速和方向。例如,当输入命令为前进时,函数会将电机控制引脚设置为前进方向,并调整电机的转速;当输入命令为后退时,函数会将电机控制引脚设置为后退方向,并调整电机的转速。 此外,为了简化操作,可以在程序中添加按键或者遥控器等外部设备来输入命令,通过读取外部设备的状态并进行相应的处理,从而控制电动车跷跷板功能。 总结起来,STM32电动车跷跷板程序主要是通过配置GPIO引脚和编写控制函数来实现对电动车电机的转速和方向控制,通过读取外部设备的输入来改变电动车的行驶方向和速度。这种程序可以方便实现电动车跷跷板功能,提供更好的操控体验。 ### 回答2: stm32电动车跷跷板程序是指使用STM32微控制器来控制电动车跷跷板运动的程序跷跷板是一种儿童游乐设施,通过在两端均匀分布的杠杆上坐或站立移动,可以得到乐趣。 为了控制电动车跷跷板的运动,我们可以使用STM32微控制器,通过编写相应的程序来控制电机的转动。首先,我们需要通过传感器或人工输入控制电动车的加速和刹车信号。比如,可以通过使用按钮或者其他接口设备来输入信号。 然后,根据输入的信号来控制电机的转速和方向。可以通过使用PWM信号来控制电机的转速,从而实现电动车的加速和刹车。同时,我们还可以通过控制电机的正反转来实现电动车前进或后退的功能。 在程序中,可以设置一个计时器来检测每次跷跷板的运动时间,当运动时间达到一定值时,可以自动停止电动车的运动,以便安全使用。此外,还可以设置线程或中断来监听输入信号的变化,实时响应用户的操作。 为了保证程序的安全性和稳定性,我们还可以加入一些保护措施。比如,检测电机的工作状态,当电机过热或出现其他异常情况时,及时停止电机的工作,避免损坏电机或造成其他危险。 总的来说,stm32电动车跷跷板程序是一种通过STM32微控制器来控制电动车跷跷板运动的程序。通过编写合适的程序代码,我们可以实现电动车的加速、刹车和方向控制等功能,从而使得电动车跷跷板运动更加安全、稳定和有趣。 ### 回答3: STM32电动车跷跷板程序主要实现了对电动车的平衡控制功能。该程序利用STM32单片机的强大处理能力和丰富的外设资源,通过加速度传感器和PID控制算法实现了电动车的自动平衡。 首先,程序通过加速度传感器检测电动车的倾斜角度。根据倾斜角度与设定的目标角度之间的差距,程序将计算出控制电机的输出信号。接下来,程序利用PID控制算法对输出信号进行调整,以使电动车趋向于平衡状态。PID控制算法通过比较目标值、实际值和误差值之间的关系,自动调节输出信号,使电动车保持平衡。 此外,程序还考虑到了电动车的动态特性。通过监测电动车的速度和加速度信息,程序可以根据需要调整输出信号的大小和方向,以使电动车更加平稳和灵活地移动。 在编写程序时,需要充分利用STM32单片机的各种外设资源,如计时器、PWM输出、A/D转换等,以实现对电动车电机的精确控制。同时,为了保证程序的实时性和可靠性,需要合理设置任务优先级、中断服务程序等。 总之,STM32电动车跷跷板程序充分利用了STM32单片机的强大功能,通过加速度传感器和PID控制算法实现了电动车的平衡控制,为电动车提供了稳定、平衡的控制能力。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值