meshtastic 0.0.179 → 0.0.180

data/lib/meshtastic/atak.rb

@@ -1,37 +1,315 @@
 # frozen_string_literal: true
 
 require 'meshtastic/atak_pb'
+require 'meshtastic/portnums_pb'
+require 'zlib'
 
 module Meshtastic
   module ATAK
-    def self.encode(opts = {})
-      packet = Meshtastic::TAKPacket.new
-      packet.is_compressed = opts.fetch(:is_compressed, false)
-      if opts[:chat]
-        packet.chat = opts[:chat]
-      elsif opts[:message]
-        packet.chat = Meshtastic::GeoChat.new(message: opts[:message])
-      end
+    V1_PORT = Meshtastic::PortNum::ATAK_PLUGIN
+    V2_PORT = Meshtastic::PortNum::ATAK_PLUGIN_V2
+    FORWARDER_PORT = Meshtastic::PortNum::ATAK_FORWARDER
+    V2_UNCOMPRESSED = 0xFF
+    COORD_SCALE = 10_000_000
+    SKIP_KEYS = %i[
+      serial_obj bluetooth_obj tcp_obj mqtt_obj to from channel want_ack hop_limit
+      port_num data want_response via psks message extra_skip packet
+    ].freeze
+
+    public_class_method def self.encode(opts = {})
+      encode_v1(opts.merge({}))
+    end
+
+    public_class_method def self.encode_v1(opts = {})
+      packet = opts[:packet] || Meshtastic::TAKPacket.new
+      packet.is_compressed = opts.fetch(:is_compressed, packet.is_compressed)
+      packet.contact = contact_from(opts) if contact?(opts)
+      packet.group = group_from(opts) if group?(opts)
+      packet.status = status_from(opts) if status?(opts)
+      packet.pli = pli_from(opts) if pli?(opts)
+      packet.chat = chat_from(opts) if chat?(opts)
+      packet.detail = opts[:detail] if opts[:detail]
       packet
     end
 
-    def self.send(opts = {})
-      data = Meshtastic::Data.new(
-        portnum: :ATAK_PLUGIN,
-        payload: encode(opts).to_proto
-      )
-      Meshtastic.deliver_data(opts.merge(data: data, port_num: Meshtastic::PortNum::ATAK_PLUGIN))
+    public_class_method def self.build_v2(opts = {})
+      packet = opts[:packet] || Meshtastic::TAKPacketV2.new
+      assign_fields(opts.merge(message: packet, extra_skip: %i[packet lat lon altitude message to]))
+      packet.latitude_i = scale_coord(value: opts[:lat]) if opts[:lat]
+      packet.longitude_i = scale_coord(value: opts[:lon]) if opts[:lon]
+      packet.altitude = opts[:altitude].to_i if opts[:altitude]
+      packet.chat = chat_from(opts) if chat?(opts) && opts[:chat].nil?
+      packet
+    end
+
+    public_class_method def self.wrap_v2(opts = {})
+      packet = opts[:packet]
+      [V2_UNCOMPRESSED].pack('C') + packet.to_proto
+    end
+
+    public_class_method def self.encode_v2(opts = {})
+      wrap_v2(packet: build_v2(opts))
+    end
+
+    public_class_method def self.decode_v2(opts = {})
+      bytes = (opts[:wire] || opts[:payload]).to_s.b
+      raise ArgumentError, 'empty ATAK V2 payload' if bytes.empty?
+
+      flags = bytes.getbyte(0)
+      body = bytes.byteslice(1..)
+      if flags == V2_UNCOMPRESSED
+        Meshtastic::TAKPacketV2.decode(body)
+      else
+        raise ArgumentError,
+              "compressed ATAK V2 dictionary id #{flags & 0x3F} is not unpacked (flags=0x#{flags.to_s(16)})"
+      end
+    end
+
+    public_class_method def self.compress_cot(opts = {})
+      Zlib::Deflate.deflate(opts[:cot].to_s)
+    end
+
+    public_class_method def self.decompress_cot(opts = {})
+      bytes = opts[:payload].to_s.b
+      bytes = bytes.byteslice(1..) if bytes.getbyte(0).zero? && bytes.bytesize > 1
+      Zlib::Inflate.inflate(bytes)
+    end
+
+    public_class_method def self.decode(opts = {})
+      payload = opts[:payload]
+      portnum = normalize_port(portnum: opts[:portnum])
+      case portnum
+      when V1_PORT, :ATAK_PLUGIN
+        Meshtastic::TAKPacket.decode(payload.to_s.b)
+      when V2_PORT, :ATAK_PLUGIN_V2
+        decode_v2(payload: payload)
+      when FORWARDER_PORT, :ATAK_FORWARDER
+        decompress_cot(payload: payload)
+      else
+        raise ArgumentError, "unsupported TAK portnum: #{opts[:portnum].inspect}"
+      end
+    end
+
+    public_class_method def self.send(opts = {})
+      send_v1(opts.merge({}))
+    end
+
+    public_class_method def self.send_v1(opts = {})
+      deliver(opts.merge(port_num: V1_PORT, payload: encode_v1(opts).to_proto))
+    end
+
+    public_class_method def self.send_chat(opts = {})
+      send_v1(opts.merge({}))
+    end
+
+    public_class_method def self.send_pli(opts = {})
+      send_v1(opts.merge({}))
+    end
+
+    public_class_method def self.send_v2(opts = {})
+      deliver(opts.merge(port_num: V2_PORT, payload: encode_v2(opts)))
+    end
+
+    public_class_method def self.send_cot(opts = {})
+      payload = compress_cot(cot: opts[:cot])
+      max_len = Meshtastic::Constants::DATA_PAYLOAD_LEN
+      raise ArgumentError, "ERROR: CoT Length > #{max_len} Bytes after zlib" if payload.bytesize > max_len
+
+      deliver(opts.merge(port_num: FORWARDER_PORT, payload: payload))
     end
 
