def fetch(self):
try:
conn = http.client.HTTPConnection(self.url)
conn.request(
'GET', '/data/2.5/weather?q={}&APPID={}'.format(
self.city, self.appid))
r = conn.getresponse()
res = r.read().decode()
conn.close()
if r.status != 200:
raise ValueError(res)
jdoc = json.loads(res)
reads = {
'city': jdoc['name'],
'wind_speed': jdoc['wind']['speed'],
'clouds': jdoc['clouds']['all'],
'temperature': jdoc['main']['temp'],
'pressure': jdoc['main']['pressure'],
'humidity': jdoc['main']['humidity'],
'visibility': jdoc['visibility']
}
data = {
'asset': self.asset_name,
'timestamp': utils.local_timestamp(),
'key': str(uuid.uuid4()),
'readings': reads
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
except ValueError as ex:
err = "Unable to fetch information from api.openweathermap: {}".format(
str(ex))
_LOGGER.error(err)
async def render_put(request):
"""Store sensor readings from Roxtec to FogLAMP
Args:
request:
The payload block decodes to JSON similar to the following:
.. code-block:: python
{
"guard_id": "444DF705F0F8",
"gateway_id": "device-0",
"state": 70,
"transit_id": "t11",
"battery": 4,
"pressure": 722,
"temperature": 0,
"last_seen": 1533816739126
}
Example:
curl --insecure -X PUT https://localhost:1608/transit -d '[{ "guard_id": "444DF705F0F8", "gateway_id": "device-0", "state": 70, "transit_id": "t11", "battery": 4, "pressure": 722, "temperature": 0, "last_seen": 1533816739126 }]'
curl -X PUT http://localhost:8608/transit -d '[{ "guard_id": "444DF705F0F8", "gateway_id": "device-0", "state": 70, "transit_id": "t11", "battery": 4, "pressure": 722, "temperature": 0, "last_seen": 1533816739126 }]'
"""
try:
message = {'result': 'success'}
payload_block = await request.json()
if type(payload_block) is not list:
raise ValueError('Payload block must be a valid list')
for payload in payload_block:
asset = "Guard " + payload['guard_id']
epoch_ms = payload['last_seen'] / 1000.0
timestamp = datetime.datetime.fromtimestamp(epoch_ms).strftime('%Y-%m-%d %H:%M:%S.%f')
key = str(uuid.uuid4())
readings = {
"gateway_id": payload['gateway_id'],
"state": payload['state'],
"battery": payload['battery'],
"pressure": payload['pressure'],
"temperature": payload['temperature']
}
if 'transit_id' in payload and payload['transit_id'] is not None:
readings['transit_id'] = payload['transit_id']
data = {
'asset': asset,
'timestamp': timestamp,
'key': key,
'readings': readings
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
except (KeyError, ValueError, TypeError) as e:
_LOGGER.exception("%d: %s", web.HTTPBadRequest.status_code, e)
raise web.HTTPBadRequest(reason=e)
except Exception as ex:
_LOGGER.exception("%d: %s", web.HTTPInternalServerError.status_code, str(ex))
raise web.HTTPInternalServerError(reason=str(ex))
return web.json_response(message)
def datachange_notification(self, node: Node, val, data):
"""
Callback for OPC UA Subscription.
This method will be called when the Client received a data change message from the Server.
"""
time_stamp = utils.local_timestamp()
asset_name = str(node)
#Trim the string to start with ns=
ns_start = asset_name.find('ns=')
if ns_start != -1:
asset_name = asset_name[ns_start:]
#Some OPC UA servers add extra parentheses, so remove them
#Remove any extraneous parentheses
asset_name = asset_name.replace("(","")
asset_name = asset_name.replace(")","")
#_LOGGER.info('opcua_py: datachange_notification %r %s', asset_name, val)
key = str(uuid.uuid4())
data = {
'asset': asset_name,
'timestamp': time_stamp, # metric.timestamp
'key' : key,
'readings': {"value": val}
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
def run(self):
global wait_event
while True:
if wait_event.is_set(): # i.e. shutdown called
return
self.condition.acquire()
while self.queue.qsize() > 0:
data = self.queue.get()
reading = data['data']
if self.handle['historicTimestamps']['value'] == 'true':
ts_col = self.handle['timestampCol']['value']
raw_time_stamp = reading.pop(ts_col)
ts_format = self.handle['timestampFormat']['value']
time_stamp = str(
datetime.datetime.strptime(raw_time_stamp, ts_format))
else:
time_stamp = data['ts']
reading = {
'asset': self.handle['assetName']['value'],
'timestamp': time_stamp,
'readings': reading
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, reading)
self.condition.notify()
self.condition.release()
async def save(self, msg):
"""Store msg content to Fledge """
# TODO: string and other types?
payload_json = json.loads(msg.payload.decode('utf-8'))
_LOGGER.debug("Ingesting %s on topic %s", payload_json, str(msg.topic))
data = {
'asset': self.asset,
'timestamp': utils.local_timestamp(),
'readings': payload_json
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
async def _start_aiotest(handle):
# This plugin adds 6 data points 2 within same min, 2 within same hour and 2 within same day
# this data is useful when testing asset browsing based on timestamps
ts_lst = list()
ts_lst.append(str(datetime.now(timezone.utc).astimezone()))
ts_lst.append(
str(datetime.now(timezone.utc).astimezone() - timedelta(seconds=3)))
ts_lst.append(
str(datetime.now(timezone.utc).astimezone() - timedelta(minutes=5)))
ts_lst.append(
str(datetime.now(timezone.utc).astimezone() - timedelta(minutes=6)))
ts_lst.append(
str(datetime.now(timezone.utc).astimezone() - timedelta(hours=3)))
ts_lst.append(
str(datetime.now(timezone.utc).astimezone() - timedelta(hours=5)))
i = 1
for user_ts in ts_lst:
try:
data = list()
data.append({
'asset':
'{}{}'.format(handle['assetPrefix']['value'],
handle['loudnessAssetName']['value']),
'timestamp':
user_ts,
'key':
str(uuid.uuid4()),
'readings': {
"loudness": i
}
})
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
await asyncio.sleep(0.1)
except (Exception, RuntimeError) as ex:
_LOGGER.exception("TEST exception: {}".format(str(ex)))
raise exceptions.DataRetrievalError(ex)
else:
i += 1
async def render_post(request):
"""Store sensor readings from SensorPhone to Fledge
Args:
request:
The payload decodes to JSON similar to the following:
.. code-block:: python
{
"mode" : "sync",
"messages" : [
{
"audio": 0.0005980864,
"device": "iOS Device",
"altitude": 30.71550178527832,
"latitude": 51.55842144498452,
"longitude": -0.8672407515484514,
"timestamp": 1514597142,
"gyroscopex": -0.005210537929087877,
"gyroscopey": -0.02013654075562954,
"gyroscopez": -0.005803442094475031,
"accelerometerx": 0.0119628909160383,
"accelerometery": -0.7869872764804313,
"accelerometerz": -0.6097259288653731}
]
}
"""
# TODO: Decide upon the correct format of message
message = {'result': 'success'}
code = web.HTTPOk.status_code
try:
payload = await request.json()
asset = 'SensorPhone'
timestamp = utils.local_timestamp()
messages = payload.get('messages')
if not isinstance(messages, list):
raise ValueError('messages must be a list')
for readings in messages:
data = {
'asset': asset,
'timestamp': timestamp,
'readings': readings
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
except (ValueError, TypeError) as e:
code = web.HTTPBadRequest.status_code
message = {'error': str(e)}
_LOGGER.exception(str(e))
except Exception as e:
code = web.HTTPInternalServerError.status_code
message = {'error': str(e)}
_LOGGER.exception(str(e))
# expect keys in response:
# (code = 2xx) result Or busy
# (code = 4xx, 5xx) error
message['status'] = code
return web.json_response(message)
async def render_post(request):
"""Store sensor readings from CoAP to Fledge
Args:
request:
The payload is a cbor-encoded array that decodes to JSON
similar to the following:
.. code-block:: python
{
"timestamp": "2017-01-02T01:02:03.23232Z-05:00",
"asset": "pump1",
"readings": {
"velocity": "500",
"temperature": {
"value": "32",
"unit": "kelvin"
}
}
}
"""
# aiocoap handlers must be defensive about exceptions. If an exception
# is raised out of a handler, it is permanently disabled by aiocoap.
# Therefore, Exception is caught instead of specific exceptions.
code = aiocoap.numbers.codes.Code.VALID
message = ''
try:
try:
payload = cbor2.loads(request.payload)
except Exception:
raise ValueError('Payload must be a dictionary')
asset = payload['asset']
timestamp = payload['timestamp']
# readings or sensor_values are optional
try:
readings = payload['readings']
except KeyError:
readings = payload[
'sensor_values'] # sensor_values is deprecated
# if optional then
# TODO: confirm, do we want to check this?
if not isinstance(readings, dict):
raise ValueError('readings must be a dictionary')
data = {
'asset': asset,
'timestamp': timestamp,
'readings': readings
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
except (KeyError, ValueError, TypeError) as e:
_LOGGER.exception("%d: %s", aiocoap.numbers.codes.Code.BAD_REQUEST,
str(e))
raise aiocoap.error.BadRequest(str(e))
except Exception as ex:
_LOGGER.exception("%d: %s",
aiocoap.numbers.codes.Code.INTERNAL_SERVER_ERROR,
str(ex))
raise aiocoap.error.ConstructionRenderableError(str(ex))
return aiocoap.Message(payload=message.encode('utf-8'), code=code)
async def render_post(self, request):
"""Store sensor readings from http_south to Fledge
Args:
request:
The payload block decodes to JSON similar to the following:
.. code-block:: python
[ {
"timestamp": "2017-01-02T01:02:03.23232Z-05:00",
"asset": "pump1",
"readings": {"humidity": 0.0, "temperature": -40.0}
},
...
]
Example:
curl -X POST http://localhost:6683/sensor-reading -d '[{"timestamp": "2017-01-02T01:02:03.23232Z-05:00",
"asset": "pump1", "readings": {"humidity": 0.0, "temperature": -40.0}}]'
"""
message = {'result': 'success'}
try:
try:
payload_block = await request.json()
except Exception:
raise ValueError('Payload block must be a valid json')
if type(payload_block) is not list:
raise ValueError('Payload block must be a valid list')
for payload in payload_block:
asset = "{}{}".format(
self.config_data['assetNamePrefix']['value'],
payload['asset'])
dt_str = payload['timestamp']
if dt_str.endswith("Z"):
fmt = "%Y-%m-%dT%H:%M:%S.%fZ"
utc_dt = datetime.strptime(dt_str, fmt)
# Convert to local time zone
dt_str = str(
utc_dt.replace(tzinfo=timezone.utc).astimezone(
tz=None))
# readings or sensor_values are optional
try:
readings = payload['readings']
except KeyError:
readings = payload[
'sensor_values'] # sensor_values is deprecated
# if optional then
# TODO: confirm, do we want to check this?
if not isinstance(readings, dict):
raise ValueError('readings must be a dictionary')
data = {
'asset': asset,
'timestamp': dt_str,
'readings': readings
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
except (KeyError, ValueError, TypeError) as e:
_LOGGER.exception("%d: %s", web.HTTPBadRequest.status_code, str(e))
raise web.HTTPBadRequest(reason=e)
except Exception as ex:
_LOGGER.exception("%d: %s",
web.HTTPInternalServerError.status_code, str(ex))
raise web.HTTPInternalServerError(reason=str(ex))
return web.json_response(message)
async def save_data(data):
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
async def render_post(self, request):
"""Store sensor readings from http_south to FogLAMP
Args:
request:
The payload block decodes to JSON similar to the following:
.. code-block:: python
[ {
"timestamp": "2017-01-02T01:02:03.23232Z-05:00",
"asset": "pump1",
"key": "80a43623-ebe5-40d6-8d80-3f892da9b3b4",
"readings": {"humidity": 0.0, "temperature": -40.0}
},
...
]
Example:
curl -X POST http://localhost:6683/sensor-reading -d '[{"timestamp": "2017-01-02T01:02:03.23232Z-05:00",
"asset": "pump1", "key": "80a43623-ebe5-40d6-8d80-3f892da9b3b4", "readings": {"humidity": 0.0, "temperature": -40.0}}]'
"""
message = {'result': 'success'}
try:
try:
payload_block = await request.json()
except Exception:
raise ValueError('Payload block must be a valid json')
if type(payload_block) is not list:
raise ValueError('Payload block must be a valid list')
for payload in payload_block:
asset = "{}{}".format(
self.config_data['assetNamePrefix']['value'],
payload['asset'])
timestamp = payload['timestamp']
key = payload['key']
# HOTFIX: To ingest readings sent from foglamp sending process
if not timestamp.rfind("+") == -1:
timestamp = timestamp + ":00"
# readings or sensor_values are optional
try:
readings = payload['readings']
except KeyError:
readings = payload[
'sensor_values'] # sensor_values is deprecated
# if optional then
# TODO: confirm, do we want to check this?
if not isinstance(readings, dict):
raise ValueError('readings must be a dictionary')
data = {
'asset': asset,
'timestamp': timestamp,
'key': key,
'readings': readings
}
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
except (KeyError, ValueError, TypeError) as e:
_LOGGER.exception("%d: %s", web.HTTPBadRequest.status_code, str(e))
raise web.HTTPBadRequest(reason=e)
except Exception as ex:
_LOGGER.exception("%d: %s",
web.HTTPInternalServerError.status_code, str(ex))
raise web.HTTPInternalServerError(reason=str(ex))
return web.json_response(message)
def camera_loop(**kwargs):
""" Main function that keeps on fetching frame ,
performing inference and drawing the result of
inference on the detection window.
Args:
Keyword Arguements -> Each one is listed below
Returns:
None
Raises:
Raises exception if unable to draw the frame on the the window.
"""
# if floating point model is used we need to subtract the mean and divide
# by standard deviation
input_mean = kwargs['input_mean']
input_std = kwargs['input_std']
# the height of the detection window on which frames are to be displayed
camera_height = kwargs['camera_height']
# the width of the detection window on which frames are to be displayed
camera_width = kwargs['camera_width']
# Note : The object contents may change if plugin_reconfigure is called
# thats why the inference object in the loop is global
# these variables are used for calculation of frame per seconds (FPS)
frame_rate_calc = 1
freq = cv2.getTickFrequency()
source = kwargs['source']
enable_window_local = kwargs['enable_window']
# Initialize the stream object and start the thread that keeps on reading frames
# This thread is independent of the Camera Processing Thread
videostream = VideoStream(resolution=(camera_width, camera_height),
source=source).start()
# For using the videostream with threading use the following :
# videostream = VideoStream(resolution=(camera_width, camera_height), source=source, enable_thread=True).start()
# The thread is allowed to capture a few frames. See FOGL-4132 for details
wait_for_frame(videostream)
# creating a window with a name
window_name = 'Human detector'
global BACKGROUND_TASK
if not BACKGROUND_TASK and enable_window_local:
foreground_task = True
cv2.namedWindow(window_name)
else:
foreground_task = False
while True:
# Capture frame-by-frame
t1 = cv2.getTickCount()
global inference, asset_name, FRAME, enable_window
# we need the height , width to resize the image for feeding into the model
height_for_model = inference.height_for_model
width_for_model = inference.width_for_model
# check if floating point model is used or not
floating_model = inference.floating_model
# The minimum confidence to threshold the detections obtained from model
min_conf_threshold = inference.min_conf_threshold
# The list of labels of the supported objects detected by the plugin
labels = inference.labels
# Taking the frame the stream
frame1 = videostream.read()
frame = frame1.copy()
# BGR to RGB
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# resizing it to feed into model
frame_resized = cv2.resize(frame_rgb,
(width_for_model, height_for_model))
# input_data will now become 4 dimensional
input_data = np.expand_dims(frame_resized, axis=0)
# now it will have (batchsize, height, width, channel)
# Normalize pixel values if using a floating model
# (i.e. if model is non-quantized)
if floating_model:
input_data = (np.float32(input_data) - input_mean) / input_std
# Perform the actual detection by running the model with the image as input
boxes, classes, scores = inference.perform_inference(input_data)
# we could have got number of objects
# but it does not work most of the times.
# num = interpreter.get_tensor(output_details[3]['index'])[0] #
# Total number of detected objects (inaccurate and not needed)
# The readings array to be inserted in the readings table
objs = []
# Loop over all detections and draw detection box
# if confidence is above minimum then only
# that detected object will be considered
# The index of person class is zero.
for i in range(len(scores)):
if (scores[i] > min_conf_threshold) and (int(classes[i] == 0)):
# Get bounding box coordinates and draw box
# Interpreter can return coordinates that are outside of image dimensions,
# need to force them to be within image using max() and min()
ymin_model = round(boxes[i][0], 3)
xmin_model = round(boxes[i][1], 3)
ymax_model = round(boxes[i][2], 3)
xmax_model = round(boxes[i][3], 3)
# map the bounding boxes from model to the window
ymin = int(max(1, (ymin_model * camera_width)))
xmin = int(max(1, (xmin_model * camera_height)))
ymax = int(min(camera_width, (ymax_model * camera_width)))
xmax = int(min(camera_height, (xmax_model * camera_height)))
# draw the rectangle on the frame
cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (10, 255, 0),
2)
# Contructing the label
# Look up object name from "labels" array using class index
object_name = labels[int(classes[i])]
# Example: 'person: 72%'
label = '%s: %d%%' % (object_name, int(scores[i] * 100))
# Get font size
labelSize, baseLine = cv2.getTextSize(label,
cv2.FONT_HERSHEY_SIMPLEX,
0.7, 2)
# Make sure not to draw label too close to top of window
label_ymin = max(ymin, labelSize[1] + 10)
# Draw white box to put label text in
cv2.rectangle(
frame, (xmin, label_ymin - labelSize[1] - 10),
(xmin + labelSize[0], label_ymin + baseLine - 10),
(255, 255, 255), cv2.FILLED)
# Draw the text label
cv2.putText(frame, label, (xmin, label_ymin - 7),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)
# the readings to be inserted into the table
objs.append({
'label': labels[classes[i]],
'score': 100 * scores[i],
'bounding_box': [xmin, ymin, xmax, ymax]
})
# Draw framerate in corner of frame
cv2.putText(frame, 'FPS: {0:.2f}'.format(frame_rate_calc), (30, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2, cv2.LINE_AA)
# All the results have been drawn on the frame, so it's time to display it.
global shutdown_in_progress
if shutdown_in_progress:
videostream.stop()
time.sleep(3)
cv2.destroyWindow(window_name)
break
else:
# Calculate framerate
t_end = cv2.getTickCount()
time1 = (t_end - t1) / freq
frame_rate_calc = 1 / time1
data = construct_readings(objs)
if not shutdown_in_progress:
async_ingest.ingest_callback(c_callback, c_ingest_ref, data)
# show the frame on the window
try:
if foreground_task and enable_window:
cv2.imshow(window_name, frame)
FRAME = frame.copy()
except Exception as e:
_LOGGER.info('exception {}'.format(e))
# wait for 1 milli second
cv2.waitKey(1)
