def _main(): global lasttime api = ConnectAPI() api.start_notifications() # calling start_notifications is required for getting/setting resource synchronously devices = api.list_connected_devices().data if not devices: raise Exception("No connected devices registered. Aborting") #selecting latest device for listening for data mainDevice = devices[-1] isActive = True lasttime = time.time() Subscribe(api, mainDevice) #creating threads # thread t: used to start the flask api which serves the phone app t = threading.Thread(target=StartAPI) t.start() # thread t2: used to sum up and guess dominant movement for minute t2 = threading.Thread(target=MinuteToDB) t2.start() #Resubscribe to pelion device if connection appear to be lost (no valid data for 3) while True: time.sleep(1.5) if time.time() - lasttime > 3: #print("Attempt reconnect!") Subscribe(api, mainDevice)
def test_config_invalid_host(self): # regression check - give a sane error for invalid hosts api = ConnectAPI(dict(host='invalid')) with mock.patch('urllib3.PoolManager.request') as mocked: mocked.side_effect = RuntimeError with self.assertRaises(RuntimeError): api.list_connected_devices().next()
def test_autostart_enabled(self): with mock.patch('urllib3.PoolManager.request') as mocked: mocked.return_value = mock.MagicMock() mocked.return_value.status = 200 a = ConnectAPI(dict(autostart_notification_thread=True)) self.assertFalse(a.has_active_notification_thread) a.get_resource_value_async('abc123', '/3/4/5') self.assertTrue(a.has_active_notification_thread)
def test_list_connected(self): # an example: list devices in Pelion Device Management from mbed_cloud import ConnectAPI api = ConnectAPI() # Print all devices for device in api.list_connected_devices(order='asc', max_results=900): print(device.id, device.state)
def Init(self): print("Pelion sync initializing start") self.api = ConnectAPI() self.api.start_notifications() self.devices = api.list_connected_devices().data if not self.devices: return False return True
def test_config_singleton(self): # check two different api configs don't clobber each other a = ConnectAPI(dict(api_key='apple')) b = ConnectAPI(dict(api_key='banana')) api_key = EndpointsApi self.assertEqual(a.apis[api_key].api_client.configuration.api_key, {'Authorization': 'apple'}) self.assertEqual(b.apis[api_key].api_client.configuration.api_key, {'Authorization': 'banana'})
def test_autostart_disabled(self): with mock.patch('urllib3.PoolManager.request') as mocked: mocked.return_value = mock.MagicMock() mocked.return_value.status = 200 a = ConnectAPI(dict(autostart_notification_thread=False)) self.assertFalse(a.has_active_notification_thread) with self.assertRaises(CloudUnhandledError) as e: a.get_resource_value_async('abc123', '/3/4/5') self.assertFalse(a.has_active_notification_thread) self.assertIn('notifications thread', str(e.exception))
def _main(): api = ConnectAPI() # calling start_notifications is required for getting/setting resource synchronously api.start_notifications() devices = api.list_connected_devices().data if not devices: raise Exception("No connected devices registered. Aborting") # Synchronously get the initial/current value of the resource while True: value = api.get_resource_value(devices[0].id, BUTTON_RESOURCE) _current_val(value) val1 = value.encode() e1 = f.encrypt(val1) os.system("mosquitto_pub -h localhost -t temp -m " + str(e1) + " -u \"roy\" -P \"roy\"") value2 = api.get_resource_value(devices[0].id, BUTTON_RESOURCE2) _current_val2(value2) val2 = value2.encode() e2 = f.encrypt(val2) os.system("mosquitto_pub -h localhost -t heart -m " + str(e2) + " -u \"roy\" -P \"roy\"") a = [[float(value), float(value2)]] predict_from_joblib = joblib.load('/home/roy/disco/predict.pkl') b = predict_from_joblib.predict(a) pre = b[0] print(pre) os.system("mosquitto_pub -h localhost -t predict -m " + str(pre)) # Register a subscription for new values api.add_resource_subscription_async(devices[0].id, BUTTON_RESOURCE, _subscription_handler)
def test(self): api = ConnectAPI() device = api.list_connected_devices().first() start = threading.Event() threads = [] for i in range(20): t = threading.Thread(target=worker, args=(i, start, api, device, 100)) t.daemon = True t.start() threads.append(t) start.set() [t.join() for t in threads]
def _main(): api = ConnectAPI() # Print devices that matches filter filters = { 'created_at': { '$gte': datetime.datetime(2017, 1, 1), '$lte': datetime.datetime(2017, 12, 31) } } devices = api.list_connected_devices(order='asc', filters=filters) for idx, device in enumerate(devices): print(device)
def test_subscribe_resources(self): import logging logging.basicConfig(level=logging.DEBUG) # an example: subscribing to resource value changes # creates an Observer listening to resource value changes for devices # whose id starts with `016` and resource paths start with `/3/0/` from mbed_cloud import ConnectAPI api = ConnectAPI() # prepare a channel channel = api.subscribe.channels.ResourceValues(device_id='016*', resource_path='/3/0/*') # start listening for updates observer = api.subscribe(channel) # on the first update for the channel, block for the specified timeout print(observer.next().block(timeout=120000))
def test_get_and_set_resource_value(self): # an example: get and set a resource value from mbed_cloud.foundation import Device from mbed_cloud import ApiFilter from mbed_cloud.foundation.enums import DeviceStateEnum from mbed_cloud import ConnectAPI # Use the Foundation interface to find a registered device. api_filter = ApiFilter() api_filter.add_filter("state", "eq", DeviceStateEnum.REGISTERED) device = Device().list(max_results=2, filter=api_filter).next() # Use the Legacy interface to find resources connect_api = ConnectAPI() # Find an observable resource for resource in connect_api.list_resources(device.id): if resource.observable: break # Set a resource value connect_api.set_resource_value(device.id, resource.path, "12") # Get a resource value value = connect_api.get_resource_value(device.id, resource.path) print("Device %s, path %s, current value: %s" %(device.id, resource.path, value)) # end of example connect_api.stop_notifications()
def _main(): api = ConnectAPI() devices = api.list_connected_devices().data if len(devices) == 0: raise Exception("No endpints registered. Aborting") # Delete device subscriptions api.delete_device_subscriptions(devices[0].id) # First register to webhook api.update_webhook("https://mbed-iot.herokuapp.com/webhook/") time.sleep(2) api.add_resource_subscription(devices[0].id, BUTTON_RESOURCE)
def setUpClass(cls): cls.api = ConnectAPI() # some arbitrary period cls.metrics = cls.api.list_metrics( start=start, end=end, )
def setup(self): # Check if API key is in environmental vars if 'MBED_CLOUD_SDK_API_KEY' in os.environ: api_key = (os.environ[str('MBED_CLOUD_SDK_API_KEY')]) else: api_key = self.config.get("api_key") if not api_key.startswith('ak_'): raise TestStepFail( "No API key in MBED_CLOUD_SDK_API_KEY or in pelion.tc_cfg") self.device_id = self.config.get("device_id") host = self.config.get("host") self.test_config = {"api_key": api_key, "host": host} self.account_api = AccountManagementAPI(self.test_config) self.connect_api = ConnectAPI(self.test_config) self.device_api = DeviceDirectoryAPI(self.test_config) # Additional parameters for handling REST requests without SDK self.rest_headers = {'Authorization': 'Bearer ' + api_key} self.rest_address = self.config.get("host") # Init delay due to internal usage of PULL notification in SDK. Notications might be lost between # tests. # TODO: Remove workaround after limitation in SDK has been fixed. self.delay(5)
def test_no_config_default(self): with TempConf(dict(api_key=self.dummy_key)): # when we get a config object, force it not to look at existing paths (to see what it defaults to) with mock.patch.object(Config, attribute='paths') as mocked: mocked.return_value = [os.environ.get("MBED_CLOUD_SDK_CONFIG")] a = ConnectAPI(dict(api_key=self.dummy_key)) self.assertIn('api.us-east-1', a.apis[EndpointsApi].api_client.configuration.host)
def _main(): api = ConnectAPI() # Print all devices for idx, device in enumerate( api.list_connected_devices(order='desc', limit=10)): resources = api.list_resources(device.id) # Print endpoint name header header = device.id print(header) print(len(header) * "-") for r in resources: print("\t- %s (%s / Observable: %s)" % (r.path, r.type if r.type else "-", r.observable)) # Space between endpoints print("")
def test_subscribe_device_state(self): # an example: subscribing to device state changes # creates an Observer listening to device state changes for devices # whose id starts with `016` from mbed_cloud import ConnectAPI api = ConnectAPI() # prepare a channel channel = api.subscribe.channels.DeviceStateChanges( device_id='016*', # here, `channel` refers to the filterable device state received from # the notification system channel=[ api.subscribe.channels.ChannelIdentifiers.registrations, api.subscribe.channels.ChannelIdentifiers.registrations_expired ] ) # start listening for updates observer = api.subscribe(channel) # on the first update for the channel, block for the specified timeout print(observer.next().block(timeout=120000))
def test_subscribe(self): # an example: subscribe to resource values from mbed_cloud import ConnectAPI # Create an instance of the Connect API connect_api = ConnectAPI() # Configure a subscription to receive resource value changes on all devices channel = connect_api.subscribe.channels.ResourceValues(device_id="*") # Contact Pelion Device Management to actually make the configured subscription observer = connect_api.subscribe(channel) # Print the subscription notifications received while True: print(observer.next().block()) # end of example break connect_api.subscribe.unsubscribe_all()
def _main(): api = ConnectAPI() header = "Get statistics from the last 30 days in 1 day interval" print("%s\n%s" % (header, len(header) * "-")) metrics = list(api.list_metrics(interval="1d", period="30d")) for idx, metric in enumerate(metrics): print(metric) header = "Get statistics from the last 2 days in 3 hours interval" print("%s\n%s" % (header, len(header) * "-")) metrics = list(api.list_metrics(interval="3h", period="2d")) for idx, metric in enumerate(metrics): print(metric) header = "Get statistics from 1 March 2017 to 1 April 2017" print("%s\n%s" % (header, len(header) * "-")) start = datetime(2017, 3, 1, 0, 0, 0) end = datetime(2017, 4, 1, 0, 0, 0) metrics = list(api.list_metrics(interval="1d", start=start, end=end)) for idx, metric in enumerate(metrics): print(metric)
def test_config_file_from_env(self): # fully define a config at a custom location, and verify it is loaded with TempConf(dict(api_key=self.dummy_key, host=self.dummy_host)): c = Config() self.assertEqual(self.dummy_key, c.get('api_key')) self.assertIn('dummy_host_url', c['host']) # verify custom config reaches the internal api a = ConnectAPI() self.assertIn( self.dummy_key, str(a.apis[EndpointsApi].api_client.configuration.api_key))
def _run_async(): api = ConnectAPI() api.start_notifications() devices = api.list_connected_devices().data if not devices: raise Exception("No devices registered. Aborting") current_value = None while True: async_resp = api.get_resource_value_async(devices[0].id, BUTTON_RESOURCE) # Busy wait - block the thread and wait for the response to finish. while not async_resp.is_done: time.sleep(0.1) # Check if we have a async error response, and abort if it is. if async_resp.error: raise Exception("Got async error response: %r" % async_resp.error) # Get the value from the async response, as we know it's done and it's not # an error. new_value = async_resp.value # Print new value to user, if it has changed. if current_value != new_value: print("Current value: %r" % (new_value, )) # Save new current value current_value = new_value
def _main(): # Setup API config #try: # result = subprocess.check_output(["mbed", "config", "--list"], stderr=subprocess.STDOUT) #except Exception: # self.logger.prn_err("ERROR: CLOUD_SDK_API_KEY global config is not set. ") # return -1 # #match = re.search(b'CLOUD_SDK_API_KEY=(.*)\n', result) #if match == None: # self.logger.prn_err("ERROR: CLOUD_SDK_API_KEY global config is not set.") # return -1 # #api_key_val = match.group(1).strip() #api_config = {"api_key" : api_key_val, "host" : "https://api.us-east-1.mbedcloud.com"} # #print(api_config) # # Instantiate Device and Connect API api = ConnectAPI() # Print all devices for idx, device in enumerate( api.list_connected_devices(order='desc', limit=10)): resources = api.list_resources(device.id) # Print endpoint name header header = device.id print(header) print(len(header) * "-") for r in resources: print("\t- %s (%s / Observable: %s)" % (r.path, r.type if r.type else "-", r.observable)) # Space between endpoints print("")
class PelionSync(): devices = None api = None value = dict() def Init(self): print("Pelion sync initializing start") self.api = ConnectAPI() self.api.start_notifications() self.devices = api.list_connected_devices().data if not self.devices: return False return True def Query(self): self.devices = api.list_connected_devices().data for device in devices: try: hat = Hat.objects.get(device_id=device.id) except: print("New device id!:{}\nAdd new hat!".format(device.id)) hat = Hat.objects.create(device_id=device.id) sv = SensorValue.objects.create(owner = hat,\ temperature = api.get_resource_value(device.id, "/3303/0/5700"),\ humid = api.get_resource_value(device.id, "/3304/0/5700"), \ accelX = api.get_resource_value(device.id, "/3313/0/5702"), \ accelY = api.get_resource_value(device.id, "/3313/0/5703"), \ accelZ = api.get_resource_value(device.id, "/3313/0/5704"), \ pressure = api.get_resource_value(device.id, "/3323/0/5700"), \ distance = api.get_resource_value(device.id, "/3330/0/5700"), \ gyroX = api.get_resource_value(device.id, "/3334/0/5702"), \ gyroY = api.get_resource_value(device.id, "/3334/0/5703"), \ gyroZ = api.get_resource_value(device.id, "/3334/0/5704"), \ gps_lat = api.get_resource_value(device.id, "/3336/0/5702"), \ gps_lng = api.get_resource_value(device.id, "/3336/0/5703"), \ gps_alt = api.get_resource_value(device.id, "/3336/0/5704"), \ voc = api.get_resource_value(device.id, "/10313/0/5700"), \ air_quality = api.get_resource_value(device.id, "/10313/0/5701"))
def _main(): api = ConnectAPI() api.start_notifications() devices = api.list_connected_devices().data if not devices: raise Exception("No connected devices registered. Aborting") value = api.get_resource_value(devices[0].id, POPUP_IOT_RESOURCE) queue = api.add_resource_subscription(devices[0].id, POPUP_IOT_RESOURCE) while True: print("Current value: %r" % (value, )) value = queue.get(timeout=30)
def pull_resource_values(device_id, database, table): import pytd import pandas as pd from mbed_cloud import ConnectAPI from prestodb.exceptions import PrestoUserError # see PDM Python client ConnectAPI examples: # https://www.pelion.com/docs/device-management/current/mbed-cloud-sdk-python/subscriptions.html # https://github.com/ARMmbed/mbed-cloud-sdk-python/blob/c2bc539856cc6932e367ed47f7c2e64ef6e3a77a/examples/connect/notifications.py#L25-L45 api = ConnectAPI({ 'api_key': os.environ.get('PDM_API_KEY'), 'host': os.environ.get('PDM_HOST') }) # check device existence try: filters = {'id': {'$eq': device_id}} api.list_connected_devices(filters=filters).data except Exception: raise ValueError('cannot find the device: {}'.format(device_id)) column_names, row = [], [] for r in api.list_resources(device_id): # observable resources whose values can change over time: # https://www.pelion.com/docs/device-management/current/connecting/collecting-resources.html if r.type is None or not r.observable: continue try: value = api.get_resource_value(device_id, r.path) except Exception as e: print('skipped resource path {} due to {}'.format(r.path, e)) continue value = _cast(value) row.append(value) column_names.append(r.type) print('path: {}, type: {}, value: {}'.format(r.path, r.type, value)) if len(row) == 0: sys.exit("no resource values from device: {}".format(device_id)) client = pytd.Client(apikey=os.environ.get('TD_API_KEY'), endpoint=os.environ.get('TD_API_SERVER'), database=database) df = pd.DataFrame(**{'columns': column_names, 'data': [row]}) try: client.load_table_from_dataframe(df, table, writer='insert_into', if_exists='append') except PrestoUserError: raise RuntimeError("inserted record does not match to current schema " "of table `{}`. Make sure a list of available " "resources is same as previous execution, or " "change `writer` to `spark` or `bulk_import` to " "take advantage of schemaless record insertion." "".format(table))
def _main(): api = ConnectAPI() # calling start_notifications is required for getting/setting resource synchronously api.start_notifications() devices = api.list_connected_devices().data if not devices: raise Exception("No connected devices registered. Aborting") # Synchronously get the initial/current value of the resource value = api.get_resource_value(devices[0].id, WRITEABLE_RESOURCE) print("Current value: %r" % (value, )) # Set Resource value. Resource needs to have type == "writable_resource" api.set_resource_value(device_id=devices[0].id, resource_path=WRITEABLE_RESOURCE, resource_value='10') # Synchronously get the current value of the resource value = api.get_resource_value(devices[0].id, WRITEABLE_RESOURCE) print("Current value: %r" % (value, ))
def test_config_from_envvar(self): # fully define a config at a custom location # as well as setting config through environment with TempConf(dict(api_key='not this one', host=self.dummy_host)): os.environ.setdefault(configuration.ENVVAR_API_KEY, self.dummy_key) c = Config() self.assertEqual(self.dummy_key, c.get('api_key')) self.assertIn('dummy_host_url', c['host']) # verify custom config reaches the internal api a = ConnectAPI() self.assertIn( self.dummy_key, str(a.apis[EndpointsApi].api_client.configuration.api_key))
def _main(): api = ConnectAPI() # calling start_notifications is required for getting/setting resource synchronously api.start_notifications() devices = api.list_connected_devices().data if not devices: raise Exception("No connected devices registered. Aborting") # Synchronously get the initial/current value of the resource value = api.get_resource_value(devices[0].id, BUTTON_RESOURCE) _current_val(value) # Register a subscription for new values api.add_resource_subscription_async(devices[0].id, BUTTON_RESOURCE, _subscription_handler) # Run forever while True: pass
def _main(): api = ConnectAPI() api.start_notifications() devices = api.list_connected_devices().data if not devices: raise Exception("No connected devices registered. Aborting") # Synchronously get the initial/current value of the resource value = api.get_resource_value(devices[0].id, BUTTON_RESOURCE) # Register a subscription for new values api.set_resource_value(device_id=devices[0].id, resource_path=WRITEABLE_RESOURCE, resource_value='10') queue = api.add_resource_subscription(devices[0].id, BUTTON_RESOURCE) while True: # Print the current value print("Current value: %r" % (value, )) # Get a new value, using the subscriptions value = queue.get(timeout=30)