mitsubishi_heatpump 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8314b54176fb56cef543e4d4f9d7fe66b80d1ac9ed10ad6da8ac847bb5afce70
+  data.tar.gz: f8a8874b0f8211523354c406a08e03e2fceeee7bac2642cf3a3ee9ed77e134c4
+SHA512:
+  metadata.gz: bbe752efd1571bba5eb2aa708ee4a43c521a4bdfc221952175591a1fb0c980c833224bf5f7d2d5f85f9c2d4fd2032141171122661640ceb7ca9c22932e7556c5
+  data.tar.gz: df5b374886f07d08e0cc7f17b9999c615581fbbe5ac39e289c233355f18bffb24f7e2dc6199807422e1bb39c3308e95e57074c558f266b754621bcbdfdb0db74

data/bin/mitsubishi

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "mitsubishi_heatpump"
+
+std_opts = { port: 80 }
+settings = {}
+
+# rubocop:todo Metrics/BlockLength -- Refactor into Parser class
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: mitsubishi HOST [options]"
+
+  opts.on("HOST", "Heatpump host") do |host|
+    std_opts[:host] = host
+  end
+
+  opts.on("-p", "--port PORT", Integer, "Heatpump port (default 80)") do |port|
+    std_opts[:port] = port
+  end
+
+  opts.on("--power POWER", "Set power (on/off)") do |power|
+    if power.downcase == "on"
+      settings[:power] = MitsubishiHeatpump::DataTypes::Power.ON
+    elsif power.downcase == "off"
+      settings[:power] = MitsubishiHeatpump::DataTypes::Power.OFF
+    end
+  end
+
+  opts.on("--target-temp TEMP", Integer, "Set target temperature") do |temp|
+    settings[:target_temp] = MitsubishiHeatpump::DataTypes::EnhancedTemperature.new(temp)
+  end
+
+  opts.on("--mode MODE", "Set mode (auto/cool/heat/dry/fan)") do |mode|
+    case mode.downcase
+    when "auto"
+      settings[:operation_mode] = MitsubishiHeatpump::DataTypes::OperationMode.AUTO
+    when "cool"
+      settings[:operation_mode] = MitsubishiHeatpump::DataTypes::OperationMode.COOL
+    when "heat"
+      settings[:operation_mode] = MitsubishiHeatpump::DataTypes::OperationMode.HEAT
+    when "dry"
+      settings[:operation_mode] = MitsubishiHeatpump::DataTypes::OperationMode.DEHUMIDIFY
+    when "fan"
+      settings[:operation_mode] = MitsubishiHeatpump::DataTypes::OperationMode.FAN
+    end
+  end
+
+  opts.on("--fan-speed SPEED", "Set fan speed (auto/quiet/low/medium/high/very_high)") do |speed|
+    settings[:fan_speed] = case speed.downcase
+                           when "auto"
+                             MitsubishiHeatpump::DataTypes::FanMode.AUTO
+                           when "quiet"
+                             MitsubishiHeatpump::DataTypes::FanMode.QUIET
+                           when "low"
+                             MitsubishiHeatpump::DataTypes::FanMode.LOW
+                           when "medium"
+                             MitsubishiHeatpump::DataTypes::FanMode.MEDIUM
+                           when "high"
+                             MitsubishiHeatpump::DataTypes::FanMode.HIGH
+                           when "very_high"
+                             MitsubishiHeatpump::DataTypes::FanMode.VERY_HIGH
+                           end
+  end
+
+  opts.on("--vertical-vane POSITION", "Set vertical vane position (auto/1-5/swing)") do |position|
+    position = case position.downcase
+               when "auto"
+                 0
+               when "swing"
+                 7
+               else
+                 position.to_i
+               end
+    settings[:vertical_vane] = MitsubishiHeatpump::DataTypes::VerticalVane.new(position)
+  end
+
+  opts.on("--horizontal-vane POSITION", "Set horizontal vane position (auto/full_left/left/center/right/full_right/"\
+  "split_center_left/split_center_right/split_left_right/split_center_left_right/swing)") do |position|
+    settings[:horizontal_vane] = case position.downcase
+                                 when "auto"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.AUTO
+                                 when "full_left"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.FULL_LEFT
+                                 when "left"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.LEFT
+                                 when "center"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.CENTER
+                                 when "right"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.RIGHT
+                                 when "full_right"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.FULL_RIGHT
+                                 when "split_center_left"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.SPLIT_CENTER_LEFT
+                                 when "split_center_right"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.SPLIT_CENTER_RIGHT
+                                 when "split_left_right"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.SPLIT_LEFT_RIGHT
+                                 when "split_center_left_right"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.SPLIT_CENTER_LEFT_RIGHT
+                                 when "swing"
+                                   MitsubishiHeatpump::DataTypes::HorizontalVane.SWING
+                                 end
+  end
+
+  opts.on("--dry-run", "Perform a dry run without sending commands") do
+    std_opts[:dry_run] = true
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+# rubocop:enable Metrics/BlockLength
+
+option_parser.parse!(ARGV)
+
+std_opts[:host] = ARGV.shift
+
+if std_opts[:host].nil?
+  puts "Error: HOST is required\n"
+  puts option_parser.help
+  exit 1
+end
+
+api = MitsubishiHeatpump::API.new(std_opts[:host], std_opts[:port])
+
+if settings.empty?
+  resp = api.status
+else
+  command = MitsubishiHeatpump::Protocol::PDU.new(
+    MitsubishiHeatpump::Protocol::SetRequest.new(
+      MitsubishiHeatpump::Protocol::SetSettings.new(
+        **settings
+      )
+    )
+  )
+  puts "Sending command:"
+  puts command.inspect
+  resp = api.send_command(command) unless std_opts[:dry_run]
+end
+
+resp.each do |pdu|
+  puts "#{pdu}\n\n"
+end

