From f3246eb779b087bfbe3908d84dc9111506b8828a Mon Sep 17 00:00:00 2001 From: sususweet Date: Sun, 28 Sep 2025 20:24:15 +0800 Subject: [PATCH] feat: add transparent protocol. --- .../midea_auto_cloud/__init__.py | 23 +- custom_components/midea_auto_cloud/climate.py | 1 - custom_components/midea_auto_cloud/const.py | 1 + .../midea_auto_cloud/core/cloud.py | 85 +++- .../midea_auto_cloud/core/device.py | 148 +++++- .../midea_auto_cloud/core/lua_runtime.py | 91 ++++ .../midea_auto_cloud/core/util.py | 50 ++ .../midea_auto_cloud/data_coordinator.py | 40 +- .../midea_auto_cloud/device_mapping/T0xAC.py | 16 +- .../midea_auto_cloud/device_mapping/T0xE2.py | 466 ++++++++++++++++++ .../midea_auto_cloud/manifest.json | 4 +- 11 files changed, 851 insertions(+), 74 deletions(-) create mode 100644 custom_components/midea_auto_cloud/core/lua_runtime.py create mode 100644 custom_components/midea_auto_cloud/core/util.py create mode 100644 custom_components/midea_auto_cloud/device_mapping/T0xE2.py diff --git a/custom_components/midea_auto_cloud/__init__.py b/custom_components/midea_auto_cloud/__init__.py index 4ecd64d..9e99798 100644 --- a/custom_components/midea_auto_cloud/__init__.py +++ b/custom_components/midea_auto_cloud/__init__.py @@ -41,7 +41,7 @@ from .const import ( CONF_SN8, CONF_SN, CONF_MODEL_NUMBER, - CONF_SERVERS + CONF_SERVERS, STORAGE_PATH, CONF_MANUFACTURER_CODE ) # 账号型：登录云端、获取设备列表，并为每台设备建立协调器（无本地控制） from .const import CONF_PASSWORD as CONF_PASSWORD_KEY, CONF_SERVER as CONF_SERVER_KEY @@ -179,11 +179,21 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry): # 为每台设备构建占位设备与协调器（不连接本地） for appliance_code, info in appliances.items(): MideaLogger.debug(f"info={info} ") + + os.makedirs(hass.config.path(STORAGE_PATH), exist_ok=True) + path = hass.config.path(STORAGE_PATH) + file = await cloud.download_lua( + path=path, + device_type=info.get(CONF_TYPE), + sn=info.get(CONF_SN), + model_number=info.get(CONF_MODEL_NUMBER), + manufacturer_code=info.get(CONF_MANUFACTURER_CODE), + ) try: device = MiedaDevice( - name=info.get(CONF_NAME) or info.get("name"), + name=info.get(CONF_NAME), device_id=appliance_code, - device_type=info.get(CONF_TYPE) or info.get("type"), + device_type=info.get(CONF_TYPE), ip_address=None, port=None, token=None, @@ -192,8 +202,10 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry): protocol=info.get(CONF_PROTOCOL) or 2, model=info.get(CONF_MODEL), subtype=info.get(CONF_MODEL_NUMBER), - sn=info.get(CONF_SN) or info.get("sn"), - sn8=info.get(CONF_SN8) or info.get("sn8"), + sn=info.get(CONF_SN), + sn8=info.get(CONF_SN8), + lua_file=file, + cloud=cloud, ) # 加载并应用设备映射（queries/centralized/calculate），并预置 attributes 键 try: @@ -289,6 +301,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry): bucket["coordinator_map"][appliance_code] = coordinator except Exception as e: MideaLogger.error(f"Init device failed: {appliance_code}, error: {e}") + # break hass.data[DOMAIN]["accounts"][config_entry.entry_id] = bucket except Exception as e: diff --git a/custom_components/midea_auto_cloud/climate.py b/custom_components/midea_auto_cloud/climate.py index 058ed28..def8ad4 100644 --- a/custom_components/midea_auto_cloud/climate.py +++ b/custom_components/midea_auto_cloud/climate.py @@ -256,7 +256,6 @@ class MideaClimateEntity(MideaEntity, ClimateEntity): if dict_config is None: return None - MideaLogger.debug(f"dict_config={dict_config}, rationale={rationale}, self.device_attributes={self.device_attributes} ") for key, config in dict_config.items(): if isinstance(config, dict): # Check if all conditions match diff --git a/custom_components/midea_auto_cloud/const.py b/custom_components/midea_auto_cloud/const.py index 0df8c68..65c7f2f 100644 --- a/custom_components/midea_auto_cloud/const.py +++ b/custom_components/midea_auto_cloud/const.py @@ -11,6 +11,7 @@ CONF_KEY = "key" CONF_SN = "sn" CONF_SN8 = "sn8" CONF_MODEL_NUMBER = "model_number" +CONF_MANUFACTURER_CODE = "manufacturer_code" CONF_LUA_FILE = "lua_file" CJSON_LUA = "--
-- cjson.lua
--
-- Copyright (c) 2018 rxi
--
-- Permission is hereby granted, free of charge, to any person obtaining a copy of
-- this software and associated documentation files (the "Software"), to deal in
-- the Software without restriction, including without limitation the rights to
-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-- of the Software, and to permit persons to whom the Software is furnished to do
-- so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in all
-- copies or substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-- SOFTWARE.
--

local cjson = { _version = "0.1.1" }

-------------------------------------------------------------------------------
-- Encode
-------------------------------------------------------------------------------

local encode

local escape_char_map = {
  [ "\\" ] = "\\\\",
  [ "\"" ] = "\\\"",
  [ "\b" ] = "\\b",
  [ "\f" ] = "\\f",
  [ "\n" ] = "\\n",
  [ "\r" ] = "\\r",
  [ "\t" ] = "\\t",
}

local escape_char_map_inv = { [ "\\/" ] = "/" }
for k, v in pairs(escape_char_map) do
  escape_char_map_inv[v] = k
end


local function escape_char(c)
  return escape_char_map[c] or string.format("\\u%04x", c:byte())
end


local function encode_nil(val)
  return "null"
end


local function encode_table(val, stack)
  local res = {}
  stack = stack or {}

  -- Circular reference?
  if stack[val] then error("circular reference") end

  stack[val] = true

  if val[1] ~= nil or next(val) == nil then
    -- Treat as array -- check keys are valid and it is not sparse
    local n = 0
    for k in pairs(val) do
      if type(k) ~= "number" then
        error("invalid table: mixed or invalid key types")
      end
      n = n + 1
    end
    if n ~= #val then
      error("invalid table: sparse array")
    end
    -- Encode
    for i, v in ipairs(val) do
      table.insert(res, encode(v, stack))
    end
    stack[val] = nil
    return "[" .. table.concat(res, ",") .. "]"

  else
    -- Treat as an object
    for k, v in pairs(val) do
      if type(k) ~= "string" then
        error("invalid table: mixed or invalid key types")
      end
      table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
    end
    stack[val] = nil
    return "{" .. table.concat(res, ",") .. "}"
  end
end


local function encode_string(val)
  return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
end


local function encode_number(val)
  -- Check for NaN, -inf and inf
  if val ~= val or val <= -math.huge or val >= math.huge then
    error("unexpected number value '" .. tostring(val) .. "'")
  end
  return string.format("%.14g", val)
end