-    def self.authors
+    public_class_method def self.authors
       "AUTHOR(S):\n        0day Inc. <support@0dayinc.com>\n      "
     end
 
-    def self.help
+    public_class_method def self.help
       puts "USAGE:
-        #{self}.send(serial_obj: serial_obj, message: 'ATAK chat')
+        # Encode a V1 TAKPacket (alias of encode_v1).
+        #{self}.encode(
+          message: 'optional - GeoChat text body to place on the packet',
+          packet: 'optional - existing Meshtastic::TAKPacket to fill instead of a new one'
+        )
+
+        # Build a V1 TAKPacket with GeoChat, PLI, contact, group, or status.
+        #{self}.encode_v1(
+          packet: 'optional - existing Meshtastic::TAKPacket to fill instead of a new one',
+          detail: 'optional - raw CoT detail bytes for the V1 detail field'
+        )
+
+        # Build a V2 TAKPacketV2 with scaled lat/lon and typed payloads.
+        #{self}.build_v2(
+          packet: 'optional - existing Meshtastic::TAKPacketV2 to fill instead of a new one',
+          chat: 'optional - Meshtastic::GeoChat object if not using message:',
+          lat: 'optional - latitude in decimal degrees (stored times 1e7)',
+          lon: 'optional - longitude in decimal degrees (stored times 1e7)',
+          altitude: 'optional - altitude in meters as an integer'
+        )
+
+        # Prefix a TAKPacketV2 protobuf with the uncompressed V2 flags byte.
+        #{self}.wrap_v2(
+          packet: 'required - Meshtastic::TAKPacketV2 to serialize onto the wire'
+        )
+
+        # Build and wrap an uncompressed V2 wire frame.
+        #{self}.encode_v2(
+          message: 'optional - GeoChat text for the V2 chat variant'
+        )
+
+        # Decode an uncompressed V2 wire frame (flags 0xFF plus protobuf).
+        #{self}.decode_v2(
+          wire: 'optional - full V2 wire bytes including the flags byte',
+          payload: 'optional - same as wire when wire is omitted'
+        )
+
+        # zlib-compress Cursor-on-Target XML for ATAK_FORWARDER.
+        #{self}.compress_cot(
+          cot: 'required - CoT XML string to deflate for the forwarder port'
+        )
+
+        # zlib-decompress ATAK_FORWARDER payload bytes back to CoT XML.
+        #{self}.decompress_cot(
+          payload: 'required - zlib bytes from an ATAK_FORWARDER Data payload'
+        )
+
+        # Dispatch decode by Meshtastic TAK portnum.
+        #{self}.decode(
+          payload: 'required - raw port payload bytes from a decoded mesh Data',
+          portnum: 'required - :ATAK_PLUGIN, :ATAK_PLUGIN_V2, or :ATAK_FORWARDER'
+        )
+
+        # Send a V1 TAKPacket (alias of send_v1).
+        #{self}.send(
+          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          message: 'optional - GeoChat text to send on ATAK_PLUGIN'
+        )
+
+        # Send a V1 TAKPacket on ATAK_PLUGIN (port 72).
+        #{self}.send_v1(
+          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          bluetooth_obj: 'optional - BLE handle from Meshtastic::Bluetooth.connect',
+          tcp_obj: 'optional - TCP handle from Meshtastic::TCP.connect'
+        )
+
+        # Send V1 GeoChat on ATAK_PLUGIN.
+        #{self}.send_chat(
+          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          message: 'optional - GeoChat text body to transmit'
+        )
+
+        # Send V1 PLI on ATAK_PLUGIN.
+        #{self}.send_pli(
+          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          lat: 'optional - latitude in decimal degrees (stored times 1e7)',
+          lon: 'optional - longitude in decimal degrees (stored times 1e7)'
+        )
+
+        # Send an uncompressed V2 frame on ATAK_PLUGIN_V2 (port 78).
+        #{self}.send_v2(
+          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          message: 'optional - GeoChat text for the V2 chat variant'
+        )
+
+        # Send zlib-compressed CoT XML on ATAK_FORWARDER (port 257).
+        #{self}.send_cot(
+          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          cot: 'required - CoT XML string small enough to fit after zlib'
+        )
+
+        # Print the AUTHOR(S) string for this module.
         #{self}.authors
       "
     end
