mirror of https://github.com/meshcore-dev/MeshCore
Chris Davis
6 months ago
committed by
GitHub
GitHub
160 changed files with 6536 additions and 1791 deletions
@ -0,0 +1,44 @@ |
|||
{ |
|||
"name": "MeshCore", |
|||
"image": "mcr.microsoft.com/devcontainers/python:3-bookworm", |
|||
"features": { |
|||
"ghcr.io/rocker-org/devcontainer-features/apt-packages:1": { |
|||
"packages": [ |
|||
"sudo" |
|||
] |
|||
} |
|||
}, |
|||
"runArgs": [ |
|||
"--privileged", |
|||
// arch tty* is owned by uucp (986) |
|||
// debian tty* is owned by uucp (20) - no change needed |
|||
"--group-add=986", |
|||
"--network=host", |
|||
"--volume=/dev/bus/usb:/dev/bus/usb:ro" |
|||
], |
|||
"postCreateCommand": { |
|||
"platformio": "pipx install platformio" |
|||
}, |
|||
"customizations": { |
|||
"vscode": { |
|||
"settings": { |
|||
"platformio-ide.disablePIOHomeStartup": true, |
|||
"editor.formatOnSave": false, |
|||
"workbench.colorCustomizations": { |
|||
"titleBar.activeBackground": "#0d1a2b", |
|||
"titleBar.activeForeground": "#ffffff", |
|||
"titleBar.inactiveBackground": "#0d1a2b99", |
|||
"titleBar.inactiveForeground": "#ffffff99" |
|||
} |
|||
}, |
|||
"extensions": [ |
|||
"platformio.platformio-ide", |
|||
"github.vscode-github-actions", |
|||
"GitHub.vscode-pull-request-github" |
|||
], |
|||
"unwantedRecommendations": [ |
|||
"ms-vscode.cpptools-extension-pack" |
|||
] |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,198 @@ |
|||
""" |
|||
Bluefruit BLE Patch Script |
|||
|
|||
Patches Bluefruit library to fix semaphore leak bug that causes device lockup |
|||
when BLE central disconnects unexpectedly (e.g., going out of range, supervision timeout). |
|||
|
|||
Patches applied: |
|||
1. BLEConnection.h: Add _hvn_qsize member to track semaphore queue size |
|||
2. BLEConnection.cpp: Store hvn_qsize and restore semaphore on disconnect |
|||
|
|||
Bug description: |
|||
- When a BLE central disconnects unexpectedly (reason=8 supervision timeout), |
|||
the BLE_GATTS_EVT_HVN_TX_COMPLETE event may never fire |
|||
- This leaves the _hvn_sem counting semaphore in a decremented state |
|||
- Since BLEConnection objects are reused (destructor never called), the |
|||
semaphore count is never restored |
|||
- Eventually all semaphore counts are exhausted and notify() blocks/fails |
|||
|
|||
""" |
|||
|
|||
from pathlib import Path |
|||
|
|||
Import("env") # pylint: disable=undefined-variable |
|||
|
|||
|
|||
def _patch_ble_connection_header(source: Path) -> bool: |
|||
""" |
|||
Add _hvn_qsize member variable to BLEConnection class. |
|||
|
|||
This is needed to restore the semaphore to its correct count on disconnect. |
|||
|
|||
Returns True if patch was applied or already applied, False on error. |
|||
""" |
|||
try: |
|||
content = source.read_text() |
|||
|
|||
# Check if already patched |
|||
if "_hvn_qsize" in content: |
|||
return True # Already patched |
|||
|
|||
# Find the location to insert - after _phy declaration |
|||
original_pattern = ''' uint8_t _phy; |
|||
|
|||
uint8_t _role;''' |
|||
|
|||
patched_pattern = ''' uint8_t _phy; |
|||
uint8_t _hvn_qsize; |
|||
|
|||
uint8_t _role;''' |
|||
|
|||
if original_pattern not in content: |
|||
print("Bluefruit patch: WARNING - BLEConnection.h pattern not found") |
|||
return False |
|||
|
|||
content = content.replace(original_pattern, patched_pattern) |
|||
source.write_text(content) |
|||
|
|||
# Verify |
|||
if "_hvn_qsize" not in source.read_text(): |
|||
return False |
|||
|
|||
return True |
|||
except Exception as e: |
|||
print(f"Bluefruit patch: ERROR patching BLEConnection.h: {e}") |
|||
return False |
|||
|
|||
|
|||
def _patch_ble_connection_source(source: Path) -> bool: |
|||
""" |
|||
Patch BLEConnection.cpp to: |
|||
1. Store hvn_qsize in constructor |
|||
2. Restore _hvn_sem semaphore to full count on disconnect |
|||
|
|||
Returns True if patch was applied or already applied, False on error. |
|||
""" |
|||
try: |
|||
content = source.read_text() |
|||
|
|||
# Check if already patched (look for the restore loop) |
|||
if "uxSemaphoreGetCount(_hvn_sem)" in content: |
|||
return True # Already patched |
|||
|
|||
# Patch 1: Store queue size in constructor |
|||
constructor_original = ''' _hvn_sem = xSemaphoreCreateCounting(hvn_qsize, hvn_qsize);''' |
|||
|
|||
constructor_patched = ''' _hvn_qsize = hvn_qsize; |
|||
_hvn_sem = xSemaphoreCreateCounting(hvn_qsize, hvn_qsize);''' |
|||
|
|||
if constructor_original not in content: |
|||
print("Bluefruit patch: WARNING - BLEConnection.cpp constructor pattern not found") |
|||
return False |
|||
|
|||
content = content.replace(constructor_original, constructor_patched) |
|||
|
|||
# Patch 2: Restore semaphore on disconnect |
|||
disconnect_original = ''' case BLE_GAP_EVT_DISCONNECTED: |
|||
// mark as disconnected |
|||
_connected = false; |
|||
break;''' |
|||
|
|||
disconnect_patched = ''' case BLE_GAP_EVT_DISCONNECTED: |
|||
// Restore notification semaphore to full count |
|||
// This fixes lockup when disconnect occurs with notifications in flight |
|||
while (uxSemaphoreGetCount(_hvn_sem) < _hvn_qsize) { |
|||
xSemaphoreGive(_hvn_sem); |
|||
} |
|||
// Release indication semaphore if waiting |
|||
if (_hvc_sem) { |
|||
_hvc_received = false; |
|||
xSemaphoreGive(_hvc_sem); |
|||
} |
|||
// mark as disconnected |
|||
_connected = false; |
|||
break;''' |
|||
|
|||
if disconnect_original not in content: |
|||
print("Bluefruit patch: WARNING - BLEConnection.cpp disconnect pattern not found") |
|||
return False |
|||
|
|||
content = content.replace(disconnect_original, disconnect_patched) |
|||
source.write_text(content) |
|||
|
|||
# Verify |
|||
verify_content = source.read_text() |
|||
if "uxSemaphoreGetCount(_hvn_sem)" not in verify_content: |
|||
return False |
|||
if "_hvn_qsize = hvn_qsize" not in verify_content: |
|||
return False |
|||
|
|||
return True |
|||
except Exception as e: |
|||
print(f"Bluefruit patch: ERROR patching BLEConnection.cpp: {e}") |
|||
return False |
|||
|
|||
|
|||
def _apply_bluefruit_patches(target, source, env): # pylint: disable=unused-argument |
|||
framework_path = env.get("PLATFORMFW_DIR") |
|||
if not framework_path: |
|||
framework_path = env.PioPlatform().get_package_dir("framework-arduinoadafruitnrf52") |
|||
|
|||
if not framework_path: |
|||
print("Bluefruit patch: ERROR - framework directory not found") |
|||
env.Exit(1) |
|||
return |
|||
|
|||
framework_dir = Path(framework_path) |
|||
bluefruit_lib = framework_dir / "libraries" / "Bluefruit52Lib" / "src" |
|||
patch_failed = False |
|||
|
|||
# Patch BLEConnection.h |
|||
conn_header = bluefruit_lib / "BLEConnection.h" |
|||
if conn_header.exists(): |
|||
before = conn_header.read_text() |
|||
success = _patch_ble_connection_header(conn_header) |
|||
after = conn_header.read_text() |
|||
|
|||
if success: |
|||
if before != after: |
|||
print("Bluefruit patch: OK - Applied BLEConnection.h fix (added _hvn_qsize member)") |
|||
else: |
|||
print("Bluefruit patch: OK - BLEConnection.h already patched") |
|||
else: |
|||
print("Bluefruit patch: FAILED - BLEConnection.h") |
|||
patch_failed = True |
|||
else: |
|||
print(f"Bluefruit patch: ERROR - BLEConnection.h not found at {conn_header}") |
|||
patch_failed = True |
|||
|
|||
# Patch BLEConnection.cpp |
|||
conn_source = bluefruit_lib / "BLEConnection.cpp" |
|||
if conn_source.exists(): |
|||
before = conn_source.read_text() |
|||
success = _patch_ble_connection_source(conn_source) |
|||
after = conn_source.read_text() |
|||
|
|||
if success: |
|||
if before != after: |
|||
print("Bluefruit patch: OK - Applied BLEConnection.cpp fix (restore semaphore on disconnect)") |
|||
else: |
|||
print("Bluefruit patch: OK - BLEConnection.cpp already patched") |
|||
else: |
|||
print("Bluefruit patch: FAILED - BLEConnection.cpp") |
|||
patch_failed = True |
|||
else: |
|||
print(f"Bluefruit patch: ERROR - BLEConnection.cpp not found at {conn_source}") |
|||
patch_failed = True |
|||
|
|||
if patch_failed: |
|||
print("Bluefruit patch: CRITICAL - Patch failed! Build aborted.") |
|||
env.Exit(1) |
|||
|
|||
|
|||
# Register the patch to run before build |
|||
bluefruit_action = env.VerboseAction(_apply_bluefruit_patches, "Applying Bluefruit BLE patches...") |
|||
env.AddPreAction("$BUILD_DIR/${PROGNAME}.elf", bluefruit_action) |
|||
|
|||
# Also run immediately to patch before any compilation |
|||
_apply_bluefruit_patches(None, None, env) |
|||
@ -0,0 +1,40 @@ |
|||
{ |
|||
"build": { |
|||
"arduino": { |
|||
"ldscript": "esp32s3_out.ld" |
|||
}, |
|||
"core": "esp32", |
|||
"extra_flags": [ |
|||
"-D ARDUINO_USB_CDC_ON_BOOT=1", |
|||
"-D ARDUINO_USB_MSC_ON_BOOT=0", |
|||
"-D ARDUINO_USB_DFU_ON_BOOT=0", |
|||
"-D ARDUINO_USB_MODE=1", |
|||
"-D ARDUINO_RUNNING_CORE=1", |
|||
"-D ARDUINO_EVENT_RUNNING_CORE=1" |
|||
], |
|||
"f_cpu": "240000000L", |
|||
"f_flash": "80000000L", |
|||
"flash_mode": "qio", |
|||
"hwids": [["0x303A", "0x1001"]], |
|||
"mcu": "esp32s3", |
|||
"variant": "esp32s3" |
|||
}, |
|||
"connectivity": ["wifi", "bluetooth"], |
|||
"debug": { |
|||
"default_tool": "esp-builtin", |
|||
"onboard_tools": ["esp-builtin"], |
|||
"openocd_target": "esp32s3.cfg" |
|||
}, |
|||
"frameworks": ["arduino", "espidf"], |
|||
"name": "ESP32-S3-Zero", |
|||
"upload": { |
|||
"flash_size": "4MB", |
|||
"maximum_ram_size": 327680, |
|||
"maximum_size": 4194304, |
|||
"require_upload_port": true, |
|||
"speed": 921600 |
|||
}, |
|||
"url": "https://www.espressif.com", |
|||
"vendor": "Espressif" |
|||
} |
|||
|
|||
@ -0,0 +1,72 @@ |
|||
{ |
|||
"build": { |
|||
"arduino": { |
|||
"ldscript": "nrf52840_s140_v6.ld" |
|||
}, |
|||
"core": "nRF5", |
|||
"cpu": "cortex-m4", |
|||
"extra_flags": "-DNRF52840_XXAA", |
|||
"f_cpu": "64000000L", |
|||
"hwids": [ |
|||
[ |
|||
"0x239A", |
|||
"0x4405" |
|||
], |
|||
[ |
|||
"0x239A", |
|||
"0x0029" |
|||
], |
|||
[ |
|||
"0x239A", |
|||
"0x002A" |
|||
] |
|||
], |
|||
"usb_product": "elecrow_eink", |
|||
"mcu": "nrf52840", |
|||
"variant": "ELECROW-ThinkNode-M3", |
|||
"bsp": { |
|||
"name": "adafruit" |
|||
}, |
|||
"softdevice": { |
|||
"sd_flags": "-DS140", |
|||
"sd_name": "s140", |
|||
"sd_version": "6.1.1", |
|||
"sd_fwid": "0x00B6" |
|||
}, |
|||
"bootloader": { |
|||
"settings_addr": "0xFF000" |
|||
} |
|||
}, |
|||
"connectivity": [ |
|||
"bluetooth" |
|||
], |
|||
"debug": { |
|||
"jlink_device": "nRF52840_xxAA", |
|||
"onboard_tools": [ |
|||
"jlink" |
|||
], |
|||
"svd_path": "nrf52840.svd", |
|||
"openocd_target": "nrf52.cfg" |
|||
}, |
|||
"frameworks": [ |
|||
"arduino" |
|||
], |
|||
"name": "elecrow nrf", |
|||
"upload": { |
|||
"maximum_ram_size": 248832, |
|||
"maximum_size": 815104, |
|||
"speed": 115200, |
|||
"use_1200bps_touch": true, |
|||
"require_upload_port": true, |
|||
"wait_for_upload_port": true, |
|||
"protocol": "nrfutil", |
|||
"protocols": [ |
|||
"jlink", |
|||
"nrfjprog", |
|||
"nrfutil", |
|||
"stlink" |
|||
] |
|||
}, |
|||
"url": "https://github.com/Elecrow-RD", |
|||
"vendor": "ELECROW" |
|||
} |
|||
@ -0,0 +1,72 @@ |
|||
{ |
|||
"build": { |
|||
"arduino": { |
|||
"ldscript": "nrf52840_s140_v6.ld" |
|||
}, |
|||
"core": "nRF5", |
|||
"cpu": "cortex-m4", |
|||
"extra_flags": "-DARDUINO_NRF52840_ELECROW_M6 -DNRF52840_XXAA", |
|||
"f_cpu": "64000000L", |
|||
"hwids": [ |
|||
[ |
|||
"0x239A", |
|||
"0x4405" |
|||
], |
|||
[ |
|||
"0x239A", |
|||
"0x0029" |
|||
], |
|||
[ |
|||
"0x239A", |
|||
"0x002A" |
|||
] |
|||
], |
|||
"usb_product": "elecrow_solar", |
|||
"mcu": "nrf52840", |
|||
"variant": "ELECROW-ThinkNode-M6", |
|||
"bsp": { |
|||
"name": "adafruit" |
|||
}, |
|||
"softdevice": { |
|||
"sd_flags": "-DS140", |
|||
"sd_name": "s140", |
|||
"sd_version": "6.1.1", |
|||
"sd_fwid": "0x00B6" |
|||
}, |
|||
"bootloader": { |
|||
"settings_addr": "0xFF000" |
|||
} |
|||
}, |
|||
"connectivity": [ |
|||
"bluetooth" |
|||
], |
|||
"debug": { |
|||
"jlink_device": "nRF52840_xxAA", |
|||
"onboard_tools": [ |
|||
"jlink" |
|||
], |
|||
"svd_path": "nrf52840.svd", |
|||
"openocd_target": "nrf52.cfg" |
|||
}, |
|||
"frameworks": [ |
|||
"arduino" |
|||
], |
|||
"name": "elecrow solar", |
|||
"upload": { |
|||
"maximum_ram_size": 248832, |
|||
"maximum_size": 815104, |
|||
"speed": 115200, |
|||
"use_1200bps_touch": true, |
|||
"require_upload_port": true, |
|||
"wait_for_upload_port": true, |
|||
"protocol": "nrfutil", |
|||
"protocols": [ |
|||
"jlink", |
|||
"nrfjprog", |
|||
"nrfutil", |
|||
"stlink" |
|||
] |
|||
}, |
|||
"url": "https://github.com/Elecrow-RD", |
|||
"vendor": "ELECROW" |
|||
} |
|||
File diff suppressed because it is too large
@ -0,0 +1,312 @@ |
|||
# Stats Binary Frame Structures |
|||
|
|||
Binary frame structures for companion radio stats commands. All multi-byte integers use little-endian byte order. |
|||
|
|||
## Command Codes |
|||
|
|||
| Command | Code | Description | |
|||
|---------|------|-------------| |
|||
| `CMD_GET_STATS` | 56 | Get statistics (2-byte command: code + sub-type) | |
|||
|
|||
### Stats Sub-Types |
|||
|
|||
The `CMD_GET_STATS` command uses a 2-byte frame structure: |
|||
- **Byte 0:** `CMD_GET_STATS` (56) |
|||
- **Byte 1:** Stats sub-type: |
|||
- `STATS_TYPE_CORE` (0) - Get core device statistics |
|||
- `STATS_TYPE_RADIO` (1) - Get radio statistics |
|||
- `STATS_TYPE_PACKETS` (2) - Get packet statistics |
|||
|
|||
## Response Codes |
|||
|
|||
| Response | Code | Description | |
|||
|----------|------|-------------| |
|||
| `RESP_CODE_STATS` | 24 | Statistics response (2-byte response: code + sub-type) | |
|||
|
|||
### Stats Response Sub-Types |
|||
|
|||
The `RESP_CODE_STATS` response uses a 2-byte header structure: |
|||
- **Byte 0:** `RESP_CODE_STATS` (24) |
|||
- **Byte 1:** Stats sub-type (matches command sub-type): |
|||
- `STATS_TYPE_CORE` (0) - Core device statistics response |
|||
- `STATS_TYPE_RADIO` (1) - Radio statistics response |
|||
- `STATS_TYPE_PACKETS` (2) - Packet statistics response |
|||
|
|||
--- |
|||
|
|||
## RESP_CODE_STATS + STATS_TYPE_CORE (24, 0) |
|||
|
|||
**Total Frame Size:** 11 bytes |
|||
|
|||
| Offset | Size | Type | Field Name | Description | Range/Notes | |
|||
|--------|------|------|------------|-------------|-------------| |
|||
| 0 | 1 | uint8_t | response_code | Always `0x18` (24) | - | |
|||
| 1 | 1 | uint8_t | stats_type | Always `0x00` (STATS_TYPE_CORE) | - | |
|||
| 2 | 2 | uint16_t | battery_mv | Battery voltage in millivolts | 0 - 65,535 | |
|||
| 4 | 4 | uint32_t | uptime_secs | Device uptime in seconds | 0 - 4,294,967,295 | |
|||
| 8 | 2 | uint16_t | errors | Error flags bitmask | - | |
|||
| 10 | 1 | uint8_t | queue_len | Outbound packet queue length | 0 - 255 | |
|||
|
|||
### Example Structure (C/C++) |
|||
|
|||
```c |
|||
struct StatsCore { |
|||
uint8_t response_code; // 0x18 |
|||
uint8_t stats_type; // 0x00 (STATS_TYPE_CORE) |
|||
uint16_t battery_mv; |
|||
uint32_t uptime_secs; |
|||
uint16_t errors; |
|||
uint8_t queue_len; |
|||
} __attribute__((packed)); |
|||
``` |
|||
|
|||
--- |
|||
|
|||
## RESP_CODE_STATS + STATS_TYPE_RADIO (24, 1) |
|||
|
|||
**Total Frame Size:** 14 bytes |
|||
|
|||
| Offset | Size | Type | Field Name | Description | Range/Notes | |
|||
|--------|------|------|------------|-------------|-------------| |
|||
| 0 | 1 | uint8_t | response_code | Always `0x18` (24) | - | |
|||
| 1 | 1 | uint8_t | stats_type | Always `0x01` (STATS_TYPE_RADIO) | - | |
|||
| 2 | 2 | int16_t | noise_floor | Radio noise floor in dBm | -140 to +10 | |
|||
| 4 | 1 | int8_t | last_rssi | Last received signal strength in dBm | -128 to +127 | |
|||
| 5 | 1 | int8_t | last_snr | SNR scaled by 4 | Divide by 4.0 for dB | |
|||
| 6 | 4 | uint32_t | tx_air_secs | Cumulative transmit airtime in seconds | 0 - 4,294,967,295 | |
|||
| 10 | 4 | uint32_t | rx_air_secs | Cumulative receive airtime in seconds | 0 - 4,294,967,295 | |
|||
|
|||
### Example Structure (C/C++) |
|||
|
|||
```c |
|||
struct StatsRadio { |
|||
uint8_t response_code; // 0x18 |
|||
uint8_t stats_type; // 0x01 (STATS_TYPE_RADIO) |
|||
int16_t noise_floor; |
|||
int8_t last_rssi; |
|||
int8_t last_snr; // Divide by 4.0 to get actual SNR in dB |
|||
uint32_t tx_air_secs; |
|||
uint32_t rx_air_secs; |
|||
} __attribute__((packed)); |
|||
``` |
|||
|
|||
--- |
|||
|
|||
## RESP_CODE_STATS + STATS_TYPE_PACKETS (24, 2) |
|||
|
|||
**Total Frame Size:** 26 bytes |
|||
|
|||
| Offset | Size | Type | Field Name | Description | Range/Notes | |
|||
|--------|------|------|------------|-------------|-------------| |
|||
| 0 | 1 | uint8_t | response_code | Always `0x18` (24) | - | |
|||
| 1 | 1 | uint8_t | stats_type | Always `0x02` (STATS_TYPE_PACKETS) | - | |
|||
| 2 | 4 | uint32_t | recv | Total packets received | 0 - 4,294,967,295 | |
|||
| 6 | 4 | uint32_t | sent | Total packets sent | 0 - 4,294,967,295 | |
|||
| 10 | 4 | uint32_t | flood_tx | Packets sent via flood routing | 0 - 4,294,967,295 | |
|||
| 14 | 4 | uint32_t | direct_tx | Packets sent via direct routing | 0 - 4,294,967,295 | |
|||
| 18 | 4 | uint32_t | flood_rx | Packets received via flood routing | 0 - 4,294,967,295 | |
|||
| 22 | 4 | uint32_t | direct_rx | Packets received via direct routing | 0 - 4,294,967,295 | |
|||
|
|||
### Notes |
|||
|
|||
- Counters are cumulative from boot and may wrap. |
|||
- `recv = flood_rx + direct_rx` |
|||
- `sent = flood_tx + direct_tx` |
|||
|
|||
### Example Structure (C/C++) |
|||
|
|||
```c |
|||
struct StatsPackets { |
|||
uint8_t response_code; // 0x18 |
|||
uint8_t stats_type; // 0x02 (STATS_TYPE_PACKETS) |
|||
uint32_t recv; |
|||
uint32_t sent; |
|||
uint32_t flood_tx; |
|||
uint32_t direct_tx; |
|||
uint32_t flood_rx; |
|||
uint32_t direct_rx; |
|||
} __attribute__((packed)); |
|||
``` |
|||
|
|||
--- |
|||
|
|||
## Command Usage Example (Python) |
|||
|
|||
```python |
|||
# Send CMD_GET_STATS command |
|||
def send_get_stats_core(serial_interface): |
|||
"""Send command to get core stats""" |
|||
cmd = bytes([56, 0]) # CMD_GET_STATS (56) + STATS_TYPE_CORE (0) |
|||
serial_interface.write(cmd) |
|||
|
|||
def send_get_stats_radio(serial_interface): |
|||
"""Send command to get radio stats""" |
|||
cmd = bytes([56, 1]) # CMD_GET_STATS (56) + STATS_TYPE_RADIO (1) |
|||
serial_interface.write(cmd) |
|||
|
|||
def send_get_stats_packets(serial_interface): |
|||
"""Send command to get packet stats""" |
|||
cmd = bytes([56, 2]) # CMD_GET_STATS (56) + STATS_TYPE_PACKETS (2) |
|||
serial_interface.write(cmd) |
|||
``` |
|||
|
|||
--- |
|||
|
|||
## Response Parsing Example (Python) |
|||
|
|||
```python |
|||
import struct |
|||
|
|||
def parse_stats_core(frame): |
|||
"""Parse RESP_CODE_STATS + STATS_TYPE_CORE frame (11 bytes)""" |
|||
response_code, stats_type, battery_mv, uptime_secs, errors, queue_len = \ |
|||
struct.unpack('<B B H I H B', frame) |
|||
assert response_code == 24 and stats_type == 0, "Invalid response type" |
|||
return { |
|||
'battery_mv': battery_mv, |
|||
'uptime_secs': uptime_secs, |
|||
'errors': errors, |
|||
'queue_len': queue_len |
|||
} |
|||
|
|||
def parse_stats_radio(frame): |
|||
"""Parse RESP_CODE_STATS + STATS_TYPE_RADIO frame (14 bytes)""" |
|||
response_code, stats_type, noise_floor, last_rssi, last_snr, tx_air_secs, rx_air_secs = \ |
|||
struct.unpack('<B B h b b I I', frame) |
|||
assert response_code == 24 and stats_type == 1, "Invalid response type" |
|||
return { |
|||
'noise_floor': noise_floor, |
|||
'last_rssi': last_rssi, |
|||
'last_snr': last_snr / 4.0, # Unscale SNR |
|||
'tx_air_secs': tx_air_secs, |
|||
'rx_air_secs': rx_air_secs |
|||
} |
|||
|
|||
def parse_stats_packets(frame): |
|||
"""Parse RESP_CODE_STATS + STATS_TYPE_PACKETS frame (26 bytes)""" |
|||
response_code, stats_type, recv, sent, flood_tx, direct_tx, flood_rx, direct_rx = \ |
|||
struct.unpack('<B B I I I I I I', frame) |
|||
assert response_code == 24 and stats_type == 2, "Invalid response type" |
|||
return { |
|||
'recv': recv, |
|||
'sent': sent, |
|||
'flood_tx': flood_tx, |
|||
'direct_tx': direct_tx, |
|||
'flood_rx': flood_rx, |
|||
'direct_rx': direct_rx |
|||
} |
|||
``` |
|||
|
|||
--- |
|||
|
|||
## Command Usage Example (JavaScript/TypeScript) |
|||
|
|||
```typescript |
|||
// Send CMD_GET_STATS command |
|||
const CMD_GET_STATS = 56; |
|||
const STATS_TYPE_CORE = 0; |
|||
const STATS_TYPE_RADIO = 1; |
|||
const STATS_TYPE_PACKETS = 2; |
|||
|
|||
function sendGetStatsCore(serialInterface: SerialPort): void { |
|||
const cmd = new Uint8Array([CMD_GET_STATS, STATS_TYPE_CORE]); |
|||
serialInterface.write(cmd); |
|||
} |
|||
|
|||
function sendGetStatsRadio(serialInterface: SerialPort): void { |
|||
const cmd = new Uint8Array([CMD_GET_STATS, STATS_TYPE_RADIO]); |
|||
serialInterface.write(cmd); |
|||
} |
|||
|
|||
function sendGetStatsPackets(serialInterface: SerialPort): void { |
|||
const cmd = new Uint8Array([CMD_GET_STATS, STATS_TYPE_PACKETS]); |
|||
serialInterface.write(cmd); |
|||
} |
|||
``` |
|||
|
|||
--- |
|||
|
|||
## Response Parsing Example (JavaScript/TypeScript) |
|||
|
|||
```typescript |
|||
interface StatsCore { |
|||
battery_mv: number; |
|||
uptime_secs: number; |
|||
errors: number; |
|||
queue_len: number; |
|||
} |
|||
|
|||
interface StatsRadio { |
|||
noise_floor: number; |
|||
last_rssi: number; |
|||
last_snr: number; |
|||
tx_air_secs: number; |
|||
rx_air_secs: number; |
|||
} |
|||
|
|||
interface StatsPackets { |
|||
recv: number; |
|||
sent: number; |
|||
flood_tx: number; |
|||
direct_tx: number; |
|||
flood_rx: number; |
|||
direct_rx: number; |
|||
} |
|||
|
|||
function parseStatsCore(buffer: ArrayBuffer): StatsCore { |
|||
const view = new DataView(buffer); |
|||
const response_code = view.getUint8(0); |
|||
const stats_type = view.getUint8(1); |
|||
if (response_code !== 24 || stats_type !== 0) { |
|||
throw new Error('Invalid response type'); |
|||
} |
|||
return { |
|||
battery_mv: view.getUint16(2, true), |
|||
uptime_secs: view.getUint32(4, true), |
|||
errors: view.getUint16(8, true), |
|||
queue_len: view.getUint8(10) |
|||
}; |
|||
} |
|||
|
|||
function parseStatsRadio(buffer: ArrayBuffer): StatsRadio { |
|||
const view = new DataView(buffer); |
|||
const response_code = view.getUint8(0); |
|||
const stats_type = view.getUint8(1); |
|||
if (response_code !== 24 || stats_type !== 1) { |
|||
throw new Error('Invalid response type'); |
|||
} |
|||
return { |
|||
noise_floor: view.getInt16(2, true), |
|||
last_rssi: view.getInt8(4), |
|||
last_snr: view.getInt8(5) / 4.0, // Unscale SNR |
|||
tx_air_secs: view.getUint32(6, true), |
|||
rx_air_secs: view.getUint32(10, true) |
|||
}; |
|||
} |
|||
|
|||
function parseStatsPackets(buffer: ArrayBuffer): StatsPackets { |
|||
const view = new DataView(buffer); |
|||
const response_code = view.getUint8(0); |
|||
const stats_type = view.getUint8(1); |
|||
if (response_code !== 24 || stats_type !== 2) { |
|||
throw new Error('Invalid response type'); |
|||
} |
|||
return { |
|||
recv: view.getUint32(2, true), |
|||
sent: view.getUint32(6, true), |
|||
flood_tx: view.getUint32(10, true), |
|||
direct_tx: view.getUint32(14, true), |
|||
flood_rx: view.getUint32(18, true), |
|||
direct_rx: view.getUint32(22, true) |
|||
}; |
|||
} |
|||
``` |
|||
|
|||
--- |
|||
|
|||
## Field Size Considerations |
|||
|
|||
- Packet counters (uint32_t): May wrap after extended high-traffic operation. |
|||
- Time fields (uint32_t): Max ~136 years. |
|||
- SNR (int8_t, scaled by 4): Range -32 to +31.75 dB, 0.25 dB precision. |
|||
|
|||
@ -0,0 +1,104 @@ |
|||
#if defined(NRF52_PLATFORM) |
|||
#include "NRF52Board.h" |
|||
|
|||
#include <bluefruit.h> |
|||
|
|||
static BLEDfu bledfu; |
|||
|
|||
static void connect_callback(uint16_t conn_handle) { |
|||
(void)conn_handle; |
|||
MESH_DEBUG_PRINTLN("BLE client connected"); |
|||
} |
|||
|
|||
static void disconnect_callback(uint16_t conn_handle, uint8_t reason) { |
|||
(void)conn_handle; |
|||
(void)reason; |
|||
|
|||
MESH_DEBUG_PRINTLN("BLE client disconnected"); |
|||
} |
|||
|
|||
void NRF52Board::begin() { |
|||
startup_reason = BD_STARTUP_NORMAL; |
|||
} |
|||
|
|||
void NRF52BoardDCDC::begin() { |
|||
NRF52Board::begin(); |
|||
|
|||
// Enable DC/DC converter for improved power efficiency
|
|||
uint8_t sd_enabled = 0; |
|||
sd_softdevice_is_enabled(&sd_enabled); |
|||
if (sd_enabled) { |
|||
sd_power_dcdc_mode_set(NRF_POWER_DCDC_ENABLE); |
|||
} else { |
|||
NRF_POWER->DCDCEN = 1; |
|||
} |
|||
} |
|||
|
|||
// Temperature from NRF52 MCU
|
|||
float NRF52Board::getMCUTemperature() { |
|||
NRF_TEMP->TASKS_START = 1; // Start temperature measurement
|
|||
|
|||
long startTime = millis(); |
|||
while (NRF_TEMP->EVENTS_DATARDY == 0) { // Wait for completion. Should complete in 50us
|
|||
if(millis() - startTime > 5) { // To wait 5ms just in case
|
|||
NRF_TEMP->TASKS_STOP = 1; |
|||
return NAN; |
|||
} |
|||
} |
|||
|
|||
NRF_TEMP->EVENTS_DATARDY = 0; // Clear event flag
|
|||
|
|||
int32_t temp = NRF_TEMP->TEMP; // In 0.25 *C units
|
|||
NRF_TEMP->TASKS_STOP = 1; |
|||
|
|||
return temp * 0.25f; // Convert to *C
|
|||
} |
|||
|
|||
bool NRF52BoardOTA::startOTAUpdate(const char *id, char reply[]) { |
|||
// Config the peripheral connection with maximum bandwidth
|
|||
// more SRAM required by SoftDevice
|
|||
// Note: All config***() function must be called before begin()
|
|||
Bluefruit.configPrphBandwidth(BANDWIDTH_MAX); |
|||
Bluefruit.configPrphConn(92, BLE_GAP_EVENT_LENGTH_MIN, 16, 16); |
|||
|
|||
Bluefruit.begin(1, 0); |
|||
// Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
|
|||
Bluefruit.setTxPower(4); |
|||
// Set the BLE device name
|
|||
Bluefruit.setName(ota_name); |
|||
|
|||
Bluefruit.Periph.setConnectCallback(connect_callback); |
|||
Bluefruit.Periph.setDisconnectCallback(disconnect_callback); |
|||
|
|||
// To be consistent OTA DFU should be added first if it exists
|
|||
bledfu.begin(); |
|||
|
|||
// Set up and start advertising
|
|||
// Advertising packet
|
|||
Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE); |
|||
Bluefruit.Advertising.addTxPower(); |
|||
Bluefruit.Advertising.addName(); |
|||
|
|||
/* Start Advertising
|
|||
- Enable auto advertising if disconnected |
|||
- Interval: fast mode = 20 ms, slow mode = 152.5 ms |
|||
- Timeout for fast mode is 30 seconds |
|||
- Start(timeout) with timeout = 0 will advertise forever (until connected) |
|||
|
|||
For recommended advertising interval |
|||
https://developer.apple.com/library/content/qa/qa1931/_index.html
|
|||
*/ |
|||
Bluefruit.Advertising.restartOnDisconnect(true); |
|||
Bluefruit.Advertising.setInterval(32, 244); // in unit of 0.625 ms
|
|||
Bluefruit.Advertising.setFastTimeout(30); // number of seconds in fast mode
|
|||
Bluefruit.Advertising.start(0); // 0 = Don't stop advertising after n seconds
|
|||
|
|||
uint8_t mac_addr[6]; |
|||
memset(mac_addr, 0, sizeof(mac_addr)); |
|||
Bluefruit.getAddr(mac_addr); |
|||
sprintf(reply, "OK - mac: %02X:%02X:%02X:%02X:%02X:%02X", mac_addr[5], mac_addr[4], mac_addr[3], |
|||
mac_addr[2], mac_addr[1], mac_addr[0]); |
|||
|
|||
return true; |
|||
} |
|||
#endif |
|||
@ -0,0 +1,39 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> |
|||
#include <MeshCore.h> |
|||
|
|||
#if defined(NRF52_PLATFORM) |
|||
|
|||
class NRF52Board : public mesh::MainBoard { |
|||
protected: |
|||
uint8_t startup_reason; |
|||
|
|||
public: |
|||
virtual void begin(); |
|||
virtual uint8_t getStartupReason() const override { return startup_reason; } |
|||
virtual float getMCUTemperature() override; |
|||
virtual void reboot() override { NVIC_SystemReset(); } |
|||
}; |
|||
|
|||
/*
|
|||
* The NRF52 has an internal DC/DC regulator that allows increased efficiency |
|||
* compared to the LDO regulator. For being able to use it, the module/board |
|||
* needs to have the required inductors and and capacitors populated. If the |
|||
* hardware requirements are met, this subclass can be used to enable the DC/DC |
|||
* regulator. |
|||
*/ |
|||
class NRF52BoardDCDC : virtual public NRF52Board { |
|||
public: |
|||
virtual void begin() override; |
|||
}; |
|||
|
|||
class NRF52BoardOTA : virtual public NRF52Board { |
|||
private: |
|||
char *ota_name; |
|||
|
|||
public: |
|||
NRF52BoardOTA(char *name) : ota_name(name) {} |
|||
virtual bool startOTAUpdate(const char *id, char reply[]) override; |
|||
}; |
|||
#endif |
|||
@ -0,0 +1,40 @@ |
|||
#ifdef IKOKA_NRF52 |
|||
|
|||
#include <Arduino.h> |
|||
#include <Wire.h> |
|||
|
|||
#include "IkokaNrf52Board.h" |
|||
|
|||
void IkokaNrf52Board::begin() { |
|||
NRF52Board::begin(); |
|||
|
|||
// ensure we have pull ups on the screen i2c, this isn't always available
|
|||
// in hardware and it should only be 20k ohms. Disable the pullups if we
|
|||
// are using the rotated lcd breakout board
|
|||
#if defined(DISPLAY_CLASS) && DISPLAY_ROTATION == 0 |
|||
pinMode(PIN_WIRE_SDA, INPUT_PULLUP); |
|||
pinMode(PIN_WIRE_SCL, INPUT_PULLUP); |
|||
#endif |
|||
|
|||
pinMode(PIN_VBAT, INPUT); |
|||
pinMode(VBAT_ENABLE, OUTPUT); |
|||
digitalWrite(VBAT_ENABLE, HIGH); |
|||
|
|||
// required button pullup is handled as part of button initilization
|
|||
// in target.cpp
|
|||
|
|||
#if defined(PIN_WIRE_SDA) && defined(PIN_WIRE_SCL) |
|||
Wire.setPins(PIN_WIRE_SDA, PIN_WIRE_SCL); |
|||
#endif |
|||
|
|||
Wire.begin(); |
|||
|
|||
#ifdef P_LORA_TX_LED |
|||
pinMode(P_LORA_TX_LED, OUTPUT); |
|||
digitalWrite(P_LORA_TX_LED, HIGH); |
|||
#endif |
|||
|
|||
delay(10); // give sx1262 some time to power up
|
|||
} |
|||
|
|||
#endif |
|||
@ -0,0 +1,44 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> |
|||
#include <MeshCore.h> |
|||
#include <helpers/NRF52Board.h> |
|||
|
|||
#ifdef IKOKA_NRF52 |
|||
|
|||
class IkokaNrf52Board : public NRF52BoardOTA { |
|||
public: |
|||
IkokaNrf52Board() : NRF52BoardOTA("XIAO_NRF52_OTA") {} |
|||
void begin(); |
|||
|
|||
#if defined(P_LORA_TX_LED) |
|||
void onBeforeTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, LOW); // turn TX LED on
|
|||
} |
|||
void onAfterTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, HIGH); // turn TX LED off
|
|||
} |
|||
#endif |
|||
|
|||
uint16_t getBattMilliVolts() override { |
|||
// Please read befor going further ;)
|
|||
// https://wiki.seeedstudio.com/XIAO_BLE#q3-what-are-the-considerations-when-using-xiao-nrf52840-sense-for-battery-charging
|
|||
|
|||
// We can't drive VBAT_ENABLE to HIGH as long
|
|||
// as we don't know wether we are charging or not ...
|
|||
// this is a 3mA loss (4/1500)
|
|||
digitalWrite(VBAT_ENABLE, LOW); |
|||
int adcvalue = 0; |
|||
analogReadResolution(12); |
|||
analogReference(AR_INTERNAL_3_0); |
|||
delay(10); |
|||
adcvalue = analogRead(PIN_VBAT); |
|||
return (adcvalue * ADC_MULTIPLIER * AREF_VOLTAGE) / 4.096; |
|||
} |
|||
|
|||
const char* getManufacturerName() const override { |
|||
return "Ikoka Handheld E22 30dBm (Xiao_nrf52)"; |
|||
} |
|||
}; |
|||
|
|||
#endif |
|||
@ -0,0 +1,103 @@ |
|||
[ikoka_handheld_nrf] |
|||
extends = nrf52_base |
|||
build_flags = ${nrf52_base.build_flags} |
|||
${sensor_base.build_flags} |
|||
-I lib/nrf52/s140_nrf52_7.3.0_API/include |
|||
-I lib/nrf52/s140_nrf52_7.3.0_API/include/nrf52 |
|||
-I variants/ikoka_handheld_nrf |
|||
-UENV_INCLUDE_GPS |
|||
-D IKOKA_NRF52 |
|||
-D RADIO_CLASS=CustomSX1262 |
|||
-D WRAPPER_CLASS=CustomSX1262Wrapper |
|||
-D P_LORA_TX_LED=11 |
|||
-D P_LORA_DIO_1=D1 |
|||
-D P_LORA_RESET=D2 |
|||
-D P_LORA_BUSY=D3 |
|||
-D P_LORA_NSS=D4 |
|||
-D SX126X_RXEN=D5 |
|||
-D SX126X_TXEN=RADIOLIB_NC |
|||
-D SX126X_DIO2_AS_RF_SWITCH=1 |
|||
-D SX126X_DIO3_TCXO_VOLTAGE=1.8 |
|||
-D SX126X_CURRENT_LIMIT=140 |
|||
-D SX126X_RX_BOOSTED_GAIN=1 |
|||
build_src_filter = ${nrf52_base.build_src_filter} |
|||
+<../variants/ikoka_handheld_nrf> |
|||
+<helpers/sensors> |
|||
lib_deps = ${nrf52_base.lib_deps} |
|||
${sensor_base.lib_deps} |
|||
densaugeo/base64 @ ~1.4.0 |
|||
|
|||
# larger screen has a different driver, this is for the 0.96 inch |
|||
[ikoka_handheld_nrf_ssd1306_companion] |
|||
lib_deps = ${ikoka_handheld_nrf.lib_deps} |
|||
adafruit/Adafruit SSD1306 @ ^2.5.13 |
|||
build_flags = ${ikoka_handheld_nrf.build_flags} |
|||
-D DISPLAY_CLASS=SSD1306Display |
|||
-D DISPLAY_ROTATION=0 |
|||
-D PIN_WIRE_SCL=D6 |
|||
-D PIN_WIRE_SDA=D7 |
|||
-D PIN_USER_BTN=D0 |
|||
-D MAX_CONTACTS=350 |
|||
-D MAX_GROUP_CHANNELS=40 |
|||
-D OFFLINE_QUEUE_SIZE=256 |
|||
-D QSPIFLASH=1 |
|||
-I examples/companion_radio/ui-new |
|||
build_src_filter = ${ikoka_handheld_nrf.build_src_filter} |
|||
+<helpers/ui/SSD1306Display.cpp> |
|||
+<../examples/companion_radio/ui-new/UITask.cpp> |
|||
+<../examples/companion_radio/*.cpp> |
|||
|
|||
[env:ikoka_handheld_nrf_e22_30dbm_096_companion_radio_ble] |
|||
extends = ikoka_nrf52 |
|||
build_flags = ${ikoka_handheld_nrf_ssd1306_companion.build_flags} |
|||
-D BLE_PIN_CODE=123456 |
|||
-D LORA_TX_POWER=20 |
|||
build_src_filter = ${ikoka_handheld_nrf_ssd1306_companion.build_src_filter} |
|||
+<helpers/nrf52/SerialBLEInterface.cpp> |
|||
|
|||
[env:ikoka_handheld_nrf_e22_30dbm_096_rotated_companion_radio_ble] |
|||
extends = ikoka_nrf52 |
|||
build_flags = ${ikoka_handheld_nrf_ssd1306_companion.build_flags} |
|||
-D BLE_PIN_CODE=123456 |
|||
-D LORA_TX_POWER=20 |
|||
-D DISPLAY_ROTATION=2 |
|||
build_src_filter = ${ikoka_handheld_nrf_ssd1306_companion.build_src_filter} |
|||
+<helpers/nrf52/SerialBLEInterface.cpp> |
|||
|
|||
[env:ikoka_handheld_nrf_e22_30dbm_096_companion_radio_usb] |
|||
extends = ikoka_nrf52 |
|||
build_flags = ${ikoka_handheld_nrf_ssd1306_companion.build_flags} |
|||
-D LORA_TX_POWER=20 |
|||
build_src_filter = ${ikoka_handheld_nrf_ssd1306_companion.build_src_filter} |
|||
|
|||
[env:ikoka_handheld_nrf_e22_30dbm_096_rotated_companion_radio_usb] |
|||
extends = ikoka_nrf52 |
|||
build_flags = ${ikoka_handheld_nrf_ssd1306_companion.build_flags} |
|||
-D LORA_TX_POWER=20 |
|||
-D DISPLAY_ROTATION=2 |
|||
build_src_filter = ${ikoka_handheld_nrf_ssd1306_companion.build_src_filter} |
|||
|
|||
[env:ikoka_handheld_nrf_e22_30dbm_repeater] |
|||
extends = ikoka_nrf52 |
|||
build_flags = |
|||
${ikoka_handheld_nrf.build_flags} |
|||
-D ADVERT_NAME='"ikoka_handheld Repeater"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
-D MAX_NEIGHBOURS=50 |
|||
-D LORA_TX_POWER=20 |
|||
build_src_filter = ${ikoka_handheld_nrf.build_src_filter} |
|||
+<../examples/simple_repeater/*.cpp> |
|||
|
|||
[env:ikoka_handheld_nrf_e22_30dbm_room_server] |
|||
extends = ikoka_nrf52 |
|||
build_flags = |
|||
${ikoka_handheld_nrf.build_flags} |
|||
-D ADVERT_NAME='"ikoka_handheld Room"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
-D LORA_TX_POWER=20 |
|||
build_src_filter = ${ikoka_handheld_nrf.build_src_filter} |
|||
+<../examples/simple_room_server/*.cpp> |
|||
@ -0,0 +1,46 @@ |
|||
#include <Arduino.h> |
|||
#include "target.h" |
|||
#include <helpers/ArduinoHelpers.h> |
|||
|
|||
IkokaNrf52Board board; |
|||
|
|||
RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI); |
|||
|
|||
WRAPPER_CLASS radio_driver(radio, board); |
|||
|
|||
VolatileRTCClock fallback_clock; |
|||
AutoDiscoverRTCClock rtc_clock(fallback_clock); |
|||
|
|||
EnvironmentSensorManager sensors; |
|||
|
|||
#ifdef DISPLAY_CLASS |
|||
DISPLAY_CLASS display; |
|||
MomentaryButton user_btn(PIN_USER_BTN, 1000, true, true); |
|||
#endif |
|||
|
|||
|
|||
bool radio_init() { |
|||
rtc_clock.begin(Wire); |
|||
|
|||
return radio.std_init(&SPI); |
|||
} |
|||
|
|||
uint32_t radio_get_rng_seed() { |
|||
return radio.random(0x7FFFFFFF); |
|||
} |
|||
|
|||
void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) { |
|||
radio.setFrequency(freq); |
|||
radio.setSpreadingFactor(sf); |
|||
radio.setBandwidth(bw); |
|||
radio.setCodingRate(cr); |
|||
} |
|||
|
|||
void radio_set_tx_power(uint8_t dbm) { |
|||
radio.setOutputPower(dbm); |
|||
} |
|||
|
|||
mesh::LocalIdentity radio_new_identity() { |
|||
RadioNoiseListener rng(radio); |
|||
return mesh::LocalIdentity(&rng); // create new random identity
|
|||
} |
|||
@ -0,0 +1,29 @@ |
|||
#pragma once |
|||
|
|||
#define RADIOLIB_STATIC_ONLY 1 |
|||
#include <RadioLib.h> |
|||
#include <helpers/radiolib/RadioLibWrappers.h> |
|||
#include <IkokaNrf52Board.h> |
|||
#include <helpers/radiolib/CustomSX1262Wrapper.h> |
|||
#include <helpers/AutoDiscoverRTCClock.h> |
|||
#include <helpers/ArduinoHelpers.h> |
|||
#include <helpers/sensors/EnvironmentSensorManager.h> |
|||
|
|||
#ifdef DISPLAY_CLASS |
|||
#include <helpers/ui/SSD1306Display.h> |
|||
#include <helpers/ui/MomentaryButton.h> |
|||
extern DISPLAY_CLASS display; |
|||
extern MomentaryButton user_btn; |
|||
#endif |
|||
|
|||
|
|||
extern IkokaNrf52Board board; |
|||
extern WRAPPER_CLASS radio_driver; |
|||
extern AutoDiscoverRTCClock rtc_clock; |
|||
extern EnvironmentSensorManager sensors; |
|||
|
|||
bool radio_init(); |
|||
uint32_t radio_get_rng_seed(); |
|||
void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr); |
|||
void radio_set_tx_power(uint8_t dbm); |
|||
mesh::LocalIdentity radio_new_identity(); |
|||
@ -0,0 +1,84 @@ |
|||
#include "variant.h" |
|||
|
|||
#include "nrf.h" |
|||
#include "wiring_constants.h" |
|||
#include "wiring_digital.h" |
|||
|
|||
const uint32_t g_ADigitalPinMap[] = { |
|||
// D0 .. D10
|
|||
2, // D0 is P0.02 (A0)
|
|||
3, // D1 is P0.03 (A1)
|
|||
28, // D2 is P0.28 (A2)
|
|||
29, // D3 is P0.29 (A3)
|
|||
4, // D4 is P0.04 (A4,SDA)
|
|||
5, // D5 is P0.05 (A5,SCL)
|
|||
43, // D6 is P1.11 (TX)
|
|||
44, // D7 is P1.12 (RX)
|
|||
45, // D8 is P1.13 (SCK)
|
|||
46, // D9 is P1.14 (MISO)
|
|||
47, // D10 is P1.15 (MOSI)
|
|||
|
|||
// LEDs
|
|||
26, // D11 is P0.26 (LED RED)
|
|||
6, // D12 is P0.06 (LED BLUE)
|
|||
30, // D13 is P0.30 (LED GREEN)
|
|||
14, // D14 is P0.14 (READ_BAT)
|
|||
|
|||
// LSM6DS3TR
|
|||
40, // D15 is P1.08 (6D_PWR)
|
|||
27, // D16 is P0.27 (6D_I2C_SCL)
|
|||
7, // D17 is P0.07 (6D_I2C_SDA)
|
|||
11, // D18 is P0.11 (6D_INT1)
|
|||
|
|||
// MIC
|
|||
42, // D19 is P1.10 (MIC_PWR)
|
|||
32, // D20 is P1.00 (PDM_CLK)
|
|||
16, // D21 is P0.16 (PDM_DATA)
|
|||
|
|||
// BQ25100
|
|||
13, // D22 is P0.13 (HICHG)
|
|||
17, // D23 is P0.17 (~CHG)
|
|||
|
|||
//
|
|||
21, // D24 is P0.21 (QSPI_SCK)
|
|||
25, // D25 is P0.25 (QSPI_CSN)
|
|||
20, // D26 is P0.20 (QSPI_SIO_0 DI)
|
|||
24, // D27 is P0.24 (QSPI_SIO_1 DO)
|
|||
22, // D28 is P0.22 (QSPI_SIO_2 WP)
|
|||
23, // D29 is P0.23 (QSPI_SIO_3 HOLD)
|
|||
|
|||
// NFC
|
|||
9, // D30 is P0.09 (NFC1)
|
|||
10, // D31 is P0.10 (NFC2)
|
|||
|
|||
// VBAT
|
|||
31, // D32 is P0.31 (VBAT)
|
|||
}; |
|||
|
|||
void initVariant() { |
|||
// Disable reading of the BAT voltage.
|
|||
// https://wiki.seeedstudio.com/XIAO_BLE#q3-what-are-the-considerations-when-using-xiao-nrf52840-sense-for-battery-charging
|
|||
pinMode(VBAT_ENABLE, OUTPUT); |
|||
// digitalWrite(VBAT_ENABLE, HIGH);
|
|||
// This was taken from Seeed github butis not coherent with the doc,
|
|||
// VBAT_ENABLE should be kept to LOW to protect P0.14, (1500/500)*(4.2-3.3)+3.3 = 3.9V > 3.6V
|
|||
// This induces a 3mA current in the resistors :( but it's better than burning the nrf
|
|||
digitalWrite(VBAT_ENABLE, LOW); |
|||
|
|||
// disable xiao charging current, the handheld uses a tp4056 to charge
|
|||
// instead of the onboard xiao charging circuit. This charges at a max of
|
|||
// 780ma instead of 100ma. In theory you could enable both, but in practice
|
|||
// fire is scary.
|
|||
pinMode(PIN_CHARGING_CURRENT, OUTPUT); |
|||
digitalWrite(PIN_CHARGING_CURRENT, HIGH); |
|||
|
|||
pinMode(PIN_QSPI_CS, OUTPUT); |
|||
digitalWrite(PIN_QSPI_CS, HIGH); |
|||
|
|||
pinMode(LED_RED, OUTPUT); |
|||
digitalWrite(LED_RED, HIGH); |
|||
pinMode(LED_GREEN, OUTPUT); |
|||
digitalWrite(LED_GREEN, HIGH); |
|||
pinMode(LED_BLUE, OUTPUT); |
|||
digitalWrite(LED_BLUE, HIGH); |
|||
} |
|||
@ -0,0 +1,148 @@ |
|||
#ifndef _SEEED_XIAO_NRF52840_H_ |
|||
#define _SEEED_XIAO_NRF52840_H_ |
|||
|
|||
/** Master clock frequency */ |
|||
#define VARIANT_MCK (64000000ul) |
|||
|
|||
#define USE_LFXO // Board uses 32khz crystal for LF
|
|||
//#define USE_LFRC // Board uses RC for LF
|
|||
|
|||
/*----------------------------------------------------------------------------
|
|||
* Headers |
|||
*----------------------------------------------------------------------------*/ |
|||
|
|||
#include "WVariant.h" |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" |
|||
{ |
|||
#endif // __cplusplus
|
|||
|
|||
#define PINS_COUNT (33) |
|||
#define NUM_DIGITAL_PINS (33) |
|||
#define NUM_ANALOG_INPUTS (8) |
|||
#define NUM_ANALOG_OUTPUTS (0) |
|||
|
|||
// LEDs
|
|||
#define PIN_LED (LED_RED) |
|||
#define LED_PWR (PINS_COUNT) |
|||
#define PIN_NEOPIXEL (PINS_COUNT) |
|||
#define NEOPIXEL_NUM (0) |
|||
|
|||
#define LED_BUILTIN (PIN_LED) |
|||
|
|||
#define LED_RED (11) |
|||
#define LED_GREEN (13) |
|||
#define LED_BLUE (12) |
|||
|
|||
#define LED_STATE_ON (1) // State when LED is litted
|
|||
|
|||
// Buttons
|
|||
#define PIN_BUTTON1 (PINS_COUNT) |
|||
|
|||
// Digital PINs
|
|||
static const uint8_t D0 = 0 ; |
|||
static const uint8_t D1 = 1 ; |
|||
static const uint8_t D2 = 2 ; |
|||
static const uint8_t D3 = 3 ; |
|||
static const uint8_t D4 = 4 ; |
|||
static const uint8_t D5 = 5 ; |
|||
static const uint8_t D6 = 6 ; |
|||
static const uint8_t D7 = 7 ; |
|||
static const uint8_t D8 = 8 ; |
|||
static const uint8_t D9 = 9 ; |
|||
static const uint8_t D10 = 10; |
|||
|
|||
#define VBAT_ENABLE (14) // Output LOW to enable reading of the BAT voltage.
|
|||
// https://wiki.seeedstudio.com/XIAO_BLE#q3-what-are-the-considerations-when-using-xiao-nrf52840-sense-for-battery-charging
|
|||
|
|||
#define PIN_CHARGING_CURRENT (22) // Battery Charging current
|
|||
// https://wiki.seedstudio.com/XIAO_BLE#battery-charging-current
|
|||
// Analog pins
|
|||
#define PIN_A0 (0) |
|||
#define PIN_A1 (1) |
|||
#define PIN_A2 (2) |
|||
#define PIN_A3 (3) |
|||
#define PIN_A4 (4) |
|||
#define PIN_A5 (5) |
|||
#define PIN_VBAT (32) // Read the BAT voltage.
|
|||
// https://wiki.seeedstudio.com/XIAO_BLE#q3-what-are-the-considerations-when-using-xiao-nrf52840-sense-for-battery-charging
|
|||
|
|||
#define BAT_NOT_CHARGING (23) // LOW when charging
|
|||
|
|||
#define AREF_VOLTAGE (3.0) |
|||
#define ADC_MULTIPLIER (3.0F) // 1M, 512k divider bridge
|
|||
|
|||
static const uint8_t A0 = PIN_A0; |
|||
static const uint8_t A1 = PIN_A1; |
|||
static const uint8_t A2 = PIN_A2; |
|||
static const uint8_t A3 = PIN_A3; |
|||
static const uint8_t A4 = PIN_A4; |
|||
static const uint8_t A5 = PIN_A5; |
|||
|
|||
#define ADC_RESOLUTION (12) |
|||
|
|||
// Other pins
|
|||
#define PIN_NFC1 (30) |
|||
#define PIN_NFC2 (31) |
|||
|
|||
// Serial interfaces
|
|||
#define PIN_SERIAL1_RX (7) |
|||
#define PIN_SERIAL1_TX (6) |
|||
|
|||
// SPI Interfaces
|
|||
#define SPI_INTERFACES_COUNT (2) |
|||
|
|||
#define PIN_SPI_MISO (9) |
|||
#define PIN_SPI_MOSI (10) |
|||
#define PIN_SPI_SCK (8) |
|||
|
|||
#define PIN_SPI1_MISO (25) |
|||
#define PIN_SPI1_MOSI (26) |
|||
#define PIN_SPI1_SCK (29) |
|||
|
|||
// Lora SPI is on SPI0
|
|||
#define P_LORA_SCLK PIN_SPI_SCK |
|||
#define P_LORA_MISO PIN_SPI_MISO |
|||
#define P_LORA_MOSI PIN_SPI_MOSI |
|||
|
|||
// Wire Interfaces
|
|||
#define WIRE_INTERFACES_COUNT (1) |
|||
|
|||
#define PIN_WIRE_SDA (6) // 4 and 5 are used for the sx1262 !
|
|||
#define PIN_WIRE_SCL (7) // use WIRE1_SDA
|
|||
|
|||
static const uint8_t SDA = (6); |
|||
static const uint8_t SCL = (7); |
|||
|
|||
//#define PIN_WIRE1_SDA (17)
|
|||
//#define PIN_WIRE1_SCL (16)
|
|||
#define PIN_LSM6DS3TR_C_POWER (15) |
|||
#define PIN_LSM6DS3TR_C_INT1 (18) |
|||
|
|||
// PDM Interfaces
|
|||
#define PIN_PDM_PWR (19) |
|||
#define PIN_PDM_CLK (20) |
|||
#define PIN_PDM_DIN (21) |
|||
|
|||
// QSPI Pins
|
|||
#define PIN_QSPI_SCK (24) |
|||
#define PIN_QSPI_CS (25) |
|||
#define PIN_QSPI_IO0 (26) |
|||
#define PIN_QSPI_IO1 (27) |
|||
#define PIN_QSPI_IO2 (28) |
|||
#define PIN_QSPI_IO3 (29) |
|||
|
|||
// On-board QSPI Flash
|
|||
#define EXTERNAL_FLASH_DEVICES (P25Q16H) |
|||
#define EXTERNAL_FLASH_USE_QSPI |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
/*----------------------------------------------------------------------------
|
|||
* Arduino objects - C++ only |
|||
*----------------------------------------------------------------------------*/ |
|||
|
|||
#endif |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue