Skip to content

Wireless Communication

I used the code from this website for the ESP32C3. I also installed the ArduinoBLE package in the Arduino IDE through the package manager.

I then downloaded the rNF Connect app on my phone and followed the instructions in the tutorial, which worked!

imgs

imgs

Working ESP32C3 code:

#include <ArduinoBLE.h>

BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // Bluetooth® Low Energy LED Service
 6
// Bluetooth® Low Energy LED Switch Characteristic - custom 128-bit UUID, read and writable by central
BLEByteCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

const int Relay1 = D2; 
const int Relay2 = D3; 
const int Relay3 = D4; 
const int Relay4 = D5; 

int Rvalue; // received value from Bluetooth Application


void setup() {
  Serial.begin(9600); //Baudrate

  // Set all the Relays as output
  pinMode(Relay1, OUTPUT);
   pinMode(Relay2, OUTPUT);
     pinMode(Relay3, OUTPUT);
   pinMode(Relay4, OUTPUT);

  // begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");

    while (1);
  }

  // set advertised local name and service UUID:
  BLE.setLocalName("AdamsBluetoothESP32C3");            // this will appear in the App search result.
  BLE.setAdvertisedService(ledService);

  // add the characteristic to the service
  ledService.addCharacteristic(switchCharacteristic);

  // add service
  BLE.addService(ledService);

  // set the initial value for the characeristic:
  switchCharacteristic.writeValue(0);

  // start advertising
  BLE.advertise();

  Serial.println("BLE LED Peripheral");
}

void loop() {
  // listen for Bluetooth® Low Energy peripherals to connect:
  BLEDevice central = BLE.central();

  // if a central is connected to peripheral:
  if (central) {
    Serial.print("Connected to central: ");
    // print the central's MAC address:
    Serial.println(central.address());


  while (central.connected()) {
        if (switchCharacteristic.written()) {
          Rvalue=switchCharacteristic.value(); // received value is stored in variable Rvalue.
          Serial.print(Rvalue);
          Serial.println(" recieved!");
        }
      }

    // when the central disconnects, print it out:
    Serial.print(F("Disconnected from central: "));
    Serial.println(central.address());
  }
}

Some other forums revealed that HC-05's Bluetooth isn't supported by Apple, so I couldn't test whether this code works. This code (and the wiring) is based off of this website.

from machine import Pin, UART

print("Something is happening")

uart = UART(0, 9600)
led = Pin(13, Pin.OUT)