data/lib/mitsubishi_heatpump/abc.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module MitsubishiHeatpump
+  module ABC
+    ##
+    # Packet base class
+    class Packet
+      attr_reader :command
+
+      def initialize(command)
+        @command = command
+      end
+
+      def serialize
+        [@command.class::COMMAND_ID] + @command.serialize
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last} => #{@command.inspect}"
+      end
+
+      alias to_s inspect
+
+      def self.parse(payload)
+        command_type = self::COMMAND_TYPES[payload[0]]
+        raise ProtocolError, "Unsupported command type" unless command_type
+
+        new(command_type.parse(payload[1..]))
+      end
+    end
+
+    ##
+    # Command base class
+    class Command
+      UPDATE_FLAGS_SIZE = 0
+      def initialize(**kwargs)
+        kwargs.each do |key, value|
+          raise ArgumentError, "Unknown parameter: #{key}" unless self.class::BYTE_VALUES.key?(key)
+
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def self.parse(payload)
+        new(**self::BYTE_VALUES.transform_values do |param|
+          param.cls.parse(
+            param.mask && param.byte.is_a?(Integer) ? payload[param.byte] & param.mask : payload[param.byte]
+          )
+        end)
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- Hard to refactor without increasing runtime complexity
+      def serialize
+        update_flag_size = self.class::UPDATE_FLAGS_SIZE
+        update_flags = DataTypes::UpdateFlags.new(0, update_flag_size)
+        bytes = [0] * 15
+        self.class::BYTE_VALUES.each do |key, param|
+          byte = param.byte
+          flag = param.update_flag || 0
+          value = instance_variable_get("@#{key}")&.serialize
+          next unless value
+
+          update_flags |= flag
+          if byte.is_a?(Integer)
+            bytes[byte] |= value
+          else
+            bytes[byte] = value
+          end
+        end
+        update_flags.serialize + bytes[update_flag_size..]
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last} => " + instance_variables.map do |var|
+          "#{var[1..]}=#{instance_variable_get(var).inspect}"
+        end.join(", ")
+      end
+
+      alias to_s inspect
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    ##
+    # Generic data type base class.
+    class DataType
+      attr_reader :value
+
+      def initialize(value, byte_size = 1)
+        raise ArgumentError, "Invalid #{self.class}: #{value}" unless validate?(value)
+
+        @value = value
+        @byte_size = byte_size
+      end
+
+      def self.parse(data)
+        if data.is_a?(Array)
+          byte_size = data.length
+          value = 0
+          data.each_with_index do |b, i|
+            value |= b << (8 * (byte_size - 1 - i))
+          end
+          new(value, byte_size)
+        else
+          new(data)
+        end
+      end
+
+      def serialize
+        if @byte_size == 1
+          @value
+        else
+          result = []
+          @byte_size.times do |i|
+            result << ((@value >> (8 * (@byte_size - 1 - i))) & 0xff)
+          end
+          result
+        end
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last} (#{@value})"
+      end
+
+      alias to_s inspect
+    end
+
+    ##
+    # Range data type base class.
+    class RangeType < DataType
+      def validate?(data)
+        self.class::RANGE.include?(data)
+      end
+    end
+
+    ##
+    # Enum data type base class.
+    class EnumType < DataType
+      def self.respond_to_missing?(method_name, include_private = false)
+        constants.include?(method_name) || super
+      end
+
+      def self.method_missing(method_name, *args, &)
+        return new(const_get(method_name)) if respond_to_missing?(method_name)
+
+        super
+      end
+
+      def validate?(data)
+        self.class.constants.map { |const| self.class.const_get(const) }.include?(data)
+      end
+
+      def inspect
+        const_name = self.class.constants.find { |const| self.class.const_get(const) == @value }
+        "#{self.class.name.split("::").last}.#{const_name}"
+      end
+    end
+
+    ##
+    # BitMap data type base class.
+    class BitMapType < EnumType
+      def respond_to_missing?(method_name, include_private = false)
+        valid = self.class.constants
+        valid |= valid.map { |c| "#{c.downcase}?".to_sym }
+        valid.include?(method_name) ||
+          super
+      end
+
+      def method_missing(method_name, *args, &)
+        if respond_to_missing?(method_name)
+          return (@value & self.class.const_get(method_name[..-2])).anybits? if method_name.to_s.end_with?("?")
+
+          return self | self.class.const_get(method_name)
+        end
+
+        super
+      end
+
+      def |(other)
+        case other
+        when BitMapType
+          self.class.new(@value | other.value, @byte_size)
+        when Integer
+          self.class.new(@value | other, @byte_size)
+        else
+          raise ArgumentError, "Cannot perform bitwise OR with #{other.class}"
+        end
+      end
+
+      def &(other)
+        case other
+        when BitMapType
+          self.class.new(@value & other.value, @byte_size)
+        when Integer
+          self.class.new(@value & other, @byte_size)
+        else
+          raise ArgumentError, "Cannot perform bitwise AND with #{other.class}"
+        end
+      end
+
+      def validate?(data)
+        data.is_a?(Integer) && data >= 0 && data <= self.class.constants.map { |const| self.class.const_get(const) }.sum
+      end
+
+      def inspect
+        flags = self.class.constants.select { |const| @value.anybits?(self.class.const_get(const)) }
+        "#{self.class.name.split("::").last} (#{flags.empty? ? value : flags.map(&:to_s).join("|")})"
+      end
+    end
+  end
+end

data/lib/mitsubishi_heatpump/api.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MitsubishiHeatpump
+  ##
+  # Mitsubishi Heatpump API class for communicating with the heat pump unit.
+  class API
+    KEY_SIZE = 16
+    IV_SIZE = 16
+    DEFAULT_KEY = "unregistered\0\0\0\0"
+
+    def initialize(host, port = 80, key = DEFAULT_KEY)
+      raise ArgumentError, "Host is required" if host.nil?
+
+      @host = host
+      @port = port
+      @key = key.length < KEY_SIZE ? key + ("\x00" * (KEY_SIZE - key.length)) : key[0, KEY_SIZE]
+    end
+
+    def encrypt_payload(payload)
+      cipher = OpenSSL::Cipher.new("AES-128-CBC")
+      cipher.encrypt
+      cipher.key = @key
+      cipher.padding = 0
+      iv = cipher.random_iv
+      payload += "\x80#{"\x00" * (16 - ((payload.length + 1) % 16))}"
+      encrypted = cipher.update(payload) + cipher.final
+      Base64.strict_encode64(iv + encrypted)
+    end
+
+    def decrypt_payload(encrypted_payload)
+      decoded = Base64.strict_decode64(encrypted_payload)
+      iv = decoded[0, IV_SIZE]
+      cipher = OpenSSL::Cipher.new("AES-128-CBC")
+      cipher.decrypt
+      cipher.key = @key
+      cipher.iv = iv
+      cipher.padding = 0
+      decrypted = cipher.update(decoded[IV_SIZE..]) + cipher.final
+      decrypted.encode.rstrip.encode("UTF-8", invalid: :replace, undef: :replace).chomp("\ufffd")
+    end
+
+    def make_request(payload)
+      body = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><ESV>#{encrypt_payload(payload)}</ESV>"
+      Net::HTTP.start(@host, @port, use_ssl: false) do |http|
+        req = Net::HTTP::Post.new("/smart")
+        req.body = body
+        res = http.request(req)
+        xml = Nokogiri::XML.parse(res.body)
+        return parse_response(decrypt_payload(xml.at("ESV").content))
+      end
+    end
+
+    def status
+      payload = "<CSV><CONNECT>ON</CONNECT></CSV>"
+      make_request(payload)
+    end
+
+    def send_command(command)
+      payload = command.serialize
+      make_request("<CSV><CONNECT>ON</CONNECT><CODE><VALUE>#{payload}</VALUE></CODE></CSV>")
+    end
+
+    def parse_response(resp)
+      pdus = []
+      xml = Nokogiri::XML.parse(resp)
+
+      xml.xpath("./LSV/CODE/VALUE").each do |node|
+        pdus << MitsubishiHeatpump::Protocol::PDU.parse(node.content)
+      rescue MitsubishiHeatpump::ProtocolError
+        next
+      end
+      pdus
+    end
+  end
+end

data/lib/mitsubishi_heatpump/data_types.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module MitsubishiHeatpump
+  module DataTypes
+    class Power < ABC::EnumType
+      OFF = 0
+      ON = 1
+      TEST_MODE = 2
+    end
+
+    class OperatingMode < ABC::EnumType
+      HEAT = 1
+      DEHUMIDIFY = 2
+      COOL = 3
+      FAN = 7
+      AUTO = 8
+      I_SEE_HEAT = 9
+      I_SEE_DRY = 10
+      I_SEE_COOL = 11
+      AUTO_HEAT = 33
+      AUTO_COOL = 35
+    end
+
+    class FanMode < ABC::EnumType
+      AUTO = 0
+      QUIET = 1
+      LOW = 2
+      MEDIUM = 3
+      HIGH = 5
+      VERY_HIGH = 6
+    end
+
+    class VerticalVane < ABC::EnumType
+      AUTO = 0
+      POS_1 = 1
+      POS_2 = 2
+      POS_3 = 3
+      POS_4 = 4
+      POS_5 = 5
+      SWING = 7
+    end
+
+    ##
+    # Horizontal vane position data type.
+    class HorizontalVane < ABC::EnumType
+      AUTO = 0
+      FULL_LEFT = 1
+      LEFT = 2
+      CENTER = 3
+      RIGHT = 4
+      FULL_RIGHT = 5
+      SPLIT_CENTER_LEFT = 6
+      SPLIT_CENTER_RIGHT = 7
+      SPLIT_LEFT_RIGHT = 8
+      SPLIT_CENTER_LEFT_RIGHT = 9
+      SWING = 12
+
+      def self.parse(data)
+        super(data & 0x0f)
+      end
+    end
+
+    ##
+    # Horizontal vane adjustment data type.
+    class HorizontalVaneAdjustment < ABC::EnumType
+      OFF = 0
+      ON = 128
+
+      def self.parse(data)
+        super(data & 0xf0)
+      end
+    end
+
+    class TimerMode < ABC::EnumType
+      NONE = 0
+      OFF = 1
+      ON = 2
+      BOTH = 3
+    end
+
+    class FilterReset < ABC::EnumType
+      NO = 0
+      YES = 1
+    end
+
+    class PowerSavingMode < ABC::EnumType
+      OFF = 0
+      ON = 10
+    end
+
+    class AirflowControlMode < ABC::EnumType
+      EVEN = 0
+      INDIRECT = 1
+      DIRECT = 2
+    end
+
+    class RemoteProhibitFlags < ABC::BitMapType
+      LOCK_POWER = 0x01
+      LOCK_MODE = 0x02
+      LOCK_TEMPERATURE = 0x04
+    end
+
+    class StatusFlags < ABC::BitMapType
+      FILTER = 0x01
+      DEFROST = 0x02
+      HOT_ADJUST = 0x04
+      STANDBY = 0x08
+    end
+
+    ##
+    # Update flags data type.
+    class UpdateFlags < ABC::BitMapType
+      def serialize
+        if @byte_size.zero?
+          return []
+        elsif @byte_size == 1
+          return [@value]
+        end
+
+        super
+      end
+
+      def validate?(data)
+        data.is_a?(Integer)
+      end
+    end
+
+    ##
+    # Enhanced temperature data type.
+    class EnhancedTemperature < ABC::RangeType
+      RANGE = (-64..63.5)
+
+      def self.parse(data)
+        new((data - 128) * 0.5)
+      end
+
+      def serialize
+        ((@value * 2) + 128).to_i & 0xff
+      end
+    end
+
+    ##
+    #  Legacy setpoint temperature data type.
+    class LegacySetpointTemperature < ABC::RangeType
+      RANGE = (16..31.5)
+
+      def self.parse(data)
+        new(31 - (data & 0x0f) + (((data & 0x10) >> 4) * 0.5))
+      end
+
+      def serialize
+        int_temp = (31 - @value.floor) & 0x0f
+        half_temp = ((@value % 1) >= 0.5 ? 1 : 0) << 4
+        int_temp | half_temp
+      end
+    end
+
+    ##
+    # Legacy heat pump temperature data type.
+    class LegacyHeatPumpTemperature < ABC::RangeType
+      RANGE = (10..41)
+
+      def self.parse(data)
+        new(data + 10)
+      end
+
+      def serialize
+        @value.to_i - 10
+      end
+    end
+
+    ##
+    # Legacy room temperature data type.
+    class LegacyRoomTemperature < ABC::RangeType
+      RANGE = (8..39.5)
+
+      def self.parse(data)
+        new((data * 0.5) + 8)
+      end
+
+      def serialize
+        ((@value - 8) * 2).to_i
+      end
+    end
+
+    class DehumidifyValue < ABC::RangeType
+      RANGE = (0..100)
+    end
+
+    ##
+    # Generic scalar data type.
+    class Scalar < ABC::DataType
+      def validate?(data)
+        data.is_a?(Integer)
+      end
+    end
+  end
+end

data/lib/mitsubishi_heatpump/protocol.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module MitsubishiHeatpump
+  module Protocol
+    ByteParam = Struct.new("ByteParam", :byte, :cls, :update_flag, :mask)
+
+    class SetSettings < ABC::Command
+      COMMAND_ID = 0x01
+      UPDATE_FLAGS_SIZE = 2
+      BYTE_VALUES = {
+        power: ByteParam.new(2, DataTypes::Power, 0x0100),
+        operating_mode: ByteParam.new(3, DataTypes::OperatingMode, 0x0200),
+        legacy_target_temp: ByteParam.new(4, DataTypes::LegacySetpointTemperature, 0x0400),
+        fan_speed: ByteParam.new(5, DataTypes::FanMode, 0x0800),
+        vertical_vane: ByteParam.new(6, DataTypes::VerticalVane, 0x1000),
+        remote_prohibit_flags: ByteParam.new(10, DataTypes::RemoteProhibitFlags, 0x4000),
+        horizontal_vane: ByteParam.new(12, DataTypes::HorizontalVane, 0x0001),
+        target_temp: ByteParam.new(13, DataTypes::EnhancedTemperature, 0x0400)
+      }.freeze
+    end
+
+    class GetSettings < ABC::Command
+      COMMAND_ID = 0x02
+      BYTE_VALUES = {
+        power: ByteParam.new(2, DataTypes::Power),
+        operating_mode: ByteParam.new(3, DataTypes::OperatingMode),
+        legacy_target_temp: ByteParam.new(4, DataTypes::LegacySetpointTemperature),
+        fan_speed: ByteParam.new(5, DataTypes::FanMode),
+        vertical_vane: ByteParam.new(6, DataTypes::VerticalVane),
+        remote_prohibit_flags: ByteParam.new(7, DataTypes::RemoteProhibitFlags),
+        horizontal_vane: ByteParam.new(9, DataTypes::HorizontalVane, 0, 0x0f),
+        horizontal_vane_adjustment: ByteParam.new(9, DataTypes::HorizontalVaneAdjustment, 0, 0xf0),
+        target_temp: ByteParam.new(10, DataTypes::EnhancedTemperature),
+        target_humidity: ByteParam.new(11, DataTypes::DehumidifyValue),
+        power_saving_mode: ByteParam.new(12, DataTypes::PowerSavingMode),
+        airflow_control_mode: ByteParam.new(13, DataTypes::AirflowControlMode),
+        left_vertical_vane: ByteParam.new(14, DataTypes::Scalar)
+      }.freeze
+    end
+
+    class GetTemperatures < ABC::Command
+      COMMAND_ID = 0x03
+      BYTE_VALUES = {
+        legacy_temp: ByteParam.new(2, DataTypes::LegacyHeatPumpTemperature),
+        outdoor_unit_temp: ByteParam.new(4, DataTypes::EnhancedTemperature),
+        current_temp: ByteParam.new(5, DataTypes::EnhancedTemperature),
+        unknown1: ByteParam.new(6, DataTypes::EnhancedTemperature),
+        unknown2: ByteParam.new(7, DataTypes::Scalar),
+        unknown3: ByteParam.new(8, DataTypes::Scalar),
+        runtime: ByteParam.new(10..12, DataTypes::Scalar)
+      }.freeze
+    end
+
+    class GetErrorStatus < ABC::Command
+      COMMAND_ID = 0x04
+      BYTE_VALUES = {
+        error_code: ByteParam.new(3..4, DataTypes::Scalar),
+        short_error_code: ByteParam.new(5, DataTypes::Scalar)
+      }.freeze
+    end
+
+    class GetTimerInfo < ABC::Command
+      COMMAND_ID = 0x05
+      BYTE_VALUES = {
+        timer_mode: ByteParam.new(2, DataTypes::TimerMode),
+        on_minutes_set: ByteParam.new(3, DataTypes::Scalar),
+        off_minutes_set: ByteParam.new(4, DataTypes::Scalar),
+        on_minutes_remaining: ByteParam.new(5, DataTypes::Scalar),
+        off_minutes_remaining: ByteParam.new(6, DataTypes::Scalar)
+      }.freeze
+    end
+
+    class GetOperationStatus < ABC::Command
+      COMMAND_ID = 0x06
+      BYTE_VALUES = {
+        compressor_frequency: ByteParam.new(2, DataTypes::Scalar),
+        operating: ByteParam.new(3, DataTypes::Power),
+        input_power: ByteParam.new(4..5, DataTypes::Scalar),
+        lifetime_consumption: ByteParam.new(6..7, DataTypes::Scalar),
+        unknown1: ByteParam.new(10, DataTypes::Scalar)
+      }.freeze
+    end
+
+    class SetRunStatus < ABC::Command
+      COMMAND_ID = 0x08
+      UPDATE_FLAGS_SIZE = 2
+      BYTE_VALUES = {
+        filter_reset: ByteParam.new(2, DataTypes::FilterReset, 0x0001),
+        dehumidify_value: ByteParam.new(3, DataTypes::DehumidifyValue, 0x0004),
+        power_saving_mode: ByteParam.new(4, DataTypes::PowerSavingMode, 0x0008),
+        airflow_control_mode: ByteParam.new(5, DataTypes::AirflowControlMode, 0x0020)
+      }.freeze
+    end
+
+    class GetRunStatus < ABC::Command
+      COMMAND_ID = 0x09
+      BYTE_VALUES = {
+        flags: ByteParam.new(2, DataTypes::StatusFlags),
+        actual_fan_speed: ByteParam.new(3, DataTypes::Scalar),
+        auto_mode: ByteParam.new(4, DataTypes::Scalar)
+      }.freeze
+    end
+
+    class SetRequest < ABC::Packet
+      PACKET_TYPE = 0x41
+      COMMAND_TYPES = {
+        SetSettings => 0x01,
+        SetRunStatus => 0x08
+      }.freeze
+    end
+
+    class SetResponse < ABC::Packet
+      PACKET_TYPE = 0x61
+    end
+
+    class GetRequest < ABC::Packet
+      PACKET_TYPE = 0x42
+    end
+
+    class GetResponse < ABC::Packet
+      PACKET_TYPE = 0x62
+      COMMAND_TYPES = {
+        0x02 => GetSettings,
+        0x03 => GetTemperatures,
+        0x04 => GetErrorStatus,
+        0x05 => GetTimerInfo,
+        0x06 => GetOperationStatus,
+        0x09 => GetRunStatus
+      }.freeze
+    end
+
+    class ConnectRequest < ABC::Packet
+      PACKET_TYPE = 0x5a
+    end
+
+    class ConnectResponse < ABC::Packet
+      PACKET_TYPE = 0x7a
+    end
+
+    class IdentifyRequest < ABC::Packet
+      PACKET_TYPE = 0x5b
+    end
+
+    class IdentifyResponse < ABC::Packet
+      PACKET_TYPE = 0x7b
+    end
+
+    ##
+    # Protocol Data Unit (PDU) for Mitsubishi Heatpump communication.
+    class PDU
+      SYNC_BYTE = 0xfc
+      PROTOCOL_ID = [0x01, 0x30].freeze
+      PACKET_TYPES = {
+        0x41 => SetRequest,
+        0x61 => SetResponse,
+        0x42 => GetRequest,
+        0x62 => GetResponse,
+        0x5a => ConnectRequest,
+        0x7a => ConnectResponse,
+        0x5b => IdentifyRequest,
+        0x7b => IdentifyResponse
+      }.freeze
+
+      attr_reader :packet
+
+      def initialize(packet)
+        @packet = packet
+      end
+
+      def self.parse(hex_string)
+        bytes = [hex_string].pack("H*").bytes
+
+        validate(bytes)
+
+        new(PACKET_TYPES[bytes[1]].parse(bytes[5, bytes[4]]))
+      end
+
+      def serialize
+        payload = @packet.serialize
+        length = payload.length
+        bytes = [SYNC_BYTE, @packet.class::PACKET_TYPE, *PROTOCOL_ID, length] + payload
+        checksum = Util.calculate_checksum(bytes)
+        bytes << checksum
+        bytes.map { |b| format("%02x", b) }.join
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last} => #{@packet.inspect}"
+      end
+
+      alias to_s inspect
+
+      def self.validate(bytes)
+        raise ProtocolError, "Invalid packet" if bytes.empty? || bytes[0] != SYNC_BYTE
+
+        raise ProtocolError, "Unsupported packet type" unless PACKET_TYPES[bytes[1]]
+
+        raise ProtocolError, "Unsupported protocol" unless bytes[2..3] == PROTOCOL_ID
+
+        raise ProtocolError, "Invalid checksum" unless Util.calculate_checksum(bytes[..-2]) == bytes.last
+      end
+    end
+
+    class ProtocolError < StandardError; end
+  end
+end