local type_func_map = {
  [ "nil"     ] = encode_nil,
  [ "table"   ] = encode_table,
  [ "string"  ] = encode_string,
  [ "number"  ] = encode_number,
  [ "boolean" ] = tostring,
}


encode = function(val, stack)
  local t = type(val)
  local f = type_func_map[t]
  if f then
    return f(val, stack)
  end
  error("unexpected type '" .. t .. "'")
end


function cjson.encode(val)
  return ( encode(val) )
end


-------------------------------------------------------------------------------
-- Decode
-------------------------------------------------------------------------------

local parse

local function create_set(...)
  local res = {}
  for i = 1, select("#", ...) do
    res[ select(i, ...) ] = true
  end
  return res
end

local space_chars   = create_set(" ", "\t", "\r", "\n")
local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
local literals      = create_set("true", "false", "null")

local literal_map = {
  [ "true"  ] = true,
  [ "false" ] = false,
  [ "null"  ] = nil,
}


local function next_char(str, idx, set, negate)
  for i = idx, #str do
    if set[str:sub(i, i)] ~= negate then
      return i
    end
  end
  return #str + 1
end


local function decode_error(str, idx, msg)
  local line_count = 1
  local col_count = 1
  for i = 1, idx - 1 do
    col_count = col_count + 1
    if str:sub(i, i) == "\n" then
      line_count = line_count + 1
      col_count = 1
    end
  end
  error( string.format("%s at line %d col %d", msg, line_count, col_count) )
end


local function codepoint_to_utf8(n)
  -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
  local f = math.floor
  if n <= 0x7f then
    return string.char(n)
  elseif n <= 0x7ff then
    return string.char(f(n / 64) + 192, n % 64 + 128)
  elseif n <= 0xffff then
    return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
  elseif n <= 0x10ffff then
    return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
                       f(n % 4096 / 64) + 128, n % 64 + 128)
  end
  error( string.format("invalid unicode codepoint '%x'", n) )
end


local function parse_unicode_escape(s)
  local n1 = tonumber( s:sub(3, 6),  16 )
  local n2 = tonumber( s:sub(9, 12), 16 )
  -- Surrogate pair?
  if n2 then
    return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
  else
    return codepoint_to_utf8(n1)
  end
end


local function parse_string(str, i)
  local has_unicode_escape = false
  local has_surrogate_escape = false
  local has_escape = false
  local last
  for j = i + 1, #str do
    local x = str:byte(j)

    if x < 32 then
      decode_error(str, j, "control character in string")
    end

    if last == 92 then -- "\\" (escape char)
      if x == 117 then -- "u" (unicode escape sequence)
        local hex = str:sub(j + 1, j + 5)
        if not hex:find("%x%x%x%x") then
          decode_error(str, j, "invalid unicode escape in string")
        end
        if hex:find("^[dD][89aAbB]") then
          has_surrogate_escape = true
        else
          has_unicode_escape = true
        end
      else
        local c = string.char(x)
        if not escape_chars[c] then
          decode_error(str, j, "invalid escape char '" .. c .. "' in string")
        end
        has_escape = true
      end
      last = nil

    elseif x == 34 then -- '"' (end of string)
      local s = str:sub(i + 1, j - 1)
      if has_surrogate_escape then
        s = s:gsub("\\u[dD][89aAbB]..\\u....", parse_unicode_escape)
      end
      if has_unicode_escape then
        s = s:gsub("\\u....", parse_unicode_escape)
      end
      if has_escape then
        s = s:gsub("\\.", escape_char_map_inv)
      end
      return s, j + 1

    else
      last = x
    end
  end
  decode_error(str, i, "expected closing quote for string")
end


local function parse_number(str, i)
  local x = next_char(str, i, delim_chars)
  local s = str:sub(i, x - 1)
  local n = tonumber(s)
  if not n then
    decode_error(str, i, "invalid number '" .. s .. "'")
  end
  return n, x
end


local function parse_literal(str, i)
  local x = next_char(str, i, delim_chars)
  local word = str:sub(i, x - 1)
  if not literals[word] then
    decode_error(str, i, "invalid literal '" .. word .. "'")
  end
  return literal_map[word], x
end


local function parse_array(str, i)
  local res = {}
  local n = 1
  i = i + 1
  while 1 do
    local x
    i = next_char(str, i, space_chars, true)
    -- Empty / end of array?
    if str:sub(i, i) == "]" then
      i = i + 1
      break
    end
    -- Read token
    x, i = parse(str, i)
    res[n] = x
    n = n + 1
    -- Next token
    i = next_char(str, i, space_chars, true)
    local chr = str:sub(i, i)
    i = i + 1
    if chr == "]" then break end
    if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
  end
  return res, i
end


local function parse_object(str, i)
  local res = {}
  i = i + 1
  while 1 do
    local key, val
    i = next_char(str, i, space_chars, true)
    -- Empty / end of object?
    if str:sub(i, i) == "}" then
      i = i + 1
      break
    end
    -- Read key
    if str:sub(i, i) ~= '"' then
      decode_error(str, i, "expected string for key")
    end
    key, i = parse(str, i)
    -- Read ':' delimiter
    i = next_char(str, i, space_chars, true)
    if str:sub(i, i) ~= ":" then
      decode_error(str, i, "expected ':' after key")
    end
    i = next_char(str, i + 1, space_chars, true)
    -- Read value
    val, i = parse(str, i)
    -- Set
    res[key] = val
    -- Next token
    i = next_char(str, i, space_chars, true)
    local chr = str:sub(i, i)
    i = i + 1
    if chr == "}" then break end
    if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
  end
  return res, i
end


local char_func_map = {
  [ '"' ] = parse_string,
  [ "0" ] = parse_number,
  [ "1" ] = parse_number,
  [ "2" ] = parse_number,
  [ "3" ] = parse_number,
  [ "4" ] = parse_number,
  [ "5" ] = parse_number,
  [ "6" ] = parse_number,
  [ "7" ] = parse_number,
  [ "8" ] = parse_number,
  [ "9" ] = parse_number,
  [ "-" ] = parse_number,
  [ "t" ] = parse_literal,
  [ "f" ] = parse_literal,
  [ "n" ] = parse_literal,
  [ "[" ] = parse_array,
  [ "{" ] = parse_object,
}


parse = function(str, idx)
  local chr = str:sub(idx, idx)
  local f = char_func_map[chr]
  if f then
    return f(str, idx)
  end
  decode_error(str, idx, "unexpected character '" .. chr .. "'")
end


function cjson.decode(str)
  if type(str) ~= "string" then
    error("expected argument of type string, got " .. type(str))
  end
  local res, idx = parse(str, next_char(str, 1, space_chars, true))
  idx = next_char(str, idx, space_chars, true)
  if idx <= #str then
    decode_error(str, idx, "trailing garbage")
  end
  return res
