数熵 ED-ble

数熵ED-N2-RS485

data_bits:  5=0x05  6=0x06  7=0x07  8=0x08
stop_bits:  1位=0x00  1.5位=0x01  2位=0x02
parity:     None=0x00  Odd=0x01  Even=0x02  (3/4降级为None)

┌──────────┐   Write NUS RX     ┌──────────┐   RS485      ┌──────────┐
│  手机 APP │ ──────────────────→ │  ED-N2   │ ─────────→ │ RS485 从站│
│          │ ←────────────────── │  设备     │ ←───────── │          │
└──────────┘  Notify NUS TX      └──────────┘   RS485      └──────────┘

01 03 00 00 00 02 C4 0B

01 03 04 00 64 00 C8 BA 7A

baud_le32(4) + data_bits(1) + stop_bits(1) + parity(1) + reserved(1)

80 25 00 00  08  00  00  00
└─baud_le32┘ └db┘└sb┘└pr┘└rs┘

channel(1, 固定0x00) + baud_le32(4) + data_bits(1) + stop_bits(1) + parity(1) + reserved(1)

00  00 C2 01 00  08  00  00  00
└ch┘└─baud_le32┘ └db┘└sb┘└pr┘└rs┘

DTR(1) + RTS(1)

DTR(1) + RTS(1) + BreakCmd(1) + BreakDuration100ms(1)

status_mask(1) + frame_err_count(1) + parity_err_count(1) + overrun_err_count(1) + 00 + 00 + 00 + 00

// ===== 数熵ED-N2 BLE 常量定义 =====
const BLE_DEVICE_NAME = '数熵ED-N2-RS485'

// Nordic UART Service（RS485 数据透传）
const NUS_SERVICE_UUID = '6E400001-B5A3-F393-E0A9-E50E24DCCA9E'
const NUS_RX_CHAR_UUID = '6E400002-B5A3-F393-E0A9-E50E24DCCA9E' // 写入
const NUS_TX_CHAR_UUID = '6E400003-B5A3-F393-E0A9-E50E24DCCA9E' // 订阅 Notify

// Serial Config Service（RS485 串口配置）
const CFG_SERVICE_UUID     = '8E400001-B5A3-F393-E0A9-E50E24DCCA9E'
const CFG_UART_CONFIG_UUID = '8E400002-B5A3-F393-E0A9-E50E24DCCA9E' // 写入串口参数
const CFG_LINE_STATE_UUID  = '8E400003-B5A3-F393-E0A9-E50E24DCCA9E' // 写入线状态
const CFG_UART_STATUS_UUID = '8E400004-B5A3-F393-E0A9-E50E24DCCA9E' // 订阅状态

// Wi-Fi Provisioning Service（电池状态）
const WF_SERVICE_UUID = '9E400001-B5A3-F393-E0A9-E50E24DCCA9E'
const WF_STATUS_UUID  = '9E400003-B5A3-F393-E0A9-E50E24DCCA9E' // 读取电池

// RS485 通道
const CHANNEL_RS485 = 0x00

let deviceId = ''

// ===== 1. 初始化蓝牙适配器 =====
function initBLE() {
  return new Promise((resolve, reject) => {
    wx.openBluetoothAdapter({
      success: resolve,
      fail: reject
    })
  })
}

// ===== 2. 搜索并连接设备 =====
function scanAndConnect() {
  return new Promise((resolve, reject) => {
    wx.startBluetoothDevicesDiscovery({
      success: () => {
        wx.onBluetoothDeviceFound((res) => {
          const device = res.devices[0]
          if (device.name === BLE_DEVICE_NAME) {
            wx.stopBluetoothDevicesDiscovery()
            wx.createBLEConnection({
              deviceId: device.deviceId,
              success: () => {
                deviceId = device.deviceId
                console.log('已连接设备:', device.name)
                resolve(deviceId)
              },
              fail: reject
            })
          }
        })
      },
      fail: reject
    })
  })
}

