devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

机器人制作开源方案 | 智能循迹避障小车_智能小车开源

作者：weixin_40725706 | 2024-04-17 06:03:20

赞

踩

智能小车开源

作者：刘元青、邹海峰、付志伟、秦怀远、牛文进

单位：哈尔滨信息工程学院

指导老师：姚清元

      智能小车是移动式机器人的重要组成部分，而移动机器人不仅能够在经济、国防、教育、文化和生活中起到越来越大的作用，也是研究复杂智能行为的产生、探索人类思维模式的有效工具与实验平台。

      本文设计的是一款基于Arduino的智能小车，它利用Arduino作为主控系统。它用蓝牙模块进行无线数据传输，实现无线控制。它利用红外线反射等原理，实现自动循迹效果。同时它利用超声波测距模块来进行测距，将测得的距离数据传给Arduino，经过Arduino处理给出反馈，驱动电机转动，实现自动避障的功能。

1. 系统设计与实现

1.1 系统设计

1.1.1 系统架构

      Roboduino智能小车车身由Arduino开发板和舵机等设备组成，其功能实现则由Arduino IDE编写程序以及Helloblock的调试来完成。

1.1.2 功能架构

      基于Arduino的Roboduino智能小车通过烧录WiFi遥控程序，利用超声波测距原理实现自动避障，利用红外线反射原理实现自动循迹，此外还有其他功能模式。

1.1.3 技术架构

      通过在Arduino IDE平台编写C代码来实现功能模块，将WIFI无线连接程序烧录至Arduino开发板，内含相关功能模块代码，利用超声波测距技术和红外线传感器分别实现自动避障和自动循迹功能。

1.2 系统实现

1.2.1 超声波测距

       实验原理：超声波模块是利用超声波特性检测距离的传感器。其带有两个超声波探头，分别用作发射和接收超声波。本次实验我们所使用的模块，其测量的范围是 0-3m。

      超声波时序图：以下时序图表明你只需要提供一个10uS 以上脉冲触发信号，该模块内部将发出8个40kHz周期电平并检测回波。一旦检测到有回波信号则输出回响信号。回响信号的脉冲宽度与所测的距离成正比。由此通过发射信号到收到的回响信号时间间隔可以计算得到距离。公式: uS/58=厘米或者uS/148=英寸;或是:距离=高电平时间*声速（340M/S）/2;建议测量周期为60ms 以上，以防止发射信号对回响信号的影响。

超声波模块引脚：根据硬件接口速查手册可知，超声波模块的超声波功能由Uno板的 Pin12引脚直接驱动。

实验程序

超声波测距（RGBUltrasonic_Ranging.ino）

  1. /*
  2.  
  3. * @par Copyright (C): 2010-2019, Shenzhen Yahboom Tech
  4.  
  5. * @file         Ultrasonic_Ranging.c
  6.  
  7. * @author       Cindy
  8.  
  9. * @version      V1.0
  10.  
  11. * @date         2018.10.18
  12.  
  13. * @brief        Ultrasonic_Ranging
  14.  
  15. * @details
  16.  
  17. * @par History   
  18.  
  19. *
  20.  
  21. */
  22.  
  23. #include <Wire.h>
  24.  
  25. #include "Adafruit_PWMServoDriver.h"
  26.  
  27. Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
  28.  
  29. const int SingPin = 12;
  30.  
  31. float distance;
  32.  
  33. /**
  34.  
  35. * Function       setup
  36.  
  37. * @author        liusen
  38.  
  39. * @date          2017.07.25
  40.  
  41. * @brief         Initial configuration
  42.  
  43. * @param[in]     void
  44.  
  45. * @retval        void
  46.  
  47. * @par History   no
  48.  
  49. */
  50.  
  51. void setup()
  52.  
  53. {
  54.  
  55.    pwm.begin();
  56.  
  57.    pwm.setPWMFreq(60);                 //Analog servos run at ~60 Hz updates
  58.  
  59.    LOGO_breathing_light(255, 40, 5);   //Gradually light the blue light of the Yhaboom_LOGO
  60.  
  61.    Serial.begin(9600);
  62.  
  63.    Serial.println("Ultrasonic sensor:");
  64.  
  65. }
  66.  
  67. /**
  68.  
  69. * Function       LOGO_light(brightness,time,increament)
  70.  
  71. * @author        wusicaijuan
  72.  
  73. * @date          2019.06.26
  74.  
  75. * @brief         LOGO_light
  76.  
  77. * @param[in1]    brightness
  78.  
  79. * @param[in2]    time
  80.  
  81. * @param[in3]    increament
  82.  
  83. * @param[out]    void
  84.  
  85. * @retval        void
  86.  
  87. * @par History   no
  88.  
  89. */
  90.  
  91. void LOGO_breathing_light(int brightness, int time, int increament)
  92.  
  93. {
  94.  
  95.   if (brightness < 0)
  96.  
  97.   {
  98.  
  99.     brightness = 0;
  100.  
  101.   }
  102.  
  103.   if (brightness > 255)
  104.  
  105.   {
  106.  
  107.     brightness = 255;
  108.  
  109.   }
  110.  
  111.   for (int b = 0; b < brightness; b += increament)
  112.  
  113.   {
  114.  
  115.     int newb = map(b, 0, 255, 0, 4095);
  116.  
  117.     pwm.setPWM(7, 0, newb);
  118.  
  119.     delay(time);
  120.  
  121.   }
  122.  
  123. }
  124.  
  125. /**
  126.  
  127. * Function       loop
  128.  
  129. * @author        Cindy
  130.  
  131. * @date          2019.07.30
  132.  
  133. * @brief         main fuction
  134.  
  135. * @param[in]     void
  136.  
  137. * @retval        void
  138.  
  139. * @par History   no
  140.  
  141. */
  142.  
  143. void loop()
  144.  
  145. {
  146.  
  147.   pinMode(SingPin,OUTPUT);
  148.  
  149.   digitalWrite(SingPin, LOW);
  150.  
  151.   delayMicroseconds(2);
  152.  
  153.   digitalWrite(SingPin, HIGH);
  154.  
  155.   delayMicroseconds(10);
  156.  
  157.   digitalWrite(SingPin, LOW);
  158.  
  159.  
  160.  
  161.   pinMode(SingPin, INPUT);
  162.  
  163.   delayMicroseconds(50);
  164.  
  165.   distance = pulseIn(SingPin, HIGH) / 58.00;
  166.  
  167.   Serial.print("distance is :");
  168.  
  169.   Serial.print(distance);
  170.  
  171.   Serial.print("cm");
  172.  
  173.   Serial.println();
  174.  
  175.   delay(1000);
  176.  
  177. }

操作流程

      我们需要通用 Arduino IDE 软件打开RGBUltrasonic_Ranging.ino文件，然后点击菜单栏中的“√”编译程序，并且等待左下角出现“编译成功”的字样。

在 Arduino IDE 的菜单栏中，我们需要选择【工具】---【端口】---选择设备管理器中刚刚显示端口号。

选择完成后，点击菜单栏下的“→”将代码上传到 UNO 板。 当左下角出现“上 传完成”字样时，表示程序已成功上传到 UNO 板。

程序下载完成之后，我们需要打开 Arduino IDE 界面右上角的“串口监视器”。

在串口监视器中选择和程序中相同的波特率。

接下来，我们就可以在串口监视器上面看到超声波模块当前所测量的距离被打印出来了。

1.2.2 巡线测试

      实验原理：红外传感器巡线的基本原理是利用物体的反射性质，我们本次实验是巡黑线行驶，当红外线发射到黑线上时会被黑线吸收掉，发射到其他的颜色的材料上会有反射到红外的接手管上。

      巡线模块引脚：根据硬件接口速查手册可知，三路巡线模块分别用Uno板的A0、A1、A2引脚驱动。

实验程序