end
return cjson" BIT_LUA = "--[[

LUA MODULE

  bit.numberlua - Bitwise operations implemented in pure Lua as numbers,
    with Lua 5.2 'bit32' and (LuaJIT) LuaBitOp 'bit' compatibility interfaces.

SYNOPSIS

  local bit = require 'bit.numberlua'
  print(bit.band(0xff00ff00, 0x00ff00ff)) --> 0xffffffff
  
  -- Interface providing strong Lua 5.2 'bit32' compatibility
  local bit32 = require 'bit.numberlua'.bit32
  assert(bit32.band(-1) == 0xffffffff)
  
  -- Interface providing strong (LuaJIT) LuaBitOp 'bit' compatibility
  local bit = require 'bit.numberlua'.bit
  assert(bit.tobit(0xffffffff) == -1)
  
DESCRIPTION
  
  This library implements bitwise operations entirely in Lua.
  This module is typically intended if for some reasons you don't want
  to or cannot  install a popular C based bit library like BitOp 'bit' [1]
  (which comes pre-installed with LuaJIT) or 'bit32' (which comes
  pre-installed with Lua 5.2) but want a similar interface.
  
  This modules represents bit arrays as non-negative Lua numbers. [1]
  It can represent 32-bit bit arrays when Lua is compiled
  with lua_Number as double-precision IEEE 754 floating point.

  The module is nearly the most efficient it can be but may be a few times
  slower than the C based bit libraries and is orders or magnitude
  slower than LuaJIT bit operations, which compile to native code.  Therefore,
  this library is inferior in performane to the other modules.

  The `xor` function in this module is based partly on Roberto Ierusalimschy's
  post in http://lua-users.org/lists/lua-l/2002-09/msg00134.html .
  
  The included BIT.bit32 and BIT.bit sublibraries aims to provide 100%
  compatibility with the Lua 5.2 "bit32" and (LuaJIT) LuaBitOp "bit" library.
  This compatbility is at the cost of some efficiency since inputted
  numbers are normalized and more general forms (e.g. multi-argument
  bitwise operators) are supported.
  
STATUS

  WARNING: Not all corner cases have been tested and documented.
  Some attempt was made to make these similar to the Lua 5.2 [2]
  and LuaJit BitOp [3] libraries, but this is not fully tested and there
  are currently some differences.  Addressing these differences may
  be improved in the future but it is not yet fully determined how to
  resolve these differences.
  
  The BIT.bit32 library passes the Lua 5.2 test suite (bitwise.lua)
  http://www.lua.org/tests/5.2/ .  The BIT.bit library passes the LuaBitOp
  test suite (bittest.lua).  However, these have not been tested on
  platforms with Lua compiled with 32-bit integer numbers.

API

  BIT.tobit(x) --> z
  
    Similar to function in BitOp.
    
  BIT.tohex(x, n)
  
    Similar to function in BitOp.
  
  BIT.band(x, y) --> z
  
    Similar to function in Lua 5.2 and BitOp but requires two arguments.
  
  BIT.bor(x, y) --> z
  
    Similar to function in Lua 5.2 and BitOp but requires two arguments.

  BIT.bxor(x, y) --> z
  
    Similar to function in Lua 5.2 and BitOp but requires two arguments.
  
  BIT.bnot(x) --> z
  
    Similar to function in Lua 5.2 and BitOp.

  BIT.lshift(x, disp) --> z
  
    Similar to function in Lua 5.2 (warning: BitOp uses unsigned lower 5 bits of shift),
  
  BIT.rshift(x, disp) --> z
  
    Similar to function in Lua 5.2 (warning: BitOp uses unsigned lower 5 bits of shift),

  BIT.extract(x, field [, width]) --> z
  
    Similar to function in Lua 5.2.
  
  BIT.replace(x, v, field, width) --> z
  
    Similar to function in Lua 5.2.
  
  BIT.bswap(x) --> z
  
    Similar to function in Lua 5.2.

  BIT.rrotate(x, disp) --> z
  BIT.ror(x, disp) --> z
  
    Similar to function in Lua 5.2 and BitOp.

  BIT.lrotate(x, disp) --> z
  BIT.rol(x, disp) --> z

    Similar to function in Lua 5.2 and BitOp.
  
  BIT.arshift
  
    Similar to function in Lua 5.2 and BitOp.
    
  BIT.btest
  
    Similar to function in Lua 5.2 with requires two arguments.

  BIT.bit32
  
    This table contains functions that aim to provide 100% compatibility
    with the Lua 5.2 "bit32" library.
    
    bit32.arshift (x, disp) --> z
    bit32.band (...) --> z
    bit32.bnot (x) --> z
    bit32.bor (...) --> z
    bit32.btest (...) --> true | false
    bit32.bxor (...) --> z
    bit32.extract (x, field [, width]) --> z
    bit32.replace (x, v, field [, width]) --> z
    bit32.lrotate (x, disp) --> z
    bit32.lshift (x, disp) --> z
    bit32.rrotate (x, disp) --> z
    bit32.rshift (x, disp) --> z

  BIT.bit
  
    This table contains functions that aim to provide 100% compatibility
    with the LuaBitOp "bit" library (from LuaJIT).
    
    bit.tobit(x) --> y
    bit.tohex(x [,n]) --> y
    bit.bnot(x) --> y
    bit.bor(x1 [,x2...]) --> y
    bit.band(x1 [,x2...]) --> y
    bit.bxor(x1 [,x2...]) --> y
    bit.lshift(x, n) --> y
    bit.rshift(x, n) --> y
    bit.arshift(x, n) --> y
    bit.rol(x, n) --> y
    bit.ror(x, n) --> y
    bit.bswap(x) --> y
    
DEPENDENCIES

  None (other than Lua 5.1 or 5.2).
    
DOWNLOAD/INSTALLATION

  If using LuaRocks:
    luarocks install lua-bit-numberlua

  Otherwise, download <https://github.com/davidm/lua-bit-numberlua/zipball/master>.
  Alternately, if using git:
    git clone git://github.com/davidm/lua-bit-numberlua.git
    cd lua-bit-numberlua
  Optionally unpack:
    ./util.mk
  or unpack and install in LuaRocks:
    ./util.mk install 

REFERENCES

  [1] http://lua-users.org/wiki/FloatingPoint
  [2] http://www.lua.org/manual/5.2/
  [3] http://bitop.luajit.org/
  
LICENSE

  (c) 2008-2011 David Manura.  Licensed under the same terms as Lua (MIT).

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  (end license)

--]]

local M = {_TYPE='module', _NAME='bit.numberlua', _VERSION='0.3.1.20120131'}

local floor = math.floor

local MOD = 2^32
local MODM = MOD-1

local function memoize(f)
  local mt = {}
  local t = setmetatable({}, mt)
  function mt:__index(k)
    local v = f(k); t[k] = v
    return v
  end
  return t
end

local function make_bitop_uncached(t, m)
  local function bitop(a, b)
    local res,p = 0,1
    while a ~= 0 and b ~= 0 do
      local am, bm = a%m, b%m
      res = res + t[am][bm]*p
      a = (a - am) / m
      b = (b - bm) / m
      p = p*m
    end
    res = res + (a+b)*p
    return res
  end
  return bitop
end

local function make_bitop(t)
  local op1 = make_bitop_uncached(t,2^1)
  local op2 = memoize(function(a)
    return memoize(function(b)
      return op1(a, b)
    end)
  end)
  return make_bitop_uncached(op2, 2^(t.n or 1))
end

-- ok?  probably not if running on a 32-bit int Lua number type platform
function M.tobit(x)
  return x % 2^32
end

M.bxor = make_bitop {[0]={[0]=0,[1]=1},[1]={[0]=1,[1]=0}, n=4}
local bxor = M.bxor

function M.bnot(a)   return MODM - a end
local bnot = M.bnot

function M.band(a,b) return ((a+b) - bxor(a,b))/2 end
local band = M.band

function M.bor(a,b)  return MODM - band(MODM - a, MODM - b) end
local bor = M.bor

local lshift, rshift -- forward declare