// ===== 3. 配置 RS485 串口参数 =====
// baud=9600, data_bits=8, stop_bits=0(1位), parity=0(None)
function configRS485(baud = 9600, dataBits = 8, stopBits = 0, parity = 0) {
  // 8字节格式: baud_le32 + data_bits + stop_bits + parity + reserved
  const buffer = new ArrayBuffer(8)
  const view = new DataView(buffer)
  view.setUint32(0, baud, true)   // baud 小端序
  view.setUint8(4, dataBits)       // data_bits
  view.setUint8(5, stopBits)       // stop_bits
  view.setUint8(6, parity)         // parity
  view.setUint8(7, 0x00)           // reserved

  return new Promise((resolve, reject) => {
    wx.writeBLECharacteristicValue({
      deviceId,
      serviceId: CFG_SERVICE_UUID,
      characteristicId: CFG_UART_CONFIG_UUID,
      value: buffer,
      success: () => {
        const parityStr = ['N', 'O', 'E'][parity] || 'N'
        const stopStr = stopBits === 0 ? '1' : stopBits === 1 ? '1.5' : '2'
        console.log(`RS485 已配置: ${baud} ${dataBits}${parityStr}${stopStr}`)
        resolve()
      },
      fail: reject
    })
  })
}

// ===== 4. 订阅 NUS TX（接收 RS485 返回数据）=====
function subscribeNusTx(onData) {
  return new Promise((resolve, reject) => {
    wx.notifyBLECharacteristicValueChange({
      deviceId,
      serviceId: NUS_SERVICE_UUID,
      characteristicId: NUS_TX_CHAR_UUID,
      state: true,
      success: () => {
        wx.onBLECharacteristicValueChange((res) => {
          if (res.characteristicId === NUS_TX_CHAR_UUID) {
            onData(new Uint8Array(res.value))
          }
        })
        console.log('已订阅 NUS TX Notify')
        resolve()
      },
      fail: reject
    })
  })
}

// ===== 5. 发送数据到 RS485（写入 NUS RX）=====
function sendToRS485(bytes) {
  const buffer = new ArrayBuffer(bytes.length)
  const view = new Uint8Array(buffer)
  for (let i = 0; i < bytes.length; i++) {
    view[i] = bytes[i]
  }

  return new Promise((resolve, reject) => {
    wx.writeBLECharacteristicValue({
      deviceId,
      serviceId: NUS_SERVICE_UUID,
      characteristicId: NUS_RX_CHAR_UUID,
      value: buffer,
      success: resolve,
      fail: reject
    })
  })
}

// ===== 6. 读取电池状态 =====
function readBatteryStatus() {
  return new Promise((resolve, reject) => {
    wx.readBLECharacteristicValue({
      deviceId,
      serviceId: WF_SERVICE_UUID,
      characteristicId: WF_STATUS_UUID,
      success: () => {
        wx.onBLECharacteristicValueChange((res) => {
          if (res.characteristicId === WF_STATUS_UUID) {
            const text = arrayBufferToUtf8(res.value)
            resolve(parseStatusText(text))
          }
        })
      },
      fail: reject
    })
  })
}

// ===== 工具函数 =====
function arrayBufferToUtf8(buffer) {
  return decodeURIComponent(escape(String.fromCharCode(...new Uint8Array(buffer))))
}

function parseStatusText(text) {
  const result = {}
  text.split(';').forEach(pair => {
    const [key, val] = pair.split('=')
    result[key] = val
  })
  return result
}

// ===== 完整调用示例 =====
async function demo() {
  try {
    await initBLE()
    await scanAndConnect()

    // 配置 RS485: 9600 8N1
    await configRS485(9600, 8, 0, 0)

    // 订阅接收 RS485 返回数据
    await subscribeNusTx((data) => {
      const hex = Array.from(data).map(b => b.toString(16).padStart(2, '0')).join(' ')
      console.log('RS485 返回:', hex)
    })

    // 发送 Modbus RTU: 读保持寄存器 从站01 起始地址0 数量2
    await sendToRS485([0x01, 0x03, 0x00, 0x00, 0x00, 0x02, 0xC4, 0x0B])

    // 读取电池
    const battery = await readBatteryStatus()
    console.log('电池:', battery.BAT_P + '%', battery.BAT_V + 'V')
  } catch (err) {
    console.error('操作失败:', err)
  }
}

