def handleTelemetry(self): """ handle the Telemetry """ #humidityVal = self.humiditySensorSimTask.getTelemetryValue() #pressureVal = self.pressureSensorSimTask.getTelemetryValue() #tempVal = self.temperatureSensorSimTask .getTelemetryValue() configUtil = ConfigUtil() if self.useEmulator : if configUtil.getBoolean(section= ConfigConst.CONSTRAINED_DEVICE, key= ConfigConst.ENABLE_SENSE_HAT_KEY): humiditySd = self.humidityI2cSensorAdapterTask.generateTelemetry() pressureSd = self.pressureI2cSensorAdapterTask.generateTelemetry() tempSd = self.temperatureI2cSensorAdapterTask.generateTelemetry() else: humiditySd = self.humidityEmulator.generateTelemetry() pressureSd = self.pressureEmulator.generateTelemetry() tempSd = self.temperatureEmulator .generateTelemetry() soilHumiditySd = self.soilHumidityEmulator.generateTelemetry() else : humiditySd = self.humiditySensorSimTask.generateTelemetry() pressureSd = self.pressureSensorSimTask.generateTelemetry() tempSd = self.temperatureSensorSimTask .generateTelemetry() if self.dataMsgListener : self.dataMsgListener.handleSensorMessage(humiditySd) self.dataMsgListener.handleSensorMessage(pressureSd) self.dataMsgListener.handleSensorMessage(tempSd) self.dataMsgListener.handleSensorMessage(soilHumiditySd) logging.info(' >>>>>>>>> Humidity is < %s >, SoilHumidity is <%s>, Pressure is < %s >, Temperature is < %s >.', str(humiditySd.getValue()), str(soilHumiditySd.getValue()), str(pressureSd.getValue()), str(tempSd.getValue()))
def __init__(self, enableMqtt: bool = True, enableCoap: bool = False): # set enable connection self.enableMqtt = enableMqtt self.enableCoap = enableCoap # load config self.configUtil = ConfigUtil() self.enableEmulator = self.configUtil.getBoolean(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_EMULATOR_KEY) self.stepmotor = StepMotorAdapterTask() # create system Perf manager self.sysPerfManager = SystemPerformanceManager() # set sensor config self.sam = SensorAdapterManager(useEmulator=self.enableEmulator) #set actuator config self.aam = ActuatorAdapterManager(useEmulator=self.enableEmulator) #set data generation config self.enableHandleTempChangeOnDevice = self.configUtil.getBoolean(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_HANDLE_TEMP_CHANGE_ON_DEVICE_KEY) self.triggerHvacTempFloor = self.configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TRIGGER_HVAC_TEMP_FLOOR_KEY); self.triggerHvacTempCeiling = self.configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TRIGGER_HVAC_TEMP_CEILING_KEY); #self.stepmotor.moveTo(-40,-40,True) # set Mqtt client if enableMqtt is True: self.mqttClient = MqttClientConnector() #self.mqttClient.subscribeToTopic(ResourceNameEnum.CDA_ACTUATOR_RESPONSE_RESOURCE.value) #self.mqttClient.subscribeToTopic(ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE.value) self.mqttClient.subscribeToTopic("ProgrammingIoT/StepMotor/Instruction") #self.mqttClient.mc.message_callback_add(callback=self.actuatorCallBack, sub=ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE.value) self.mqttClient.mc.message_callback_add(callback=self.stepMotorCallBack, sub="ProgrammingIoT/StepMotor/Instruction")
def __init__(self): configUtil = ConfigUtil() self.cpuUtilPct = None self.memUtilPct = None self.pollRate = configUtil.getInteger( section=ConfigConst.CONSTRAINED_DEVICE, key=ConfigConst.POLL_CYCLES_KEY, defaultVal=ConfigConst.DEFAULT_POLL_CYCLES) self.locationID = configUtil.getProperty( section=ConfigConst.CONSTRAINED_DEVICE, key=ConfigConst.DEVICE_LOCATION_ID_KEY, defaultVal=ConfigConst.NOT_SET) if self.pollRate <= 0: self.pollRate = ConfigConst.DEFAULT_POLL_CYCLES self.scheduler = BackgroundScheduler() self.scheduler.add_job(self.handleTelemetry(), 'interval', seconds=self.pollRate) self.cpuUtilTask = SystemCpuUtilTask() self.memUtilTask = SystemMemUtilTask() self.dataMsgListener = None # self.memUtilPct = None # self.cpuUtilPct = None logging.info("Initializing SystemPerformance Manager...")
def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing MqttClientConnector class...") self.cfg = ConfigUtil() self.mcc = MqttClientConnector()
def __init__(self, dataSet = None): super(PressureSensorEmulatorTask, self).__init__(SensorData.PRESSURE_SENSOR_TYPE, minVal = SensorDataGenerator.LOW_NORMAL_ENV_PRESSURE, maxVal = SensorDataGenerator.HI_NORMAL_ENV_PRESSURE) configUtil = ConfigUtil() #get ENABLE_SENSE_HAT_KEY value (bool) enableSenseHAT = configUtil.getBoolean(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_SENSE_HAT_KEY) if enableSenseHAT is False: enableEmulation = True else: enableEmulation = False # create senseHAT instance self.sh = SenseHAT(emulate=enableEmulation)
def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing ActuatorAdapterManager class...") self.configUtil = ConfigUtil() self.enableEmulator = self.configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_EMULATOR_KEY) self.defaultMsgListener = DefaultDataMessageListener() self.actuatorAdapterMgr = ActuatorAdapterManager( useEmulator=self.enableEmulator) self.actuatorAdapterMgr.setDataMessageListener(self.defaultMsgListener)
def __init__(self): super(HumidifierEmulatorTask, self).__init__(actuatorType = ActuatorData.HUMIDIFIER_ACTUATOR_TYPE, simpleName = "HUMIDIFIER") # Create an instance of SenseHAT and set the emulate flag to True if running the emulator, or False if using real hardware # This can be read from ConfigUtil using the ConfigConst.CONSTRAINED_DEVICE section and the ConfigConst.ENABLE_SENSE_HAT_KEY # If the ConfigConst.ENABLE_SENSE_HAT_KEY is False, set the emulate flag to True, otherwise set to False configUtil = ConfigUtil() #get ENABLE_SENSE_HAT_KEY value (bool) enableSenseHAT = configUtil.getBoolean(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_SENSE_HAT_KEY) if enableSenseHAT is False: enableEmulation = True else: enableEmulation = False # create senseHAT instance self.sh = SenseHAT(emulate=enableEmulation)
def __init__(self, enableMqtt: bool = True, enableCoap: bool = False): self.sysPerfManager = SystemPerformanceManager() self.sensorAdapterManager = SensorAdapterManager() self.actuatorAdapterManager = ActuatorAdapterManager() self.configUtil = ConfigUtil() self.enableHandleTempChangeOnDevice = self.configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_HANDLE_TEMP_CHANGE_ON_DEVICE_KEY) self.triggerHvacTempFloor = self.configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TRIGGER_HVAC_TEMP_FLOOR_KEY) self.triggerHvacTempCeiling = self.configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TRIGGER_HVAC_TEMP_CEILING_KEY)
def setUpClass(self): logging.basicConfig(format = '%(asctime)s:%(module)s:%(levelname)s:%(message)s', level = logging.DEBUG) logging.info("Running DataIntegrationTest test cases...") encodeToUtf8 = False self.dataUtil = DataUtil(encodeToUtf8) self.cdaDataPath = ConfigUtil().getProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEST_CDA_DATA_PATH_KEY) self.gdaDataPath = ConfigUtil().getProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEST_GDA_DATA_PATH_KEY) if not os.path.exists(self.cdaDataPath): logging.info("================================================") logging.info("DataIntegrationTest - path needs to be created: " + self.cdaDataPath) os.makedirs(self.cdaDataPath, exist_ok = True)
def __init__(self): """ Initialization of class. Create an instance of HvacEmulatorTask """ super(SprinklerMasterEmulatorTask, self).__init__(actuatorType = ActuatorData.SPRINKLER_MASTER_ACTUATOR_TYPE, simpleName = "SPRI_MASTER") # Create an instance of SenseHAT and set the emulate flag to True if running the emulator, or False if using real hardware # This can be read from ConfigUtil using the ConfigConst.CONSTRAINED_DEVICE section and the ConfigConst.ENABLE_SENSE_HAT_KEY # If the ConfigConst.ENABLE_SENSE_HAT_KEY is False, set the emulate flag to True, otherwise set to False configUtil = ConfigUtil() if configUtil.getBoolean(section= ConfigConst.CONSTRAINED_DEVICE, key= ConfigConst.ENABLE_SENSE_HAT_KEY): enableEmulation = False else: enableEmulation = True self.sh = SenseHAT(emulate = enableEmulation)
class SensorAdapterManagerTest(unittest.TestCase): """ This test case class contains very basic unit tests for SensorAdapterManager. It should not be considered complete, but serve as a starting point for the student implementing additional functionality within their Programming the IoT environment. """ @classmethod def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing SensorAdapterManager class...") self.configUtil = ConfigUtil() self.enableEmulator = self.configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_EMULATOR_KEY) self.defaultMsgListener = DefaultDataMessageListener() self.sensorAdapterMgr = SensorAdapterManager( useEmulator=self.enableEmulator) self.sensorAdapterMgr.setDataMessageListener(self.defaultMsgListener) def setUp(self): pass def tearDown(self): pass def testStartAndStopManager(self): self.sensorAdapterMgr.startManager() sleep(20) self.sensorAdapterMgr.stopManager()
def __init__(self): """ Constructor of HvacEmulatorTask. Init emulated or not SenseHAT instance according to config. """ super(HvacEmulatorTask, self).__init__(actuatorType=ActuatorData.HVAC_ACTUATOR_TYPE, simpleName=ConfigConst.HVAC_ACTUATOR_NAME) self.enableEmulation = True configUtil = ConfigUtil() enableSenseHAT = configUtil.getBoolean(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_SENSE_HAT_KEY) if enableSenseHAT is True: self.enableEmulation = False else: self.enableEmulation = True self.sh = SenseHAT(emulate=self.enableEmulation) pass pass
def __init__(self): self.dataUtil = DataUtil() self.configUtil = ConfigUtil() self.host = self.configUtil.getProperty( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.HOST_KEY) self.port = self.configUtil.getInteger( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.PORT_KEY) self.enableCrypt = self.configUtil.getBoolean( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.ENABLE_CRYPT_KEY) if self.enableCrypt: self.credFilePath = self.configUtil.getProperty( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.CRED_FILE_KEY) # TODO: init redis with encryption logging.info("Redis client setting: host = {0}, port = {1}.".format( self.host, self.port)) # Init with no connection established self.curConnection: redis.client.Redis = None
def __init__(self, dataSet = None): """ Initialization of class. Create an instance of TemperatureSensorEmulatorTask """ # Create an instance of SenseHAT and set the emulate flag to True if running the emulator, or False if using real hardware # This can be read from ConfigUtil using the ConfigConst.CONSTRAINED_DEVICE section and the ConfigConst.ENABLE_SENSE_HAT_KEY # If the ConfigConst.ENABLE_SENSE_HAT_KEY is False, set the emulate flag to True, otherwise set to False super(TemperatureSensorEmulatorTask, self).__init__(SensorData.TEMP_SENSOR_TYPE, minVal = SensorDataGenerator.LOW_NORMAL_ENV_TEMP, maxVal = SensorDataGenerator.HI_NORMAL_ENV_TEMP) configUtil = ConfigUtil() if configUtil.getBoolean(section= ConfigConst.CONSTRAINED_DEVICE, key= ConfigConst.ENABLE_SENSE_HAT_KEY): enableEmulation = False else: enableEmulation = True self.sh = SenseHAT(emulate = enableEmulation)
def __init__(self, dataSet=None): super(HumiditySensorEmulatorTask, self).__init__( SensorData.HUMIDITY_SENSOR_TYPE, minVal=SensorDataGenerator.LOW_NORMAL_ENV_HUMIDITY, maxVal=SensorDataGenerator.HI_NORMAL_ENV_HUMIDITY) # Create an instance of SenseHAT and set the emulate flag to True if running the emulator, or False if using real hardware # This can be read from ConfigUtil using the ConfigConst.CONSTRAINED_DEVICE section and the ConfigConst.ENABLE_SENSE_HAT_KEY # If the ConfigConst.ENABLE_SENSE_HAT_KEY is False, set the emulate flag to True, otherwise set to False configUtil = ConfigUtil() #get ENABLE_SENSE_HAT_KEY value (bool) enableSenseHAT = configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_SENSE_HAT_KEY) if enableSenseHAT is False: enableEmulation = True else: enableEmulation = False #create senseHAT instance self.sh = SenseHAT(emulate=enableEmulation)
class ActuatorAdapterManagerTest(unittest.TestCase): """ This test case class contains very basic unit tests for ActuatorSimAdapterManager. It should not be considered complete, but serve as a starting point for the student implementing additional functionality within their Programming the IoT environment. """ @classmethod def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing ActuatorAdapterManager class...") self.configUtil = ConfigUtil() self.enableEmulator = self.configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_EMULATOR_KEY) self.defaultMsgListener = DefaultDataMessageListener() self.actuatorAdapterMgr = ActuatorAdapterManager( useEmulator=self.enableEmulator) self.actuatorAdapterMgr.setDataMessageListener(self.defaultMsgListener) def setUp(self): pass def tearDown(self): pass def testHumidifierSimulation(self): ad = ActuatorData(actuatorType=ActuatorData.HUMIDIFIER_ACTUATOR_TYPE) ad.setValue(50.0) ad.setCommand(ActuatorData.COMMAND_ON) self.actuatorAdapterMgr.sendActuatorCommand(ad) ad.setCommand(ActuatorData.COMMAND_OFF) self.actuatorAdapterMgr.sendActuatorCommand(ad) def testHvacSimulation(self): ad = ActuatorData(actuatorType=ActuatorData.HVAC_ACTUATOR_TYPE) ad.setValue(22.5) ad.setCommand(ActuatorData.COMMAND_ON) self.actuatorAdapterMgr.sendActuatorCommand(ad) ad.setCommand(ActuatorData.COMMAND_OFF) self.actuatorAdapterMgr.sendActuatorCommand(ad) def testLEDSimulation(self): ad = ActuatorData(actuatorType=ActuatorData.LED_DISPLAY_ACTUATOR_TYPE) ad.setStateData(stateData="Test stateData") ad.setCommand(ActuatorData.COMMAND_ON) self.actuatorAdapterMgr.sendActuatorCommand(ad) ad.setCommand(ActuatorData.COMMAND_OFF) self.actuatorAdapterMgr.sendActuatorCommand(ad)
def __init__(self, dataSet=None): """ Constructor of PressureSensorEmulatorTask Using super class constructor to init :param dataSet: Dict for construct object with given data """ super(PressureSensorEmulatorTask, self).__init__( sensorType=SensorData.PRESSURE_SENSOR_TYPE, dataSet=dataSet, minVal=SensorDataGenerator.LOW_NORMAL_ENV_PRESSURE, maxVal=SensorDataGenerator.HI_NORMAL_ENV_PRESSURE) self.enableEmulation = True configUtil = ConfigUtil() enableSenseHAT = configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_SENSE_HAT_KEY) if enableSenseHAT is True: self.enableEmulation = False else: self.enableEmulation = True self.sh = SenseHAT(emulate=self.enableEmulation) pass
def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.INFO) logging.info("Testing CoapClientConnector class...") self.dataMsgListener = DefaultDataMessageListener() self.pollRate = ConfigUtil().getInteger( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.POLL_CYCLES_KEY, ConfigConst.DEFAULT_POLL_CYCLES) self.coapClient = CoapClientConnector()
def __init__(self): """ Use the ConfigUtil configuration information for the CoAP Gateway to retrieve the host and port information. """ self.config = ConfigUtil() self.dataMsgListener = None self.coapClient = None self.host = self.config.getProperty(ConfigConst.COAP_GATEWAY_SERVICE, ConfigConst.HOST_KEY, ConfigConst.DEFAULT_HOST) self.port = self.config.getInteger(ConfigConst.COAP_GATEWAY_SERVICE, ConfigConst.PORT_KEY, ConfigConst.DEFAULT_COAP_PORT) logging.info('\tCoAP Server Host: ' + self.host) logging.info('\tCoAP Server Port: ' + str(self.port)) """ Validate the url information """ self.url = "coap://" + self.host + ":" + str(self.port) + "/" try: logging.info("Parsing URL: " + self.url) self.host, self.port, self.path = parse_uri(self.url) tmpHost = socket.gethostbyname(self.host) if tmpHost: self.host = tmpHost self._initClient() else: logging.error("Can't resolve host: " + self.host) except socket.gaierror: logging.info("Failed to resolve host: " + self.host) self._initClient()
def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.INFO) logging.info( "Testing CoapServerAdapter and CoapClientConnector classes...") self.dataMsgListener = DefaultDataMessageListener() self.pollRate = ConfigUtil().getInteger( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.POLL_CYCLES_KEY, ConfigConst.DEFAULT_POLL_CYCLES) self.coapClient = CoapClientConnector() self.coapServer = CoapServerAdapter( dataMsgListener=self.dataMsgListener) self.tempDataUpdateListener = GetTelemetryResourceHandler() self.sysPerfDataUpdateListener = GetSystemPerformanceResourceHandler() # add these CoAP resource handlers as listeners to the IDataMessageListener impl self.dataMsgListener.setTelemetryDataListener( ConfigConst.TEMP_SENSOR_NAME, self.tempDataUpdateListener) self.dataMsgListener.setSystemPerformanceDataListener( self.sysPerfDataUpdateListener) # add these CoAP resource handlers to the CoAP server self.coapServer.addResource( \ ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, \ ConfigConst.TEMP_SENSOR_NAME, \ self.tempDataUpdateListener) self.coapServer.addResource( \ ResourceNameEnum.CDA_SYSTEM_PERF_MSG_RESOURCE, \ ConfigConst.SYSTEM_PERF_NAME, \ self.sysPerfDataUpdateListener) # create a scheduler to update system perf data and temp sensor data at pollCycles self.scheduler = BackgroundScheduler() self.scheduler.add_job(self._updateTelemetry, 'interval', seconds=self.pollRate) # start the server and the scheduled data updater self.coapServer.startServer() self.scheduler.start()
def __init__(self, name=ConfigConst.NOT_SET, typeID=ConfigConst.DEFAULT_TYPE_ID, d=None): """ Constructor. @param d Defaults to None. The data (dict) to use for setting all parameters. It's provided here as a convenience - mostly for testing purposes. The utility in DataUtil should be used instead. """ self.updateTimeStamp() self.hasError = False useDefaults = True if d: try: self.name = d[ConfigConst.NAME_PROP] self.typeID = d[ConfigConst.TYPE_ID_PROP] self.statusCode = d[ConfigConst.STATUS_CODE_PROP] self.latitude = d[ConfigConst.LATITUDE_PROP] self.longitude = d[ConfigConst.LONGITUDE_PROP] self.elevation = d[ConfigConst.ELEVATION_PROP] useDefaults = False except: pass if useDefaults: self.name = name self.typeID = typeID self.statusCode = ConfigConst.DEFAULT_STATUS self.latitude = ConfigConst.DEFAULT_LAT self.longitude = ConfigConst.DEFAULT_LON self.elevation = ConfigConst.DEFAULT_ELEVATION if not self.name: self.name = ConfigConst.NOT_SET # always pull location ID from configuration file self.locationID = ConfigUtil().getProperty( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.DEVICE_LOCATION_ID_KEY)
def setUpClass(self): logging.info("Testing MqttClientConnector class...") self.cfg = ConfigUtil() self.mcc = MqttClientConnector(clientID = 'CDAMqttClientConnectorTest001')
def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing ConfigUtil class...") self.configUtil = ConfigUtil(configFile=self.configFile)
class MqttClientConnectorTest(unittest.TestCase): """ This test case class contains very basic unit tests for MqttClientConnector. It should not be considered complete, but serve as a starting point for the student implementing additional functionality within their Programming the IoT environment. """ @classmethod def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing MqttClientConnector class...") self.cfg = ConfigUtil() self.mcc = MqttClientConnector() def setUp(self): pass def tearDown(self): pass @unittest.skip("Ignore for now.") def testConnectAndDisconnect(self): delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) self.mcc.connectClient() sleep(delay + 5) self.mcc.disconnectClient() @unittest.skip("Ignore for now.") def testConnectAndCDAManagementStatusPubSub(self): qos = 1 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) self.mcc.connectClient() self.mcc.subscribeToTopic( resource=ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE, qos=qos) sleep(5) self.mcc.publishMessage( resource=ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE, msg="TEST: This is the CDA message payload.", qos=qos) sleep(5) self.mcc.unsubscribeFromTopic( resource=ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE) sleep(5) sleep(delay) self.mcc.disconnectClient() @unittest.skip("Ignore for now.") def testActuatorCmdPubSub(self): qos = 0 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) actuatorData = ActuatorData() actuatorData.setCommand(7) self.mcc.setDataMessageListener(DefaultDataMessageListener()) payload = DataUtil().actuatorDataToJson(actuatorData) self.mcc.connectClient() sleep(5) self.mcc.publishMessage( resource=ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, msg=payload, qos=qos) sleep(delay + 5) self.mcc.disconnectClient() @unittest.skip("Ignore for now.") def testCDAManagementStatusSubscribe(self): qos = 1 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) self.mcc.connectClient() self.mcc.subscribeToTopic( resource=ResourceNameEnum.CDA_MGMT_STATUS_CMD_RESOURCE, qos=qos) sleep(delay) self.mcc.disconnectClient() @unittest.skip("Ignore for now.") def testCDAManagementStatusPublish(self): """ Uncomment this test when integration between the GDA and CDA using MQTT. """ qos = 1 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) self.mcc.connectClient() self.mcc.publishMessage( resource=ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE, msg="TEST: This is the CDA message payload.", qos=qos) sleep(delay) self.mcc.disconnectClient()
class ConfigUtilTest(unittest.TestCase): """ This test case class contains very basic unit tests for ConfigUtil. It should not be considered complete, but serve as a starting point for the student implementing additional functionality within their Programming the IoT environment. """ DEFAULT_USER = "******" DEFAULT_AUTH = "Bar" # optionally test the following files # - EmptyTestConfig.props # - InvalidTestConfig.props # - None (which will default to ./config/PiotConfig.props) configFile = "./ValidTestConfig.props" @classmethod def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing ConfigUtil class...") self.configUtil = ConfigUtil(configFile=self.configFile) def setUp(self): pass def tearDown(self): pass def testGetBooleanProperty(self): enableLogging = self.configUtil.hasProperty( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_LOGGING_KEY) self.assertTrue(enableLogging) def testGetCredentials(self): creds = self.configUtil.getCredentials(ConfigConst.CONSTRAINED_DEVICE) self.assertIsNotNone(creds) self.assertEqual(creds[ConfigConst.USER_NAME_TOKEN_KEY], self.DEFAULT_USER) self.assertEqual(creds[ConfigConst.USER_AUTH_TOKEN_KEY], self.DEFAULT_AUTH) pass def testGetIntegerProperty(self): port = self.configUtil.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.PORT_KEY) self.assertEqual(port, ConfigConst.DEFAULT_MQTT_PORT) def testGetFloatProperty(self): hSimFloor = self.configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.HUMIDITY_SIM_FLOOR_KEY) self.assertGreater(hSimFloor, 0.0) def testGetProperty(self): hostName = self.configUtil.getProperty( ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.HOST_KEY) self.assertTrue(hostName) def testHasProperty(self): self.assertTrue( self.configUtil.hasProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_EMULATOR_KEY)) def testHasSection(self): self.assertTrue( self.configUtil.hasSection(ConfigConst.CONSTRAINED_DEVICE)) def testIsConfigDataLoaded(self): self.assertTrue(self.configUtil.isConfigDataLoaded())
def __init__(self, useEmulator: bool = False, pollRate: int = 5, allowConfigOverride: bool = True): self.useEmulator = useEmulator self.pollRate = pollRate self.allowConfigOverride = allowConfigOverride self.dataMsgListener = IDataMessageListener() self.scheduler = BackgroundScheduler() self.scheduler.add_job(self.handleTelemetry, 'interval', seconds=self.pollRate) # whether use Emulator if self.useEmulator is True: logging.info("Use Emulator") # load the Humidity emulator humidityModule = __import__( 'programmingtheiot.cda.emulated.HumiditySensorEmulatorTask', fromlist=['HumiditySensorEmulatorTask']) heClazz = getattr(humidityModule, 'HumiditySensorEmulatorTask') self.humidityEmulator = heClazz() # load the Pressure emulator pressureModule = __import__( 'programmingtheiot.cda.emulated.PressureSensorEmulatorTask', fromlist=['PressureSensorEmulatorTask']) heClazz = getattr(pressureModule, 'PressureSensorEmulatorTask') self.pressureEmulator = heClazz() # load the Temp emulator tempModule = __import__( 'programmingtheiot.cda.emulated.TemperatureSensorEmulatorTask', fromlist=['TemperatureSensorEmulatorTask']) heClazz = getattr(tempModule, 'TemperatureSensorEmulatorTask') self.tempEmulator = heClazz() else: logging.info("Use Simulator") self.dataGenerator = SensorDataGenerator() configUtil = ConfigUtil() #define data range humidityFloor = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.HUMIDITY_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_ENV_HUMIDITY) humidityCeiling = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.HUMIDITY_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_ENV_HUMIDITY) pressureFloor = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.PRESSURE_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_ENV_PRESSURE) pressureCeiling = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.PRESSURE_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_ENV_PRESSURE) tempFloor = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEMP_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_INDOOR_TEMP) tempCeiling = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEMP_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_INDOOR_TEMP) #generate dataset self.humidityData = self.dataGenerator.generateDailyEnvironmentHumidityDataSet( minValue=humidityFloor, maxValue=humidityCeiling, useSeconds=False) self.pressureData = self.dataGenerator.generateDailyEnvironmentPressureDataSet( minValue=pressureFloor, maxValue=pressureCeiling, useSeconds=False) self.tempData = self.dataGenerator.generateDailyIndoorTemperatureDataSet( minValue=tempFloor, maxValue=tempCeiling, useSeconds=False) #create task with data self.htask = HumiditySensorSimTask(dataSet=self.humidityData) self.ptask = PressureSensorSimTask(dataSet=self.pressureData) self.ttask = TemperatureSensorSimTask(dataSet=self.tempData)
class MqttClientConnectorTest(unittest.TestCase): """ This test case class contains very basic unit tests for MqttClientConnector. It should not be considered complete, but serve as a starting point for the student implementing additional functionality within their Programming the IoT environment. """ @classmethod def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing MqttClientConnector class...") self.cfg = ConfigUtil() self.mcc = MqttClientConnector( clientID='CDAMqttClientConnectorTest001') def setUp(self): pass def tearDown(self): pass @unittest.skip("Ignore for now.") def testConnectAndDisconnect(self): delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) self.mcc.connect() sleep(delay + 5) self.mcc.disconnect() @unittest.skip("Ignore for now.") def testConnectAndPublish(self): qos = 1 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) listener = DefaultDataMessageListener() self.mcc.connect() self.mcc.subscribeToTopic( ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE, qos) sleep(5) self.mcc.publishMessage(ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE, "TEST: This is the CDA message payload.", qos) sleep(5) self.mcc.unsubscribeFromTopic( ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE) sleep(5) sleep(delay) self.mcc.disconnect() @unittest.skip("Ignore for now.") def testIntegrateWithGdaSubscribeCdaCmdTopic(self): qos = 1 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) listener = DefaultDataMessageListener() self.mcc.connect() self.mcc.subscribeToTopic( ResourceNameEnum.CDA_MGMT_STATUS_CMD_RESOURCE, qos) sleep(delay) self.mcc.disconnect() @unittest.skip("Ignore for now.") def testIntegrateWithGdaPublishCdaMgmtTopic(self): qos = 1 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) listener = DefaultDataMessageListener() self.mcc.connect() self.mcc.publishMessage(ResourceNameEnum.CDA_MGMT_STATUS_MSG_RESOURCE, "TEST: This is the CDA message payload.", qos) sleep(5) self.mcc.disconnect() def testActuatorCmdPubSub(self): qos = 1 # NOTE: delay can be anything you'd like - the sleep() calls are simply to slow things down a bit for observation delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) actuatorData = ActuatorData() payload = DataUtil().actuatorDataToJson(actuatorData) self.mcc.connectClient() sleep(3) self.mcc.publishMessage( resource=ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, msg=payload, qos=qos) sleep(3) self.mcc.disconnectClient()
def __init__(self, useEmulator: bool = False, pollRate: int = 5, allowConfigOverride: bool = True): self.useEmulator = useEmulator self.pollRate = pollRate self.dataMsgListener = 0 self.allowConfigOverride = allowConfigOverride self.scheduler = BackgroundScheduler() self.scheduler.add_job(self.handleTelemetry, 'interval', seconds=self.pollRate) if (self.useEmulator == True): logging.info("Emulators are being used") humidityModule = __import__( 'programmingtheiot.cda.emulated.HumiditySensorEmulatorTask', fromlist=['HumiditySensorEmulatorTask']) heClazz = getattr(humidityModule, 'HumiditySensorEmulatorTask') self.humidityEmulator = heClazz() pressureModule = __import__( 'programmingtheiot.cda.emulated.PressureSensorEmulatorTask', fromlist=['PressureSensorEmulatorTask']) heClazz = getattr(pressureModule, 'PressureSensorEmulatorTask') self.pressureEmulator = heClazz() tempModule = __import__( 'programmingtheiot.cda.emulated.TemperatureSensorEmulatorTask', fromlist=['TemperatureSensorEmulatorTask']) heClazz = getattr(tempModule, 'TemperatureSensorEmulatorTask') self.tempEmulator = heClazz() else: logging.info("Simulators are being used") self.dataGenerator = SensorDataGenerator() configUtil = ConfigUtil() humidity_floor = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.HUMIDITY_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_ENV_HUMIDITY) humidity_ceiling = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.HUMIDITY_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_ENV_HUMIDITY) pressure_Floor = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.PRESSURE_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_ENV_PRESSURE) pressure_ceiling = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.PRESSURE_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_ENV_PRESSURE) temp_floor = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEMP_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_INDOOR_TEMP) temp_ceiling = configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEMP_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_INDOOR_TEMP) self.humidityData = self.dataGenerator.generateDailyEnvironmentHumidityDataSet( minValue=humidity_floor, maxValue=humidity_ceiling, useSeconds=False) self.pressureData = self.dataGenerator.generateDailyEnvironmentPressureDataSet( minValue=pressure_Floor, maxValue=pressure_ceiling, useSeconds=False) self.tempData = self.dataGenerator.generateDailyIndoorTemperatureDataSet( minValue=temp_floor, maxValue=temp_ceiling, useSeconds=False) self.humiditySensorSimTask = HumiditySensorSimTask( self.humidityData) self.pressureSensorSimTask = PressureSensorSimTask( self.pressureData) self.temperatureSensorSimTask = TemperatureSensorSimTask( self.tempData) logging.info("Simulated Humidity Sensor Sim Task Value is: %s ", self.humiditySensorSimTask.LatestSensorData) logging.info("Simulated Pressure Sensor Sim Task Value is : %s ", self.pressureSensorSimTask.LatestSensorData) logging.info("Simulated Temperature Sensor Sim Task Value is: %s ", self.temperatureSensorSimTask.LatestSensorData) self.handleTelemetry() pass
def __init__(self, useEmulator: bool = False, pollRate: int = 15, allowConfigOverride: bool = True): """ Initialization of class. Create an instance of SensorAdapterManager """ self.useEmulator = useEmulator self.pollRate = pollRate self.allowConfigOverride = allowConfigOverride self.dataMsgListener = None self.scheduler = BackgroundScheduler() self.scheduler.add_job(self.handleTelemetry, 'interval', seconds = self.pollRate) configUtil = ConfigUtil() """ If self.useEmulator is true, we will use Emulator to generate sensor data Else we will use SensorDataGenerator """ if self.useEmulator : logging.info("---> Emulators will be used ") if configUtil.getBoolean(section= ConfigConst.CONSTRAINED_DEVICE, key= ConfigConst.ENABLE_SENSE_HAT_KEY): logging.info("---> SMbus will be used ") self.humidityI2cSensorAdapterTask = HumidityI2cSensorAdapterTask() self.pressureI2cSensorAdapterTask = PressureI2cSensorAdapterTask() self.temperatureI2cSensorAdapterTask = TemperatureI2cSensorAdapterTask() else: # load the Humidity emulator humidityModule = __import__('programmingtheiot.cda.emulated.HumiditySensorEmulatorTask', fromlist = ['HumiditySensorEmulatorTask']) heClazz = getattr(humidityModule, 'HumiditySensorEmulatorTask') self.humidityEmulator = heClazz() pressureModule = __import__('programmingtheiot.cda.emulated.PressureSensorEmulatorTask', fromlist = ['PressureSensorEmulatorTask']) peClazz = getattr(pressureModule, 'PressureSensorEmulatorTask') self.pressureEmulator = peClazz() temperatureModule = __import__('programmingtheiot.cda.emulated.TemperatureSensorEmulatorTask', fromlist = ['TemperatureSensorEmulatorTask']) teClazz = getattr(temperatureModule, 'TemperatureSensorEmulatorTask') self.temperatureEmulator =teClazz() ##add by miaoyao for final project soilHumidityModule = __import__('programmingtheiot.cda.emulated.SoilHumiditySensorEmulatorTask', fromlist = ['SoilHumiditySensorEmulatorTask']) shClazz = getattr(soilHumidityModule, 'SoilHumiditySensorEmulatorTask') self.soilHumidityEmulator = shClazz() else: logging.info("---> Simulators will be used ") self.dataGenerator = SensorDataGenerator() humidityFloor = configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.HUMIDITY_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_ENV_HUMIDITY) humidityCeiling = configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.HUMIDITY_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_ENV_HUMIDITY) pressureFloor = configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.PRESSURE_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_ENV_PRESSURE) pressureCeiling = configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.PRESSURE_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_ENV_PRESSURE) tempFloor = configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEMP_SIM_FLOOR_KEY, SensorDataGenerator.LOW_NORMAL_INDOOR_TEMP) tempCeiling = configUtil.getFloat(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEMP_SIM_CEILING_KEY, SensorDataGenerator.HI_NORMAL_INDOOR_TEMP) humidityData = self.dataGenerator.generateDailyEnvironmentHumidityDataSet(minValue = humidityFloor, maxValue = humidityCeiling, useSeconds = False) pressureData = self.dataGenerator.generateDailyEnvironmentPressureDataSet(minValue = pressureFloor, maxValue = pressureCeiling, useSeconds = False) tempData = self.dataGenerator.generateDailyIndoorTemperatureDataSet(minValue = tempFloor, maxValue = tempCeiling, useSeconds = False) self.humiditySensorSimTask = HumiditySensorSimTask(dataSet= humidityData) self.pressureSensorSimTask = PressureSensorSimTask(dataSet= pressureData) self.temperatureSensorSimTask = TemperatureSensorSimTask(dataSet= tempData)
class CoapClientConnector(IRequestResponseClient): """ Shell representation of class for student implementation. """ def __init__(self): """ Use the ConfigUtil configuration information for the CoAP Gateway to retrieve the host and port information. """ self.config = ConfigUtil() self.dataMsgListener = None self.coapClient = None self.host = self.config.getProperty(ConfigConst.COAP_GATEWAY_SERVICE, ConfigConst.HOST_KEY, ConfigConst.DEFAULT_HOST) self.port = self.config.getInteger(ConfigConst.COAP_GATEWAY_SERVICE, ConfigConst.PORT_KEY, ConfigConst.DEFAULT_COAP_PORT) logging.info('\tCoAP Server Host: ' + self.host) logging.info('\tCoAP Server Port: ' + str(self.port)) """ Validate the url information """ self.url = "coap://" + self.host + ":" + str(self.port) + "/" try: logging.info("Parsing URL: " + self.url) self.host, self.port, self.path = parse_uri(self.url) tmpHost = socket.gethostbyname(self.host) if tmpHost: self.host = tmpHost self._initClient() else: logging.error("Can't resolve host: " + self.host) except socket.gaierror: logging.info("Failed to resolve host: " + self.host) self._initClient() """ Send DISCOVER request to the server """ def sendDiscoveryRequest( self, timeout: int = IRequestResponseClient.DEFAULT_TIMEOUT) -> bool: logging.info('Discovering remote resources...') # NOTE: we can use the API to send a discovery 'GET', or - per [RFC7252](https://tools.ietf.org/html/rfc7252#section-7.2) # and its reference of [RFC6690](https://tools.ietf.org/html/rfc6690#section-1.2.1), we can just send the following: # self.coapClient.get(path = '/.well-known/core', callback = self._onDiscoveryResponse, timeout = timeout) self.coapClient.discover(callback=self._onDiscoveryResponse, timeout=timeout) """ Send delete request to the server """ def sendDeleteRequest( self, resource: ResourceNameEnum, enableCON=False, timeout: int = IRequestResponseClient.DEFAULT_TIMEOUT) -> bool: logging.info("the method sendDeleteRequest is called") if resource: logging.debug("Issuing DELETE with path: " + resource.value) request = self.coapClient.mk_request(defines.Codes.DELETE, path=resource.value) request.token = generate_random_token(2) if not enableCON: request.type = defines.Types["NON"] self.coapClient.send_request(request=request, callback=self._onDeleteResponse, timeout=timeout) else: logging.warning( "Can't test DELETE - no path or path list provided.") """ Send get request to the server """ def sendGetRequest( self, resource: ResourceNameEnum, enableCON=False, timeout: int = IRequestResponseClient.DEFAULT_TIMEOUT) -> bool: logging.info("the method sendGetRequest is called") if resource: logging.debug("Issuing GET with path: " + resource.value) request = self.coapClient.mk_request(defines.Codes.GET, path=resource.value) request.token = generate_random_token(2) if not enableCON: request.type = defines.Types["NON"] self.coapClient.send_request(request=request, callback=self._onGetResponse, timeout=timeout) else: logging.warning("Can't test GET - no path or path list provided.") """ Send post request to the server """ def sendPostRequest( self, resource: ResourceNameEnum, payload: str, enableCON=False, timeout: int = IRequestResponseClient.DEFAULT_TIMEOUT) -> bool: #logging.info("the method sendPostRequest is called") if resource: logging.debug("Issuing POST with path: " + resource.value) request = self.coapClient.mk_request(defines.Codes.POST, path=resource.value) request.token = generate_random_token(2) request.payload = payload if not enableCON: request.type = defines.Types["NON"] self.coapClient.send_request(request=request, callback=self._onPostResponse, timeout=timeout) else: logging.warning("Can't test POST - no path or path list provided.") """ Send put request to the server """ def sendPutRequest( self, resource: ResourceNameEnum, payload: str, enableCON=False, timeout: int = IRequestResponseClient.DEFAULT_TIMEOUT) -> bool: #logging.info("the method sendPutRequest is called") if resource: logging.debug("Issuing PUT with path: " + resource.value) request = self.coapClient.mk_request(defines.Codes.PUT, path=resource.value) request.token = generate_random_token(2) request.payload = payload if not enableCON: request.type = defines.Types["NON"] self.coapClient.send_request(request=request, callback=self._onPutResponse, timeout=timeout) else: logging.warning("Can't test PUT - no path or path list provided.") """ Set the Data Message Listener """ def setDataMessageListener(self, listener: IDataMessageListener) -> bool: self.dataMsgListener = listener def startObserver(self, resource: ResourceNameEnum, ttl: int = IRequestResponseClient.DEFAULT_TTL) -> bool: pass def stopObserver( self, timeout: int = IRequestResponseClient.DEFAULT_TIMEOUT) -> bool: self.coapClient.close() """ Initialize the coap client """ def _initClient(self): if not self.coapClient: self.coapClient = HelperClient(server=(self.host, self.port)) """ Callback function for sendDiscoveryRequest() """ def _onDiscoveryResponse(self, response): if response: logging.info(response.pretty_print()) # get the payload and convert to a list of paths self.pathList = response.payload.split(',') index = 0 # the following is optional, but provides an easy way to track all the returned resource names for path in self.pathList: for char in '<\>': path = path.replace(char, '') self.pathList[index] = path logging.info(' Path entry [' + str(index) + ']:' + self.pathList[index]) index += 1 else: logging.info("No response received.") """ Callback function for sendGetRequest() """ def _onGetResponse(self, response): logging.info('[COAP_CALLBACK] GET response received.') if response: logging.info('Token: ' + str(response.token)) logging.info(str(response.location_path)) logging.info(str(response.payload)) # # NOTE: This next section is optional if you want to send a callback to the self.dataMsgListener instance # # TODO: get the URI and convert to ResourceNameEnum resource = ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE msg = str(response.payload) if response.payload: ad = DataUtil.jsonToActuatorData(self, msg) if ad.getActuatorType() == 4: resource = ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE else: resource = ResourceNameEnum.CDA_CLOUD_ACTUATOR_CMD_RESOURCE if self.dataMsgListener and response.payload: self.dataMsgListener.handleIncomingMessage(resource, msg) """ Callback function for sendPutRequest() """ def _onPutResponse(self, response): #logging.info('PUT response received.') if response: logging.info('Token: ' + str(response.token)) logging.info(str(response.location_path)) logging.info(str(response.payload)) """ Callback function for sendPostRequest() """ def _onPostResponse(self, response): #logging.info('POST response received.') if response: logging.info('Token: ' + str(response.token)) logging.info(str(response.location_path)) logging.info(str(response.payload)) """ Callback function for sendDeleteRequest() """ def _onDeleteResponse(self, response): logging.info('DELETE response received.') if response: logging.info('Token: ' + str(response.token)) logging.info(str(response.location_path)) logging.info(str(response.payload))