meshtastic 0.0.178 → 0.0.179

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89ae445ffe5b5a92527ac776eefac452593bdd34473a325c6048d8b19d3b7d9a
-  data.tar.gz: b3173a5209a3b9efefad113218573f399bb2f62ae794c037a1f5ea9c4ba24ed7
+  metadata.gz: 3fa03c5234c1b6d136fca93a0a37a5c9dd6588b116b6f932f457f4e139eee89c
+  data.tar.gz: 54d66239895c5989f8f8ee5423e63d05769bdecd6281d59d914b31561177fabd
 SHA512:
-  metadata.gz: 2e94b436cb0340c13a372e1e11c3cb85b9f26303ed2e7d667ba754eb205e30a84383894b494904d548b4d86bcce2c8a245fd85b03fd42b4a9e9c4d64de2cc696
-  data.tar.gz: 4d784f09138ee9ecf2c9fde1503adf3974b651a82a35e5f96ed3cb64109ecd9ceae007e582ca3e3b208fb0a2e574d9e9f11a3c1c5fd584518d199cd9c14ec3b3
+  metadata.gz: fd7705cf063ef5448b167dc7d3f1664dea20cc25ff1b1791a72de2e4a656afc11ef5717969b4171f65736448616e05f985a9a5c40dc11196559b9767a2b5b286
+  data.tar.gz: 506c41dfa105d57a5fae6febd3fa9748f30319c1a280f0ebbc5412d1bfd8b9f9330c337aba25033ee06e9fbc10fa4c600a28cecd61baab145422ec02162df238

data/README.md

