Portenta C33 + UWB Shield BLE Communication with React Native App

`
#include 
#include 
#include 

#define UWB_SERVICE_UUID   "12345678-1234-5678-1234-56789abcdef0"
#define CMD_CHAR_UUID      "12345678-1234-5678-1234-56789abcdef1"
#define DATA_CHAR_UUID     "12345678-1234-5678-1234-56789abcdef2"

BLEService uwbService(UWB_SERVICE_UUID);

BLECharacteristic cmdChar(CMD_CHAR_UUID, BLEWrite, 64);
BLECharacteristic dataChar(DATA_CHAR_UUID, BLENotify, 64);

void onCmdWritten(BLEDevice central, BLECharacteristic characteristic) {
  String cmd = "";
  int len = characteristic.valueLength();
  for (int i = 0; i < len; i++) {
    cmd += (char)characteristic.value()[i];
  }

  Serial.print("CMD from phone: "); 
  Serial.println(cmd);

  if (cmd == "LED:ON") {
    digitalWrite(LED_BUILTIN, HIGH);
    dataChar.writeValue("OK:LED_ON");
  } 
  else if (cmd == "LED:OFF") {
    digitalWrite(LED_BUILTIN, LOW);
    dataChar.writeValue("OK:LED_OFF");
  } 
  else if (cmd.startsWith("UWB:")) {
    String resp = "UWB_RESP:dummy";
    dataChar.writeValue(resp.c_str());
  } 
  else {
    dataChar.writeValue("ERR:UNKNOWN_CMD");
  }
}

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

  pinMode(LED_BUILTIN, OUTPUT);

  if (!BLE.begin()) {
    Serial.println("Failed to init BLE!");
    while (1);
  }

  BLE.setLocalName("Portenta-UWB");
  BLE.setAdvertisedService(uwbService);
  uwbService.addCharacteristic(cmdChar);
  uwbService.addCharacteristic(dataChar);
  BLE.addService(uwbService);

  cmdChar.setEventHandler(BLEWritten, onCmdWritten);

  BLE.advertise();
  Serial.println("BLE advertising as Portenta-UWB");

  SPI.begin();
}

void loop() {
  BLE.poll();
}

`
import React, { useEffect, useState } from "react";
import {
  View,
  Text,
  Button,
  FlatList,
  TouchableOpacity,
  PermissionsAndroid,
  Platform,
} from "react-native";
import { BleManager } from "react-native-ble-plx";
import { Buffer } from "buffer";

const manager = new BleManager();

const UWB_SERVICE_UUID = "12345678-1234-5678-1234-56789abcdef0";
const CMD_CHAR_UUID = "12345678-1234-5678-1234-56789abcdef1";
const DATA_CHAR_UUID = "12345678-1234-5678-1234-56789abcdef2";

export default function App() {
  const [devices, setDevices] = useState([]);
  const [connectedDevice, setConnectedDevice] = useState(null);

  const startScan = async () => {
    setDevices([]);

    if (Platform.OS === "android" && Platform.Version >= 23) {
      await PermissionsAndroid.requestMultiple([
        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
        PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
        PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
      ]);
    }

    manager.startDeviceScan(null, null, (error, device) => {
      if (error) {
        console.log("Scan error:", error);
        return;
      }

      if (device && device.name) {
        setDevices((prev) => {
          if (!prev.find((d) => d.id === device.id)) {
            return [...prev, device];
          }
          return prev;
        });
      }
    });

    setTimeout(() => manager.stopDeviceScan(), 10000);
  };

  useEffect(() => {
    startScan();
    return () => manager.destroy();
  }, []);

  const connectToDevice = async (device) => {
    try {
      const connected = await manager.connectToDevice(device.id);
      await connected.discoverAllServicesAndCharacteristics();
      setConnectedDevice(connected);
      console.log(" Connected to:", connected.name);

      connected.monitorCharacteristicForService(
        UWB_SERVICE_UUID,
        DATA_CHAR_UUID,
        (error, char) => {
          if (error) {
            console.log("Notify error:", error);
            return;
          }
          if (char?.value) {
            const msg = Buffer.from(char.value, "base64").toString("utf-8");
            console.log(" From board:", msg);
          }
        }
      );
    } catch (error) {
      console.log("Connection error:", error);
    }
  };

  const sendCommand = async (cmd) => {
    if (!connectedDevice) return;
    try {
      await connectedDevice.writeCharacteristicWithResponseForService(
        UWB_SERVICE_UUID,
        CMD_CHAR_UUID,
        Buffer.from(cmd, "utf-8").toString("base64")
      );
      console.log(" Sent:", cmd);
    } catch (error) {
      console.log("Write error:", error);
    }
  };

  return (
    
      Nearby BLE Devices

      

       item.id}
        renderItem={({ item }) => (
           connectToDevice(item)}>
            
              {item.name || "Unnamed"} ({item.id})
            
          
        )}
      />

      {connectedDevice && (
        
           Connected to {connectedDevice.name}
           sendCommand("LED:ON")} />
           sendCommand("LED:OFF")} />
           sendCommand("UWB:REQ")} />
        
      )}
    
  );
}