import android.bluetooth.BluetoothGatt
import android.bluetooth.BluetoothGattCharacteristic
import android.bluetooth.BluetoothGattDescriptor
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.util.UUID

class EdN2BLE {

    companion object {
        const val DEVICE_NAME = "数熵ED-Slink"

        // Nordic UART Service（RS485 数据透传）
        val NUS_SERVICE_UUID     = UUID.fromString("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
        val NUS_RX_CHAR_UUID     = UUID.fromString("6E400002-B5A3-F393-E0A9-E50E24DCCA9E") // Write
        val NUS_TX_CHAR_UUID     = UUID.fromString("6E400003-B5A3-F393-E0A9-E50E24DCCA9E") // Notify

        // Serial Config Service（RS485 串口配置）
        val CFG_SERVICE_UUID     = UUID.fromString("8E400001-B5A3-F393-E0A9-E50E24DCCA9E")
        val CFG_UART_CONFIG_UUID = UUID.fromString("8E400002-B5A3-F393-E0A9-E50E24DCCA9E") // Write
        val CFG_UART_STATUS_UUID = UUID.fromString("8E400004-B5A3-F393-E0A9-E50E24DCCA9E") // Notify

        // Wi-Fi Provisioning Service（电池状态）
        val WF_SERVICE_UUID      = UUID.fromString("9E400001-B5A3-F393-E0A9-E50E24DCCA9E")
        val WF_STATUS_UUID       = UUID.fromString("9E400003-B5A3-F393-E0A9-E50E24DCCA9E") // Read/Notify

        // CCCD Descriptor（启用 Notify）
        val CCCD_UUID            = UUID.fromString("00002902-0000-1000-8000-00805F9B34FB")
    }

    private var gatt: BluetoothGatt? = null
    private var onDataReceived: ((ByteArray) -> Unit)? = null

    /**
     * 配置 RS485 串口参数（8字节格式）
     * @param baud 波特率，如 9600
     * @param dataBits 数据位 5/6/7/8
     * @param stopBits 停止位 0=1位, 1=1.5位, 2=2位
     * @param parity 校验位 0=None, 1=Odd, 2=Even
     */
    fun configRS485(baud: Int, dataBits: Int = 8, stopBits: Int = 0, parity: Int = 0) {
        val buffer = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN)
        buffer.putInt(baud)                // baud (小端序)
        buffer.put(dataBits.toByte())      // data_bits
        buffer.put(stopBits.toByte())      // stop_bits
        buffer.put(parity.toByte())        // parity
        buffer.put(0x00)                   // reserved

        writeCharacteristic(CFG_UART_CONFIG_UUID, buffer.array(), CFG_SERVICE_UUID)
    }

    /**
     * 发送数据到 RS485（通过 NUS RX 写入）
     */
    fun sendToRS485(data: ByteArray) {
        writeCharacteristic(NUS_RX_CHAR_UUID, data, NUS_SERVICE_UUID)
    }

    /**
     * 订阅 NUS TX Notify（接收 RS485 返回数据）
     */
    fun subscribeNusTx(callback: (ByteArray) -> Unit) {
        onDataReceived = callback
        enableNotify(NUS_TX_CHAR_UUID, NUS_SERVICE_UUID)
    }

    /**
     * 发送 Modbus RTU 读保持寄存器请求
     * @param slaveAddr 从站地址
     * @param startAddr 起始寄存器地址
     * @param quantity 寄存器数量
     */
    fun sendModbusReadHoldingRegisters(slaveAddr: Int, startAddr: Int, quantity: Int) {
        val frame = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN)
        frame.put(slaveAddr.toByte())          // 从站地址
        frame.put(0x03)                         // 功能码: 读保持寄存器
        frame.putShort(startAddr.toShort())     // 起始地址
        frame.putShort(quantity.toShort())       // 寄存器数量

