標(biāo)題: STM32紅外舵機(jī)自動(dòng)壁障小車(chē)源程序 [打印本頁(yè)]
作者: zxcvbnm..    時(shí)間: 2018-4-8 17:37
標(biāo)題: STM32紅外舵機(jī)自動(dòng)壁障小車(chē)源程序
基于STM32的紅外舵機(jī)自動(dòng)壁障小車(chē)

單片機(jī)源程序如下:
  1. #include "stm32f10x_it.h"
  2. #include "stm32f10x_lib.h"
  3. #include "stm32f10x_type.h"
  4. #include "stm32f10x_usart.h"
  5. #include "defines.h"
  6. #include "stm32f10x_flash.h"
  7. #include "cpu.h"

  9. #include <stdio.h>


  12. #define  FLASH_ADDRESS   (0x08000000 + 1024 * 32 - 4096)  /* 存儲(chǔ)數(shù)據(jù)Flash頁(yè)首地址 */

  14. #define DUTY_WIDTH 25  //占空比最大級(jí)數(shù)
  15. #define CAR_QIAN_JIN 0 //小車(chē)前進(jìn)
  16. #define CAR_HOU_TUI  1 //小車(chē)后退


  19. u8 debug_switch = 0;//調(diào)試開(kāi)關(guān)
  20. u32 IR_ref_value_L = 0;//紅外感應(yīng)參考值，開(kāi)機(jī)前將小車(chē)置于空曠位置，系統(tǒng)便于識(shí)別環(huán)境光強(qiáng)度
  21. u32 IR_ref_value_R = 0;//紅外感應(yīng)參考值，開(kāi)機(jī)前將小車(chē)置于空曠位置，系統(tǒng)便于識(shí)別環(huán)境光強(qiáng)度

  23. u8 moto_run = 0;//電機(jī)運(yùn)行標(biāo)志
  24. u8 moto_R_speed = 0;//電機(jī)速度
  25. u8 moto_R_dir   = CAR_QIAN_JIN;//電機(jī)方向
  26. u8 moto_L_speed = 0;//電機(jī)速度
  27. u8 moto_L_dir   = CAR_QIAN_JIN;//電機(jī)方向
  28. u8 moto_speed   = 0;//電機(jī)前進(jìn)的速度
  29. s8 moto_speed_adj = 1;//左右電機(jī)速度校正，-3~+3，已左邊輪子速度為基準(zhǔn)，在右邊輪子速度加校正值

  31. //u32 TIME_L_R  = (TIMER_FREQ / 3);//轉(zhuǎn)彎時(shí)間，完成后自動(dòng)歸正
  32. u8 moto_L_switch = 0;//左轉(zhuǎn)有效
  33. u8 moto_R_switch = 0;//右轉(zhuǎn)有效


  36. u32 left_turn_cnt = 0;        //轉(zhuǎn)彎時(shí)間定時(shí)器
  37. u32 right_turn_cnt = 0;        //轉(zhuǎn)彎時(shí)間定時(shí)器

  39. u32 b_led_cnt = 0;//剎車(chē)燈時(shí)間定時(shí)器
  40. u32 beep_cnt = 0;//喇叭時(shí)間定時(shí)器,ms

  42. u8 lamp_front_bright = 0; //大燈亮度
  43. u8 lamp_f = 0; //大燈開(kāi)關(guān)切換

  45. void Lamp_front(u8 de);


  48. /***********************************************************************
  49. 函數(shù)功能: 寫(xiě)flash，數(shù)據(jù)長(zhǎng)度不超過(guò)1扇區(qū)
  50. 入口參數(shù):
  51. 出口參數(shù):
  52. ***********************************************************************/
  53. void WriteFlash(u32 byte_addr , u16 len , u8 *dat)
  54. {
  55.         u16 i = 0;

  57.         len = len / 2 * 2 + (len % 2) * 2;

  59.         FLASH_Unlock();
  60.         FLASH_ErasePage(byte_addr);                  /* 擦除頁(yè) */
  61.         //FLASH_ProgramWord(FLASH_ADR,0 << 1 | 0);   /* 寫(xiě)16位半字 */
  62.         for(i = 0 ; i < len ; i += 2)
  63.         {
  64.                 FLASH_ProgramHalfWord(byte_addr + i , *(u16*)&dat[i]);   /* 寫(xiě)16位半字 */
  65.         }

  67.         FLASH_Lock();
  68. }
  69. /***********************************************************************
  70. 函數(shù)功能:延時(shí)_dlytime毫秒
  71. 入口參數(shù):
  72. 出口參數(shù):
  73. ***********************************************************************/
  74. void Delay_ms(u32 _dlytime)
  75. {
  76.         u32 i;
  77.         u32 j;

  79.         for (i = 0; i < _dlytime * 10; i++)
  80.                 for (j = 0; j < 0xff; j++);       
  81. }
  82. /***********************************************************************
  83. 函數(shù)功能:延時(shí)
  84. 入口參數(shù):
  85. 出口參數(shù):
  86. ***********************************************************************/
  87. void Delay(u32 _dlytime)
  88. {
  89.         u32 i;
  90.         u32 j;

  92.         for (i = 0; i < _dlytime * 1; i++)
  93.                 for (j = 0; j < 0x13; j++);       
  94. }
  95. /***********************************************************************
  96. 函數(shù)功能:獲取AD值
  97. 入口參數(shù):
  98. 出口參數(shù):
  99. ***********************************************************************/
  100. u16 GetADCVal(u8 ADC_Channel)
  101. {       
  102.         ADC_RegularChannelConfig(ADC1, ADC_Channel, 1, ADC_SampleTime_239Cycles5);
  103.        
  104.         /* Start ADC1 Software Conversion */
  105.         ADC_SoftwareStartConvCmd(ADC1, ENABLE);

  107.         while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);

  109.         return ADC_GetConversionValue(ADC1);
  110. }
  111. /***********************************************************************
  112. 函數(shù)功能:判斷左側(cè)是否有障礙物
  113. 入口參數(shù):
  114. 出口參數(shù): 1:有障礙,
  115. ***********************************************************************/
  116. u8 CheckHinder_Left()
  117. {
  118.         u16 adc = 0 , avg = 0;
  119.         static u32 adc_temp = 0 , times = 0;

  121.         adc = GetADCVal(ADC_Channel_5);
  122.                
  123.         adc_temp += adc;
  124.         times ++;

  126.         if(adc > IR_ref_value_L + 350)
  127.          return 1;

  129.         avg = (adc_temp / times); //獲取平均值

  131.         if(adc > avg + 60)//如果當(dāng)前值大于平均值較多，也認(rèn)為是有障礙
  132.                 return 2;

  134.         return 0;
  135. }
  136. /***********************************************************************
  137. 函數(shù)功能:判斷右側(cè)是否有障礙物
  138. 入口參數(shù):
  139. 出口參數(shù): 1:有障礙,
  140. ***********************************************************************/
  141. u8 CheckHinder_Right()
  142. {
  143.         u16 adc = 0 , avg = 0;
  144.         static u32 adc_temp = 0 , times = 0;

  146.         adc = GetADCVal(ADC_Channel_4);
  147.                
  148.         adc_temp += adc;
  149.         times ++;

  151.         if(adc > IR_ref_value_R + 150)
  152.          return 1;

  154.         avg = (adc_temp / times); //獲取平均值

  156.         if(adc > avg + 50)//如果當(dāng)前值大于平均值較多，也認(rèn)為是有障礙
  157.                 return 2;

  159.         return 0;
  160. }
  161. /***********************************************************************
  162. 函數(shù)功能:向串口發(fā)數(shù)據(jù)
  163. 入口參數(shù):
  164. 出口參數(shù):
  165. ***********************************************************************/
  166. void SendDataToUart(u8 dat)
  167. {
  168.         UART1_SendByte(dat);       
  169. }
  170. /***********************************************************************
  171. 函數(shù)功能:發(fā)送數(shù)據(jù)
  172. 入口參數(shù):
  173. 出口參數(shù):
  174. ***********************************************************************/
  175. void SendStrToUart(char*str)
  176. {
  177.         while(*str)
  178.         {
  179.                 SendDataToUart(*str ++);
  180.         }
  181. }
  182. /***********************************************************************
  183. 函數(shù)功能:
  184. 入口參數(shù):
  185. 出口參數(shù):
  186. ***********************************************************************/
  187. void Timer2ISR(void)
  188. {
  189.         static u32 cnt = 0 , st = 0 , cnt_t = 0 , beep_freq_cnt = 0 , beep_freq = 1000 ;       
  190.         static u8 b = 0 , l_r_led = 0;
  191.         static u32 l_r_led_cnt = 0;//轉(zhuǎn)彎燈時(shí)間定時(shí)器
  192.         u32 audio_adc_val = 0;

  194.         //

  196.         if(cnt < DUTY_WIDTH)//占空比計(jì)數(shù)
  197.         {
  198.                 cnt ++;
  199.         }
  200.         else
  201.         {
  202.                 cnt = 0;
  203.         }


  206.         GPIO_WriteBit(GPIOC , GPIO_Pin_13 , l_r_led); //cpu狀態(tài)指示燈
  207.         GPIO_WriteBit(GPIOB, GPIO_Pin_2 , l_r_led);


  210.         //剎車(chē)燈控制       
  211.                 if(b_led_cnt < TIMER_FREQ / 2)
  212.                 {
  213.                         b_led_cnt ++;
  214.                         GPIO_WriteBit(GPIOB, GPIO_Pin_2 , 1);
  215.                 }
  216.                 else
  217.                 {
  218.                         //GPIO_WriteBit(GPIOB, GPIO_Pin_2 , 0);
  219.                 }


  222.         if(l_r_led_cnt < TIMER_FREQ / 5)
  223.         {
  224.                 l_r_led_cnt ++ ;
  225.         }
  226.         else
  227.         {
  228.                 l_r_led_cnt = 0;
  229.                 l_r_led = !l_r_led;
  230.         }

  232.         //轉(zhuǎn)彎控制
  233.         if(moto_L_switch) //左轉(zhuǎn)
  234.         {
  235.                 if(left_turn_cnt > 0)
  236.                 {
  237.                         left_turn_cnt --;
  238.                         GPIO_WriteBit(GPIOA, GPIO_Pin_1 , l_r_led);
  239.                         GPIO_WriteBit(GPIOA, GPIO_Pin_12 , 0);
  240.                 }
  241.                 else
  242.                 {
  243.                         moto_L_speed = moto_speed;//轉(zhuǎn)彎結(jié)束，自動(dòng)歸正
  244.                         moto_R_speed = moto_speed;//轉(zhuǎn)彎結(jié)束，自動(dòng)歸正
  245.                         moto_L_switch = 0;
  246.                         moto_L_dir = CAR_QIAN_JIN;
  247.                         moto_R_dir = CAR_QIAN_JIN;
  248.                         GPIO_WriteBit(GPIOA, GPIO_Pin_1 , 0);
  249.                 }
  250.         }
  251.         else
  252.         if(moto_R_switch)  //右轉(zhuǎn)
  253.         {
  254.                 if(right_turn_cnt > 0)
  255.                 {
  256.                         right_turn_cnt --;
  257.                         GPIO_WriteBit(GPIOA, GPIO_Pin_12 , l_r_led);
  258.                         GPIO_WriteBit(GPIOA, GPIO_Pin_1 , 0);
  259.                 }
  260.                 else
  261.                 {
  262.                         moto_L_speed = moto_speed;//轉(zhuǎn)彎結(jié)束，自動(dòng)歸正
  263.                         moto_R_speed = moto_speed;//轉(zhuǎn)彎結(jié)束，自動(dòng)歸正
  264.                         moto_R_switch = 0;
  265.                         moto_R_dir = CAR_QIAN_JIN;
  266.                         moto_L_dir = CAR_QIAN_JIN;
  267.                         GPIO_WriteBit(GPIOA, GPIO_Pin_12 , 0);
  268.                 }
  269.         }

  271.         //右電機(jī)控制,定時(shí)器模擬PWM控制
  272.         GPIO_WriteBit(GPIOB, GPIO_Pin_3  , moto_R_speed > 0 ? (cnt <= moto_R_speed + moto_speed_adj ?  (moto_R_dir == CAR_QIAN_JIN ? moto_run & 1 : 0) : 0) : 0);
  273.         GPIO_WriteBit(GPIOA, GPIO_Pin_15 , moto_R_speed > 0 ? (cnt <= moto_R_speed + moto_speed_adj ?  (moto_R_dir == moto_run & 1 ? moto_run & 1 : 0) : 0) : 0);
  274.                
  275.         //左電機(jī)控制,定時(shí)器模擬PWM控制
  276.         GPIO_WriteBit(GPIOA, GPIO_Pin_2  , moto_L_speed > 0 ? (cnt <= moto_L_speed ?  (moto_L_dir == moto_run & 1 ? moto_run & 1 : 0) : 0) : 0);
  277.         GPIO_WriteBit(GPIOA, GPIO_Pin_3  , moto_L_speed > 0 ? (cnt <= moto_L_speed ?  (moto_L_dir == CAR_QIAN_JIN ? moto_run & 1 : 0) : 0) : 0);       
  278.        
  279.         GPIO_WriteBit(GPIOA, GPIO_Pin_11  , cnt < lamp_front_bright);// 大燈


  282.         if(beep_freq_cnt < TIMER_FREQ / beep_freq / 2)//喇叭頻率計(jì)數(shù)器
  283.                 {
  284.                          beep_freq_cnt ++;
  285.                 }
  286.                 else
  287.                 {
  288.                         beep_freq_cnt = 0;
  289.                         b = !b;
  290.                 }

  292.                 if(beep_cnt > 0)//喇叭響持續(xù)時(shí)間
  293.                         {                               
  294.                                 beep_cnt --;
  295.                                 GPIO_WriteBit(GPIOB, GPIO_Pin_0 , b);
  296.                         }
  297.                         else
  298.                         {
  299.                                 GPIO_WriteBit(GPIOB, GPIO_Pin_0 , 0);
  300.                         }

  302. }

  304.   
  305. /***********************************************************************
  306. 函數(shù)功能:串口接收數(shù)據(jù)中斷程序,處理命令
  307. 入口參數(shù):
  308. 出口參數(shù):
  309. ***********************************************************************/
  310. void Uart1RevISR(u8 dat)
  311. {
  312.         char txt[33];

  314.         switch(dat)
  315.         {
  316.                 case '0': //開(kāi)關(guān)大燈
  317.                         lamp_f = !lamp_f;                       
  318.                 break;
  319.                 case 'a': //查詢(xún)連接
  320.                         SendStrToUart("b");               
  321.                 break;
  322.                 case 'd': //調(diào)試開(kāi)關(guān)
  323.                         debug_switch = !debug_switch;       
  324.                         sprintf(txt , "調(diào)試開(kāi)關(guān):%d\r\n" , debug_switch);
  325.                         SendStrToUart(txt);               
  326.                 break;
  327.                 case '5': //開(kāi)關(guān)喇叭
  328.                         beep_cnt = (TIMER_FREQ / 1000) * 300;
  329.                        
  330.                         sprintf(txt , "beep:%d\r\n" , beep_cnt);
  331.                         SendStrToUart(txt);                       
  332.                 break;
  333.                 case ' ': //開(kāi)關(guān)喇叭
  334.                         beep_cnt = (TIMER_FREQ / 1000) * 300;

  336.                         sprintf(txt , "beep:%d\r\n" , beep_cnt);
  337.                         SendStrToUart(txt);
  338.                 break;
  339.                 case '8': //加速
  340.                         moto_run = 1;

  342.                         if(CAR_QIAN_JIN == moto_L_dir && CAR_QIAN_JIN == moto_R_dir) //
  343.                         {
  344.                                 if(moto_speed < DUTY_WIDTH - 4)
  345.                                         moto_speed += 1;
  346.                         }
  347.                         else
  348.                         if(CAR_HOU_TUI == moto_L_dir && CAR_HOU_TUI == moto_R_dir) //
  349.                         {
  350.                                 if(moto_speed > 0)
  351.                                         moto_speed -= 1;
  352.                                 else
  353.                                 {
  354.                                         moto_speed = 0;
  355.                                         moto_L_dir = CAR_QIAN_JIN; //減速到0時(shí)開(kāi)始后退
  356.                                         moto_R_dir = CAR_QIAN_JIN; //減速到0時(shí)開(kāi)始后退
  357.                                 }
  358.                         }

  360.                         moto_L_speed = moto_speed;
  361.                         moto_R_speed = moto_speed;

  363.                         sprintf(txt , "L:%d , R:%d\r\n" , moto_L_speed , moto_R_speed);
  364.                         SendStrToUart(txt);
  365.                 break;
  366.                 case '2': //減速
  367.                         if(CAR_QIAN_JIN == moto_L_dir && CAR_QIAN_JIN == moto_R_dir) //
  368.                         {
  369.                                 if(moto_speed > 0)
  370.                                         moto_speed -= 1;
  371.                                 else
  372.                                 {
  373.                                         moto_speed = 0;
  374.                                         moto_L_dir = CAR_HOU_TUI; //減速到0時(shí)開(kāi)始后退
  375.                                         moto_R_dir = CAR_HOU_TUI; //減速到0時(shí)開(kāi)始后退
  376.                                 }
  377.                         }
  378.                         else
  379.                         if(CAR_HOU_TUI == moto_L_dir && CAR_HOU_TUI == moto_R_dir) //
  380.                         {
  381.                                 if(moto_speed < DUTY_WIDTH / 2)
  382.                                         moto_speed += 1;
  383.                         }


  386.                         b_led_cnt = 0;

  388.                         moto_L_speed = moto_speed;
  389.                         moto_R_speed = moto_speed;

  391.                         sprintf(txt , "L:%d , R:%d\r\n" , moto_L_speed , moto_R_speed);
  392.                         SendStrToUart(txt);

  394.                 break;
  395.                 case '7': //左轉(zhuǎn)校正
  396.                         if(moto_speed_adj < 3)
  397.                                 moto_speed_adj ++;
  398.                 break;
  399.                 case '9': //右轉(zhuǎn)校正
  400.                         if(moto_speed_adj > -3)
  401.                                 moto_speed_adj --;
  402.                 break;
  403.                 case '4': //左轉(zhuǎn)
  404.                         moto_L_switch = 1;
  405.                         moto_R_switch = 0;
  406.                         moto_L_dir = CAR_QIAN_JIN;
  407.                         moto_R_dir = CAR_QIAN_JIN;

  409.                         left_turn_cnt = (TIMER_FREQ / 5);//轉(zhuǎn)彎時(shí)間定時(shí)器
  410.                         moto_L_speed = moto_speed / 3;
  411.                         moto_R_speed = moto_speed;

  413.                         sprintf(txt , "L:%d , R:%d\r\n" , moto_L_switch , moto_R_switch);
  414.                         SendStrToUart(txt);
  415.                 break;
  416.                 case '6': //右轉(zhuǎn)
  417.                         moto_R_switch = 1;
  418.                         moto_L_switch = 0;
  419.                         moto_R_dir = CAR_QIAN_JIN;
  420.                         moto_L_dir = CAR_QIAN_JIN;

  422.                         right_turn_cnt = (TIMER_FREQ / 5);//轉(zhuǎn)彎時(shí)間定時(shí)器
  423.                         moto_R_speed = moto_speed / 3;
  424.                         moto_L_speed = moto_speed;

  426.                         sprintf(txt , "L:%d , R:%d\r\n" , moto_L_switch , moto_R_switch);
  427.                         SendStrToUart(txt);
  428.                 break;
  429.                 case 'l': //左轉(zhuǎn)大彎，并稍微后退，避障用
  430.                         moto_L_switch = 1;
  431.                         moto_R_switch = 0;
  432.                         moto_L_dir = CAR_HOU_TUI;
  433.                         moto_R_dir = CAR_HOU_TUI;

  435.                         left_turn_cnt = (TIMER_FREQ / (moto_speed / 20 + 1) );//轉(zhuǎn)彎時(shí)間定時(shí)器, 轉(zhuǎn)彎時(shí)間與速度相關(guān)
  436.                         moto_L_speed = moto_speed;
  437.                         moto_R_speed = moto_speed / 4;

  439.                         //sprintf(txt , "L:%d , R:%d\r\n" , moto_L_switch , moto_R_switch);
  440.                         //SendStrToUart(txt);
  441.                 break;
  442.                 case 'r': //右轉(zhuǎn)大彎，并稍微后退，避障用
  443.                         moto_R_switch = 1;
  444.                         moto_L_switch = 0;
  445.                         moto_R_dir = CAR_HOU_TUI;
  446.                         moto_L_dir = CAR_HOU_TUI;

  448.                         right_turn_cnt = (TIMER_FREQ / (moto_speed / 20 + 1) );//轉(zhuǎn)彎時(shí)間定時(shí)器, 轉(zhuǎn)彎時(shí)間與速度相關(guān)
  449.                         moto_R_speed = moto_speed;
  450.                         moto_L_speed = moto_speed / 4;

  452.                         //sprintf(txt , "L:%d , R:%d\r\n" , moto_L_switch , moto_R_switch);
  453.                         //SendStrToUart(txt);
  454.                 break;
  455.         }
  456. }
  457. /***********************************************************************
  458. 函數(shù)功能:串口接收數(shù)據(jù)中斷程序,處理命令
  459. 入口參數(shù):
  460. 出口參數(shù):
  461. ***********************************************************************/
  462. void Uart2RevISR(u8 dat)
  463. {       
  464.         u8 n = 0 , i = 0 , len = 0 , ch = 0;
  465.         float val = 0.0;
  466.         static float current_adj = 1.0;
  467.        
  468. }


  471. /***********************************************************************
  472. 函數(shù)功能:大燈控制
  473. 入口參數(shù):
  474. 出口參數(shù):
  475. ***********************************************************************/
  476. void Lamp_front(u8 de)
  477. {
  478.         u8 i = 0;

  480.         if(de == 1)//燈漸亮
  481.         {
  482.                 if(lamp_front_bright == 0)
  483.                 {       
  484.                         for(i = 0 ; i < DUTY_WIDTH ; i ++)
  485.                                 {
  486.                                         lamp_front_bright = i;
  487.                                         Delay_ms(20);
  488.                                 }
  489.                 }
  490.         }
  491.         else //燈漸暗
  492.         {
  493.                 if(lamp_front_bright == DUTY_WIDTH - 1)
  494.                 {       
  495.                         for(i = 0 ; i < DUTY_WIDTH ; i ++)
  496.                                 {
  497.                                         lamp_front_bright = DUTY_WIDTH - i - 1;          
  498.                                         Delay_ms(20);
  499.                                 }
  500.                 }
  501.         }
  502. }

  504. /***********************************************************************
  505. 函數(shù)功能:
  506. 入口參數(shù):
  507. 出口參數(shù):
  508. ***********************************************************************/
  509. int main(void)
  510. {
  511.         char txt[44];
  512.         int i = 0 , ls = 0 , rs = 0 , t = 0;
  513.         s32 ad = 0;

  515.         STM32_Board_Init();

  517.         //SendStrToUart("AT+BAUD8");//設(shè)置波特率為115200

  519.         moto_speed = 18; //
  520.         moto_run = 1;

  522.         moto_R_speed = moto_speed;
  523.         moto_R_dir   = CAR_QIAN_JIN;//電機(jī)方向

  525.         moto_L_speed = moto_speed;
  526.         moto_L_dir   = CAR_QIAN_JIN ;//電機(jī)方向

  528.         Delay_ms(200);

  530.         //自動(dòng)識(shí)別環(huán)境光強(qiáng)度
  531.         for(i = 0 ; i < 20 ; i ++)
  532.         {
  533.                 t += GetADCVal(ADC_Channel_5);
  534.         }
  535.         t /= 20;
  536.         IR_ref_value_L = t;

  538.         t = 0;
  539.         for(i = 0 ; i < 20 ; i ++)
  540.         {
  541.                 t += GetADCVal(ADC_Channel_4);
  542.         }
  543.         t /= 20;
  544.         IR_ref_value_R = t;

  546.         //FlashData=*(vu32*)(FLASH_ADR);         /* 讀取地址中的16位數(shù)據(jù) */       
  547.         //SendDataToUart('A');

  549.         lamp_front_bright = 0; //大燈亮度
  550.         beep_cnt = (TIMER_FREQ / 1000) * 100;//喇叭叫

  552.         while(1)
  553.                 {
  554.                         if(debug_switch == 0)
  555.                         {
  556.                                 if(lamp_front_bright == 0)
  557.                                 {
  558.                                         if(lamp_f == 1)
  559.                                         {
  560.                                                 Lamp_front(lamp_f);
  561.                                         }
  562.                                 }
  563.                                 else
  564.                                 {
  565.                                         if(lamp_f == 0)
  566.                                         {
  567.                                                 Lamp_front(lamp_f);
  568.                                         }
  569.                                 }
  570.        
  571.                                 rs = CheckHinder_Right();
  572.        
  573.                                 if( rs )        //判斷右側(cè)是否有障礙物 ， 如有則左轉(zhuǎn)
  574.                                 {
  575.                                         if(moto_L_switch == 0)
  576.                                         {
  577.                                                 Uart1RevISR('l');      //發(fā)送左轉(zhuǎn)指令
  578.                                                
  579.                                                 if(lamp_f == 0)        //如果大燈沒(méi)開(kāi)，這里打開(kāi)大燈
  580.                                                         lamp_front_bright = (rs - 0 ) * 10 + 0;
  581.                
  582.                                                 if(beep_cnt == 0)       
  583.                                                         beep_cnt = (TIMER_FREQ / 1000) * 50;  //喇叭叫一聲
  584.                                                 //SendStrToUart("<<<\r\n");
  585.                                         }
  586.                                 }
  587.                                 else
  588.                                 {
  589.                                         ls = CheckHinder_Left();
  590.                                                                                          //判斷左側(cè)是否有障礙物 ， 如有則右轉(zhuǎn)
  591.                                         if(ls)
  592.                                         {
  593.                                                 if(moto_R_switch == 0)
  594.                                                 {
  595.                                                         Uart1RevISR('r');      //發(fā)送右轉(zhuǎn)指令
  596.                        
  597.                                                         if(lamp_f == 0)        //如果大燈沒(méi)開(kāi)，這里打開(kāi)大燈
  598.                                                                 lamp_front_bright = (ls - 0 ) * 10 + 0;
  599.                        
  600.                                                         if(beep_cnt == 0)       
  601.                                                                 beep_cnt = (TIMER_FREQ / 1000) * 10;  //喇叭叫一聲
  602.                                                         //SendStrToUart(">>>\r\n");
  603.                                                 }
  604.                                         }
  605.                                         else
  606.                                         {
  607.                                                 if(lamp_f == 0 && lamp_front_bright > 0)
  608.                                                         lamp_front_bright = 0;
  609.                                         }
  610.                                 }       

  612.                                 Delay_ms(10);
  613.        
  614.                                 if(GPIO_ReadInputDataBit(GPIOB , GPIO_Pin_9) == 0)        //key1按下 ,開(kāi)車(chē)和停車(chē)切換
  615.                                 {
  616.                                         moto_run = !moto_run;
  617.        
  618.                                         while(GPIO_ReadInputDataBit(GPIOB , GPIO_Pin_9) == 0);
  619.                                         Delay_ms(20);
  620.                                 }

  622.                                 #if 0
  623.                                 if(lamp_f == 0)        //如果大燈沒(méi)開(kāi)，這里打開(kāi)大燈
  624.                                 {
  625.                                         ad = GetADCVal(ADC_Channel_6);
  626.                                         ad -= 2000;
  627.                                         if(ad > 0)
  628.                                                 ad = 0;
  629.                                         ad = 0 - ad;

  631.                                         ad /= 200;
  632.                                         lamp_front_bright = ad;
  633.                                 }
  634.                                 #endif
  635.                         }

  637.                         //GPIO_WriteBit(GPIOC , GPIO_Pin_13 , 0);//led
  638.                         //Delay_ms(200);
  639.                         //GPIO_WriteBit(GPIOC , GPIO_Pin_13 , 1);//led

  641.                         if(debug_switch)
  642.                         {
  643.                                 Delay_ms(50);
  644.                                 sprintf(txt , "右側(cè)紅外感應(yīng)AD4:%4d,左側(cè)紅外感應(yīng)AD5:%4d,音頻：%4d\r\n" , GetADCVal(ADC_Channel_4) , GetADCVal(ADC_Channel_5) , GetADCVal(ADC_Channel_6) );
  645.                                 SendStrToUart(txt);
  646.                         }
  647.                 }

  649.         return 0;
  650. }
復(fù)制代碼

所有資料51hei提供下載:
stm32 Car V1.0.zip (603.16 KB, 下載次數(shù): 23)


作者: 灰泰郎    時(shí)間: 2019-4-7 19:22
下載學(xué)習(xí)一下。



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1