def setup_gateway(port, persistence, persistence_file, version):
"""Return gateway after setup of the gateway."""
gateway = mysensors.SerialGateway(port,
event_callback=None,
persistence=persistence,
persistence_file=persistence_file,
protocol_version=version)
gateway.metric = is_metric
gateway.debug = config[DOMAIN].get(CONF_DEBUG, False)
gateway = GatewayWrapper(gateway, version)
# pylint: disable=attribute-defined-outside-init
gateway.event_callback = gateway.callback_factory()
def gw_start(event):
"""Callback to trigger start of gateway and any persistence."""
gateway.start()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: gateway.stop())
if persistence:
for node_id in gateway.sensors:
gateway.event_callback('persistence', node_id)
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, gw_start)
return gateway
def setup_platform(hass, config, add_devices, discovery_info=None):
""" Setup the mysensors platform. """
import mysensors.mysensors as mysensors
import mysensors.const_14 as const
devices = {} # keep track of devices added to HA
# Just assume celcius means that the user wants metric for now.
# It may make more sense to make this a global config option in the future.
is_metric = (hass.config.temperature_unit == TEMP_CELCIUS)
def sensor_update(update_type, nid):
""" Callback for sensor updates from the MySensors gateway. """
_LOGGER.info("sensor_update %s: node %s", update_type, nid)
sensor = gateway.sensors[nid]
if sensor.sketch_name is None:
return
if nid not in devices:
devices[nid] = {}
node = devices[nid]
new_devices = []
for child_id, child in sensor.children.items():
if child_id not in node:
node[child_id] = {}
for value_type, value in child.values.items():
if value_type not in node[child_id]:
name = '{} {}.{}'.format(sensor.sketch_name, nid, child.id)
node[child_id][value_type] = \
MySensorsNodeValue(
nid, child_id, name, value_type, is_metric, const)
new_devices.append(node[child_id][value_type])
else:
node[child_id][value_type].update_sensor(
value, sensor.battery_level)
if new_devices:
_LOGGER.info("adding new devices: %s", new_devices)
add_devices(new_devices)
port = config.get(CONF_PORT)
if port is None:
_LOGGER.error("Missing required key 'port'")
return False
persistence = config.get(CONF_PERSISTENCE, True)
gateway = mysensors.SerialGateway(port,
sensor_update,
persistence=persistence)
gateway.metric = is_metric
gateway.debug = config.get(CONF_DEBUG, False)
gateway.start()
if persistence:
for nid in gateway.sensors:
sensor_update('sensor_update', nid)
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: gateway.stop())
def setup_gateway(device, persistence_file, baud_rate, tcp_port):
"""Return gateway after setup of the gateway."""
try:
socket.inet_aton(device)
# valid ip address
gateway = mysensors.TCPGateway(
device, event_callback=None, persistence=persistence,
persistence_file=persistence_file, protocol_version=version,
port=tcp_port)
except OSError:
# invalid ip address
gateway = mysensors.SerialGateway(
device, event_callback=None, persistence=persistence,
persistence_file=persistence_file, protocol_version=version,
baud=baud_rate)
gateway.metric = is_metric
gateway.debug = config[DOMAIN].get(CONF_DEBUG, False)
optimistic = config[DOMAIN].get(CONF_OPTIMISTIC, False)
gateway = GatewayWrapper(gateway, version, optimistic)
# pylint: disable=attribute-defined-outside-init
gateway.event_callback = gateway.callback_factory()
def gw_start(event):
"""Callback to trigger start of gateway and any persistence."""
gateway.start()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: gateway.stop())
if persistence:
for node_id in gateway.sensors:
gateway.event_callback('persistence', node_id)
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, gw_start)
return gateway
def setup(ada, settings, driver):
import mysensors.mysensors as mysensors
gateway = mysensors.SerialGateway(settings['device'], event_callback=None, persistence=False,
protocol_version="2.0", baud=settings['baudrate'])
bridge = Bridge(driver.entities, gateway)
gateway.event_callback = bridge.event
gateway.start()
def setup_gateway(device, persistence_file, baud_rate, tcp_port, in_prefix,
out_prefix):
"""Return gateway after setup of the gateway."""
if device == MQTT_COMPONENT:
if not setup_component(hass, MQTT_COMPONENT, config):
return
mqtt = get_component(MQTT_COMPONENT)
retain = config[DOMAIN].get(CONF_RETAIN)
def pub_callback(topic, payload, qos, retain):
"""Call MQTT publish function."""
mqtt.publish(hass, topic, payload, qos, retain)
def sub_callback(topic, callback, qos):
"""Call MQTT subscribe function."""
mqtt.subscribe(hass, topic, callback, qos)
gateway = mysensors.MQTTGateway(
pub_callback, sub_callback,
event_callback=None, persistence=persistence,
persistence_file=persistence_file,
protocol_version=version, in_prefix=in_prefix,
out_prefix=out_prefix, retain=retain)
else:
try:
is_serial_port(device)
gateway = mysensors.SerialGateway(
device, event_callback=None, persistence=persistence,
persistence_file=persistence_file,
protocol_version=version, baud=baud_rate)
except vol.Invalid:
try:
socket.getaddrinfo(device, None)
# valid ip address
gateway = mysensors.TCPGateway(
device, event_callback=None, persistence=persistence,
persistence_file=persistence_file,
protocol_version=version, port=tcp_port)
except OSError:
# invalid ip address
return
gateway.metric = hass.config.units.is_metric
gateway.optimistic = config[DOMAIN].get(CONF_OPTIMISTIC)
gateway.device = device
gateway.event_callback = gw_callback_factory(hass)
def gw_start(event):
"""Trigger to start of the gateway and any persistence."""
if persistence:
discover_persistent_devices(hass, gateway)
gateway.start()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: gateway.stop())
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, gw_start)
return gateway
def setup_gateway(device, persistence_file, baud_rate, tcp_port, in_prefix,
out_prefix):
"""Return gateway after setup of the gateway."""
# pylint: disable=too-many-arguments
if device == MQTT_COMPONENT:
if not setup_component(hass, MQTT_COMPONENT, config):
return
mqtt = get_component(MQTT_COMPONENT)
retain = config[DOMAIN].get(CONF_RETAIN)
def pub_callback(topic, payload, qos, retain):
"""Call mqtt publish function."""
mqtt.publish(hass, topic, payload, qos, retain)
def sub_callback(topic, callback, qos):
"""Call mqtt subscribe function."""
mqtt.subscribe(hass, topic, callback, qos)
gateway = mysensors.MQTTGateway(
pub_callback, sub_callback,
event_callback=None, persistence=persistence,
persistence_file=persistence_file,
protocol_version=version, in_prefix=in_prefix,
out_prefix=out_prefix, retain=retain)
else:
try:
socket.inet_aton(device)
# valid ip address
gateway = mysensors.TCPGateway(
device, event_callback=None, persistence=persistence,
persistence_file=persistence_file,
protocol_version=version, port=tcp_port)
except OSError:
# invalid ip address
gateway = mysensors.SerialGateway(
device, event_callback=None, persistence=persistence,
persistence_file=persistence_file,
protocol_version=version, baud=baud_rate)
gateway.metric = hass.config.units.is_metric
gateway.debug = config[DOMAIN].get(CONF_DEBUG)
optimistic = config[DOMAIN].get(CONF_OPTIMISTIC)
gateway = GatewayWrapper(gateway, optimistic, device)
# pylint: disable=attribute-defined-outside-init
gateway.event_callback = gateway.callback_factory()
def gw_start(event):
"""Callback to trigger start of gateway and any persistence."""
gateway.start()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: gateway.stop())
if persistence:
for node_id in gateway.sensors:
gateway.event_callback('persistence', node_id)
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, gw_start)
return gateway
def __init__(self, parent):
self.parent = parent
gateway = mysensors.SerialGateway(
'/dev/ttyUSB0',
baud=115200, #timeout=1.0, reconnect_timeout=10.0,
event_callback=self.event,
persistence=True,
persistence_file='mysensors.pickle',
protocol_version='2.2')
gateway.start_persistence()
gateway.on_conn_made = self.conn_made
gateway.on_conn_lost = self.conn_lost
self.parent.mySensorsGateway = gateway
"""Example for using pymysensors."""
import mysensors.mysensors as mysensors
def event(update_type, nid):
"""Callback for mysensors updates."""
print(update_type + " " + str(nid))
# To create a serial gateway.
GATEWAY = mysensors.SerialGateway('/dev/ttyACM0',
event,
protocol_version='2.0')
# To create a TCP gateway.
# GATEWAY = mysensors.TCPGateway('127.0.0.1', event, True)
GATEWAY.debug = True
GATEWAY.start()
# To set sensor 1, child 1, sub-type V_LIGHT (= 2), with value 1.
# GATEWAY.set_child_value(1, 1, 2, 1)
# GATEWAY.stop()
def setup_gateway(device, persistence_file, baud_rate, tcp_port, in_prefix,
out_prefix):
"""Return gateway after setup of the gateway."""
if device == MQTT_COMPONENT:
if not setup_component(hass, MQTT_COMPONENT, config):
return
mqtt = get_component(MQTT_COMPONENT)
retain = config[DOMAIN].get(CONF_RETAIN)
def pub_callback(topic, payload, qos, retain):
"""Call mqtt publish function."""
mqtt.publish(hass, topic, payload, qos, retain)
def sub_callback(topic, callback, qos):
"""Call mqtt subscribe function."""
mqtt.subscribe(hass, topic, callback, qos)
gateway = mysensors.MQTTGateway(pub_callback,
sub_callback,
event_callback=None,
persistence=persistence,
persistence_file=persistence_file,
protocol_version=version,
in_prefix=in_prefix,
out_prefix=out_prefix,
retain=retain)
else:
try:
is_serial_port(device)
gateway = mysensors.SerialGateway(
device,
event_callback=None,
persistence=persistence,
persistence_file=persistence_file,
protocol_version=version,
baud=baud_rate)
except vol.Invalid:
try:
socket.getaddrinfo(device, None)
# valid ip address
gateway = mysensors.TCPGateway(
device,
event_callback=None,
persistence=persistence,
persistence_file=persistence_file,
protocol_version=version,
port=tcp_port)
except OSError:
# invalid ip address
return
gateway.metric = hass.config.units.is_metric
optimistic = config[DOMAIN].get(CONF_OPTIMISTIC)
gateway = GatewayWrapper(gateway, optimistic, device)
# pylint: disable=attribute-defined-outside-init
gateway.event_callback = gateway.callback_factory()
def gw_start(event):
"""Callback to trigger start of gateway and any persistence."""
if persistence:
for node_id in gateway.sensors:
node = gateway.sensors[node_id]
for child_id in node.children:
child = node.children[child_id]
for value_type in child.values:
msg = mysensors.Message().modify(
node_id=node_id,
child_id=child_id,
type=1,
sub_type=value_type)
gateway.event_callback(msg)
gateway.start()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: gateway.stop())
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, gw_start)
return gateway
"""Example for using pymysensors."""
import logging
import mysensors.mysensors as mysensors
logging.basicConfig(level=logging.DEBUG)
def event(message):
"""Callback for mysensors updates."""
print("sensor_update " + str(message.node_id))
# To create a serial gateway.
GATEWAY = mysensors.SerialGateway("/dev/ttyACM0",
event_callback=event,
protocol_version="2.0")
# To create a TCP gateway.
# GATEWAY = mysensors.TCPGateway('127.0.0.1', event_callback=event)
GATEWAY.start()
# To set sensor 1, child 1, sub-type V_LIGHT (= 2), with value 1.
# GATEWAY.set_child_value(1, 1, 2, 1)
# GATEWAY.stop()
# bot.message_loop(handle)
print('running Sensor Controller ...')
myIPaddress = str(
subprocess.check_output(
['dig', '+short', 'myip.opendns.com', '@resolver1.opendns.com']))
import mysensors.mysensors as mysensors
ALARM_STATUS = 1
############### WORKING HERE ##################
GATEWAY = mysensors.SerialGateway(
'/dev/ttyMySensorsGateway',
MySensorEvent,
persistence=True,
persistence_file='/home/pi/git/thermostat/thermostat/mysensors.pickle')
GATEWAY.start()
# generate a name for this maggiordomo if does not exist
try:
MaggiordomoIDFile = open(IDpath, 'r')
MaggiordomoID = MaggiordomoIDFile.read().strip()
MaggiordomoIDFile.close()
# bot.sendMessage(CHATID, "sono "+MaggiordomoID+". Mi sono appena svegliato")
except IOError:
#logging.error("Non ho trovato il file con ID del maggiordomo. Genero ID e lo salvo")
MaggiordomoID = "Maggiordomo-" + ''.join(
random.SystemRandom().choice(string.ascii_uppercase + string.digits)
def init_gw_thread(event_handler):
""" instantiate the SerialGateway """
global gw_thread
gw_thread = mysensors.SerialGateway(
config["device"], event_handler, protocol_version='1.5',
baud=config["baud_rate"])
import mysensors.mysensors as mysensors
def event(type, nid):
print(type + " " + str(nid))
gw = mysensors.SerialGateway('/dev/ttyACM0', event, True)
gw.debug = True
gw.start()
# To set sensor 2, child 1, sub-type V_LIGHT (= 2), with value 1.
gw.set_child_value(2, 1, 2, 1)
gw.stop()
Getting the type and values of node 23, child sensor 4 would be performed as follows:
s_type = GATEWAY.sensors[23].children[4].type
values = GATEWAY.sensors[23].children[4].values
'''
ALARM_STATUS = 1
ALARM_ACTIVE = 1
MOVING_STATUS = 1
#GATEWAY = mysensors.SerialGateway('/dev/ttyMySensorsGateway', MySensorEvent, persistence=False)
GATEWAY = mysensors.SerialGateway(
'/dev/ttyMySensorsGateway',
baud=115200,
event_callback=MySensorEvent,
persistence=True,
persistence_file='/home/pi/git/thermostat/thermostat/mysensors.pickle',
protocol_version='2.0')
GATEWAY.start_persistence()
_LOGGER.debug("Starting Gateway")
GATEWAY.start()
# generate a name for this maggiordomo if does not exist
try:
MaggiordomoIDFile = open(IDpath, 'r')
MaggiordomoID = MaggiordomoIDFile.read().strip()
MaggiordomoIDFile.close()
# bot.sendMessage(CHATID, "sono "+MaggiordomoID+". Mi sono appena svegliato")
CURSOR_OFF = '20'
BLINK_CURSOR_ON = '40'
BLINK_CURSOR_OFF = '41'
def event_callback(msg):
"""Callback for mysensors updates."""
print('MSG | '\
' NodeId: {} | ChildId: {} | Type:{}'.format(
msg.node_id,msg.child_id,msg.type)
)
GATEWAY = mysensors.SerialGateway(port=SERIAL_PORT,
baud=115200,
event_callback=event_callback,
protocol_version='2.2')
GATEWAY.start()
# To set sensor 1, child 1, sub-type V_LIGHT (= 2), with value 1.
print("Wait for gateway ...")
time.sleep(2)
print("Sensors detected: {}".format(len(GATEWAY.sensors)))
is_sensor = GATEWAY.is_sensor(0, 1)
# Check if there is a sensor
print('Check for a valid sensor at node 0 child 1: {}'.format(is_sensor))
### Start Test
