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

使用Arduino UNO和蓝牙模块制作智能小车_arduino蓝牙模块控制小车

作者：繁依Fanyi0 | 2024-08-22 04:37:49

赞

踩

arduino蓝牙模块控制小车

目录

概述

1 硬件结构

1.1 硬件组成

1.2 蓝牙模块介绍

1.3 控制板IO引脚定义

2 机械结构

3 固件设计

4 App设计

5 参考文献

概述

       本文主要介绍使用Arduino UNO作为主板，用于控制电机和接收蓝牙模块数据。蓝牙模块用于从手机App上接收控制信号，使用L298N作为驱动板设计一台智能小车，可通过手机上的App来控制小车的运行状态。

项目代码 git 地址：Arduino_project: 基于Arduino板卡的开源项目 (gitee.com)

1 硬件结构

1.1 硬件组成

         本系统硬件结构是以Arduino为主控板，蓝牙模块上RX和TX与Arduino上的TX和RX相连。L298N作为电源管理模块和驱动模块，分别为控制板、蓝牙模块提供电源。电池模块提供整个系统的工作电压，采用可充电的锂电池，单个电池电压为： 3.7V, 电池盒中总共装载4节锂电池。硬件列表如下。

名称功能介绍注释
Arduino UNO控制板处理蓝牙数据和控制电机
L298N驱动模块驱动四个电机：正转、反转、停止
HC-05 蓝牙模块接收/发送控信号传送App发送的信号
3.7V 锂电池系统供电4节锂电池构成供电盒

1.2 蓝牙模块介绍

       HC-08蓝牙串口通信模块是新一代的基于Bluetooth Specification V4.0 BLE 蓝牙协议的数传模块。无线工作频段为 2.4GHz ISM，调制方式是 GFSK。模块最大发射功率为4dBm，接收灵敏度-93dBm，空旷环境下和 手机可以实现 80 米超远距离通信。

        其和MCU之间通过串口通信，软件设计也简单便捷，且不需要考虑蓝牙协议栈问题，非常适合做速成产品。

蓝牙模块与MCU之间连接图：

1.3 控制板IO引脚定义

引脚功能定义如下：

控制板引脚功能介绍
AI-0连接控制板： IN-1左侧电机控制信号引脚
AI-1连接控制板： IN-2左侧电机控制信号引脚
AI-2连接控制板： IN-3右侧电机控制信号引脚
AI-3连接控制板： IN-4右侧电机控制信号引脚
RX/TX连接HC-08蓝牙模块 TX/RX

2 机械结构

       系统采用集成底盘结构，四个电机固定在最底层底板上，L298N放在最底层的顶层板上，顶层板用于支撑控制板和电池模块。其具体框架结构如下：

3 固件设计

       固件主要使用电机控制和蓝牙模块数据的发送和接收。其具体代码如下，工程采用Arduino IDE开发：

