pyg90alarm.alarm

Provides interface to G90 alarm panel.

Note

Both local protocol (referred to as 1.2) and cloud one

(mentioned as 1.1) are supported.

The next example queries the device with IP address 10.10.10.250 for the information - the product name, protocol version, HW versions and such.

>>> import asyncio
>>> from pyg90alarm import G90Alarm
>>> async def main():
       g90 = G90Alarm(host='10.10.10.250')
       s = await g90.host_info
       print(s)
>>> asyncio.run(main())
G90HostInfo(host_guid='<...>',
            product_name='TSV018-C3SIA',
            wifi_protocol_version='1.2',
            cloud_protocol_version='1.1',
            mcu_hw_version='206',
            wifi_hw_version='206',
            gsm_status=3,
            wifi_status=3,
            reserved1=0,
            reserved2=0,
            band_frequency='4264',
            gsm_signal_level=50,
            wifi_signal_level=100)

Classes

G90Alarm(host[, port, reset_occupancy_interval])

Allows to interact with G90 alarm panel.

class pyg90alarm.alarm.G90Alarm(host, port=12368, reset_occupancy_interval=3.0)

Bases: G90NotificationProtocol

Allows to interact with G90 alarm panel.

Parameters:

host (str) – Hostname or IP address of the alarm panel. Since the protocol is UDP-based it is ok to use broadcast or directed broadcast addresses, such as 255.255.255.255 or 10.10.10.255 (the latter assumes the device is on 10.10.10.0/24 network)
port (int) – The UDP port of the device where it listens for the protocol commands on WiFi interface, currently the devices don’t allow it to be customized
reset_occupancy_interval (float) – The interval upon that the sensors are simulated to go into inactive state.

property host: str

Returns the hostname or IP address of the alarm panel.

This is the address used for communication with the device.

property port: int

Returns the UDP port number used to communicate with the alarm panel.

By default, this is set to the standard G90 protocol port.

async command(code, data=None)

Invokes a command against the alarm panel.

Parameters:

code (G90Commands) – Command code
data (List[Any] | None) – Command data

Return type:

List[Any]

Returns:

The result of command invocation

paginated_result(code, start=1, end=None)

Returns asynchronous generator for a paginated command, that is - command operating on a range of records.

Parameters:

code (G90Commands) – Command code
start (int) – Starting record position (one-based)
end (int | None) – Ending record position (one-based)

Return type:

AsyncGenerator[G90PaginatedResponse, None]

Returns:

Asynchronous generator over the result of command invocation.

async mcu_reboot()

Reboots the MCU of the alarm panel.

Note that underlying command doesn’t return any result, so there is no feedback from the panel upon execution.

Return type:: None

async gsm_reboot()

Reboots the GSM module of the alarm panel.

Note that underlying command doesn’t return any result, so there is no feedback from the panel upon execution.

Return type:: None

async wifi_reboot()

Reboots the WiFi module of the alarm panel.

Note that underlying command doesn’t return any result, so there is no feedback from the panel upon execution.

Return type:: None

async reboot()

Reboots the entire alarm panel.

The system commands performing reboot of a panel’s module don’t return anything so there is no feedback from the panel upon execution, hence the commands are spaced with delays to allow the panel to process them.

Please be aware that the delays are determined experimentally and might be too long or too short.

Return type:: None

async set_cloud_server_address(cloud_ip, cloud_port)

Sets the cloud server address the alarm panel connects to.

Parameters:

cloud_ip (str) – IP address of the server to receive cloud protocol notifications, should be reachable from the panel. Typically it is the IP address of the host running the package
cloud_port (int) – Port number of the server to receive cloud protocol notifications, should be reachable from the panel

Return type:

None

async classmethod discover()

Initiates discovering devices available in the same network segment, by using global broadcast address as the destination.

Return type:: List[G90DiscoveredDevice]
Returns:: List of discovered devices

async classmethod targeted_discover(device_id)

Initiates discovering devices available in the same network segment using targeted protocol, that is - specifying target device GUID in the request, so only the specific device should respond to the query.

Parameters:: device_id (str) – GUID of the target device to discover
Return type:: List[G90DiscoveredDeviceTargeted]
Returns:: List of discovered devices

property sensors: List[G90Sensor]

Returns the list of sensors configured in the device. Please note it doesn’t update those from the panel except initially when the list if empty.

Returns:: List of sensors

async get_sensors()

Provides list of sensors configured in the device, updating them from panel on each call.

Return type:: List[G90Sensor]
Returns:: List of sensors

async find_sensor(idx, name, exclude_unavailable=True)

Finds sensor by index and name.

Parameters:

idx (int) – Sensor index
name (str) – Sensor name
exclude_unavailable (bool) – Flag indicating if unavailable sensors should be excluded from the search

Return type:

G90Sensor | None

Returns:

Sensor instance

async register_sensor(definition_name, name=None, timeout=30)

Registers the sensor with the panel.

Parameters:

definition_name (str) – Name of the sensor definition to register
name (str | None) – Optional name of the sensor to register, if not provided the name will be taken from the definition
timeout (float) – Timeout for the registration process, in seconds