@@ -24,185 +24,13 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-The primary interaction modules today are `Meshtastic::MQTT` (broker), `Meshtastic::Serial` (USB/UART), and `Meshtastic::Bluetooth` (BLE via Linux BlueZ). Examples for each follow.
-
-### MQTT
-
-To view MQTT messages, and include only messages containing `_APP` _and_ `LongFast` strings, use the following code:
-
-```ruby
-require 'meshtastic'
-Meshtastic::MQTT.help
-mqtt_obj = Meshtastic::MQTT.connect
-puts mqtt_obj.inspect
-Meshtastic::MQTT.subscribe(
-  mqtt_obj: mqtt_obj,
-  include: '_APP, LongFast'
-)
-```
-
-This code will dump the contents of every message:
-
-```ruby
-require 'meshtastic'
-mqtt_obj = Meshtastic::MQTT.connect
-Meshtastic::MQTT.subscribe(
-  mqtt_obj: mqtt_obj,
-  root_topic: 'msh',
-  region: 'US',
-  topic: '2/e/LongFast/#',
-  psks: { LongFast: 'AQ==' }
-) do |message|
-  puts message.inspect
-end
-```
-
-Sending a message over MQTT:
-
-```ruby
-require 'meshtastic'
-mqtt_obj = Meshtastic::MQTT.connect
-client_id = "!#{mqtt_obj.client_id}"
-Meshtastic::MQTT.send_text(
-  mqtt_obj: mqtt_obj,
-  from: client_id,
-  to: '!ffffffff',
-  root_topic: 'msh',
-  region: 'US',
-  topic: '2/e/LongFast/#',
-  channel: 93,
-  text: 'Hello, World!',
-  psks: { LongFast: 'AQ==' }
-)
-```
-
-One of the "gotchas" when sending messages is ensuring you're sending over the proper integer for the `channel` parameter.  The best way to determine the proper `channel` value is by sending a test message from within the meshtastic app and then viewing the MQTT message similar to the following:
+All usage examples live under [documentation/](documentation/README.md): transports (MQTT, Serial, Bluetooth, TCP), Admin and other feature modules, internals, and generated protobuf types.
 
 ```ruby
 require 'meshtastic'
-mqtt_obj = Meshtastic::MQTT.connect
-Meshtastic::MQTT.subscribe(
-  mqtt_obj: mqtt_obj,
-  root_topic: 'msh',
-  region: 'US',
-  topic: '2/e/LongFast/#',
-  psks: { LongFast: 'AQ==' },
-  include: '!YOUR_CLIENT_ID'
-) do |message|
-  puts message.inspect
-end
-```
-
-You should see something like this:
-
+Meshtastic.help          # constants in the namespace
+Meshtastic::Serial.help  # methods for one module
 ```
-{packet: {from: 3237997296, to: 4294967295, channel: 93, id: 1, rx_time: 1735689600, rx_snr: 0.0, hop_limit: 3, want_ack: false, priority: :HIGH, rx_rssi: 0, delayed: :NO_DELAY, via_mqtt: false, hop_start: 3, public_key: "", pki_encrypted: false, next_hop: 0, relay_node: 0, tx_after: 0, decoded: {portnum: :TEXT_MESSAGE_APP, payload: "WHAT IS MY channel VALUE?", want_response: false, dest: 0, source: 0, request_id: 0, reply_id: 0, emoji: 0, bitfield: 0}, encrypted: :decrypted, topic: "msh/US/2/e/LongFast/!c0ffee00", node_id_from: "!c0ffee00", node_id_to: "!ffffffff", rx_time_utc: "2025-01-01 00:00:00 UTC"}, channel_id: "LongFast", gateway_id: "!c0ffee00"}
-```
-
-Note where is says `channel: 93`.  This is the `channel` value required to send messages in this particular example.
-
-### Serial and Bluetooth (send / receive)
-
-`Meshtastic::Serial` (USB/UART) and `Meshtastic::Bluetooth` (Linux BLE via BlueZ) talk to a local radio using the same client API. The radio encrypts with its configured channel keys. Payloads are sent decoded; `channel:` is the index on the device, not an MQTT channel hash.
-
-Do not open Serial and Bluetooth to the same radio at once. Disconnect when finished (`ensure` is the reliable pattern). `send_text` / `send_data` report bytes written, not mesh delivery. `want_ack: true` requests a `ROUTING_APP` acknowledgment (`error_reason: NONE` means the local radio accepted the route). Incoming text is a UTF-8 string under `message[:packet][:decoded][:payload]`.
-
-Call `wait_for_config` before using `my_node_num` or sending. It raises `Timeout::Error` if the firmware never completes the handshake. Opening a port or pairing is not the same as a completed handshake.
-
-#### Serial (`Meshtastic::Serial`)
-
-Use the device’s USB CDC port (`/dev/ttyACM*` or `/dev/ttyUSB*`). Enable Radio Configuration → Security → Serial Console (`security.serial_enabled`). That is not Module Configuration → Serial (`TEXTMSG` / `PROTO` on GPIO). Keep “Override Console Serial Port” off.
-
-```ruby
-require 'meshtastic'
-
-serial_obj = nil
-begin
-  serial_obj = Meshtastic::Serial.connect(block_dev: '/dev/ttyACM0', baud: 115_200)
-  Meshtastic::Serial.wait_for_config(serial_obj: serial_obj, timeout: 10)
-  puts "local node: !#{serial_obj[:my_node_num].to_s(16)}"
-
-  # Direct message, or to: '!ffffffff' for the shared channel.
-  Meshtastic::Serial.send_text(
-    serial_obj: serial_obj,
-    to: '!aabbccdd',
-    channel: 0,
-    text: 'Hello over serial!',
-    want_ack: true
-  )
-
-  Meshtastic::Serial.subscribe(
-    serial_obj: serial_obj,
-    include: 'TEXT_MESSAGE_APP'
-  ) do |message|
-    packet = message[:packet]
-    puts "#{packet[:node_id_from]}: #{packet.dig(:decoded, :payload)}"
-  end
-ensure
-  Meshtastic::Serial.disconnect(serial_obj: serial_obj)
-end
-```
-
-Drive the loop yourself with `recv_from_radio(serial_obj:, timeout:)` (`0` polls, `nil` blocks) or `drain_from_radio`. A closed empty queue returns `nil`; an unplugged device raises `IOError`. If `wait_for_config` times out, the USB path is up but the Stream API is not (wrong port, Serial Console disabled, or firmware not responding).
-
-#### Bluetooth (`Meshtastic::Bluetooth`)
-
-Linux only (BlueZ + `ruby-dbus`). Connect with a BLE address (`AA:BB:CC:DD:EE:FF`), not a mesh id (`!11223344`). Pair first; this gem does not guess a PIN. BLE writes unframed ToRadio protobufs (no UART `0x94 0xC3` header).
-
-Scan:
-
-```ruby
-require 'meshtastic'
-Meshtastic::Bluetooth.scan(adapter: 'hci0', timeout: 5)
-# => [{ address: 'AA:BB:CC:DD:EE:FF', name: 'Meshtastic_eeff', paired: true }, ...]
-```
-
-Pair while discovery is running. Screen devices typically show a random 6-digit PIN:
-
-```text
-bluetoothctl
-agent KeyboardDisplay
-default-agent
-scan on
-pair AA:BB:CC:DD:EE:FF
-trust AA:BB:CC:DD:EE:FF
-scan off
-quit
-```
-
-`Failed to pair: AuthenticationFailed` means the agent never got the PIN. `Device … not available` means scan first; the advertisement dropped.
-
-Send and receive (same options as Serial, `bluetooth_obj:` instead of `serial_obj:`):
-
-```ruby
-require 'meshtastic'
-
-bluetooth_obj = nil
-begin
-  bluetooth_obj = Meshtastic::Bluetooth.connect(address: 'AA:BB:CC:DD:EE:FF')
-  Meshtastic::Bluetooth.wait_for_config(bluetooth_obj: bluetooth_obj, timeout: 30)
-
-  Meshtastic::Bluetooth.send_text(
-    bluetooth_obj: bluetooth_obj,
-    to: '!aabbccdd',
-    channel: 0,
-    text: 'Hello over BLE!',
-    want_ack: true
-  )
-
-  Meshtastic::Bluetooth.subscribe(
-    bluetooth_obj: bluetooth_obj,
-    include: 'TEXT_MESSAGE_APP'
-  ) do |message|
-    packet = message[:packet]
-    puts "#{packet[:node_id_from]}: #{packet.dig(:decoded, :payload)}"
-  end
-ensure
-  Meshtastic::Bluetooth.disconnect(bluetooth_obj: bluetooth_obj)
-end
-```
-
-Disconnect the phone’s Meshtastic BLE session while Linux is connected. After an aborted reconnect (`le-connection-abort-by-local`), `bluetoothctl disconnect <addr>` and wait a couple of seconds before `connect` again. Config dumps over BLE can take longer than serial; 30 seconds is a reasonable `wait_for_config` timeout.
 
 ## Contributing
 

