Add Support for Heat Pumps (Type = 0xC3) #107
Labels
Comments
|
Cool. Thanks for the protocol files! I'll see what I can do, obviously I'll need some help from you to test it since I don't own one. :) Can you describe what functionality you'd like to see? In my mind it would work similar to a air conditioner/heater e.g current temp, target temp, mode |
|
I’d be more than happy to test, but I’d also help to code in a new branch and later merge. I guess it’s more or less the same, just a few more values. Mainly, I’d like to be able to read the temperature sensors, flow meter, the relay positions, power consumption, and set points. In our case, the HP provides hot water for the heating circuits (floor heating and radiators) and if the temperature in the hot water storage (for tapped water) drops below a certain value, it switches a valve and heats up the storage. However, the controller can also be programmed to control other things such as solar thermal collectors. So it has additional analog imputs ans switched outputs and the operator can program rules. |
Awesome, I've thrown together a branch (https://github.com/mill1000/midea-msmart/tree/feature/device_c3) to start some development. At this point it's mostly just a skeleton with some type definitions.
Good to know. Do you also use it for "domestic" hot water use (e.g. showers, sinks)?
I'm guessing these functions might fall under the "install" type messages which in my mind are a lower priority from the day to day query/command messages. I see that the protocol has a number of timers/timing functions. (Day, weekly, holiday, maybe more.) Are you using those? Generally in my mind the built-in timers aren't useful when combined with another automation system |
Great, I'll update my repo.
Yes. That is what the storage that I mentioned is for.
Yes. In a first step, I would like to be able to read out temperature values. Maybe later I'd be nice to be able to manipulate the set point of the heating circuits or the domestic hot water tank (i.e. when there is lots of photovoltaik energy).
Yes. |
|
Cool. Just pushed some updates to the branch. It should be just enough to enable some basic testing of communication. Can you checkout the branch and try running this example against your device? import asyncio
import logging
from msmart.device import HeatPump as HP
from msmart.device.C3.command import QueryBasicCommand
logging.basicConfig(level=logging.DEBUG)
DEVICE_IP = "YOUR_DEVICE_IP"
DEVICE_PORT = 6444
DEVICE_ID = "YOUR_AC_ID"
# For V3 devices
DEVICE_TOKEN = None # "YOUR_DEVICE_TOKEN"
DEVICE_KEY = None # "YOUR_DEVICE_KEY"
async def main():
device = HP(ip=DEVICE_IP, port=6444, device_id=int(DEVICE_ID))
if DEVICE_TOKEN and DEVICE_KEY:
await device.authenticate(DEVICE_TOKEN, DEVICE_KEY)
command = QueryBasicCommand()
resp = await device._send_command_get_responses(command)
for r in resp:
print(r)
if __name__ == "__main__":
asyncio.run(main()) |
|
Well, thank you for starting! However, you seem to use a newer version of python than 3.8.2. The issue is that I use a Pi Zero W and it has kernel issues when running Any idea what to do? |
|
It's my intent to support Python 3.8 so I'll make the necessary fixes |
|
Ok, I just pushed a fix for the typing issues on Python 3.8 |
|
You are so quick :-o Btw I am running python 3.9.2 on a Pi Zero W with Bullseye. |
|
Hm...thanks for testing. Looks like it didn't like that command. I'll have to reexamine the code and see if I missed something. |
|
Oops. I had the device type as Can you pull the latest commit and try again? |
|
@nixmeer Any chance you've been able to test the latest changes? |
|
Heij :) However, the results did not change a lot. Authentication is still working but no answer to the commands after authenticating. I got another minor issue: When I pull the code, the init.py tries to get the version of the msmart-ng module. However, I do not have the package installed but the |
|
Ok, looks like I might have misunderstood how Lua arrays work. Can you try this example snippet? import asyncio
import logging
from msmart.const import DeviceType, FrameType
from msmart.device import HeatPump as HP
# from msmart.device.C3.command import QueryBasicCommand
from msmart.frame import Frame
logging.basicConfig(level=logging.DEBUG)
DEVICE_IP = "YOUR_DEVICE_IP"
DEVICE_PORT = 6444
DEVICE_ID = "YOUR_AC_ID"
# For V3 devices
DEVICE_TOKEN = None # "YOUR_DEVICE_TOKEN"
DEVICE_KEY = None # "YOUR_DEVICE_KEY"
class QueryTest(Frame):
def tobytes(self) -> bytes:
payload = bytes([1])
# Build frame header
header = bytearray(self._HEADER_LENGTH)
# Start byte
header[0] = 0xAA
# Length of header, payload and checksum
header[1] = len(payload) + self._HEADER_LENGTH
# Device/appliance type
header[2] = self._device_type
# Device protocol version
header[8] = self._protocol_version
# Frame type
header[9] = self._frame_type
# Build frame from header and payload
frame = bytearray(header + payload)
# Calculate total frame checksum
frame.append(Frame.checksum(frame[1:]))
return bytes(frame)
async def main():
device = HP(ip=DEVICE_IP, port=6444, device_id=int(DEVICE_ID))
if DEVICE_TOKEN and DEVICE_KEY:
await device.authenticate(DEVICE_TOKEN, DEVICE_KEY)
command = QueryTest(DeviceType.HEAT_PUMP, frame_type=FrameType.REQUEST)
resp = await device._send_command_get_responses(command)
for r in resp:
print(r)
if __name__ == "__main__":
asyncio.run(main()) |
|
Hi :) Looks better, doesn't it? |
|
It got a response! Awesome! |
|
Cool I fixed the payload parser and this is what I got out of the message. Does this seem like a reasonable representation of your system? i.e. Temperatures seem correct, power states, etc |
|
Looks great. The heat pump runs one heating circuit and domestic hot water, the other “zone” appears to be turned off. I don’t know what “run_mode” and “runmode_under_auto” might be but I’ll figure that out. Except for “tank temperature”, there’s no sensor values yet (such as outside temperature or circuit temperatures). This message looks more like the system state. |
|
Yes it appears
|
|
Ok, makes sense. Do you think the other messages should work now or is more work to be done? |
|
Ok, I've got a rough skeleton of a device class now. Can you pull and run the latest example below? import asyncio
import logging
from msmart.device import HeatPump as HP
from msmart.device.C3.command import QueryBasicCommand
logging.basicConfig(level=logging.DEBUG)
DEVICE_IP = "YOUR_DEVICE_IP"
DEVICE_PORT = 6444
DEVICE_ID = "YOUR_AC_ID"
# For V3 devices
DEVICE_TOKEN = None # "YOUR_DEVICE_TOKEN"
DEVICE_KEY = None # "YOUR_DEVICE_KEY"
async def main():
device = HP(ip=DEVICE_IP, port=6444, device_id=int(DEVICE_ID))
if DEVICE_TOKEN and DEVICE_KEY:
await device.authenticate(DEVICE_TOKEN, DEVICE_KEY)
await device.refresh()
print(vars(device))
if __name__ == "__main__":
asyncio.run(main()) |
I expect any of the query messages will work. The responses just have to be parsed. I'm currently working on the "unit parameters" query which should contain some additional temperature sensor readings. Then we'll have to test the control commands. |
|
Sounds like a plan. Here's the latest response: |
|
Just pushed a change to fix that silly typo, and added an additional request for the "unit parameters". Can you re-run the example? Have you used the OEM app? Could you share screenshots of it so I can better understand it's functionality? |
|
Here‘s the output: I’ll put together some screenshots of the app later today. |
|
Thanks. Huh..well it didn't like that last query type did it. Here's another example that will send every known query type. import asyncio
import logging
from msmart.device import HeatPump as HP
from msmart.device.C3.command import QueryCommand, QueryType
logging.basicConfig(level=logging.DEBUG)
DEVICE_IP = "YOUR_DEVICE_IP"
DEVICE_PORT = 6444
DEVICE_ID = "YOUR_DEVICE_ID"
# For V3 devices
DEVICE_TOKEN = None # "YOUR_DEVICE_TOKEN"
DEVICE_KEY = None # "YOUR_DEVICE_KEY"
async def main():
device = HP(ip=DEVICE_IP, port=6444, device_id=int(DEVICE_ID))
if DEVICE_TOKEN and DEVICE_KEY:
await device.authenticate(DEVICE_TOKEN, DEVICE_KEY)
for type in QueryType:
print(f"Sending query type {type.name}.")
command = QueryCommand(type)
await device._send_command_parse_responses(command)
if __name__ == "__main__":
asyncio.run(main()) |
|
Here's the output of that: Output |
|
Excellent! Thank you again. Any luck with those screenshots? |
|
Here you go again: Output<'/details> |
|
Thanks again. I'll review this in a few days. Appreciate your patience |
|
Wait 😂 you’re the one doing all the work |
|
Cool looks like there was an unsolicited message from your device This is an "up" type message with "power4" payload. I think it roughly breaks down like so
|
|
I wonder if there are any other messages that might be solicited. Can you run the last example even longer? |
|
I can help with
That is probably the thermal energy that was produced using the 4960 kWh of electrical energy |
|
Is it possible to request these messages at a higher interval? |
|
You can try reducing the sleep duration between |
|
Here you go: (GitHub does not allow more than 2^16 characters....) |
|
Thanks. I still only see the "power4" messages so that might be the only unsolicited one it sends. I wonder now if we can request that message so we don't have to wait to get some of the data |
|
Here's a quick test to see if we can solict the power messages. Totally a guess import asyncio
import logging
from msmart.device import HeatPump as HP
from msmart.const import DeviceType
from msmart.frame import Frame
logging.basicConfig(level=logging.DEBUG)
DEVICE_IP = "YOUR_DEVICE_IP"
DEVICE_PORT = 6444
DEVICE_ID = "YOUR_DEVICE_ID"
# For V3 devices
DEVICE_TOKEN = None # "YOUR_DEVICE_TOKEN"
DEVICE_KEY = None # "YOUR_DEVICE_KEY"
class UpCommand(Frame):
def __init__(self, type) -> None:
super().__init__(DeviceType.HEAT_PUMP, frame_type=0x4)
self._type = type
def tobytes(self) -> bytes:
return super().tobytes(bytes([
self._type
]))
async def main():
device = HP(ip=DEVICE_IP, port=6444, device_id=int(DEVICE_ID))
if DEVICE_TOKEN and DEVICE_KEY:
await device.authenticate(DEVICE_TOKEN, DEVICE_KEY)
for i in [1, 3, 4, 5]:
print(f"Sending up type # {i}.")
command = UpCommand(i)
await device._send_command_parse_responses(command)
if __name__ == "__main__":
asyncio.run(main()) |
|
Hi, Output |
|
Thanks. Ok, looks like we just have to wait for the power messages. At this point, I think the path forward is to start implementing and testing the control messages. Here's a short TODO
|
|
Ok, just pushed an update that should allow you to do some basic control of the device. Supported controls
Here's an example import asyncio
import logging
from msmart.device import HeatPump as HP
logging.basicConfig(level=logging.DEBUG)
DEVICE_IP = "YOUR_DEVICE_IP"
DEVICE_PORT = 6444
DEVICE_ID = "YOUR_AC_ID"
# For V3 devices
DEVICE_TOKEN = None # "YOUR_DEVICE_TOKEN"
DEVICE_KEY = None # "YOUR_DEVICE_KEY"
async def main():
device = HP(ip=DEVICE_IP, port=6444, device_id=int(DEVICE_ID))
if DEVICE_TOKEN and DEVICE_KEY:
await device.authenticate(DEVICE_TOKEN, DEVICE_KEY)
await device.refresh()
print(device)
# Change DHW temperature
device.dhw_target_temperature = 35
# Turn off zone1 and set temperature
device.zone1.target_temperature = 30
device.zone1.power_state = False
await device.apply()
print(device)
if __name__ == "__main__":
asyncio.run(main())If you can, try adjusting a few settings and report back with the results. |
|
Hi However, if you want to continue your work, I am happy to test for you. |
Well, I think that would be possible. The tool would have to maintain a connection (like calling refresh() every 60 seconds or so) and then pass on the data in the power4 messages. Let me know if you do end up going with ESPHome. I'd be curious to know what you come up with. |
|
Would you be able to test the basic control example above? I'd like to know if that's working if I end up shelving this development. |
|
Hi! I think I have similar requirements from this as @nixmeer. The most important thing for me would be to get all the information possible. On the display I can see a lot of interesting temperatures... And also I could see in the Thank you for your work! I'm here if you need me to test anything. I'm a web developer and my Python skills are limited but I can also do some debugging. Logs from this: |
|
Thanks for testing. There was a silly bug in the control commands. I just pushed a fix so if you could test again that'd be great. |
|
Nice! It Worked! |
|
Well mostly :) It looks like the Zone1 power didn't turn off like I expected. Was this line present in your example? |
|
Yes.. Sorry, I must have changed it in my test And it worked to take it back to the original: |
|
No worries. Thanks for running the test again. |
|
Pushed a few minor tweaks to expose some additional device properties. I think it should cover the majority of basic device controls. You should be able to setup a basic script to poll the device occasionally and get some of the temperature and power numbers you're looking for. |
|
I think there are some errors. I fixed it by commenting # "dhw_fast_mode": self.dhw_fast_mode,And then I got the following error: Which I fixed by adding.a return 0 to the tbh_power_state |
|
Whoops! That's what I get for not testing properly... |
|
And the response was exactly the same as before when running the refresh command, only that extra await device.refresh()
print(device)However, what I meant by more information is I think the info part of elseif ((_msgType==cmdTable["MSG_TYPE_QUERY"]) and (_msgBodyType==cmdTable["MSG_TYPE_QUERY_INSTALL"])) then
-- 安装设定参数0x08查询
binToModel(streams, "dhwEnable", _bodyBytes[1],BIT7)
binToModel(streams, "boostertbhEn", _bodyBytes[1],BIT6)
binToModel(streams, "disinfectEnable", _bodyBytes[1],BIT5)
binToModel(streams, "dhwPumpEnable", _bodyBytes[1],BIT4)
binToModel(streams, "dhwPriorityTime", _bodyBytes[1],BIT3)
binToModel(streams, "dhwPumpDIEnable", _bodyBytes[1],BIT2)
binToModel(streams, "coolEnable", _bodyBytes[1],BIT1)
binToModel(streams, "fgZone1CoolTempHigh", _bodyBytes[1],BIT0)
binToModel(streams, "heatEnable", _bodyBytes[2],BIT7)
binToModel(streams, "fgZone1HeatTempHigh", _bodyBytes[2],BIT6)
binToModel(streams, "pumpiSliModeEn", _bodyBytes[2],BIT5)
binToModel(streams, "roomSensorEn", _bodyBytes[2],BIT4)
binToModel(streams, "roomTherEn", _bodyBytes[2],BIT3)
binToModel(streams, "roomTherSetModeEn", _bodyBytes[2],BIT2)
binToModel(streams, "dualroomThermostatEn", _bodyBytes[2],BIT1)
binToModel(streams, "fgdhwPriorEn", _bodyBytes[2],BIT0)
binToModel(streams, "acsEnable", _bodyBytes[3],BIT7)
binToModel(streams, "dhwHeaterAhsEn", _bodyBytes[3],BIT6)
binToModel(streams, "tempPcbEn", _bodyBytes[3],BIT5)
binToModel(streams, "tbt2ProbeEn", _bodyBytes[3],BIT4)
binToModel(streams, "pipeExceed10m", _bodyBytes[3],BIT3)
binToModel(streams, "solarCn18En", _bodyBytes[3],BIT2)
binToModel(streams, "fgOwnSolarEn", _bodyBytes[3],BIT1)
binToModel(streams, "fgInputDhwHeater", _bodyBytes[3],BIT0)
binToModel(streams, "smartgridEn", _bodyBytes[4],BIT7)
binToModel(streams, "t1bProbeEn", _bodyBytes[4],BIT6)
binToModel(streams, "fgZone2CoolTempHigh", _bodyBytes[4],BIT5)
binToModel(streams, "fgZone2HeatTempHigh", _bodyBytes[4],BIT4)
binToModel(streams, "doubleZoneEn", _bodyBytes[4],BIT3)
binToModel(streams, "fgTaProbeIdu", _bodyBytes[4],BIT2)
binToModel(streams, "tbt1ProbeEn", _bodyBytes[4],BIT1)
binToModel(streams, "fgIbhInTank", _bodyBytes[4],BIT0)
binToModel(streams, "dT5On", _bodyBytes[6], nil)
binToModel(streams, "dT5On", _bodyBytes[6], nil)
binToModel(streams, "dT1S5", _bodyBytes[8], nil)
binToModel(streams, "tIntervaDhw", _bodyBytes[10], nil)
binToModel(streams, "t4Dhwmax", _bodyBytes[12], nil)
binToModel(streams, "t4Dhwmin", _bodyBytes[13]* 256+_bodyBytes[14], nil)
binToModel(streams, "tTBHdelay", _bodyBytes[15]* 256+_bodyBytes[16], nil)
binToModel(streams, "dT5STBHoff", _bodyBytes[17]* 256+_bodyBytes[18], nil)
binToModel(streams, "t4TBHon", _bodyBytes[19]* 256+_bodyBytes[20], nil)
binToModel(streams, "t5sDI", _bodyBytes[21]* 256+_bodyBytes[22], nil)
binToModel(streams, "tDImax", _bodyBytes[23]* 256+_bodyBytes[24], nil)
binToModel(streams, "tDIhightemp", _bodyBytes[25]* 256+_bodyBytes[26], nil)
binToModel(streams, "tIntervalC", _bodyBytes[27]* 256+_bodyBytes[28], nil)
binToModel(streams, "dT1SC", _bodyBytes[29]* 256+_bodyBytes[30], nil)
binToModel(streams, "dTSC", _bodyBytes[31]* 256+_bodyBytes[32], nil)
binToModel(streams, "t4Cmax", _bodyBytes[33]* 256+_bodyBytes[34], nil)
binToModel(streams, "t4Cmin", _bodyBytes[35]* 256+_bodyBytes[36], nil)
binToModel(streams, "tIntervalH", _bodyBytes[37]* 256+_bodyBytes[38], nil)
binToModel(streams, "dT1SH", _bodyBytes[39]* 256+_bodyBytes[40], nil)
binToModel(streams, "dTSH", _bodyBytes[41]* 256+_bodyBytes[42], nil)
binToModel(streams, "t4Hmax", _bodyBytes[43]* 256+_bodyBytes[44], nil)
binToModel(streams, "t4Hmin", _bodyBytes[45]* 256+_bodyBytes[46], nil)
binToModel(streams, "t4IBHon", _bodyBytes[47]* 256+_bodyBytes[48], nil)
binToModel(streams, "dT1IBHon", _bodyBytes[49]* 256+_bodyBytes[50], nil)
binToModel(streams, "tIBHdelay", _bodyBytes[51]* 256+_bodyBytes[52], nil)
binToModel(streams, "tIBH12delay", _bodyBytes[53]* 256+_bodyBytes[54], nil)
binToModel(streams, "t4AHSon", _bodyBytes[55]* 256+_bodyBytes[56], nil)
binToModel(streams, "dT1AHSon", _bodyBytes[57]* 256+_bodyBytes[58], nil)
binToModel(streams, "dT1AHSoff", _bodyBytes[59]* 256+_bodyBytes[60], nil)
binToModel(streams, "tAHSdelay", _bodyBytes[61]* 256+_bodyBytes[62], nil)
binToModel(streams, "tDHWHPmax", _bodyBytes[63]* 256+_bodyBytes[64], nil)
binToModel(streams, "tDHWHPrestrict", _bodyBytes[65]* 256+_bodyBytes[66], nil)
binToModel(streams, "t4autocmin", _bodyBytes[67]* 256+_bodyBytes[68], nil)
binToModel(streams, "t4autohmax", _bodyBytes[69]* 256+_bodyBytes[70], nil)
binToModel(streams, "t1sHolHeat", _bodyBytes[71]* 256+_bodyBytes[72], nil)
binToModel(streams, "t5SHolDhw", _bodyBytes[73]* 256+_bodyBytes[74], nil)
binToModel(streams, "perStart", _bodyBytes[75]* 256+_bodyBytes[76], nil)
binToModel(streams, "timeAdjust", _bodyBytes[77]* 256+_bodyBytes[78], nil)
binToModel(streams, "dTbt2", _bodyBytes[79]* 256+_bodyBytes[80], nil)
binToModel(streams, "powerIbh1", (_bodyBytes[81]* 256+_bodyBytes[82])/10, nil)
binToModel(streams, "powerIbh2", (_bodyBytes[83]* 256+_bodyBytes[84])/10, nil)
binToModel(streams, "powerTbh", (_bodyBytes[85]* 256+_bodyBytes[86])/10, nil)
binToModel(streams, "ecoHeatT1s", _bodyBytes[87]* 256+_bodyBytes[88], nil)
binToModel(streams, "ecoHeatTs", _bodyBytes[89]* 256+_bodyBytes[90], nil)
binToModel(streams, "tDryup", _bodyBytes[91]* 256+_bodyBytes[92], nil)
binToModel(streams, "tDrypeak", _bodyBytes[93]* 256+_bodyBytes[94], nil)
binToModel(streams, "tdrydown", _bodyBytes[95]* 256+_bodyBytes[96], nil)
binToModel(streams, "tempDrypeak", _bodyBytes[97]* 256+_bodyBytes[98], nil)
binToModel(streams, "timePreheatFloor", _bodyBytes[99]* 256+_bodyBytes[100], nil)
binToModel(streams, "t1SPreheatFloor", _bodyBytes[101]* 256+_bodyBytes[102], nil)
--103~112为空
binToModel(streams, "t1SetC1", _bodyBytes[113]* 256+_bodyBytes[114], nil)
binToModel(streams, "t1SetC2", _bodyBytes[115]* 256+_bodyBytes[116], nil)
binToModel(streams, "t4C1", _bodyBytes[117]* 256+_bodyBytes[118], nil)
binToModel(streams, "t4C2", _bodyBytes[119]* 256+_bodyBytes[120], nil)
binToModel(streams, "t1SetH1", _bodyBytes[121]* 256+_bodyBytes[122], nil)
binToModel(streams, "t1SetH2", _bodyBytes[123]* 256+_bodyBytes[124], nil)
binToModel(streams, "t4H1", _bodyBytes[125]* 256+_bodyBytes[126], nil)
binToModel(streams, "t4H2", _bodyBytes[127]* 256+_bodyBytes[128], nil)
binToModel(streams, "typeVolLmt", _bodyBytes[129]* 256+_bodyBytes[130], nil)
binToModel(streams, "timeT4FreshC", _bodyBytes[131]/2, nil)
binToModel(streams, "timeT4FreshH", _bodyBytes[132]/2, nil)
binToModel(streams, "tPumpiDelay", (_bodyBytes[133]* 256+_bodyBytes[134])/2, nil)
binToModel(streams, "deltaTsloar", _bodyBytes[135], nil)
binToModel(streams, "solarFunction", _bodyBytes[136], nil)
binToModel(streams, "enSwitchPDC", _bodyBytes[138],BIT0)
binToModel(streams, "gasCost", (_bodyBytes[139]* 256+_bodyBytes[140])/100, nil)
binToModel(streams, "eleCost", (_bodyBytes[141]* 256+_bodyBytes[142])/100, nil)
binToModel(streams, "ahsSetTempMax", _bodyBytes[143], nil)
binToModel(streams, "ahsSetTempMin", _bodyBytes[144], nil)
binToModel(streams, "ahsSetTempMaxVolt", _bodyBytes[145], nil)
binToModel(streams, "ahsSetTempMinVolt", _bodyBytes[146], nil)
binToModel(streams, "t2AntiSVRun", _bodyBytes[147]* 256+_bodyBytes[148], nil)
binToModel(streams, "dftPortFuncEn", _bodyBytes[150],BIT0)
--_bodyBytes[150]~_bodyBytes[180]预留
binToModel(streams, "t1AntiPump", _bodyBytes[181]* 256+_bodyBytes[182], nil)
binToModel(streams, "t2AntiPumpRun", _bodyBytes[183]* 256+_bodyBytes[184], nil)
binToModel(streams, "t1AntiLockSV", _bodyBytes[185]* 256+_bodyBytes[186], nil)
binToModel(streams, "tbhEnFunc", _bodyBytes[187]* 256+_bodyBytes[188], nil)
binToModel(streams, "ibhEnFunc", _bodyBytes[189]* 256+_bodyBytes[190], nil)
--binToModel(streams, "", _bodyBytes[191]* 256+_bodyBytes[192], nil)
binToModel(streams, "ahsEnFunc", _bodyBytes[193]* 256+_bodyBytes[194], nil)
binToModel(streams, "ahsPumpiControl", _bodyBytes[195]* 256+_bodyBytes[196], nil)
binToModel(streams, "modeSetPri", _bodyBytes[197]* 256+_bodyBytes[198], nil)
binToModel(streams, "pumpType", _bodyBytes[199]* 256+_bodyBytes[200], nil)
binToModel(streams, "pumpiSilentOutput", _bodyBytes[201]* 256+_bodyBytes[202], nil)I will try to make a video of the installation menu on the heatpump. But basically in there there's temperatures for water in, water out, Heat exchanger in, Heat Exchanger Out, Compressor In, Compressor Out, Compressor frequency (which according to the installer is something like a percentage power that the compressor is running at), water flow and much more... I did try to replace the Not sure if that's how it's supposed to work, but what was interesting was that if I replaced QUERY_BASIC (0x1) with anything from 0x2 to 0x7 it didn't timeout, only 0x8 (QUERY_INSTALL) failed. I guess it has something to do with the toBytes function. Anyway, I'm going a bit blind on this :) Don't really understand how things work... |
I may be wrong, but I interpreted the
This is more or less what happened on nixmeer's device. No response to anything beyond query 0x7. (#107 (comment)). I don't think anything is wrong with the query, I think the device just ignores it. Perhaps there's a special "install" mode that enables the functionality. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Hi :)
I am desperately looking for a way to connect to my heat pump and read out data via python but all python modules I found so far only support type 0xAC devices. However, my heat pump is of type 0xC3.
Could you add support for that? As of reading though #100, I already downloaded the protocol files.
Thanks ahead!
Jan
T_0000_C3_171H120F_2023062601.txt
T0xC3_2023120100_sm.zip
The text was updated successfully, but these errors were encountered: