Mini Program BLE Connection Example

uni.createBLEConnection({
    deviceId: "Scanned Device ID",
    timeout: 10000,
    success: (res) => {
        console.log('Connected:', res);
        data.deviceId = arr[0].deviceId;
        getDeviceServices(arr[0].deviceId);
    },
    fail: (err) => {
        console.error('Connection failed:', err);
    }
});

// Get BLE services
const getDeviceServices = (deviceId) => {
    uni.getBLEDeviceServices({
        deviceId,
        success: (res) => {
            console.log('Device services:', res.services);
            data.deviceServer = res.services[0].uuid;
            getDeviceCharacteristics(deviceId, res.services[0].uuid);
        },
        fail: (err) => {
            console.error('Get services failed:', err);
        }
    });
};

// Get BLE characteristics
const getDeviceCharacteristics = (deviceId, serviceId) => {
    uni.getBLEDeviceCharacteristics({
        deviceId,
        serviceId,
        success: (res) => {
            console.log('Device characteristic:', res.characteristics[0].uuid);
        },
        fail: (err) => {
            console.error('Get characteristics failed:', err);
        },
        complete: () => {
            uni.hideLoading()
        }
    });
};

Mini Program BLE Send Example

const EOT_MARKER = "--END--";
async function sendBleDataFunction({
    deviceId,
    serviceId,
    characteristicId,
    data,
    onEnd
}) {
    const reqData = str2ab(encodeURIComponent(JSON.stringify(data)));
    const chunkSize = 32;
    try {
        const success = await sendDataInChunks(
            deviceId,
            serviceId,
            characteristicId,
            reqData,
            chunkSize
        );

        if (success) {
            console.log('All packets sent successfully');
            try {
                await new Promise((resolve, reject) => {
                    uni.writeBLECharacteristicValue({
                        deviceId,
                        serviceId,
                        characteristicId,
                        value: str2ab(EOT_MARKER),
                        success(res) {
                            console.log('End marker sent:', res.errMsg);
                            resolve(res);
                        },
                        fail(err) {
                            console.error('End marker failed:', err);
                            reject(err);
                        }
                    });
                });
                console.log('All done, including end marker');
                onEnd && onEnd();
            } catch (eotError) {
                console.error('Error sending end marker:', eotError);
                uni.showToast({ title: 'Failed to send completion signal', icon: 'none' });
            }

        } else {
            console.log('Error occurred during data transmission');
            uni.showToast({ title: 'Data transmission failed', icon: 'none' });
        }
    } catch (error) {
        console.log('Unexpected write error:', error);
        uni.showToast({ title: 'Write failed', icon: 'none' });
    }
}

/**
 * Send ArrayBuffer in BLE chunks
 */
async function sendDataInChunks(deviceId, serviceId, characteristicId, buffer, chunkSize) {
    console.log(`Preparing to send ${buffer.byteLength} bytes in chunks of ${chunkSize} bytes.`);

    let offset = 0;
    while (offset < buffer.byteLength) {
        const chunk = buffer.slice(offset, Math.min(offset + chunkSize, buffer.byteLength));
        offset += chunk.byteLength;

        console.log(`Sending chunk of ${chunk.byteLength} bytes. Remaining: ${buffer.byteLength - offset}`);

        try {
            await new Promise((resolve, reject) => {
                uni.writeBLECharacteristicValue({
                    deviceId,
                    serviceId,
                    characteristicId,
                    value: chunk,
                    success(res) {
                        console.log('Chunk sent:', res.errMsg);
                        setTimeout(resolve, 50);
                    },
                    fail(err) {
                        console.error('Chunk send failed:', err);
                        reject(err);
                    }
                });
            });
        } catch (error) {
            console.error('Chunk send error, aborting.', error);
            return false;
        }
    }
    console.log('All chunks sent successfully.');
    return true;
}

// Example payload
let obj = {
    wifi_name: "Wi-Fi Name",
    wifi_pwd: "Wi-Fi Password",
    ext1: "Super-agent api_key",
    ext7: "Wake-up mode",
}

sendBleDataFunction({
    deviceId: "xxx",
    serviceId: "xxx",
    characteristicId: "xxx",
    data: obj,
    onEnd() {
        data.saveLoading = false
        back()
    }
});