+
+    private_class_method def self.deliver(opts = {})
+      data = Meshtastic::Data.new(portnum: opts[:port_num], payload: opts[:payload])
+      Meshtastic.deliver_data(opts.merge(data: data, port_num: opts[:port_num]))
+    end
+
+    private_class_method def self.scale_coord(opts = {})
+      (opts[:value].to_f * COORD_SCALE).round
+    end
+
+    private_class_method def self.normalize_port(opts = {})
+      portnum = opts[:portnum]
+      return portnum if portnum.is_a?(Integer)
+      return Meshtastic::PortNum.resolve(portnum) if portnum.is_a?(Symbol)
+
+      portnum
+    end
+
+    private_class_method def self.assign_fields(opts = {})
+      message = opts[:message]
+      skip = SKIP_KEYS + Array(opts[:extra_skip])
+      opts.each do |key, value|
+        next if skip.include?(key)
+        next unless message.respond_to?("#{key}=")
+
+        message.public_send("#{key}=", value)
+      end
+      message
+    end
+
+    private_class_method def self.contact?(opts = {})
+      opts[:contact] || opts[:callsign] || opts[:device_callsign]
+    end
+
+    private_class_method def self.group?(opts = {})
+      opts[:group] || opts[:team] || opts[:role]
+    end
+
+    private_class_method def self.status?(opts = {})
+      opts[:status] || opts[:battery]
+    end
+
+    private_class_method def self.pli?(opts = {})
+      opts[:pli] || opts[:lat] || opts[:lon]
+    end
+
+    private_class_method def self.chat?(opts = {})
+      opts[:chat] || opts[:message]
+    end
+
+    private_class_method def self.contact_from(opts = {})
+      return opts[:contact] if opts[:contact].is_a?(Meshtastic::Contact)
+
+      Meshtastic::Contact.new(
+        callsign: opts[:callsign].to_s,
+        device_callsign: opts[:device_callsign].to_s
+      )
+    end
+
+    private_class_method def self.group_from(opts = {})
+      return opts[:group] if opts[:group].is_a?(Meshtastic::Group)
+
+      Meshtastic::Group.new(team: opts[:team], role: opts[:role])
+    end
+
+    private_class_method def self.status_from(opts = {})
+      return opts[:status] if opts[:status].is_a?(Meshtastic::Status)
+
+      Meshtastic::Status.new(battery: opts[:battery].to_i)
+    end
+
+    private_class_method def self.pli_from(opts = {})
+      return opts[:pli] if opts[:pli].is_a?(Meshtastic::PLI)
+
+      pli = Meshtastic::PLI.new
+      pli.latitude_i = scale_coord(value: opts[:lat]) if opts[:lat]
+      pli.longitude_i = scale_coord(value: opts[:lon]) if opts[:lon]
+      pli.altitude = opts[:altitude].to_i if opts[:altitude]
+      pli.speed = opts[:speed].to_i if opts[:speed]
+      pli.course = opts[:course].to_i if opts[:course]
+      pli
+    end
+
+    private_class_method def self.chat_from(opts = {})
+      return opts[:chat] if opts[:chat].is_a?(Meshtastic::GeoChat)
+
+      Meshtastic::GeoChat.new(
+        message: opts[:message].to_s,
+        to: opts[:to].to_s,
+        to_callsign: opts[:to_callsign].to_s
+      )
+    end
   end
 end

