mirror of https://github.com/meshcore-dev/MeshCore
Marnick Hartgers
4 months ago
40 changed files with 1680 additions and 202 deletions
@ -0,0 +1,50 @@ |
|||
{ |
|||
"build": { |
|||
"arduino": { |
|||
"ldscript": "esp32s3_out.ld", |
|||
"memory_type": "qio_opi" |
|||
}, |
|||
"core": "esp32", |
|||
"extra_flags": [ |
|||
"-DBOARD_HAS_PSRAM", |
|||
"-DLILYGO_TBEAM_1W", |
|||
"-DARDUINO_USB_CDC_ON_BOOT=1", |
|||
"-DARDUINO_USB_MODE=0", |
|||
"-DARDUINO_RUNNING_CORE=1", |
|||
"-DARDUINO_EVENT_RUNNING_CORE=1" |
|||
], |
|||
"f_cpu": "240000000L", |
|||
"f_flash": "80000000L", |
|||
"flash_mode": "qio", |
|||
"psram_type": "opi", |
|||
"hwids": [ |
|||
[ |
|||
"0x303A", |
|||
"0x1001" |
|||
] |
|||
], |
|||
"mcu": "esp32s3", |
|||
"variant": "lilygo_tbeam_1w" |
|||
}, |
|||
"connectivity": [ |
|||
"wifi", |
|||
"bluetooth", |
|||
"lora" |
|||
], |
|||
"debug": { |
|||
"openocd_target": "esp32s3.cfg" |
|||
}, |
|||
"frameworks": [ |
|||
"arduino" |
|||
], |
|||
"name": "LilyGo TBeam-1W", |
|||
"upload": { |
|||
"flash_size": "16MB", |
|||
"maximum_ram_size": 327680, |
|||
"maximum_size": 16777216, |
|||
"require_upload_port": true, |
|||
"speed": 921600 |
|||
}, |
|||
"url": "http://www.lilygo.cn/", |
|||
"vendor": "LilyGo" |
|||
} |
|||
@ -0,0 +1,152 @@ |
|||
# MeshCore KISS Modem Protocol |
|||
|
|||
Serial protocol for the KISS modem firmware. Enables sending/receiving MeshCore packets over LoRa and cryptographic operations using the modem's identity. |
|||
|
|||
## Serial Configuration |
|||
|
|||
115200 baud, 8N1, no flow control. |
|||
|
|||
## Frame Format |
|||
|
|||
Standard KISS framing with byte stuffing. |
|||
|
|||
| Byte | Name | Description | |
|||
|------|------|-------------| |
|||
| `0xC0` | FEND | Frame delimiter | |
|||
| `0xDB` | FESC | Escape character | |
|||
| `0xDC` | TFEND | Escaped FEND (FESC + TFEND = 0xC0) | |
|||
| `0xDD` | TFESC | Escaped FESC (FESC + TFESC = 0xDB) | |
|||
|
|||
``` |
|||
┌──────┬─────────┬──────────────┬──────┐ |
|||
│ FEND │ Command │ Data (escaped)│ FEND │ |
|||
│ 0xC0 │ 1 byte │ 0-510 bytes │ 0xC0 │ |
|||
└──────┴─────────┴──────────────┴──────┘ |
|||
``` |
|||
|
|||
Maximum unescaped frame size: 512 bytes. |
|||
|
|||
## Commands |
|||
|
|||
### Request Commands (Host → Modem) |
|||
|
|||
| Command | Value | Data | |
|||
|---------|-------|------| |
|||
| `CMD_DATA` | `0x00` | Packet (2-255 bytes) | |
|||
| `CMD_GET_IDENTITY` | `0x01` | - | |
|||
| `CMD_GET_RANDOM` | `0x02` | Length (1 byte, 1-64) | |
|||
| `CMD_VERIFY_SIGNATURE` | `0x03` | PubKey (32) + Signature (64) + Data | |
|||
| `CMD_SIGN_DATA` | `0x04` | Data to sign | |
|||
| `CMD_ENCRYPT_DATA` | `0x05` | Key (32) + Plaintext | |
|||
| `CMD_DECRYPT_DATA` | `0x06` | Key (32) + MAC (2) + Ciphertext | |
|||
| `CMD_KEY_EXCHANGE` | `0x07` | Remote PubKey (32) | |
|||
| `CMD_HASH` | `0x08` | Data to hash | |
|||
| `CMD_SET_RADIO` | `0x09` | Freq (4) + BW (4) + SF (1) + CR (1) | |
|||
| `CMD_SET_TX_POWER` | `0x0A` | Power dBm (1) | |
|||
| `CMD_SET_SYNC_WORD` | `0x0B` | Sync word (1) | |
|||
| `CMD_GET_RADIO` | `0x0C` | - | |
|||
| `CMD_GET_TX_POWER` | `0x0D` | - | |
|||
| `CMD_GET_SYNC_WORD` | `0x0E` | - | |
|||
| `CMD_GET_VERSION` | `0x0F` | - | |
|||
| `CMD_GET_CURRENT_RSSI` | `0x10` | - | |
|||
| `CMD_IS_CHANNEL_BUSY` | `0x11` | - | |
|||
| `CMD_GET_AIRTIME` | `0x12` | Packet length (1) | |
|||
| `CMD_GET_NOISE_FLOOR` | `0x13` | - | |
|||
| `CMD_GET_STATS` | `0x14` | - | |
|||
| `CMD_GET_BATTERY` | `0x15` | - | |
|||
| `CMD_PING` | `0x16` | - | |
|||
| `CMD_GET_SENSORS` | `0x17` | Permissions (1) | |
|||
|
|||
### Response Commands (Modem → Host) |
|||
|
|||
| Command | Value | Data | |
|||
|---------|-------|------| |
|||
| `CMD_DATA` | `0x00` | SNR (1) + RSSI (1) + Packet | |
|||
| `RESP_IDENTITY` | `0x21` | PubKey (32) | |
|||
| `RESP_RANDOM` | `0x22` | Random bytes (1-64) | |
|||
| `RESP_VERIFY` | `0x23` | Result (1): 0x00=invalid, 0x01=valid | |
|||
| `RESP_SIGNATURE` | `0x24` | Signature (64) | |
|||
| `RESP_ENCRYPTED` | `0x25` | MAC (2) + Ciphertext | |
|||
| `RESP_DECRYPTED` | `0x26` | Plaintext | |
|||
| `RESP_SHARED_SECRET` | `0x27` | Shared secret (32) | |
|||
| `RESP_HASH` | `0x28` | SHA-256 hash (32) | |
|||
| `RESP_OK` | `0x29` | - | |
|||
| `RESP_RADIO` | `0x2A` | Freq (4) + BW (4) + SF (1) + CR (1) | |
|||
| `RESP_TX_POWER` | `0x2B` | Power dBm (1) | |
|||
| `RESP_SYNC_WORD` | `0x2C` | Sync word (1) | |
|||
| `RESP_VERSION` | `0x2D` | Version (1) + Reserved (1) | |
|||
| `RESP_ERROR` | `0x2E` | Error code (1) | |
|||
| `RESP_TX_DONE` | `0x2F` | Result (1): 0x00=failed, 0x01=success | |
|||
| `RESP_CURRENT_RSSI` | `0x30` | RSSI dBm (1, signed) | |
|||
| `RESP_CHANNEL_BUSY` | `0x31` | Result (1): 0x00=clear, 0x01=busy | |
|||
| `RESP_AIRTIME` | `0x32` | Milliseconds (4) | |
|||
| `RESP_NOISE_FLOOR` | `0x33` | dBm (2, signed) | |
|||
| `RESP_STATS` | `0x34` | RX (4) + TX (4) + Errors (4) | |
|||
| `RESP_BATTERY` | `0x35` | Millivolts (2) | |
|||
| `RESP_PONG` | `0x36` | - | |
|||
| `RESP_SENSORS` | `0x37` | CayenneLPP payload | |
|||
|
|||
## Error Codes |
|||
|
|||
| Code | Value | Description | |
|||
|------|-------|-------------| |
|||
| `ERR_INVALID_LENGTH` | `0x01` | Request data too short | |
|||
| `ERR_INVALID_PARAM` | `0x02` | Invalid parameter value | |
|||
| `ERR_NO_CALLBACK` | `0x03` | Feature not available | |
|||
| `ERR_MAC_FAILED` | `0x04` | MAC verification failed | |
|||
| `ERR_UNKNOWN_CMD` | `0x05` | Unknown command | |
|||
| `ERR_ENCRYPT_FAILED` | `0x06` | Encryption failed | |
|||
| `ERR_TX_PENDING` | `0x07` | TX already pending | |
|||
|
|||
## Data Formats |
|||
|
|||
### Radio Parameters (CMD_SET_RADIO / RESP_RADIO) |
|||
|
|||
All values little-endian. |
|||
|
|||
| Field | Size | Description | |
|||
|-------|------|-------------| |
|||
| Frequency | 4 bytes | Hz (e.g., 869618000) | |
|||
| Bandwidth | 4 bytes | Hz (e.g., 62500) | |
|||
| SF | 1 byte | Spreading factor (5-12) | |
|||
| CR | 1 byte | Coding rate (5-8) | |
|||
|
|||
### Received Packet (CMD_DATA response) |
|||
|
|||
| Field | Size | Description | |
|||
|-------|------|-------------| |
|||
| SNR | 1 byte | Signal-to-noise × 4, signed | |
|||
| RSSI | 1 byte | Signal strength dBm, signed | |
|||
| Packet | variable | Raw MeshCore packet | |
|||
|
|||
### Stats (RESP_STATS) |
|||
|
|||
All values little-endian. |
|||
|
|||
| Field | Size | Description | |
|||
|-------|------|-------------| |
|||
| RX | 4 bytes | Packets received | |
|||
| TX | 4 bytes | Packets transmitted | |
|||
| Errors | 4 bytes | Receive errors | |
|||
|
|||
### Sensor Permissions (CMD_GET_SENSORS) |
|||
|
|||
| Bit | Value | Description | |
|||
|-----|-------|-------------| |
|||
| 0 | `0x01` | Base (battery) | |
|||
| 1 | `0x02` | Location (GPS) | |
|||
| 2 | `0x04` | Environment (temp, humidity, pressure) | |
|||
|
|||
Use `0x07` for all permissions. |
|||
|
|||
### Sensor Data (RESP_SENSORS) |
|||
|
|||
Data returned in CayenneLPP format. See [CayenneLPP documentation](https://docs.mydevices.com/docs/lorawan/cayenne-lpp) for parsing. |
|||
|
|||
## Notes |
|||
|
|||
- Modem generates identity on first boot (stored in flash) |
|||
- SNR values multiplied by 4 for 0.25 dB precision |
|||
- Wait for `RESP_TX_DONE` before sending next packet |
|||
- Sending `CMD_DATA` while TX is pending returns `ERR_TX_PENDING` |
|||
- See [packet_structure.md](./packet_structure.md) for packet format |
|||
@ -0,0 +1,437 @@ |
|||
#include "KissModem.h" |
|||
#include <CayenneLPP.h> |
|||
|
|||
KissModem::KissModem(Stream& serial, mesh::LocalIdentity& identity, mesh::RNG& rng, |
|||
mesh::Radio& radio, mesh::MainBoard& board, SensorManager& sensors) |
|||
: _serial(serial), _identity(identity), _rng(rng), _radio(radio), _board(board), _sensors(sensors) { |
|||
_rx_len = 0; |
|||
_rx_escaped = false; |
|||
_rx_active = false; |
|||
_has_pending_tx = false; |
|||
_pending_tx_len = 0; |
|||
_setRadioCallback = nullptr; |
|||
_setTxPowerCallback = nullptr; |
|||
_getCurrentRssiCallback = nullptr; |
|||
_getStatsCallback = nullptr; |
|||
_config = {0, 0, 0, 0, 0}; |
|||
} |
|||
|
|||
void KissModem::begin() { |
|||
_rx_len = 0; |
|||
_rx_escaped = false; |
|||
_rx_active = false; |
|||
_has_pending_tx = false; |
|||
} |
|||
|
|||
void KissModem::writeByte(uint8_t b) { |
|||
if (b == KISS_FEND) { |
|||
_serial.write(KISS_FESC); |
|||
_serial.write(KISS_TFEND); |
|||
} else if (b == KISS_FESC) { |
|||
_serial.write(KISS_FESC); |
|||
_serial.write(KISS_TFESC); |
|||
} else { |
|||
_serial.write(b); |
|||
} |
|||
} |
|||
|
|||
void KissModem::writeFrame(uint8_t cmd, const uint8_t* data, uint16_t len) { |
|||
_serial.write(KISS_FEND); |
|||
writeByte(cmd); |
|||
for (uint16_t i = 0; i < len; i++) { |
|||
writeByte(data[i]); |
|||
} |
|||
_serial.write(KISS_FEND); |
|||
} |
|||
|
|||
void KissModem::writeErrorFrame(uint8_t error_code) { |
|||
writeFrame(RESP_ERROR, &error_code, 1); |
|||
} |
|||
|
|||
void KissModem::loop() { |
|||
while (_serial.available()) { |
|||
uint8_t b = _serial.read(); |
|||
|
|||
if (b == KISS_FEND) { |
|||
if (_rx_active && _rx_len > 0) { |
|||
processFrame(); |
|||
} |
|||
_rx_len = 0; |
|||
_rx_escaped = false; |
|||
_rx_active = true; |
|||
continue; |
|||
} |
|||
|
|||
if (!_rx_active) continue; |
|||
|
|||
if (b == KISS_FESC) { |
|||
_rx_escaped = true; |
|||
continue; |
|||
} |
|||
|
|||
if (_rx_escaped) { |
|||
_rx_escaped = false; |
|||
if (b == KISS_TFEND) b = KISS_FEND; |
|||
else if (b == KISS_TFESC) b = KISS_FESC; |
|||
} |
|||
|
|||
if (_rx_len < KISS_MAX_FRAME_SIZE) { |
|||
_rx_buf[_rx_len++] = b; |
|||
} |
|||
} |
|||
} |
|||
|
|||
void KissModem::processFrame() { |
|||
if (_rx_len < 1) return; |
|||
|
|||
uint8_t cmd = _rx_buf[0]; |
|||
const uint8_t* data = &_rx_buf[1]; |
|||
uint16_t data_len = _rx_len - 1; |
|||
|
|||
switch (cmd) { |
|||
case CMD_DATA: |
|||
if (data_len < 2) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
} else if (data_len > KISS_MAX_PACKET_SIZE) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
} else if (_has_pending_tx) { |
|||
writeErrorFrame(ERR_TX_PENDING); |
|||
} else { |
|||
memcpy(_pending_tx, data, data_len); |
|||
_pending_tx_len = data_len; |
|||
_has_pending_tx = true; |
|||
} |
|||
break; |
|||
case CMD_GET_IDENTITY: |
|||
handleGetIdentity(); |
|||
break; |
|||
case CMD_GET_RANDOM: |
|||
handleGetRandom(data, data_len); |
|||
break; |
|||
case CMD_VERIFY_SIGNATURE: |
|||
handleVerifySignature(data, data_len); |
|||
break; |
|||
case CMD_SIGN_DATA: |
|||
handleSignData(data, data_len); |
|||
break; |
|||
case CMD_ENCRYPT_DATA: |
|||
handleEncryptData(data, data_len); |
|||
break; |
|||
case CMD_DECRYPT_DATA: |
|||
handleDecryptData(data, data_len); |
|||
break; |
|||
case CMD_KEY_EXCHANGE: |
|||
handleKeyExchange(data, data_len); |
|||
break; |
|||
case CMD_HASH: |
|||
handleHash(data, data_len); |
|||
break; |
|||
case CMD_SET_RADIO: |
|||
handleSetRadio(data, data_len); |
|||
break; |
|||
case CMD_SET_TX_POWER: |
|||
handleSetTxPower(data, data_len); |
|||
break; |
|||
case CMD_GET_RADIO: |
|||
handleGetRadio(); |
|||
break; |
|||
case CMD_GET_TX_POWER: |
|||
handleGetTxPower(); |
|||
break; |
|||
case CMD_GET_VERSION: |
|||
handleGetVersion(); |
|||
break; |
|||
case CMD_GET_CURRENT_RSSI: |
|||
handleGetCurrentRssi(); |
|||
break; |
|||
case CMD_IS_CHANNEL_BUSY: |
|||
handleIsChannelBusy(); |
|||
break; |
|||
case CMD_GET_AIRTIME: |
|||
handleGetAirtime(data, data_len); |
|||
break; |
|||
case CMD_GET_NOISE_FLOOR: |
|||
handleGetNoiseFloor(); |
|||
break; |
|||
case CMD_GET_STATS: |
|||
handleGetStats(); |
|||
break; |
|||
case CMD_GET_BATTERY: |
|||
handleGetBattery(); |
|||
break; |
|||
case CMD_PING: |
|||
handlePing(); |
|||
break; |
|||
case CMD_GET_SENSORS: |
|||
handleGetSensors(data, data_len); |
|||
break; |
|||
default: |
|||
writeErrorFrame(ERR_UNKNOWN_CMD); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void KissModem::handleGetIdentity() { |
|||
writeFrame(RESP_IDENTITY, _identity.pub_key, PUB_KEY_SIZE); |
|||
} |
|||
|
|||
void KissModem::handleGetRandom(const uint8_t* data, uint16_t len) { |
|||
if (len < 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
uint8_t requested = data[0]; |
|||
if (requested < 1 || requested > 64) { |
|||
writeErrorFrame(ERR_INVALID_PARAM); |
|||
return; |
|||
} |
|||
|
|||
uint8_t buf[64]; |
|||
_rng.random(buf, requested); |
|||
writeFrame(RESP_RANDOM, buf, requested); |
|||
} |
|||
|
|||
void KissModem::handleVerifySignature(const uint8_t* data, uint16_t len) { |
|||
if (len < PUB_KEY_SIZE + SIGNATURE_SIZE + 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
mesh::Identity signer(data); |
|||
const uint8_t* signature = data + PUB_KEY_SIZE; |
|||
const uint8_t* msg = data + PUB_KEY_SIZE + SIGNATURE_SIZE; |
|||
uint16_t msg_len = len - PUB_KEY_SIZE - SIGNATURE_SIZE; |
|||
|
|||
uint8_t result = signer.verify(signature, msg, msg_len) ? 0x01 : 0x00; |
|||
writeFrame(RESP_VERIFY, &result, 1); |
|||
} |
|||
|
|||
void KissModem::handleSignData(const uint8_t* data, uint16_t len) { |
|||
if (len < 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
uint8_t signature[SIGNATURE_SIZE]; |
|||
_identity.sign(signature, data, len); |
|||
writeFrame(RESP_SIGNATURE, signature, SIGNATURE_SIZE); |
|||
} |
|||
|
|||
void KissModem::handleEncryptData(const uint8_t* data, uint16_t len) { |
|||
if (len < PUB_KEY_SIZE + 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
const uint8_t* key = data; |
|||
const uint8_t* plaintext = data + PUB_KEY_SIZE; |
|||
uint16_t plaintext_len = len - PUB_KEY_SIZE; |
|||
|
|||
uint8_t buf[KISS_MAX_FRAME_SIZE]; |
|||
int encrypted_len = mesh::Utils::encryptThenMAC(key, buf, plaintext, plaintext_len); |
|||
|
|||
if (encrypted_len > 0) { |
|||
writeFrame(RESP_ENCRYPTED, buf, encrypted_len); |
|||
} else { |
|||
writeErrorFrame(ERR_ENCRYPT_FAILED); |
|||
} |
|||
} |
|||
|
|||
void KissModem::handleDecryptData(const uint8_t* data, uint16_t len) { |
|||
if (len < PUB_KEY_SIZE + CIPHER_MAC_SIZE + 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
const uint8_t* key = data; |
|||
const uint8_t* ciphertext = data + PUB_KEY_SIZE; |
|||
uint16_t ciphertext_len = len - PUB_KEY_SIZE; |
|||
|
|||
uint8_t buf[KISS_MAX_FRAME_SIZE]; |
|||
int decrypted_len = mesh::Utils::MACThenDecrypt(key, buf, ciphertext, ciphertext_len); |
|||
|
|||
if (decrypted_len > 0) { |
|||
writeFrame(RESP_DECRYPTED, buf, decrypted_len); |
|||
} else { |
|||
writeErrorFrame(ERR_MAC_FAILED); |
|||
} |
|||
} |
|||
|
|||
void KissModem::handleKeyExchange(const uint8_t* data, uint16_t len) { |
|||
if (len < PUB_KEY_SIZE) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
uint8_t shared_secret[PUB_KEY_SIZE]; |
|||
_identity.calcSharedSecret(shared_secret, data); |
|||
writeFrame(RESP_SHARED_SECRET, shared_secret, PUB_KEY_SIZE); |
|||
} |
|||
|
|||
void KissModem::handleHash(const uint8_t* data, uint16_t len) { |
|||
if (len < 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
uint8_t hash[32]; |
|||
mesh::Utils::sha256(hash, 32, data, len); |
|||
writeFrame(RESP_HASH, hash, 32); |
|||
} |
|||
|
|||
bool KissModem::getPacketToSend(uint8_t* packet, uint16_t* len) { |
|||
if (!_has_pending_tx) return false; |
|||
|
|||
memcpy(packet, _pending_tx, _pending_tx_len); |
|||
*len = _pending_tx_len; |
|||
_has_pending_tx = false; |
|||
return true; |
|||
} |
|||
|
|||
void KissModem::onPacketReceived(int8_t snr, int8_t rssi, const uint8_t* packet, uint16_t len) { |
|||
uint8_t buf[2 + KISS_MAX_PACKET_SIZE]; |
|||
buf[0] = (uint8_t)snr; |
|||
buf[1] = (uint8_t)rssi; |
|||
memcpy(&buf[2], packet, len); |
|||
writeFrame(CMD_DATA, buf, 2 + len); |
|||
} |
|||
|
|||
void KissModem::handleSetRadio(const uint8_t* data, uint16_t len) { |
|||
if (len < 10) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
if (!_setRadioCallback) { |
|||
writeErrorFrame(ERR_NO_CALLBACK); |
|||
return; |
|||
} |
|||
|
|||
uint32_t freq_hz, bw_hz; |
|||
memcpy(&freq_hz, data, 4); |
|||
memcpy(&bw_hz, data + 4, 4); |
|||
uint8_t sf = data[8]; |
|||
uint8_t cr = data[9]; |
|||
|
|||
_config.freq_hz = freq_hz; |
|||
_config.bw_hz = bw_hz; |
|||
_config.sf = sf; |
|||
_config.cr = cr; |
|||
|
|||
float freq = freq_hz / 1000000.0f; |
|||
float bw = bw_hz / 1000.0f; |
|||
|
|||
_setRadioCallback(freq, bw, sf, cr); |
|||
writeFrame(RESP_OK, nullptr, 0); |
|||
} |
|||
|
|||
void KissModem::handleSetTxPower(const uint8_t* data, uint16_t len) { |
|||
if (len < 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
if (!_setTxPowerCallback) { |
|||
writeErrorFrame(ERR_NO_CALLBACK); |
|||
return; |
|||
} |
|||
|
|||
_config.tx_power = data[0]; |
|||
_setTxPowerCallback(data[0]); |
|||
writeFrame(RESP_OK, nullptr, 0); |
|||
} |
|||
|
|||
void KissModem::handleGetRadio() { |
|||
uint8_t buf[10]; |
|||
memcpy(buf, &_config.freq_hz, 4); |
|||
memcpy(buf + 4, &_config.bw_hz, 4); |
|||
buf[8] = _config.sf; |
|||
buf[9] = _config.cr; |
|||
writeFrame(RESP_RADIO, buf, 10); |
|||
} |
|||
|
|||
void KissModem::handleGetTxPower() { |
|||
writeFrame(RESP_TX_POWER, &_config.tx_power, 1); |
|||
} |
|||
|
|||
void KissModem::handleGetVersion() { |
|||
uint8_t buf[2]; |
|||
buf[0] = KISS_FIRMWARE_VERSION; |
|||
buf[1] = 0; |
|||
writeFrame(RESP_VERSION, buf, 2); |
|||
} |
|||
|
|||
void KissModem::onTxComplete(bool success) { |
|||
uint8_t result = success ? 0x01 : 0x00; |
|||
writeFrame(RESP_TX_DONE, &result, 1); |
|||
} |
|||
|
|||
void KissModem::handleGetCurrentRssi() { |
|||
if (!_getCurrentRssiCallback) { |
|||
writeErrorFrame(ERR_NO_CALLBACK); |
|||
return; |
|||
} |
|||
|
|||
float rssi = _getCurrentRssiCallback(); |
|||
int8_t rssi_byte = (int8_t)rssi; |
|||
writeFrame(RESP_CURRENT_RSSI, (uint8_t*)&rssi_byte, 1); |
|||
} |
|||
|
|||
void KissModem::handleIsChannelBusy() { |
|||
uint8_t busy = _radio.isReceiving() ? 0x01 : 0x00; |
|||
writeFrame(RESP_CHANNEL_BUSY, &busy, 1); |
|||
} |
|||
|
|||
void KissModem::handleGetAirtime(const uint8_t* data, uint16_t len) { |
|||
if (len < 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
uint8_t packet_len = data[0]; |
|||
uint32_t airtime = _radio.getEstAirtimeFor(packet_len); |
|||
writeFrame(RESP_AIRTIME, (uint8_t*)&airtime, 4); |
|||
} |
|||
|
|||
void KissModem::handleGetNoiseFloor() { |
|||
int16_t noise_floor = _radio.getNoiseFloor(); |
|||
writeFrame(RESP_NOISE_FLOOR, (uint8_t*)&noise_floor, 2); |
|||
} |
|||
|
|||
void KissModem::handleGetStats() { |
|||
if (!_getStatsCallback) { |
|||
writeErrorFrame(ERR_NO_CALLBACK); |
|||
return; |
|||
} |
|||
|
|||
uint32_t rx, tx, errors; |
|||
_getStatsCallback(&rx, &tx, &errors); |
|||
uint8_t buf[12]; |
|||
memcpy(buf, &rx, 4); |
|||
memcpy(buf + 4, &tx, 4); |
|||
memcpy(buf + 8, &errors, 4); |
|||
writeFrame(RESP_STATS, buf, 12); |
|||
} |
|||
|
|||
void KissModem::handleGetBattery() { |
|||
uint16_t mv = _board.getBattMilliVolts(); |
|||
writeFrame(RESP_BATTERY, (uint8_t*)&mv, 2); |
|||
} |
|||
|
|||
void KissModem::handlePing() { |
|||
writeFrame(RESP_PONG, nullptr, 0); |
|||
} |
|||
|
|||
void KissModem::handleGetSensors(const uint8_t* data, uint16_t len) { |
|||
if (len < 1) { |
|||
writeErrorFrame(ERR_INVALID_LENGTH); |
|||
return; |
|||
} |
|||
|
|||
uint8_t permissions = data[0]; |
|||
CayenneLPP telemetry(255); |
|||
if (_sensors.querySensors(permissions, telemetry)) { |
|||
writeFrame(RESP_SENSORS, telemetry.getBuffer(), telemetry.getSize()); |
|||
} else { |
|||
writeFrame(RESP_SENSORS, nullptr, 0); |
|||
} |
|||
} |
|||
@ -0,0 +1,152 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> |
|||
#include <Identity.h> |
|||
#include <Utils.h> |
|||
#include <Mesh.h> |
|||
#include <helpers/SensorManager.h> |
|||
|
|||
#define KISS_FEND 0xC0 |
|||
#define KISS_FESC 0xDB |
|||
#define KISS_TFEND 0xDC |
|||
#define KISS_TFESC 0xDD |
|||
|
|||
#define KISS_MAX_FRAME_SIZE 512 |
|||
#define KISS_MAX_PACKET_SIZE 255 |
|||
|
|||
#define CMD_DATA 0x00 |
|||
#define CMD_GET_IDENTITY 0x01 |
|||
#define CMD_GET_RANDOM 0x02 |
|||
#define CMD_VERIFY_SIGNATURE 0x03 |
|||
#define CMD_SIGN_DATA 0x04 |
|||
#define CMD_ENCRYPT_DATA 0x05 |
|||
#define CMD_DECRYPT_DATA 0x06 |
|||
#define CMD_KEY_EXCHANGE 0x07 |
|||
#define CMD_HASH 0x08 |
|||
#define CMD_SET_RADIO 0x09 |
|||
#define CMD_SET_TX_POWER 0x0A |
|||
#define CMD_GET_RADIO 0x0C |
|||
#define CMD_GET_TX_POWER 0x0D |
|||
#define CMD_GET_VERSION 0x0F |
|||
#define CMD_GET_CURRENT_RSSI 0x10 |
|||
#define CMD_IS_CHANNEL_BUSY 0x11 |
|||
#define CMD_GET_AIRTIME 0x12 |
|||
#define CMD_GET_NOISE_FLOOR 0x13 |
|||
#define CMD_GET_STATS 0x14 |
|||
#define CMD_GET_BATTERY 0x15 |
|||
#define CMD_PING 0x16 |
|||
#define CMD_GET_SENSORS 0x17 |
|||
|
|||
#define RESP_IDENTITY 0x21 |
|||
#define RESP_RANDOM 0x22 |
|||
#define RESP_VERIFY 0x23 |
|||
#define RESP_SIGNATURE 0x24 |
|||
#define RESP_ENCRYPTED 0x25 |
|||
#define RESP_DECRYPTED 0x26 |
|||
#define RESP_SHARED_SECRET 0x27 |
|||
#define RESP_HASH 0x28 |
|||
#define RESP_OK 0x29 |
|||
#define RESP_RADIO 0x2A |
|||
#define RESP_TX_POWER 0x2B |
|||
#define RESP_VERSION 0x2D |
|||
#define RESP_ERROR 0x2E |
|||
#define RESP_TX_DONE 0x2F |
|||
#define RESP_CURRENT_RSSI 0x30 |
|||
#define RESP_CHANNEL_BUSY 0x31 |
|||
#define RESP_AIRTIME 0x32 |
|||
#define RESP_NOISE_FLOOR 0x33 |
|||
#define RESP_STATS 0x34 |
|||
#define RESP_BATTERY 0x35 |
|||
#define RESP_PONG 0x36 |
|||
#define RESP_SENSORS 0x37 |
|||
|
|||
#define ERR_INVALID_LENGTH 0x01 |
|||
#define ERR_INVALID_PARAM 0x02 |
|||
#define ERR_NO_CALLBACK 0x03 |
|||
#define ERR_MAC_FAILED 0x04 |
|||
#define ERR_UNKNOWN_CMD 0x05 |
|||
#define ERR_ENCRYPT_FAILED 0x06 |
|||
#define ERR_TX_PENDING 0x07 |
|||
|
|||
#define KISS_FIRMWARE_VERSION 1 |
|||
|
|||
typedef void (*SetRadioCallback)(float freq, float bw, uint8_t sf, uint8_t cr); |
|||
typedef void (*SetTxPowerCallback)(uint8_t power); |
|||
typedef float (*GetCurrentRssiCallback)(); |
|||
typedef void (*GetStatsCallback)(uint32_t* rx, uint32_t* tx, uint32_t* errors); |
|||
|
|||
struct RadioConfig { |
|||
uint32_t freq_hz; |
|||
uint32_t bw_hz; |
|||
uint8_t sf; |
|||
uint8_t cr; |
|||
uint8_t tx_power; |
|||
}; |
|||
|
|||
class KissModem { |
|||
Stream& _serial; |
|||
mesh::LocalIdentity& _identity; |
|||
mesh::RNG& _rng; |
|||
mesh::Radio& _radio; |
|||
mesh::MainBoard& _board; |
|||
SensorManager& _sensors; |
|||
|
|||
uint8_t _rx_buf[KISS_MAX_FRAME_SIZE]; |
|||
uint16_t _rx_len; |
|||
bool _rx_escaped; |
|||
bool _rx_active; |
|||
|
|||
uint8_t _pending_tx[KISS_MAX_PACKET_SIZE]; |
|||
uint16_t _pending_tx_len; |
|||
bool _has_pending_tx; |
|||
|
|||
SetRadioCallback _setRadioCallback; |
|||
SetTxPowerCallback _setTxPowerCallback; |
|||
GetCurrentRssiCallback _getCurrentRssiCallback; |
|||
GetStatsCallback _getStatsCallback; |
|||
|
|||
RadioConfig _config; |
|||
|
|||
void writeByte(uint8_t b); |
|||
void writeFrame(uint8_t cmd, const uint8_t* data, uint16_t len); |
|||
void writeErrorFrame(uint8_t error_code); |
|||
void processFrame(); |
|||
|
|||
void handleGetIdentity(); |
|||
void handleGetRandom(const uint8_t* data, uint16_t len); |
|||
void handleVerifySignature(const uint8_t* data, uint16_t len); |
|||
void handleSignData(const uint8_t* data, uint16_t len); |
|||
void handleEncryptData(const uint8_t* data, uint16_t len); |
|||
void handleDecryptData(const uint8_t* data, uint16_t len); |
|||
void handleKeyExchange(const uint8_t* data, uint16_t len); |
|||
void handleHash(const uint8_t* data, uint16_t len); |
|||
void handleSetRadio(const uint8_t* data, uint16_t len); |
|||
void handleSetTxPower(const uint8_t* data, uint16_t len); |
|||
void handleGetRadio(); |
|||
void handleGetTxPower(); |
|||
void handleGetVersion(); |
|||
void handleGetCurrentRssi(); |
|||
void handleIsChannelBusy(); |
|||
void handleGetAirtime(const uint8_t* data, uint16_t len); |
|||
void handleGetNoiseFloor(); |
|||
void handleGetStats(); |
|||
void handleGetBattery(); |
|||
void handlePing(); |
|||
void handleGetSensors(const uint8_t* data, uint16_t len); |
|||
|
|||
public: |
|||
KissModem(Stream& serial, mesh::LocalIdentity& identity, mesh::RNG& rng, |
|||
mesh::Radio& radio, mesh::MainBoard& board, SensorManager& sensors); |
|||
|
|||
void begin(); |
|||
void loop(); |
|||
|
|||
void setRadioCallback(SetRadioCallback cb) { _setRadioCallback = cb; } |
|||
void setTxPowerCallback(SetTxPowerCallback cb) { _setTxPowerCallback = cb; } |
|||
void setGetCurrentRssiCallback(GetCurrentRssiCallback cb) { _getCurrentRssiCallback = cb; } |
|||
void setGetStatsCallback(GetStatsCallback cb) { _getStatsCallback = cb; } |
|||
|
|||
bool getPacketToSend(uint8_t* packet, uint16_t* len); |
|||
void onPacketReceived(int8_t snr, int8_t rssi, const uint8_t* packet, uint16_t len); |
|||
void onTxComplete(bool success); |
|||
}; |
|||
@ -0,0 +1,117 @@ |
|||
#include <Arduino.h> |
|||
#include <target.h> |
|||
#include <helpers/ArduinoHelpers.h> |
|||
#include <helpers/IdentityStore.h> |
|||
#include "KissModem.h" |
|||
|
|||
#if defined(NRF52_PLATFORM) |
|||
#include <InternalFileSystem.h> |
|||
#elif defined(RP2040_PLATFORM) |
|||
#include <LittleFS.h> |
|||
#elif defined(ESP32) |
|||
#include <SPIFFS.h> |
|||
#endif |
|||
|
|||
StdRNG rng; |
|||
mesh::LocalIdentity identity; |
|||
KissModem* modem; |
|||
|
|||
void halt() { |
|||
while (1) ; |
|||
} |
|||
|
|||
void loadOrCreateIdentity() { |
|||
#if defined(NRF52_PLATFORM) |
|||
InternalFS.begin(); |
|||
IdentityStore store(InternalFS, ""); |
|||
#elif defined(ESP32) |
|||
SPIFFS.begin(true); |
|||
IdentityStore store(SPIFFS, "/identity"); |
|||
#elif defined(RP2040_PLATFORM) |
|||
LittleFS.begin(); |
|||
IdentityStore store(LittleFS, "/identity"); |
|||
store.begin(); |
|||
#else |
|||
#error "Filesystem not defined" |
|||
#endif |
|||
|
|||
if (!store.load("_main", identity)) { |
|||
identity = radio_new_identity(); |
|||
while (identity.pub_key[0] == 0x00 || identity.pub_key[0] == 0xFF) { |
|||
identity = radio_new_identity(); |
|||
} |
|||
store.save("_main", identity); |
|||
} |
|||
} |
|||
|
|||
void onSetRadio(float freq, float bw, uint8_t sf, uint8_t cr) { |
|||
radio_set_params(freq, bw, sf, cr); |
|||
} |
|||
|
|||
void onSetTxPower(uint8_t power) { |
|||
radio_set_tx_power(power); |
|||
} |
|||
|
|||
float onGetCurrentRssi() { |
|||
return radio_driver.getCurrentRSSI(); |
|||
} |
|||
|
|||
void onGetStats(uint32_t* rx, uint32_t* tx, uint32_t* errors) { |
|||
*rx = radio_driver.getPacketsRecv(); |
|||
*tx = radio_driver.getPacketsSent(); |
|||
*errors = radio_driver.getPacketsRecvErrors(); |
|||
} |
|||
|
|||
void setup() { |
|||
board.begin(); |
|||
|
|||
if (!radio_init()) { |
|||
halt(); |
|||
} |
|||
|
|||
radio_driver.begin(); |
|||
|
|||
rng.begin(radio_get_rng_seed()); |
|||
loadOrCreateIdentity(); |
|||
|
|||
Serial.begin(115200); |
|||
uint32_t start = millis(); |
|||
while (!Serial && millis() - start < 3000) delay(10); |
|||
delay(100); |
|||
|
|||
sensors.begin(); |
|||
|
|||
modem = new KissModem(Serial, identity, rng, radio_driver, board, sensors); |
|||
modem->setRadioCallback(onSetRadio); |
|||
modem->setTxPowerCallback(onSetTxPower); |
|||
modem->setGetCurrentRssiCallback(onGetCurrentRssi); |
|||
modem->setGetStatsCallback(onGetStats); |
|||
modem->begin(); |
|||
} |
|||
|
|||
void loop() { |
|||
modem->loop(); |
|||
|
|||
uint8_t packet[KISS_MAX_PACKET_SIZE]; |
|||
uint16_t len; |
|||
|
|||
if (modem->getPacketToSend(packet, &len)) { |
|||
radio_driver.startSendRaw(packet, len); |
|||
while (!radio_driver.isSendComplete()) { |
|||
delay(1); |
|||
} |
|||
radio_driver.onSendFinished(); |
|||
modem->onTxComplete(true); |
|||
} |
|||
|
|||
uint8_t rx_buf[256]; |
|||
int rx_len = radio_driver.recvRaw(rx_buf, sizeof(rx_buf)); |
|||
|
|||
if (rx_len > 0) { |
|||
int8_t snr = (int8_t)(radio_driver.getLastSNR() * 4); |
|||
int8_t rssi = (int8_t)radio_driver.getLastRSSI(); |
|||
modem->onPacketReceived(snr, rssi, rx_buf, rx_len); |
|||
} |
|||
|
|||
radio_driver.loop(); |
|||
} |
|||
@ -0,0 +1,71 @@ |
|||
#include "TBeam1WBoard.h" |
|||
|
|||
void TBeam1WBoard::begin() { |
|||
ESP32Board::begin(); |
|||
|
|||
// Power on radio module (must be done before radio init)
|
|||
pinMode(SX126X_POWER_EN, OUTPUT); |
|||
digitalWrite(SX126X_POWER_EN, HIGH); |
|||
radio_powered = true; |
|||
delay(10); // Allow radio to power up
|
|||
|
|||
// RF switch RXEN pin handled by RadioLib via setRfSwitchPins()
|
|||
|
|||
// Initialize LED
|
|||
pinMode(LED_PIN, OUTPUT); |
|||
digitalWrite(LED_PIN, LOW); |
|||
|
|||
// Initialize fan control (on by default - 1W PA can overheat)
|
|||
pinMode(FAN_CTRL_PIN, OUTPUT); |
|||
digitalWrite(FAN_CTRL_PIN, HIGH); |
|||
} |
|||
|
|||
void TBeam1WBoard::onBeforeTransmit() { |
|||
// RF switching handled by RadioLib via SX126X_DIO2_AS_RF_SWITCH and setRfSwitchPins()
|
|||
digitalWrite(LED_PIN, HIGH); // TX LED on
|
|||
} |
|||
|
|||
void TBeam1WBoard::onAfterTransmit() { |
|||
digitalWrite(LED_PIN, LOW); // TX LED off
|
|||
} |
|||
|
|||
uint16_t TBeam1WBoard::getBattMilliVolts() { |
|||
// T-Beam 1W uses 7.4V battery with voltage divider
|
|||
// ADC reads through divider - adjust multiplier based on actual divider ratio
|
|||
analogReadResolution(12); |
|||
uint32_t raw = 0; |
|||
for (int i = 0; i < 8; i++) { |
|||
raw += analogRead(BATTERY_PIN); |
|||
} |
|||
raw = raw / 8; |
|||
// Assuming voltage divider ratio from ADC_MULTIPLIER
|
|||
// 3.3V reference, 12-bit ADC (4095 max)
|
|||
return static_cast<uint16_t>((raw * 3300 * ADC_MULTIPLIER) / 4095); |
|||
} |
|||
|
|||
const char* TBeam1WBoard::getManufacturerName() const { |
|||
return "LilyGo T-Beam 1W"; |
|||
} |
|||
|
|||
void TBeam1WBoard::powerOff() { |
|||
// Turn off radio LNA (CTRL pin must be LOW when not receiving)
|
|||
digitalWrite(SX126X_RXEN, LOW); |
|||
|
|||
// Turn off radio power
|
|||
digitalWrite(SX126X_POWER_EN, LOW); |
|||
radio_powered = false; |
|||
|
|||
// Turn off LED and fan
|
|||
digitalWrite(LED_PIN, LOW); |
|||
digitalWrite(FAN_CTRL_PIN, LOW); |
|||
|
|||
ESP32Board::powerOff(); |
|||
} |
|||
|
|||
void TBeam1WBoard::setFanEnabled(bool enabled) { |
|||
digitalWrite(FAN_CTRL_PIN, enabled ? HIGH : LOW); |
|||
} |
|||
|
|||
bool TBeam1WBoard::isFanEnabled() const { |
|||
return digitalRead(FAN_CTRL_PIN) == HIGH; |
|||
} |
|||
@ -0,0 +1,45 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> |
|||
#include <helpers/ESP32Board.h> |
|||
#include "variant.h" |
|||
|
|||
// LilyGo T-Beam 1W with SX1262 + external PA (XY16P35 module)
|
|||
//
|
|||
// Power architecture (LDO is separate chip on T-Beam board, not inside XY16P35):
|
|||
//
|
|||
// VCC (+4.0~+8.0V) ──┬──────────────────► XY16P35 VCC pin 5 (PA direct)
|
|||
// (USB or Battery) │
|
|||
// │ ┌───────────┐
|
|||
// └──►│ LDO Chip │──► +3.3V ──► XY16P35 (SX1262 + LNA)
|
|||
// │ EN=GPIO40 │
|
|||
// └───────────┘
|
|||
// LDO_EN (GPIO 40): H @ +1.2V~VIN, active high, not floating
|
|||
//
|
|||
// Control signals:
|
|||
// - LDO_EN (GPIO 40): HIGH enables LDO → powers SX1262 + LNA
|
|||
// - TCXO_EN (DIO3): HIGH enables TCXO (set to 1.8V per Meshtastic)
|
|||
// - CTL (GPIO 21): HIGH=RX (LNA on), LOW=TX (LNA off)
|
|||
// - DIO2: AUTO via SX126X_DIO2_AS_RF_SWITCH (TX path)
|
|||
//
|
|||
// Power notes:
|
|||
// - PA needs VCC 4.0-8.0V for full 32dBm output
|
|||
// - USB-C (3.9-6V) marginal; 7.4V battery recommended
|
|||
// - Battery must support 2A+ discharge for high-power TX
|
|||
|
|||
class TBeam1WBoard : public ESP32Board { |
|||
private: |
|||
bool radio_powered = false; |
|||
|
|||
public: |
|||
void begin(); |
|||
void onBeforeTransmit() override; |
|||
void onAfterTransmit() override; |
|||
uint16_t getBattMilliVolts() override; |
|||
const char* getManufacturerName() const override; |
|||
void powerOff() override; |
|||
|
|||
// Fan control methods
|
|||
void setFanEnabled(bool enabled); |
|||
bool isFanEnabled() const; |
|||
}; |
|||
@ -0,0 +1,26 @@ |
|||
#ifndef Pins_Arduino_h |
|||
#define Pins_Arduino_h |
|||
|
|||
#include <stdint.h> |
|||
|
|||
#define USB_VID 0x303a |
|||
#define USB_PID 0x1001 |
|||
|
|||
// Serial (USB CDC)
|
|||
static const uint8_t TX = 43; |
|||
static const uint8_t RX = 44; |
|||
|
|||
// I2C for OLED and sensors
|
|||
static const uint8_t SDA = 8; |
|||
static const uint8_t SCL = 9; |
|||
|
|||
// Default SPI mapped to Radio/SD
|
|||
static const uint8_t SS = 15; // LoRa CS
|
|||
static const uint8_t MOSI = 11; |
|||
static const uint8_t MISO = 12; |
|||
static const uint8_t SCK = 13; |
|||
|
|||
// SD Card CS
|
|||
#define SDCARD_CS 10 |
|||
|
|||
#endif /* Pins_Arduino_h */ |
|||
@ -0,0 +1,193 @@ |
|||
[LilyGo_TBeam_1W] |
|||
extends = esp32_base |
|||
board = t_beam_1w |
|||
build_flags = |
|||
${esp32_base.build_flags} |
|||
-I variants/lilygo_tbeam_1w |
|||
-D TBEAM_1W |
|||
|
|||
; Radio - SX1262 with high-power PA (32dBm max output) |
|||
; Note: Set SX1262 output to 22dBm max, external PA provides additional gain |
|||
-D RADIO_CLASS=CustomSX1262 |
|||
-D WRAPPER_CLASS=CustomSX1262Wrapper |
|||
-D P_LORA_DIO_1=1 |
|||
-D P_LORA_NSS=15 |
|||
-D P_LORA_RESET=3 |
|||
-D P_LORA_BUSY=38 |
|||
-D P_LORA_SCLK=13 |
|||
-D P_LORA_MISO=12 |
|||
-D P_LORA_MOSI=11 |
|||
|
|||
; RF switch configuration: |
|||
; DIO2 controls TX path (PA enable) via SX126X_DIO2_AS_RF_SWITCH |
|||
; GPIO21 controls RX path (LNA enable) via SX126X_RXEN |
|||
; Truth table: DIO2=1,RXEN=0 → TX | DIO2=0,RXEN=1 → RX |
|||
-D SX126X_DIO2_AS_RF_SWITCH=true |
|||
-D SX126X_RXEN=21 |
|||
-D SX126X_DIO3_TCXO_VOLTAGE=3.0 |
|||
-D SX126X_CURRENT_LIMIT=140 |
|||
-D SX126X_RX_BOOSTED_GAIN=1 |
|||
|
|||
; TX power: 22dBm to SX1262, PA module adds ~10dB for 32dBm total |
|||
-D LORA_TX_POWER=22 |
|||
|
|||
; Battery - 2S 7.4V LiPo (6.0V min, 8.4V max) |
|||
-D BATT_MIN_MILLIVOLTS=6000 |
|||
-D BATT_MAX_MILLIVOLTS=8400 |
|||
|
|||
; Display - SH1106 OLED at 0x3C |
|||
-D DISPLAY_CLASS=SH1106Display |
|||
|
|||
; I2C pins |
|||
-D PIN_BOARD_SDA=8 |
|||
-D PIN_BOARD_SCL=9 |
|||
|
|||
; GPS - L76K module |
|||
; GNSS_TXD (IO5) = GPS transmits → MCU RX |
|||
; GNSS_RXD (IO6) = GPS receives → MCU TX |
|||
-D PIN_GPS_TX=5 |
|||
-D PIN_GPS_RX=6 |
|||
-D PIN_GPS_EN=16 |
|||
-D ENV_INCLUDE_GPS=1 |
|||
|
|||
; User interface |
|||
-D PIN_USER_BTN=17 |
|||
|
|||
build_src_filter = ${esp32_base.build_src_filter} |
|||
+<../variants/lilygo_tbeam_1w> |
|||
+<helpers/ui/SH1106Display.cpp> |
|||
+<helpers/ui/MomentaryButton.cpp> |
|||
+<helpers/sensors> |
|||
|
|||
lib_deps = |
|||
${esp32_base.lib_deps} |
|||
adafruit/Adafruit SH110X @ ~2.1.13 |
|||
stevemarple/MicroNMEA @ ~2.0.6 |
|||
|
|||
; === LILYGO T-Beam 1W Repeater === |
|||
[env:LilyGo_TBeam_1W_repeater] |
|||
extends = LilyGo_TBeam_1W |
|||
build_flags = |
|||
${LilyGo_TBeam_1W.build_flags} |
|||
-D ADVERT_NAME='"T-Beam 1W Repeater"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
-D MAX_NEIGHBOURS=50 |
|||
-D PERSISTANT_GPS=1 |
|||
-D ENV_SKIP_GPS_DETECT=1 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${LilyGo_TBeam_1W.build_src_filter} |
|||
+<../examples/simple_repeater> |
|||
lib_deps = |
|||
${LilyGo_TBeam_1W.lib_deps} |
|||
${esp32_ota.lib_deps} |
|||
|
|||
; === LILYGO T-Beam 1W Room Server === |
|||
[env:LilyGo_TBeam_1W_room_server] |
|||
extends = LilyGo_TBeam_1W |
|||
build_flags = |
|||
${LilyGo_TBeam_1W.build_flags} |
|||
-D ADVERT_NAME='"T-Beam 1W Room"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
-D ROOM_PASSWORD='"hello"' |
|||
-D PERSISTANT_GPS=1 |
|||
-D ENV_SKIP_GPS_DETECT=1 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${LilyGo_TBeam_1W.build_src_filter} |
|||
+<../examples/simple_room_server> |
|||
lib_deps = |
|||
${LilyGo_TBeam_1W.lib_deps} |
|||
${esp32_ota.lib_deps} |
|||
|
|||
; === LILYGO T-Beam 1W Companion Radio (USB) === |
|||
[env:LilyGo_TBeam_1W_companion_radio_usb] |
|||
extends = LilyGo_TBeam_1W |
|||
build_flags = |
|||
${LilyGo_TBeam_1W.build_flags} |
|||
-I examples/companion_radio/ui-new |
|||
-D MAX_CONTACTS=350 |
|||
-D MAX_GROUP_CHANNELS=40 |
|||
-D PERSISTANT_GPS=1 |
|||
-D ENV_SKIP_GPS_DETECT=1 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${LilyGo_TBeam_1W.build_src_filter} |
|||
+<../examples/companion_radio/*.cpp> |
|||
+<../examples/companion_radio/ui-new/*.cpp> |
|||
lib_deps = |
|||
${LilyGo_TBeam_1W.lib_deps} |
|||
densaugeo/base64 @ ~1.4.0 |
|||
|
|||
; === LILYGO T-Beam 1W Companion Radio (BLE) === |
|||
[env:LilyGo_TBeam_1W_companion_radio_ble] |
|||
extends = LilyGo_TBeam_1W |
|||
build_flags = |
|||
${LilyGo_TBeam_1W.build_flags} |
|||
-I examples/companion_radio/ui-new |
|||
-D MAX_CONTACTS=350 |
|||
-D MAX_GROUP_CHANNELS=40 |
|||
-D BLE_PIN_CODE=123456 |
|||
-D OFFLINE_QUEUE_SIZE=256 |
|||
-D PERSISTANT_GPS=1 |
|||
-D ENV_SKIP_GPS_DETECT=1 |
|||
; -D BLE_DEBUG_LOGGING=1 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${LilyGo_TBeam_1W.build_src_filter} |
|||
+<helpers/esp32/*.cpp> |
|||
+<../examples/companion_radio/*.cpp> |
|||
+<../examples/companion_radio/ui-new/*.cpp> |
|||
lib_deps = |
|||
${LilyGo_TBeam_1W.lib_deps} |
|||
densaugeo/base64 @ ~1.4.0 |
|||
|
|||
; === LILYGO T-Beam 1W Companion Radio (WiFi) === |
|||
[env:LilyGo_TBeam_1W_companion_radio_wifi] |
|||
extends = LilyGo_TBeam_1W |
|||
build_flags = |
|||
${LilyGo_TBeam_1W.build_flags} |
|||
-I examples/companion_radio/ui-new |
|||
-D MAX_CONTACTS=350 |
|||
-D MAX_GROUP_CHANNELS=40 |
|||
-D WIFI_DEBUG_LOGGING=1 |
|||
-D WIFI_SSID='"myssid"' |
|||
-D WIFI_PWD='"mypwd"' |
|||
-D PERSISTANT_GPS=1 |
|||
-D ENV_SKIP_GPS_DETECT=1 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${LilyGo_TBeam_1W.build_src_filter} |
|||
+<helpers/esp32/*.cpp> |
|||
+<../examples/companion_radio/*.cpp> |
|||
+<../examples/companion_radio/ui-new/*.cpp> |
|||
lib_deps = |
|||
${LilyGo_TBeam_1W.lib_deps} |
|||
densaugeo/base64 @ ~1.4.0 |
|||
|
|||
; === LILYGO T-Beam 1W Repeater with ESPNow Bridge === |
|||
[env:LilyGo_TBeam_1W_repeater_bridge_espnow] |
|||
extends = LilyGo_TBeam_1W |
|||
build_flags = |
|||
${LilyGo_TBeam_1W.build_flags} |
|||
-D ADVERT_NAME='"T-Beam 1W ESPNow Bridge"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
-D MAX_NEIGHBOURS=50 |
|||
-D WITH_ESPNOW_BRIDGE=1 |
|||
-D PERSISTANT_GPS=1 |
|||
-D ENV_SKIP_GPS_DETECT=1 |
|||
; -D BRIDGE_DEBUG=1 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${LilyGo_TBeam_1W.build_src_filter} |
|||
+<helpers/bridges/ESPNowBridge.cpp> |
|||
+<../examples/simple_repeater> |
|||
lib_deps = |
|||
${LilyGo_TBeam_1W.lib_deps} |
|||
${esp32_ota.lib_deps} |
|||
@ -0,0 +1,64 @@ |
|||
#include <Arduino.h> |
|||
#include "target.h" |
|||
|
|||
TBeam1WBoard board; |
|||
|
|||
#ifdef DISPLAY_CLASS |
|||
DISPLAY_CLASS display; |
|||
MomentaryButton user_btn(PIN_USER_BTN, 1000, true); |
|||
#endif |
|||
|
|||
static SPIClass spi; |
|||
|
|||
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); |
|||
|
|||
ESP32RTCClock fallback_clock; |
|||
AutoDiscoverRTCClock rtc_clock(fallback_clock); |
|||
|
|||
#if ENV_INCLUDE_GPS |
|||
#include <helpers/sensors/MicroNMEALocationProvider.h> |
|||
MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1); |
|||
EnvironmentSensorManager sensors = EnvironmentSensorManager(nmea); |
|||
#else |
|||
EnvironmentSensorManager sensors; |
|||
#endif |
|||
|
|||
bool radio_init() { |
|||
fallback_clock.begin(); |
|||
rtc_clock.begin(Wire); |
|||
|
|||
// Initialize SPI for radio
|
|||
spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI); |
|||
|
|||
// GPS serial initialized by EnvironmentSensorManager::begin()
|
|||
|
|||
bool success = radio.std_init(&spi); |
|||
if (success) { |
|||
// T-Beam 1W has external PA requiring longer ramp time (>800us recommended)
|
|||
// RADIOLIB_SX126X_PA_RAMP_800U = 0x05
|
|||
radio.setTxParams(LORA_TX_POWER, RADIOLIB_SX126X_PA_RAMP_800U); |
|||
} |
|||
return success; |
|||
} |
|||
|
|||
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); |
|||
} |
|||
@ -0,0 +1,27 @@ |
|||
#pragma once |
|||
|
|||
#define RADIOLIB_STATIC_ONLY 1 |
|||
#include <RadioLib.h> |
|||
#include <helpers/radiolib/RadioLibWrappers.h> |
|||
#include <helpers/radiolib/CustomSX1262Wrapper.h> |
|||
#include <helpers/AutoDiscoverRTCClock.h> |
|||
#include <helpers/sensors/EnvironmentSensorManager.h> |
|||
#include "TBeam1WBoard.h" |
|||
|
|||
#ifdef DISPLAY_CLASS |
|||
#include <helpers/ui/SH1106Display.h> |
|||
#include <helpers/ui/MomentaryButton.h> |
|||
extern DISPLAY_CLASS display; |
|||
extern MomentaryButton user_btn; |
|||
#endif |
|||
|
|||
extern TBeam1WBoard 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,96 @@ |
|||
// LilyGo T-Beam-1W variant.h
|
|||
// Configuration based on Meshtastic PR #8967 and LilyGO documentation
|
|||
|
|||
#pragma once |
|||
|
|||
// I2C for OLED display (SH1106 at 0x3C)
|
|||
#define I2C_SDA 8 |
|||
#define I2C_SCL 9 |
|||
|
|||
// GPS - Quectel L76K
|
|||
// GNSS_TXD (IO5) = GPS transmits → MCU RX (setPins rxPin)
|
|||
// GNSS_RXD (IO6) = GPS receives → MCU TX (setPins txPin)
|
|||
#define PIN_GPS_TX 5 // MCU receives from GPS TX
|
|||
#define PIN_GPS_RX 6 // MCU transmits to GPS RX
|
|||
#define PIN_GPS_PPS 7 // GPS PPS output
|
|||
#define PIN_GPS_EN 16 // GPS wake-up/enable (GPS_EN_PIN in LilyGO code)
|
|||
#define HAS_GPS 1 |
|||
#define GPS_BAUDRATE 9600 |
|||
|
|||
// Buttons
|
|||
#define BUTTON_PIN 0 // BUTTON 1 (boot)
|
|||
#define BUTTON_PIN_ALT 17 // BUTTON 2
|
|||
|
|||
// SPI (shared by LoRa and SD)
|
|||
#define SPI_MOSI 11 |
|||
#define SPI_SCK 13 |
|||
#define SPI_MISO 12 |
|||
#define SPI_CS 10 |
|||
|
|||
// SD Card
|
|||
#define HAS_SDCARD |
|||
#define SDCARD_USE_SPI1 |
|||
#define SDCARD_CS SPI_CS |
|||
|
|||
// LoRa Radio - SX1262 with 1W PA
|
|||
#define USE_SX1262 |
|||
|
|||
#define LORA_SCK SPI_SCK |
|||
#define LORA_MISO SPI_MISO |
|||
#define LORA_MOSI SPI_MOSI |
|||
#define LORA_CS 15 |
|||
#define LORA_RESET 3 |
|||
#define LORA_DIO1 1 |
|||
#define LORA_BUSY 38 |
|||
|
|||
// CRITICAL: Radio power enable - MUST be HIGH before lora.begin()!
|
|||
// GPIO 40 powers the SX1262 + PA module via LDO
|
|||
#define SX126X_POWER_EN 40 |
|||
|
|||
#ifdef USE_SX1262 |
|||
#define SX126X_CS LORA_CS |
|||
#define SX126X_DIO1 LORA_DIO1 |
|||
#define SX126X_BUSY LORA_BUSY |
|||
#define SX126X_RESET LORA_RESET |
|||
|
|||
// RF switching configuration for 1W PA module
|
|||
// DIO2 controls PA (via SX126X_DIO2_AS_RF_SWITCH)
|
|||
// CTRL PIN (GPIO 21) controls LNA - must be HIGH during RX
|
|||
// Truth table: DIO2=1,CTRL=0 -> TX (PA on, LNA off)
|
|||
// DIO2=0,CTRL=1 -> RX (PA off, LNA on)
|
|||
#define SX126X_DIO2_AS_RF_SWITCH |
|||
#define SX126X_RXEN 21 // LNA enable - HIGH during RX
|
|||
|
|||
// TCXO voltage - required for radio init
|
|||
#define SX126X_DIO3_TCXO_VOLTAGE 3.0 |
|||
|
|||
#define SX126X_MAX_POWER 22 |
|||
#endif |
|||
|
|||
// LED
|
|||
#define LED_PIN 18 |
|||
#define LED_STATE_ON 1 // HIGH = ON
|
|||
|
|||
// Battery ADC
|
|||
#define BATTERY_PIN 4 |
|||
#define ADC_CHANNEL ADC1_GPIO4_CHANNEL |
|||
#define BATTERY_SENSE_SAMPLES 30 |
|||
#define ADC_MULTIPLIER 3.0 |
|||
|
|||
// NTC temperature sensor
|
|||
#define NTC_PIN 14 |
|||
|
|||
// Fan control
|
|||
#define FAN_CTRL_PIN 41 |
|||
|
|||
// PA Ramp Time - T-Beam 1W requires >800us stabilization (default is 200us)
|
|||
// Value 0x05 = RADIOLIB_SX126X_PA_RAMP_800U
|
|||
#define SX126X_PA_RAMP_US 0x05 |
|||
|
|||
// Display - SH1106 OLED (128x64)
|
|||
#define USE_SH1106 |
|||
#define OLED_WIDTH 128 |
|||
#define OLED_HEIGHT 64 |
|||
|
|||
// 32768 Hz crystal present
|
|||
#define HAS_32768HZ 1 |
|||
@ -0,0 +1,28 @@ |
|||
#include <Arduino.h> |
|||
#include "ThinkNodeM3Board.h" |
|||
#include <Wire.h> |
|||
|
|||
#include <bluefruit.h> |
|||
|
|||
void ThinkNodeM3Board::begin() { |
|||
NRF52Board::begin(); |
|||
btn_prev_state = HIGH; |
|||
|
|||
Wire.begin(); |
|||
|
|||
delay(10); // give sx1262 some time to power up
|
|||
} |
|||
|
|||
uint16_t ThinkNodeM3Board::getBattMilliVolts() { |
|||
int adcvalue = 0; |
|||
|
|||
analogReference(AR_INTERNAL_2_4); |
|||
analogReadResolution(ADC_RESOLUTION); |
|||
delay(10); |
|||
|
|||
// ADC range is 0..2400mV and resolution is 12-bit (0..4095)
|
|||
adcvalue = analogRead(PIN_VBAT_READ); |
|||
// Convert the raw value to compensated mv, taking the resistor-
|
|||
// divider into account (providing the actual LIPO voltage)
|
|||
return (uint16_t)((float)adcvalue * ADC_FACTOR); |
|||
} |
|||
@ -0,0 +1,54 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> |
|||
#include <MeshCore.h> |
|||
#include <helpers/NRF52Board.h> |
|||
|
|||
#define ADC_FACTOR ((1000.0*ADC_MULTIPLIER*AREF_VOLTAGE)/ADC_MAX) |
|||
|
|||
class ThinkNodeM3Board : public NRF52BoardDCDC { |
|||
protected: |
|||
#if NRF52_POWER_MANAGEMENT |
|||
void initiateShutdown(uint8_t reason) override; |
|||
#endif |
|||
uint8_t btn_prev_state; |
|||
|
|||
public: |
|||
ThinkNodeM3Board() : NRF52Board("THINKNODE_M3_OTA") {} |
|||
void begin(); |
|||
uint16_t getBattMilliVolts() override; |
|||
|
|||
#if defined(P_LORA_TX_LED) |
|||
void onBeforeTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, HIGH); // turn TX LED on
|
|||
} |
|||
void onAfterTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, LOW); // turn TX LED off
|
|||
} |
|||
#endif |
|||
|
|||
const char* getManufacturerName() const override { |
|||
return "Elecrow ThinkNode M3"; |
|||
} |
|||
|
|||
int buttonStateChanged() { |
|||
#ifdef BUTTON_PIN |
|||
uint8_t v = digitalRead(BUTTON_PIN); |
|||
if (v != btn_prev_state) { |
|||
btn_prev_state = v; |
|||
return (v == LOW) ? 1 : -1; |
|||
} |
|||
#endif |
|||
return 0; |
|||
} |
|||
|
|||
void powerOff() override { |
|||
// turn off all leds, sd_power_system_off will not do this for us
|
|||
#ifdef P_LORA_TX_LED |
|||
digitalWrite(P_LORA_TX_LED, LOW); |
|||
#endif |
|||
|
|||
// power off board
|
|||
sd_power_system_off(); |
|||
} |
|||
}; |
|||
@ -1,14 +0,0 @@ |
|||
#include <Arduino.h> |
|||
#include "ThinknodeM3Board.h" |
|||
#include <Wire.h> |
|||
|
|||
#include <bluefruit.h> |
|||
|
|||
void ThinknodeM3Board::begin() { |
|||
Nrf52BoardDCDC::begin(); |
|||
btn_prev_state = HIGH; |
|||
|
|||
Wire.begin(); |
|||
|
|||
delay(10); // give sx1262 some time to power up
|
|||
} |
|||
@ -1,58 +0,0 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> |
|||
#include <MeshCore.h> |
|||
#include <helpers/NRF52Board.h> |
|||
|
|||
#define ADC_FACTOR ((1000.0*ADC_MULTIPLIER*AREF_VOLTAGE)/ADC_MAX) |
|||
|
|||
class ThinknodeM3Board : public Nrf52BoardDCDC { |
|||
protected: |
|||
uint8_t btn_prev_state; |
|||
|
|||
public: |
|||
void begin(); |
|||
|
|||
uint16_t getBattMilliVolts() override { |
|||
int adcvalue = 0; |
|||
|
|||
analogReference(AR_INTERNAL_2_4); |
|||
analogReadResolution(ADC_RESOLUTION); |
|||
delay(10); |
|||
|
|||
// ADC range is 0..2400mV and resolution is 12-bit (0..4095)
|
|||
adcvalue = analogRead(PIN_VBAT_READ); |
|||
// Convert the raw value to compensated mv, taking the resistor-
|
|||
// divider into account (providing the actual LIPO voltage)
|
|||
return (uint16_t)((float)adcvalue * ADC_FACTOR); |
|||
} |
|||
|
|||
#if defined(P_LORA_TX_LED) |
|||
#if !defined(P_LORA_TX_LED_ON) |
|||
#define P_LORA_TX_LED_ON HIGH |
|||
#endif |
|||
void onBeforeTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, P_LORA_TX_LED_ON); // turn TX LED on
|
|||
} |
|||
void onAfterTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, !P_LORA_TX_LED_ON); // turn TX LED off
|
|||
} |
|||
#endif |
|||
|
|||
const char* getManufacturerName() const override { |
|||
return "Elecrow ThinkNode M3"; |
|||
} |
|||
|
|||
int buttonStateChanged() { |
|||
#ifdef BUTTON_PIN |
|||
uint8_t v = digitalRead(BUTTON_PIN); |
|||
if (v != btn_prev_state) { |
|||
btn_prev_state = v; |
|||
return (v == LOW) ? 1 : -1; |
|||
} |
|||
#endif |
|||
return 0; |
|||
} |
|||
|
|||
void powerOff() override { sd_power_system_off(); } |
|||
}; |
|||
Loading…
Reference in new issue