        // 计算 Modbus CRC16
        val crc = calculateCRC16(frame.array(), 6)
        frame.putShort(crc.toShort())

        sendToRS485(frame.array())
    }

    private fun writeCharacteristic(uuid: UUID, data: ByteArray, serviceUuid: UUID) {
        val service = gatt?.getService(serviceUuid) ?: return
        val char = service.getCharacteristic(uuid) ?: return
        char.value = data
        char.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
        gatt?.writeCharacteristic(char)
    }

    private fun enableNotify(uuid: UUID, serviceUuid: UUID) {
        val service = gatt?.getService(serviceUuid) ?: return
        val char = service.getCharacteristic(uuid) ?: return
        gatt?.setCharacteristicNotification(char, true)
        val descriptor = char.getDescriptor(CCCD_UUID)
        descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
        gatt?.writeDescriptor(descriptor)
    }

    /**
     * Modbus CRC16 计算
     */
    private fun calculateCRC16(data: ByteArray, length: Int): Int {
        var crc = 0xFFFF
        for (i in 0 until length) {
            crc = crc xor (data[i].toInt() and 0xFF)
            for (j in 0 until 8) {
                crc = if (crc and 0x0001 != 0) (crc shr 1) xor 0xA001 else crc shr 1
            }
        }
        return crc
    }
}

"""
数熵ED-N2 便携调试器 BLE 二次开发示例（Python + bleak）
依赖: pip install bleak
"""
import asyncio
import struct
from bleak import BleakClient, BleakScanner

# ===== BLE 常量定义 =====
DEVICE_NAME = "数熵ED-N2-RS485"

# Nordic UART Service（RS485 数据透传）
NUS_SERVICE_UUID     = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
NUS_RX_CHAR_UUID     = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"  # Write
NUS_TX_CHAR_UUID     = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"  # Notify

# Serial Config Service（RS485 串口配置）
CFG_SERVICE_UUID     = "8E400001-B5A3-F393-E0A9-E50E24DCCA9E"
CFG_UART_CONFIG_UUID = "8E400002-B5A3-F393-E0A9-E50E24DCCA9E"  # Write
CFG_LINE_STATE_UUID  = "8E400003-B5A3-F393-E0A9-E50E24DCCA9E"  # Write
CFG_UART_STATUS_UUID = "8E400004-B5A3-F393-E0A9-E50E24DCCA9E"  # Notify

# Wi-Fi Provisioning Service（电池状态）
WF_SERVICE_UUID      = "9E400001-B5A3-F393-E0A9-E50E24DCCA9E"
WF_STATUS_UUID       = "9E400003-B5A3-F393-E0A9-E50E24DCCA9E"  # Read/Notify


# ===== Modbus CRC16 计算 =====
def crc16(data: bytes) -> int:
    crc = 0xFFFF
    for byte in data:
        crc ^= byte
        for _ in range(8):
            crc = (crc >> 1) ^ 0xA001 if (crc & 0x0001) else (crc >> 1)
    return crc


# ===== 构造 RS485 串口配置命令（8字节格式）=====
def build_uart_config(baud: int, data_bits: int = 8,
                      stop_bits: int = 0, parity: int = 0) -> bytes:
    """
    构造 RS485 串口配置字节
    baud:      1200~2000000
    data_bits: 5/6/7/8
    stop_bits: 0=1位, 1=1.5位, 2=2位
    parity:    0=None, 1=Odd, 2=Even
    """
    return struct.pack('<IBBBB', baud, data_bits, stop_bits, parity, 0x00)


# ===== 构造 Modbus RTU 读保持寄存器请求 =====
def build_modbus_read_holding(slave: int, start_addr: int, quantity: int) -> bytes:
    """构造 Modbus RTU 功能码 03 请求帧"""
    frame = struct.pack('>BBHH', slave, 0x03, start_addr, quantity)
    crc = crc16(frame)
    return frame + struct.pack('<H', crc)