① Tracking_PID_v1.ino

  1. /*
  2.  
  3. * @par Copyright (C): 2010-2019, Shenzhen Yahboom Tech
  4.  
  5. * @file         Tracking_test.c
  6.  
  7. * @author       wusicaijuan
  8.  
  9. * @version      V1.0
  10.  
  11. * @date         2019.08.05
  12.  
  13. * @brief        Tracking_test
  14.  
  15. * @details
  16.  
  17. * @par History   
  18.  
  19. *
  20.  
  21. */
  22.  
  23. #include "Adafruit_PWMServoDriver.h"
  24.  
  25. Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
  26.  
  27. float max = 3.85;
  28.  
  29. float s = 100;
  30.  
  31. float Kp = 37, Ki = 4, Kd = 60;  
  32.  
  33. float error = 0, P = 0, I = 0, D = 0, PID_value = 0;
  34.  
  35. float previous_error = 0, previous_I = 0;
  36.  
  37. int sensor[3] = {0, 0, 0};
  38.  
  39. int initial_motor_speed = 40;
  40.  
  41. const int key = 7;
  42.  
  43. void read_sensor_values(void);
  44.  
  45. void calculate_pid(void);
  46.  
  47. void motor_control(void);
  48.  
  49. void keyscan(void);
  50.  
  51. void Clear_All_PWM(void);
  52.  
  53. /**
  54.  
  55. * Function       setup
  56.  
  57. * @author        wusicaijuan
  58.  
  59. * @date          2019.08.05
  60.  
  61. * @brief         Initial configuration
  62.  
  63. * @param[in]     void
  64.  
  65. * @retval        void
  66.  
  67. * @par History   no
  68.  
  69. */
  70.  
  71. void setup()
  72.  
  73. {
  74.  
  75. // put your setup code here, to run once:
  76.  
  77. pwm.begin();
  78.  
  79. pwm.setPWMFreq(60); // Analog servos run at ~60 Hz updates
  80.  
  81. Clear_All_PWM();
  82.  
  83. pinMode(A0, INPUT);
  84.  
  85. pinMode(A1, INPUT);
  86.  
  87. pinMode(A2, INPUT);
  88.  
  89. pinMode(key, INPUT);
  90.  
  91. keysacn();
  92.  
  93. }
  94.  
  95. /**
  96.  
  97. * Function       loop
  98.  
  99. * @author        wusicaijuan
  100.  
  101. * @date          2019.07.30
  102.  
  103. * @brief         main fuction
  104.  
  105. * @param[in]     void
  106.  
  107. * @retval        void
  108.  
  109. * @par History   no
  110.  
  111. */
  112.  
  113. void loop()
  114.  
  115. {
  116.  
  117. read_sensor_values();
  118.  
  119. calculate_pid();
  120.  
  121. motor_control();
  122.  
  123. }
  124.  
  125. /**
  126.  
  127. * Function       read_sensor_values
  128.  
  129. * @author        wusicaijuan
  130.  
  131. * @date          2019.07.30
  132.  
  133. * @brief         read sensor value to change car movement
  134.  
  135. * @param[in]     void
  136.  
  137. * @retval        void
  138.  
  139. * @par History   no
  140.  
  141. */
  142.  
  143. void read_sensor_values()
  144.  
  145. {
  146.  
  147. sensor[0] = analogRead(A0);
  148.  
  149. sensor[1] = analogRead(A1);
  150.  
  151. sensor[2] = analogRead(A2);
  152.  
  153. if (sensor[0] > 100)
  154.  
  155. {
  156.  
  157. sensor[0] = 1;
  158.  
  159. }
  160.  
  161. else
  162.  
  163. {
  164.  
  165. sensor[0] = 0;
  166.  
  167. }
  168.  
  169. if (sensor[1] > 100)
  170.  
  171. {
  172.  
  173. sensor[1] = 1;
  174.  
  175. }
  176.  
  177. else
  178.  
  179. {
  180.  
  181. sensor[1] = 0;
  182.  
  183. }
  184.  
  185. if (sensor[2] > 100)
  186.  
  187. {
  188.  
  189. sensor[2] = 1;
  190.  
  191. }
  192.  
  193. else
  194.  
  195. {
  196.  
  197. sensor[2] = 0;
  198.  
  199. }
  200.  
  201. if ((sensor[0] == 0) && (sensor[1] == 0) && (sensor[2] == 1))
  202.  
  203. {
  204.  
  205. error = 2;
  206.  
  207. }
  208.  
  209. else if ((sensor[0] == 0) && (sensor[1] == 1) && (sensor[2] == 1))
  210.  
  211. {
  212.  
  213. error = 1;
  214.  
  215. }
  216.  
  217. else if ((sensor[0] == 0) && (sensor[1] == 1) && (sensor[2] == 0))
  218.  
  219. {
  220.  
  221. error = 0;
  222.  
  223. }
  224.  
  225. else if ((sensor[0] == 1) && (sensor[1] == 1) && (sensor[2] == 0))
  226.  
  227. {
  228.  
  229. error = -1;
  230.  
  231. }
  232.  
  233. else if ((sensor[0] == 1) && (sensor[1] == 0) && (sensor[2] == 0))
  234.  
  235. {
  236.  
  237. error = -2;
  238.  
  239. }
  240.  
  241. else if ((sensor[0] == 0) && (sensor[1] == 0) && (sensor[2] == 0))
  242.  
  243. {
  244.  
  245. if (error > 0)
  246.  
  247. {
  248.  
  249. //spin left
  250.  
  251. error = max;
  252.  
  253. }
  254.  
  255. else
  256.  
  257. {
  258.  
  259. //spin right
  260.  
  261. error = -max;
  262.  
  263. }
  264.  
  265. }
  266.  
  267. }
  268.  
  269. /**
  270.  
  271. * Function       calculate_pid
  272.  
  273. * @author        wusicaijuan
  274.  
  275. * @date          2019.06.25
  276.  
  277. * @brief         calculate_pid
  278.  
  279. * @param[out]   
  280.  
  281. * @retval       
  282.  
  283. * @par History   no
  284.  
  285. */
  286.  
  287. void calculate_pid()
  288.  
  289. {
  290.  
  291. P = error;
  292.  
  293. I = I + previous_I;
  294.  
  295. D = error - previous_error;
  296.  
  297. PID_value = (Kp * P) + (Ki * I) + (Kd * D);
  298.  
  299. // Serial.println(PID_value);
  300.  
  301. previous_I = I;
  302.  
  303. previous_error = error;
  304.  
  305. }
  306.  
  307. void motor_control()
  308.  
  309. {
  310.  
  311. // Calculating the effective motor speed:
  312.  
  313. int left_motor_speed = initial_motor_speed - PID_value;
  314.  
  315. int right_motor_speed = initial_motor_speed + PID_value;
  316.  
  317. // The motor speed should not exceed the max PWM value
  318.  
  319. // left_motor_speed = constrain(left_motor_speed, -255, 255);
  320.  
  321. // right_motor_speed = constrain(right_motor_speed, -255, 255);
  322.  
  323. left_motor_speed = constrain(left_motor_speed, -s, s);
  324.  
  325. right_motor_speed = constrain(right_motor_speed, -s, s);
  326.  
  327. run(left_motor_speed, right_motor_speed);
  328.  
  329. }
  330.  
  331. /**
  332.  
  333. * Function       run
  334.  
  335. * @author        wusicaijuan
  336.  
  337. * @date          2019.06.25
  338.  
  339. * @brief         run
  340.  
  341. * @param[in]     Speed
  342.  
  343. * @param[out]    void
  344.  
  345. * @retval        void
  346.  
  347. * @par History   no
  348.  
  349. */
  350.  
  351. void run(float Speed1, float Speed2)
  352.  
  353. {
  354.  
  355. Speed1 = map(Speed1, -255, 255, -4095, 4095);
  356.  
  357. Speed2 = map(Speed2, -255, 255, -4095, 4095);
  358.  
  359. if (Speed2 > 0)
  360.  
  361. {
  362.  
  363. pwm.setPWM(10, 0, Speed2); //Right front wheel Forward
  364.  
  365. pwm.setPWM(11, 0, 0);
  366.  
  367. pwm.setPWM(8, 0, Speed2); //Right rear wheel Forward
  368.  
  369. pwm.setPWM(9, 0, 0);
  370.  
  371. }
  372.  
  373. else
  374.  
  375. {
  376.  
  377. pwm.setPWM(10, 0, 0);
  378.  
  379. pwm.setPWM(11, 0, abs(Speed2));
  380.  
  381. pwm.setPWM(8, 0, 0);
  382.  
  383. pwm.setPWM(9, 0, abs(Speed2));
  384.  
  385. }
  386.  
  387. if (Speed1 > 0)
  388.  
  389. {
  390.  
  391. pwm.setPWM(13, 0, Speed1); //Left front wheel Forward
  392.  
  393. pwm.setPWM(12, 0, 0);
  394.  
  395. pwm.setPWM(15, 0, Speed1); //Left front wheel Forward
  396.  
  397. pwm.setPWM(14, 0, 0);
  398.  
  399. }
  400.  
  401. else
  402.  
  403. {
  404.  
  405. pwm.setPWM(13, 0, 0);
  406.  
  407. pwm.setPWM(12, 0, abs(Speed1));
  408.  
  409. pwm.setPWM(15, 0, 0);
  410.  
  411. pwm.setPWM(14, 0, abs(Speed1));
  412.  
  413. }
  414.  
  415. }
  416.  
  417. /**
  418.  
  419. * Function       sleft
  420.  
  421. * @author        wusicaijuan
  422.  
  423. * @date          2019.06.25
  424.  
  425. * @brief         turn left(Left wheel stop，Right wheel advance)
  426.  
  427. * @param[in]     Speed
  428.  
  429. * @param[out]    void
  430.  
  431. * @retval        void
  432.  
  433. * @par History   no
  434.  
  435. */
  436.  
  437. void sleft(float Speed)
  438.  
  439. {
  440.  
  441. pwm.setPWM(10, 0, Speed); //Right front wheel Forword
  442.  
  443. pwm.setPWM(11, 0, 0);
  444.  
  445. pwm.setPWM(8, 0, Speed);   //Right rear wheel Forword
  446.  
  447. pwm.setPWM(9, 0, 0);
  448.  
  449. pwm.setPWM(13, 0, 0);     //Left front wheel Back
  450.  
  451. pwm.setPWM(12, 0, Speed);
  452.  
  453. pwm.setPWM(15, 0, 0);     //Left rear wheel Back
  454.  
  455. pwm.setPWM(14, 0, Speed);
  456.  
  457. }
  458.  
  459. /**
  460.  
  461. * Function       sright
  462.  
  463. * @author        wusicaijuan
  464.  
  465. * @date          2019.06.25
  466.  
  467. * @brief         spin_right(Left wheel advance，Right wheel back)
  468.  
  469. * @param[in]     Speed
  470.  
  471. * @param[out]    void
  472.  
  473. * @retval        void
  474.  
  475. * @par History   no
  476.  
  477. */
  478.  
  479. void sright(float Speed)
  480.  
  481. {
  482.  
  483. pwm.setPWM(10, 0, 0);
  484.  
  485. pwm.setPWM(11, 0, Speed);   //Right front wheel Back
  486.  
  487. pwm.setPWM(8, 0, 0);
  488.  
  489. pwm.setPWM(9, 0, Speed);   //Right rear wheel Back
  490.  
  491. pwm.setPWM(13, 0, Speed);   //Left front wheel Forword
  492.  
  493. pwm.setPWM(12, 0, 0);
  494.  
  495. pwm.setPWM(15, 0, Speed);   //Left rear wheel Forword
  496.  
  497. pwm.setPWM(14, 0, 0);
  498.  
  499. }
  500.  
  501. /**
  502.  
  503. * Function       keysacn
  504.  
  505. * @author        wusicaijuan
  506.  
  507. * @date          2019.06.04
  508.  
  509. * @brief         keysacn
  510.  
  511. * @param[in1]    void
  512.  
  513. * @retval        void
  514.  
  515. * @par History   no
  516.  
  517. */
  518.  
  519. void keysacn()
  520.  
  521. {
  522.  
  523. int val;
  524.  
  525. val = digitalRead(key); //Read the level value of   digital 7 port assigned to val
  526.  
  527. while (val == HIGH)   //Cycles when the button is not pressed
  528.  
  529. {
  530.  
  531. val = digitalRead(key);
  532.  
  533. }
  534.  
  535. while (val == LOW)     //When button is not pressed
  536.  
  537. {
  538.  
  539. delay(1);
  540.  
  541. val = digitalRead(key); //Read the level value of   digital 7 port assigned to val
  542.  
  543. while (val == HIGH)   //Determine if the button is released
  544.  
  545. {
  546.  
  547. break;
  548.  
  549. }
  550.  
  551. }
  552.  
  553. }
  554.  
  555. /*
  556.  
  557. * Function       Clear_All_PWM
  558.  
  559. * @author        wusicaijuan
  560.  
  561. * @date          2019.07.04
  562.  
  563. * @brief         Turn off PWM
  564.  
  565. * @param[in]     void
  566.  
  567. * @param[out]    void
  568.  
  569. * @retval        void
  570.  
  571. * @par History   no
  572.  
  573. */
  574.  
  575. void Clear_All_PWM()
  576.  
  577. {
  578.  
  579. for (int i = 0; i < 16; i++)
  580.  
  581. {
  582.  
  583. pwm.setPWM(i, 0, 0);
  584.  
  585. }
  586.  
  587. }