data/documentation/README.md

@@ -0,0 +1,59 @@
+# Meshtastic Ruby documentation
+
+Usage for every constant in the `Meshtastic` namespace lives here. The root [README](../README.md) is install, expectations, and contributing only.
+
+`require 'meshtastic'` then `Meshtastic.help` lists loaded constants. Each first-class API module also has `.help` and `.authors`.
+
+Examples use placeholder addresses only:
+
+- Serial port: `/dev/ttyACM0`
+- BLE: `AA:BB:CC:DD:EE:FF`
+- Mesh node: `!aabbccdd` (destination), `!11223344` (local)
+- MQTT sample node: `!c0ffee00`
+- TCP radio: `192.0.2.10`
+- Broadcast: `!ffffffff` (protocol all-nodes address)
+
+## Transports
+
+- [Meshtastic::MQTT](mqtt.md)
+- [Meshtastic::Serial](serial.md)
+- [Meshtastic::Bluetooth](bluetooth.md)
+- [Meshtastic::Bluetooth::BlueZ](bluetooth-bluez.md)
+- [Meshtastic::TCP](tcp.md)
+
+Feature modules send protobufs over Serial, Bluetooth, or TCP via `Meshtastic.deliver_data`. Pass `serial_obj:`, `bluetooth_obj:`, or `tcp_obj:`. MQTT encrypts on the host; the radio encrypts on the other three.
+
+Do not open Serial and Bluetooth to the same radio at once. Always `disconnect` in `ensure`.
+
+## Feature modules
+
+- [Meshtastic::Admin](admin.md)
+- [Meshtastic::Channel](channel.md)
+- [Meshtastic::Config](config.md)
+- [Meshtastic::ModuleConfig](module-config.md)
+- [Meshtastic::Position](position.md)
+- [Meshtastic::Telemetry](telemetry.md)
+- [Meshtastic::Traceroute](traceroute.md)
+- [Meshtastic::RemoteHardware](remote-hardware.md)
+- [Meshtastic::Storeforward](storeforward.md)
+- [Meshtastic::ATAK](atak.md)
+- [Meshtastic::Paxcount](paxcount.md)
+- [Meshtastic::Cannedmessages](cannedmessages.md)
+- [Meshtastic::RTTTL](rtttl.md)
+- [Meshtastic::Portnums](portnums.md)
+- [Meshtastic::Apponly](apponly.md)
+- [Meshtastic::Clientonly](clientonly.md)
+- [Meshtastic::Deviceonly](deviceonly.md)
+- [Meshtastic::Localonly](localonly.md)
+- [Meshtastic::ConnectionStatus](connection-status.md)
+- [Meshtastic::Xmodem](xmodem.md)
+
+## Internals
+
+- [Meshtastic (top-level)](meshtastic.md)
+- [Meshtastic::MeshInterface](mesh-interface.md)
+- [Meshtastic::StreamInterface](stream-interface.md)
+- [Meshtastic::Util](util.md)
+- [Generated protobuf types](protobufs.md)
+
+Protobuf message classes that this gem reopens (`Channel`, `Config`, `Position`, `Telemetry`, `ModuleConfig`, `Paxcount`) must not define class methods named `send` or `encode` (those belong to protobuf). Use `get`/`set`, `transmit`, `build`, or `request` instead.

