meshtastic 0.0.176 → 0.0.177

data/lib/meshtastic/bluetooth.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'timeout'
+
+# Meshtastic client API over Bluetooth Low Energy, using Linux BlueZ and Ruby D-Bus.
+module Meshtastic
+  module Bluetooth
+    autoload :BlueZ, 'meshtastic/bluetooth/bluez'
+
+    def self.scan(opts = {})
+      BlueZ.scan(adapter: opts.fetch(:adapter, 'hci0'), timeout: opts.fetch(:timeout, 5))
+    end
+
+    # Connect to an already paired BLE address (not a mesh node ID).
+    def self.connect(opts = {})
+      connection = BlueZ.new(address: opts[:address], adapter: opts.fetch(:adapter, 'hci0'), timeout: opts.fetch(:timeout, 15))
+      connection.connect
+      bluetooth_obj = {
+        bluetooth_conn: connection, address: opts[:address], tx_mutex: Mutex.new,
+        rx_mutex: Mutex.new, from_radio_queue: Queue.new, config_queue: Queue.new,
+        proto_data: [], console_data: []
+      }
+      bluetooth_obj[:rx_thread] = start_reader(bluetooth_obj)
+      if opts.fetch(:want_config, true)
+        mesh = Meshtastic::MeshInterface.new
+        bytes = mesh.start_config
+        bluetooth_obj[:config_id] = mesh.config_id
+        send_to_radio(bluetooth_obj: bluetooth_obj, to_radio: bytes)
+      end
+      @last_bluetooth_obj = bluetooth_obj
+      bluetooth_obj
+    rescue StandardError
+      bluetooth_obj ? disconnect(bluetooth_obj: bluetooth_obj) : connection&.close
+      raise
+    end
+
+    private_class_method def self.start_reader(handle)
+      Thread.new do
+        until handle[:closing]
+          bytes = handle[:bluetooth_conn].read
+          if bytes.empty?
+            sleep 0.1
+            next
+          end
+          receive_bytes(handle, bytes)
+        end
+      rescue StandardError => e
+        handle[:rx_error] = IOError.new("Bluetooth receive failed: #{e.message}") unless handle[:closing]
+      ensure
+        handle[:from_radio_queue].close
+        handle[:config_queue].close
+      end
+    end
+
+    private_class_method def self.receive_bytes(handle, bytes)
+      message = Meshtastic::FromRadio.decode(bytes)
+      if message.my_info
+        handle[:my_info] = message.my_info.to_h
+        handle[:my_node_num] = message.my_info.my_node_num
+      end
+      handle[:metadata] = message.metadata.to_h if message.metadata
+      handle[:rx_mutex].synchronize do
+        handle[:proto_data] << message.to_h
+        handle[:console_data] << "#{message.log_record.message}\n" if message.log_record
+      end
+      handle[:from_radio_queue] << message
+      if message.payload_variant == :config_complete_id && message.config_complete_id == handle[:config_id]
+        handle[:config_complete] = true
+        handle[:config_queue].close
+      end
+    rescue Google::Protobuf::ParseError => e
+      warn "Meshtastic::Bluetooth: failed to decode FromRadio (#{e.message})"
+    end
+
+    private_class_method def self.handle_for(opts)
+      handle = opts[:bluetooth_obj] || @last_bluetooth_obj
+      raise ArgumentError, 'bluetooth_obj is required; call connect first' unless handle
+
+      handle
+    end
+
+    def self.wait_for_config(opts = {})
+      handle = handle_for(opts)
+      raise ArgumentError, 'connect with want_config: true first' unless handle[:config_id]
+
+      handle[:config_queue].pop(timeout: opts.fetch(:timeout, 10))
+      raise handle[:rx_error] if handle[:rx_error]
+      raise IOError, 'Bluetooth connection closed' if handle[:closing]
+      raise Timeout::Error, "No configuration response from #{handle[:address]}" unless handle[:config_complete]
+
+      handle
+    end
+
+    def self.recv_from_radio(opts = {})
+      handle = handle_for(opts)
+      timeout = opts.fetch(:timeout, 5)
+      timeout = nil if timeout&.negative?
+      message = handle[:from_radio_queue].pop(timeout: timeout)
+      raise handle[:rx_error] if message.nil? && handle[:rx_error]
+
+      message
+    end
+
+    def self.drain_from_radio(opts = {})
+      handle = handle_for(opts)
+      messages = []
+      opts.fetch(:max, 256).times do
+        message = recv_from_radio(bluetooth_obj: handle, timeout: 0)
+        break unless message
+
+        messages << message
+      end
+      messages
+    end
+
+    def self.dump_stdout_data(opts = {}, &)
+      Meshtastic::Serial.dump_stdout_data(opts.merge(serial_obj: handle_for(opts)), &)
+    end
+
+    def self.flush_data(opts = {})
+      Meshtastic::Serial.flush_data(opts.merge(serial_obj: handle_for(opts)))
+    end
+
+    # Yield the same enriched FromRadio hashes as Serial, without opening a UART.
+    def self.subscribe(opts = {})
+      handle = handle_for(opts)
+      psks = opts.fetch(:psks, { LongFast: 'AQ==' }).dup
+      raise ArgumentError, 'psks must be a hash' unless psks.is_a?(Hash)
+
+      psks[:LongFast] = '1PG7OiApB1nwvP+rz05pAQ==' if psks[:LongFast] == 'AQ=='
+      psks = Meshtastic::MeshInterface.new.get_cipher_keys(psks: psks)
+      includes = opts[:include].to_s.split(',').map(&:strip)
+      excludes = opts[:exclude].to_s.split(',').map(&:strip)
+      loop do
+        message = recv_from_radio(bluetooth_obj: handle, timeout: opts[:timeout])
+        break if message.nil? && handle[:from_radio_queue].closed?
+        next unless message
+
+        decoded = message.to_h
+        if decoded[:packet]
+          # Share the existing pure packet decoder; BLE never uses Serial's IO methods.
+          decoded[:packet] = Meshtastic::Serial.send(:enrich_packet,
+                                                     message: decoded[:packet], psks: psks,
+                                                     gps_metadata: opts[:gps_metadata], include_raw: opts[:include_raw],
+                                                     raw_packet: opts[:include_raw] ? message.to_proto : nil)
+        end
+        source = decoded.inspect
+        next unless includes.all? { |term| source.include?(term) } && excludes.none? { |term| source.include?(term) }
+
+        if block_given?
+          yield decoded
+        else
+          begin
+            puts JSON.pretty_generate(decoded)
+          rescue JSON::GeneratorError
+            puts decoded.inspect
+          end
+        end
+      end
+    rescue Interrupt
+      disconnect(bluetooth_obj: handle)
+    rescue StandardError
+      disconnect(bluetooth_obj: handle)
+      raise
+    end
+
+    # Write one complete serialized ToRadio to GATT. BLE does not use UART headers.
+    def self.send_to_radio(opts = {})
+      handle = opts[:bluetooth_obj]
+      raise ArgumentError, 'bluetooth_obj is required' unless handle
+      raise IOError, 'Bluetooth connection closed' if handle[:closing]
+
+      message = opts[:to_radio]
+      body = case message
+             when Meshtastic::ToRadio then message.to_proto
+             when String then message.b
+             else raise ArgumentError, 'to_radio must be Meshtastic::ToRadio or a serialized String'
+             end
+      raise ArgumentError, 'ToRadio payload exceeds 512 bytes' if body.bytesize > Meshtastic::MAX_TO_FROM_RADIO_SIZE
+
+      begin
+        handle[:tx_mutex].synchronize { handle[:bluetooth_conn].write(body) }
+      rescue StandardError
+        disconnect(bluetooth_obj: handle)
+        raise
+      end
+    end
+
+    def self.send_text(opts = {})
+      handle = opts[:bluetooth_obj]
+      raise ArgumentError, 'bluetooth_obj is required' unless handle
+
+      text = opts.fetch(:text, 'SYN').to_s
+      max_len = Meshtastic::Constants::DATA_PAYLOAD_LEN
+      raise ArgumentError, "Text Length > #{max_len} Bytes" if text.bytesize > max_len
+
+      args = opts.merge(text: text, via: :radio, psks: nil, channel: opts.fetch(:channel, 0), from: opts[:from] || handle[:my_node_num] || 0)
+      send_to_radio(bluetooth_obj: handle, to_radio: Meshtastic::MeshInterface.new.send_text(args))
+    end
+
+    def self.send_data(opts = {})
+      handle = opts[:bluetooth_obj]
+      raise ArgumentError, 'bluetooth_obj is required' unless handle
+      raise ArgumentError, 'data must be Meshtastic::Data' unless opts[:data].is_a?(Meshtastic::Data)
+
+      args = opts.merge(via: :radio, psks: nil, channel: opts.fetch(:channel, 0), from: opts[:from] || handle[:my_node_num] || 0)
+      send_to_radio(bluetooth_obj: handle, to_radio: Meshtastic::MeshInterface.new.send_data(args))
+    end
+
+    def self.disconnect(opts = {})
+      handle = opts[:bluetooth_obj]
+      return unless handle
+      return if handle[:closing]
+
+      handle[:closing] = true
+      handle[:from_radio_queue].close
+      handle[:config_queue].close
+      begin
+        handle[:tx_mutex].synchronize do
+          handle[:bluetooth_conn].write(Meshtastic::ToRadio.new(disconnect: true).to_proto)
+        end
+      rescue StandardError
+        # A lost BLE link cannot receive a disconnect request.
+        nil
+      ensure
+        handle[:bluetooth_conn].close
+        reader = handle[:rx_thread]
+        reader.join(1) if reader && reader != Thread.current
+      end
+      nil
+    end
+
+    def self.authors
+      "AUTHOR(S):\n        0day Inc. <support@0dayinc.com>\n      "
+    end
+
+    def self.help
+      puts "Send and receive Meshtastic messages over Bluetooth Low Energy (Linux BlueZ).
+      BLE writes unframed ToRadio protobufs (no UART START1/START2 header). Pair first with bluetoothctl.
+
+      USAGE:
+        devices = #{self}.scan(
+          adapter: 'optional - BlueZ adapter (default: hci0)',
+          timeout: 'optional - discovery seconds (default: 5)'
+        )
+
+        bluetooth_obj = #{self}.connect(
+          address: 'required - BLE address (AA:BB:CC:DD:EE:FF), not a mesh node ID',
+          adapter: 'optional - BlueZ adapter (default: hci0)',
+          timeout: 'optional - D-Bus/connect seconds (default: 15)',
+          want_config: 'optional - request full node DB after connect (default: true)'
+        )
+
+        #{self}.wait_for_config(
+          bluetooth_obj: 'required - bluetooth_obj connected with want_config: true',
+          timeout: 'optional - seconds to await configuration (default: 10)'
+        )
+
+        #{self}.send_to_radio(
+          bluetooth_obj: 'required - bluetooth_obj returned from #connect',
+          to_radio: 'required - Meshtastic::ToRadio OR serialized String'
+        )
+
+        from_radio = #{self}.recv_from_radio(
+          bluetooth_obj: 'optional - bluetooth_obj (default: most recently opened connection)',
+          timeout: 'optional - seconds (default: 5; 0 = poll; nil = block forever)'
+        )
+
+        msgs = #{self}.drain_from_radio(bluetooth_obj: bluetooth_obj, max: 256)
+
+        #{self}.subscribe(
+          bluetooth_obj: 'required - bluetooth_obj returned from #connect',
+          include: 'optional - comma-delimited string(s) to include',
+          exclude: 'optional - comma-delimited string(s) to exclude'
+        )
+
+        #{self}.send_text(
+          bluetooth_obj: 'required - bluetooth_obj returned from #connect',
+          to: 'optional - Destination ID (Default: \"!ffffffff\")',
+          channel: 'optional - channel index (Default: 0)',
+          text: 'optional - Text Message (Default: SYN)',
+          want_ack: 'optional - Want Acknowledgement (Default: false)'
+        )
+
+        #{self}.send_data(
+          bluetooth_obj: 'required - bluetooth_obj returned from #connect',
+          data: 'required - Meshtastic::Data',
+          to: 'optional - Destination ID (Default: \"!ffffffff\")',
+          channel: 'optional - channel index (Default: 0)'
+        )
+
+        #{self}.disconnect(bluetooth_obj: bluetooth_obj)
+
+        #{self}.authors
+      "
+    end
+  end
+end

