def _createTestSensorData(self):
sd = SensorData()
sd.setName(self.DEFAULT_NAME)
sd.setValue(self.MIN_VALUE)
logging.info("Sensor data as string: " + str(sd))
return sd
def _execTestPost(self, maxTestRuns: int, useCon: bool):
sensorData = SensorData()
payload = DataUtil().sensorDataToJson(sensorData)
startTime = time.time_ns()
for seqNo in range(0, maxTestRuns):
self.coapClient.sendPostRequest(
resource=ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE,
enableCON=useCon,
payload=payload)
endTime = time.time_ns()
elapsedMillis = (endTime - startTime) / self.NS_IN_MILLIS
print("POST message - useCON = " + str(useCon) + " [" +
str(maxTestRuns) + "]: " + str(elapsedMillis) + " ms")
def jsonToSensorData(self, jsonData):
# process data
print(str(jsonData))
jsonData = jsonData.replace("\'", "\"").replace('False',
'false').replace(
'True', 'true')
# load json data
adDict = json.loads(jsonData)
# create object and put json data in it
ad = SensorData()
# vars() get the properties dict of the object
mvDict = vars(ad)
# iter properties and fill it
for key in adDict:
if key in mvDict:
setattr(ad, key, adDict[key])
return ad
def generateTelemetry(self) -> SensorData:
"""
Retrieve the telemetry value from method _getSystemUtil, package the row data into SensorData.
Update latestSensorData and return it.
TODO: change to generate SystemPerformanceData
@return SensorData Packaged latest sensor data
"""
sensor_date = SensorData(sensorType=SensorData.SYS_UTIL_TYPE)
sensor_date.setName(self.simpleName)
sensor_date.setValue(self._getSystemUtil())
self.latestSensorData = sensor_date
return self.latestSensorData
pass
def testStoreSensorData(self):
logging.info("Testing storeData method...")
ret = self.redisPersistenceAdapter.connectClient()
self.assertTrue(ret)
testData = SensorData()
testData.setName('TestRedisClientAdapter')
testData.setValue(123.456)
ret = self.redisPersistenceAdapter.storeData(
testData, ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE)
self.assertTrue(ret)
ret = self.redisPersistenceAdapter.disconnectClient()
self.assertTrue(ret)
logging.info("Test storeData method finished.\n")
pass
def _execTestPublish(self, maxTestRuns: int, qos: int):
self.assertTrue(self.mqttClient.connectClient())
sensorData = SensorData()
payload = DataUtil().sensorDataToJson(sensorData)
startTime = time.time_ns()
for seqNo in range(0, maxTestRuns):
self.mqttClient.publishMessage(
resource=ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE,
msg=payload,
qos=qos)
endTime = time.time_ns()
elapsedMillis = (endTime - startTime) / self.NS_IN_MILLIS
self.assertTrue(self.mqttClient.disconnectClient())
logging.info("Publish message - QoS " + str(qos) + " [" +
str(maxTestRuns) + "]: " + str(elapsedMillis) + " ms")
def generateTelemetry(self) -> SensorData:
# create SensorData instance
sd = SensorData(self.sensorType)
if self.useRandom is True:
# generate data
sd.setValue(random.uniform(self.minVal, self.maxVal))
else:
# use origin data set
if self.dataSet.getDataEntryCount() >= self.currentIndex + 1:
sd.setValue(self.dataSet.getDataEntry(self.currentIndex))
# set and check index
self.currentIndex += 1
if self.currentIndex >= self.dataSet.getDataEntryCount() - 1:
self.currentIndex = 0
self.sensorData = sd
return sd
def testSensorDataConversionsFromObject(self):
logging.info("\n\n----- [JSON Conversions from SensorData] -----")
sdName = "Foobar2 Sensor"
sdObj1 = SensorData()
sdObj1.setName(sdName)
sdObj1Str = self.dataUtil.sensorDataToJson(sdObj1)
sdObj2 = self.dataUtil.jsonToSensorData(sdObj1Str)
sdObj2Str = self.dataUtil.sensorDataToJson(sdObj2)
logging.info("Sample SensorData: " + str(sdObj1))
logging.info("SensorData to JSON: " + str(sdObj1Str))
logging.info("JSON back to SensorData: " + str(sdObj2))
logging.info("SensorData back to JSON: " + str(sdObj2Str))
self.assertEqual(sdName, sdObj1.getName())
self.assertEqual(sdObj1.getName(), sdObj2.getName())
self.assertEqual(sdObj1.getTimeStamp(), sdObj2.getTimeStamp())
self.assertEqual(sdObj1Str, sdObj2Str)
def _execTestPublish(self, maxTestRuns: int, qos: int):
self.assertTrue(self.mqttClient.connectClient())
sensorData = SensorData()
payload = DataUtil().sensorDataToJson(sensorData)
payloadLen = len(payload)
startTime = time.time_ns()
for seqNo in range(0, maxTestRuns):
self.mqttClient.publishMessage(
resource=ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE,
msg=payload,
qos=qos)
endTime = time.time_ns()
elapsedMillis = (endTime - startTime) / self.NS_IN_MILLIS
self.assertTrue(self.mqttClient.disconnectClient())
logging.info( \
"\n\tTesting Publish: QoS = %r | msgs = %r | payload size = %r | start = %r | end = %r | elapsed = %r", \
qos, maxTestRuns, payloadLen, startTime / 1000, endTime / 1000, elapsedMillis / 1000)
def jsonToSensorData(self, jsonData):
"""
Convert JSON to an SensorData instance
@return SensorData
"""
jsonData = jsonData.replace("\'", "\"").replace('False',
'false').replace(
'True', 'true')
logging.info('Convert JSON to an SensorData instance: ' + jsonData)
## Load the dictionary data for the JSON string
sdDict = json.loads(jsonData)
##Create an instance of SensorData, extract the variables, then map the JSON dict into the new object via an iterative lookup of each key / value pair.
sd = SensorData()
mvDict = vars(sd)
for key in sdDict:
if key in mvDict:
setattr(sd, key, sdDict[key])
return sd
def generateTelemetry(self) -> SensorData: """ Generate the Telemetry @return SensorData """ sd = SensorData(sensorType = self.sensorType, name = self.sensorName) if self.useRandomizer: randomVal = random.uniform(self.minVal, self.maxVal) sd.setValue(randomVal) else: self.index += 1 if self.index >= len(self.dataSet): self.index = 0 data = self.dataSet[self.index] sd.setValue(data) return sd
def _updateTelemetry(self):
sysPerfVal = random.uniform(1.0, 50.0)
tempVal = random.uniform(18.0, 22.0)
sysPerfData = SystemPerformanceData()
sysPerfData.setName("SystemPerfMsg")
sysPerfData.setCpuUtilization(sysPerfVal)
sysPerfData.setDiskUtilization(sysPerfVal)
sysPerfData.setMemoryUtilization(sysPerfData)
# Uncomment the next SLOC to trigger data message listener callback for perf data
#self.dataMsgListener.handleSystemPerformanceMessage(sysPerfData)
sensorData = SensorData()
sensorData.setName(ConfigConst.TEMP_SENSOR_NAME)
sensorData.setValue(tempVal)
self.dataMsgListener.handleSensorMessage(sensorData)
def generateTelemetry(self) -> SensorData:
data = SensorData(sensorType=self._sensorType)
data.setValue(self._readValueFromI2cBus())
self._latestSensorData = data
return self._latestSensorData
pass
def testDefaultValues(self):
sd = SensorData()
self.assertEquals(sd.getName(), ConfigConst.NOT_SET)
self.assertEquals(sd.getValue(), SensorData.DEFAULT_VAL)
def testStoreSensorData(self):
sd = SensorData()
rpa = RedisPersistenceAdapter()
rpa.storeData(ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, sd)
def generateTelemetry(self) -> SensorData: sensorData = SensorData(sensorType = 3) sensorVal = self.sh.environ.temperature sensorData.setValue(sensorVal) self.LatestSensorData = sensorData return self.LatestSensorData