data/documentation/admin.md

@@ -0,0 +1,54 @@
+# Meshtastic::Admin
+
+Builds `Meshtastic::AdminMessage` and sends it on `ADMIN_APP` (port 6) through [Meshtastic.deliver_data](meshtastic.md). Pass a connected `serial_obj`, `bluetooth_obj`, or `tcp_obj`.
+
+Responses come back as `FromRadio` packets on the same transport (`subscribe` / `recv_from_radio`).
+
+## Methods
+
+- `encode` — copies matching keys onto an `AdminMessage`
+- `send` — wrap and deliver (`want_response` default true)
+- `reboot(seconds: 5)`
+- `shutdown(seconds: 5)`
+- `get_owner` / `set_owner(long_name:, short_name:, owner:)`
+- `get_channel(index:)` / `set_channel(channel_settings:)`
+- `get_config(config_type:)` / `set_config(config:)`
+- `nodedb_reset`
+- `help` / `authors`
+
+`config_type` values: `:DEVICE_CONFIG`, `:POSITION_CONFIG`, `:POWER_CONFIG`, `:NETWORK_CONFIG`, `:DISPLAY_CONFIG`, `:LORA_CONFIG`, `:BLUETOOTH_CONFIG`, `:SECURITY_CONFIG`, `:SESSIONKEY_CONFIG`, `:DEVICEUI_CONFIG`.
+
+Any other `AdminMessage` field can be passed to `send` / `encode` (for example `set_ringtone_message`, `get_module_config_request`).
+
+## Examples
+
+```ruby
+require 'meshtastic'
+
+serial_obj = Meshtastic::Serial.connect(block_dev: '/dev/ttyACM0')
+Meshtastic::Serial.wait_for_config(serial_obj: serial_obj)
+
+Meshtastic::Admin.set_owner(serial_obj: serial_obj, long_name: 'Node', short_name: 'N1')
+Meshtastic::Admin.get_owner(serial_obj: serial_obj)
+Meshtastic::Admin.get_config(serial_obj: serial_obj, config_type: :LORA_CONFIG)
+Meshtastic::Admin.get_channel(serial_obj: serial_obj, index: 0)
+Meshtastic::Admin.reboot(serial_obj: serial_obj, seconds: 5)
+# Meshtastic::Admin.shutdown(serial_obj: serial_obj, seconds: 5)
+# Meshtastic::Admin.nodedb_reset(serial_obj: serial_obj)
+```
+
+Raw field:
+
+```ruby
+Meshtastic::Admin.send(
+  serial_obj: serial_obj,
+  factory_reset_config: true
+)
+```
+
+## Related
+
+- [Meshtastic::Channel](channel.md)
+- [Meshtastic::Config](config.md)
+- [Meshtastic::ModuleConfig](module-config.md)
+- [Meshtastic::RTTTL](rtttl.md)

data/documentation/apponly.md

@@ -0,0 +1,22 @@
+# Meshtastic::Apponly
+
+App-side channel export: `Meshtastic::ChannelSet` (from `apponly.proto`).
+
+## Methods
+
+- `encode(settings:, lora_config:)`
+- `decode(bytes)`
+- `help` / `authors`
+
+## Example
+
+```ruby
+set = Meshtastic::Apponly.encode(
+  settings: [Meshtastic::ChannelSettings.new(name: 'LongFast')]
+)
+round_trip = Meshtastic::Apponly.decode(set.to_proto)
+```
+
+## Related
+
+- [Meshtastic::Channel](channel.md)