系统代码：

  1. // ATMEL ATMEGA8 & 168 / ARDUINO
  2. //
  3. //                  +-\/-+
  4. //            PC6  1|    |28  PC5 (AI 5)
  5. //      (D 0) PD0  2|    |27  PC4 (AI 4)
  6. //      (D 1) PD1  3|    |26  PC3 (AI 3)
  7. //      (D 2) PD2  4|    |25  PC2 (AI 2)
  8. // PWM+ (D 3) PD3  5|    |24  PC1 (AI 1)
  9. //      (D 4) PD4  6|    |23  PC0 (AI 0)
  10. //            VCC  7|    |22  GND
  11. //            GND  8|    |21  AREF
  12. //            PB6  9|    |20  AVCC
  13. //            PB7 10|    |19  PB5 (D 13)
  14. // PWM+ (D 5) PD5 11|    |18  PB4 (D 12)
  15. // PWM+ (D 6) PD6 12|    |17  PB3 (D 11) PWM
  16. //      (D 7) PD7 13|    |16  PB2 (D 10) PWM
  17. //      (D 8) PB0 14|    |15  PB1 (D 9)  PWM
  18. //                  +----+
  19.  
  20. #include <Arduino.h>
  21.  
  22. //电机控制接口 
  23. #define PIN_A0   (14)
  24. #define PIN_A1   (15)
  25. #define PIN_A2   (16)
  26. #define PIN_A3   (17)
  27.  
  28. static const uint8_t MA0 = PIN_A0;
  29. static const uint8_t MA1 = PIN_A1;
  30. static const uint8_t MA2 = PIN_A2;
  31. static const uint8_t MA3 = PIN_A3;
  32.  
  33. // BLUE TOOTH
  34. char command;
  35.  
  36. void setup() 
  37. {
  38.     // put your setup code here, to run once:
  39.     Serial.begin(9600);
  40.  
  41.     pinMode(MA0, OUTPUT);
  42.     pinMode(MA1, OUTPUT);
  43.     pinMode(MA2, OUTPUT);
  44.     pinMode(MA3, OUTPUT);
  45. }
  46.  
  47. void loop() 
  48. {
  49.    while(Serial.available())
  50.    {
  51.        command =Serial.read();
  52.        switch(command )
  53.        {
  54.                 case 0x18:    //前进
  55.                  digitalWrite(MA0, LOW);
  56.                  digitalWrite(MA1, HIGH);
  57.                  digitalWrite(MA2, LOW);
  58.                  digitalWrite(MA3, HIGH);
  59.  
  60.                 break;
  61.  
  62.                 case 0x52:    //后退
  63.                  digitalWrite(MA0, HIGH);
  64.                  digitalWrite(MA1, LOW);
  65.                  digitalWrite(MA2, HIGH);
  66.                  digitalWrite(MA3, LOW);
  67.  
  68.  
  69.                 break;
  70.  
  71.                 case 0x08:    // 左转
  72.                  digitalWrite(MA0, HIGH);
  73.                  digitalWrite(MA1, LOW);
  74.                  digitalWrite(MA2, LOW);
  75.                  digitalWrite(MA3, HIGH);
  76.                 break;
  77.  
  78.                 case 0x5a:     //右转
  79.                  digitalWrite(MA0, LOW);
  80.                  digitalWrite(MA1, HIGH);
  81.                  digitalWrite(MA2, HIGH);
  82.                  digitalWrite(MA3, LOW);
  83.  
  84.                 break;
  85.               case 0x45: 
  86.               default:
  87.                  digitalWrite(MA0, LOW);
  88.                  digitalWrite(MA1, LOW);
  89.                  digitalWrite(MA2, LOW);
  90.                  digitalWrite(MA3, LOW);
  91.               break;        
  92.        }
  93.    }
  94. }

4 App设计

        使用微信小程序开发App，其特点是集成在微信App内，不用单独安装，搜索到该App既可以使用。该程序主要实现4个按钮，实现小车前进、后退、左转、右转功能。

App UI:

开发工具：

