４輪駆動車のプログラム集

19．BLEリモコン（本体側）

3つのUUIDの頭8桁をリモコン側と共通の自分固有のコードにしておきましょう。
1つめはSERVICE_UUID、2つめは送信用(TX)、3つめは受信用(RX)のUUID。リモコン（No.18）とはRXとTXが逆なので注意。

  

    // === ESP32 BLE Client sample skech ===
    #include <Arduino.h>
    #include <BLEDevice.h>
    #include <ESP32Servo.h>
    #include <Ticker.h>
    Ticker ticker;
    Servo myServo;
    // See the following for generating UUIDs:
    // https://www.uuidgenerator.net/
    
    // 3つのUUIDを下に書き込む。hatumei1を自分の好きな（リモコンと同じ）8文字に変えてください。
    #define SERVICE_UUID "hatumei1-23f3-4fd7-9271-96aee32da1a3"
    #define CHARACTERISTIC_UUID_TX "hatumei1-ce72-452f-af50-67cb23484128"
    #define CHARACTERISTIC_UUID_RX "hatumei1-7116-4d54-b676-b81a86e3f407"
    #define SERVER_NAME "esp32ble"
    #define Tx_value '1' // send to Server "1"
    // Board Using pin
    #define builtinLED 2         // Onboard Blue LED LEDC_BASE_FREQ, LEDC_TIMER_BIT
    #define SERVO_PIN 13         // Servo Orange Wire
    #define LEDR 27              // Red LED
    #define LEDG 17              // Green LED
    #define LEDB 16              // Blue LED
    #define in1 25               // PWM pin
    #define in2 26               // PWM pin
    #define in3 32               // PWM pin
    #define in4 33               // PWM pin
    #define LEDC_CHANNEL_1 3     // Channel 3
    #define LEDC_CHANNEL_2 4     // Channel 4
    #define LEDC_CHANNEL_3 5     // Channel 5
    #define LEDC_CHANNEL_4 6     // Channel 6
    #define LEDC_BASE_FREQ 100.0 // キャリア周波数設定 100Hz
    #define LEDC_TIMER_BIT 8     // 分解能8bit（0-255）
    
    int Rx_flag = 0;     // received flag
    int xAxis = 512;     // Joystick X-Nutral Value
    int yAxis = 512;     // Joystick Y-Nutral Value
    int speedLeft = 255; // 反転回路があるので255が最弱、0が最強である
    int speedRight = 255;
    int stop_speed = 255;           // DC Motor Stop Value
    int lowest_speed_bitL = 140;     // DC Motor lowest rotation Value
    int lowest_speed_bitR = 160;     // DC Motor lowest rotation Value
    int data0, data1, data2, data3; // Recieve data 0-3
    
    unsigned long previoustime0 = 0;
    unsigned long previoustime1 = 0;
    unsigned long previoustime2 = 0;
    
    static BLEUUID serviceUUID(SERVICE_UUID);
    static BLEUUID charUUID_RX(CHARACTERISTIC_UUID_RX);
    static BLEUUID charUUID_TX(CHARACTERISTIC_UUID_TX);
    static BLEAddress *pServerAddress;
    static boolean doConnect = false;
    static boolean connected = false;
    static BLERemoteCharacteristic *pRemoteCharacteristicRX;
    static BLERemoteCharacteristic *pRemoteCharacteristicTX;
    
    static void notifyCallback(
        BLERemoteCharacteristic *pBLERemoteCharacteristic,
        uint8_t *pData,
        size_t length,
        bool isNotify)
    {
      Serial.print("Notify callback for characteristic ");
      Serial.print(pBLERemoteCharacteristic->getUUID().toString().c_str());
      Serial.print(" of data length ");
      Serial.println(length);
      Serial.print("data: ");
      Serial.println((char *)pData);
    }
    class MyClientCallback : public BLEClientCallbacks
    {
      void onConnect(BLEClient *pclient)
      {
      }
      void onDisconnect(BLEClient *pclient)
      {
        connected = false;
        Serial.println("onDisconnect");
      }
    };
    bool connectToServer(BLEAddress pAddress)
    {
      Serial.print("Forming a connection to ");
      Serial.println(pAddress.toString().c_str());
      BLEClient *pClient = BLEDevice::createClient();
      Serial.println(" - Created client");
      pClient->setClientCallbacks(new MyClientCallback());
      // Connect to the remove BLE Server
      pClient->connect(pAddress);
      Serial.println(" - Connected to server");
      pClient->setMTU(517); // set client to request maximum MTU from server
    
      BLERemoteService *pRemoteService = pClient->getService(serviceUUID);
      Serial.print(" - Connected to server :");
      Serial.println(serviceUUID.toString().c_str());
      if (pRemoteService == nullptr)
      {
        Serial.print("Failed to find our service UUID: ");
        Serial.println(serviceUUID.toString().c_str());
        pClient->disconnect();
        return false;
      }
      // Get the reference of the characteristic for Receive
      pRemoteCharacteristicRX = pRemoteService->getCharacteristic(charUUID_RX);
      if (pRemoteCharacteristicRX == nullptr)
      {
        Serial.print("Failed to find characteristic RX ID: ");
        Serial.println(charUUID_RX.toString().c_str());
        pClient->disconnect();
        return false;
      }
      Serial.print(" - Found characteristic RX ID: ");
      Serial.println(charUUID_RX.toString().c_str());
      // Get the reference of the characteristic for Send
      pRemoteCharacteristicTX = pRemoteService->getCharacteristic(charUUID_TX);
      if (pRemoteCharacteristicTX == nullptr)
      {
        Serial.print("Failed to find characteristic TX ID ");
        Serial.println(charUUID_TX.toString().c_str());
        pClient->disconnect();
        return false;
      }
      Serial.print(" - Found characteristic TX ID: ");
      Serial.println(charUUID_TX.toString().c_str());
      // Read the value of the characteristic
      if (pRemoteCharacteristicRX->canRead())
      {
        std::string value = pRemoteCharacteristicRX->readValue();
        Serial.print("The characteristic value was: ");
        Serial.println(value.c_str());
      }
      if (pRemoteCharacteristicRX->canNotify())
        // pRemoteCharacteristicRX->registerForNotify(notifyCallback);
        // Serial.println("End of notify");
        return true;
    }
    
    class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks
    {
      void onResult(BLEAdvertisedDevice advertisedDevice)
      {
        Serial.print("BLE Advertised Device found: ");
        Serial.println(advertisedDevice.toString().c_str());
        Serial.println(advertisedDevice.getName().c_str());
        if (advertisedDevice.getName() == SERVER_NAME)
        {
          Serial.println(advertisedDevice.getAddress().toString().c_str());
          advertisedDevice.getScan()->stop();
          pServerAddress = new BLEAddress(advertisedDevice.getAddress());
          doConnect = true;
        }
      }
    };
    void get_scan()
    {
      BLEScan *pBLEScan = BLEDevice::getScan();
      Serial.println("getScan");
      pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
      Serial.println("setAdvertisedDeviceCallbacks");
      pBLEScan->setActiveScan(true);
      pBLEScan->start(5);
      Serial.println("");
      Serial.println("End of scan");
    }
    // LEDC Setup Attach Channel
    void ledc_attach_channel()
    {
      ledcSetup(LEDC_CHANNEL_1, LEDC_BASE_FREQ, LEDC_TIMER_BIT);
      ledcSetup(LEDC_CHANNEL_2, LEDC_BASE_FREQ, LEDC_TIMER_BIT);
      ledcSetup(LEDC_CHANNEL_3, LEDC_BASE_FREQ, LEDC_TIMER_BIT);
      ledcSetup(LEDC_CHANNEL_4, LEDC_BASE_FREQ, LEDC_TIMER_BIT);
      ledcAttachPin(in1, LEDC_CHANNEL_1);
      ledcAttachPin(in2, LEDC_CHANNEL_2);
      ledcAttachPin(in3, LEDC_CHANNEL_3);
      ledcAttachPin(in4, LEDC_CHANNEL_4);
    }
    void ledBlink()
    {
      volatile static int led = HIGH;
      digitalWrite(builtinLED, led);
      led = !led;
    }
    void setup()
    {
      Serial.begin(115200);
      pinMode(LEDR, OUTPUT);
      pinMode(LEDG, OUTPUT);
      pinMode(LEDB, OUTPUT);
      pinMode(builtinLED, OUTPUT);
      Serial.println("BLE_Cliant_start");
      BLEDevice::init("");
      get_scan();
      Serial.println("BLE End of setup");
      ticker.attach(0.1, ledBlink);
      myServo.attach(SERVO_PIN);
      ledc_attach_channel();
      delay(500);
    }
    void loop()
    {
      unsigned long currenttime = millis();
      if (doConnect == true)
      {
        if (connectToServer(*pServerAddress))
        {
          Serial.println("We are now connected to the BLE Server.");
          connected = true;
        }
        else
        {
          Serial.println("We have failed to connect to the server; there is nothin more we will do.");
          connected = false;
        }
        doConnect = false;
      }
      if (connected)
      {
        // Connection Handling
        ticker.detach();
        digitalWrite(builtinLED, HIGH);
        // Receive data read
        std::string Rxvalue = pRemoteCharacteristicRX->readValue();
        String Rxdata = Rxvalue.c_str(); // copy str(value)
        String str(Rxdata);
        String subf = str.substring(2, 3);   // Flag
        String subx = str.substring(6, 9);   // potX data
        String suby = str.substring(12, 15); // potY data
        String subk = str.substring(18, 19); // buttonK data
        // Convert int flag xyAxis and buttonK
        data0 = subf.toInt(); // receive flag
        data1 = subx.toInt(); // joystick X value
        data2 = suby.toInt(); // joystick Y value
        data3 = subk.toInt(); // joystick button
        // Serial Monitor Received Data
        char buffer[20];
        // sprintf(buffer, "F:%d X:%03d Y:%03d K:%d", data0, data1, data2, data3);
        // Serial.println(buffer);
        // to Server Send data
        pRemoteCharacteristicTX->writeValue(Tx_value);
        // Serial.println(Tx_value);
        // delay(1000);
      }
      else
      {
        digitalWrite(builtinLED, LOW);
        ticker.attach(0.1, ledBlink);
        // reconnecting
        Serial.println("Not connected");
        doConnect = false;
        get_scan();
      }
      // Connected Receive Flag
      if (data0 == 1)
      {
        // Pot data Numeric Replace
        xAxis = map(data1, 0, 255, 0, 1023);
        yAxis = map(data2, 0, 255, 0, 1023);
        // Forward
        if (yAxis > 660)
        {
          speedLeft = map(yAxis, 510, 1023, lowest_speed_bitL, 0);
          speedRight = map(yAxis, 510, 1023, lowest_speed_bitR, 0);
          // Left turn
          if (xAxis < 360)
          {
            // int xMapped = map(xAxis, 0, 510, 255, 0);
            speedLeft = lowest_speed_bitL;
            if (speedRight < 0)
            {
              speedRight = 0;
            }
            if (speedLeft > 100)
            {
              speedLeft = 100;
            }
          }
          // Right turn
          else if (xAxis > 660)
          {
            // int xMapped = map(xAxis, 510, 1023, 0, 255);
            speedRight = lowest_speed_bitR;
          }
          ledcWrite(LEDC_CHANNEL_1, speedLeft);
          ledcWrite(LEDC_CHANNEL_2, stop_speed);
          ledcWrite(LEDC_CHANNEL_3, speedRight);
          ledcWrite(LEDC_CHANNEL_4, stop_speed);
        }
        // Backward
        if (yAxis < 360)
        {
          speedLeft = map(yAxis, 510, 0, lowest_speed_bitL, 0);
          speedRight = map(yAxis, 510, 0, lowest_speed_bitR, 0);
            // Left turn (back)
            if (xAxis < 360)
            {
            // int xMapped = map(xAxis, 0, 510, 255, 0);
              speedLeft = lowest_speed_bitL;
            }
            // Right turn (back)
            else if (xAxis > 660)
            {
            // int xMapped = map(xAxis, 510, 1023, 0, 255);
              speedRight = lowest_speed_bitR;
            }
            ledcWrite(LEDC_CHANNEL_1, stop_speed);
            ledcWrite(LEDC_CHANNEL_2, speedLeft);
            ledcWrite(LEDC_CHANNEL_3, stop_speed);
            ledcWrite(LEDC_CHANNEL_4, speedRight);
          }
          // Pivot Left turn
          if (yAxis >= 360 && yAxis <= 660 && xAxis < 360)
          {
            speedLeft = map(xAxis, 510, 0, lowest_speed_bitL, 0);
            speedRight = map(xAxis, 510, 0, lowest_speed_bitR, 0);
            ledcWrite(LEDC_CHANNEL_1, stop_speed);
            ledcWrite(LEDC_CHANNEL_2, speedLeft);
            ledcWrite(LEDC_CHANNEL_3, speedRight);
            ledcWrite(LEDC_CHANNEL_4, stop_speed);
          }
          // Pivot Right turn
          if (yAxis >= 360 && yAxis <= 660 && xAxis > 660)
          {
            speedLeft = map(xAxis, 510, 1023, lowest_speed_bitL, 0);
            speedRight = map(xAxis, 510, 1023, lowest_speed_bitR, 0);
            ledcWrite(LEDC_CHANNEL_1, speedLeft);
            ledcWrite(LEDC_CHANNEL_2, stop_speed);
            ledcWrite(LEDC_CHANNEL_3, stop_speed);
            ledcWrite(LEDC_CHANNEL_4, speedRight);
          }
          // Joystick neutral
          if ((yAxis >= 360 && yAxis <= 660) && (xAxis >= 360 && xAxis <= 660))
          {
            ledcWrite(LEDC_CHANNEL_1, stop_speed);
            ledcWrite(LEDC_CHANNEL_2, stop_speed);
            ledcWrite(LEDC_CHANNEL_3, stop_speed);
            ledcWrite(LEDC_CHANNEL_4, stop_speed);
          }
          // joystick button LED
          if (data3 == 1)
          {
            digitalWrite(LEDB, HIGH);
            myServo.write(150);
          }
          else
          {
            digitalWrite(LEDB, LOW);
            myServo.write(90);
          }
          // Motor Drive LED
          if (speedLeft < 95 || speedRight < 95)
          {
            digitalWrite(LEDG, HIGH);
          }
          else
          {
            digitalWrite(LEDG, LOW);
          }
          // serial monitor
          // Serial.print(F("\r\nxAxis: "));
          // Serial.print(xAxis);
          // Serial.print(F("\tyAxis: "));
          // Serial.print(yAxis);
          // Serial.print(F("\tspeedLeft: "));
          // Serial.print(speedLeft);
          // Serial.print(F("\tspeedRight: "));
          // Serial.print(speedRight);
          // Serial.print(F("\tbutton5: "));
          // Serial.print(data3);
        }
      }