jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-18 10:47:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update remaining modbus platforms to use pymodbus_call (#50768)

Browse Source
This commit is contained in:
jan iversen 2021-05-17 22:12:18 +02:00 committed by GitHub
parent f762d3c748
commit ba827db8ec
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 44 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
homeassistant/components/modbus/climate.py
View File

@ -28,7 +28,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
from .const import ( from .const import (
ATTR_TEMPERATURE, ATTR_TEMPERATURE,
CALL_TYPE_REGISTER_HOLDING, CALL_TYPE_REGISTER_HOLDING,
CALL_TYPE_REGISTER_INPUT, CALL_TYPE_WRITE_REGISTERS,
CONF_CLIMATES, CONF_CLIMATES,
CONF_CURRENT_TEMP, CONF_CURRENT_TEMP,
CONF_CURRENT_TEMP_REGISTER_TYPE, CONF_CURRENT_TEMP_REGISTER_TYPE,
@ -208,10 +208,11 @@ class ModbusThermostat(ClimateEntity):
) )
byte_string = struct.pack(self._structure, target_temperature) byte_string = struct.pack(self._structure, target_temperature)
register_value = struct.unpack(">h", byte_string[0:2])[0] register_value = struct.unpack(">h", byte_string[0:2])[0]
self._available = await self._hub.async_write_registers( self._available = await self._hub.async_pymodbus_call(
self._slave, self._slave,
self._target_temperature_register, self._target_temperature_register,
register_value, register_value,
CALL_TYPE_WRITE_REGISTERS,
) )
await self.async_update() await self.async_update()
@ -235,14 +236,9 @@ class ModbusThermostat(ClimateEntity):
async def _async_read_register(self, register_type, register) -> float | None: async def _async_read_register(self, register_type, register) -> float | None:
"""Read register using the Modbus hub slave.""" """Read register using the Modbus hub slave."""
if register_type == CALL_TYPE_REGISTER_INPUT: result = await self._hub.async_pymodbus_call(
result = await self._hub.async_read_input_registers( self._slave, register, self._count, register_type
self._slave, register, self._count )
)
else:
result = await self._hub.async_read_holding_registers(
self._slave, register, self._count
)
if result is None: if result is None:
self._available = False self._available = False
return -1 return -1

70
homeassistant/components/modbus/cover.py
View File

@ -27,7 +27,8 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
from .const import ( from .const import (
CALL_TYPE_COIL, CALL_TYPE_COIL,
CALL_TYPE_REGISTER_HOLDING, CALL_TYPE_REGISTER_HOLDING,
CALL_TYPE_REGISTER_INPUT, CALL_TYPE_WRITE_COIL,
CALL_TYPE_WRITE_REGISTER,
CONF_REGISTER, CONF_REGISTER,
CONF_STATE_CLOSED, CONF_STATE_CLOSED,
CONF_STATE_CLOSING, CONF_STATE_CLOSING,
@ -94,18 +95,22 @@ class ModbusCover(CoverEntity, RestoreEntity):
# If we read cover status from coil, and not from optional status register, # If we read cover status from coil, and not from optional status register,
# we interpret boolean value False as closed cover, and value True as open cover. # we interpret boolean value False as closed cover, and value True as open cover.
# Intermediate states are not supported in such a setup. # Intermediate states are not supported in such a setup.
if self._coil is not None and self._status_register is None: if self._coil is not None:
self._state_closed = False self._write_type = CALL_TYPE_WRITE_COIL
self._state_open = True if self._status_register is None:
self._state_closing = None self._state_closed = False
self._state_opening = None self._state_open = True
self._state_closing = None
self._state_opening = None
# If we read cover status from the main register (i.e., an optional # If we read cover status from the main register (i.e., an optional
# status register is not specified), we need to make sure the register_type # status register is not specified), we need to make sure the register_type
# is set to "holding". # is set to "holding".
if self._register is not None and self._status_register is None: if self._register is not None:
self._status_register = self._register self._write_type = CALL_TYPE_WRITE_REGISTER
self._status_register_type = CALL_TYPE_REGISTER_HOLDING if self._status_register is None:
self._status_register = self._register
self._status_register_type = CALL_TYPE_REGISTER_HOLDING
async def async_added_to_hass(self): async def async_added_to_hass(self):
"""Handle entity which will be added.""" """Handle entity which will be added."""
@ -169,21 +174,17 @@ class ModbusCover(CoverEntity, RestoreEntity):
async def async_open_cover(self, **kwargs: Any) -> None: async def async_open_cover(self, **kwargs: Any) -> None:
"""Open cover.""" """Open cover."""
if self._coil is not None: self._available = await self._hub.async_pymodbus_call(
await self._async_write_coil(True) self._slave, self._register, self._state_open, self._write_type
else: )
await self._async_write_register(self._state_open) self.async_update()
await self.async_update()
async def async_close_cover(self, **kwargs: Any) -> None: async def async_close_cover(self, **kwargs: Any) -> None:
"""Close cover.""" """Close cover."""
if self._coil is not None: self._available = await self._hub.async_pymodbus_call(
await self._async_write_coil(False) self._slave, self._register, self._state_closed, self._write_type
else: )
await self._async_write_register(self._state_closed) self.async_update()
await self.async_update()
async def async_update(self, now=None): async def async_update(self, now=None):
"""Update the state of the cover.""" """Update the state of the cover."""
@ -198,14 +199,9 @@ class ModbusCover(CoverEntity, RestoreEntity):
async def _async_read_status_register(self) -> int | None: async def _async_read_status_register(self) -> int | None:
"""Read status register using the Modbus hub slave.""" """Read status register using the Modbus hub slave."""
if self._status_register_type == CALL_TYPE_REGISTER_INPUT: result = await self._hub.async_pymodbus_call(
result = await self._hub.async_read_input_registers( self._slave, self._status_register, 1, self._status_register_type
self._slave, self._status_register, 1 )
)
else:
result = await self._hub.async_read_holding_registers(
self._slave, self._status_register, 1
)
if result is None: if result is None:
self._available = False self._available = False
return None return None
@ -215,24 +211,14 @@ class ModbusCover(CoverEntity, RestoreEntity):
return value return value
async def _async_write_register(self, value):
"""Write holding register using the Modbus hub slave."""
self._available = await self._hub.async_write_register(
self._slave, self._register, value
)
async def _async_read_coil(self) -> bool | None: async def _async_read_coil(self) -> bool | None:
"""Read coil using the Modbus hub slave.""" """Read coil using the Modbus hub slave."""
result = await self._hub.async_read_coils(self._slave, self._coil, 1) result = await self._hub.async_pymodbus_call(
self._slave, self._coil, 1, CALL_TYPE_COIL
)
if result is None: if result is None:
self._available = False self._available = False
return None return None
value = bool(result.bits[0] & 1) value = bool(result.bits[0] & 1)
return value return value
async def _async_write_coil(self, value):
"""Write coil using the Modbus hub slave."""
self._available = await self._hub.async_write_coil(
self._slave, self._coil, value
)

20
homeassistant/components/modbus/modbus.py
View File

@ -327,26 +327,6 @@ class ModbusHub:
self._pymodbus_call, unit, address, value, use_call self._pymodbus_call, unit, address, value, use_call
) )
async def async_read_coils(self, unit, address, count):
"""Read coils."""
return await self.async_pymodbus_call(unit, address, count, CALL_TYPE_COIL)
async def async_read_discrete_inputs(self, unit, address, count):
"""Read discrete inputs."""
return await self.async_pymodbus_call(unit, address, count, CALL_TYPE_DISCRETE)
async def async_read_input_registers(self, unit, address, count):
"""Read input registers."""
return await self.async_pymodbus_call(
unit, address, count, CALL_TYPE_REGISTER_INPUT
)
async def async_read_holding_registers(self, unit, address, count):
"""Read holding registers."""
return await self.async_pymodbus_call(
unit, address, count, CALL_TYPE_REGISTER_HOLDING
)
async def async_write_coil(self, unit, address, value) -> bool: async def async_write_coil(self, unit, address, value) -> bool:
"""Write coil.""" """Write coil."""
return await self.async_pymodbus_call( return await self.async_pymodbus_call(

35
homeassistant/components/modbus/switch.py
View File

@ -22,9 +22,6 @@ from homeassistant.helpers.typing import ConfigType
from .const import ( from .const import (
CALL_TYPE_COIL, CALL_TYPE_COIL,
CALL_TYPE_DISCRETE,
CALL_TYPE_REGISTER_HOLDING,
CALL_TYPE_REGISTER_INPUT,
CONF_INPUT_TYPE, CONF_INPUT_TYPE,
CONF_STATE_OFF, CONF_STATE_OFF,
CONF_STATE_ON, CONF_STATE_ON,
@ -62,14 +59,9 @@ class ModbusSwitch(SwitchEntity, RestoreEntity):
self._available = True self._available = True
self._scan_interval = timedelta(seconds=config[CONF_SCAN_INTERVAL]) self._scan_interval = timedelta(seconds=config[CONF_SCAN_INTERVAL])
self._address = config[CONF_ADDRESS] self._address = config[CONF_ADDRESS]
if config[CONF_WRITE_TYPE] == CALL_TYPE_COIL: self._write_type = config[CONF_WRITE_TYPE]
self._async_write_func = self._hub.async_write_coil self._command_on = config[CONF_COMMAND_ON]
self._command_on = 0x01 self._command_off = config[CONF_COMMAND_OFF]
self._command_off = 0x00
else:
self._async_write_func = self._hub.async_write_register
self._command_on = config[CONF_COMMAND_ON]
self._command_off = config[CONF_COMMAND_OFF]
if CONF_VERIFY in config: if CONF_VERIFY in config:
if config[CONF_VERIFY] is None: if config[CONF_VERIFY] is None:
config[CONF_VERIFY] = {} config[CONF_VERIFY] = {}
@ -82,15 +74,6 @@ class ModbusSwitch(SwitchEntity, RestoreEntity):
) )
self._state_on = config[CONF_VERIFY].get(CONF_STATE_ON, self._command_on) self._state_on = config[CONF_VERIFY].get(CONF_STATE_ON, self._command_on)
self._state_off = config[CONF_VERIFY].get(CONF_STATE_OFF, self._command_off) self._state_off = config[CONF_VERIFY].get(CONF_STATE_OFF, self._command_off)
if self._verify_type == CALL_TYPE_REGISTER_HOLDING:
self._async_read_func = self._hub.async_read_holding_registers
elif self._verify_type == CALL_TYPE_DISCRETE:
self._async_read_func = self._hub.async_read_discrete_inputs
elif self._verify_type == CALL_TYPE_REGISTER_INPUT:
self._async_read_func = self._hub.async_read_input_registers
else: # self._verify_type == CALL_TYPE_COIL:
self._async_read_func = self._hub.async_read_coils
else: else:
self._verify_active = False self._verify_active = False
@ -125,8 +108,8 @@ class ModbusSwitch(SwitchEntity, RestoreEntity):
async def async_turn_on(self, **kwargs): async def async_turn_on(self, **kwargs):
"""Set switch on.""" """Set switch on."""
result = await self._async_write_func( result = await self._hub.async_pymodbus_call(
self._slave, self._address, self._command_on self._slave, self._address, self._command_on, self._write_type
) )
if result is False: if result is False:
self._available = False self._available = False
@ -141,8 +124,8 @@ class ModbusSwitch(SwitchEntity, RestoreEntity):
async def async_turn_off(self, **kwargs): async def async_turn_off(self, **kwargs):
"""Set switch off.""" """Set switch off."""
result = await self._async_write_func( result = await self._hub.async_pymodbus_call(
self._slave, self._address, self._command_off self._slave, self._address, self._command_off, self._write_type
) )
if result is False: if result is False:
self._available = False self._available = False
@ -164,7 +147,9 @@ class ModbusSwitch(SwitchEntity, RestoreEntity):
self.async_write_ha_state() self.async_write_ha_state()
return return
result = await self._async_read_func(self._slave, self._verify_address, 1) result = await self._hub.async_pymodbus_call(
self._slave, self._verify_address, 1, self._verify_type
)
if result is None: if result is None:
self._available = False self._available = False
self.async_write_ha_state() self.async_write_ha_state()