② Tracking_test.ino

  1. /*
  2.  
  3. * @par Copyright (C): 2010-2019, Shenzhen Yahboom Tech
  4.  
  5. * @file         Tracking_test.c
  6.  
  7. * @author       wusicaijuan
  8.  
  9. * @version      V1.0
  10.  
  11. * @date         2019.08.05
  12.  
  13. * @brief        Tracking_test
  14.  
  15. * @details
  16.  
  17. * @par History   
  18.  
  19. *
  20.  
  21. */
  22.  
  23. #include "Adafruit_PWMServoDriver.h"
  24.  
  25. Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
  26.  
  27. int sensor[3];
  28.  
  29. const int key = 7; //Define key pin
  30.  
  31. void keyscan(void);
  32.  
  33. void Clear_All_PWM(void);
  34.  
  35. #define   L_Value   analogRead(A2)
  36.  
  37. #define   M_Value   analogRead(A1)
  38.  
  39. #define   R_Value   analogRead(A0)
  40.  
  41. /**
  42.  
  43. * Function       setup
  44.  
  45. * @author        liusen
  46.  
  47. * @date          2017.07.25
  48.  
  49. * @brief         Initial configuration
  50.  
  51. * @param[in]     void
  52.  
  53. * @retval        void
  54.  
  55. * @par History   no
  56.  
  57. */
  58.  
  59. void setup()
  60.  
  61. {
  62.  
  63.   // put your setup code here, to run once:
  64.  
  65.   pwm.begin();
  66.  
  67.   pwm.setPWMFreq(60); // Analog servos run at ~60 Hz updates
  68.  
  69.   Clear_All_PWM();
  70.  
  71.   pinMode(A0, INPUT);
  72.  
  73.   pinMode(A1, INPUT);
  74.  
  75.   pinMode(A2, INPUT);
  76.  
  77.   pinMode(key, INPUT);
  78.  
  79.   keysacn();
  80.  
  81. }
  82.  
  83. /**
  84.  
  85. * Function       loop
  86.  
  87. * @author        wusicaijuan
  88.  
  89. * @date          2019.07.30
  90.  
  91. * @brief         main fuction
  92.  
  93. * @param[in]     void
  94.  
  95. * @retval        void
  96.  
  97. * @par History   no
  98.  
  99. */
  100.  
  101. void loop()
  102.  
  103. {
  104.  
  105.   read_sensor_values();
  106.  
  107. }
  108.  
  109. /**
  110.  
  111. * Function       read_sensor_values
  112.  
  113. * @author        wusicaijuan
  114.  
  115. * @date          2019.07.30
  116.  
  117. * @brief         read sensor value to change car movement
  118.  
  119. * @param[in]     void
  120.  
  121. * @retval        void
  122.  
  123. * @par History   no
  124.  
  125. */
  126.  
  127. /*450，350，400分别是中间探头左侧探头右侧探头黑白线之间的临界值,
  128.  
  129.   * 请用户一定要根据实际情况打印观察这三个数据，并进行修改。
  131.   */
  133. void read_sensor_values()
  134.  
  135. {
  136.  
  137.     if(M_Value>340)  
  138.  
  139.     {
  140.  
  141.       run(65);
  142.  
  143.     }
  144.  
  145.     else if(L_Value > 350)
  146.  
  147.     {
  148.  
  149.       sleft(75);
  150.  
  151.       while(L_Value>350);
  152.  
  153.     }
  154.  
  155.     else if(R_Value > 400)   
  156.  
  157.     {
  158.  
  159.       sright(75);
  160.  
  161.       while(R_Value > 400);   
  162.  
  163.     }
  164.  
  165. }
  166.  
  167. /**
  168.  
  169. * Function       run
  170.  
  171. * @author        wusicaijuan
  172.  
  173. * @date          2019.06.25
  174.  
  175. * @brief         run
  176.  
  177. * @param[in]     Speed
  178.  
  179. * @param[out]    void
  180.  
  181. * @retval        void
  182.  
  183. * @par History   no
  184.  
  185. */
  186.  
  187. void run(float Speed)
  188.  
  189. {
  190.  
  191.   Speed = map(Speed, 0, 255, 0, 4095);
  192.  
  193.   pwm.setPWM(10, 0, Speed); //Right front wheel Forward
  194.  
  195.   pwm.setPWM(11, 0, 0);
  196.  
  197.   pwm.setPWM(8, 0, Speed); //Right rear wheel Forward
  198.  
  199.   pwm.setPWM(9, 0, 0);
  200.  
  201.   pwm.setPWM(13, 0, Speed); //Left front wheel Forward
  202.  
  203.   pwm.setPWM(12, 0, 0);
  204.  
  205.   pwm.setPWM(15, 0, Speed); //Left front wheel Forward
  206.  
  207.   pwm.setPWM(14, 0, 0);
  208.  
  209. }
  210.  
  211. /**
  212.  
  213. * Function       left
  214.  
  215. * @author        wusicaijuan
  216.  
  217. * @date          2019.06.26
  218.  
  219. * @brief         turn left(Left wheel stop，Right wheel advance)
  220.  
  221. * @param[in]     Speed
  222.  
  223. * @param[out]    void
  224.  
  225. * @retval        void
  226.  
  227. * @par History   no
  228.  
  229. */
  230.  
  231. void left(float Speed)
  232.  
  233. {
  234.  
  235.   Speed = map(Speed, 0, 255, 0, 4095);
  236.  
  237.   pwm.setPWM(10, 0, Speed);   //Right front wheel Reverse
  238.  
  239.   pwm.setPWM(11, 0, 0);
  240.  
  241.   pwm.setPWM(8, 0, Speed);   //Right rear wheel Reverse
  242.  
  243.   pwm.setPWM(9, 0, 0);
  244.  
  245.   pwm.setPWM(13, 0, 0);     //Left front wheel Stop
  246.  
  247.   pwm.setPWM(12, 0, 0);
  248.  
  249.   pwm.setPWM(15, 0, 0);
  250.  
  251.   pwm.setPWM(14, 0, 0);
  252.  
  253. }
  254.  
  255. /**
  256.  
  257. * Function       right
  258.  
  259. * @author        wusicaijuan
  260.  
  261. * @date          2019.06.26
  262.  
  263. * @brief         turn right (Left wheel advance，Right wheel stop)
  264.  
  265. * @param[in]     Speed
  266.  
  267. * @param[out]    void
  268.  
  269. * @retval        void
  270.  
  271. * @par History   no
  272.  
  273. */
  274.  
  275. void right(float Speed)
  276.  
  277. {
  278.  
  279.   Speed = map(Speed, 0, 255, 0, 4095);
  280.  
  281.   pwm.setPWM(10, 0, 0);   //Right front wheel Stop
  282.  
  283.   pwm.setPWM(11, 0, 0);
  284.  
  285.   pwm.setPWM(8, 0, 0);
  286.  
  287.   pwm.setPWM(9, 0, 0);
  288.  
  289.   pwm.setPWM(13, 0, Speed);   //Left front wheel Reverse
  290.  
  291.   pwm.setPWM(12, 0, 0);
  292.  
  293.   pwm.setPWM(15, 0, Speed); //Left rear wheel Reverse
  294.  
  295.   pwm.setPWM(14, 0, 0);
  296.  
  297. }
  298.  
  299. /**
  300.  
  301. * Function       sleft
  302.  
  303. * @author        wusicaijuan
  304.  
  305. * @date          2019.06.25
  306.  
  307. * @brief         spin_left(Left wheel back，Right wheel advance)
  308.  
  309. * @param[in]     Speed
  310.  
  311. * @param[out]    void
  312.  
  313. * @retval        void
  314.  
  315. * @par History   no
  316.  
  317. */
  318.  
  319. void sleft(float Speed)
  320.  
  321. {
  322.  
  323.   Speed = map(Speed, 0, 255, 0, 4095);
  324.  
  325.   pwm.setPWM(10, 0, Speed);   //Right front wheel Forword
  326.  
  327.   pwm.setPWM(11, 0, 0);
  328.  
  329.   pwm.setPWM(8, 0, Speed);   //Right rear wheel Forword
  330.  
  331.   pwm.setPWM(9, 0, 0);
  332.  
  333.   pwm.setPWM(13, 0, 0);      //Left front wheel Back
  334.  
  335.   pwm.setPWM(12, 0, Speed);
  336.  
  337.   pwm.setPWM(15, 0, 0);
  338.  
  339.   pwm.setPWM(14, 0, Speed);   //Left rear wheel Back
  340.  
  341. }
  342.  
  343. /**
  344.  
  345. * Function       sright
  346.  
  347. * @author        wusicaijuan
  348.  
  349. * @date          2019.06.25
  350.  
  351. * @brief         spin_right(Left wheel advance，Right wheel back)
  352.  
  353. * @param[in]     Speed
  354.  
  355. * @param[out]    void
  356.  
  357. * @retval        void
  358.  
  359. * @par History   no
  360.  
  361. */
  362.  
  363. void sright(float Speed)
  364.  
  365. {
  366.  
  367.   Speed = map(Speed, 0, 255, 0, 4095);
  368.  
  369.   pwm.setPWM(10, 0, 0);
  370.  
  371.   pwm.setPWM(11, 0, Speed);   //Right front wheel Back
  372.  
  373.   pwm.setPWM(8, 0, 0);
  374.  
  375.   pwm.setPWM(9, 0, Speed);   //Right rear wheel Back
  376.  
  377.   pwm.setPWM(13, 0, Speed);   //Left front wheel Forword
  378.  
  379.   pwm.setPWM(12, 0, 0);
  380.  
  381.   pwm.setPWM(15, 0, Speed);   //Left rear wheel Forword
  382.  
  383.   pwm.setPWM(14, 0, 0);
  384.  
  385. }
  386.  
  387. /**
  388.  
  389. * Function       keysacn
  390.  
  391. * @author        wusicaijuan
  392.  
  393. * @date          2019.06.04
  394.  
  395. * @brief         keysacn
  396.  
  397. * @param[in1]    void
  398.  
  399. * @retval        void
  400.  
  401. * @par History   no
  402.  
  403. */
  404.  
  405. void keysacn()
  406.  
  407. {
  408.  
  409.   int val;
  410.  
  411.   val = digitalRead(key); //Read the level value of   digital 7 port assigned to val
  412.  
  413.   while (val == HIGH)     //Cycles when the button is not pressed
  414.  
  415.   {
  416.  
  417.     val = digitalRead(key);
  418.  
  419.   }
  420.  
  421.   while (val == LOW)      //When button is not pressed
  422.  
  423.   {
  424.  
  425.     delay(10);       
  426.  
  427.     val = digitalRead(key); //Read the level value of   digital 7 port assigned to val
  428.  
  429.     while (val == HIGH)     //Determine if the button is released
  430.  
  431.     {
  432.  
  433.       break;
  434.  
  435.     }
  436.  
  437.   }
  438.  
  439. }
  440.  
  441. /*
  442.  
  443. * Function       Clear_All_PWM
  444.  
  445. * @author        wusicaijuan
  446.  
  447. * @date          2019.07.04
  448.  
  449. * @brief         Turn off PWM
  450.  
  451. * @param[in]     void
  452.  
  453. * @param[out]    void
  454.  
  455. * @retval        void
  456.  
  457. * @par History   no
  458.  
  459. */
  460.  
  461. void Clear_All_PWM()
  462.  
  463. {
  464.  
  465.   for (int i = 0; i < 16; i++)
  466.  
  467.   {
  468.  
  469.     pwm.setPWM(i, 0, 0);
  470.  
  471.   }
  472.  
  473. }

③ TrackingSensorTest.ino

  1. //30    27    29
  2.  
  3. void setup()
  4.  
  5. {
  6.  
  7. Serial.begin(115200);
  8.  
  9. pinMode(A0, INPUT);
  10.  
  11. pinMode(A1, INPUT);
  12.  
  13. pinMode(A2, INPUT);
  14.  
  15. }
  16.  
  17. void loop()
  18.  
  19. {
  20.  
  21. delay(50);
  22.  
  23. Serial.print(analogRead(A0));   
  24.  
  25. Serial.print(",");
  26.  
  27. Serial.print(analogRead(A1));
  28.  
  29. Serial.print(",");
  30.  
  31. Serial.println(analogRead(A2));
  32.  
  33. }

实验现象

      对于程序Tracking_test.ino，首先打开在TrackingSensorTest文件夹中 TrackingSensorTest.ino。并通过数据线将小车（或者是已经插入扩展板的 Uno板）与电脑连接。然后将三路巡线模块处于白色底部上（必须是你的小车将要行驶的巡线赛道的白色底部），如下图所示将三路巡线模块处于黑色赛道上（必须是你的小车将要行驶的巡线黑色赛道）。

在Arduino IDE界面的右上角打开串口监视器，需要选择与程序中所设置的相同的波特率。

当巡线传感器的三个探头检测到白色时，检测到黑色时，打印出当前输出的模拟值。

如果数据显示一点波动，这是正常的。

打开 Tracking_test 文件夹中的 Tracking_test.ino 文件，并且根据上一步打印出来的数值，取一个最佳的临界值，修改程序中的数据。

      修改完成之后，保存程序并将程序下载小车上。

      对于程序：Tracking_PID.ino首先，打开在TrackingSensorTest 文件夹中 TrackingSensorTest.ino。并通过数据线将小车（或者是已经插入扩展板的 Uno 板）与电脑连接。然后，将三路巡线模块处于白色底部上（必须是你的小车将要行驶的巡线赛道的白色底部）。

在 Arduino IDE 界面的右上角打开串口监视器，需要选择与程序中所设置的相同的波特率。

当巡线传感器的三个探头检测到白色时，打印出当前输出的模拟值。

如果数据显示一点波动，这是正常的，可以取五个数据的平均值。

打开Tracking_PID 文件夹中的 Tracking_PID.ino 文件，并且修改程序中的数据。

1.2.3 WIFI摄像头控制

实验原理：根据硬件接口速查手册可知，WIFI 摄像头模块是通过串口进行通讯的。

实验程序

