ipro_ble_remote¶

┌─────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  1. 掃描     │ --> │  2. 連接        │ --> │  3. 協商 MTU     │
│  Scan for   │     │  Connect to     │     │  Request        │
│  "IPRO-Rmt" │     │  Device         │     │  MTU 513        │
└─────────────┘     └─────────────────┘     └─────────────────┘
                                                    │
                    ┌─────────────────┐     ┌───────▼───────────┐
                    │  5. 啟用通知     │ <-- │  4. 發現服務      │
                    │  Enable CCCD    │     │  Discover        │
                    │  Notifications  │     │  Services        │
                    └─────────────────┘     └───────────────────┘
                             │
                    ┌────────▼────────┐
                    │  6. 開始互動     │
                    │  Read/Write     │
                    │  Characteristics│
                    └─────────────────┘

PIR Image Service (0xFF50)
├── PIR Status (0xFF51)
│   ├── Properties: Read, Notify
│   └── CCCD: 0x2902
├── Image Control (0xFF52)
│   └── Properties: Write
├── Image Data (0xFF53)
│   ├── Properties: Notify
│   └── CCCD: 0x2902
└── Image Info (0xFF54)
    ├── Properties: Read, Notify
    └── CCCD: 0x2902

typedef struct __attribute__((packed)) {
    uint8_t  motion_detected;   // Offset 0: 1=動態偵測, 0=無動態
    uint32_t timestamp;         // Offset 1-4: 時間戳記 (ms, Little Endian)
    uint32_t event_count;       // Offset 5-8: 總事件次數 (Little Endian)
} pir_status_t;                 // Total: 9 bytes

fun parsePirStatus(data: ByteArray): PirStatus {
    val buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
    return PirStatus(
        motionDetected = buffer.get() == 1.toByte(),
        timestamp = buffer.int.toLong() and 0xFFFFFFFFL,
        eventCount = buffer.int.toLong() and 0xFFFFFFFFL
    )
}

struct PirStatus {
    let motionDetected: Bool
    let timestamp: UInt32
    let eventCount: UInt32

    init(data: Data) {
        motionDetected = data[0] == 1
        timestamp = data.subdata(in: 1..<5).withUnsafeBytes { $0.load(as: UInt32.self).littleEndian }
        eventCount = data.subdata(in: 5..<9).withUnsafeBytes { $0.load(as: UInt32.self).littleEndian }
    }
}

Byte 0: 0x03 (Command)
Byte 1: Chunk Index Low
Byte 2: Chunk Index High

// 拍照
fun captureImage(characteristic: BluetoothGattCharacteristic) {
    characteristic.value = byteArrayOf(0x01)
    gatt.writeCharacteristic(characteristic)
}

// 請求圖片資訊
fun requestImageInfo(characteristic: BluetoothGattCharacteristic) {
    characteristic.value = byteArrayOf(0x02)
    gatt.writeCharacteristic(characteristic)
}

// 請求特定數據塊
fun requestChunk(characteristic: BluetoothGattCharacteristic, index: Int) {
    val data = ByteBuffer.allocate(3).order(ByteOrder.LITTLE_ENDIAN)
        .put(0x03.toByte())
        .putShort(index.toShort())
        .array()
    characteristic.value = data
    gatt.writeCharacteristic(characteristic)
}

// 中止傳輸
fun abortTransfer(characteristic: BluetoothGattCharacteristic) {
    characteristic.value = byteArrayOf(0x04)
    gatt.writeCharacteristic(characteristic)
}

typedef struct __attribute__((packed)) {
    uint32_t image_size;    // Offset 0-3: 圖片總大小 (bytes, Little Endian)
    uint16_t chunk_count;   // Offset 4-5: 總數據塊數量 (Little Endian)
    uint16_t chunk_size;    // Offset 6-7: 每塊大小 (通常 244 bytes)
    uint8_t  format;        // Offset 8: 格式 (0=JPEG, 1=RAW)
    uint8_t  status;        // Offset 9: 狀態
} img_info_t;               // Total: 10 bytes