data/lib/mitsubishi_heatpump/util.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MitsubishiHeatpump
+  ##
+  # Utility functions for Mitsubishi Heatpump protocol.
+  class Util
+    def self.calculate_checksum(bytes)
+      (0xfc - bytes.sum) & 0xff
+    end
+  end
+end

data/lib/mitsubishi_heatpump/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MitsubishiHeatpump
+  VERSION = "0.1.0"
+end

data/lib/mitsubishi_heatpump.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "base64"
+require "nokogiri"
+require "mitsubishi_heatpump/util"
+require "mitsubishi_heatpump/abc"
+require "mitsubishi_heatpump/api"
+require "mitsubishi_heatpump/data_types"
+require "mitsubishi_heatpump/protocol"

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: mitsubishi_heatpump
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anders Alfredsson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.82'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.82'
+description:
+email: andersb86@gmail.com
+executables:
+- mitsubishi
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mitsubishi
+- lib/mitsubishi_heatpump.rb
+- lib/mitsubishi_heatpump/abc.rb
+- lib/mitsubishi_heatpump/api.rb
+- lib/mitsubishi_heatpump/data_types.rb
+- lib/mitsubishi_heatpump/protocol.rb
+- lib/mitsubishi_heatpump/util.rb
+- lib/mitsubishi_heatpump/version.rb
+homepage: https://github.com/pacive/mitsubishi_heatpump
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: A gem for local control of Mitsubishi heat pumps
+test_files: []