WIFI模块（WIFI_control_car_15.ino）

  1. /**
  2.  
  3. * @par Copyright (C): 2010-2019, Shenzhen Yahboom Tech
  4.  
  5. * @file         Wifi control car.c
  6.  
  7. * @author       Cindy
  8.  
  9. * @version      V1.0
  10.  
  11. * @date         2019.09.11
  12.  
  13. * @brief       
  14.  
  15. * @details
  16.  
  17. * @par History  
  18.  
  19. *
  20.  
  21. */
  22.  
  23. #include <Arduino.h>
  24.  
  25. #include "Adafruit_PWMServoDriver.h"
  26.  
  27. #include "Adafruit_NeoPixel.h"       
  28.  
  29. #include "RGBLed.h"
  30.  
  31. #include "avr/pgmspace.h"
  32.  
  33. #define RGB_GREEN    0xFF0000    //定义RGB灯的颜色
  34.  
  35. #define RGB_RED   0x00FF00
  36.  
  37. #define RGB_BLUE    0x0000FF
  38.  
  39. #define RGB_YELLOW   0xFFFF00
  40.  
  41. #define RGB_PURPLE   0x00FFFF
  42.  
  43. #define RGB_WHITE   0xFFFFFF
  44.  
  45. #define RGB_CYAN   0xFF00FF
  46.  
  47. #define RGB_OFF   0x000000
  48.  
  49. const int RgbPin = 11;    //定义七彩超声波模块上面RGB灯的引脚
  50.  
  51. RGBLed mRgb(RgbPin,2);
  52.  
  53. Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
  54.  
  55. #define SERVOMIN 150     
  56.  
  57. #define SERVOMAX 600     
  58.  
  59. #define PIN 6   //定义RGB的引脚
  60.  
  61. #define MAX_LED 1 //扩展板上仅有一个同类型的板载RGB灯
  62.  
  63. Adafruit_NeoPixel strip = Adafruit_NeoPixel(MAX_LED, PIN, NEO_RGB + NEO_KHZ800);
  64.  
  65. const char enServo[] = {0, 1, 2, 3};
  66.  
  67. const unsigned char music_max[5] = {42,39,36,70,25};   //音乐歌曲的最大长度
  68.  
  69. #define run_car '1'       
  70.  
  71. #define back_car '2'     
  72.  
  73. #define left_car '3'     
  74.  
  75. #define right_car '4'   
  76.  
  77. #define spin_left_car '5'  
  78.  
  79. #define spin_right_car '6'
  80.  
  81. #define stop_car '7'     
  82.  
  83. #define H_servoL 'L'       
  84.  
  85. #define H_servoR 'R'     
  86.  
  87. #define H_servoS 'S'   
  88.  
  89. #define V_servoU 'U'
  90.  
  91. #define V_servoD 'D'
  92.  
  93. #define V_servoS 'S'
  94.  
  95. int Servo_LR = 90;
  96.  
  97. int Servo_UD = 90;
  98.  
  99. const int flag_time = 2000; //时间标记点间隔2s
  100.  
  101. int newtime = 0;            //记录系统当前的时间
  102.  
  103. int lasttime = 0;           //记录系统上一次的时间点
  104.  
  105. int g_num = 0;
  106.  
  107. int buzzer = 10;            //定义蜂鸣器的引脚
  108.  
  109. int CarSpeedControl = 80;   //set speed of car
  110.  
  111. int SingPin = 12;         
  112.  
  113. int distance = 0;
  114.  
  115. int red, green, blue;
  116.  
  117. int initial_motor_speed = 100;
  118.  
  119. int sensor[3];
  120.  
  121. int time = 40000;
  122.  
  123. int count = 10;
  124.  
  125. /*小车运动状态枚举*/
  126.  
  127. const typedef enum {
  128.  
  129.   enRUN = 1,
  130.  
  131.   enBACK,
  132.  
  133.   enLEFT,
  134.  
  135.   enRIGHT,
  136.  
  137.   enSPINLEFT,
  138.  
  139.   enSPINRIGHT,
  140.  
  141.   enSTOP
  142.  
  143. } enCarState;
  144.  
  145. /*舵机状态枚举*/
  146.  
  147. const typedef enum {
  148.  
  149.   enHServoL = 1,
  150.  
  151.   enHServoR,
  152.  
  153.   enHServoS
  154.  
  155. } enHServoState;
  156.  
  157. int IncomingByte = 0;            //接收到的数据字节
  158.  
  159. String InputString = "";         //用来存储接收到的数据
  160.  
  161. boolean NewLineReceived = false; //上一次数据结束的标志
  162.  
  163. boolean StartBit   = false;       //协议开始标志
  164.  
  165. String ReturnTemp = "";          //用来存储返回值
  166.  
  167. static int g_CarState = enSTOP;         //1前进 2后退 3左转 4 右转 0停止
  168.  
  169. static int g_HServoState = enHServoS; //1:左转 2:右转 3:停止
  170.  
  171. int g_modeSelect = 0;   //0:默认的状态
  172.  
  173. int g_modeMusic = 0; //0:默认的状态
  174.  
  175. int g_musicSelect = 1;
  176.  
  177. int g_modeCar = 0;
  178.  
  179. boolean g_motor = false;
  180.  
  181. //Music
  182.  
  183. enum enMusic
  184.  
  185.   {
  186.  
  187.     enStar=1,
  188.  
  189.     Bingo=2,
  190.  
  191.     MerryChristmas=3,
  192.  
  193.     Ode=4,
  194.  
  195.     Birthday=5
  196.  
  197.   };
  198.  
  199. #define G5 392
  200.  
  201. #define A6 440
  202.  
  203. #define B7 494
  204.  
  205. #define c1 525
  206.  
  207. #define d2 587
  208.  
  209. #define e3 659
  210.  
  211. #define f4 698
  212.  
  213. #define g5 784
  214.  
  215. #define a6 880
  216.  
  217. #define b7 988
  218.  
  219. #define C1 1047
  220.  
  221. #define D2 1175
  222.  
  223. #define E3 1319
  224.  
  225. #define F4 1397
  226.  
  227. #define GG5 1568
  228.  
  229. #define AA6 1769
  230.  
  231. #define g4 392
  232.  
  233. #define c5 523
  234.  
  235. #define a4 440
  236.  
  237. #define d5 587
  238.  
  239. #define e5 659
  240.  
  241. #define b4 494
  242.  
  243. #define c6 1047
  244.  
  245. #define d6 1175
  246.  
  247. #define b5 988
  248.  
  249. #define a5 880
  250.  
  251. #define g5 784
  252.  
  253. #define e6 1319
  254.  
  255. #define f6 1397
  256.  
  257. #define a5 880
  258.  
  259. #define f5 698
  260.  
  261. const PROGMEM   int ODe[70][2]   //歌曲--欢乐颂
  262.  
  263. {
  264.  
  265.   {e3,2},{e3,2},{f4,2},{g5,2},{g5,2},{f4,2},{e3,2},{d2,2},{c1,2},{c1,2},{d2,2},{e3,2},{e3,3},{d2,1},{d2,4},
  266.  
  267.   {e3,2},{e3,2},{f4,2},{g5,2},{g5,2},{f4,2},{e3,2},{d2,2},{c1,2},{c1,2},{d2,2},{e3,2},{d2,3},{c1,1},{c1,4},
  268.  
  269.   {d2,2},{d2,2},{e3,2},{c1,2},{d2,2},{e3,1},{f4,1},{e3,2},{c1,2},
  270.  
  271.   {d2,2},{e3,1},{f4,1},{e3,2},{d2,2},{c1,2},{d2,2},{G5,2},
  272.  
  273.   {e3,2},{e3,2},{f4,2},{g5,2},{g5,2},{f4,2},{e3,2},{d2,2},{c1,2},{c1,2},{d2,2},{e3,2},{d2,3},{c1,1},{c1,4},
  274.  
  275. };
  276.  
  277. const PROGMEM   int BIrthday[25][2] //歌曲--生日快乐
  278.  
  279. {
  280.  
  281.   {G5,2},{A6,2},{G5,2},{c1,2},{B7,4},
  282.  
  283.   {G5,2},{A6,2},{G5,2},{d2,2},{c1,4},
  284.  
  285.   {G5,2},{g5,2},{e3,2},{c1,2},{B7,2},{A6,2},
  286.  
  287.   {f4,2},{e3,2},{c1,2},{d2,2},{c1,2}
  288.  
  289. };
  290.  
  291. const PROGMEM   int STar[42][2] //歌曲--小星星
  292.  
  293. {
  294.  
  295.   {c1,2},{c1,2},{g5,2},{g5,2},{a6,2},{a6,2},{g5,4},
  296.  
  297.   {f4,2},{f4,2},{e3,2},{e3,2},{d2,2},{d2,2},{c1,4},
  298.  
  299.   {g5,2},{g5,2},{f4,2},{f4,2},{e3,2},{e3,2},{d2,4},
  300.  
  301.   {g5,2},{g5,2},{f4,2},{f4,2},{e3,2},{e3,2},{d2,4},
  302.  
  303.   {c1,2},{c1,2},{g5,2},{g5,2},{a6,2},{a6,2},{g5,4},
  304.  
  305.   {f4,2},{f4,2},{e3,2},{e3,2},{d2,2},{d2,2},{c1,4},
  306.  
  307. };
  308.  
  309. const PROGMEM   int MErryChristmas[36][2]   //歌曲--圣诞快乐
  310.  
  311. {
  312.  
  313.   {g5,1},{g5,1},{c6,2},{c6,1},{d6,1},{c6,1},{b5,1},{a5,2},{a5,2},{0,2},
  314.  
  315.   {a5,1},{a5,1},{d6,2},{d6,1},{e6,1},{d6,1},{c6,1},{b5,2},{g5,2},{0,2},
  316.  
  317.   {g5,1},{g5,1},{e6,2},{e6,1},{f6,1},{e6,1},{d6,1},{c6,2},{a5,2},{0,2},
  318.  
  319.   {g5,1},{g5,1},{a5,1},{d6,1},{b5,1},{c6,2}
  320.  
  321. };
  322.  
  323. const PROGMEM   int BIngo[39][2]   //歌曲--宾果
  324.  
  325. {
  326.  
  327.   {g4,1},{c5,1},{c5,1},{c5,1},{g4,1},{a4,1},{a4,1},{g4,1},{g4,1},
  328.  
  329.   {c5,1},{c5,1},{d5,1},{d5,1},{e5,2},{c5,1},{0,1},
  330.  
  331.   {e5,2},{e5,2},{f5,1},{f5,1},{f5,2},{d5,2},{d5,2},{e5,1},{e5,1},{e5,2},
  332.  
  333.   {c5,2},{c5,2},{d5,1},{d5,1},{d5,1},{c5,1},{b4,1},{g4,1},{a4,1},{b4,1},{c5,2},{c5,1},{c5,1}
  334.  
  335. };
  336.  
  337. int serial_putc( char c, struct __file * )
  338.  
  339. {
  340.  
  341.   Serial.write( c );
  342.  
  343.   return c;
  344.  
  345. }
  346.  
  347. void printf_begin(void)
  348.  
  349. {
  350.  
  351.   fdevopen( &serial_putc, 0 );
  352.  
  353. }
  354.  
  355. /*
  356.  
  357. * Function       Clear_All_PWM
  358.  
  359. * @author        wusicaijuan
  360.  
  361. * @date          2019.07.04
  362.  
  363. * @brief         关闭PCA9685的所有PWM
  364.  
  365. * @param[in]     void
  366.  
  367. * @param[out]    void
  368.  
  369. * @retval        void
  370.  
  371. * @par History   No
  372.  
  373. */
  374.  
  375. void Clear_All_PWM()
  376.  
  377. {
  378.  
  379.   for (int i = 0; i < 16; i++)
  380.  
  381.   {
  382.  
  383.     pwm.setPWM(i, 0, 0);
  384.  
  385.   }
  386.  
  387. }
  388.  
  389. /**
  390.  
  391. * Function       setup
  392.  
  393. * @author        Cindy
  394.  
  395. * @date          2019.09.11
  396.  
  397. * @brief         初始化设置
  398.  
  399. * @param[in]     void
  400.  
  401. * @retval        void
  402.  
  403. * @par History   no
  404.  
  405. */
  406.  
  407. void setup()
  408.  
  409. {
  410.  
  411.   Serial.begin(9600);
  412.  
  413.   printf_begin();
  414.  
  415.   strip.begin();
  416.  
  417.   strip.show();
  418.  
  419.   pwm.begin();
  420.  
  421.   pwm.setPWMFreq(60);
  422.  
  423.   Clear_All_PWM();
  424.  
  425.   Servo180(1,90); //将三个舵机都初始化至90度
  426.  
  427.   Servo180(2,90);
  428.  
  429.   Servo180(3,90);
  430.  
  431.   breathing_light(255, 40, 5);
  432.  
  433.   pinMode(buzzer, OUTPUT);
  434.  
  435.   digitalWrite(buzzer, HIGH);
  436.  
  437. }
  438.  
  439. /**
  440.  
  441. * Function       setBuzzer_Tone
  442.  
  443. * @author        Cindy
  444.  
  445. * @date          2019.09.02
  446.  
  447. * @brief         设置蜂鸣器的音调
  448.  
  449. * @param[in]     void
  450.  
  451. * @param[out]    void
  452.  
  453. * @retval        void
  454.  
  455. * @par History   no
  456.  
  457. */
  458.  
  459. void setBuzzer_Tone(uint16_t frequency, uint32_t duration)
  460.  
  461. {
  462.  
  463.   int period = 1000000L / frequency;//1000000L
  464.  
  465.     int pulse = period / 2;
  466.  
  467.  
  468.  
  469.     for (long i = 0; i < duration * 200000L; i += period)
  470.  
  471.     {
  472.  
  473.     digitalWrite(buzzer, 1);
  474.  
  475.       delayMicroseconds(pulse);
  476.  
  477.       digitalWrite(buzzer, 0);
  478.  
  479.       delayMicroseconds(pulse);
  480.  
  481.     }
  482.  
  483.     if(frequency==0)
  484.  
  485.     delay(230*duration);  
  486.  
  487.   delay(20);
  488.  
  489. }
  490.  
  491. /**
  492.  
  493. * Function       5-music
  494.  
  495. * @author        Cindy
  496.  
  497. * @date          2019.09.02
  498.  
  499. * @brief         五首歌曲
  500.  
  501. * @param[in]     void
  502.  
  503. * @param[out]    void
  504.  
  505. * @retval        void
  506.  
  507. * @par History   no
  508.  
  509. */
  510.  
  511. void birthday(int j)    //生日快乐
  512.  
  513. {
  514.  
  515.     setBuzzer_Tone(pgm_read_word_near(&BIrthday[j][0]), pgm_read_word_near(&BIrthday[j][1]));
  516.  
  517. }
  518.  
  519. void ode(int j)     //欢乐颂
  520.  
  521. {
  522.  
  523.     setBuzzer_Tone(pgm_read_word_near(&ODe[j][0]), pgm_read_word_near(&ODe[j][1]));
  524.  
  525. }
  526.  
  527. void star(int j)   //小星星
  528.  
  529. {
  530.  
  531.     setBuzzer_Tone(pgm_read_word_near(&STar[j][0]), pgm_read_word_near(&STar[j][1]));
  532.  
  533. }
  534.  
  535. void merryChristmas(int j)   //圣诞快乐
  536.  
  537. {
  538.  
  539.     setBuzzer_Tone(pgm_read_word_near(&MErryChristmas[j][0]), pgm_read_word_near(&MErryChristmas[j][1]));
  540.  
  541. }
  542.  
  543. void bingo(int j)   //宾果
  544.  
  545. {
  546.  
  547.     setBuzzer_Tone(pgm_read_word_near(&BIngo[j][0]), pgm_read_word_near(&BIngo[j][1]));
  548.  
  549. }
  550.  
  551. /**
  552.  
  553. * Function       music_Play
  554.  
  555. * @author        Cindy
  556.  
  557. * @date          2019.09.11
  558.  
  559. * @brief         播放音乐
  560.  
  561. * @param[in]     void
  562.  
  563. * @param[out]    void
  564.  
  565. * @retval        void
  566.  
  567. * @par History   no
  568.  
  569. */
  570.  
  571. void music_Play(uint8_t v_song, uint8_t index)
  572.  
  573. {
  574.  
  575.   switch(v_song)
  576.  
  577.   {
  578.  
  579.     case enStar:
  580.  
  581.     {
  582.  
  583.       star(index);
  584.  
  585.       break;
  586.  
  587.     }
  588.  
  589.     case Bingo:
  590.  
  591.     {
  592.  
  593.       bingo(index);   
  594.  
  595.       break;
  596.  
  597.     }
  598.  
  599.     case MerryChristmas:
  600.  
  601.     {
  602.  
  603.       merryChristmas(index);     
  604.  
  605.       break;
  606.  
  607.     }
  608.  
  609.     case Ode:
  610.  
  611.     {
  612.  
  613.       ode(index);
  614.  
  615.       break;
  616.  
  617.     }
  618.  
  619.     case Birthday:
  620.  
  621.     {
  622.  
  623.       birthday(index);  
  624.  
  625.       break;
  626.  
  627.     }
  628.  
  629.   }
  630.  
  631. }
  632.  
  633. /*
  634.  
  635. * Function      Servo180(num, degree)
  636.  
  637. * @author       wusicaijuan
  638.  
  639. * @date         2019.06.25
  640.  
  641. * @bried        控制180度舵机旋转
  642.  
  643. * @param[in1]   index
  644.  
  645.                     1: s1
  646.  
  647.                     2: s2
  648.  
  649.                     3: s3
  650.  
  651.                     4: s4
  652.  
  653. * @param[in2]   degree (0 <= degree <= 180)
  654.  
  655. * @retval       void
  656.  
  657. */
  658.  
  659. void Servo180(int num, int degree)
  660.  
  661. {
  662.  
  663.   long us = (degree * 1800 / 180 + 600); // 0.6 ~ 2.4
  664.  
  665.   long pwmvalue = us * 4096 / 20000;   // 50hz: 20,000 us
  666.  
  667.   pwm.setPWM(enServo[num - 1], 0, pwmvalue);
  668.  
  669. }
  670.  
  671. /**
  672.  
  673. * Function       Distance_test
  674.  
  675. * @author        Cindy
  676.  
  677. * @date          2019.09.11
  678.  
  679. * @brief         超声波测距
  680.  
  681. * @param[in]     void
  682.  
  683. * @param[out]    void
  684.  
  685. * @retval        void
  686.  
  687. * @par History   no
  688.  
  689. */
  690.  
  691. void Distance_test()
  692.  
  693. {
  694.  
  695.   pinMode(SingPin,OUTPUT);
  696.  
  697.   digitalWrite(SingPin, LOW);
  698.  
  699.   delayMicroseconds(2);
  700.  
  701.   digitalWrite(SingPin, HIGH);
  702.  
  703.   delayMicroseconds(15);
  704.  
  705.   digitalWrite(SingPin, LOW);
  706.  
  707.  
  708.  
  709.   pinMode(SingPin, INPUT);
  710.  
  711.   delayMicroseconds(50);
  712.  
  713.   distance = pulseIn(SingPin, HIGH) / 58;
  714.  
  715.   //Serial.print("distance is :");
  716.  
  717.   //Serial.print(distance);
  718.  
  719.   //Serial.print("cm");
  720.  
  721.   //Serial.println();
  722.  
  723.   //delay(1000);
  724.  
  725. }
  726.  
  727. /**
  728.  
  729. * Function       PCB_RGB(R,G,B)
  730.  
  731. * @author        wusicaijuan
  732.  
  733. * @date          2019.06.26
  734.  
  735. * @brief         控制板载的RGB
  736.  
  737. * @param[in1]    R
  738.  
  739. * @param[in2]    G
  740.  
  741. * @param[in3]    B
  742.  
  743. * @param[out]    void
  744.  
  745. * @retval        void
  746.  
  747. * @par History   
  748.  
  749. *
  750.  
  751. */
  752.  
  753. void PCB_RGB(int R, int G, int B)
  754.  
  755. {
  756.  
  757.   uint8_t i = 0;
  758.  
  759.   R = map(R, 0, 255, 0, 200);  
  760.  
  761.   G = map(G, 0, 255, 0, 200);
  762.  
  763.   B = map(B, 0, 255, 0, 200);
  764.  
  765.   uint32_t color = strip.Color(G, R, B);
  766.  
  767.   strip.setPixelColor(i, color);
  768.  
  769.   strip.show();
  770.  
  771. }
  772.  
  773. /**
  774.  
  775. * Function       Ultrasonic_RGB(R,G,B)
  776.  
  777. * @author        wusicaijuan
  778.  
  779. * @date          2019.06.26
  780.  
  781. * @brief         控制超声波模块上面的七彩灯
  782.  
  783. * @param[in1]    R
  784.  
  785. * @param[in2]    G
  786.  
  787. * @param[in3]    B
  788.  
  789. * @param[out]    void
  790.  
  791. * @retval        void
  792.  
  793. * @par History   no
  794.  
  795. */
  796.  
  797. void   Ultrasonic_RGB(int R, int G, int B)
  798.  
  799. {
  800.  
  801.   mRgb.setColor(0,G,R,B);
  802.  
  803.   mRgb.show();
  804.  
  805. }
  806.  
  807. /**
  808.  
  809. * Function       advance
  810.  
  811. * @author        wusicaijuan
  812.  
  813. * @date          2019.06.25
  814.  
  815. * @param[in]     小车前进
  816.  
  817. * @param[out]    void
  818.  
  819. * @retval        void
  820.  
  821. * @par History   no
  822.  
  823. */
  824.  
  825. void advance(int Speed)
  826.  
  827. {
  828.  
  829.   Speed = map(Speed, 0, 255, 0, 4095);
  830.  
  831.   pwm.setPWM(10, 0, Speed); //右前方车轮前进
  832.  
  833. pwm.setPWM(11, 0, 0);
  834.  
  835.   pwm.setPWM(8, 0, Speed); //右后方车轮前进
  836.  
  837.   pwm.setPWM(9, 0, 0);
  838.  
  839.   pwm.setPWM(13, 0, Speed); //左前方车轮前进
  840.  
  841.   pwm.setPWM(12, 0, 0);
  842.  
  843.   pwm.setPWM(15, 0, Speed); //左后方车轮前进
  844.  
  845.   pwm.setPWM(14, 0, 0);
  846.  
  847. }
  848.  
  849. /**
  850.  
  851. * Function       brake
  852.  
  853. * @author        wusicaijuan
  854.  
  855. * @date          2019.06.25
  856.  
  857. * @brief         小车停止
  858.  
  859. * @param[in]     void
  860.  
  861. * @param[out]    void
  862.  
  863. * @retval        void
  864.  
  865. * @par History   no
  866.  
  867. */
  868.  
  869. void brake()
  870.  
  871. {
  872.  
  873. pwm.setPWM(8, 0, 0);
  874.  
  875.   pwm.setPWM(9, 0, 0);

  1. pwm.setPWM(11, 0, 0);
  2.  
  3.   pwm.setPWM(10, 0, 0);
  4.  
  5.   pwm.setPWM(12, 0, 0);
  6.  
  7.   pwm.setPWM(13, 0, 0);
  8.  
  9.   pwm.setPWM(14, 0, 0);
  10.  
  11.   pwm.setPWM(15, 0, 0);
  12.  
  13. }
  14.  
  15. /**
  16.  
  17. * Function       left
  18.  
  19. * @author        wusicaijuan
  20.  
  21. * @date          2019.06.26
  22.  
  23. * @brief         小车左转
  24.  
  25. * @param[in]     Speed
  26.  
  27. * @param[out]    void
  28.  
  29. * @retval        void
  30.  
  31. * @par History   no
  32.  
  33. */
  34.  
  35. void left(int Speed)
  36.  
  37. {
  38.  
  39.   Speed = map(Speed, 0, 255, 0, 4095);
  40.  
  41.   pwm.setPWM(10, 0, Speed);     //右前方车轮前进
  42.  
  43.   pwm.setPWM(11, 0, 0);
  44.  
  45.   pwm.setPWM(8, 0, Speed);      //右后方车轮前进
  46.  
  47.   pwm.setPWM(9, 0, 0);     
  48.  
  49.   pwm.setPWM(13, 0, 0);         //左侧车轮停止
  50.  
  51.   pwm.setPWM(12, 0, 0);
  52.  
  53.   pwm.setPWM(15, 0, 0);
  54.  
  55.   pwm.setPWM(14, 0, 0);
  56.  
  57. }
  58.  
  59. /**
  60.  
  61. * Function       right
  62.  
  63. * @author        wusicaijuan
  64.  
  65. * @date          2019.06.26
  66.  
  67. * @brief         小车右转
  68.  
  69. * @param[in]     Speed
  70.  
  71. * @param[out]    void
  72.  
  73. * @retval        void
  74.  
  75. * @par History   no
  76.  
  77. */
  78.  
  79. void right(int Speed)
  80.  
  81. {
  82.  
  83.   Speed = map(Speed, 0, 255, 0, 4095);
  84.  
  85.   pwm.setPWM(10, 0, 0);        //右侧车轮停止
  86.  
  87.   pwm.setPWM(11, 0, 0);
  88.  
  89.   pwm.setPWM(8, 0, 0);
  90.  
  91.   pwm.setPWM(9, 0, 0);
  92.  
  93.   pwm.setPWM(13, 0, Speed);    //左前方车轮前进
  94.  
  95.   pwm.setPWM(12, 0, 0);
  96.  
  97.   pwm.setPWM(15, 0, Speed);    //左后方车轮前进
  98.  
  99.   pwm.setPWM(14, 0, 0);
  100.  
  101. }
  102.  
  103. /**
  104.  
  105. * Function       spin_left
  106.  
  107. * @author        wusicaijuan
  108.  
  109. * @date          2019.06.25
  110.  
  111. * @brief         左旋(左轮后退，右轮前进)
  112.  
  113. * @param[in]     Speed
  114.  
  115. * @param[out]    void
  116.  
  117. * @retval        void
  118.  
  119. * @par History   no
  120.  
  121. */
  122.  
  123. void spin_left(int Speed)
  124.  
  125. {
  126.  
  127.   Speed = map(Speed, 0, 255, 0, 4095);
  128.  
  129.   pwm.setPWM(10, 0, Speed);      //右前方车轮前进
  130.  
  131.   pwm.setPWM(11, 0, 0);
  132.  
  133.   pwm.setPWM(8, 0, Speed);       //右前方车轮前进
  134.  
  135.   pwm.setPWM(9, 0, 0);
  136.  
  137.   pwm.setPWM(13, 0, 0);
  138.  
  139.   pwm.setPWM(12, 0, Speed);      //左前方车轮后退
  140.  
  141.   pwm.setPWM(15, 0, 0);
  142.  
  143.   pwm.setPWM(14, 0, Speed);      //左后方车轮后退
  144.  
  145. }
  146.  
  147. /**
  148.  
  149. * Function       spin_right
  150.  
  151. * @author        wusicaijuan
  152.  
  153. * @date          2019.06.25
  154.  
  155. * @brief         右旋(左轮前进，右轮后退)
  156.  
  157. * @param[in]     Speed
  158.  
  159. * @param[out]    void
  160.  
  161. * @retval        void
  162.  
  163. * @par History   no
  164.  
  165. */
  166.  
  167. void spin_right(int Speed)
  168.  
  169. {
  170.  
  171.   Speed = map(Speed, 0, 255, 0, 4095);
  172.  
  173.   pwm.setPWM(10, 0, 0);
  174.  
  175.   pwm.setPWM(11, 0, Speed);    //右前方车轮后退
  176.  
  177.   pwm.setPWM(8, 0, 0);
  178.  
  179.   pwm.setPWM(9, 0, Speed);     //右后方车轮后退
  180.  
  181.   pwm.setPWM(13, 0, Speed);    //左前方车轮前进
  182.  
  183.   pwm.setPWM(12, 0, 0);
  184.  
  185.   pwm.setPWM(15, 0, Speed);    //左后方车轮前进
  186.  
  187.   pwm.setPWM(14, 0, 0);
  188.  
  189. }
  190.  
  191. /**
  192.  
  193. * Function       back
  194.  
  195. * @author        wusicaijuan
  196.  
  197. * @date          2019.06.25
  198.  
  199. * @brief         小车后退
  200.  
  201. * @param[in]     Speed
  202.  
  203. * @param[out]    void
  204.  
  205. * @retval        void
  206.  
  207. * @par History   No
  208.  
  209. */
  210.  
  211. void back(int Speed)
  212.  
  213. {
  214.  
  215.   Speed = map(Speed, 0, 255, 0, 4095);
  216.  
  217.   pwm.setPWM(10, 0, 0);
  218.  
  219.   pwm.setPWM(11, 0, Speed); //右前方车轮后退
  220.  
  221.   pwm.setPWM(8, 0, 0);
  222.  
  223.   pwm.setPWM(9, 0, Speed); //右后方车轮后退
  224.  
  225.   pwm.setPWM(13, 0, 0);
  226.  
  227.   pwm.setPWM(12, 0, Speed);   //左前方车轮后退
  228.  
  229.   pwm.setPWM(15, 0, 0);
  230.  
  231.   pwm.setPWM(14, 0, Speed); //左后方车轮后退
  232.  
  233. }
  234.  
  235. /**
  236.  
  237. * Function       whistle
  238.  
  239. * @author        Cindy
  240.  
  241. * @date          2019.09.11
  242.  
  243. * @brief         鸣笛
  244.  
  245. * @param[in]     void
  246.  
  247. * @param[out]    void
  248.  
  249. * @retval        void
  250.  
  251. * @par History   no
  252.  
  253. */
  254.  
  255. void whistle()
  256.  
  257. {
  258.  
  259.   for (int i = 0; i < 100; i++)
  260.  
  261.   {
  262.  
  263.     digitalWrite(buzzer, HIGH); //发出声音
  264.  
  265.     delay(3);         
  266.  
  267.     digitalWrite(buzzer, LOW);   //不发出声音
  268.  
  269.     delay(1);         
  270.  
  271.   }
  272.  
  273. }
  274.  
  275. /**
  276.  
  277. * Function       breathing_light(brightness,time,increament)
  278.  
  279. * @author        wusicaijuan
  280.  
  281. * @date          2019.06.26
  282.  
  283. * @brief         logo内嵌的蓝色RGB灯
  284.  
  285. * @param[in1]    brightness
  286.  
  287. * @param[in2]    time
  288.  
  289. * @param[in3]    increament
  290.  
  291. * @param[out]    void
  292.  
  293. * @retval        void
  294.  
  295. * @par History   no
  296.  
  297. */
  298.  
  299. void breathing_light(int brightness, int time, int increament)
  300.  
  301. {
  302.  
  303.   if (brightness < 0)
  304.  
  305.   {
  306.  
  307.     brightness = 0;
  308.  
  309.   }
  310.  
  311.   if (brightness > 255)
  312.  
  313.   {
  314.  
  315.     brightness = 255;
  316.  
  317.   }
  318.  
  319.   for (int b = 0; b < brightness; b += increament)
  320.  
  321.   {
  322.  
  323.     int newb = map(b, 0, 255, 0, 4095);
  324.  
  325.     pwm.setPWM(7, 0, newb);
  326.  
  327.     delay(time);
  328.  
  329.   }
  330.  
  331. }
  332.  
  333. /********************************************************************************************************/
  334.  
  335. /*模式3-巡线模式*/
  336.  
  337. /**
  338.  
  339. * Function       Tracking_Mode
  340.  
  341. * @author        Cindy
  342.  
  343. * @date          2019.09.11
  344.  
  345. * @brief         巡线
  346.  
  347. * @param[in1]    void
  348.  
  349. * @param[out]    void
  350.  
  351. * @retval        void
  352.  
  353. * @par History   no
  354.  
  355. */
  356.  
  357. //可根据实际情况修改程序中的参数
  358.  
  359. void Tracking_Mode()
  360.  
  361. {
  362.  
  363.   sensor[0] = analogRead(A0);
  364.  
  365.   sensor[1] = analogRead(A1);
  366.  
  367.   sensor[2] = analogRead(A2);
  368.  
  369.   if(sensor[0]>100)   //三个参数100，100，100大家可根据实际情况进行调节
  370.  
  371.   {
  372.  
  373.     sensor[0] = 1;
  374.  
  375.   }
  376.  
  377.   else
  378.  
  379.   {
  380.  
  381.     sensor[0] = 0;
  382.  
  383.   }
  384.  
  385.   if(sensor[1]>100)
  386.  
  387.   {
  388.  
  389.     sensor[1] = 1;
  390.  
  391.   }
  392.  
  393.   else{
  394.  
  395.     sensor[1] = 0;
  396.  
  397.   }
  398.  
  399.   if(sensor[2]>100)
  400.  
  401.   {
  402.  
  403.     sensor[2] = 1;
  404.  
  405.   }
  406.  
  407.   else
  408.  
  409.   {
  410.  
  411.     sensor[2] = 0;
  412.  
  413.   }
  414.  
  415.  
  416.  
  417.   if ((sensor[0] == 0) && (sensor[1] == 0) && (sensor[2] == 1))
  418.  
  419.   {
  420.  
  421.     spin_left(80);
  422.  
  423.   }
  424.  
  425.   else if ((sensor[0] == 0) && (sensor[1] == 1) && (sensor[2] == 1))
  426.  
  427.   {
  428.  
  429.     left(100);
  430.  
  431.   }
  432.  
  433.   else if ((sensor[0] == 0) && (sensor[1] == 1) && (sensor[2] == 0))
  434.  
  435.   {
  436.  
  437.     advance(70);
  438.  
  439.   }
  440.  
  441.   else if ((sensor[0] == 1) && (sensor[1] == 1) && (sensor[2] == 0))
  442.  
  443.   {
  444.  
  445.     right(100);
  446.  
  447.   }
  448.  
  449.   else if ((sensor[0] == 1) && (sensor[1] == 0) && (sensor[2] == 0))
  450.  
  451.   {
  452.  
  453.     spin_right(80);
  454.  
  455.   }
  456.  
  457.   else if ((sensor[0] == 0) && (sensor[1] == 0) && (sensor[2] == 0))
  458.  
  459.   {
  460.  
  461.     //Clear_All_PWM();//全部检测到白色,保持上一个状态
  462.  
  463.   }
  464.  
  465.   else if ((sensor[0] == 1) && (sensor[1] == 1) && (sensor[2] == 1))
  466.  
  467.   {
  468.  
  469.     //Clear_All_PWM();//全部检测到黑色,保持上一个状态
  470.  
  471.   }
  472.  
  473. }
  474.  
  475. /********************************************************************************************************/
  476.  
  477. /*模式2: 超声波避障模式*/
  478.  
  479. /**
  480.  
  481. * Function       bubble
  482.  
  483. * @author        Cindy
  484.  
  485. * @date          2019.09.11
  486.  
  487. * @brief         采用冒泡排序法。
  488.  
  489. * @param[in1]    a:超声波数组的首地址
  490.  
  491. * @param[in2]    n:超声波数组的大小
  492.  
  493. * @param[out]    void
  494.  
  495. * @retval        void
  496.  
  497. * @par History   no
  498.  
  499. */
  500.  
  501. void bubble(unsigned long *a, int n)
  502.  
  503. {
  504.  
  505.   int i, j, temp;
  506.  
  507.   for (i = 0; i < n - 1; i++)
  508.  
  509.   {
  510.  
  511.     for (j = i + 1; j < n; j++)
  512.  
  513.     {
  514.  
  515.       if (a[i] > a[j])
  516.  
  517.       {
  518.  
  519.         temp = a[i];
  520.  
  521.         a[i] = a[j];
  522.  
  523.         a[j] = temp;
  524.  
  525.       }
  526.  
  527.     }
  528.  
  529.   }
  530.  
  531.   return;
  532.  
  533. }
  534.  
  535. /**
  536.  
  537. * Function       Distance
  538.  
  539. * @author        Cindy
  540.  
  541. * @date          2019.09.11
  542.  
  543. * @brief         去掉最大值和最小值，取中间三个数据的平均值
  544.  
  545. * @param[in]     void
  546.  
  547. * @param[out]    void
  548.  
  549. * @retval        void
  550.  
  551. * @par History   No
  552.  
  553. */
  554.  
  555. void Distance()
  556.  
  557. {
  558.  
  559.   unsigned long ultrasonic[5] = {0};
  560.  
  561.   int num = 0;
  562.  
  563.   while (num < 5)
  564.  
  565.   {
  566.  
  567.     Distance_test();
  568.  
  569.     ultrasonic[num] = distance;
  570.  
  571.     //printf("L%d:%d\r\n", num, (int)distance);
  572.  
  573.     num++;
  574.  
  575.     delay(10);
  576.  
  577.   }
  578.  
  579.   num = 0;
  580.  
  581.   bubble(ultrasonic, 5);
  582.  
  583.   distance = (ultrasonic[1] + ultrasonic[2] + ultrasonic[3]) / 3;
  584.  
  585.   return;
  586.  
  587. }
  588.  
  589. enum {
  590.  
  591.   LEFT_DIRECTION,
  592.  
  593.   RIGHT_DIRECTION,
  594.  
  595.   FRONT_DIRECTION,
  596.  
  597.   ALL_CHECKED_START_ACTION
  598.  
  599. };
  600.  
  601. /**
  602.  
  603. * Function       ult_check_distance_and_action
  604.  
  605. * @author        Cindy
  606.  
  607. * @date          2019.09.11
  608.  
  609. * @brief         舵机转动检测距离
  610.  
  611. * @param[in]     void
  612.  
  613. * @param[out]    void
  614.  
  615. * @retval        void
  616.  
  617. * @par History   no
  618.  
  619. */
  620.  
  621. int ult_check_distance_and_action(uint8_t p_direction)
  622.  
  623. {
  624.  
  625.   static int LeftDistance = 0;    //LeftDistance
  626.  
  627.   static int RightDistance = 0;   //RightDistance
  628.  
  629.   static int FrontDistance = 0;   //FrontDistance
  630.  
  631.   static int cnt = 0;
  632.  
  633.   int ret = 0;
  634.  
  635.   if (0 == g_modeSelect)
  636.  
  637.   {
  638.  
  639.     cnt = 0;
  640.  
  641.     brake();
  642.  
  643.     LeftDistance = 0;
  644.  
  645.     RightDistance = 0;
  646.  
  647.     FrontDistance = 0;
  648.  
  649.     ret = -1;
  650.  
  651.     return ret;
  652.  
  653.   }
  654.  
  655.   mRgb.setColor(0,RGB_GREEN);  
  656.  
  657.   mRgb.show();
  658.  
  659.   if (LEFT_DIRECTION == p_direction)
  660.  
  661.   {
  662.  
  663.     Servo180(1, 180);     
  664.  
  665.   } else if (RIGHT_DIRECTION == p_direction)
  666.  
  667.   {
  668.  
  669.     Servo180(1, 0);     
  670.  
  671.   } else if (FRONT_DIRECTION == p_direction)
  672.  
  673.   {
  674.  
  675.     Servo180(1, 90);     
  676.  
  677.   }
  678.  
  679.   else if (ALL_CHECKED_START_ACTION == p_direction)   //舵机转动左,右,前三个方向完成测距
  680.  
  681.   {
  682.  
  683.     if (0 == cnt)
  684.  
  685.     {
  686.  
  687.       brake();
  688.  
  689.       delay(50);
  690.  
  691.     }
  692.  
  693.     cnt++;   
  694.  
  695.     if (LeftDistance < 25 && RightDistance < 25 && FrontDistance < 25)   //比较三个方向的距离
  696.  
  697.     {
  698.  
  699.       mRgb.setColor(0,RGB_PURPLE);  
  700.  
  701.       mRgb.show();
  702.  
  703.       spin_right(80);     
  704.  
  705.       delay(19);
  706.  
  707.     } else if (LeftDistance >= RightDistance)
  708.  
  709. {
  710.  
  711.       mRgb.setColor(0,RGB_BLUE);  
  712.  
  713.       mRgb.show();
  714.  
  715.       spin_left(80);     
  716.  
  717.       delay(13);
  718.  
  719.     } else if (LeftDistance < RightDistance)
  720.  
  721.     {
  722.  
  723.       mRgb.setColor(0,RGB_YELLOW);  
  724.  
  725.       mRgb.show();
  726.  
  727.       spin_right(80);   
  728.  
  729.       delay(13);
  730.  
  731.     }
  732.  
  733.     if (cnt > 50)    //此处是控制小车左旋、右旋的时间19*50/13*50
  734.  
  735.     {
  736.  
  737.       brake();
  738.  
  739.       LeftDistance = 0;
  740.  
  741.       RightDistance = 0;
  742.  
  743.       FrontDistance = 0;
  744.  
  745.       cnt = 0;
  746.  
  747.       ret = 1;
  748.  
  749.       return ret;
  750.  
  751.     }
  752.  
  753.     else
  754.  
  755.     {
  756.  
  757.       return ret;
  758.  
  759.     }
  760.  
  761.   }
  762.  
  763.     delay(20);
  764.  
  765.     cnt++;
  766.  
  767.     if (cnt > 20)   //这里是用来控制,让舵机每次转动之后延迟20ms
  768.  
  769.     {
  770.  
  771.       cnt = 0;
  772.  
  773.       Distance();
  774.  
  775.       if (LEFT_DIRECTION == p_direction)
  776.  
  777.       {
  778.  
  779.         LeftDistance = distance;
  780.  
  781.       } else if (RIGHT_DIRECTION == p_direction)
  782.  
  783.       {
  784.  
  785.         RightDistance = distance;
  786.  
  787.       } else if (FRONT_DIRECTION == p_direction)
  788.  
  789.       {
  790.  
  791.         FrontDistance = distance;
  792.  
  793.       }
  794.  
  795.       ret = 1;
  796.  
  797.     }
  798.  
  799.   return ret;
  800.  
  801. }
  802.  
  803. /**
  804.  
  805. * Function       UltrasonicAvoidServoMode
  806.  
  807. * @author        Cindy
  808.  
  809. * @date          2019.09.11
  810.  
  811. * @brief         超声波避障模式
  812.  
  813. * @param[in]     void
  814.  
  815. * @param[out]    void
  816.  
  817. * @retval        void
  818.  
  819. * @par History   no
  820.  
  821. */
  822.  
  823. void UltrasonicAvoidServoMode()
  824.  
  825. {
  826.  
  827.   static int cnt_1 = 0;
  828.  
  829.   static int distance_smaller_25 = 0;
  830.  
  831.   static int bak_distance = 0;
  832.  
  833.   int ret = 0;
  834.  
  835.   if (0 == distance_smaller_25)
  836.  
  837.   {
  838.  
  839.     Distance_test();
  840.  
  841.     bak_distance = distance;
  842.  
  843.   }
  844.  
  845.   if (bak_distance < 25)    //如果检测到的距离小于25，小车开始避障
  846.  
  847.   {
  848.  
  849.     if (0 == distance_smaller_25)
  850.  
  851.     {
  852.  
  853.       cnt_1 = 0;
  854.  
  855.       distance_smaller_25 = 1;
  856.  
  857.       brake();
  858.  
  859.       delay(50);
  860.  
  861.     }
  862.  
  863.     ret = ult_check_distance_and_action(cnt_1);
  864.  
  865.     if (-1 == ret)
  866.  
  867.     {
  868.  
  869.       distance_smaller_25 = 0;
  870.  
  871.       bak_distance = 0;
  872.  
  873.       cnt_1 = 0;
  874.  
  875.       return;
  876.  
  877.     }
  878.  
  879.     else if (1 == ret)
  880.  
  881.    {
  882.  
  883.       cnt_1 ++;
  884.  
  885.     }
  886.  
  887.     if (4 == cnt_1)
  888.  
  889.     {
  890.  
  891.       distance_smaller_25 = 0;
  892.  
  893.       bak_distance = 0;
  894.  
  895.       cnt_1 = 0;
  896.  
  897.     }
  898.  
  899.   }
  900.  
  901.   else if(bak_distance >= 25)     //如果距离大于25，小车保持前进
  902.  
  903.   {
  904.  
  905.     if (1 == distance_smaller_25)
  906.  
  907.     {
  908.  
  909.       distance_smaller_25 = 0;
  910.  
  911.     }
  912.  
  913.     bak_distance = 0;
  914.  
  915.     advance(95);
  916.  
  917.   }
  918.  
  919. }
  920.  
  921. /********************************************************************************************************/
  922.  
  923. /*模式1---七彩灯模式*/
  924.  
  925. /**
  926.  
  927. * Function       color_light
  928.  
  929. * @author        Cindy
  930.  
  931. * @date          2019.09.11
  932.  
  933. * @brief         通过舵机转动到不同的角度改变RGB的颜色
  934.  
  935. * @param[in]     pos:舵机转动的角度
  936.  
  937. * @param[out]    void
  938.  
  939. * @retval        void
  940.  
  941. * @par History   no
  942.  
  943. */
  944.  
  945. void color_light(int pos)
  946.  
  947. {
  948.  
  949.   //当舵机转动到150-180度之间，点亮白色
  950.  
  951.   if (pos > 150)
  952.  
  953.   {
  954.  
  955.     mRgb.setColor(0,RGB_WHITE);   
  956.  
  957.     mRgb.show();
  958.  
  959.   }
  960.  
  961.   //当舵机转动到125-150度之间，点亮红色
  962.  
  963.   else if (pos > 125)
  964.  
  965.   {
  966.  
  967.     mRgb.setColor(0,RGB_RED);  
  968.  
  969.     mRgb.show();
  970.  
  971.   }
  972.  
  973.   //当舵机转动到100-125度之间，点亮绿色
  974.  
  975.   else if (pos > 100)
  976.  
  977.   {
  978.  
  979.     mRgb.setColor(0,RGB_GREEN);  
  980.  
  981.     mRgb.show();
  982.  
  983.   }
  984.  
  985.   //当舵机转动到75-100度之间，点亮蓝色
  986.  
  987.   else if (pos > 75)

  1. mRgb.setColor(0,RGB_BLUE);
  2.  
  3.     mRgb.show();
  4.  
  5.   }
  6.  
  7.   //当舵机转动到50-75度之间，点亮黄色
  8.  
  9.   else if (pos > 50)
  10.  
  11.   {
  12.  
  13.     mRgb.setColor(0,RGB_YELLOW);  
  14.  
  15.     mRgb.show();
  16.  
  17.   }
  18.  
  19.   //当舵机转动到25-50度之间，点亮紫色
  20.  
  21.   else if (pos > 25)
  22.  
  23.   {
  24.  
  25.     mRgb.setColor(0,RGB_PURPLE);  
  26.  
  27.     mRgb.show();
  28.  
  29.   }
  30.  
  31.   //当舵机转动到0-25度之间，点亮青色
  32.  
  33.   else if (pos > 0)
  34.  
  35.   {
  36.  
  37.     mRgb.setColor(0,RGB_CYAN);  
  38.  
  39.     mRgb.show();
  40.  
  41.   }
  42.  
  43.   else
  44.  
  45.   {
  46.  
  47.     mRgb.setColor(0,RGB_OFF);  
  48.  
  49.     mRgb.show();
  50.  
  51.   }
  52.  
  53. }
  54.  
  55. /**
  56.  
  57. * Function       ServoColorRGBMode
  58.  
  59. * @author        wusicaijuan
  60.  
  61. * @date          2019.06.26
  62.  
  63. * @brief         七彩灯模式
  64.  
  65. * @param[in1]    brightness
  66.  
  67. * @param[in2]    time
  68.  
  69. * @param[in3]    increament
  70.  
  71. * @param[out]    void
  72.  
  73. * @retval        void
  74.  
  75. * @par History   no
  76.  
  77. */
  78.  
  79. static int pos = 0;
  80.  
  81. static int is_max_pos = 0;
  82.  
  83. void   ServoColorRGBMode()
  84.  
  85. {
  86.  
  87.   if (0 == is_max_pos)
  88.  
  89.   {
  90.  
  91.     pos += 25;
  92.  
  93.     if (pos >= 180)
  94.  
  95.     {
  96.  
  97.         is_max_pos = 1;  
  98.  
  99.     }
  100.  
  101.   } else {
  102.  
  103.     pos -= 25;
  104.  
  105.     if (pos <= 0)
  106.  
  107.     {
  108.  
  109.         is_max_pos = 0;
  110.  
  111.     }
  112.  
  113.   }
  114.  
  115.   Servo180(1, pos);
  116.  
  117.   color_light(pos);
  118.  
  119.   delay(200);
  120.  
  121. }
  122.  
  123. /**
  124.  
  125. * Function       BeepOnOffMode
  126.  
  127. * @author        Cindy
  128.  
  129. * @date          2019.09.11
  130.  
  131. * @brief         切换模式鸣笛
  132.  
  133. * @param[in]     void
  134.  
  135. * @param[out]    void
  136.  
  137. * @retval        void
  138.  
  139. * @par History   no
  140.  
  141. */
  142.  
  143. void BeepOnOffMode()
  144.  
  145. {
  146.  
  147.   for (int i = 0; i < 200; i++)
  148.  
  149.   {
  150.  
  151.     digitalWrite(buzzer, HIGH); //发出声音
  152.  
  153.     delay(3);         
  154.  
  155.     digitalWrite(buzzer, LOW);   //不发出声音
  156.  
  157.     delay(1);         
  158.  
  159.   }
  160.  
  161. }
  162.  
  163. /**
  164.  
  165. * Function       serial_data_parse
  166.  
  167. * @author        Cindy
  168.  
  169. * @date          2019.09.11
  170.  
  171. * @brief         Serial port data parsing and specify the corresponding action
  172.  
  173. * @param[in]     void
  174.  
  175. * @param[out]    void
  176.  
  177. * @retval        void
  178.  
  179. * @par History   no
  180.  
  181. */
  182.  
  183. void serial_data_parse()
  184.  
  185. {
  186.  
  187.     //Serial.println(InputString);
  188.  
  189.     //解析串口发来指令并控制舵机云台的转动
  190.  
  191.     //首先，判断是否进入了模式选择
  192.  
  193.     if (InputString.indexOf("Mode") > 0 && (InputString.length() == 9) )
  194.  
  195.     {
  196.  
  197.       if (InputString[6] == '0'&& InputString[7] == '0') //stop
  198.  
  199.       {
  200.  
  201.         Clear_All_PWM();
  202.  
  203.         g_CarState = enSTOP;
  204.  
  205.         g_modeSelect = 0;
  206.  
  207.         BeepOnOffMode();
  208.  
  209.         Servo180(1,90);
  210.  
  211.         Ultrasonic_RGB(0,0,0);
  212.  
  213.       }
  214.  
  215.       else if(InputString[6] != '0' && InputString[7] == '1')
  216.  
  217.       {
  218.  
  219.         switch (InputString[6])
  220.  
  221.         {
  222.  
  223.           //case '0': g_modeSelect = 0; Clear_All_PWM(); break;
  224.  
  225.           case '1': g_modeSelect = 1; BeepOnOffMode(); break;
  226.  
  227.           case '2': g_modeSelect = 2; BeepOnOffMode(); break;
  228.  
  229.           case '3': g_modeSelect = 3; BeepOnOffMode(); break;
  230.  
  231.           default: g_modeSelect = 0;   break;
  232.  
  233.         }
  234.  
  235.         //delay(1000);
  236.  
  237.         //BeepOnOffMode();
  238.  
  239.       }
  240.  
  241.         InputString = "";                     
  242.  
  243.         NewLineReceived = false;
  244.  
  245.         return;
  246.  
  247.     }
  248.  
  249.     if (g_modeSelect != 0)
  250.  
  251.     {
  252.  
  253.       InputString = "";                   
  254.  
  255.       NewLineReceived = false;
  256.  
  257.       return;
  258.  
  259.     }
  260.  
  261.    
  262.  
  263.     if (InputString.indexOf("Music") > 0 && (InputString.length() == 10))
  264.  
  265.     {
  266.  
  267.       //Serial.println(InputString);
  268.  
  269.       g_modeMusic = 1;   //开启音乐模式
  270.  
  271.       g_musicSelect = (InputString[8] - 0x30)*10 + (InputString[7] - 0x30);   //将字符串转化成数字
  272.  
  273.       g_num = 0;
  274.  
  275.       InputString = "";                     
  276.  
  277.       NewLineReceived = false;
  278.  
  279.       return;
  280.  
  281.     }
  282.  
  283.     //解析上位机发来的舵机云台的控制指令并执行舵机旋转
  284.  
  285.    if (InputString.indexOf("Servo") > 0 )
  286.  
  287.     {
  288.  
  289.     //$Servo,UD180# servo rotate 180
  290.  
  291.     if (InputString.indexOf("UD") > 0)   //控制垂直方向的舵机（摄像头上下转动）
  292.  
  293.     {
  294.  
  295.       int i = InputString.indexOf("UD"); //寻找以PTZ开头,#结束中间的字符
  296.  
  297.       int ii = InputString.indexOf("#", i);
  298.  
  299.       if (ii > i)
  300.  
  301.       {
  302.  
  303.         String m_skp = InputString.substring(i + 2, ii);
  304.  
  305.         int m_kp = m_skp.toInt(); //将找到的字符串变成整型
  306.  
  307.         Servo180(3, 180 - m_kp);   //让舵机转动到指定角度m_kp
  308.  
  309.       }
  310.  
  311.       InputString = ""; //清空串口数据
  312.  
  313.       NewLineReceived = false;
  314.  
  315.       return; //跳出循环
  316.  
  317.     }
  318.  
  319.     //$Servo,LRS#   舵机停止
  320.  
  321.     //$Servo,LRL#   舵机左转
  322.  
  323.     //$Servo,LRR#   舵机右转
  324.  
  325.       if (InputString.indexOf("LR") > 0)
  326.  
  327.       {
  328.  
  329.         switch (InputString[9])
  330.  
  331.         {
  332.  
  333.         case H_servoL:
  334.  
  335.           g_HServoState = enHServoL;
  336.  
  337.           break;
  338.  
  339.         case H_servoR:
  340.  
  341.           g_HServoState = enHServoR;
  342.  
  343.           break;
  344.  
  345.         case H_servoS:
  346.  
  347.           g_HServoState = enHServoS;
  348.  
  349.           break;
  350.  
  351.         }
  352.  
  353.          InputString = ""; //清除串口数据
  354.  
  355.          NewLineReceived = false;
  356.  
  357.          return;
  358.  
  359.       }
  360.  
  361.     }
  362.  
  363.   //解析上位机发来的通用协议指令,并执行相应的动作
  364.  
  365.   //如:$1,0,0,0#    小车前进
  366.  
  367.   //将数据的长度作为判断的依据
  368.  
  369.   if ((InputString.indexOf("Mode") == -1) && (InputString.indexOf("Servo") == -1) && (InputString.length() == 9))
  370.  
  371.   {
  372.  
  373.     //Light up RGB
  374.  
  375.     if (InputString[7] == '1')     
  376.  
  377.     {
  378.  
  379.        int r = random (0, 255);  
  380.  
  381.        int g = random (0, 255);  
  382.  
  383.        int b = random (0, 255);
  384.  
  385.        PCB_RGB(r,g,b);
  386.  
  387.        Ultrasonic_RGB(r,g,b);
  388.  
  389.        InputString = ""; //清除串口数据
  390.  
  391.       NewLineReceived = false;
  392.  
  393.       return;
  394.  
  395.     }
  396.  
  397.      //Make whistle
  398.  
  399.     if (InputString[5] == '1')     
  400.  
  401.     {
  402.  
  403.       whistle();   //鸣笛
  404.  
  405.     }
  406.  
  407.     //调节小车的速度
  408.  
  409.     if (InputString[3] == '1') //加速
  410.  
  411.     {
  412.  
  413.       CarSpeedControl += 20;
  414.  
  415.       if (CarSpeedControl > 150)
  416.  
  417.       {
  418.  
  419.         CarSpeedControl = 150;
  420.  
  421.       }
  422.  
  423.       InputString = ""; //清除串口数据
  424.  
  425.       NewLineReceived = false;
  426.  
  427.       return;
  428.  
  429.     }
  430.  
  431.     if (InputString[3] == '2') //减速
  432.  
  433.     {
  434.  
  435.       CarSpeedControl -= 20;
  436.  
  437.       if (CarSpeedControl < 50)
  438.  
  439.       {
  440.  
  441.         CarSpeedControl = 50;
  442.  
  443.       }
  444.  
  445.       InputString = ""; //清除串口数据
  446.  
  447.       NewLineReceived = false;
  448.  
  449.       return;
  450.  
  451.     }
  452.  
  453.     switch (InputString[1])
  454.  
  455.     {
  456.  
  457.     case run_car:
  458.  
  459.       g_CarState = enRUN;
  460.  
  461.       break;
  462.  
  463.     case back_car:
  464.  
  465.       g_CarState = enBACK;
  466.  
  467.       break;
  468.  
  469.     case left_car:
  470.  
  471.       g_CarState = enLEFT;
  472.  
  473.       break;
  474.  
  475.     case right_car:
  476.  
  477.       g_CarState = enRIGHT;
  478.  
  479.       break;
  480.  
  481.     case spin_left_car:
  482.  
  483.       g_CarState = enSPINLEFT;
  484.  
  485.       break;
  486.  
  487.     case spin_right_car:
  488.  
  489.       g_CarState = enSPINRIGHT;
  490.  
  491.       break;
  492.  
  493.     case stop_car:
  494.  
  495.       g_CarState = enSTOP;
  496.  
  497.       break;
  498.  
  499.     default:
  500.  
  501.       g_CarState = enSTOP;
  502.  
  503.       break;
  504.  
  505.     }
  506.  
  507.      InputString = "";         //清除串口数据
  508.  
  509.     NewLineReceived = false;
  510.  
  511.    
  512.  
  513.     //控制小车的运动状态
  514.  
  515.     switch (g_CarState)
  516.  
  517.     {
  518.  
  519.     case enSTOP:
  520.  
  521.       brake();
  522.  
  523.       break;
  524.  
  525.     case enRUN:
  526.  
  527.       advance(CarSpeedControl);
  528.  
  529.       break;
  530.  
  531.     case enLEFT:
  532.  
  533.       left(CarSpeedControl);
  534.  
  535.       break;
  536.  
  537.     case enRIGHT:
  538.  
  539.       right(CarSpeedControl);
  540.  
  541.       break;
  542.  
  543.     case enBACK:
  544.  
  545.       back(CarSpeedControl);
  546.  
  547.       break;
  548.  
  549.     case enSPINLEFT:
  550.  
  551.       spin_left(CarSpeedControl);
  552.  
  553.       break;
  554.  
  555.     case enSPINRIGHT:
  556.  
  557.       spin_right(CarSpeedControl);
  558.  
  559.       break;
  560.  
  561.     default:
  562.  
  563.       brake();
  564.  
  565.       break;
  566.  
  567.     }
  568.  
  569.   }
  570.  
  571.   InputString = ""; //清除串口数据
  572.  
  573.   NewLineReceived = false;
  574.  
  575.   return;
  576.  
  577. }
  578.  
  579. /**
  580.  
  581. * Function       serial_data_postback
  582.  
  583. * @author        Cindy
  584.  
  585. * @date          2019.09.11
  586.  
  587. * @brief         将采集的传感器数据通过串口传输给上位机显示
  588.  
  589. * @param[in]     void
  590.  
  591. * @retval        void
  592.  
  593. * @par History   NO
  594.  
  595. */
  596.  
  597. void serial_data_postback()
  598.  
  599. {
  600.  
  601.   /*将超声波的数据传送到APK并且显示出来 */
  602.  
  603.   //$CSB,000#
  604.  
  605.   //Ultrasonic Data
  606.  
  607.   Distance_test();
  608.  
  609.   ReturnTemp = "$CSB," ;
  610.  
  611.   ReturnTemp.concat(distance);
  612.  
  613.   ReturnTemp += "#";
  614.  
  615.   Serial.print(ReturnTemp);
  616.  
  617.   return;
  618.  
  619. }
  620.  
  621. /*
  622.  
  623. * Function       HServo_State
  624.  
  625. * @author        wusicaijuan
  626.  
  627. * @date          2019.07.04
  628.  
  629. * @brief         Control state of servo
  630.  
  631. * @param[in]     void
  632.  
  633. * @param[out]    void
  634.  
  635. * @retval        void
  636.  
  637. * @par History   no
  638.  
  639. */
  640.  
  641. void HServo_State()   //控制摄像头水平方向转动（左---右）
  642.  
  643. {
  644.  
  645.   if (g_HServoState != enHServoS)
  646.  
  647.   {
  648.  
  649.     if (g_HServoState == enHServoL)
  650.  
  651.     {
  652.  
  653.       Servo_LR++;
  654.  
  655.       if (Servo_LR > 180)
  656.  
  657.       {
  658.  
  659.         Servo_LR = 180;
  660.  
  661.       }
  662.  
  663.       Servo180(2, Servo_LR);
  664.  
  665.       delay(5);
  666.  
  667.     }
  668.  
  669.     if (g_HServoState == enHServoR)
  670.  
  671.     {
  672.  
  673.       Servo_LR--;
  674.  
  675.       if (Servo_LR < 0)
  676.  
  677.       {
  678.  
  679.         Servo_LR = 0;
  680.  
  681.       }
  682.  
  683.       Servo180(2, Servo_LR);
  684.  
  685.       delay(5);
  686.  
  687.      }
  688.  
  689.   return;
  690.  
  691.   }
  692.  
  693. }
  694.  
  695. /**
  696.  
  697. * Function       serialEvent
  698.  
  699. * @author        Cindy
  700.  
  701. * @date          2019.09.11
  702.  
  703. * @brief         
  704.  
  705. * @param[in]     void
  706.  
  707. * @param[out]    void
  708.  
  709. * @retval        void
  710.  
  711. * @par History   
  712.  
  713. */
  714.  
  715. void serialEvent()   //该函数在Arduino内部被自动调用
  716.  
  717. {
  718.  
  719.   while (Serial.available())
  720.  
  721.   {
  722.  
  723.     //一个字节一个字节地读,下一句是读到的放入字符串数组中组成一个完成的数据包
  724.  
  725.     IncomingByte = Serial.read();
  726.  
  727.     if (IncomingByte == '$')
  728.  
  729.     {
  730.  
  731.       StartBit = true;
  732.  
  733.     }
  734.  
  735.     if (StartBit == true)
  736.  
  737.     {
  738.  
  739.       InputString += (char) IncomingByte;
  740.  
  741.     }
  742.  
  743.     if (StartBit == true && IncomingByte == '#')
  744.  
  745.     {
  746.  
  747.       NewLineReceived = true;
  748.  
  749.       StartBit = false;
  750.  
  751.     }
  752.  
  753.   }
  754.  
  755. }
  756.  
  757. /**
  758.  
  759. * Function       loop
  760.  
  761. * @author        Cindy
  762.  
  763. * @date          2019.09.11
  764.  
  765. * @brief         主函数
  766.  
  767. * @param[in]     void
  768.  
  769. * @retval        void
  770.  
  771. * @par History   
  772.  
  773. */
  774.  
  775. void loop()
  776.  
  777. {
  778.  
  779.   if (NewLineReceived)
  780.  
  781.   {
  782.  
  783.     serial_data_parse();  
  784.  
  785.   }
  786.  
  787.   newtime = millis();
  788.  
  789.   if (newtime - lasttime > flag_time)
  790.  
  791.   {
  792.  
  793.     lasttime = newtime;
  794.  
  795.     InputString = "";   //清除串口数据
  796.  
  797.   }
  798.  
  799.   switch (g_modeSelect)
  800.  
  801.   {
  802.  
  803.     case 1:
  804.  
  805.       ServoColorRGBMode();   //七彩灯模式
  806.  
  807.       break;
  808.  
  809.     case 2:
  810.  
  811.       UltrasonicAvoidServoMode();//超声波避障模式
  812.  
  813.       break;
  814.  
  815.     case 3:
  816.  
  817.       Tracking_Mode();   //巡线模式
  818.  
  819.       break;
  820.  
  821.     case 0:
  822.  
  823.     default:
  824.  
  825.       break;
  826.  
  827.   }
  828.  
  829.   if( g_modeMusic == 1 )
  830.  
  831.   {
  832.  
  833.       switch (g_musicSelect)
  834.  
  835.       {
  836.  
  837.         case 11:
  838.  
  839.           music_Play(1, g_num);
  840.  
  841.           break;
  842.  
  843.         case 12:
  844.  
  845.           music_Play(2, g_num);
  846.  
  847.           break;
  848.  
  849.         case 13:
  850.  
  851.           music_Play(3, g_num);
  852.  
  853.           break;
  854.  
  855.         case 14:
  856.  
  857.           music_Play(4, g_num);
  858.  
  859.           break;
  860.  
  861.         case 15:
  862.  
  863.           music_Play(5, g_num);
  864.  
  865.           break;  
  866.  
  867.         case 0:
  868.  
  869.         default:
  870.  
  871.           g_modeMusic = 0;
  872.  
  873.           break;
  874.  
  875.       }
  876.  
  877.       g_num++;
  878.  
  879.       if(g_musicSelect != 0 && g_num >= music_max[g_musicSelect % 10 - 1])
  880.  
  881.       {
  882.  
  883.         g_num = 0;
  884.  
  885.         g_modeMusic = 2; //stop music
  886.  
  887.       }
  888.  
  889.   }
  890.  
  891.   // if (g_modeSelect == 0 && g_modeMusic == 0 && g_motor == false)   //上报超声波距离
  892.  
  893.   // {
  894.  
  895.   //   time--;
  896.  
  897.   //   if (time == 0)
  898.  
  899.   //   {
  900.  
  901.   //     count--;
  902.  
  903.   //     time = 40000;
  904.  
  905.   //     if (count == 0)
  906.  
  907.   //     {
  908.  
  909.   //       serial_data_postback();
  910.  
  911.   //       time = 40000;
  912.  
  913.   //       count = 10;
  914.  
  915.   //     }
  916.  
  917.   //   }
  918.  
  919.   // }
  920.  
  921.   HServo_State();  
  922.  
  923. }