data class ImageInfo(
    val imageSize: Int,
    val chunkCount: Int,
    val chunkSize: Int,
    val format: ImageFormat,
    val status: ImageStatus
)

enum class ImageFormat { JPEG, RAW }
enum class ImageStatus { IDLE, CAPTURING, READY, TRANSFERRING, ERROR }

fun parseImageInfo(data: ByteArray): ImageInfo {
    val buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
    return ImageInfo(
        imageSize = buffer.int,
        chunkCount = buffer.short.toInt() and 0xFFFF,
        chunkSize = buffer.short.toInt() and 0xFFFF,
        format = if (buffer.get() == 0.toByte()) ImageFormat.JPEG else ImageFormat.RAW,
        status = ImageStatus.values()[buffer.get().toInt()]
    )
}

┌────────────┬────────────┬─────────────────────┐
│ Chunk Index│ Chunk Size │      Image Data     │
│  (2 bytes) │  (2 bytes) │    (≤240 bytes)     │
└────────────┴────────────┴─────────────────────┘

typedef struct __attribute__((packed)) {
    uint16_t chunk_index;   // Offset 0-1: 數據塊索引 (0-based)
    uint16_t chunk_size;    // Offset 2-3: 本塊數據大小 (CRITICAL: 必須從此讀取!)
    uint8_t  data[];        // Offset 4+: 圖片數據
} img_chunk_header_t;

class ImageReceiver {
    private var imageInfo: ImageInfo? = null
    private var receivedChunks = mutableMapOf<Int, ByteArray>()

    fun onImageInfoReceived(data: ByteArray) {
        imageInfo = parseImageInfo(data)
        receivedChunks.clear()
    }

    fun onChunkReceived(data: ByteArray): Float {
        val buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
        val chunkIndex = buffer.short.toInt() and 0xFFFF
        val chunkSize = buffer.short.toInt() and 0xFFFF

        val chunkData = ByteArray(chunkSize)
        buffer.get(chunkData)
        receivedChunks[chunkIndex] = chunkData

        // 返回進度
        return receivedChunks.size.toFloat() / (imageInfo?.chunkCount ?: 1)
    }

    fun isComplete(): Boolean {
        val info = imageInfo ?: return false
        return receivedChunks.size == info.chunkCount
    }

    fun assembleImage(): ByteArray? {
        val info = imageInfo ?: return null
        if (!isComplete()) return null

        val imageData = ByteArrayOutputStream()
        for (i in 0 until info.chunkCount) {
            receivedChunks[i]?.let { imageData.write(it) }
        }
        return imageData.toByteArray()
    }
}

┌─────────┐                      ┌─────────┐
│  手機   │                      │  設備   │
└────┬────┘                      └────┬────┘
     │                                │
     │  1. Enable Image Data Notify   │
     │ ──────────────────────────────>│
     │                                │
     │  2. Enable Image Info Notify   │
     │ ──────────────────────────────>│
     │                                │
     │  3. Write CAPTURE (0x01)       │
     │ ──────────────────────────────>│
     │                                │
     │  4. Notify: Image Info         │
     │ <──────────────────────────────│ (status=CAPTURING)
     │                                │
     │  5. Notify: Image Info         │
     │ <──────────────────────────────│ (status=READY, size, chunks)
     │                                │
     │  6. Write REQUEST_CHUNK(0)     │
     │ ──────────────────────────────>│
     │                                │
     │  7. Notify: Chunk 0 data       │
     │ <──────────────────────────────│
     │                                │
     │  8. Write REQUEST_CHUNK(1)     │
     │ ──────────────────────────────>│
     │                                │
     │  9. Notify: Chunk 1 data       │
     │ <──────────────────────────────│
     │                                │
     │        ... repeat ...          │
     │                                │
     │  N. All chunks received        │
     │  -> Assemble JPEG              │
     │  -> Display image              │
     ▼                                ▼