data/lib/meshtastic/lorawan_bridge_pb.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: meshtastic/lorawan_bridge.proto
+
+require 'google/protobuf'
+
+
+descriptor_data = "\n\x1fmeshtastic/lorawan_bridge.proto\x12\nmeshtastic\"\xfc\x07\n\rLoRaWANBridge\x12\x32\n\x06uplink\x18\x01 \x01(\x0b\x32 .meshtastic.LoRaWANBridge.UplinkH\x00\x12\x36\n\x08\x64ownlink\x18\x02 \x01(\x0b\x32\".meshtastic.LoRaWANBridge.DownlinkH\x00\x12\x37\n\ttx_result\x18\x03 \x01(\x0b\x32\".meshtastic.LoRaWANBridge.TxResultH\x00\x12\x37\n\x05\x63hunk\x18\x04 \x01(\x0b\x32&.meshtastic.LoRaWANBridge.PayloadChunkH\x00\x1a\xaf\x01\n\x06Uplink\x12\x0f\n\x07\x66req_hz\x18\x01 \x01(\x07\x12\x0c\n\x04tmst\x18\x02 \x01(\x07\x12\x10\n\x08rssi_x10\x18\x03 \x01(\x11\x12\x0f\n\x07snr_x10\x18\x04 \x01(\x11\x12\x14\n\x0cradio_params\x18\x05 \x01(\r\x12\x13\n\x0b\x66sk_bitrate\x18\t \x01(\r\x12\x0f\n\x07payload\x18\x06 \x01(\x0c\x12\x12\n\npayload_id\x18\x07 \x01(\r\x12\x13\n\x0b\x63hunk_count\x18\x08 \x01(\r\x1a\xef\x01\n\x08\x44ownlink\x12\x0f\n\x07\x66req_hz\x18\x01 \x01(\x07\x12\x0c\n\x04tmst\x18\x02 \x01(\x07\x12\x14\n\x0cradio_params\x18\x03 \x01(\r\x12\x11\n\tpower_dbm\x18\x04 \x01(\r\x12\x11\n\timmediate\x18\x05 \x01(\x08\x12\x17\n\x0finvert_polarity\x18\x06 \x01(\x08\x12\x0e\n\x06no_crc\x18\x07 \x01(\x08\x12\x11\n\tmay_defer\x18\x08 \x01(\x08\x12\x12\n\nrequest_id\x18\x0c \x01(\r\x12\x0f\n\x07payload\x18\t \x01(\x0c\x12\x12\n\npayload_id\x18\n \x01(\r\x12\x13\n\x0b\x63hunk_count\x18\x0b \x01(\r\x1aN\n\x0cPayloadChunk\x12\x12\n\npayload_id\x18\x01 \x01(\r\x12\x13\n\x0b\x63hunk_index\x18\x02 \x01(\r\x12\x15\n\rpayload_chunk\x18\x03 \x01(\x0c\x1a\x8d\x02\n\x08TxResult\x12\x0c\n\x04tmst\x18\x01 \x01(\x07\x12\x39\n\x06status\x18\x02 \x01(\x0e\x32).meshtastic.LoRaWANBridge.TxResult.Status\x12\x12\n\nrequest_id\x18\x03 \x01(\r\"\xa3\x01\n\x06Status\x12\x08\n\x04NONE\x10\x00\x12\x0c\n\x08TOO_LATE\x10\x01\x12\r\n\tTOO_EARLY\x10\x02\x12\x14\n\x10\x43OLLISION_PACKET\x10\x03\x12\x14\n\x10\x43OLLISION_BEACON\x10\x04\x12\x0b\n\x07TX_FREQ\x10\x05\x12\x0c\n\x08TX_POWER\x10\x06\x12\x10\n\x0cGPS_UNLOCKED\x10\x07\x12\x0c\n\x08\x44\x45\x46\x45RRED\x10\x08\x12\x0b\n\x07\x44ROPPED\x10\tB\t\n\x07variantBi\n\x14org.meshtastic.protoB\x13LoRaWANBridgeProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3"
+
+pool = ::Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Meshtastic
+  LoRaWANBridge = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("meshtastic.LoRaWANBridge").msgclass
+  LoRaWANBridge::Uplink = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("meshtastic.LoRaWANBridge.Uplink").msgclass
+  LoRaWANBridge::Downlink = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("meshtastic.LoRaWANBridge.Downlink").msgclass
+  LoRaWANBridge::PayloadChunk = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("meshtastic.LoRaWANBridge.PayloadChunk").msgclass
+  LoRaWANBridge::TxResult = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("meshtastic.LoRaWANBridge.TxResult").msgclass
+  LoRaWANBridge::TxResult::Status = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("meshtastic.LoRaWANBridge.TxResult.Status").enummodule
+end