function M.rshift(a,disp) -- Lua5.2 insipred
  if disp < 0 then return lshift(a,-disp) end
  return floor(a % 2^32 / 2^disp)
end
rshift = M.rshift

function M.lshift(a,disp) -- Lua5.2 inspired
  if disp < 0 then return rshift(a,-disp) end 
  return (a * 2^disp) % 2^32
end
lshift = M.lshift

function M.tohex(x, n) -- BitOp style
  n = n or 8
  local up
  if n <= 0 then
    if n == 0 then return '' end
    up = true
    n = - n
  end
  x = band(x, 16^n-1)
  return ('%0'..n..(up and 'X' or 'x')):format(x)
end
local tohex = M.tohex

function M.extract(n, field, width) -- Lua5.2 inspired
  width = width or 1
  return band(rshift(n, field), 2^width-1)
end
local extract = M.extract

function M.replace(n, v, field, width) -- Lua5.2 inspired
  width = width or 1
  local mask1 = 2^width-1
  v = band(v, mask1) -- required by spec?
  local mask = bnot(lshift(mask1, field))
  return band(n, mask) + lshift(v, field)
end
local replace = M.replace

function M.bswap(x)  -- BitOp style
  local a = band(x, 0xff); x = rshift(x, 8)
  local b = band(x, 0xff); x = rshift(x, 8)
  local c = band(x, 0xff); x = rshift(x, 8)
  local d = band(x, 0xff)
  return lshift(lshift(lshift(a, 8) + b, 8) + c, 8) + d
end
local bswap = M.bswap

function M.rrotate(x, disp)  -- Lua5.2 inspired
  disp = disp % 32
  local low = band(x, 2^disp-1)
  return rshift(x, disp) + lshift(low, 32-disp)
end
local rrotate = M.rrotate

function M.lrotate(x, disp)  -- Lua5.2 inspired
  return rrotate(x, -disp)
end
local lrotate = M.lrotate

M.rol = M.lrotate  -- LuaOp inspired
M.ror = M.rrotate  -- LuaOp insipred


function M.arshift(x, disp) -- Lua5.2 inspired
  local z = rshift(x, disp)
  if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
  return z
end
local arshift = M.arshift

function M.btest(x, y) -- Lua5.2 inspired
  return band(x, y) ~= 0
end

--
-- Start Lua 5.2 "bit32" compat section.
--

M.bit32 = {} -- Lua 5.2 'bit32' compatibility


local function bit32_bnot(x)
  return (-1 - x) % MOD
end
M.bit32.bnot = bit32_bnot

local function bit32_bxor(a, b, c, ...)
  local z
  if b then
    a = a % MOD
    b = b % MOD
    z = bxor(a, b)
    if c then
      z = bit32_bxor(z, c, ...)
    end
    return z
  elseif a then
    return a % MOD
  else
    return 0
  end
end
M.bit32.bxor = bit32_bxor

local function bit32_band(a, b, c, ...)
  local z
  if b then
    a = a % MOD
    b = b % MOD
    z = ((a+b) - bxor(a,b)) / 2
    if c then
      z = bit32_band(z, c, ...)
    end
    return z
  elseif a then
    return a % MOD
  else
    return MODM
  end
end
M.bit32.band = bit32_band

local function bit32_bor(a, b, c, ...)
  local z
  if b then
    a = a % MOD
    b = b % MOD
    z = MODM - band(MODM - a, MODM - b)
    if c then
      z = bit32_bor(z, c, ...)
    end
    return z
  elseif a then
    return a % MOD
  else
    return 0
  end
end
M.bit32.bor = bit32_bor

function M.bit32.btest(...)
  return bit32_band(...) ~= 0
end

function M.bit32.lrotate(x, disp)
  return lrotate(x % MOD, disp)
end

function M.bit32.rrotate(x, disp)
  return rrotate(x % MOD, disp)
end

function M.bit32.lshift(x,disp)
  if disp > 31 or disp < -31 then return 0 end
  return lshift(x % MOD, disp)
end

function M.bit32.rshift(x,disp)
  if disp > 31 or disp < -31 then return 0 end
  return rshift(x % MOD, disp)
end

function M.bit32.arshift(x,disp)
  x = x % MOD
  if disp >= 0 then
    if disp > 31 then
      return (x >= 0x80000000) and MODM or 0
    else
      local z = rshift(x, disp)
      if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
      return z
    end
  else
    return lshift(x, -disp)
  end
end

function M.bit32.extract(x, field, ...)
  local width = ... or 1
  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
  x = x % MOD
  return extract(x, field, ...)
end

function M.bit32.replace(x, v, field, ...)
  local width = ... or 1
  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
  x = x % MOD
  v = v % MOD
  return replace(x, v, field, ...)
end


--
-- Start LuaBitOp "bit" compat section.
--

M.bit = {} -- LuaBitOp "bit" compatibility

function M.bit.tobit(x)
  x = x % MOD
  if x >= 0x80000000 then x = x - MOD end
  return x
end
local bit_tobit = M.bit.tobit

function M.bit.tohex(x, ...)
  return tohex(x % MOD, ...)
end

function M.bit.bnot(x)
  return bit_tobit(bnot(x % MOD))
end

local function bit_bor(a, b, c, ...)
  if c then
    return bit_bor(bit_bor(a, b), c, ...)
  elseif b then
    return bit_tobit(bor(a % MOD, b % MOD))
  else
    return bit_tobit(a)
  end
end
M.bit.bor = bit_bor

local function bit_band(a, b, c, ...)
  if c then
    return bit_band(bit_band(a, b), c, ...)
  elseif b then
    return bit_tobit(band(a % MOD, b % MOD))
  else
    return bit_tobit(a)
  end
end
M.bit.band = bit_band

local function bit_bxor(a, b, c, ...)
  if c then
    return bit_bxor(bit_bxor(a, b), c, ...)
  elseif b then
    return bit_tobit(bxor(a % MOD, b % MOD))
  else
    return bit_tobit(a)
  end
end
M.bit.bxor = bit_bxor

function M.bit.lshift(x, n)
  return bit_tobit(lshift(x % MOD, n % 32))
end

function M.bit.rshift(x, n)
  return bit_tobit(rshift(x % MOD, n % 32))
end

function M.bit.arshift(x, n)
  return bit_tobit(arshift(x % MOD, n % 32))
end

function M.bit.rol(x, n)
  return bit_tobit(lrotate(x % MOD, n % 32))
end

function M.bit.ror(x, n)
  return bit_tobit(rrotate(x % MOD, n % 32))
end

function M.bit.bswap(x)
  return bit_tobit(bswap(x % MOD))
end