Return type:

G90Sensor

Returns:

Sensor instance

property devices: List[G90Device]

Returns the list of devices (switches) configured in the device. Please note it doesn’t update those from the panel except initially when the list if empty.

Returns:: List of devices

async get_devices()

Provides list of devices (switches) configured in the device, updating them from panel on each call. Multi-node devices, those having multiple ports, are expanded into corresponding number of resulting entries.

Return type:: List[G90Device]
Returns:: List of devices

async find_device(idx, name, exclude_unavailable=True)

Finds device by index and name.

Parameters:

idx (int) – Device index
name (str) – Device name
exclude_unavailable (bool) – Flag indicating if unavailable devices should be excluded from the search

Return type:

G90Device | None

Returns:

Device instance

async register_device(definition_name, name=None, timeout=30)

Registers device (relay, switch) with the panel.

Parameters:

definition_name (str) – Name of the device definition to register
name (str | None) – Optional name of the device to register, if not provided the name will be taken from the definition
timeout (float) – Timeout for the registration process, in seconds

Return type:

G90Device

Returns:

Device instance

property host_info: G90HostInfo: Property over new get_host_info() method, retained for compatibility.

async get_host_info()

Provides the device information (for example hardware versions, signal levels etc.).

Return type:: G90HostInfo
Returns:: Device information

property host_status: G90HostStatus: Property over new get_host_status() method, retained for compatibility.

async get_host_status()

Provides the device status (for example, armed or disarmed, configured phone number, product name etc.).

Return type:: G90HostStatus
Returns:: Device information

property alert_config: G90AlertConfig

Provides alert configuration object.

Returns:: Alert configuration object

async get_alert_config()

Provides alert configuration flags, retained for compatibility - using alert_config and G90AlertConfig is preferred.

Return type:: G90AlertConfigFlags
Returns:: The alerts configured

async set_alert_config(flags)

Sets the alert configuration flags, retained for compatibility - using alert_config and G90AlertConfig is preferred.

Return type:: None

async alarm_phones(force=False)

Provides access to alarm panel phone numbers.

Parameters:: force (bool) – If True, bypass cached value and force device read.
Return type:: G90AlarmPhones
Returns:: Alarm panel phone numbers

async host_config(force=False)

Provides access to alarm panel configuration.

Parameters:: force (bool) – If True, bypass cached value and force device read.
Return type:: G90HostConfig
Returns:: Alarm panel configuration

async net_config(force=False)

Provides access to alarm panel network configuration.

Parameters:: force (bool) – If True, bypass cached value and force device read.
Return type:: G90NetConfig
Returns:: Alarm panel network configuration

async sia_config(force=False)

Provides access to SIA Internet reporting configuration.

Parameters:: force (bool) – If True, bypass cached value and force device read.
Return type:: G90SiaConfig
Returns:: SIA Internet reporting configuration

async cid_config(force=False)

Provides access to CID (Contact ID) phone reporting configuration.

Parameters:: force (bool) – If True, bypass cached value and force device read.
Return type:: G90CidConfig
Returns:: CID phone reporting configuration

property user_data_crc: G90UserDataCRC: Property over new get_user_data_crc() method, retained for compatibility.

async get_user_data_crc()

Retieves checksums (CRC) for different on-device databases (history, sensors etc.). Might be used to detect if there is a change in a particular database.

Note

Note that due to a bug in the firmware CRC for sensors and device databases change on each call even if there were no changes

Return type:: G90UserDataCRC
Returns:: Checksums for different databases

async history(start=1, count=1)

Retrieves event history from the device.

Parameters:

start (int) – Starting record number (one-based)
count (int) – Number of records to retrieve

Return type:

List[G90History]

Returns:

List of history entries

async on_sensor_activity(idx, name, occupancy=True)

Invoked both for sensor notifications and door open/close alerts, since the logic for both is same and could be reused. Fires corresponding callback if set by the user with sensor_callback.

Please note the method is for internal use by the class.

Parameters:

idx (int) – The index of the sensor the callback is invoked for. Please note the index is a property of sensor, not the direct index of sensors array
name (str) – The name of the sensor, along with the idx parameter it is used to look the sensor up from the sensors list
occupancy (bool) – The flag indicating the target sensor state (=occupancy), will always be True for callbacks invoked from alarm panel notifications, and reflects actual sensor state for device alerts (only for door type sensors, if door open/close alerts are enabled)

Return type:

None

property sensor_callback: G90CallbackList[Callable[[int, str, bool], None] | Callable[[int, str, bool], Coroutine[None, None, None]]]

Sensor activity callback, which is invoked when sensor activates.

Setting the property will add the callback to the list of (retained for compatilibity with earlier package versions), or G90CallbackList instance could be accessed over the property - G90Alarm(…).sensor_callback.add(callback) or G90Alarm(…).sensor_callback.remove(callback) methods could be used to add or remove the callback, respectively.

async on_door_open_close(event_id, zone_name, is_open)

Invoked when door open/close alert comes from the alarm panel. Fires corresponding callback if set by the user with door_open_close_callback.

Please note the method is for internal use by the class.