data/lib/meshtastic/mesh_interface.rb

@@ -477,7 +477,9 @@ module Meshtastic
         decoder = Meshtastic::StoreAndForward
       when :TELEMETRY_APP
         decoder = Meshtastic::Telemetry
-      when :TEXT_MESSAGE_APP, :UNKNOWN_APP
+      when :TEXT_MESSAGE_APP
+        return payload.dup.force_encoding(Encoding::UTF_8).scrub
+      when :UNKNOWN_APP
         decoder = Meshtastic::Data
       when :TRACEROUTE_APP
         decoder = Meshtastic::RouteDiscovery

data/lib/meshtastic/mqtt.rb

@@ -213,14 +213,8 @@ module Meshtastic
           if message.is_a?(Hash)
             flat_message = message.values.join(' ')
 
-            disp = false
-            # disp = true if exclude_arr.none? { |exclude| flat_message.include?(exclude) } && (
-            #                  include_arr.first == message[:id] ||
-            #                  include_arr.all? { |include| flat_message.include?(include) }
-            #                )
-
-            disp = true if !exclude_arr.intersect?(flat_message) &&
-                           include_arr.all? { |include| flat_message.include?(include) }
+            disp = exclude_arr.none? { |exc| flat_message.include?(exc) } &&
+                   include_arr.all? { |inc| flat_message.include?(inc) }
 
             if disp
               if block_given?