return M" diff --git a/custom_components/midea_auto_cloud/core/cloud.py b/custom_components/midea_auto_cloud/core/cloud.py index 619f4bd..0585fbb 100644 --- a/custom_components/midea_auto_cloud/core/cloud.py +++ b/custom_components/midea_auto_cloud/core/cloud.py @@ -3,10 +3,13 @@ import time import datetime import json import base64 +import asyncio +import requests from aiohttp import ClientSession from secrets import token_hex from .logger import MideaLogger from .security import CloudSecurity, MeijuCloudSecurity, MSmartCloudSecurity +from .util import bytes_to_dec_string _LOGGER = logging.getLogger(__name__) @@ -100,6 +103,46 @@ class MideaCloud: return None + def _api_request_sync(self, endpoint: str, data: dict, header=None) -> dict | None: + header = header or {} + if not data.get("reqId"): + data.update({ + "reqId": token_hex(16) + }) + if not data.get("stamp"): + data.update({ + "stamp": datetime.datetime.now().strftime("%Y%m%d%H%M%S") + }) + random = str(int(time.time())) + url = self._api_url + endpoint + dump_data = json.dumps(data) + sign = self._security.sign(dump_data, random) + header.update({ + "content-type": "application/json; charset=utf-8", + "secretVersion": "1", + "sign": sign, + "random": random, + }) + if self._access_token is not None: + header.update({ + "accesstoken": self._access_token + }) + response:dict = {"code": -1} + _LOGGER.debug(f"Midea cloud API header: {header}") + _LOGGER.debug(f"Midea cloud API dump_data: {dump_data}") + try: + r = requests.post(url, headers=header, data=dump_data, timeout=5) + raw = r.content + _LOGGER.debug(f"Midea cloud API url: {url}, data: {data}, response: {raw}") + response = json.loads(raw) + except Exception as e: + _LOGGER.debug(f"API request attempt failed: {e}") + + if int(response["code"]) == 0 and "data" in response: + return response["data"] + + return None + async def _get_login_id(self) -> str | None: data = self._make_general_data() data.update({ @@ -115,27 +158,27 @@ class MideaCloud: async def login(self) -> bool: raise NotImplementedError() - async def get_keys(self, appliance_id: int): - result = {} - for method in [1, 2]: - udp_id = self._security.get_udp_id(appliance_id, method) - data = self._make_general_data() - data.update({ - "udpid": udp_id - }) - response = await self._api_request( - endpoint="/v1/iot/secure/getToken", - data=data - ) - if response and "tokenlist" in response: - for token in response["tokenlist"]: - if token["udpId"] == udp_id: - result[method] = { - "token": token["token"].lower(), - "key": token["key"].lower() - } - result.update(default_keys) - return result + async def send_cloud(self, appliance_id: int, data: bytearray): + appliance_code = str(appliance_id) + params = { + 'applianceCode': appliance_code, + 'order': self._security.aes_encrypt(bytes_to_dec_string(data)).hex(), + 'timestamp': 'true', + "isFull": "false" + } + + if response := await self._api_request( + endpoint='/v1/appliance/transparent/send', + data=params, + ): + if response and response.get('reply'): + _LOGGER.debug("[%s] Cloud command response: %s", appliance_code, response) + reply_data = self._security.aes_decrypt(bytes.fromhex(response['reply'])) + return reply_data + else: + _LOGGER.warning("[%s] Cloud command failed: %s", appliance_code, response) + + return None async def list_home(self) -> dict | None: return {1: "My home"} diff --git a/custom_components/midea_auto_cloud/core/device.py b/custom_components/midea_auto_cloud/core/device.py index a829f01..d797287 100644 --- a/custom_components/midea_auto_cloud/core/device.py +++ b/custom_components/midea_auto_cloud/core/device.py @@ -1,10 +1,14 @@ import threading import socket from enum import IntEnum + +from .cloud import MideaCloud from .security import LocalSecurity, MSGTYPE_HANDSHAKE_REQUEST, MSGTYPE_ENCRYPTED_REQUEST from .packet_builder import PacketBuilder from .message import MessageQuestCustom from .logger import MideaLogger +from .lua_runtime import MideaCodec +from .util import dec_string_to_bytes class AuthException(Exception): @@ -39,7 +43,9 @@ class MiedaDevice(threading.Thread): subtype: int | None, connected: bool, sn: str | None, - sn8: str | None): + sn8: str | None, + lua_file: str | None, + cloud: MideaCloud | None): threading.Thread.__init__(self) self._socket = None self._ip_address = ip_address @@ -71,6 +77,8 @@ class MiedaDevice(threading.Thread): self._centralized = [] self._calculate_get = [] self._calculate_set = [] + self._lua_runtime = MideaCodec(lua_file, sn=sn, subtype=subtype) if lua_file is not None else None + self._cloud = cloud @property def device_name(self): @@ -126,14 +134,16 @@ class MiedaDevice(threading.Thread): def get_attribute(self, attribute): return self._attributes.get(attribute) - def set_attribute(self, attribute, value): + async def set_attribute(self, attribute, value): if attribute in self._attributes.keys(): new_status = {} for attr in self._centralized: new_status[attr] = self._attributes.get(attr) new_status[attribute] = value + if set_cmd := self._lua_runtime.build_control(new_status): + await self._build_send(set_cmd) - def set_attributes(self, attributes): + async def set_attributes(self, attributes): new_status = {} for attr in self._centralized: new_status[attr] = self._attributes.get(attr) @@ -142,6 +152,9 @@ class MiedaDevice(threading.Thread): if attribute in self._attributes.keys(): has_new = True new_status[attribute] = value + if has_new: + if set_cmd := self._lua_runtime.build_control(new_status): + await self._build_send(set_cmd) def set_ip_address(self, ip_address): MideaLogger.debug(f"Update IP address to {ip_address}") @@ -188,12 +201,6 @@ class MiedaDevice(threading.Thread): response = response[8: 72] self._security.tcp_key(response, self._key) - def _send_message(self, data): - if self._protocol == 3: - self._send_message_v3(data, msg_type=MSGTYPE_ENCRYPTED_REQUEST) - else: - self._send_message_v2(data) - def _send_message_v2(self, data): if self._socket is not None: self._socket.send(data) @@ -204,11 +211,128 @@ class MiedaDevice(threading.Thread): data = self._security.encode_8370(data, msg_type) self._send_message_v2(data) - def _build_send(self, cmd: str): + async def _build_send(self, cmd: str): MideaLogger.debug(f"Sending: {cmd.lower()}") bytes_cmd = bytes.fromhex(cmd) - msg = PacketBuilder(self._device_id, bytes_cmd).finalize() - self._send_message(msg) + await self._send_message(bytes_cmd) + + async def refresh_status(self): + for query in self._queries: + if query_cmd := self._lua_runtime.build_query(query): + await self._build_send(query_cmd) + + def _parse_cloud_message(self, decrypted): + # MideaLogger.debug(f"Received: {decrypted}") + if status := self._lua_runtime.decode_status(dec_string_to_bytes(decrypted).hex()): + MideaLogger.debug(f"Decoded: {status}") + new_status = {} + for single in status.keys(): + value = status.get(single) + if single not in self._attributes or self._attributes[single] != value: + self._attributes[single] = value + new_status[single] = value + if len(new_status) > 0: + for c in self._calculate_get: + lvalue = c.get("lvalue") + rvalue = c.get("rvalue") + if lvalue and rvalue: + calculate = False + for s, v in new_status.items(): + if rvalue.find(f"[{s}]") >= 0: + calculate = True + break + if calculate: + calculate_str1 = \ + (f"{lvalue.replace('[', 'self._attributes[')} = " + f"{rvalue.replace('[', 'self._attributes[')}") \ + .replace("[", "[\"").replace("]", "\"]") + calculate_str2 = \ + (f"{lvalue.replace('[', 'new_status[')} = " + f"{rvalue.replace('[', 'self._attributes[')}") \ + .replace("[", "[\"").replace("]", "\"]") + try: + exec(calculate_str1) + exec(calculate_str2) + except Exception: + MideaLogger.warning( + f"Calculation Error: {lvalue} = {rvalue}", self._device_id + ) + self._update_all(new_status) + return ParseMessageResult.SUCCESS + + def _parse_message(self, msg): + if self._protocol == 3: + messages, self._buffer = self._security.decode_8370(self._buffer + msg) + else: + messages, self._buffer = self.fetch_v2_message(self._buffer + msg) + if len(messages) == 0: + return ParseMessageResult.PADDING + for message in messages: + if message == b"ERROR": + return ParseMessageResult.ERROR + payload_len = message[4] + (message[5] << 8) - 56 + payload_type = message[2] + (message[3] << 8) + if payload_type in [0x1001, 0x0001]: + # Heartbeat detected + pass + elif len(message) > 56: + cryptographic = message[40:-16] + if payload_len % 16 == 0: + decrypted = self._security.aes_decrypt(cryptographic) + MideaLogger.debug(f"Received: {decrypted.hex().lower()}") + if status := self._lua_runtime.decode_status(decrypted.hex()): + MideaLogger.debug(f"Decoded: {status}") + new_status = {} + for single in status.keys(): + value = status.get(single) + if single not in self._attributes or self._attributes[single] != value: + self._attributes[single] = value + new_status[single] = value + if len(new_status) > 0: + for c in self._calculate_get: + lvalue = c.get("lvalue") + rvalue = c.get("rvalue") + if lvalue and rvalue: + calculate = False + for s, v in new_status.items(): + if rvalue.find(f"[{s}]") >= 0: + calculate = True + break + if calculate: + calculate_str1 = \ + (f"{lvalue.replace('[', 'self._attributes[')} = " + f"{rvalue.replace('[', 'self._attributes[')}") \ + .replace("[", "[\"").replace("]", "\"]") + calculate_str2 = \ + (f"{lvalue.replace('[', 'new_status[')} = " + f"{rvalue.replace('[', 'self._attributes[')}") \ + .replace("[", "[\"").replace("]", "\"]") + try: + exec(calculate_str1) + exec(calculate_str2) + except Exception: + MideaLogger.warning( + f"Calculation Error: {lvalue} = {rvalue}", self._device_id + ) + self._update_all(new_status) + return ParseMessageResult.SUCCESS + + async def _send_message(self, data): + if reply := await self._cloud.send_cloud(self._device_id, data): + result = self._parse_cloud_message(reply) + if result == ParseMessageResult.ERROR: + MideaLogger.debug(f"Message 'ERROR' received") + elif result == ParseMessageResult.SUCCESS: + timeout_counter = 0 + + # if self._protocol == 3: + # self._send_message_v3(data, msg_type=MSGTYPE_ENCRYPTED_REQUEST) + # else: + # self._send_message_v2(data) + + async def _send_heartbeat(self): + msg = PacketBuilder(self._device_id, bytearray([0x00])).finalize(msg_type=0) + await self._send_message(msg) def _device_connected(self, connected=True): self._connected = connected diff --git a/custom_components/midea_auto_cloud/core/lua_runtime.py b/custom_components/midea_auto_cloud/core/lua_runtime.py new file mode 100644 index 0000000..70e6a82 --- /dev/null +++ b/custom_components/midea_auto_cloud/core/lua_runtime.py @@ -0,0 +1,91 @@ +import lupa +import threading +import json +from .logger import MideaLogger + + +class LuaRuntime: + def __init__(self, file): + self._runtimes = lupa.LuaRuntime() + string = f'dofile("{file}")' + self._runtimes.execute(string) + self._lock = threading.Lock() + self._json_to_data = self._runtimes.eval("function(param) return jsonToData(param) end") + self._data_to_json = self._runtimes.eval("function(param) return dataToJson(param) end") + + def json_to_data(self, json_value): + with self._lock: + result = self._json_to_data(json_value) + + return result + + def data_to_json(self, data_value): + with self._lock: + result = self._data_to_json(data_value) + return result + + +class MideaCodec(LuaRuntime): + def __init__(self, file, sn=None, subtype=None): + super().__init__(file) + self._sn = sn + self._subtype = subtype + + def _build_base_dict(self): + device_info ={} + if self._sn is not None: + device_info["deviceSN"] = self._sn + if self._subtype is not None: + device_info["deviceSubType"] = self._subtype + base_dict = { + "deviceinfo": device_info + } + return base_dict + + def build_query(self, append=None): + query_dict = self._build_base_dict() + query_dict["query"] = {} if append is None else append + json_str = json.dumps(query_dict) + try: + result = self.json_to_data(json_str) + return result + except lupa.LuaError as e: + MideaLogger.error(f"LuaRuntimeError in build_query {json_str}: {repr(e)}") + return None + + def build_control(self, append=None): + query_dict = self._build_base_dict() + query_dict["control"] = {} if append is None else append + json_str = json.dumps(query_dict) + try: + result = self.json_to_data(json_str) + return result + except lupa.LuaError as e: + MideaLogger.error(f"LuaRuntimeError in build_control {json_str}: {repr(e)}") + return None + + def build_status(self, append=None): + query_dict = self._build_base_dict() + query_dict["status"] = {} if append is None else append + json_str = json.dumps(query_dict) + try: + result = self.json_to_data(json_str) + return result + except lupa.LuaError as e: + MideaLogger.error(f"LuaRuntimeError in build_status {json_str}: {repr(e)}") + return None + + def decode_status(self, data: str): + data_dict = self._build_base_dict() + data_dict["msg"] = { + "data": data + } + json_str = json.dumps(data_dict) + try: + result = self.data_to_json(json_str) + status = json.loads(result) + return status.get("status") + except lupa.LuaError as e: + MideaLogger.error(f"LuaRuntimeError in decode_status {data}: {repr(e)}") + return None + diff --git a/custom_components/midea_auto_cloud/core/util.py b/custom_components/midea_auto_cloud/core/util.py new file mode 100644 index 0000000..8bb5985 --- /dev/null +++ b/custom_components/midea_auto_cloud/core/util.py @@ -0,0 +1,50 @@ +def bytes_to_dec_string(data: bytearray) -> bytearray: + """ + 将 bytearray 转换为逗号分隔的十进制字符串格式，然后返回 bytearray + 对应 Java 的 bytesToDecString 方法 + """ + # 处理有符号字节（模拟 Java 的 byte 类型 -128 到 127） + result = [] + for b in data: + # 将无符号字节转换为有符号字节 + signed_byte = b if b < 128 else b - 256 + result.append(str(signed_byte)) + + decimal_string = ','.join(result) + return bytearray(decimal_string, 'utf-8') + + +def dec_string_to_bytes(dec_string: str) -> bytearray: + """ + 将逗号分隔的十进制字符串转换为字节数组 + 对应 Java 的 decStringToBytes 方法 + + Args: + dec_string: 逗号分隔的十进制字符串，如 "1,2,-3,127" + + Returns: + bytearray: 转换后的字节数组 + """ + if dec_string is None: + return bytearray() + + # 按逗号分割字符串 + split_values = dec_string.split(',') + result = bytearray(len(split_values)) + + for i, value_str in enumerate(split_values): + try: + # 解析十进制字符串为整数，然后转换为字节 + int_value = int(value_str.strip()) + # 确保值在字节范围内 (-128 到 127) + if int_value < -128: + int_value = -128 + elif int_value > 127: + int_value = 127 + result[i] = int_value & 0xFF # 转换为无符号字节 + except (ValueError, IndexError) as e: + # 如果解析失败，记录错误并跳过该值 + print(f"dec_string_to_bytes() error: {e}") + result[i] = 0 # 默认值 + + return result diff --git a/custom_components/midea_auto_cloud/data_coordinator.py b/custom_components/midea_auto_cloud/data_coordinator.py index 27c12f8..05c2c9e 100644 --- a/custom_components/midea_auto_cloud/data_coordinator.py +++ b/custom_components/midea_auto_cloud/data_coordinator.py @@ -90,16 +90,17 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]): return self.data try: - # 使用传入的 cloud 实例（若可用） - cloud = self._cloud - if cloud and hasattr(cloud, "get_device_status"): - try: - status = await cloud.get_device_status(self._device_id) - if isinstance(status, dict) and len(status) > 0: - for k, v in status.items(): - self.device.attributes[k] = v - except Exception as e: - MideaLogger.debug(f"Cloud status fetch failed: {e}") + await self.device.refresh_status() + # # 使用传入的 cloud 实例（若可用） + # cloud = self._cloud + # if cloud and hasattr(cloud, "get_device_status"): + # try: + # status = await cloud.get_device_status(self._device_id) + # if isinstance(status, dict) and len(status) > 0: + # for k, v in status.items(): + # self.device.attributes[k] = v + # except Exception as e: + # MideaLogger.debug(f"Cloud status fetch failed: {e}") # 返回并推送当前状态 updated = MideaDeviceData( @@ -120,26 +121,15 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]): async def async_set_attribute(self, attribute: str, value) -> None: """Set a device attribute.""" # 云端控制：构造 control 与 status（携带当前状态作为上下文） - cloud = self._cloud - control = {attribute: value} - status = dict(self.device.attributes) - if cloud and hasattr(cloud, "send_device_control"): - ok = await cloud.send_device_control(self._device_id, control=control, status=status) - if ok: - # 本地先行更新，随后依赖轮询或设备事件校正 - self.device.attributes[attribute] = value + await self.device.set_attribute(attribute, value) + self.device.attributes[attribute] = value self.mute_state_update_for_a_while() self.async_update_listeners() async def async_set_attributes(self, attributes: dict) -> None: """Set multiple device attributes.""" - cloud = self._cloud - control = dict(attributes) - status = dict(self.device.attributes) - if cloud and hasattr(cloud, "send_device_control"): - ok = await cloud.send_device_control(self._device_id, control=control, status=status) - if ok: - self.device.attributes.update(attributes) + await self.device.set_attributes(attributes) + self.device.attributes.update(attributes) self.mute_state_update_for_a_while() self.async_update_listeners() diff --git a/custom_components/midea_auto_cloud/device_mapping/T0xAC.py b/custom_components/midea_auto_cloud/device_mapping/T0xAC.py index 68c29d9..402cf71 100644 --- a/custom_components/midea_auto_cloud/device_mapping/T0xAC.py +++ b/custom_components/midea_auto_cloud/device_mapping/T0xAC.py @@ -6,10 +6,10 @@ from homeassistant.components.switch import SwitchDeviceClass DEVICE_MAPPING = { "default": { "rationale": ["off", "on"], - "queries": [{}, {"query_type": "prevent_straight_wind"}], + "queries": [{}], "centralized": [ "power", "temperature", "small_temperature", "mode", "eco", - "comfort_power_save", "comfort_sleep", "strong_wind", + "comfort_power_save", "strong_wind", "wind_swing_lr", "wind_swing_lr", "wind_speed","ptc", "dry" ], "entities": { @@ -28,12 +28,12 @@ DEVICE_MAPPING = { "none": { "eco": "off", "comfort_power_save": "off", - "comfort_sleep": "off", + # "comfort_sleep": "off", "strong_wind": "off" }, "eco": {"eco": "on"}, "comfort": {"comfort_power_save": "on"}, - "sleep": {"comfort_sleep": "on"}, + # "sleep": {"comfort_sleep": "on"}, "boost": {"strong_wind": "on"} }, "swing_modes": { @@ -87,9 +87,9 @@ DEVICE_MAPPING = { }, "22012227": { "rationale": ["off", "on"], - "queries": [{}, {"query_type": "prevent_straight_wind"}], + "queries": [{}], "centralized": ["power", "temperature", "small_temperature", "mode", "eco", "comfort_power_save", - "comfort_sleep", "strong_wind", "wind_swing_lr", "wind_swing_ud", "wind_speed", + "strong_wind", "wind_swing_lr", "wind_swing_ud", "wind_speed", "ptc", "dry"], "entities": { @@ -108,12 +108,12 @@ DEVICE_MAPPING = { "none": { "eco": "off", "comfort_power_save": "off", - "comfort_sleep": "off", + # "comfort_sleep": "off", "strong_wind": "off" }, "eco": {"eco": "on"}, "comfort": {"comfort_power_save": "on"}, - "sleep": {"comfort_sleep": "on"}, + # "sleep": {"comfort_sleep": "on"}, "boost": {"strong_wind": "on"} }, "swing_modes": { diff --git a/custom_components/midea_auto_cloud/device_mapping/T0xE2.py b/custom_components/midea_auto_cloud/device_mapping/T0xE2.py new file mode 100644 index 0000000..a8b4ac3 --- /dev/null +++ b/custom_components/midea_auto_cloud/device_mapping/T0xE2.py @@ -0,0 +1,466 @@ +from homeassistant.const import Platform, UnitOfTemperature, UnitOfTime, PERCENTAGE, PRECISION_HALVES +from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass +from homeassistant.components.binary_sensor import BinarySensorDeviceClass +from homeassistant.components.switch import SwitchDeviceClass + +DEVICE_MAPPING = { + "default": { + "manufacturer": "美的", + "rationale": ["off", "on"], + "queries": [{}], + "centralized": [ + "power", "temperature", "mode", "heat", "music", "ti_protect", "fast_wash", + "ali_manager", "water_quality", "rate", "ele_exception", "communication_error", + "cur_rate", "sterilize_left_days", "uv_sterilize_minute", "uv_sterilize_second", + "eplus", "summer", "winter", "efficient", "night", "bath_person", "cloud", + "bath", "half_heat", "whole_heat", "sterilization", "frequency_hot", "scene", + "big_water", "wash", "negative_ions", "screen_off", "t_hot", "baby_wash", + "dad_wash", "mom_wash", "wash_with_temp", "single_wash", "people_wash", + "wash_temperature", "one_egg", "two_egg", "always_fell", "smart_sterilize", + "sterilize_cycle_index", "sound_dad", "screen_light", "morning_night_bash", + "version", "tds_value", "door_status", "limit_error", "sensor_error", + "scene_id", "auto_off", "clean", "volume", "passwater_lowbyte", "cloud_appoint", + "protect", "midea_manager", "sleep", "memory", "shower", "scroll_hot", + "fast_hot_power", "hot_power", "safe", "water_flow", "heat_water_level", + "flow", "appoint_wash", "now_wash", "end_time_hour", "end_time_minute", + "get_time", "get_temp", "func_select", "warm_power", "type_select", + "cur_temperature", "sterilize_high_temp", "discharge_status", "top_temp", + "bottom_heat", "top_heat", "show_h", "uv_sterilize", "machine", "error_code", + "need_discharge", "elec_warning", "bottom_temp", "water_cyclic", "water_system", + "discharge_left_time", "in_temperature", "mg_remain", "waterday_lowbyte", + "waterday_highbyte", "tech_water", "protect_show", "appoint_power" + ], + "entities": { + Platform.WATER_HEATER: { + "water_heater": { + "name": "Water Heater", + "power": "power", + "operation_list": { + "off": {"power": "off"}, + "heat": {"power": "on", "mode": "heat"}, + "auto": {"power": "on", "mode": "auto"}, + "eco": {"power": "on", "mode": "eco"}, + "fast": {"power": "on", "mode": "fast"} + }, + "target_temperature": "temperature", + "current_temperature": "cur_temperature", + "min_temp": 30, + "max_temp": 75, + "temperature_unit": UnitOfTemperature.CELSIUS, + "precision": PRECISION_HALVES, + } + }, + Platform.SWITCH: { + "music": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "ti_protect": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "fast_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "ali_manager": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "heat": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "ele_exception": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "communication_error": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "eplus": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "summer": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "winter": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "efficient": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "night": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "bath_person": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "cloud": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "bath": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "half_heat": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "whole_heat": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "sterilization": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "frequency_hot": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "scene": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "big_water": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "negative_ions": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "screen_off": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "t_hot": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "baby_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "dad_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "mom_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "wash_with_temp": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "single_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "people_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "one_egg": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "two_egg": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "always_fell": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "smart_sterilize": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "sound_dad": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "door_status": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "limit_error": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "sensor_error": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "auto_off": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "clean": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "cloud_appoint": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "protect": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "midea_manager": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "sleep": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "memory": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "shower": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "scroll_hot": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "fast_hot_power": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "hot_power": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "safe": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "water_flow": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "appoint_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "now_wash": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "get_time": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "get_temp": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "warm_power": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "sterilize_high_temp": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "bottom_heat": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "top_heat": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "show_h": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "uv_sterilize": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "need_discharge": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "elec_warning": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "water_cyclic": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "tech_water": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "protect_show": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "appoint_power": { + "device_class": SwitchDeviceClass.SWITCH, + } + }, + Platform.SELECT: { + "mode": { + "options": { + "none": {"mode": "none"}, + "heat": {"mode": "heat"}, + "auto": {"mode": "auto"}, + "eco": {"mode": "eco"}, + "fast": {"mode": "fast"} + } + }, + "water_quality": { + "options": { + "0": {"water_quality": 0}, + "1": {"water_quality": 1}, + "2": {"water_quality": 2}, + "3": {"water_quality": 3} + } + }, + "func_select": { + "options": { + "low": {"func_select": "low"}, + "medium": {"func_select": "medium"}, + "high": {"func_select": "high"} + } + }, + "type_select": { + "options": { + "normal": {"type_select": "normal"}, + "eco": {"type_select": "eco"}, + "fast": {"type_select": "fast"} + } + }, + "machine": { + "options": { + "real_machine": {"machine": "real_machine"}, + "virtual_machine": {"machine": "virtual_machine"} + } + } + }, + Platform.SENSOR: { + "temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "cur_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "top_temp": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "bottom_temp": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "in_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "passwater_lowbyte": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "L", + "state_class": SensorStateClass.MEASUREMENT + }, + "passwater_highbyte": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "L", + "state_class": SensorStateClass.MEASUREMENT + }, + "rate": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "L/min", + "state_class": SensorStateClass.MEASUREMENT + }, + "cur_rate": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "L/min", + "state_class": SensorStateClass.MEASUREMENT + }, + "sterilize_left_days": { + "device_class": SensorDeviceClass.DURATION, + "unit_of_measurement": UnitOfTime.DAYS, + "state_class": SensorStateClass.MEASUREMENT + }, + "uv_sterilize_minute": { + "device_class": SensorDeviceClass.DURATION, + "unit_of_measurement": UnitOfTime.MINUTES, + "state_class": SensorStateClass.MEASUREMENT + }, + "uv_sterilize_second": { + "device_class": SensorDeviceClass.DURATION, + "unit_of_measurement": UnitOfTime.SECONDS, + "state_class": SensorStateClass.MEASUREMENT + }, + "screen_light": { + "device_class": SensorDeviceClass.ILLUMINANCE, + "unit_of_measurement": "lx", + "state_class": SensorStateClass.MEASUREMENT + }, + "morning_night_bash": { + "device_class": SensorDeviceClass.DURATION, + "unit_of_measurement": UnitOfTime.MINUTES, + "state_class": SensorStateClass.MEASUREMENT + }, + "version": { + "device_class": SensorDeviceClass.ENUM + }, + "tds_value": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "ppm", + "state_class": SensorStateClass.MEASUREMENT + }, + "scene_id": { + "device_class": SensorDeviceClass.ENUM + }, + "volume": { + "device_class": SensorDeviceClass.SOUND_PRESSURE, + "unit_of_measurement": "%", + "state_class": SensorStateClass.MEASUREMENT + }, + "heat_water_level": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "%", + "state_class": SensorStateClass.MEASUREMENT + }, + "flow": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "L/min", + "state_class": SensorStateClass.MEASUREMENT + }, + "end_time_hour": { + "device_class": SensorDeviceClass.DURATION, + "unit_of_measurement": UnitOfTime.HOURS, + "state_class": SensorStateClass.MEASUREMENT + }, + "end_time_minute": { + "device_class": SensorDeviceClass.DURATION, + "unit_of_measurement": UnitOfTime.MINUTES, + "state_class": SensorStateClass.MEASUREMENT + }, + "wash_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "sterilize_cycle_index": { + "device_class": SensorDeviceClass.ENUM + }, + "discharge_status": { + "device_class": SensorDeviceClass.ENUM + }, + "error_code": { + "device_class": SensorDeviceClass.ENUM + }, + "water_system": { + "device_class": SensorDeviceClass.ENUM + }, + "discharge_left_time": { + "device_class": SensorDeviceClass.DURATION, + "unit_of_measurement": UnitOfTime.MINUTES, + "state_class": SensorStateClass.MEASUREMENT + }, + "mg_remain": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "mg", + "state_class": SensorStateClass.MEASUREMENT + }, + "waterday_lowbyte": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "L", + "state_class": SensorStateClass.MEASUREMENT + }, + "waterday_highbyte": { + "device_class": SensorDeviceClass.WATER, + "unit_of_measurement": "L", + "state_class": SensorStateClass.MEASUREMENT + } + }, + Platform.BINARY_SENSOR: { + "door_status": { + "device_class": BinarySensorDeviceClass.DOOR, + }, + "limit_error": { + "device_class": BinarySensorDeviceClass.PROBLEM, + }, + "sensor_error": { + "device_class": BinarySensorDeviceClass.PROBLEM, + }, + "communication_error": { + "device_class": BinarySensorDeviceClass.PROBLEM, + }, + "ele_exception": { + "device_class": BinarySensorDeviceClass.PROBLEM, + }, + "elec_warning": { + "device_class": BinarySensorDeviceClass.PROBLEM, + } + } + } + } +} + diff --git a/custom_components/midea_auto_cloud/manifest.json b/custom_components/midea_auto_cloud/manifest.json index 3f21e14..bb60d1f 100644 --- a/custom_components/midea_auto_cloud/manifest.json +++ b/custom_components/midea_auto_cloud/manifest.json @@ -6,6 +6,6 @@ "documentation": "https://github.com/sususweet/midea-meiju-codec#readme", "iot_class": "cloud_push", "issue_tracker": "https://github.com/sususweet/midea-meiju-codec/issues", - "requirements": [], - "version": "v0.0.5" + "requirements": ["lupa>=2.0"], + "version": "v0.0.6" } \ No newline at end of file