def ConnectAndSetOnOff(email, password, name=None, uuid=None, mac=None, action='on'): """ Connect to Meross Cloud and set on or off a smartplug """ if mac and not name and not uuid: Exit("<F> Error : not implemented !") if not name and not uuid and not mac: Exit("<F> Error : need at least 'name', 'uuid' or 'mac' parameter to set on or off a smartplug !") try: httpHandler = MerossHttpClient(email, password) except: Exit("<F> Error : can't connect to Meross Cloud ! Please verify Internet connection, email and password !") # Retrieves the list of supported devices devices = httpHandler.list_supported_devices() device = None for d in devices: if (d._uuid == uuid) or (d._name == name): device = d break try: if action == 'on': device.turn_on() else: device.turn_off() except: pass return
def scan_power_switches(callback=None, **kwargs): if '' == kwargs['meross_username'] or '' == kwargs['meross_password']: logger.info('Meross cloud is not enabled.') return try: httpHandler = MerossHttpClient(email=kwargs['meross_username'], password=kwargs['meross_password']) logger.info('Logged into Meross cloud successfull.') devices = httpHandler.list_supported_devices() if len(devices) == 0: logger.warning('Unfortunaly your Meross device is not supported by this software. We found zero power switches.') for counter, device in enumerate(devices): data = device.get_sys_data() try: for channel_data in data['all']['digest']['togglex']: if int(channel_data['channel']) > 0: yield terrariumPowerSwitch(md5((terrariumPowerSwitchMSS425E.TYPE + data['all']['system']['hardware']['macAddress'] + str(channel_data['channel'])).encode()).hexdigest(), terrariumPowerSwitchMSS425E.TYPE, (device,int(channel_data['channel'])), 'Channel {}'.format(channel_data['channel']), None, callback) except Exception as ex: print('Scan error in terrariumPowerSwitchMSS425E') print(ex) except UnauthorizedException as ex: logger.error('Authentication error with Merros cloud for \'{}\' type power switch. Please check username and password.'.format(terrariumPowerSwitchMSS425E.TYPE))
def setUp(self): httpHandler = MerossHttpClient(email=EMAIL, password=PASSWORD) # Retrieves the list of supported devices devices = httpHandler.list_supported_devices() for counter, device in enumerate(devices): if isinstance(device, Mss310): self.device = device break
class TestHttpMethods(unittest.TestCase): def setUp(self): self.client = MerossHttpClient(email=EMAIL, password=PASSWORD) def test_device_listing(self): devices = self.client.list_devices() assert devices is not None assert len(devices) > 0 def test_supported_device_listing(self): devices = self.client.list_devices() assert devices is not None assert len(devices) > 0
def __init__(self, meross_email, meross_password): self._devices_lock = RLock() self._devices = dict() self._event_callbacks_lock = RLock() self._event_callbacks = [] self._http_client = MerossHttpClient(email=meross_email, password=meross_password) self._cloud_creds = self._http_client.get_cloud_credentials() # Instantiate the mqtt cloud client self._cloud_client = MerossCloudClient(cloud_credentials=self._cloud_creds, push_message_callback=self._dispatch_push_notification) self._cloud_client.connection_status.register_connection_event_callback(callback=self._fire_event)
def login(self): global device1 user = self.e1.get() passw = self.e2.get() httphandler = MerossHttpClient(email=user, password=passw) devices = httphandler.list_supported_devices() for counter, device in enumerate(devices): device1 = device self.master.switch_frame(GraphPage)
def __init__(self, cloud_credentials, discovery_interval, auto_reconnect): self._cloud_creds = cloud_credentials self._http_client = MerossHttpClient(cloud_credentials=self._cloud_creds) self._devices_lock = lock_factory.build_rlock() self._devices = dict() self._event_callbacks_lock = lock_factory.build_rlock() self._event_callbacks = [] # Instantiate the mqtt cloud client self._cloud_client = MerossCloudClient(cloud_credentials=self._cloud_creds, push_message_callback=self._dispatch_push_notification, auto_reconnect=auto_reconnect) self._cloud_client.connection_status.register_connection_event_callback(callback=self._fire_event) self._device_discoverer = None self._stop_discovery = Event() self._device_discovery_done = Event() self._discovery_interval = discovery_interval
def from_email_and_password(cls, meross_email, meross_password, discovery_interval=30.0, auto_reconnect=True ): cloud_creds = MerossHttpClient.login(email=meross_email, password=meross_password) return MerossManager( cloud_credentials=cloud_creds, discovery_interval=discovery_interval, auto_reconnect=auto_reconnect)
def ConnectAndRefreshAll(email, password): """ Connect to Meross Cloud and refresh all devices and informations """ try: httpHandler = MerossHttpClient(email, password) except: Exit( "<F> Error : can't connect to Meross Cloud ! Please verify Internet connection, email and password !" ) # Retrieves the list of supported devices devices = httpHandler.list_supported_devices() # Build dict of devices informations d_devices = {} for num in range(len(devices)): if debug: print(50 * '=' + '\nnum=', num) device = devices[num] d = RefreshOneDevice(device=device) uuid = device._uuid d_devices[uuid] = d if debug: pprint.pprint(d_devices) # Save dictionnary into Pickle file # f = open(pklfile,"wb") # pickle.dump(d_devices,f) # f.close() # Save dictionnary into JSON file # l_devices = list(d_devices.values()) # print(l_devices) # with open(jsonfile, 'w') as fp: # json.dump(d_devices, fp) return d_devices
def setup(hass, config): """Set up Tuya Component.""" from meross_iot.api import MerossHttpClient username = config[DOMAIN][CONF_USERNAME] password = config[DOMAIN][CONF_PASSWORD] meross = MerossHttpClient(email=username, password=password) hass.data[DATA_MEROSS] = meross hass.data[DOMAIN] = {'entities': {}} def load_devices(): hass.data[DATA_DEVICES] = {} for device in meross.list_supported_devices(): hass.data[DATA_DEVICES][device.device_id()] = device """Load new devices by device_list.""" device_type_list = {} for device in hass.data[DATA_DEVICES].values(): if device.device_id() not in hass.data[DOMAIN]['entities']: ha_type = 'switch' if ha_type not in device_type_list: device_type_list[ha_type] = [] device_type_list[ha_type].append(device.device_id()) hass.data[DOMAIN]['entities'][device.device_id()] = None for ha_type, dev_ids in device_type_list.items(): discovery.load_platform(hass, ha_type, DOMAIN, {'dev_ids': dev_ids}, config) load_devices() def poll_devices_update(event_time): """Check if accesstoken is expired and pull device list from server.""" _LOGGER.debug("Pull devices from Meross.") # Add new discover device. load_devices() # Delete not exist device. for dev_id in list(hass.data[DOMAIN]['entities']): if dev_id not in hass.data[DATA_DEVICES].keys(): dispatcher_send(hass, SIGNAL_DELETE_ENTITY, dev_id) hass.data[DOMAIN]['entities'].pop(dev_id) track_time_interval(hass, poll_devices_update, timedelta(minutes=15)) hass.services.register(DOMAIN, SERVICE_PULL_DEVICES, poll_devices_update) def force_update(call): """Force all devices to pull data.""" dispatcher_send(hass, SIGNAL_UPDATE_ENTITY) hass.services.register(DOMAIN, SERVICE_FORCE_UPDATE, force_update) return True
def countdown_task(meross_device, meross_channel, meross_email, meross_password, seconds): print("Turn off the device for %s seconds" % seconds) http_handler = MerossHttpClient(email=meross_email, password=meross_password) # get my device by name device = get_device(http_handler, meross_device) if device is not None: channels = device.get_channels() if channels[0] is not None: device.turn_off_channel(channels[int(meross_channel)]) time.sleep(int(seconds)) print("Turn back on the device") device.turn_on_channel(channels[int(meross_channel)])
def get_or_renew_creds(email, password, stored_creds): try: if stored_creds is None: http_client = MerossHttpClient.from_user_password(email=email, password=password) else: http_client = MerossHttpClient(cloud_credentials=stored_creds) # Test device listing. If goes ok, return it immediately http_devices = http_client.list_devices() return http_client.get_cloud_credentials(), http_devices except TokenException: # In case the current token is expired or invalid, let's try to re-login. _LOGGER.warning("Current token has been refused by the Meross Cloud. Trying to generate a new one with " "stored user credentials...") # Build a new client with username/password rather than using stored credentials http_client = MerossHttpClient.from_user_password(email=email, password=password) http_devices = http_client.list_devices() return http_client.get_cloud_credentials(), http_devices
def ConnectAndRefreshAll(email, password): """ Connect to Meross Cloud and refresh all devices and informations """ try: httpHandler = MerossHttpClient(email, password) except: Exit("<F> Error : can't connect to Meross Cloud ! Please verify Internet connection, email and password !") # Retrieves the list of supported devices devices = httpHandler.list_supported_devices() #print(devices) #print(50*'=') # Build dict of devices informations d_devices = {} for num in range(len(devices)): if debug: print(50*'=' + '\nnum=', num) device = devices[num] #if not device._name == 'Meross multi 1': #pprint.pprint(device) #print (device._name) data = device.get_sys_data() if debug: pprint.pprint(data) #pprint.pprint(device) uuid = device._uuid d_devices[uuid] = dict( { 'name': device._name, 'ip': data['all']['system']['firmware']['innerIp'], 'mac': data['all']['system']['hardware']['macAddress'], 'online': data['all']['system']['online']['status'], 'uuid': uuid, 'type': data['all']['system']['hardware']['type'], 'firmversion': data['all']['system']['firmware']['version'], 'hardversion': data['all']['system']['hardware']['version'] } ) # on/off status onoff = [] try: onoff = [ data['all']['control']['toggle']['onoff'] ] except: try: ll = data['all']['digest']['togglex'] onoff = [ x['onoff'] for x in ll ] except: pass d_devices[uuid]['onoff'] = onoff # Current power try: electricity = device.get_electricity() d_devices[uuid]['power'] = electricity['electricity']['power'] except: d_devices[uuid]['power'] = '-1' # Historical consumption try: l_consumption = device.get_power_consumptionX()['consumptionx'] except: l_consumption = [] d_devices[uuid]['consumption'] = [] # on decide de ne pas la stocker # Yesterday consumption today = datetime.today() yesterday = (today - timedelta(1) ).strftime("%Y-%m-%d") d_devices[uuid]['consumption_yesterday'] = -1 for c in l_consumption: if c['date'] == yesterday: try: d_devices[uuid]['consumption_yesterday'] = c['value'] except: d_devices[uuid]['consumption_yesterday'] = -1 break if debug: pprint.pprint(d_devices) # Save dictionnary into Pickle file f = open(pklfile,"wb") pickle.dump(d_devices,f) f.close() # Save dictionnary into JSON file l_devices = list(d_devices.values()) #print(l_devices) with open(jsonfile, 'w') as fp: json.dump(d_devices, fp) return d_devices
def _test_authorization(username, password): client = MerossHttpClient(email=username, password=password) client.get_cloud_credentials()
def ConnectAndSetOnOff(devices, email, password, name=None, uuid=None, mac=None, action='on', channel='0'): """ Connect to Meross Cloud and set on or off a smartplug """ if mac and not name and not uuid: Exit("<F> Error : not implemented !") if not name and not uuid and not mac: Exit( "<F> Error : need at least 'name', 'uuid' or 'mac' parameter to set on or off a smartplug !" ) try: httpHandler = MerossHttpClient(email, password) except: Exit( "<F> Error : can't connect to Meross Cloud ! Please verify Internet connection, email and password !" ) # Retrieves the list of supported devices ldevices = httpHandler.list_supported_devices() device = None for d in ldevices: if (d._uuid == uuid) or (d._name == name): device = d break uuid = d._uuid #pprint.pprint( devices[uuid] ) if len(devices[uuid]['onoff']) == 1: try: if action == 'on': device.turn_on() else: device.turn_off() except: pass else: try: if action == 'on': if channel == '0': device.turn_on() else: device.turn_on_channel(channel) else: if channel == '0': device.turn_off() else: device.turn_off_channel(channel) except: pass devices[d._uuid] = RefreshOneDevice(device) return devices
class MerossManager(object): @classmethod def from_email_and_password(cls, meross_email, meross_password, discovery_interval=30.0, auto_reconnect=True ): cloud_creds = MerossHttpClient.login(email=meross_email, password=meross_password) return MerossManager( cloud_credentials=cloud_creds, discovery_interval=discovery_interval, auto_reconnect=auto_reconnect) def __init__(self, cloud_credentials, discovery_interval, auto_reconnect): self._cloud_creds = cloud_credentials self._http_client = MerossHttpClient(cloud_credentials=self._cloud_creds) self._devices_lock = lock_factory.build_rlock() self._devices = dict() self._event_callbacks_lock = lock_factory.build_rlock() self._event_callbacks = [] # Instantiate the mqtt cloud client self._cloud_client = MerossCloudClient(cloud_credentials=self._cloud_creds, push_message_callback=self._dispatch_push_notification, auto_reconnect=auto_reconnect) self._cloud_client.connection_status.register_connection_event_callback(callback=self._fire_event) self._device_discoverer = None self._stop_discovery = Event() self._device_discovery_done = Event() self._discovery_interval = discovery_interval def list_http_devices(self): """ Performs a listing of Meross Devices as reported by the HTTP API. """ return self._http_client.list_devices() def start(self, wait_for_first_discovery=True): l.debug("Starting manager") # Connect to the mqtt broker self._cloud_client.connect() l.debug("Connection succeeded. Starting discovery...") if self._device_discoverer is None or not self._device_discoverer.is_alive(): self._device_discoverer = Thread(target=self._device_discover_thread) self._device_discoverer.start() if wait_for_first_discovery: l.debug("Caller requested wait-for-first-discovery. Waiting...") self._device_discovery_done.wait() l.debug("Discovery done.") def stop(self, logout=False): l.debug("Stopping manager...") self._cloud_client.close() self._stop_discovery.set() self._device_discoverer.join() if logout: self._http_client.logout() l.debug("Stop done.") def _device_discover_thread(self): while True: try: self._discover_devices(online_only=False) finally: if self._stop_discovery.wait(self._discovery_interval): self._stop_discovery.clear() break def register_event_handler(self, callback): with self._event_callbacks_lock: if callback in self._event_callbacks: pass else: self._event_callbacks.append(callback) def unregister_event_handler(self, callback): with self._event_callbacks_lock: if callback not in self._event_callbacks: pass else: self._event_callbacks.remove(callback) def get_device_by_uuid(self, uuid): self._ensure_started() dev = None with self._devices_lock: dev = self._devices.get(uuid) return dev def get_device_by_name(self, name): self._ensure_started() with self._devices_lock: for k, v in self._devices.items(): if v.name.lower() == name.lower(): return v return None def get_supported_devices(self): self._ensure_started() return [x for k, x in self._devices.items()] def get_devices_by_kind(self, clazz): self._ensure_started() res = [] with self._devices_lock: for k, v in self._devices.items(): if isinstance(v, clazz): res.append(v) return res def get_devices_by_type(self, type_name): self._ensure_started() res = [] with self._devices_lock: for k, v in self._devices.items(): if v.type.lower() == type_name.lower(): res.append(v) return res def _dispatch_push_notification(self, message, from_myself=False): """ When a push notification is received from the MQTT client, it needs to be delivered to the corresponding device. This method serves that scope. :param message: :param from_myself: boolean flag. When True, it means that the message received is related to a previous request issued by this client. When is false, it means the message is related to some other client. :return: """ header = message['header'] # type: dict payload = message['payload'] # type: dict # Identify the UUID of the target device by looking at the FROM field of the message header dev_uuid = header['from'].split('/')[2] # Let's intercept the Bind events: they are useful to trigger new device discovery namespace = header.get('namespace') # TODO: The following has been commented because it may trigger a recursive events-loop. This is not strictly # necessary here, so just avoid doing so. #if namespace is not None and namespace in [BIND, ONLINE]: # self._discover_devices() # Let's find the target of the event so that it can handle accordingly device = None with self._devices_lock: device = self._devices.get(dev_uuid) if device is not None: device.handle_push_notification(namespace, payload, from_myself=from_myself) else: # If we receive a push notification from a device that is not yet contained into our registry, # it probably means a new one has just been registered with the meross cloud. # This should never happen as we handle the "bind" event just above. However, It appears that the report # event is fired before the BIND event. So we need to ignore it at this point if namespace == REPORT: l.info("Ignoring REPORT event from device %s" % dev_uuid) else: l.warn("An event was received from an unknown device, which did not trigger the BIND event. " "Device UUID: %s, namespace: %s." % (dev_uuid, namespace)) def _discover_devices(self, online_only=False): """ Discovers the devices that are visible via HTTP API and update the internal list of managed devices accordingly. :return: """ for dev in self._http_client.list_devices(): online = dev['onlineStatus'] if online_only and online != 1: # The device is not online, so we skip it. continue # If the device we have discovered is not in the list we already handle, we need to add it. discovered = self._handle_device_discovered(dev) # If the specific device is an HUB, add all its sub devices if isinstance(discovered, GenericHub): for subdev in self._http_client.list_hub_subdevices(discovered.uuid): self._handle_device_discovered(dev=subdev, parent_hub=discovered) self._device_discovery_done.set() return self._devices def _handle_device_unbound(self, dev_uuid): with self._devices_lock: if dev_uuid in self._devices: l.info("Unregistering device %s" % dev_uuid) del self._devices[dev_uuid] def _handle_device_discovered(self, dev, parent_hub=None): device = None # Check whether we are dealing with a full device or with a subdevice if 'deviceType' in dev and 'uuid' in dev: # FULL DEVICE case d_type = dev['deviceType'] d_id = dev['uuid'] device_id = d_id with self._devices_lock: if device_id not in self._devices: device = build_wrapper(device_type=d_type, device_uuid=d_id, cloud_client=self._cloud_client, device_specs=dev) self._devices[device_id] = device is_subdevice = False elif 'subDeviceType' in dev and 'subDeviceId' in dev: # SUB DEVICE case d_type = dev['subDeviceType'] d_id = dev['subDeviceId'] device_id = "%s:%s" % (parent_hub.uuid, d_id) with self._devices_lock: if device_id not in self._devices: device = build_subdevice_wrapper(device_type=d_type, device_id=d_id, parent_hub=parent_hub, cloud_client=self._cloud_client, device_specs=dev) self._devices[device_id] = device is_subdevice = True else: l.warn("Discovered device does not seem to be either a full device nor a subdevice.") return if device is not None: # If this device was not in the list before, register the event handler for it and fire the ONLINE event. with self._event_callbacks_lock: for c in self._event_callbacks: device.register_event_callback(c) return device else: # If the device already existed, fire an ONLINE event if the device online status has changed old_dev = self._devices.get(device_id) new_online_status = dev.get('onlineStatus', 2) # TODO: Fix this workaround... # Emulate the push notification payload = {'online': {'status': new_online_status}} old_dev.handle_push_notification(ONLINE, payload) # if device was unchanged, return reference to existing instance return old_dev # TODO: handle subdevices def _fire_event(self, eventobj): for c in self._event_callbacks: try: c(eventobj) except: l.exception("An unhandled error occurred while invoking callback") def _ensure_started(self): if not self._cloud_client.connection_status.check_status(ClientStatus.SUBSCRIBED): l.warn("The manager is not connected to the mqtt broker. Did you start the Meross manager?")
from meross_iot.api import MerossHttpClient import csv, io EMAIL = 'YOUR_EMAIL' PASSWORD = '******' client = MerossHttpClient(email=EMAIL, password=PASSWORD) devices = client.list_supported_devices() def sanitize_personal_info(d): if isinstance(d, dict): for key, value in d.items(): k = key.lower() if isinstance(value, dict): sanitize_personal_info(value) elif isinstance(value, str) and (k == 'uuid' or k == 'macaddress' or k == 'wifimac' or k == 'userid' or k == 'bssid' or k == 'ssid'): d[key] = 'X' elif isinstance(d, list): for k in d: sanitize_personal_info(k) return d if __name__ == '__main__': output = io.StringIO() writer = csv.writer(output, delimiter=';')
def _test_authorization(username, password): client = MerossHttpClient.from_user_password(email=username, password=password) return client.get_cloud_credentials()
class MerossManager(object): # HTTPClient object used to discover devices _http_client = None # Dictionary of devices that are currently handled by this manager # as UUID -> Device _devices = None # Lock item used to protect access to the device collection _devices_lock = None # Cloud credentials to be used against the Meross MQTT cloud _cloud_creds = None _cloud_client = None # List of callbacks that should be called when an event occurs _event_callbacks = None _event_callbacks_lock = None def __init__(self, meross_email, meross_password): self._devices_lock = RLock() self._devices = dict() self._event_callbacks_lock = RLock() self._event_callbacks = [] self._http_client = MerossHttpClient(email=meross_email, password=meross_password) self._cloud_creds = self._http_client.get_cloud_credentials() # Instantiate the mqtt cloud client self._cloud_client = MerossCloudClient(cloud_credentials=self._cloud_creds, push_message_callback=self._dispatch_push_notification) self._cloud_client.connection_status.register_connection_event_callback(callback=self._fire_event) def start(self): # Connect to the mqtt broker self._cloud_client.connect() self._discover_devices() def stop(self): self._cloud_client.close() def register_event_handler(self, callback): with self._event_callbacks_lock: if callback in self._event_callbacks: pass else: self._event_callbacks.append(callback) def unregister_event_handler(self, callback): with self._event_callbacks_lock: if callback not in self._event_callbacks: pass else: self._event_callbacks.remove(callback) def get_device_by_uuid(self, uuid): self._ensure_started() dev = None with self._devices_lock: dev = self._devices.get(uuid) return dev def get_device_by_name(self, name): self._ensure_started() with self._devices_lock: for k, v in self._devices.items(): if v.name.lower() == name.lower(): return v return None def get_supported_devices(self): self._ensure_started() return [x for k, x in self._devices.items()] def get_devices_by_kind(self, clazz): self._ensure_started() res = [] with self._devices_lock: for k, v in self._devices.items(): if isinstance(v, clazz): res.append(v) return res def get_devices_by_type(self, type_name): self._ensure_started() res = [] with self._devices_lock: for k, v in self._devices.items(): if v.type.lower() == type_name.lower(): res.append(v) return res def _dispatch_push_notification(self, message, from_myself=False): """ When a push notification is received from the MQTT client, it needs to be delivered to the corresponding device. This method serves that scope. :param message: :param from_myself: boolean flag. When True, it means that the message received is related to a previous request issued by this client. When is false, it means the message is related to some other client. :return: """ header = message['header'] # type: dict payload = message['payload'] # type: dict # Identify the UUID of the target device by looking at the FROM field of the message header dev_uuid = header['from'].split('/')[2] device = None with self._devices_lock: device = self._devices.get(dev_uuid) if device is not None: namespace = header['namespace'] device.handle_push_notification(namespace, payload, from_myself=from_myself) else: # If we receive a push notification from a device that is not yet contained into our registry, # it probably means a new one has just been registered with the meross cloud. # Therefor, let's retrieve info from the HTTP api. self._discover_devices() def _discover_devices(self, online_only=False): """ Discovers the devices that are visible via HTTP API and update the internal list of managed devices accordingly. :return: """ for dev in self._http_client.list_devices(): online = dev['onlineStatus'] if online_only and online != 1: # The device is not online, so we skip it. continue # If the device we have discovered is not in the list we already handle, we need to add it. discovered = self._handle_device_discovered(dev) # If the specific device is an HUB, add all its sub devices if isinstance(discovered, GenericHub): for subdev in self._http_client.list_hub_subdevices(discovered.uuid): self._handle_device_discovered(dev=subdev, parent_hub=discovered) return self._devices def _handle_device_discovered(self, dev, parent_hub=None): device = None # Check whether we are dealing with a full device or with a subdevice if 'deviceType' in dev and 'uuid' in dev: # FULL DEVICE case d_type = dev['deviceType'] d_id = dev['uuid'] device_id = d_id device = build_wrapper(device_type=d_type, device_uuid=d_id, cloud_client=self._cloud_client, device_specs=dev) elif 'subDeviceType' in dev and 'subDeviceId' in dev: # SUB DEVICE case d_type = dev['subDeviceType'] d_id = dev['subDeviceId'] device_id = "%s:%s" % (parent_hub.uuid, d_id) device = build_subdevice_wrapper(device_type=d_type, device_id=d_id, parent_hub=parent_hub, cloud_client=self._cloud_client, device_specs=dev) else: l.warn("Discovered device does not seem to be either a full device nor a subdevice.") return if device is not None: # Check if the discovered device is already in the list of handled devices. # If not, add it right away. Otherwise, ignore it. is_new = False with self._devices_lock: if d_id not in self._devices: is_new = True self._devices[device_id] = device # If this is new device, register the event handler for it and fire the ONLINE event. if is_new: with self._event_callbacks_lock: for c in self._event_callbacks: device.register_event_callback(c) evt = DeviceOnlineStatusEvent(device, device.online) self._fire_event(evt) return device def _fire_event(self, eventobj): for c in self._event_callbacks: try: c(eventobj) except: l.exception("An unhandled error occurred while invoking callback") def _ensure_started(self): if not self._cloud_client.connection_status.check_status(ClientStatus.SUBSCRIBED): l.warn("The manager is not connected to the mqtt broker. Did you start the Meross manager?")
def setUp(self): self.client = MerossHttpClient(email=EMAIL, password=PASSWORD)
#!/usr/bin/env python3.6 from sys import argv from meross_iot.api import MerossHttpClient mDev = int(argv[1]) mCh = argv[2] # ch 1-2-3-USB mVal = int(argv[3]) # 0 = Off / 1 = On print("parametri:" + argv[1] + " / " + argv[2] + " / " + argv[3]) mConnect = MerossHttpClient(email="YOUR REGISTERED EMAIL", password="******") mDevices = mConnect.list_supported_devices() if mCh != "USB": mCh = int(mCh) if mVal == 0: mDevices[mDev].turn_off_channel(mCh) else: mDevices[mDev].turn_on_channel(mCh) else: if int(mVal) == 0: print("DISABILITA USB") mDevices[mDev].disable_usb() else: print("ABILITA USB") mDevices[mDev].enable_usb()
devices = CLIENT.list_supported_devices() result = [] for device in devices: result.append({ 'name': device._name, 'isOn': device.get_status(0) }) return result elif commandName == 'turn-device-on': for device in CLIENT.list_supported_devices(): if device._name == props['deviceName']: device.turn_on() elif commandName == 'turn-device-off': for device in CLIENT.list_supported_devices(): if device._name == props['deviceName']: device.turn_off() return {} if __name__ == '__main__': CLIENT = MerossHttpClient(email=MEROSS_EMAIL, password=MEROSS_PASSWORD) def handler(data, callback): callback(handleInput(data)) on_message(handler)
import time import sys from meross_iot.api import MerossHttpClient from time import sleep from passwords import * if __name__=='__main__': httpHandler = MerossHttpClient(email=meross_email, password=meross_password) # Retrieves the list of supported devices devices = httpHandler.list_supported_devices() plug = devices[0] while True: print(plug.get_electricity()['electricity']['power']) sleep(1)
from meross_iot.api import MerossHttpClient from meross_iot.supported_devices.power_plugs import GenericPlug from meross_iot.supported_devices.light_bulbs import GenericBulb import secret httpHandler = MerossHttpClient(email=secret.email, password=secret.password) device = httpHandler.list_supported_devices()[0] def turnOn(): device.turn_on_channel(0) def turnOff(): device.turn_off_channel(0) def getPowerConsumption(): return device.get_power_consumption() def getElectricityConsumption(): return device.get_electricity() if __name__ == '__main__': httpHandler = MerossHttpClient(email="*****@*****.**", password="******") print("Listing online devices...")
def setUp(self): self.client = MerossHttpClient.from_user_password(email=EMAIL, password=PASSWORD)