data/lib/meshtastic/bluetooth/bluez.rb

@@ -12,7 +12,9 @@ module Meshtastic
       TORADIO_UUID = 'f75c76d2-129e-4dad-a1dd-7866124401e7'
       FROMRADIO_UUID = '2c55e69e-4993-11ed-b878-0242ac120002'
 
-      def self.scan(adapter: 'hci0', timeout: 5)
+      public_class_method def self.scan(opts = {})
+        adapter = opts[:adapter] || 'hci0'
+        timeout = opts[:timeout] || 5
         new(address: '00:00:00:00:00:00', adapter: adapter, timeout: timeout).scan_adapter
       end
 
@@ -182,6 +184,23 @@ module Meshtastic
         @timeout = timeout
         @mutex = Mutex.new
       end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n          0day Inc. <support@0dayinc.com>\n        "
+      end
+
+      public_class_method def self.help
+        puts "USAGE:
+          # Scan BlueZ for nearby Meshtastic BLE advertisements.
+          #{self}.scan(
+            adapter: 'optional - BlueZ adapter name such as hci0',
+            timeout: 'optional - discovery duration in seconds (default: 5)'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+      end
     end
   end
 end

data/lib/meshtastic/bluetooth.rb

@@ -8,12 +8,12 @@ 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))
+    public_class_method def self.scan(opts = {})
+      BlueZ.scan(opts.merge({}))
     end
 
     # Connect to an already paired BLE address (not a mesh node ID).
-    def self.connect(opts = {})
+    public_class_method def self.connect(opts = {})
       connection = BlueZ.new(address: opts[:address], adapter: opts.fetch(:adapter, 'hci0'), timeout: opts.fetch(:timeout, 15))
       connection.connect
       bluetooth_obj = {
@@ -21,7 +21,7 @@ module Meshtastic
         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)
+      bluetooth_obj[:rx_thread] = start_reader(handle: bluetooth_obj)
       if opts.fetch(:want_config, true)
         mesh = Meshtastic::MeshInterface.new
         bytes = mesh.start_config
@@ -35,7 +35,8 @@ module Meshtastic
       raise
     end
 
-    private_class_method def self.start_reader(handle)
+    private_class_method def self.start_reader(opts = {})
+      handle = opts[:handle]
       Thread.new do
         until handle[:closing]
           bytes = handle[:bluetooth_conn].read
@@ -43,7 +44,7 @@ module Meshtastic
             sleep 0.1
             next
           end
