lxp-packet 0.3.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f2d92693be97e362ae4d3485fa4772bc813a9271d0fd6aa90d60dad103fe31
-  data.tar.gz: c55207ae772cbe564f7891d634547209d8e022e545711dbe5813138cd53de722
+  metadata.gz: '096a5bb502e1d685696a0a14e483d59ddc8669bc8bda9c785dba152180d7ee9e'
+  data.tar.gz: 6448359ba7d17210b71eaf6173943d71d28ec37f243e544899efee05b8341ae0
 SHA512:
-  metadata.gz: 9ae5ae4c8df6d890bf75ec7280c598d2fb29c48977b7ffb256163b105566f73796b915c631388dea19c7b59aad2305720f7e0db7173bf0373d9bef0299d1b92f
-  data.tar.gz: d9290a541c2489825f76a259b467779dfc5b20f44b156a1f645d98b3515e3ab6ff1764ba99e3aa8733af07db0cae3f68f4d31b7f56da48cc32cfabee349a5c89
+  metadata.gz: 3f483b86c1e92673f5c6d0f48da17db156e458af250ca7fe598fc5fec18f27c1a2c8dd8fb795192685b05497b385063a65b0db2f3d21131ca93c48fb313ac870
+  data.tar.gz: e3f9c800854a950d28ffb7e86c92a3bbaa60e53892a274489ccb9f774ae54818d177b373c4d48950f23787a7a85ca9555c161c575a6a2139705d3ad47f602235

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Metrics/LineLength:
+  Enabled: no

data/CHANGELOG.md

@@ -5,7 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.7.1] - 2021-04-28
+
+### Added
+
+- `AC_CHARGE_SOC_LIMIT` register constant
+
+## [0.7.0] - 2020-05-08
+
+### Added
+
+- support for requesting input registers on demand
+- support for sending heartbeats
+
+## [0.6.0] - 2020-04-10
+
+### Added
+
+- support `v_pv_*` keys in `ReadInput1`
+- support `bat_count` key in `ReadInput3`
+
+## [0.5.0] - 2020-04-09
+
+### Added
+
+- support 3 PV strings in `ReadInput1` and `ReadInput2`
+- support 3 phase power in `ReadInput1`
+- support `t_bat` key in `ReadInput2#to_h` (suspect this is Lead Acid only as mine is 0)
+- support `uptime` key in `ReadInput2#to_h`
+
+### Fixed
+
+- parsing of temperatures above 255C in ReadInput2
+
+
+## [0.4.0] - 2020-04-07
+
+### Added
+
+- parsing of ReadHold packets with multiple registers/values
+- beginnings of a test suite!
+
 
 ## [0.3.0] - 2020-04-02
 

data/README.md

@@ -44,6 +44,14 @@ It can optionally be configured with a second network endpoint; I set this to TC
 
 Alternatively you can probably just change the first setting if you don't care about the official Lux portal or mobile app being updated, though I found it useful to verify I was setting the right values at first. This would also prevent LuxPower sending you firmware updates (for better or for worse), not that I've had any so far.
 
+## Inverter Fundamentals
+
+The inverter has two basic sets of information.
+
+There are 114 registers (0-113), which are also referred to as "holdings". See [doc/LXP_REGISTERS.txt](doc/LXP_REGISTERS.txt) for a list of them. Most of these you can write, and they affect inverter operation. Some pieces of information span several registers, for example the serial number is in registers 2 through 8.
+
+Additionally there are input registers. These are transient information which the inverter broadcasts to any connected client every 2 minutes. These are sent as sets of 3 packets. `ReadInput1` / `ReadInput2` / `ReadInput3` are used to parse these.
+
 ## Examples
 
 The inverter requires that your datalog serial and inverter serial are in the packets you send to it for it to respond.