data/documentation/atak.md

@@ -0,0 +1,27 @@
+# Meshtastic::ATAK
+
+Encodes `Meshtastic::TAKPacket` and sends it on `ATAK_PLUGIN` (port 72).
+
+## Methods
+
+- `encode(is_compressed:, chat:, message:)` — `message:` builds a `GeoChat`
+- `send`
+- `help` / `authors`
+
+## Example
+
+```ruby
+Meshtastic::ATAK.send(
+  serial_obj: serial_obj,
+  message: 'ATAK chat'
+)
+
+packet = Meshtastic::ATAK.encode(message: 'ATAK chat')
+packet.chat.message # => "ATAK chat"
+```
+
+Related protobufs: `TAKPacket`, `GeoChat`, `Contact`, `Group`, `PLI`, `TAKPacketV2`. See [protobufs.md](protobufs.md).
+
+## Related
+
+- [Meshtastic::ModuleConfig](module-config.md) (`:TAK_CONFIG`)

data/documentation/bluetooth-bluez.md

@@ -0,0 +1,35 @@
+# Meshtastic::Bluetooth::BlueZ
+
+Linux D-Bus backend used by [Meshtastic::Bluetooth](bluetooth.md). You normally call `Meshtastic::Bluetooth.scan` / `connect` instead of this class.
+
+## Constants
+
+- `SERVICE_UUID`
+- `TORADIO_UUID`
+- `FROMRADIO_UUID`
+
+## Methods
+
+- `BlueZ.scan(adapter: 'hci0', timeout: 5)` — `StartDiscovery` then list Device1 objects on that adapter. Returns `{ address:, name:, paired: }`.
+- `#connect` — requires an already paired device; raises if not paired or `ServicesResolved` times out
+- `#read` / write ToRadio characteristic
+- `#close`
+
+Requires `ruby-dbus`. Uses the system bus. D-Bus calls are serialized on a mutex.
+
+```ruby
+require 'meshtastic'
+
+hits = Meshtastic::Bluetooth::BlueZ.scan(adapter: 'hci0', timeout: 5)
+hits.each { |d| puts "#{d[:address]} #{d[:name]} paired=#{d[:paired]}" }
+
+conn = Meshtastic::Bluetooth::BlueZ.new(address: 'AA:BB:CC:DD:EE:FF', adapter: 'hci0', timeout: 15)
+conn.connect
+conn.close
+```
+
+Pairing is outside this class (`bluetoothctl`). The module will not try PIN values.
+
+## Related
+
+- [Meshtastic::Bluetooth](bluetooth.md)

data/documentation/bluetooth.md