核心代码如下： 

  1. const utils = require('utils.js')
  2. const ble = require('bluetooth.js')
  3. Page({
  4.     /**
  5.      * 页面的初始数据
  6.      */
  7.     data: {
  8.         pageload: false,
  9.         connected: false,
  10.         send_hex: false,
  11.         send_string: true,
  12.         send_string_val: 'Hex',
  13.         recv_string: true,
  14.         recv_string_val: 'Hex',
  15.         recv_value: '',
  16.         send_number: 0,
  17.         recv_number: 0,
  18.         recv_hex: true,
  19.         try_cnt:0,
  20.         deviceArray: []
  21.     },
  22.  
  23.  
  24.     /**
  25.      * 生命周期函数--监听页面加载
  26.      */
  27.     onLoad: function (options) {
  28.         var that = this; 
  29.  
  30.         console.log(options);
  31.         this.setData({
  32.             pageload:true,
  33.             connected: false,
  34.             deviceId: options.id,
  35.             try_cnt:0,
  36.             deviceName: options.name
  37.         });
  38.  
  39.         console.log("detail:  onLoad");
  40.         wx.stopBluetoothDevicesDiscovery({
  41.             success: function (res) {
  42.                 console.log('停止搜索设备', res)
  43.             }
  44.         })
  45.  
  46.         that.closeBLEConnection(that.data.deviceId);
  47.         that.createBLEConnection(that.data.deviceId, that.data.deviceName); 
  48.     }, 
  49.  
  50.     onHide () {
  51.         var that = this;
  52.         // Do something when hide.
  53.         // 断开连接
  54.         console.log("detail:  onHide");
  55.     },
  56.  
  57.     onShow:function()
  58.     {      
  59.         // var that = this; 
  60.         // connect bluetooth
  61.         // that.closeBLEConnection(that.data.deviceId);
  62.         // that.createBLEConnection(that.data.deviceId, that.data.deviceName); 
  63.     },
  64.  
  65.     onUnload() {
  66.         var that = this;
  67.  
  68.         this.setData({
  69.             pageload:true,
  70.             connected: false,
  71.             try_cnt:0,
  72.         });
  73.  
  74.         console.log("page:  onUnload  ");
  75.         that.offBLEMonitor();
  76.         that.closeBLEConnection(that.data.deviceId);
  77.         that.closeBluetoothAdapter();
  78.  
  79.         wx.showToast({
  80.             title: '断开蓝牙',
  81.             icon: 'success',
  82.             duration: 2000
  83.           })  
  84.     },
  85.  
  86.  
  87.     DisConnectTap:function()
  88.     {
  89.         var that = this;
  90.  
  91.         that.setData({
  92.             pageload:true,
  93.             connected: false,
  94.             try_cnt:0,
  95.         });
  96.  
  97.         ble.openBluetoothAdapter(that.data.deviceId, that.data.deviceName);
  98.         that.createBLEConnection(that.data.deviceId, that.data.deviceName); 
  99.     },
  100.  
  101.  
  102.  
  103.     RecvCleanTap: function () {
  104.         this.setData({
  105.             recv_value: '',
  106.             recv_number: 0
  107.         });
  108.     },  
  109.  
  110.     /**
  111.      * 创建连接
  112.      * @param {*} deviceId 
  113.      * @param {*} name 
  114.      */
  115.     createBLEConnection(deviceId, name) 
  116.     {
  117.         wx.createBLEConnection({
  118.             deviceId,  
  119.             success: (res) => {
  120.                 console.log('createBLEConnection - success： ', res)
  121.                 this.getBLEDeviceServices(deviceId)              
  122.             },
  123.             fail: (res) => {
  124.                 console.error('createBLEConnection - fail: ', res)
  125.                 if(res.errCode == 10006 ){
  126.                     this.createBLEConnection(deviceId, name)
  127.                 }
  128.                 else{
  129.                     ble.openBluetoothAdapter(deviceId, name)
  130.                     this.createBLEConnection(deviceId, name)
  131.                 }
  132.  
  133.                 this.setData({
  134.                     connected: false,
  135.                 })               
  136.             } 
  137.         })
  138.     },
  139.         
  140.     getBLEDeviceServices(deviceId) 
  141.     {
  142.         var that = this;
  143.         wx.getBLEDeviceServices({
  144.             deviceId,
  145.             success: (res) => 
  146.             {
  147.                 console.log('getBLEDeviceServices - success： ', res)
  148.                 for (let i = 0; i < res.services.length; i++) 
  149.                 {
  150.                     var ergodic_UUID =res.services[i].uuid;      //取出服务里面的UUID
  151.                     var UUID_slice = ergodic_UUID.slice(4, 8);   //截取4到8位
  152.  
  153.                     console.log('getBLEDeviceServices, service ID =  ', res.services[i].uuid);
  154.                     if ( res.services[i].isPrimary && (UUID_slice == "FFE0") ) 
  155.                     {
  156.                         that.setData({
  157.                             serviceId: res.services[i].uuid,
  158.                         });
  159.                         break;
  160.                     }
  161.                 }
  162.  
  163.                 wx.getConnectedBluetoothDevices({
  164.                     services: res.services,
  165.                     success: (res) => 
  166.                     {                         
  167.                       console.log("getConnectedBluetoothDevices - success:  " +  res)
  168.                     },
  169.                     fail: (res) => {
  170.                         console.error('getConnectedBluetoothDevices - fail: ', res)
  171.                         ble.openBluetoothAdapter(deviceId, that.data.deviceName)
  172.                     }                    
  173.                 })
  174.  
  175.                 that.getBLEDeviceCharacteristics(deviceId, that.data.serviceId);
  176.             },
  177.             fail: (res) => {
  178.                 console.error('getBLEDeviceServices - fail: ', res)
  179.                 // try it again
  180.                 ble.openBluetoothAdapter(deviceId, that.data.deviceName)
  181.                 that.monitor_connected();
  182.             } 
  183.         });
  184.     },
  185.  
  186.    getBLEDeviceCharacteristics(deviceId, serviceId) 
  187.    {
  188.         var that = this;
  189.         let falg = false;
  190.  
  191.         wx.getBLEDeviceCharacteristics({
  192.             deviceId,
  193.             serviceId,
  194.             success: (res) => 
  195.             {
  196.                 that.setData({
  197.                     connected: true,
  198.                 })                
  199.                 console.log('getBLEDeviceCharacteristics success', res.characteristics)
  200.                 for (let i = 0; i < res.characteristics.length; i++) 
  201.                 {
  202.                     let item = res.characteristics[i]
  203.                      
  204.                     console.log('getBLEDeviceCharacteristics, Characteristics ID =  ', item.uuid)
  205.                     // 该特征值：可读
  206.                     if (item.properties.read) 
  207.                     {
  208.                         wx.readBLECharacteristicValue({
  209.                             deviceId,
  210.                             serviceId,
  211.                             characteristicId: item.uuid,
  212.                         })
  213.                     }
  214.  
  215.                     // 该特征值：可写
  216.                     if (item.properties.write) 
  217.                     {
  218.                         this.setData({
  219.                             canWrite: true
  220.                         })
  221.                         this._deviceId = deviceId
  222.                         this._serviceId = serviceId
  223.                         this._characteristicId = item.uuid
  224.                         this.writeValue()
  225.                     }
  226.  
  227.                     if (item.properties.notify || item.properties.indicate) 
  228.                     {
  229.                         that.setData({
  230.                             characteristicId: item.uuid
  231.                         });
  232.                         falg = true;
  233.                         break;
  234.                     }
  235.                 }
  236.  
  237.                 
  238.                 if( falg )
  239.                 {
  240.                     console.debug('getBLEDeviceCharacteristics - deviceId : ', deviceId)
  241.                     console.debug('getBLEDeviceCharacteristics - serviceId : ', serviceId)
  242.                     console.debug('getBLEDeviceCharacteristics - characteristicId: ', that.data.characteristicId)
  243.  
  244.                     // read device character value 
  245.                     that.readBLECharacteristicValue(deviceId, serviceId, that.data.characteristicId)   
  246.                     that.notifyBLECharacteristicValueChange(deviceId, serviceId, that.data.characteristicId) 
  247.                 }
  248.             },
  249.             fail: (res) => {
  250.                 console.error('getBLEDeviceCharacteristics -- fail: ', res)
  251.                 this.setData({
  252.                     connected: false,
  253.                 })
  254.  
  255.                 if (res.errCode === 10006)
  256.                 {
  257.                     that.offBLEMonitor();
  258.                     that.createBLEConnection(deviceId, that.data.deviceName); 
  259.                 }
  260.             }
  261.         })
  262.  
  263.    },
  264.  
  265.    readBLECharacteristicValue(deviceId,serviceId, characteristicId )
  266.    {
  267.         wx.readBLECharacteristicValue({
  268.                 // 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
  269.                 deviceId,
  270.                 // 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
  271.                 serviceId,
  272.                 // 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
  273.                 characteristicId,
  274.                 success (res) {
  275.                     console.log('readBLECharacteristicValue:', res.errCode)
  276.                 }
  277.          })
  278.    },
  279.  
  280.    notifyBLECharacteristicValueChange(deviceId,serviceId, characteristicId )
  281.    {
  282.         var that = this;
  283.  
  284.         wx.notifyBLECharacteristicValueChange({
  285.             state: true,    // enable notify
  286.             deviceId,
  287.             serviceId,
  288.             characteristicId,
  289.  
  290.             success: (res) => {
  291.                 console.info('notifyBLECharacteristicValueChange success: ', res.errMsg)
  292.  
  293.                 // read data here 
  294.                 // 操作之前先监听，保证第一时间获取数据
  295.                 wx.onBLECharacteristicValueChange(function(res) 
  296.                 {
  297.                     that.data.connected = true; 
  298.                     console.info('onBLECharacteristicValueChange', res);
  299.                     console.info(`characteristic ${res.characteristicId} has changed, now is ${res.value}`);
  300.  
  301.                     var result = res.value;
  302.                     var hex = utils.buf2hex(result);
  303.                     var _hex_ss =  utils.hex2string(hex);
  304.  
  305.                     console.info("hex: " + hex);
  306.                     console.info("string: " + _hex_ss);
  307.  
  308.                     var recv_number_1 = that.data.recv_number + _hex_ss.length / 2;
  309.                     var recv_number = Math.round(recv_number_1);
  310.  
  311.                     that.setData({
  312.                         recv_number: recv_number,
  313.                         recv_value: that.data.recv_value + _hex_ss,
  314.                     });
  315.  
  316.                     let _ss = that.data.recv_value
  317.                     if( _ss.includes("TM(C):") && _ss.includes("HM:") && _ss.includes("\n"))
  318.                     {
  319.                         let buff =  _ss.split(' ')
  320.                         console.log( _ss )
  321.                         console.log(buff)
  322.                         that.data.recv_value = "";
  323.                         that.data.recv_number = 0;
  324.  
  325.                         that.setData({
  326.                             temphtValue: buff[2],
  327.                             humidityValue: buff[4],
  328.                         });
  329.                         
  330.                     }      
  331.                     that.monitor_connected();
  332.                 })                                 
  333.             },
  334.  
  335.             fail: (res) => {
  336.                 console.error('notifyBLECharacteristicValueChange fail: ', res)
  337.                 that.monitor_connected();
  338.             }
  339.         })    
  340.    },
  341.  
  342.    monitor_connected_action()
  343.    {
  344.         var that = this;
  345.  
  346.  
  347.         let deviceId = that.data.deviceId;
  348.  
  349.         wx.onBLEConnectionStateChange(function(res) {
  350.             // 该方法回调中可以用于处理连接意外断开等异常情况
  351.             console.log( "onBLEConnectionStateChange ----- " +  `device ${res.deviceId} state has changed, connected: ${res.connected}`)
  352.             if( res.deviceId == deviceId && res.connected == false )
  353.             {    
  354.                 wx.closeBLEConnection({
  355.                     deviceId,
  356.                     success: (res) => {
  357.                         console.debug('detail: closeBLEConnection success', res);  
  358.                         that.offBLEMonitor();
  359.                         that.createBLEConnection(deviceId, that.data.deviceName); 
  360.                     },
  361.                     fail: (res) => {                     
  362.                         console.error('detail: closeBLEConnection fail', res);  
  363.                         if (res.errCode === 10006) {
  364.                             that.offBLEMonitor();
  365.                             that.createBLEConnection(deviceId, that.data.deviceName); 
  366.                         }
  367.                     }
  368.                 })
  369.  
  370.                 that.setData({
  371.                     try_cnt: that.data.try_cnt + 1,
  372.                 })
  373.             }
  374.             else{
  375.                 that.data.try_cnt  = 0;
  376.             }
  377.         })   
  378.    },
  379.  
  380.    monitor_connected()
  381.    {
  382.         var that = this;
  383.  
  384.         setTimeout(that.monitor_connected_action, 200);
  385.    },
  386.  
  387.     writeValue( val ) 
  388.     {
  389.         // 向蓝牙设备发送一个0x00的16进制数据
  390.         let buffer = new ArrayBuffer(1);
  391.         let dataView = new DataView(buffer);
  392.  
  393.         dataView.setUint8(0, val);
  394.  
  395.         console.debug('getBLEDeviceCharacteristics - deviceId : ', this._deviceId)
  396.         console.debug('getBLEDeviceCharacteristics - serviceId : ', this._serviceId)
  397.         console.debug('getBLEDeviceCharacteristics - characteristicId: ', this._characteristicId)
  398.  
  399.         wx.writeBLECharacteristicValue({
  400.             deviceId: this._deviceId,
  401.             serviceId: this._serviceId,
  402.             characteristicId: this._characteristicId,
  403.             value: buffer,
  404.             success: (res) => {
  405.                 console.debug('writeBLECharacteristicValue success', res);  
  406.             },
  407.             fail: (res) => {
  408.                 console.error(' writeBLECharacteristicValue fail', res);  
  409.                 this.setData({
  410.                     connected: false,
  411.                 }) 
  412.             }
  413.         })
  414.     },
  415.  
  416.     closeBluetoothAdapter() 
  417.     {
  418.         wx.closeBluetoothAdapter({           
  419.             success (res) {
  420.               console.log(res)
  421.             }        
  422.         })
  423.  
  424.         this.setData({
  425.             connected: false,
  426.         }),         
  427.         this._discoveryStarted = false
  428.     },
  429.  
  430.     closeBLEConnection( deviceId ) 
  431.     {
  432.         wx.closeBLEConnection({
  433.             deviceId,
  434.             success: (res) => {
  435.                 console.debug('detail: closeBLEConnection success', res);  
  436.             },
  437.             fail: (res) => {
  438.                 console.error('detail: closeBLEConnection fail', res);  
  439.             }
  440.         })
  441.  
  442.         this.setData({
  443.             connected: false,
  444.             canWrite: false,
  445.         })
  446.     },
  447.  
  448.     run_up:function()
  449.     {
  450.     	var that = this;
  451.  
  452.         var val = 0x18 ;      
  453.         that.writeValue( val );   
  454.     }, 
  455.     
  456.     run_down:function()
  457.     {
  458.     	var that = this;
  459.  
  460.         var val = 0x52;      
  461.         that.writeValue( val );   
  462.     },
  463.  
  464.     run_left:function()
  465.     {
  466.     	var that = this;
  467.  
  468.         var val = 0x08;      
  469.         that.writeValue( val );   
  470.  
  471.     },
  472.  
  473.     run_right:function()
  474.     {
  475.     	var that = this;
  476.  
  477.         var val = 0x5a;      
  478.         that.writeValue( val );   
  479.     },
  480.  
  481.     whiteLightValueSliderChange:function(e)
  482.     {
  483.         var that = this;
  484.         // 向蓝牙设备发送一个0x00的16进制数据
  485.         var val = Math.random() * 255 | 0;      
  486.         that.writeValue( val );   
  487.     },
  488.  
  489.     offBLEMonitor(){
  490.         this.setData({
  491.             connected: false,
  492.         }), 
  493.         wx.offBLEPeripheralConnectionStateChanged();
  494.         wx.offBLEConnectionStateChange();
  495.         wx.offBLECharacteristicValueChange();
  496.         wx.offBLEMTUChange();
  497.     }
  498. })

5 参考文献

1）使用Arduino UNO硬件平台制作智能小车-CSDN博客

2）汇承HC-08蓝牙串口模块使用规格书(含指令集）.pdf

3）概览 | 微信开放文档 (qq.com)

4）Arduino 实验室 – Arduino中文站，提供丰富的Arduino教程和DIY资讯 (nxez.com)

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

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

  

闽ICP备14008679号