while True:
  if uart.any() > 0:
    data = uart.read()
    print(data)
    if "on" in data:
      led.value(1)
      print('LED on \n')
      uart.write('LED on \n')
    elif "off" in data:
      led.value(0)
      print('LED off \n')
      uart.write('LED off \n')"""

ChatGPT said that the HC-05 can't use BLE, and gave me the following code to run instead on the ESP32. I also could order the HM-10 module instead, but I'll try the other solution for now. After I had it write the code it said it make a mistake and the ESP32C3 specifically doesn't support non-BLE bluetooth communication.

Here's code written for the MicroPython.

from machine import Pin, UART
import time

uart = UART(0, 9600)  # The HM-10 uses a baud rate of 9600 by default

# Send AT commands to the HM-10 module to connect to the ESP32C3
# Replace the MAC address below with the MAC address of your ESP32C3
uart.write('AT+CONMAC_address_of_your_ESP32C3\n')
time.sleep(1) # Waiting for the connection to be established

while True:
    # Send a message to the ESP32C3
    message = "Hello, ESP32C3!"
    uart.write(message)

    # Wait for a second before sending the next message
    time.sleep(1)

    # Read any incoming messages
    if uart.any():
        data = uart.read()
        print(data)

Here's the code it wrote to figure out the address of the esp32c3.

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  delay(1000);

  // Print ESP32 Local MAC Address
  Serial.printf("ESP32C3 MAC Address: %s\n", WiFi.macAddress().c_str());
}

void loop() {
}

Here was the output!

34:85:18:00:8C:98

And based on that, here's the new MicroPython code:

from machine import Pin, UART
import time

uart = UART(0, 9600)  # The HM-10 uses a baud rate of 9600 by default

# Send AT commands to the HM-10 module to connect to the ESP32C3
uart.write('AT+CON348518008C98\n')
time.sleep(1) # Waiting for the connection to be established

while True:
    # Send a message to the ESP32C3
    message = "Hello, ESP32C3!"
    uart.write(message)

    # Wait for a second before sending the next message
    time.sleep(1)

    # Read any incoming messages
    if uart.any():
        data = uart.read()
        print(data)

I asked to confirm that the original ESP32C3 code was advertising the BLE connection, and here was its affirmative response.

Yes, the original code you provided for the ESP32C3 does advertise it. The following line in the setup function starts the advertising process:
BLE.advertise();
This line makes the ESP32C3 visible to other BLE devices, which allows the HM-10 module to discover and connect to it.

Moreover, the following line sets a local name for the device which can be helpful while scanning:
BLE.setLocalName("AdamsBluetoothESP32C3");
When a BLE device such as the HM-10 scans for nearby devices, it will see a device named "AdamsBluetoothESP32C3". This is the name of your ESP32C3.

ChatGPT wrote the following code.

from machine import UART, Pin
import time

uart = UART(0, 9600)  # init with given baudrate

def send_command(cmd):
    uart.write(cmd + '\r\n')
    time.sleep(0.5)  # Wait for command to execute

def setup():
    send_command('AT')  # Check if HM-10 is responding
    response = uart.read()
    if response == 'OK':
        print('HM-10 is responding')
    else:
        print('HM-10 not responding')

    send_command('AT+ROLE1')  # Set HM-10 to central role

    # Assuming you know the address of your peripheral
    # Replace the X's with the address of your peripheral
    send_command('AT+CON348518008C98\n')  

def loop():
    while True:
        if uart.any():  # If there's data on UART
            data = uart.read()
            print('Received:', data)
            # Process data here

        # Add your own data sending logic here
        # uart.write('Data to send')
        time.sleep(0.1)

if __name__ == "__main__":
    setup()
    loop()

And I used this for the ESP32-C3.

#include <ArduinoBLE.h>

BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // Bluetooth® Low Energy LED Service

// Bluetooth® Low Energy LED Switch Characteristic - custom 128-bit UUID, read and writable by central
BLEByteCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

const int Relay1 = D2; 
const int Relay2 = D3; 
const int Relay3 = D4; 
const int Relay4 = D5; 

int Rvalue; // received value from Bluetooth Application


void setup() {
  Serial.begin(9600); //Baudrate

  // Set all the Relays as output
  pinMode(Relay1, OUTPUT);
   pinMode(Relay2, OUTPUT);
     pinMode(Relay3, OUTPUT);
   pinMode(Relay4, OUTPUT);

  // begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");

    while (1);
  }

  // set advertised local name and service UUID:
  BLE.setLocalName("AdamsBluetoothESP32C3");            // this will appear in the App search result.
  BLE.setAdvertisedService(ledService);

  // add the characteristic to the service
  ledService.addCharacteristic(switchCharacteristic);

  // add service
  BLE.addService(ledService);

  // set the initial value for the characeristic:
  switchCharacteristic.writeValue(0);

  // start advertising
  BLE.advertise();

  Serial.println("BLE LED Peripheral");
}

void loop() {
  // listen for Bluetooth® Low Energy peripherals to connect:
  BLEDevice central = BLE.central();

  // if a central is connected to peripheral:
  if (central) {
    Serial.print("Connected to central: ");
    // print the central's MAC address:
    Serial.println(central.address());


  while (central.connected()) {
        if (switchCharacteristic.written()) {
          Rvalue=switchCharacteristic.value(); // received value is stored in variable Rvalue.
          Serial.print(Rvalue);
          Serial.println(" recieved!");
        }
      }

    // when the central disconnects, print it out:
    Serial.print(F("Disconnected from central: "));
    Serial.println(central.address());
  }
}

HM-10 Bluetooth Module

I found this page updated today (6/1)! In the page source I saw a link to this GitHub repo. I downloaded the entire repo as a zip file. Unfortunately, the bluetooth module wasn't recognized even though the repo said I needed only 1.17 MicroPython or higher. However, the original documentation said some features may not have been released yet.

I used the Bluetooth Terminal app on my iPhone and saw the name of the module was DSD TECH and the UUID (which this post revealed is not constant) was A370BABF-1390-E050-10EA-338637BA6996.

I also realized that the red light flashing when it's not connected and contantly on when it is.

Sending the AT commands from this source, this source, this source, this source, and thi ssource never worked for me, although I could read information from UART.

Here's the working MicroPython code.

from machine import UART, Pin
import time

uart = UART(0, 9600, tx=Pin(0), rx=Pin(1))  # init with given baudrate
uart.init(9600, bits=8, parity=None, stop=1)
def send_command(cmd):
    uart.write(cmd + '\r\n')
    time.sleep(0.5)  # Wait for command to execute

def setup():
    send_command('wakeup')  # Check if HM-10 is responding
    response = uart.read()
    print(response)
    if response == 'OK':
        print('HM-10 is responding')
    else:
        print('HM-10 not responding')

    send_command('AT+ROLE1')  # Set HM-10 to central role

    # Assuming you know the address of your peripheral
    # Replace the X's with the address of your peripheral
    send_command('AT+CON348518008C98\n')  

def loop():
    while True:
        if uart.any():
            print(uart.readline())

if __name__ == "__main__":
    setup()
    loop()

Here was the Arduino Uno code that worked.

#include <SoftwareSerial.h>

SoftwareSerial HM10(2, 3); // RX = 2, TX = 3

char appData;  

String inData = "";

void setup()

{

  Serial.begin(9600);

  Serial.println("HM10 serial started at 9600");

  HM10.begin(9600); // set HM10 serial at 9600 baud rate

  pinMode(13, OUTPUT); // onboard LED

  digitalWrite(13, LOW); // switch OFF LED


}


void loop()

{

  HM10.listen();  // listen the HM10 port

  while (HM10.available() > 0) {   // if HM10 sends something then read

    appData = HM10.read();

    inData = String(appData);  // save the data in string format

    Serial.write(appData);

  }




  if (Serial.available()) {           // Read user input if available.

    delay(10);

    HM10.write(Serial.read());

  }

  if ( inData == "F") {

    Serial.println("LED OFF");

    digitalWrite(13, LOW); // switch OFF LED

    delay(500);

  }

  if ( inData == "N") {

    Serial.println("LED ON");

    digitalWrite(13, HIGH); // switch ON LED

    delay(500);

    digitalWrite(13, HIGH); // switch ON LED

    delay(500);

    digitalWrite(13, LOW); // switch OFF LED

    delay(500);

    digitalWrite(13, HIGH); // switch ON LED

    delay(500);

    digitalWrite(13, LOW); // switch OFF LED

    delay(500);

    digitalWrite(13, HIGH); // switch ON LED

    delay(500);

    digitalWrite(13, LOW); // switch OFF LED

    delay(500);

    digitalWrite(13, HIGH); // switch ON LED

    delay(500);

    digitalWrite(13, LOW); // switch OFF LED

    delay(500);

    digitalWrite(13, HIGH); // switch OFF LED

    delay(500);



  }

}

ChatGPT revised the ESP32C3's code to connect to the bluetooth module named DSD TECH, and it worked first try!

#include <ArduinoBLE.h>

BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); 
BLEByteCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

const int Relay1 = D2; 
const int Relay2 = D3; 
const int Relay3 = D4; 
const int Relay4 = D5;

int Rvalue;

void setup() {
  Serial.begin(9600); 

  pinMode(Relay1, OUTPUT);
  pinMode(Relay2, OUTPUT);
  pinMode(Relay3, OUTPUT);
  pinMode(Relay4, OUTPUT);

  if (!BLE.begin()) {
    Serial.println("starting Bluetooth failed!");
    while (1);
  }

  ledService.addCharacteristic(switchCharacteristic);
  BLE.addService(ledService);
  switchCharacteristic.writeValue(0);

  Serial.println("Scanning...");

  BLE.scanForName("DSD TECH");
}

void loop() {
  // check if a peripheral has been discovered
  BLEDevice peripheral = BLE.available();

  if (peripheral) {
    // discovered a peripheral
    Serial.print("Found ");
    Serial.print(peripheral.address());
    Serial.print(" '");
    Serial.print(peripheral.localName());
    Serial.println("'");

    // if the peripheral is named "DSD TECH", connect to it
    if (peripheral.localName() == "DSD TECH") {
      Serial.println("Connecting ...");

      if (peripheral.connect()) {
        Serial.println("Connected");
        // if connected, do something with the peripheral:
        // for example, read or write a characteristic
      } else {
        Serial.println("Failed to connect!");
      }
    }
  }
}

It then wrote this code to send a message.

#include <ArduinoBLE.h>

BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); 
BLEByteCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

const int Relay1 = D2; 
const int Relay2 = D3; 
const int Relay3 = D4; 
const int Relay4 = D5;

int Rvalue;

void setup() {
  Serial.begin(9600); 

  pinMode(Relay1, OUTPUT);
  pinMode(Relay2, OUTPUT);
  pinMode(Relay3, OUTPUT);
  pinMode(Relay4, OUTPUT);

  if (!BLE.begin()) {
    Serial.println("starting Bluetooth failed!");
    while (1);
  }

  ledService.addCharacteristic(switchCharacteristic);
  BLE.addService(ledService);
  switchCharacteristic.writeValue(0);

  Serial.println("Scanning...");

  BLE.scanForName("DSD TECH");
}

void loop() {
  // check if a peripheral has been discovered
  BLEDevice peripheral = BLE.available();

  if (peripheral) {
    // discovered a peripheral
    Serial.print("Found ");
    Serial.print(peripheral.address());
    Serial.print(" '");
    Serial.print(peripheral.localName());
    Serial.println("'");

    // if the peripheral is named "DSD TECH", connect to it
    if (peripheral.localName() == "DSD TECH") {
      Serial.println("Connecting ...");

      if (peripheral.connect()) {
        Serial.println("Connected");
        // if connected, do something with the peripheral:

        // discover peripheral attributes
        if (peripheral.discoverAttributes()) {
          // get the remote characteristic by its UUID
          BLECharacteristic remoteCharacteristic = peripheral.characteristic("19B10001-E8F2-537E-4F6C-D104768A1214");

          if (remoteCharacteristic) {
            uint8_t value = 1;
            if (remoteCharacteristic.canWrite()) {
              remoteCharacteristic.writeValue(value);
              Serial.println("Sent value to remote characteristic");
            } else {
              Serial.println("Remote characteristic is not writable");
            }
          } else {
            Serial.println("Remote characteristic not found");
          }
        } else {
          Serial.println("Attribute discovery failed");
        }
      } else {
        Serial.println("Failed to connect!");
      }
    }
  }
}

But it didn't work, so it revised it to the following.

This repo

#include <ArduinoBLE.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);

  // begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");

    while (1);
  }

  Serial.println("Bluetooth® Low Energy Central - Peripheral Explorer");

  // start scanning for peripherals
  BLE.scan();
}

void loop() {
  // check if a peripheral has been discovered
  BLEDevice peripheral = BLE.available();

  if (peripheral) {
    // discovered a peripheral, print out address, local name, and advertised service
    Serial.print("Found ");
    Serial.print(peripheral.address());
    Serial.print(" '");
    Serial.print(peripheral.localName());
    Serial.print("' ");
    Serial.print(peripheral.advertisedServiceUuid());
    Serial.println();

    // see if peripheral is a LED
    if (peripheral.localName() == "DSD TECH") { //LED
      // stop scanning
      BLE.stopScan();

      explorerPeripheral(peripheral);

      // peripheral disconnected, we are done
      while (1) {
        // do nothing
      }
    }
  }
}

void explorerPeripheral(BLEDevice peripheral) {
  // connect to the peripheral
  Serial.println("Connecting ...");

  if (peripheral.connect()) {
    Serial.println("Connected");
  } else {
    Serial.println("Failed to connect!");
    return;
  }

  // discover peripheral attributes
  Serial.println("Discovering attributes ...");
  if (peripheral.discoverAttributes()) {
    Serial.println("Attributes discovered");
  } else {
    Serial.println("Attribute discovery failed!");
    peripheral.disconnect();
    return;
  }

  // read and print device name of peripheral
  Serial.println();
  Serial.print("Device name: ");
  Serial.println(peripheral.deviceName());
  Serial.print("Appearance: 0x");
  Serial.println(peripheral.appearance(), HEX);
  Serial.println();

  // loop the services of the peripheral and explore each
  for (int i = 0; i < peripheral.serviceCount(); i++) {
    BLEService service = peripheral.service(i);

    exploreService(service);
  }

  Serial.println();

  // we are done exploring, disconnect
  Serial.println("Disconnecting ...");
  peripheral.disconnect();
  Serial.println("Disconnected");
}

void exploreService(BLEService service) {
  // print the UUID of the service
  Serial.print("Service ");
  Serial.println(service.uuid());

  // loop the characteristics of the service and explore each
  for (int i = 0; i < service.characteristicCount(); i++) {
    BLECharacteristic characteristic = service.characteristic(i);

    exploreCharacteristic(characteristic);
  }
}

void exploreCharacteristic(BLECharacteristic characteristic) {
  // print the UUID and properties of the characteristic
  Serial.print("\tCharacteristic ");
  Serial.print(characteristic.uuid());
  Serial.print(", properties 0x");
  Serial.print(characteristic.properties(), HEX);

  // check if the characteristic is readable
  if (characteristic.canRead()) {
    // read the characteristic value
    characteristic.read();

    if (characteristic.valueLength() > 0) {
      // print out the value of the characteristic
      Serial.print(", value 0x");
      printData(characteristic.value(), characteristic.valueLength());
    }
  }
  Serial.println();

  // loop the descriptors of the characteristic and explore each
  for (int i = 0; i < characteristic.descriptorCount(); i++) {
    BLEDescriptor descriptor = characteristic.descriptor(i);

    exploreDescriptor(descriptor);
  }
}

void exploreDescriptor(BLEDescriptor descriptor) {
  // print the UUID of the descriptor
  Serial.print("\t\tDescriptor ");
  Serial.print(descriptor.uuid());

  // read the descriptor value
  descriptor.read();

  // print out the value of the descriptor
  Serial.print(", value 0x");
  printData(descriptor.value(), descriptor.valueLength());

  Serial.println();
}

void printData(const unsigned char data[], int length) {
  for (int i = 0; i < length; i++) {
    unsigned char b = data[i];

    if (b < 16) {
      Serial.print("0");
    }

    Serial.print(b, HEX);
  }
}

output:

    Characteristic 2a03, properties 0xA, value 0x000000000000
        Descriptor 2803, value 0x020B00042A
        Descriptor 2a04, value 0x5000A0000000E803
    Characteristic 2a04, properties 0x2, value 0x5000A0000000E803
Service 1801
    Characteristic 2a05, properties 0x20
        Descriptor 2902, value 0x0000
Service ffe0
    Characteristic ffe1, properties 0x16, value 0x38AB4153DAF7
        Descriptor 2902, value 0x0000
        Descriptor 2901, value 0x4453442054454348

Disconnecting ...
Disconnected

The 0X38AB... was same as on the phone app Lightblue.

I decided to try to modify the scanner code, which worked! I was having trouble converting a char[] to a char* so I couldn't check the entire UUID, but checking the fourth character worked!

#include <ArduinoBLE.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);

  // begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");

    while (1);
  }

  Serial.println("Bluetooth® Low Energy Central - Peripheral Explorer");

  // start scanning for peripherals
  BLE.scan();
}

void loop() {
  // check if a peripheral has been discovered
  BLEDevice peripheral = BLE.available();

  if (peripheral) {
    // discovered a peripheral, print out address, local name, and advertised service
    Serial.print("Found ");
    Serial.print(peripheral.address());
    Serial.print(" '");
    Serial.print(peripheral.localName());
    Serial.print("' ");
    Serial.print(peripheral.advertisedServiceUuid());
    Serial.println();

    // see if peripheral is a LED
    if (peripheral.localName() == "DSD TECH") { //LED
      // stop scanning
      BLE.stopScan();

      explorerPeripheral(peripheral);

      // peripheral disconnected, we are done
      while (1) {
        // do nothing
      }
    }
  }
}

void explorerPeripheral(BLEDevice peripheral) {
  // connect to the peripheral
  Serial.println("Connecting ...");

  if (peripheral.connect()) {
    Serial.println("Connected");
  } else {
    Serial.println("Failed to connect!");
    return;
  }

  // discover peripheral attributes
  Serial.println("Discovering attributes ...");
  if (peripheral.discoverAttributes()) {
    Serial.println("Attributes discovered");
  } else {
    Serial.println("Attribute discovery failed!");
    peripheral.disconnect();
    return;
  }

  // read and print device name of peripheral
  Serial.println();
  Serial.print("Device name: ");
  Serial.println(peripheral.deviceName());
  Serial.print("Appearance: 0x");
  Serial.println(peripheral.appearance(), HEX);
  Serial.println();

  // loop the services of the peripheral and explore each
  for (int i = 0; i < peripheral.serviceCount(); i++) {
    BLEService service = peripheral.service(i);

    exploreService(service);
  }

  Serial.println();

  // we are done exploring, disconnect
  Serial.println("Disconnecting ...");
  peripheral.disconnect();
  Serial.println("Disconnected");
}

void exploreService(BLEService service) {
  // print the UUID of the service
  Serial.print("Service ");
  Serial.println(service.uuid());

  // loop the characteristics of the service and explore each
  for (int i = 0; i < service.characteristicCount(); i++) {
    BLECharacteristic characteristic = service.characteristic(i);

    exploreCharacteristic(characteristic);
  }
}

void exploreCharacteristic(BLECharacteristic characteristic) {
  // print the UUID and properties of the characteristic
  Serial.print("\tCharacteristic ");
  Serial.println(characteristic.uuid());
  char s[] = "ffe1";
  Serial.print(s[3]);Serial.print(" == ");Serial.print(characteristic.uuid()[3]);Serial.println("? ");Serial.println(characteristic.uuid()[3] == s[3]);
  if (characteristic.uuid()[3] == s[3]){
    Serial.print("WRITING 6 to ");Serial.println(characteristic.uuid());
  uint8_t v_ = 6;
  characteristic.writeValue(v_);
  }
  Serial.print(", properties 0x");
  Serial.print(characteristic.properties(), HEX);

  // check if the characteristic is readable
  if (characteristic.canRead()) {
    // read the characteristic value
    characteristic.read();

    if (characteristic.valueLength() > 0) {
      // print out the value of the characteristic
      Serial.print(", value 0x");
      printData(characteristic.value(), characteristic.valueLength());
    }
  }
  Serial.println();

  // loop the descriptors of the characteristic and explore each
  for (int i = 0; i < characteristic.descriptorCount(); i++) {
    BLEDescriptor descriptor = characteristic.descriptor(i);

    exploreDescriptor(descriptor);
  }
}

void exploreDescriptor(BLEDescriptor descriptor) {
  // print the UUID of the descriptor
  Serial.print("\t\tDescriptor ");
  Serial.print(descriptor.uuid());

  // read the descriptor value
  descriptor.read();

  // print out the value of the descriptor
  Serial.print(", value 0x");
  printData(descriptor.value(), descriptor.valueLength());

  Serial.println();
}

void printData(const unsigned char data[], int length) {
  for (int i = 0; i < length; i++) {
    unsigned char b = data[i];

    if (b < 16) {
      Serial.print("0");
    }

    Serial.print(b, HEX);
  }
}

I also noticed that I can't decode the uint8_t only can tell what it is in its byte form.

I then modified it to this so that it would only scan for a device that matched the HM-10's name, which worked!

#include <ArduinoBLE.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);

  // begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");

    while (1);
  }

  Serial.println("Bluetooth® Low Energy Central - Peripheral Explorer");

  // start scanning for peripherals
  BLE.scanForName("DSD TECH");
}

void loop() {
  // check if a peripheral has been discovered
  BLEDevice peripheral = BLE.available();

  if (peripheral) {
    // discovered a peripheral, print out address, local name, and advertised service
    Serial.print("Found ");
    Serial.print(peripheral.address());
    Serial.print(" '");
    Serial.print(peripheral.localName());
    Serial.print("' ");
    Serial.print(peripheral.advertisedServiceUuid());
    Serial.println();

    // see if peripheral is a LED
    if (peripheral.localName() == "DSD TECH") { //LED
      // stop scanning
      BLE.stopScan();

      explorerPeripheral(peripheral);

      // peripheral disconnected, we are done
      while (1) {
        // do nothing
      }
    }
  }
}

void explorerPeripheral(BLEDevice peripheral) {
  // connect to the peripheral
  Serial.println("Connecting ...");

  if (peripheral.connect()) {
    Serial.println("Connected");
  } else {
    Serial.println("Failed to connect!");
    return;
  }

  // discover peripheral attributes
  Serial.println("Discovering attributes ...");
  if (peripheral.discoverAttributes()) {
    Serial.println("Attributes discovered");
  } else {
    Serial.println("Attribute discovery failed!");
    peripheral.disconnect();
    return;
  }

  // read and print device name of peripheral
  Serial.println();
  Serial.print("Device name: ");
  Serial.println(peripheral.deviceName());
  Serial.print("Appearance: 0x");
  Serial.println(peripheral.appearance(), HEX);
  Serial.println();

  // loop the services of the peripheral and explore each
  for (int i = 0; i < peripheral.serviceCount(); i++) {
    BLEService service = peripheral.service(i);

    exploreService(service);
  }

  Serial.println();

  // we are done exploring, disconnect
  Serial.println("Disconnecting ...");
  peripheral.disconnect();
  Serial.println("Disconnected");
}

void exploreService(BLEService service) {
  // print the UUID of the service
  Serial.print("Service ");
  Serial.println(service.uuid());

  // loop the characteristics of the service and explore each
  for (int i = 0; i < service.characteristicCount(); i++) {
    BLECharacteristic characteristic = service.characteristic(i);

    exploreCharacteristic(characteristic);
  }
}

void exploreCharacteristic(BLECharacteristic characteristic) {
  // print the UUID and properties of the characteristic
  Serial.print("\tCharacteristic ");
  Serial.println(characteristic.uuid());
  char s[] = "ffe1";
  Serial.print(s[3]);Serial.print(" == ");Serial.print(characteristic.uuid()[3]);Serial.println("? ");Serial.println(characteristic.uuid()[3] == s[3]);
  if (characteristic.uuid()[3] == s[3]){
    Serial.print("WRITING 6 to ");Serial.println(characteristic.uuid());
  uint8_t v_ = 6;
  characteristic.writeValue(v_);
  }
  Serial.print(", properties 0x");
  Serial.print(characteristic.properties(), HEX);

  // check if the characteristic is readable
  if (characteristic.canRead()) {
    // read the characteristic value
    characteristic.read();

    if (characteristic.valueLength() > 0) {
      // print out the value of the characteristic
      Serial.print(", value 0x");
      printData(characteristic.value(), characteristic.valueLength());
    }
  }
  Serial.println();

  // loop the descriptors of the characteristic and explore each
  for (int i = 0; i < characteristic.descriptorCount(); i++) {
    BLEDescriptor descriptor = characteristic.descriptor(i);

    exploreDescriptor(descriptor);
  }
}

void exploreDescriptor(BLEDescriptor descriptor) {
  // print the UUID of the descriptor
  Serial.print("\t\tDescriptor ");
  Serial.print(descriptor.uuid());

  // read the descriptor value
  descriptor.read();

  // print out the value of the descriptor
  Serial.print(", value 0x");
  printData(descriptor.value(), descriptor.valueLength());

  Serial.println();
}

void printData(const unsigned char data[], int length) {
  for (int i = 0; i < length; i++) {
    unsigned char b = data[i];

    if (b < 16) {
      Serial.print("0");
    }

    Serial.print(b, HEX);
  }
}