@@ -0,0 +1,87 @@
+# Meshtastic::Bluetooth
+
+Linux BLE client (BlueZ + `ruby-dbus`). Same send/receive API as Serial, with `bluetooth_obj:` instead of `serial_obj:`.
+
+Connect with a BLE address (`AA:BB:CC:DD:EE:FF`), not a mesh id (`!11223344`). Pair first; this gem does not guess a PIN. BLE writes unframed `ToRadio` protobufs (no UART `0x94 0xC3` header).
+
+Do not open Serial and Bluetooth to the same radio at once. Disconnect the phone’s Meshtastic BLE session while Linux is connected.
+
+## Methods
+
+- `scan(adapter:, timeout:)`
+- `connect(address:, adapter:, timeout:, want_config:)`
+- `wait_for_config` — 30 seconds is a reasonable BLE timeout
+- `send_text` / `send_data` / `send_to_radio`
+- `recv_from_radio` / `drain_from_radio`
+- `dump_stdout_data` / `flush_data`
+- `subscribe`
+- `disconnect`
+- `help` / `authors`
+
+## Scan
+
+```ruby
+require 'meshtastic'
+Meshtastic::Bluetooth.scan(adapter: 'hci0', timeout: 5)
+# => [{ address: 'AA:BB:CC:DD:EE:FF', name: 'Meshtastic_eeff', paired: true }, ...]
+```
+
+## Pair
+
+Pair while discovery is running. Screen devices typically show a random 6-digit PIN. Do not invent PIN values.
+
+```text
+bluetoothctl
+agent KeyboardDisplay
+default-agent
+scan on
+pair AA:BB:CC:DD:EE:FF
+trust AA:BB:CC:DD:EE:FF
+scan off
+quit
+```
+
+`Failed to pair: AuthenticationFailed` means the agent never got the PIN. `Device … not available` means scan first; the advertisement dropped.
+
+## Send / receive
+
+```ruby
+require 'meshtastic'
+
+bluetooth_obj = nil
+begin
+  bluetooth_obj = Meshtastic::Bluetooth.connect(address: 'AA:BB:CC:DD:EE:FF')
+  Meshtastic::Bluetooth.wait_for_config(bluetooth_obj: bluetooth_obj, timeout: 30)
+
+  Meshtastic::Bluetooth.send_text(
+    bluetooth_obj: bluetooth_obj,
+    to: '!aabbccdd',
+    channel: 0,
+    text: 'Hello over BLE!',
+    want_ack: true
+  )
+
+  Meshtastic::Bluetooth.subscribe(
+    bluetooth_obj: bluetooth_obj,
+    include: 'TEXT_MESSAGE_APP'
+  ) do |message|
+    packet = message[:packet]
+    puts "#{packet[:node_id_from]}: #{packet.dig(:decoded, :payload)}"
+  end
+ensure
+  Meshtastic::Bluetooth.disconnect(bluetooth_obj: bluetooth_obj)
+end
+```
+
+After an aborted reconnect (`le-connection-abort-by-local`), `bluetoothctl disconnect <addr>` and wait a couple of seconds before `connect` again.
+
+GATT UUIDs (see [BlueZ](bluetooth-bluez.md)):
+
+- Service `6ba1b218-15a8-461f-9fa8-5dcae273eafd`
+- ToRadio `f75c76d2-129e-4dad-a1dd-7866124401e7`
+- FromRadio `2c55e69e-4993-11ed-b878-0242ac120002`
+
+## Related
+
+- [Meshtastic::Bluetooth::BlueZ](bluetooth-bluez.md)
+- [Meshtastic::Serial](serial.md)

data/documentation/cannedmessages.md

@@ -0,0 +1,25 @@
+# Meshtastic::Cannedmessages
+
+Wraps `Meshtastic::CannedMessageModuleConfig` (`messages` is a newline-separated string).
+
+## Methods
+
+- `encode(messages:)`
+- `send` — publishes the string on `TEXT_MESSAGE_APP` (not an admin set). To store canned lines on the device, use [Admin](admin.md) `set_canned_message_module_messages` or [ModuleConfig](module-config.md).
+- `help` / `authors`
+
+## Example
+
+```ruby
+cfg = Meshtastic::Cannedmessages.encode(messages: "Yes\nNo\nMaybe")
+cfg.messages # => "Yes\nNo\nMaybe"
+
+Meshtastic::Admin.send(
+  serial_obj: serial_obj,
+  set_canned_message_module_messages: "Yes\nNo\nMaybe"
+)
+```
+
+## Related
+
+- [Meshtastic::Admin](admin.md)

data/documentation/channel.md

@@ -0,0 +1,30 @@
+# Meshtastic::Channel
+
+Reopens the generated `Meshtastic::Channel` protobuf class with get/set helpers that call [Admin](admin.md).
+
+This is a protobuf class, not a Ruby module. Do not add class methods named `send` or `encode`.
+
+## Methods
+
+- `get(serial_obj:, index:)` — `get_channel_request`
+- `set(serial_obj:, channel:)` — `set_channel`
+- `help` / `authors`
+
+Also all protobuf instance fields: `index`, `settings` (`ChannelSettings`), `role` (`:DISABLED`, `:PRIMARY`, `:SECONDARY`).
+
+## Example
+
+```ruby
+Meshtastic::Channel.get(serial_obj: serial_obj, index: 0)
+
+settings = Meshtastic::ChannelSettings.new(name: 'LongFast', psk: "\x01")
+channel = Meshtastic::Channel.new(index: 0, settings: settings, role: :PRIMARY)
+Meshtastic::Channel.set(serial_obj: serial_obj, channel: channel)
+```
+
+Listen for `ADMIN_APP` replies on the same transport.
+
+## Related
+
+- [Meshtastic::Admin](admin.md)
+- [Meshtastic::Apponly](apponly.md) (`ChannelSet`)