class EdN2BLE:
    """数熵ED-N2 BLE 设备封装"""

    def __init__(self, address: str = None):
        self.address = address
        self.client = None

    async def scan(self) -> str:
        """扫描设备，返回地址"""
        print(f"正在搜索 {DEVICE_NAME} ...")
        device = await BleakScanner.find_device_by_name(DEVICE_NAME)
        if device:
            self.address = device.address
            print(f"找到设备: {device.name} ({device.address})")
            return device.address
        raise FileNotFoundError(f"未找到设备 {DEVICE_NAME}")

    async def connect(self):
        """连接设备"""
        if not self.address:
            await self.scan()
        self.client = BleakClient(self.address)
        await self.client.connect()
        print(f"已连接: {self.address}")
        # 订阅 NUS TX Notify（接收 RS485 返回数据）
        await self.client.start_notify(NUS_TX_CHAR_UUID, self._on_nus_tx)

    async def disconnect(self):
        """断开连接"""
        if self.client and self.client.is_connected:
            await self.client.disconnect()
            print("已断开")

    def _on_nus_tx(self, sender, data: bytearray):
        """NUS TX Notify 回调：接收 RS485 返回数据"""
        hex_str = ' '.join(f'{b:02X}' for b in data)
        print(f"[RX] {hex_str}")

    async def config_rs485(self, baud: int = 9600, data_bits: int = 8,
                           stop_bits: int = 0, parity: int = 0):
        """配置 RS485 串口参数"""
        payload = build_uart_config(baud, data_bits, stop_bits, parity)
        await self.client.write_gatt_char(CFG_UART_CONFIG_UUID, payload, response=False)
        parity_str = ['N', 'O', 'E'][parity] if parity < 3 else 'N'
        stop_str = str(stop_bits) if stop_bits != 1 else '1.5'
        print(f"[CFG] RS485: {baud} {data_bits}{parity_str}{stop_str}")

    async def send_to_rs485(self, data: bytes):
        """发送数据到 RS485"""
        await self.client.write_gatt_char(NUS_RX_CHAR_UUID, data, response=False)
        hex_str = ' '.join(f'{b:02X}' for b in data)
        print(f"[TX] {hex_str}")

    async def send_modbus_read(self, slave: int = 1, start_addr: int = 0, quantity: int = 2):
        """发送 Modbus RTU 读保持寄存器请求"""
        frame = build_modbus_read_holding(slave, start_addr, quantity)
        await self.send_to_rs485(frame)

    async def read_battery_status(self) -> dict:
        """读取电池/设备状态"""
        data = await self.client.read_gatt_char(WF_STATUS_UUID)
        text = data.decode('utf-8')
        return self._parse_status(text)

    @staticmethod
    def _parse_status(text: str) -> dict:
        """解析状态文本 V=1;BAT_V=3.987;..."""
        result = {}
        for pair in text.split(';'):
            if '=' in pair:
                key, val = pair.split('=', 1)
                result[key] = val
        return result


# ===== 完整使用示例 =====
async def main():
    ed = EdN2BLE()
    try:
        # 1. 连接设备
        await ed.connect()

        # 2. 配置 RS485: 9600 8N1
        await ed.config_rs485(baud=9600, data_bits=8, stop_bits=0, parity=0)

        # 3. 读取电池状态
        status = await ed.read_battery_status()
        print(f"电池: {status.get('BAT_P', '?')}%  {status.get('BAT_V', '?')}V  充电:{status.get('BAT_CHG', '0')}")

        # 4. 发送 Modbus RTU 请求并等待响应
        #    从站地址=1, 功能码=03(读保持寄存器), 起始地址=0, 数量=2
        await ed.send_modbus_read(slave=1, start_addr=0, quantity=2)

        # 5. 等待 RS485 返回数据（NUS TX Notify 自动回调打印）
        await asyncio.sleep(2)
    finally:
        await ed.disconnect()