┌─────────┐                      ┌─────────┐
│  手機   │                      │  設備   │
└────┬────┘                      └────┬────┘
     │                                │
     │  1. Enable PIR Status Notify   │
     │ ──────────────────────────────>│
     │                                │
     │  [PIR sensor detects motion]   │
     │                                │
     │  2. Notify: PIR Status         │
     │ <──────────────────────────────│ (motion=1)
     │                                │
     │  [Device auto captures image]  │
     │                                │
     │  3. Notify: Image Info         │
     │ <──────────────────────────────│ (status=READY)
     │                                │
     │  4. App starts chunk requests  │
     │ ──────────────────────────────>│
     ▼                                ▼

class BleRemoteService : Service() {
    private val PIR_IMAGE_SERVICE_UUID = UUID.fromString("0000FF50-0000-1000-8000-00805F9B34FB")
    private val PIR_STATUS_CHAR_UUID = UUID.fromString("0000FF51-0000-1000-8000-00805F9B34FB")
    private val IMG_CTRL_CHAR_UUID = UUID.fromString("0000FF52-0000-1000-8000-00805F9B34FB")
    private val IMG_DATA_CHAR_UUID = UUID.fromString("0000FF53-0000-1000-8000-00805F9B34FB")
    private val IMG_INFO_CHAR_UUID = UUID.fromString("0000FF54-0000-1000-8000-00805F9B34FB")
    private val CCCD_UUID = UUID.fromString("00002902-0000-1000-8000-00805F9B34FB")

    private val imageReceiver = ImageReceiver()

    private val gattCallback = object : BluetoothGattCallback() {
        override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                val pirService = gatt.getService(PIR_IMAGE_SERVICE_UUID)
                pirService?.let {
                    // Enable notifications
                    enableNotification(gatt, it.getCharacteristic(PIR_STATUS_CHAR_UUID))
                    enableNotification(gatt, it.getCharacteristic(IMG_DATA_CHAR_UUID))
                    enableNotification(gatt, it.getCharacteristic(IMG_INFO_CHAR_UUID))
                }
            }
        }

        override fun onCharacteristicChanged(
            gatt: BluetoothGatt,
            characteristic: BluetoothGattCharacteristic,
            value: ByteArray
        ) {
            when (characteristic.uuid) {
                PIR_STATUS_CHAR_UUID -> {
                    val status = parsePirStatus(value)
                    if (status.motionDetected) {
                        onMotionDetected(status)
                    }
                }
                IMG_INFO_CHAR_UUID -> {
                    imageReceiver.onImageInfoReceived(value)
                    val info = parseImageInfo(value)
                    if (info.status == ImageStatus.READY) {
                        // Start requesting chunks
                        requestNextChunk(gatt, 0)
                    }
                }
                IMG_DATA_CHAR_UUID -> {
                    val progress = imageReceiver.onChunkReceived(value)
                    onTransferProgress(progress)

                    if (imageReceiver.isComplete()) {
                        val jpegData = imageReceiver.assembleImage()
                        jpegData?.let { onImageReceived(it) }
                    } else {
                        // Request next chunk
                        requestNextChunk(gatt, imageReceiver.receivedChunks.size)
                    }
                }
            }
        }
    }

    private fun enableNotification(gatt: BluetoothGatt, char: BluetoothGattCharacteristic?) {
        char?.let {
            gatt.setCharacteristicNotification(it, true)
            val descriptor = it.getDescriptor(CCCD_UUID)
            descriptor?.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
            gatt.writeDescriptor(descriptor)
        }
    }

    private fun requestNextChunk(gatt: BluetoothGatt, index: Int) {
        val pirService = gatt.getService(PIR_IMAGE_SERVICE_UUID)
        val ctrlChar = pirService?.getCharacteristic(IMG_CTRL_CHAR_UUID)
        ctrlChar?.let {
            val data = ByteBuffer.allocate(3).order(ByteOrder.LITTLE_ENDIAN)
                .put(0x03.toByte())
                .putShort(index.toShort())
                .array()
            it.value = data
            gatt.writeCharacteristic(it)
        }
    }

    fun captureImage(gatt: BluetoothGatt) {
        val pirService = gatt.getService(PIR_IMAGE_SERVICE_UUID)
        val ctrlChar = pirService?.getCharacteristic(IMG_CTRL_CHAR_UUID)
        ctrlChar?.let {
            it.value = byteArrayOf(0x01)
            gatt.writeCharacteristic(it)
        }
    }
}