data/documentation/clientonly.md

@@ -0,0 +1,21 @@
+# Meshtastic::Clientonly
+
+Client-side `Meshtastic::DeviceProfile` encode/decode (`clientonly.proto`).
+
+## Methods
+
+- `encode(long_name:, short_name:)`
+- `decode(bytes)`
+- `help` / `authors`
+
+## Example
+
+```ruby
+profile = Meshtastic::Clientonly.encode(long_name: 'Node', short_name: 'N1')
+profile.long_name # => "Node"
+Meshtastic::Clientonly.decode(profile.to_proto)
+```
+
+## Related
+
+- [Meshtastic::Admin](admin.md) (`set_owner`)

data/documentation/config.md

@@ -0,0 +1,29 @@
+# Meshtastic::Config
+
+Reopens the generated `Meshtastic::Config` protobuf class. Get/set go through [Admin](admin.md).
+
+## Methods
+
+- `get(serial_obj:, config_type: :DEVICE_CONFIG)`
+- `set(serial_obj:, config:)` — `config` is a `Meshtastic::Config`
+- `help` / `authors`
+
+Protobuf oneofs include `device`, `position`, `power`, `network`, `display`, `lora`, `bluetooth`, `security`, `sessionkey`, `device_ui`.
+
+## Example
+
+```ruby
+Meshtastic::Config.get(serial_obj: serial_obj, config_type: :LORA_CONFIG)
+
+config = Meshtastic::Config.new
+config.device = Meshtastic::Config::DeviceConfig.new(role: :CLIENT)
+Meshtastic::Config.set(serial_obj: serial_obj, config: config)
+```
+
+`config_type` list: [Admin](admin.md).
+
+## Related
+
+- [Meshtastic::Admin](admin.md)
+- [Meshtastic::ModuleConfig](module-config.md)
+- [Meshtastic::Localonly](localonly.md)

data/documentation/connection-status.md

@@ -0,0 +1,22 @@
+# Meshtastic::ConnectionStatus
+
+Decodes `Meshtastic::DeviceConnectionStatus`.
+
+## Methods
+
+- `decode(bytes)`
+- `help` / `authors`
+
+## Example
+
+```ruby
+status = Meshtastic::ConnectionStatus.decode(
+  Meshtastic::DeviceConnectionStatus.new.to_proto
+)
+```
+
+Related types: `WifiConnectionStatus`, `EthernetConnectionStatus`, `NetworkConnectionStatus`, `BluetoothConnectionStatus`, `SerialConnectionStatus`.
+
+## Related
+
+- [Generated protobuf types](protobufs.md)

data/documentation/deviceonly.md

@@ -0,0 +1,22 @@
+# Meshtastic::Deviceonly
+
+Decodes device-only snapshots: `DeviceState` and `NodeDatabase`.
+
+## Methods
+
+- `decode_state(bytes)`
+- `decode_nodedb(bytes)`
+- `help` / `authors`
+
+## Example
+
+```ruby
+state = Meshtastic::Deviceonly.decode_state(Meshtastic::DeviceState.new.to_proto)
+nodedb = Meshtastic::Deviceonly.decode_nodedb(Meshtastic::NodeDatabase.new.to_proto)
+```
+
+Related types: `PositionLite`, `UserLite`, `NodeInfoLite`, `ChannelFile`, `BackupPreferences`.
+
+## Related
+
+- [Meshtastic::Localonly](localonly.md)

data/documentation/localonly.md

@@ -0,0 +1,21 @@
+# Meshtastic::Localonly
+
+Decodes `LocalConfig` and `LocalModuleConfig` (full config blobs stored on the client).
+
+## Methods
+
+- `decode_config(bytes)`
+- `decode_module_config(bytes)`
+- `help` / `authors`
+
+## Example
+
+```ruby
+Meshtastic::Localonly.decode_config(Meshtastic::LocalConfig.new.to_proto)
+Meshtastic::Localonly.decode_module_config(Meshtastic::LocalModuleConfig.new.to_proto)
+```
+
+## Related
+
+- [Meshtastic::Config](config.md)
+- [Meshtastic::ModuleConfig](module-config.md)