-          receive_bytes(handle, bytes)
+          receive_bytes(handle: handle, bytes: bytes)
         end
       rescue StandardError => e
         handle[:rx_error] = IOError.new("Bluetooth receive failed: #{e.message}") unless handle[:closing]
@@ -53,7 +54,9 @@ module Meshtastic
       end
     end
 
-    private_class_method def self.receive_bytes(handle, bytes)
+    private_class_method def self.receive_bytes(opts = {})
+      handle = opts[:handle]
+      bytes = opts[:bytes]
       message = Meshtastic::FromRadio.decode(bytes)
       if message.my_info
         handle[:my_info] = message.my_info.to_h
@@ -73,14 +76,14 @@ module Meshtastic
       warn "Meshtastic::Bluetooth: failed to decode FromRadio (#{e.message})"
     end
 
-    private_class_method def self.handle_for(opts)
+    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 = {})
+    public_class_method def self.wait_for_config(opts = {})
       handle = handle_for(opts)
       raise ArgumentError, 'connect with want_config: true first' unless handle[:config_id]
 
@@ -92,7 +95,7 @@ module Meshtastic
       handle
     end
 
-    def self.recv_from_radio(opts = {})
+    public_class_method def self.recv_from_radio(opts = {})
       handle = handle_for(opts)
       timeout = opts.fetch(:timeout, 5)
       timeout = nil if timeout&.negative?
@@ -102,7 +105,7 @@ module Meshtastic
       message
     end
 
-    def self.drain_from_radio(opts = {})
+    public_class_method def self.drain_from_radio(opts = {})
       handle = handle_for(opts)
       messages = []
       opts.fetch(:max, 256).times do
@@ -114,16 +117,21 @@ module Meshtastic
       messages
     end
 
-    def self.dump_stdout_data(opts = {}, &)
-      Meshtastic::Serial.dump_stdout_data(opts.merge(serial_obj: handle_for(opts)), &)
+    public_class_method def self.dump_stdout_data(opts = {})
+      merged = opts.merge(serial_obj: handle_for(opts))
+      if block_given?
+        Meshtastic::Serial.dump_stdout_data(merged) { |row| yield row } # rubocop:disable Style/ExplicitBlockArgument
+      else
+        Meshtastic::Serial.dump_stdout_data(merged)
+      end
     end
 
-    def self.flush_data(opts = {})
+    public_class_method 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 = {})
+    public_class_method 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)
@@ -166,7 +174,7 @@ module Meshtastic
     end
 
     # Write one complete serialized ToRadio to GATT. BLE does not use UART headers.
-    def self.send_to_radio(opts = {})
+    public_class_method 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]
@@ -187,7 +195,7 @@ module Meshtastic
       end
     end
 
-    def self.send_text(opts = {})
+    public_class_method def self.send_text(opts = {})
       handle = opts[:bluetooth_obj]
       raise ArgumentError, 'bluetooth_obj is required' unless handle
 
@@ -199,7 +207,7 @@ module Meshtastic
       send_to_radio(bluetooth_obj: handle, to_radio: Meshtastic::MeshInterface.new.send_text(args))
     end
 
-    def self.send_data(opts = {})
+    public_class_method 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)
@@ -208,7 +216,7 @@ module Meshtastic
       send_to_radio(bluetooth_obj: handle, to_radio: Meshtastic::MeshInterface.new.send_data(args))
     end
 
-    def self.disconnect(opts = {})
+    public_class_method def self.disconnect(opts = {})
       handle = opts[:bluetooth_obj]
       return unless handle
       return if handle[:closing]
@@ -231,68 +239,71 @@ module Meshtastic
       nil
     end
 
-    def self.authors
+    public_class_method 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.
+    public_class_method def self.help
+      puts "        USAGE:
+        # Run the scan class method for this module.
+        #{self}.scan
 
-      USAGE:
-        devices = #{self}.scan(
-          adapter: 'optional - BlueZ adapter (default: hci0)',
-          timeout: 'optional - discovery seconds (default: 5)'
+        # Run the connect class method for this module.
+        #{self}.connect(
+          address: 'optional - value for address passed into connect'
         )
 