fun onImageReceived(jpegData: ByteArray) {
    val bitmap = BitmapFactory.decodeByteArray(jpegData, 0, jpegData.size)
    runOnUiThread {
        imageView.setImageBitmap(bitmap)
    }
}

class BleRemoteManager: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {

    let pirImageServiceUUID = CBUUID(string: "FF50")
    let pirStatusCharUUID = CBUUID(string: "FF51")
    let imgCtrlCharUUID = CBUUID(string: "FF52")
    let imgDataCharUUID = CBUUID(string: "FF53")
    let imgInfoCharUUID = CBUUID(string: "FF54")

    var imageReceiver = ImageReceiver()
    var imgCtrlChar: CBCharacteristic?

    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        guard service.uuid == pirImageServiceUUID else { return }

        for char in service.characteristics ?? [] {
            switch char.uuid {
            case pirStatusCharUUID, imgDataCharUUID, imgInfoCharUUID:
                peripheral.setNotifyValue(true, for: char)
            case imgCtrlCharUUID:
                imgCtrlChar = char
            default:
                break
            }
        }
    }

    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
        guard let data = characteristic.value else { return }

        switch characteristic.uuid {
        case pirStatusCharUUID:
            let status = PirStatus(data: data)
            if status.motionDetected {
                onMotionDetected(status)
            }

        case imgInfoCharUUID:
            imageReceiver.onImageInfoReceived(data)
            if let info = imageReceiver.imageInfo, info.status == .ready {
                requestChunk(peripheral, index: 0)
            }

        case imgDataCharUUID:
            let progress = imageReceiver.onChunkReceived(data)
            onTransferProgress(progress)

            if imageReceiver.isComplete() {
                if let jpegData = imageReceiver.assembleImage() {
                    onImageReceived(jpegData)
                }
            } else {
                requestChunk(peripheral, index: imageReceiver.receivedChunks.count)
            }

        default:
            break
        }
    }

    func captureImage(_ peripheral: CBPeripheral) {
        guard let char = imgCtrlChar else { return }
        peripheral.writeValue(Data([0x01]), for: char, type: .withResponse)
    }

    func requestChunk(_ peripheral: CBPeripheral, index: Int) {
        guard let char = imgCtrlChar else { return }
        var data = Data([0x03])
        data.append(contentsOf: withUnsafeBytes(of: UInt16(index).littleEndian) { Array($0) })
        peripheral.writeValue(data, for: char, type: .withResponse)
    }
}

class ImageReceiver {
    var imageInfo: ImageInfo?
    var receivedChunks = [Int: Data]()

    func onImageInfoReceived(_ data: Data) {
        imageInfo = ImageInfo(data: data)
        receivedChunks.removeAll()
    }

    func onChunkReceived(_ data: Data) -> Float {
        let chunkIndex = Int(data[0]) | (Int(data[1]) << 8)
        let chunkSize = Int(data[2]) | (Int(data[3]) << 8)
        let chunkData = data.subdata(in: 4..<(4 + chunkSize))
        receivedChunks[chunkIndex] = chunkData

        return Float(receivedChunks.count) / Float(imageInfo?.chunkCount ?? 1)
    }

    var isComplete: Bool {
        guard let info = imageInfo else { return false }
        return receivedChunks.count == info.chunkCount
    }

    func assembleImage() -> Data? {
        guard let info = imageInfo, isComplete else { return nil }
        var imageData = Data()
        for i in 0..<info.chunkCount {
            if let chunk = receivedChunks[i] {
                imageData.append(chunk)
            }
        }
        return imageData
    }
}

