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): 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 __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 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 setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing mccConnector class...") self.cfg = ConfigUtil() self.mcc = CoapClientConnector()
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 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, 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 __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): """ 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)
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): """ 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 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, 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)
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 __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 __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 __init__(self, enableMqtt: bool = True, enableCoap: bool = False): """ Initialization of class. Create an instance of DeviceDataManager """ self.configUtil = ConfigUtil() self.enableEmulator = self.configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_EMULATOR_KEY) self.enableRedis = False self.sysPerfManager = SystemPerformanceManager() self.sysPerfManager.setDataMessageListener(self) self.sensorAdapterManager = SensorAdapterManager( useEmulator=self.enableEmulator) self.sensorAdapterManager.setDataMessageListener(self) self.actuatorAdapterManager = ActuatorAdapterManager( useEmulator=self.enableEmulator) self.actuatorAdapterManager.setDataMessageListener(self) ##add by miaoyao @10/30/2020 if self.enableRedis: self.redisClient = RedisPersistenceAdapter() 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) ##add by miaoyao for final project self.enableHandleSoilHumidityChangeOnDevice = self.configUtil.getBoolean( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_HANDLE_SOIL_HUMIDITY_CHANGE_ON_DEVICE_KEY) self.triggerWaterDeviceHumiFloor = self.configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TRIGGER_WATER_SOIL_HUMI_FLOOR_KEY) self.triggerWaterDeviceHumiCeiling = self.configUtil.getFloat( ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TRIGGER_WATER_SOIL_HUMI_CEILING_KEY) ##add by miaoyao @11/02/2020 ##self.enableMqtt = self.configUtil.getBoolean(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.ENABLE_MQTT_KEY) self.enableMqtt = enableMqtt self.enableCoap = enableCoap if self.enableMqtt: self.mqttClient = MqttClientConnector() self.mqttClient.setDataMessageListener(self) if self.enableCoap: self.coapClient = CoapClientConnector() self.coapClient.setDataMessageListener(self)
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 setUpClass(self): logging.info("Testing MqttClientConnector class...") self.cfg = ConfigUtil() self.mcc = MqttClientConnector(clientID = 'CDAMqttClientConnectorTest001')
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 = 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)
def __init__(self, useEmulator: bool = False, enableSenseHAT: bool = False, pollRate: int = 5, allowConfigOverride: bool = True): """ Init the SensorAdapterManager, if using simulator, setup data sets and sim tasks for simulation :param useEmulator: Whether use Emulator :param pollRate: Interval seconds for polling sensor data :param allowConfigOverride: If allow to override config """ logging.info("SensorAdapterManager is initializing...") # Init basic config variables self.useEmulator = useEmulator self.pollRate = pollRate self.allowConfigOverride = allowConfigOverride # Init data message listener self.dataMsgListener: IDataMessageListener = None # Init scheduler self.scheduler = BackgroundScheduler() self.scheduler.add_job(self.handleTelemetry, 'interval', seconds=self.pollRate) configUtil = ConfigUtil() self.enableSenseHAT = enableSenseHAT if self.enableSenseHAT is True: logging.info("SensorAdapterManager is using SenseHAT.") self.humiditySensorI2cTask = HumidityI2cSensorAdapterTask() self.pressureSensorI2cTask = PressureI2cSensorAdapterTask() self.temperatureSensorI2cTask = TemperatureI2cSensorAdapterTask() pass elif self.useEmulator is True: logging.info("SensorAdapterManager is using emulator.") humidityModule = __import__( 'programmingtheiot.cda.emulated.HumiditySensorEmulatorTask', fromlist=['HumiditySensorEmulatorTask']) huClass = getattr(humidityModule, 'HumiditySensorEmulatorTask') self.humidityEmulator = huClass() pressureModule = __import__( 'programmingtheiot.cda.emulated.PressureSensorEmulatorTask', fromlist=['PressureSensorEmulatorTask']) prClass = getattr(pressureModule, 'PressureSensorEmulatorTask') self.pressureEmulator = prClass() tempModule = __import__( 'programmingtheiot.cda.emulated.TemperatureSensorEmulatorTask', fromlist=['TemperatureSensorEmulatorTask']) teClass = getattr(tempModule, 'TemperatureSensorEmulatorTask') self.tempEmulator = teClass() else: logging.info("SensorAdapterManager is using simulators.") 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, minVal=humidityFloor, maxVal=humidityCeiling) self.pressureSensorSimTask = PressureSensorSimTask( dataSet=pressureData, minVal=pressureFloor, maxVal=pressureCeiling) self.temperatureSensorSimTask = TemperatureSensorSimTask( dataSet=tempData, minVal=tempFloor, maxVal=tempCeiling) 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)