-        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)'
-        )
+        # Run the wait_for_config class method for this module.
+        #{self}.wait_for_config
 
-        #{self}.wait_for_config(
-          bluetooth_obj: 'required - bluetooth_obj connected with want_config: true',
-          timeout: 'optional - seconds to await configuration (default: 10)'
-        )
+        # Run the recv_from_radio class method for this module.
+        #{self}.recv_from_radio
 
-        #{self}.send_to_radio(
-          bluetooth_obj: 'required - bluetooth_obj returned from #connect',
-          to_radio: 'required - Meshtastic::ToRadio OR serialized String'
-        )
+        # Run the drain_from_radio class method for this module.
+        #{self}.drain_from_radio
 
-        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)'
-        )
+        # Run the dump_stdout_data class method for this module.
+        #{self}.dump_stdout_data
 
-        msgs = #{self}.drain_from_radio(bluetooth_obj: bluetooth_obj, max: 256)
+        # Run the flush_data class method for this module.
+        #{self}.flush_data
 
+        # Run the subscribe class method for this module.
         #{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'
+          include: 'optional - value for include passed into subscribe',
+          exclude: 'optional - value for exclude passed into subscribe',
+          timeout: 'optional - value for timeout passed into subscribe',
+          gps_metadata: 'optional - value for gps_metadata passed into subscribe',
+          include_raw: 'optional - value for include_raw passed into subscribe'
         )
 
+        # Run the send_to_radio class method for this module.
+        #{self}.send_to_radio(
+          bluetooth_obj: 'optional - value for bluetooth_obj passed into send_to_radio',
+          to_radio: 'optional - value for to_radio passed into send_to_radio'
+        )
+
+        # Run the send_text class method for this module.
         #{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)'
+          bluetooth_obj: 'optional - value for bluetooth_obj passed into send_text',
+          from: 'optional - value for from passed into send_text'
         )
 
+        # Run the send_data class method for this module.
         #{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)'
+          bluetooth_obj: 'optional - value for bluetooth_obj passed into send_data',
+          data: 'optional - value for data passed into send_data',
+          from: 'optional - value for from passed into send_data'
         )
 
-        #{self}.disconnect(bluetooth_obj: bluetooth_obj)
+        # Run the disconnect class method for this module.
+        #{self}.disconnect(
+          bluetooth_obj: 'optional - value for bluetooth_obj passed into disconnect'
+        )
 
+        # Run the authors class method for this module.
         #{self}.authors
+
       "
     end
   end

data/lib/meshtastic/cannedmessages.rb

@@ -4,13 +4,13 @@ require 'meshtastic/cannedmessages_pb'
 
 module Meshtastic
   module Cannedmessages
-    def self.encode(opts = {})
+    public_class_method def self.encode(opts = {})
       config = Meshtastic::CannedMessageModuleConfig.new
       config.messages = opts.fetch(:messages, '')
       config
     end
 
-    def self.send(opts = {})
+    public_class_method def self.send(opts = {})
       data = Meshtastic::Data.new(
         portnum: :TEXT_MESSAGE_APP,
         payload: encode(opts).messages.to_s.b
@@ -18,14 +18,21 @@ module Meshtastic
       Meshtastic.deliver_data(opts.merge(data: data, port_num: Meshtastic::PortNum::TEXT_MESSAGE_APP))
     end
 
-    def self.authors
+    public_class_method def self.authors
       "AUTHOR(S):\n        0day Inc. <support@0dayinc.com>\n      "
     end
 
-    def self.help
-      puts "USAGE:
-        #{self}.encode(messages: \"Yes\\nNo\\nMaybe\")
+    public_class_method def self.help
+      puts "        USAGE:
+        # Run the encode class method for this module.
+        #{self}.encode
+
+        # Run the send class method for this module.
+        #{self}.send
+
+        # Run the authors class method for this module.
         #{self}.authors
+
       "
     end
   end