make -C apps/bluetooth/ble/ipro_ble_remote DEFCONFIG=defconfig_reef
# -> build_reef/build_out/ipro_ble_remote_IPRO7.bin

# --chip-variant IPRO7AI：Reef（QFN56）的 flash pin。工具失敗時也回傳 0，請看輸出有沒有 [All Success]
ipro_iot_tool_macos --chipname ipro7 --chip-variant IPRO7AI --port /dev/cu.usbmodemXXXX --baudrate 921600 \
    --boot2 <IntelProCube>/chips/ipro7/builtin_imgs/boot2_v0.6.0/ipro_boot2_IPRO7_v0.6.0.bin \
    --pt apps/bluetooth/ble/ipro_ble_remote/partition_cfg_2M_remote_ab.toml \
    --firmware apps/bluetooth/ble/ipro_ble_remote/build_reef/build_out/ipro_ble_remote_IPRO7.bin

# 產生套件（需要 IntelProCube 命令列工具：IPRO_FLASH_TOOL 指向它，或放在 PATH 裡；
# boot2 自動用工具內最高版本，0.7.x 為 v0.6.0，要指定其他版本設 IPRO_BOOT2）
IPRO_FLASH_TOOL=<IntelProCube>/ipro_iot_tool_macos sh apps/bluetooth/ble/ipro_ble_remote/tools/make_reef_ota.sh
# -> build_reef/build_out/ipro_ble_remote_reef.xz.ota（約 345 KB）

# Mac 上用 bleak 推送（python3 -m venv .venv && .venv/bin/pip install bleak）
.venv/bin/python apps/bluetooth/ble/ipro_ble_remote/tools/reef_ota.py build_reef/build_out/ipro_ble_remote_reef.xz.ota

./build_freertos.sh ipro_ble_remote build

+------------------+     BLE GATT      +------------------+
|   手機 App       | <--------------> |  IPRO7 開發板     |
|   (Android/iOS)  |                   |                  |
+------------------+                   +------------------+
       |                                      |
       | Write LED State                      | LED GPIO
       | Read Temperature                     | Temp Sensor
       | Enable Notification                  | Button GPIO
       | Send UART Data                       | UART Console
       | Receive PIR Events                   | PIR Sensor GPIO
       | Receive Image Chunks                 | Camera / Simulated
       |                                      |

apps/bluetooth/ble/ipro_ble_remote/
├── README.md                      # 本文件
├── OTA_IMPLEMENTATION_GUIDE.md     # OTA 實作指南 (給 APP Team)
├── CMakeLists.txt                 # 編譯設定
├── Kconfig                        # 配置選項
├── .config                      # 專案配置
├── main.c                         # 主程式入口
├── build/                         # 編譯輸出
├── src/                           # 源代碼目录
│   ├── app/                       # 應用層
│   │   ├── remote_app.c          # 應用邏輯
│   │   └── remote_cli.c          # CLI 命令
│   ├── services/                  # BLE 服務層
│   │   ├── remote_services.c     # 基礎服務 (LED/Button/Env/UART)
│   │   ├── pir_image_service.c   # PIR + 圖片傳輸服務
│   │   └── ota_service.c         # OTA 韌體更新服務
│   └── data/                      # 數據文件
│       ├── pic_array.h           # 圖片數據 1
│       ├── pic_cat_array.h       # 圖片數據 2
│       └── pic_cat_2_array.h     # 圖片數據 3
└── include/                       # 公共標頭文件
    ├── remote_app.h               # 應用標頭
    ├── remote_services.h          # 服務標頭
    ├── pir_image_service.h        # PIR 服務標頭
    └── ota_service.h              # OTA 服務標頭

# 從 SDK 根目录編譯
cd /path/to/ipro_sdk
./build_freertos.sh ipro_ble_remote build

# 編譯輸出位置
apps/bluetooth/ble/ipro_ble_remote/build/build_out/ipro_ble_remote_IPRO7.elf