@@ -73,9 +81,9 @@ end
 
 This is necessary because occasionally the inverter will send us state data and heartbeats, as well as replies for other clients (see above) which we need to either process (if you're interested in them) or ignore (which is easier, and done here).
 
-### Reading
+### Reading Holding Registers
 
-This is the simplest use-case; read the value of something from the inverter.
+This is the simplest use-case; read the value of a holding register from the inverter.
 
 ```ruby
 pkt = LXP::Packet::ReadHold.new
@@ -96,6 +104,50 @@ r = read_reply(sock, pkt)
 puts "Received: #{r.value}" # should be discharge cut-off value
 ```
 
+Usually, `ReadHold` instances contain the details of just one register. However, it is possible they can contain multiple. Pressing "Read" on the LuxPower Web Portal provokes the inverter into sending out 5 packets that each contain multiple registers, for example.
+
+To do this yourself, set `#value` in a `ReadHold` you're going to send to the inverter. This tells it how many registers you want in the reply, and they'll start from the number set in `#register`:
+
+```ruby
+# get registers 0 through 22 inclusive:
+pkt.register = 0
+pkt.value = 23
+```
+
+To access these in the reply, you can use subscript notation to get a register directly, or call `#to_h` to get a hash of registers/values. For convenience this also works with single register packets, though obviously only one subscript will ever return data, and `to_h` will only have one key.
+
+```ruby
+# assuming pkt is a parsed packet with multiple registers/values:
+pkt[0] # => 35462 # value of register 0
+pkt.to_h # { 0 => 35462, 1 => 1, ... }
+
+# assuming pkt is a parsed packet with only register 21:
+pkt[21] # => value of register 21
+pkt[22] # => nil
+pkt.to_h # { 21 => 62292 }
+```
+
+### Reading Input Registers
+
+This is similar to reading holdings. The inverter should send these packets every 2 minutes anyway, but if you want them on demand, you can create a `ReadInput1` (or 2, or 3) and send it.
+
+The response packet contains a bunch of data, the simplest way to get at these is to call `to_h` on the packet, which returns a Hash of data:
+
+```ruby
+pkt = LXP::Packet::ReadInput1.new
+pkt.datalog_serial = 'AB12345678'
+pkt.inverter_serial = '1234567890'
+
+# assuming your inverter is at 192.168.0.30
+sock = TCPSocket.new('192.168.0.30', 4346)
+sock.write(out)
+
+r = read_reply(sock, pkt)
+# r is a populated ReadInput1, which responds to #to_h:
+r.to_h # => {:status=>16, :soc=>79, ... }
+```
+
+
 ### Writing
 
 Updating a value on the inverter.
@@ -119,7 +171,7 @@ r = read_reply(sock, pkt)
 puts "Received: #{r.value}" # should be new discharge cut-off value, 20
 ```
 
-### Updating a multi-byte register
+### Updating a bitwise register
 
 The Lux has two registers that contain multiple settings. In `doc/LXP_REGISTERS.txt` you can see them at 21 and 110. They have two bytes.
 
@@ -127,7 +179,7 @@ This library combines them into a 16bit word, so that the constants in `LXP::Pac
 
 First you need to read the previous value, update it with a new bit, then write it back. This is really just a combination of the two above examples.
 
-This enables AC charge. You need to OR the bit with the previous value so as not to change other settings tored in register 21.
+This example enables AC charge. You need to OR the bit with the previous value so as not to change other settings stored in register 21.
 
 It could be improved not to bother doing the write if it was already enabled.
 

data/doc/LXP_PACKET.txt

@@ -28,15 +28,13 @@ Then there's a header:
                                 194=data to translate
                                 195=read param 196=write param
     8    10       datalog serial number
-   18     2       data frame length or heartbeat number?
+   18     2       data frame length
 
-Mostly the packets I've been dealing with have TCP_FUNCTION 194. I ignore
-heartbeats, and I've not seen 195 or 196 I don't think.
 
-For 194, bytes 18/19 are the data frame length which should match the number
-of bytes that follows. It's sometimes easier to think of the dataframe as
-its own structure so here are byte offsets in both the dataframe and the entire
-packet:
+For TCP_FUNCTION 194, bytes 18/19 are the data frame length which should match
+the number of bytes that follows. It's sometimes easier to think of the
+dataframe as its own structure so here are byte offsets in both the dataframe
+and the entire packet:
 
  BYTE BYTES VALUE MEANING
  0/20     1       address? 0 when writing to inverter, 1 when reading?
@@ -56,9 +54,6 @@ between R_HOLD and R_INPUT yet. W_SINGLE writes a single register; not used
 W_MULTI.
 
 To get the inverter to populate the response value for an R_HOLD, the value
-you send seems to need to be 1.
-
-Register and value are also referred to as start address and point number;
-this seems to be for the regular stats the inverter sends out every 2 minutes;
-seems to send 3 packets, the first one with address 0, then 40, then 80.
-Not really done much with this yet.
+you send needs to be above 0. This tells the inverter how many registers you
+want to read. Normally this is 1, if its higher than you'll get seqeuential
+registers

data/doc/LXP_REGISTERS.txt

@@ -8,10 +8,20 @@ testing in case I got anything wrong!
 Registers 21 and 110 are bitmasks; normally you fetch the previous
 settings, apply your changes, and set the new value back.
 
-0 MODEL
-2 SERIAL_NUM
-7 FW_CODE
-12 TIME
+0-1 MODEL
+  contains (not sure how to decode these yet):
+    lithiumType
+    powerRating
+    leadAcidType
+    ruleMask
+    batteryType
+    meterBrand
+    measurement
+    rule
+2-8 SERIAL_NUM
+7 FW_CODE ?
+9-10 ?
+12-14 TIME
 15 COM_ADDR
 16 LANGUAGE
 20 PV_INPUT_MODE

data/lib/lxp/packet/base.rb

@@ -16,9 +16,9 @@ class LXP
       attr_accessor :chksum
 
       def initialize
-        @header = [0] * 20
-        @data = [0] * 16
-        @chksum = [0, 0]
+        @header ||= [0] * 20
+        @data ||= [0] * 16
+        @chksum ||= [0, 0]
 
         # prefix
         @header[0] = 161
@@ -26,7 +26,6 @@ class LXP
 
         self.protocol = 1
 
-        # length after first 6 bytes maybe?
         self.packet_length = 32
 
         @header[6] = 1 # unsure, always seems to be 1
@@ -89,6 +88,10 @@ class LXP
         @header[7] = tcp_function & 0xff
       end
 
+      def datalog_serial
+        @header[8, 10].pack('C*')
+      end
+
       # Passed as a string
       def datalog_serial=(datalog_serial)
         @header[8, 10] = datalog_serial.bytes
@@ -111,6 +114,10 @@ class LXP
         @data[1] = device_function
       end
 
+      def inverter_serial
+        @data[2, 10].pack('C*')
+      end
+
       # Passed as a string
       def inverter_serial=(inverter_serial)
         @data[2, 10] = inverter_serial.bytes
@@ -125,12 +132,6 @@ class LXP
         @data[13] = (register >> 8) & 0xff
       end
 
-      def value_length_byte?
-        @value_length_byte ||=
-          protocol == 2 &&
-          device_function != DeviceFunctions::WRITE_SINGLE
-      end
-
       def value_length
         if value_length_byte?
           @data[14]
@@ -142,13 +143,11 @@ class LXP
       # protocol 1 has value at 14 and 15
       # protocol 2 has length at 14, then that many bytes of values
       #
-      # So this can return an int or an array.
-      #
-      def value
+      def values
         if value_length_byte?
           @data[15, value_length]
         else
-          @data[14] | @data[15] << 8
+          @data[14, 2] # | @data[15] << 8
         end
       end
 
@@ -171,6 +170,12 @@ class LXP
 
       private
 
+      def value_length_byte?
+        @value_length_byte ||=
+          protocol == 2 &&
+          device_function != DeviceFunctions::WRITE_SINGLE
+      end
+
       def crc16_modbus(arr)
         arr.length.times.inject(0xffff) do |r, n|
           r ^= arr[n]

data/lib/lxp/packet/device_functions.rb

@@ -7,6 +7,12 @@ class LXP
       READ_INPUT   = 4
       WRITE_SINGLE = 6
       WRITE_MULTI  = 16
+
+      # not handled yet
+      READ_HOLD_ERROR    = 131
+      READ_INPUT_ERROR   = 132
+      WRITE_SINGLE_ERROR = 134
+      WRITE_MULTI_ERROR  = 144
     end
   end
 end

data/lib/lxp/packet/heartbeat.rb

@@ -15,16 +15,20 @@ class LXP
     #
     # They have no data and no checksum, so there's really not a lot here.
     #
-    # Ideally these could be instantiated via .parse, but they only seem to
-    # have one byte for the length, and .parse expects two. There's nothing
-    # to parse anyway so never mind.
-    #
     class Heartbeat < Base
       def initialize
+        @header = [0] * 19
+
         super
 
+        self.packet_length = 13
+        self.protocol = 2
         self.tcp_function = TcpFunctions::HEARTBEAT
       end
+
+      def bytes
+        header
+      end
     end
   end
 end

data/lib/lxp/packet/read_hold.rb

@@ -12,24 +12,42 @@ class LXP
         self.device_function = DeviceFunctions::READ_HOLD
 
         self.data_length = 18
-        # start by assuming this packet will be sent to the inverter.
-        # we need to put a 1 in the value to get the inverter to
-        # populate the reply.
+
+        # in ReadHold packets, the value is the number of registers
+        # we want to read. Default to 1.
         self.value = 1
       end
 
-      # ReadHold packets should always (I think) have two byte values.
+      # Return the first value in a ReadHold packet. This is normally used
+      # when the packet only has one value.
+      #
+      # #values returns an Array. This converts it to an int.
       #
-      # Raise if not, as that is not expected?
+      def value(offset = 0)
+        Utils.int(values[offset, 2])
+      end
+
+      # Subscript notation is used when the ReadHold packet has multiple
+      # registers in it. This is indicated by value_length > 2.
       #
-      # Base#value will return an int for protocol 1, or an Array
-      # for protocol 2. If we can, convert that Array to an int.
+      # In this case, #register tells us the first register in the values, then
+      # each 2 bytes are subsequent registers.
       #
-      def value
-        raise 'value_length not 2?' unless value_length == 2
+      def [](reg_num)
+        offset = (reg_num - register) * 2
+
+        return if offset.negative? || offset > data_length
+
+        value(offset)
+      end
+
+      # Return a Hash of all register->values in the ReadHold packet.
+      def to_h
+        r = register
 
-        r = super
-        r.is_a?(Array) ? Utils.int(r, 2) : r
+        values.each_slice(2).each_with_index.map do |v, idx|
+          [r + idx, Utils.int(v)]
+        end.to_h
       end
     end
   end

data/lib/lxp/packet/read_input.rb

@@ -6,6 +6,15 @@ class LXP
   class Packet
     # Input packets are a stream of values related to energy flows (inputs?)
     class ReadInput < Base
+      def initialize
+        super
+
+        self.tcp_function = TcpFunctions::TRANSLATED_DATA
+        self.device_function = DeviceFunctions::READ_INPUT
+
+        self.data_length = 18
+      end
+
       def self.parse(ascii)
         i = super
 

data/lib/lxp/packet/read_input1.rb

@@ -5,47 +5,87 @@ require_relative 'read_input'
 class LXP
   class Packet
     class ReadInput1 < ReadInput
+      def initialize
+        super
+
+        self.register = 0
+        self.value = 40
+      end
+
       # Decode the data and return a hash of values in this input packet
       def to_h
         {
-          status: @data[15],
+          # 0 = static 1
+          # 1 = R_INPUT
+          # 2..12 = serial
+          # 13/14 = length
+
+          status: Utils.int(@data[15, 2]),
+
+          v_pv_1: Utils.int(@data[17, 2]) / 10.0, # V
+          v_pv_2: Utils.int(@data[19, 2]) / 10.0, # V
+          v_pv_3: Utils.int(@data[21, 2]) / 10.0, # V
 
-          v_bat: Utils.int(@data[23, 2], :lsb) / 10.0, # V
+          v_bat: Utils.int(@data[23, 2]) / 10.0, # V
           soc: @data[25], # %
+          # 26 used for anything?
 
-          # 26..28 ?
+          # 27 always been 0 so far
+          # 28 I've seen anything from 0 to 53, changes occasionally but
+          # not spotted a pattern yet.
+          _unknown_i1_27: @data[27],
+          _unknown_i1_28: @data[28],
 
-          p_pv: Utils.int(@data[29, 2], :lsb), # W
-          p_charge: Utils.int(@data[35, 2], :lsb), # W
-          p_discharge: Utils.int(@data[37, 2], :lsb), # W
-          v_acr: Utils.int(@data[39, 2], :lsb) / 10.0, # V
-          f_ac: Utils.int(@data[45, 2], :lsb) / 100.0, # Hz
+          # this might be useless if 27 and 28 are independent
+          _unknown_i1_27_28: Utils.int(@data[27, 2]),
 
-          p_inv: Utils.int(@data[47, 2], :lsb), # W
-          p_rec: Utils.int(@data[49, 2], :lsb), # W
+          p_pv: Utils.int(@data[29, 2]) +
+            Utils.int(@data[31, 2]) +
+            Utils.int(@data[33, 2]), # W
+          p_pv_1: Utils.int(@data[29, 2]), # W
+          p_pv_2: Utils.int(@data[31, 2]), # W
+          p_pv_3: Utils.int(@data[33, 2]), # W
+          p_charge: Utils.int(@data[35, 2]), # W
+          p_discharge: Utils.int(@data[37, 2]), # W
+          v_ac_r: Utils.int(@data[39, 2]) / 10.0, # V
+          v_ac_s: Utils.int(@data[41, 2]) / 10.0, # V
+          v_ac_t: Utils.int(@data[43, 2]) / 10.0, # V
+          f_ac: Utils.int(@data[45, 2]) / 100.0, # Hz
 
-          # 51..54 ?
+          p_inv: Utils.int(@data[47, 2]), # W
+          p_rec: Utils.int(@data[49, 2]), # W
 
-          v_eps: Utils.int(@data[55, 2], :lsb) / 10.0, # V
-          f_eps: Utils.int(@data[61, 2], :lsb) / 100.0, # Hz
+          # this seems to track with charge/discharge but at lower values.
+          # no idea what this means.
+          _unknown_i1_51_52: Utils.int(@data[51, 2]), # W ?
+
+          pf: Utils.int(@data[53, 2]) / 1000.0, # Hz
+
+          v_eps_r: Utils.int(@data[55, 2]) / 10.0, # V
+          v_eps_s: Utils.int(@data[57, 2]) / 10.0, # V
+          v_eps_t: Utils.int(@data[59, 2]) / 10.0, # V
+          f_eps: Utils.int(@data[61, 2]) / 100.0, # Hz
 
           # peps and seps in 63..66?
 
-          p_to_grid: Utils.int(@data[67, 2], :lsb), # W
-          p_to_user: Utils.int(@data[69, 2], :lsb), # W
-
-          e_pv_day: Utils.int(@data[71, 2], :lsb) / 10.0, # kWh
-          # 73..76 ?
-          e_inv_day: Utils.int(@data[77, 2], :lsb) / 10.0, # kWh
-          e_rec_day: Utils.int(@data[79, 2], :lsb) / 10.0, # kWh
-          e_chg_day: Utils.int(@data[81, 2], :lsb) / 10.0, # kWh
-          e_dischg_day: Utils.int(@data[83, 2], :lsb) / 10.0, # kWh
-          e_eps_day: Utils.int(@data[85, 2], :lsb) / 10.0, # kWh
-          e_to_grid_day: Utils.int(@data[87, 2], :lsb) / 10.0, # kWh
-          e_to_user_day: Utils.int(@data[89, 2], :lsb) / 10.0, # kWh
-
-          v_bus_1: Utils.int(@data[91, 2], :lsb) / 10.0, # V
-          v_bus_2: Utils.int(@data[93, 2], :lsb) / 10.0 # V
+          p_to_grid: Utils.int(@data[67, 2]), # W
+          p_to_user: Utils.int(@data[69, 2]), # W
+
+          e_pv_day: (Utils.int(@data[71, 2]) +
+                     Utils.int(@data[73, 2]) + Utils.int(@data[75, 2])) / 10.0, # kWh
+          e_pv_1_day: Utils.int(@data[71, 2]) / 10.0, # kWh
+          e_pv_2_day: Utils.int(@data[73, 2]) / 10.0, # kWh
+          e_pv_3_day: Utils.int(@data[75, 2]) / 10.0, # kWh
+          e_inv_day: Utils.int(@data[77, 2]) / 10.0, # kWh
+          e_rec_day: Utils.int(@data[79, 2]) / 10.0, # kWh
+          e_chg_day: Utils.int(@data[81, 2]) / 10.0, # kWh
+          e_dischg_day: Utils.int(@data[83, 2]) / 10.0, # kWh
+          e_eps_day: Utils.int(@data[85, 2]) / 10.0, # kWh
+          e_to_grid_day: Utils.int(@data[87, 2]) / 10.0, # kWh
+          e_to_user_day: Utils.int(@data[89, 2]) / 10.0, # kWh
+
+          v_bus_1: Utils.int(@data[91, 2]) / 10.0, # V
+          v_bus_2: Utils.int(@data[93, 2]) / 10.0 # V
         }
       end
     end

data/lib/lxp/packet/read_input2.rb

@@ -5,21 +5,49 @@ require_relative 'read_input'
 class LXP
   class Packet
     class ReadInput2 < ReadInput
+      def initialize
+        super
+
+        self.register = 40
+        self.value = 40
+      end
+
       # Decode the data and return a hash of values in this input packet
       def to_h
         {
-          e_pv_all: Utils.int(@data[15, 4], :lsb) / 10.0, # kWh
-          e_inv_all: Utils.int(@data[27, 4], :lsb) / 10.0, # kWh
-          e_rec_all: Utils.int(@data[31, 4], :lsb) / 10.0, # kWh
-          e_chg_all: Utils.int(@data[35, 4], :lsb) / 10.0, # kWh
-          e_dischg_all: Utils.int(@data[39, 4], :lsb) / 10.0, # kWh
-          e_eps_all: Utils.int(@data[43, 4], :lsb) / 10.0, # kWh
-          e_to_grid_all: Utils.int(@data[47, 4], :lsb) / 10.0, # kWh
-          e_to_user_all: Utils.int(@data[51, 4], :lsb) / 10.0, # kWh
-
-          t_inner: Utils.int(@data[62, 2], :msb),
-          t_rad_1: Utils.int(@data[64, 2], :msb),
-          t_rad_2: Utils.int(@data[66, 2], :msb)
+          # 0 = static 1
+          # 1 = R_INPUT
+          # 2..12 = serial
+          # 13/14 = length
+
+          e_pv_all: (Utils.int(@data[15, 4]) +
+                     Utils.int(@data[19, 4]) +
+                     Utils.int(@data[23, 4])) / 10.0, # kWh
+          e_pv_1_all: Utils.int(@data[15, 4]) / 10.0, # kWh
+          e_pv_2_all: Utils.int(@data[19, 4]) / 10.0, # kWh
+          e_pv_3_all: Utils.int(@data[23, 4]) / 10.0, # kWh
+          e_inv_all: Utils.int(@data[27, 4]) / 10.0, # kWh
+          e_rec_all: Utils.int(@data[31, 4]) / 10.0, # kWh
+          e_chg_all: Utils.int(@data[35, 4]) / 10.0, # kWh
+          e_dischg_all: Utils.int(@data[39, 4]) / 10.0, # kWh
+          e_eps_all: Utils.int(@data[43, 4]) / 10.0, # kWh
+          e_to_grid_all: Utils.int(@data[47, 4]) / 10.0, # kWh
+          e_to_user_all: Utils.int(@data[51, 4]) / 10.0, # kWh
+
+          # 55 .. 62?
+          #   fault code? 4 bytes?
+          #   warning code? 4 bytes?
+
+          t_inner: Utils.int(@data[63, 2]),
+          t_rad_1: Utils.int(@data[65, 2]),
+          t_rad_2: Utils.int(@data[67, 2]),
+          t_bat: Utils.int(@data[69, 2]),
+
+          # 71..72 ?
+
+          # this actually seems to be cumulative runtime.
+          # not found an uptime since reboot yet.
+          uptime: Utils.int(@data[73, 4]) # seconds
         }
       end
     end

data/lib/lxp/packet/read_input3.rb

@@ -5,14 +5,30 @@ require_relative 'read_input'
 class LXP
   class Packet
     class ReadInput3 < ReadInput
+      def initialize
+        super
+
+        self.register = 80
+        self.value = 40
+      end
+
       # Decode the data and return a hash of values in this input packet
       def to_h
         {
-          max_chg_curr: Utils.int(@data[17, 2], :lsb) / 100.0, # A
-          max_dischg_curr: Utils.int(@data[19, 2], :lsb) / 100.0, # A
-          charge_volt_ref: Utils.int(@data[21, 2], :lsb) / 10.0, # V
-          dischg_cut_volt: Utils.int(@data[23, 2], :lsb) / 10.0, # V
+          # 0 = static 1
+          # 1 = R_INPUT
+          # 2..12 = serial
+          # 13/14 = length
 
+          # 15..16? .. (observed: 10)
+
+          max_chg_curr: Utils.int(@data[17, 2]) / 100.0, # A
+          max_dischg_curr: Utils.int(@data[19, 2]) / 100.0, # A
+          charge_volt_ref: Utils.int(@data[21, 2]) / 10.0, # V
+          dischg_cut_volt: Utils.int(@data[23, 2]) / 10.0, # V
+
+          # are these actually 2 bytes as well?
+          # never seen data in them so its hard to tell.
           bat_status_0: @data[25],
           bat_status_1: @data[27],
           bat_status_2: @data[29],
@@ -23,7 +39,9 @@ class LXP
           bat_status_7: @data[39],
           bat_status_8: @data[41],
           bat_status_9: @data[43],
-          bat_status_inv: @data[45]
+          bat_status_inv: @data[45],
+
+          bat_count: Utils.int(@data[47, 2])
         }
       end
     end

data/lib/lxp/packet/registers.rb

@@ -12,6 +12,9 @@ class LXP
       # Grid Charge Power Rate (%)
       AC_CHARGE_POWER_CMD = 66
 
+      # AC Charge SOC Limit (%)
+      AC_CHARGE_SOC_LIMIT = 67
+
       # Discharge cut-off SOC (%)
       DISCHG_CUT_OFF_SOC_EOD = 105
     end

data/lib/lxp/packet/write_single.rb

@@ -27,14 +27,10 @@ class LXP
       #
       # Raise if not, as that is not expected?
       #
-      # Base#value will return an int for protocol 1, or an Array
-      # for protocol 2. If we can, convert that Array to an int.
-      #
       def value
         raise 'value_length not 2?' unless value_length == 2
 
-        r = super
-        r.is_a?(Array) ? Utils.int(r, 2) : r
+        Utils.int(values[0, 2])
       end
     end
   end

data/lib/lxp/utils.rb

@@ -4,16 +4,14 @@ class LXP
   module Utils
     module_function
 
-    def int(bytes, order = :lsb)
-      bytes = bytes.reverse if order == :msb
-
+    def int(bytes)
       bytes.each_with_index.map do |b, idx|
         b << (idx * 8)
       end.inject(:|)
     end
 
-    def int_complement(bytes, order = :lsb)
-      r = int(bytes, order)
+    def int_complement(bytes)
+      r = int(bytes)
       r -= 0x10000 if r & 0x8000 == 0x8000
       r
     end

data/lib/lxp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class LXP
-  VERSION = '0.3.0'
+  VERSION = '0.7.1'
 end

data/lxp-packet.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.add_development_dependency 'bundler', '~> 2.0'
+  s.add_development_dependency 'rspec'
 end

data/spec/parser_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe LXP::Packet::Parser do
+  let(:parser) { LXP::Packet::Parser.new(input.pack('C*')) }
+  let(:packet) { parser.parse }
+
+  subject { packet }
+
+  context 'ReadHold multi data (registers 0-22)' do
+    let(:input) { [161, 26, 2, 0, 77, 0, 1, 194, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 63, 0, 1, 3, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 0, 0, 46, 134, 138, 1, 0, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 66, 65, 65, 65, 1, 10, 10, 1, 0, 0, 20, 4, 7, 16, 14, 49, 1, 0, 1, 0, 0, 0, 0, 0, 4, 0, 0, 0, 84, 243, 176, 4, 40, 224] }
+
+    it { is_expected.to be_a LXP::Packet::ReadHold }
+
+    it 'has the correct attributes' do
+      expect(packet).to have_attributes register: 0,
+                                        values: [134, 138, 1, 0, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 66, 65, 65, 65, 1, 10, 10, 1, 0, 0, 20, 4, 7, 16, 14, 49, 1, 0, 1, 0, 0, 0, 0, 0, 4, 0, 0, 0, 84, 243, 176, 4],
+                                        to_h: { 0 => 35_462, 1 => 1, 2 => 22_616, 3 => 22_616, 4 => 22_616, 5 => 22_616, 6 => 22_616, 7 => 16_706, 8 => 16_705, 9 => 2561, 10 => 266, 11 => 0, 12 => 1044, 13 => 4103, 14 => 12_558, 15 => 1, 16 => 1, 17 => 0, 18 => 0, 19 => 4, 20 => 0, 21 => 62_292, 22 => 1200 },
+                                        protocol: 2,
+                                        packet_length: 77, data_length: 63,
+                                        tcp_function: LXP::Packet::TcpFunctions::TRANSLATED_DATA,
+                                        device_function: LXP::Packet::DeviceFunctions::READ_HOLD,
+                                        inverter_serial: 'XXXXXXXXXX',
+                                        datalog_serial: 'cccccccccc',
+                                        bytes: input
+      expect(packet[22]).to eq 1200
+
+      # test out of bounds subscripts return nil
+      expect(packet[23]).to be_nil
+    end
+  end
+
+  context 'ReadHold multi data (registers 80-113)' do
+    let(:input) { [161, 26, 2, 0, 99, 0, 1, 194, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 85, 0, 1, 3, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 80, 0, 68, 0, 0, 0, 0, 100, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 0, 50, 0, 111, 9, 252, 8, 20, 0, 5, 0, 0, 0, 0, 0, 0, 0, 48, 2, 144, 1, 66, 0, 66, 0, 0, 0, 0, 0, 10, 0, 56, 255, 38, 2, 0, 0, 144, 1, 2, 0, 0, 0, 0, 0, 0, 0, 193, 242] }
+
+    it { is_expected.to be_a LXP::Packet::ReadHold }
+
+    it 'has the correct attributes' do
+      expect(packet).to have_attributes register: 80,
+                                        values: [0, 0, 0, 0, 100, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 0, 50, 0, 111, 9, 252, 8, 20, 0, 5, 0, 0, 0, 0, 0, 0, 0, 48, 2, 144, 1, 66, 0, 66, 0, 0, 0, 0, 0, 10, 0, 56, 255, 38, 2, 0, 0, 144, 1, 2, 0, 0, 0, 0, 0, 0, 0],
+                                        to_h: { 80 => 0, 81 => 0, 82 => 100, 83 => 20, 84 => 0, 85 => 0, 86 => 0, 87 => 0, 88 => 0, 89 => 0, 90 => 230, 91 => 50, 92 => 2415, 93 => 2300, 94 => 20, 95 => 5, 96 => 0, 97 => 0, 98 => 0, 99 => 560, 100 => 400, 101 => 66, 102 => 66, 103 => 0, 104 => 0, 105 => 10, 106 => 65_336, 107 => 550, 108 => 0, 109 => 400, 110 => 2, 111 => 0, 112 => 0, 113 => 0 },
+                                        protocol: 2,
+                                        packet_length: 99, data_length: 85,
+                                        tcp_function: LXP::Packet::TcpFunctions::TRANSLATED_DATA,
+                                        device_function: LXP::Packet::DeviceFunctions::READ_HOLD,
+                                        inverter_serial: 'XXXXXXXXXX',
+                                        datalog_serial: 'cccccccccc',
+                                        bytes: input
+      expect(packet[80]).to eq 0
+      expect(packet[94]).to eq 20
+      expect(packet[113]).to eq 0
+
+      # test out of bounds subscripts return nil
+      expect(packet[114]).to be_nil
+      expect(packet[79]).to be_nil
+    end
+  end
+
+  context 'ReadInput1 data' do
+    let(:input) { [161, 26, 2, 0, 111, 0, 1, 194, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 97, 0, 1, 4, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 0, 0, 80, 16, 0, 0, 0, 0, 0, 0, 0, 241, 1, 95, 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 121, 2, 172, 9, 1, 0, 0, 0, 146, 19, 57, 2, 0, 0, 227, 0, 232, 3, 172, 9, 0, 11, 80, 112, 146, 19, 0, 0, 0, 0, 0, 0, 0, 0, 221, 0, 0, 0, 0, 0, 42, 0, 73, 0, 86, 0, 52, 0, 0, 0, 36, 0, 2, 0, 172, 14, 181, 11, 127, 131] }
+
+    it { is_expected.to be_a LXP::Packet::ReadInput1 }
+
+    it 'has the correct attributes' do
+      expect(packet).to have_attributes register: 0,
+                                        values: [16, 0, 0, 0, 0, 0, 0, 0, 241, 1, 95, 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 121, 2, 172, 9, 1, 0, 0, 0, 146, 19, 57, 2, 0, 0, 227, 0, 232, 3, 172, 9, 0, 11, 80, 112, 146, 19, 0, 0, 0, 0, 0, 0, 0, 0, 221, 0, 0, 0, 0, 0, 42, 0, 73, 0, 86, 0, 52, 0, 0, 0, 36, 0, 2, 0, 172, 14, 181, 11],
+                                        protocol: 2,
+                                        packet_length: 111, data_length: 97,
+                                        tcp_function: LXP::Packet::TcpFunctions::TRANSLATED_DATA,
+                                        device_function: LXP::Packet::DeviceFunctions::READ_INPUT,
+                                        inverter_serial: 'XXXXXXXXXX',
+                                        datalog_serial: 'cccccccccc',
+                                        bytes: input
+    end
+
+    describe '#to_h' do
+      subject { packet.to_h }
+      it { is_expected.to eq _unknown_i1_27: 0, _unknown_i1_28: 47, _unknown_i1_27_28: 12_032, _unknown_i1_51_52: 227, status: 16, v_pv_1: 0.0, v_pv_2: 0.0, v_pv_3: 0.0, v_bat: 49.7, soc: 95, p_pv: 0, p_pv_1: 0, p_pv_2: 0, p_pv_3: 0, p_charge: 0, p_discharge: 633, v_ac_r: 247.6, v_ac_s: 0.1, v_ac_t: 0.0, f_ac: 50.1, p_inv: 569, p_rec: 0, pf: 1.0, v_eps_r: 247.6, v_eps_s: 281.6, v_eps_t: 2875.2, f_eps: 50.1, p_to_grid: 0, p_to_user: 0, e_pv_day: 22.1, e_pv_1_day: 22.1, e_pv_2_day: 0.0, e_pv_3_day: 0.0, e_inv_day: 4.2, e_rec_day: 7.3, e_chg_day: 8.6, e_dischg_day: 5.2, e_eps_day: 0.0, e_to_grid_day: 3.6, e_to_user_day: 0.2, v_bus_1: 375.6, v_bus_2: 299.7 }
+    end
+  end
+
+  context 'ReadInput2 data' do
+    let(:input) { [161, 26, 2, 0, 111, 0, 1, 194, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 97, 0, 1, 4, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 40, 0, 80, 83, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 179, 38, 0, 0, 43, 45, 0, 0, 105, 51, 0, 0, 44, 47, 0, 0, 0, 0, 0, 0, 95, 5, 0, 0, 63, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 36, 0, 37, 0, 0, 0, 0, 0, 35, 136, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 188, 199] }
+
+    it { is_expected.to be_a LXP::Packet::ReadInput2 }
+
+    it 'has the correct attributes' do
+      expect(packet).to have_attributes register: 40,
+                                        values: [83, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 179, 38, 0, 0, 43, 45, 0, 0, 105, 51, 0, 0, 44, 47, 0, 0, 0, 0, 0, 0, 95, 5, 0, 0, 63, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 36, 0, 37, 0, 0, 0, 0, 0, 35, 136, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                                        protocol: 2,
+                                        packet_length: 111, data_length: 97,
+                                        tcp_function: LXP::Packet::TcpFunctions::TRANSLATED_DATA,
+                                        device_function: LXP::Packet::DeviceFunctions::READ_INPUT,
+                                        inverter_serial: 'XXXXXXXXXX',
+                                        datalog_serial: 'cccccccccc',
+                                        bytes: input
+    end
+
+    describe '#to_h' do
+      subject { packet.to_h }
+      it { is_expected.to eq e_chg_all: 1316.1, e_dischg_all: 1207.6, e_eps_all: 0.0, e_inv_all: 990.7, e_pv_all: 1774.7, e_pv_1_all: 1774.7, e_pv_2_all: 0.0, e_pv_3_all: 0.0, e_rec_all: 1156.3, e_to_grid_all: 137.5, e_to_user_all: 1183.9, t_bat: 0, t_inner: 48, t_rad_1: 36, t_rad_2: 37, uptime: 14_714_915 }
+    end
+  end
+end

data/spec/read_hold_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe LXP::Packet::ReadHold do
+  let(:packet) { LXP::Packet::ReadHold.new }
+
+  before do
+    packet.inverter_serial = '1234567890'
+    packet.datalog_serial = '0987654321'
+    packet.register = 21
+  end
+
+  it 'has the correct attributes' do
+    expect(packet).to have_attributes register: 21, values: [1, 0], value: 1,
+                                      to_h: { 21 => 1 },
+                                      protocol: 1,
+                                      packet_length: 32, data_length: 18,
+                                      tcp_function: LXP::Packet::TcpFunctions::TRANSLATED_DATA,
+                                      device_function: LXP::Packet::DeviceFunctions::READ_HOLD,
+                                      inverter_serial: '1234567890',
+                                      datalog_serial: '0987654321',
+                                      bytes: [161, 26, 1, 0, 32, 0, 1, 194, 48, 57, 56, 55, 54, 53, 52, 51, 50, 49, 18, 0, 0, 3, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 21, 0, 1, 0, 241, 72]
+    expect(packet[21]).to eq 1
+  end
+
+  it 'creates the correct binary' do
+    expect(packet.to_bin).to eq [161, 26, 1, 0, 32, 0, 1, 194, 48, 57, 56, 55, 54, 53, 52, 51, 50, 49, 18, 0, 0, 3, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 21, 0, 1, 0, 241, 72].pack('C*')
+  end
+
+  it 'works with protocol 2' do
+    packet.protocol = 2
+    expect(packet).to have_attributes protocol: 2,
+                                      bytes: [161, 26, 2, 0, 32, 0, 1, 194, 48, 57, 56, 55, 54, 53, 52, 51, 50, 49, 18, 0, 0, 3, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 21, 0, 1, 0, 241, 72]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'lxp/packet'

data/spec/write_single_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.describe LXP::Packet::WriteSingle do
+  let(:packet) { LXP::Packet::WriteSingle.new }
+
+  before do
+    packet.inverter_serial = '1234567890'
+    packet.datalog_serial = '0987654321'
+    packet.register = 21
+    packet.value = 8000
+  end
+
+  it 'has the correct attributes' do
+    expect(packet).to have_attributes register: 21, values: [64, 31], value: 8000,
+                                      protocol: 1,
+                                      packet_length: 32, data_length: 18,
+                                      tcp_function: LXP::Packet::TcpFunctions::TRANSLATED_DATA,
+                                      device_function: LXP::Packet::DeviceFunctions::WRITE_SINGLE,
+                                      inverter_serial: '1234567890',
+                                      datalog_serial: '0987654321',
+                                      bytes: [161, 26, 1, 0, 32, 0, 1, 194, 48, 57, 56, 55, 54, 53, 52, 51, 50, 49, 18, 0, 0, 6, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 21, 0, 64, 31, 69, 211]
+  end
+
+  it 'creates the correct binary' do
+    expect(packet.to_bin).to eq [161, 26, 1, 0, 32, 0, 1, 194, 48, 57, 56, 55, 54, 53, 52, 51, 50, 49, 18, 0, 0, 6, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 21, 0, 64, 31, 69, 211].pack('C*')
+  end
+
+  it 'works with protocol 2' do
+    packet.protocol = 2
+    expect(packet).to have_attributes protocol: 2,
+                                      bytes: [161, 26, 2, 0, 32, 0, 1, 194, 48, 57, 56, 55, 54, 53, 52, 51, 50, 49, 18, 0, 0, 6, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 21, 0, 64, 31, 69, 211]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lxp-packet
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Chris Elsworth
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-02 00:00:00.000000000 Z
+date: 2021-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,7 +24,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-description: 
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
 email:
 - chris@cae.me.uk
 executables: []
@@ -32,6 +46,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -55,13 +71,17 @@ files:
 - lib/lxp/utils.rb
 - lib/lxp/version.rb
 - lxp-packet.gemspec
+- spec/parser_spec.rb
+- spec/read_hold_spec.rb
+- spec/spec_helper.rb
+- spec/write_single_spec.rb
 homepage: https://github.com/celsworth/lxp-packet
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/celsworth/lxp-packet
   source_code_uri: https://github.com/celsworth/lxp-packet
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -76,9 +96,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Library to generate and parse LuxPower inverter packets
 test_files: []