实验现象

      程序下载完成之后，使用APK控制小车。 手机连接上WIFI摄像头模块的WIFI热点：Yahboom_WIFI，无需密码，可以直接连接。 具体步骤如下：程序下载完成之后，将WIFI 摄像头模块的接线插入扩展板上相应位置。打开小车的电源开关，可以看到WIFI摄像头模块上面红色的指示灯处于闪烁状态。下载APK：安卓用户请用浏览器扫描二维码，下载并安装APK；苹果用户请用相机扫码二维码或者进入APP Store搜索“YahboomRobot”，下载并安装该APK。

      模式选择：当模式切换成功之后，我们可以听到蜂鸣器鸣笛。如果你点击了一下选项，没有听到蜂鸣器鸣笛的话，就证明没有进入模式，请APK界面的按钮，或者再次长按APK 界面的按钮再松手，即可成功进入相应的模式。

2. 结论

      相较于其他系统,Arduino表现出编程简易、成本低、平台跨越等一系列优势,将其应用于智能小车设计具有十分重要的现实意义.文章通过阐述整体系统设计方案,对Arduino单片机智能小车硬件设计、软件设计及示例功能的实现展开探讨,旨在为促进智能小车设计的健康稳定发展提供必要借鉴。

      小车以Arduino为控制核心，用单片机产生PWM波，控制小车速度。利用灰度传感器对路面黑色轨迹进行检测，并将路面检测信号反馈给单片机。单片机对采集到的信号予以分析判断，及时控制驱动电机以调整小车转向，从而使小车能够沿着黑色轨迹自动行驶，实现小车自动循迹的目的。

以Arduino单片机为控制核心，基于超声波测距的原理,利用超声波传感器，检测小车前方障碍物的距离，然后把数据传送给单片机。当超声波检测到距离小车前方15CM有障碍物时单片机就发出指令让小车左转一定角度，然后停止行进继续探测。如果前方15CM没有障碍物则直行，否则继续左转一定角度。如此通过超声波不断的循环检测周边环境的情况进行自动避障。

      总体来说，基于Arduino的Roboduino智能小车还是有市场前景的，这是人工智能必要的产物，紧跟时代潮流。

更多详情请见：【S054】智能循迹避障小车

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/438558
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号