if __name__ == "__main__":
    asyncio.run(main())

// ===== 数熵ED-N2 BLE 常量 =====
const NUS_SERVICE_UUID     = '6e400001-b5a3-f393-e0a9-e50e24dcca9e'
const NUS_RX_CHAR_UUID     = '6e400002-b5a3-f393-e0a9-e50e24dcca9e' // Write
const NUS_TX_CHAR_UUID     = '6e400003-b5a3-f393-e0a9-e50e24dcca9e' // Notify
const CFG_SERVICE_UUID     = '8e400001-b5a3-f393-e0a9-e50e24dcca9e'
const CFG_UART_CONFIG_UUID = '8e400002-b5a3-f393-e0a9-e50e24dcca9e' // Write

let characteristicRx = null  // NUS RX（写入）
let characteristicTx = null  // NUS TX（Notify）
let characteristicCfg = null // UART Config（写入）

// ===== 连接设备 =====
async function connect() {
  const device = await navigator.bluetooth.requestDevice({
    filters: [{ name: '数熵ED-Slink' }],
    optionalServices: [NUS_SERVICE_UUID, CFG_SERVICE_UUID]
  })

  const server = await device.gatt.connect()

  // 获取 NUS 服务（数据透传）
  const nusService = await server.getPrimaryService(NUS_SERVICE_UUID)
  characteristicRx = await nusService.getCharacteristic(NUS_RX_CHAR_UUID)
  characteristicTx = await nusService.getCharacteristic(NUS_TX_CHAR_UUID)

  // 订阅 NUS TX Notify（接收 RS485 返回数据）
  await characteristicTx.startNotifications()
  characteristicTx.addEventListener('characteristicvaluechanged', (event) => {
    const data = new Uint8Array(event.target.value.buffer)
    const hex = Array.from(data).map(b => b.toString(16).padStart(2, '0')).join(' ')
    console.log('[RX]', hex)
  })

  // 获取 Config 服务（串口配置）
  const cfgService = await server.getPrimaryService(CFG_SERVICE_UUID)
  characteristicCfg = await cfgService.getCharacteristic(CFG_UART_CONFIG_UUID)

  console.log('设备已连接')
}

// ===== 配置 RS485 串口参数（8字节格式）=====
function configRS485(baud = 9600, dataBits = 8, stopBits = 0, parity = 0) {
  const buffer = new ArrayBuffer(8)
  const view = new DataView(buffer)
  view.setUint32(0, baud, true)  // baud 小端序
  view.setUint8(4, dataBits)
  view.setUint8(5, stopBits)
  view.setUint8(6, parity)
  view.setUint8(7, 0x00)
  return characteristicCfg.writeValueWithoutResponse(buffer)
}

// ===== 发送数据到 RS485 =====
function sendToRS485(bytes) {
  const buffer = new Uint8Array(bytes).buffer
  return characteristicRx.writeValueWithoutResponse(buffer)
}

// ===== Modbus CRC16 =====
function crc16(data) {
  let crc = 0xFFFF
  for (const byte of data) {
    crc ^= byte
    for (let i = 0; i < 8; i++) {
      crc = (crc & 0x0001) ? ((crc >> 1) ^ 0xA001) : (crc >> 1)
    }
  }
  return crc
}

// ===== 完整示例 =====
async function demo() {
  await connect()
  await configRS485(9600, 8, 0, 0)

  // Modbus RTU: 读保持寄存器 从站01 地址0 数量2
  const frame = [0x01, 0x03, 0x00, 0x00, 0x00, 0x02]
  const crc = crc16(frame)
  frame.push(crc & 0xFF, (crc >> 8) & 0xFF)
  await sendToRS485(frame)
}

baud:      1200 / 2400 / 4800 / 9600 / 19200 / 38400 / 57600 / 115200 / 230400 ...
data_bits: 5 / 6 / 7 / 8
stop_bits: 0(1位) / 1(1.5位) / 2(2位)
parity:    0(None) / 1(Odd) / 2(Even)