@@ -276,33 +270,12 @@ module Meshtastic
       opts[:topic] = absolute_topic
       opts[:via] = :mqtt
 
-      # TODO: Implement chunked message to deal with large messages
-      text = opts[:text].to_s
-      max_bytes = 231
-      mui = Meshtastic::MeshInterface.new
+      text = opts.fetch(:text, 'SYN').to_s
+      max_len = Meshtastic::Constants::DATA_PAYLOAD_LEN
+      raise ArgumentError, "ERROR: Text Length > #{max_len} Bytes" if text.bytesize > max_len
 
-      if text.bytesize > max_bytes
-        total_chunks = (text.bytesize.to_f / max_bytes).ceil
-        total_chunks.times do |i|
-          chunk_num = i + 1
-          chunk_prefix = " (#{chunk_num} of #{total_chunks})\n"
-          chunk_prefix_len = chunk_prefix.bytesize
-          start_index = i * (max_bytes - chunk_prefix_len)
-          end_index = (start_index + (max_bytes - chunk_prefix_len)) - 1
-          chunk = "#{chunk_prefix} #{text.byteslice(start_index..end_index)}"
-          # This addresses a weird bug in the protocal if the first byte
-          # is an h or H followed by a single byte, which returns
-          # {} or {bitfiled: INT}
-          opts[:text] = chunk
-          protobuf_chunk = mui.send_text(opts)
-          mqtt_obj.publish(absolute_topic, protobuf_chunk)
-          sleep 0.3
-        end
-      else
-        opts[:text] = " #{text}"
-        protobuf_text = mui.send_text(opts)
-        mqtt_obj.publish(absolute_topic, protobuf_text)
-      end
+      opts[:text] = text
+      mqtt_obj.publish(absolute_topic, Meshtastic::MeshInterface.new.send_text(opts))
     rescue StandardError => e
       raise e
     end