def testSensorAPIs(self): self.sensor1 = Sensor.Create(self.e, "000-100", self.st.key().id()) self.sensor1.Update(name="Sensor 1") self.sensor2 = Sensor.Create(self.e, "000-200", self.st.key().id()) db.put([self.sensor1, self.sensor2]) # Test list params = self.__commonParams() result = self.get_json("/api/sensor", params) self.assertTrue(result['success']) self.assertEqual(len(result['data']['sensors']), 2) # Test detail params = self.__commonParams() params['with_records'] = 10 result = self.get_json("/api/sensor/%s" % "000-100", params) self.assertTrue(result['success']) self.assertEqual(result['data']['sensor']['name'], "Sensor 1") # Test create with alias params = self.__commonParams() KN = "00-200" params['kn'] = KN params['name'] = "Geo Sensor 1" params['sensortype_alias'] = "geo" result = self.post_json("/api/sensor", params) self.assertTrue(result['success']) s = Sensor.get_by_key_name(KN, parent=self.e.key()) self.assertIsNotNone(s) self.assertEqual(s.name, "Geo Sensor 1") self.assertEqual(s.sensortype.key(), self.st.key())
def delete(self, sensor_id = None): sensor = Sensor.query.filter_by(id = sensor_id).first() if sensor: Sensor.delete(id = sensor.id) return jsonify(ApiObjects(sensor.json())) else: return jsonify(ApiObjects())
def _save_sensor(params): try: sensor = Sensor(**params) sensor.save() except: print params raise
def seed_node(site_id = None, alias = None, latitude = None, longitude = None): if site_id: site = Site.query.filter_by(id = site_id).first() else: site = Site.create(name = 'Techrice site {}'.format(uuid4().hex)) if not alias: alias = 'Techrice node {}'.format(uuid4().hex) node = Node.create(name = alias, site = site, latitude = latitude, longitude = longitude) solar = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'solar voltage').first(), name = 'vsol') battery = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'battery voltage').first(), name = 'vbat') temperature = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'DHT11 temperature').first(), name = 'temperature') humidity = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'DHT11 humidity').first(), name = 'humidity') sonar = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'sonar HC SR-04').first(), name = 'sonar') header = Header.get_header(node_id = node.id) print header return { 'node': 'name: {}, id: {}, longitude: {}, latitude: {}'.format(node.name, node.id, node.longitude, node.latitude), 'sensors': map(lambda s: 'name: {}, id: {}'.format(s.name, s.id), node.sensors), 'header' : header }
def env_test_01(): admin_user = User(name="Administrator", role=ROLE_ADMIN, access_code="1234") admin_user.add_registration_code("1234") session.add_all([ admin_user, User(name="Chuck Norris", role=ROLE_USER, access_code="1111") ]) print(" - Created users") z1 = Zone(name="No delay", description="Alert with no delay") z2 = Zone(name="Tamper", disarmed_delay=0, away_alert_delay=None, stay_alert_delay=None, description="Sabotage alert") z3 = Zone(name="Away/stay delayed", away_alert_delay=5, stay_alert_delay=5, description="Alert delayed when armed AWAY or STAY") z4 = Zone(name="Stay delayed", stay_alert_delay=5, description="Alert delayed when armed STAY") z5 = Zone(name="Stay", stay_alert_delay=None, description="No alert when armed STAY") session.add_all([z1, z2, z3, z4, z5]) print(" - Created zones") session.add_all(SENSOR_TYPES) print(" - Created sensor types") s1 = Sensor(channel=0, sensor_type=SENSOR_TYPES[0], zone=z3, description="Garage") s2 = Sensor(channel=1, sensor_type=SENSOR_TYPES[2], zone=z5, description="Test room") s3 = Sensor(channel=2, sensor_type=SENSOR_TYPES[1], zone=z2, description="Tamper") session.add_all([s1, s2, s3]) print(" - Created sensors") kt1 = KeypadType(1, "DSC", "DSC keybus (DSC PC-1555RKZ)") kt2 = KeypadType(2, "WIEGAND", "Wiegand keypad") session.add_all([kt1, kt2]) print(" - Created keypad types") k1 = Keypad(keypad_type=kt1) session.add_all([k1]) print(" - Created keypads") session.commit()
def initialize_database(app, db): """Drop and restore database in a consistent state""" with app.app_context(): db.drop_all() db.create_all() first_network = Network(name='First Network', site='DEL18DT') first_network.sensors.extend([Sensor(name='Bulkhead 5 Water Level', value=50), Sensor(name='Bulkhead 7 Water Level', value=20), Sensor(name='Bulkhead 2 Water Level', value=40)]) second_network = Network(name='Second Network', site='DEL23DT') second_network.sensors.extend([Sensor(name='Rain Sensor Front Level', value=250), Sensor(name='Rain Sensor Back Level', value=620)]) db.session.add(first_network) db.session.add(second_network) db.session.commit()
def setUp(self): self.set_application(tst_app) self.setup_testbed() self.init_datastore_stub() self.init_memcache_stub() self.init_taskqueue_stub() self.init_app_identity_stub() self.init_mail_stub() self.register_search_api_stub() self.init_urlfetch_stub() self.init_blobstore_stub() self.init_modules_stub() cloudstorage.set_default_retry_params(None) # Create enterprise, sensortype and sensor self.e = Enterprise.Create() self.e.Update(name="Test Ent", timezone="Africa/Nairobi") self.e.put() self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False) self.owner.Update(name=OWNER_NAME, currency="KES") self.owner.put() self.spedometer = SensorType.Create(self.e) schema = {'speed': {'unit': 'kph'}, 'narrative': {'type': 'string'}} self.spedometer.Update(name="Spedometer", schema=json.dumps(schema)) self.spedometer.put() self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID, self.spedometer.key().id()) self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(), name="Vehicle Sensor 1") self.vehicle_1.put()
def testRecordAPIs(self): self.sensor1 = Sensor.Create(self.e, "000-100", self.st.key().id()) self.sensor1.put() now = datetime.now() r1_ts = tools.unixtime(now) r = Record.Create(tools.unixtime(now), self.sensor1, {'location': '51.5033640,-0.1276250'}) r2 = Record.Create( tools.unixtime(now) + 1000, self.sensor1, {'location': '51.5033640,-0.1276250'}) db.put([r, r2]) # Test list params = self.__commonParams() params.update({'sensor_kn': "000-100"}) result = self.get_json("/api/data", params) self.assertTrue(result['success']) self.assertEqual(len(result['data']['records']), 2) # Test detail params = self.__commonParams() result = self.get_json("/api/data/%s/%s" % ("000-100", r1_ts), params) self.assertTrue(result['success']) _r = result['data']['record'] self.assertEqual(_r['sensor_kn'], "000-100") self.assertEqual(_r['ts'], r1_ts) self.assertEqual( _r['kn'], "%s_%s_%s" % (self.e.key().id(), self.sensor1.key().name(), int(r1_ts)))
def testAlarmWithPayment(self): # Create smartphone report sensor self.smartphone_sensor_type = SensorType.Create(self.e) schema = {'agreement': {'unit': '1-5 scale'}} self.smartphone_sensor_type.Update(name="Report Sensor", schema=json.dumps(schema)) self.smartphone_sensor_type.put() self.smartphone_sensor = Sensor.Create( self.e, "1000", self.smartphone_sensor_type.key().id()) self.smartphone_sensor.Update( sensortype_id=self.smartphone_sensor_type.key().id(), name="Smartphone Reports 1", contacts={"user": self.owner.key().id()}) self.smartphone_sensor.put() # Create smartphone report rule with payment on any report PMNT_AMOUNT = 10.0 self.any_report_rule = Rule.Create(self.e) self.any_report_rule.Update( name="Any Report", sensortype_id=self.smartphone_sensor_type.key().id(), column="agreement", trigger=RULE.ANY_DATA, payment_contacts=["user"], payment_amount=PMNT_AMOUNT, consecutive_limit=RULE. ANY, # Deactivate immediately (should be == 1) duration=0) self.any_report_rule.put() self.assertTrue(self.any_report_rule.payments_enabled()) self.process = ProcessTask.Create(self.e) self.process.Update(rule_ids=[self.any_report_rule.key().id()]) self.process.put() # Apply our process to our sensor self.sp = SensorProcessTask.Create(self.e, self.process, self.smartphone_sensor) self.sp.put() BATCH_SIZE = 3 BATCH_1 = { 'agreement': [random.randint(1, 5) for x in range(BATCH_SIZE)], } self.__createNewRecords(BATCH_1, first_dt=datetime.now(), sensor=self.smartphone_sensor) self.__runProcessing() # This batch should have fired 3 alarms for any report, and created # 3 payments. pmnts = Payment.Fetch(self.owner) self.assertEqual(len(pmnts), 3) total_payments = BATCH_SIZE * PMNT_AMOUNT self.assertEqual(total_payments, sum([p.amount for p in pmnts]))
def post(self): form = SensorCreateForm() if not form.validate_on_submit(): return form.errors, 422 sensor = Sensor(form.name.data, form.description.data) db.session.add(sensor) db.session.commit() return SensorSerializer(sensor).data, 201
def node_add_sensors(node_id): """ Add a Sensor Registers sensor on nodes --- tags: - sensors definitions: - schema: id: Post_Sensor required: - id - type - pin properties: id: type: integer description: id of the sensor type: type: string description: type of sensor enum: ['door','temperature','trigger','led'] pin: type: integer description: the gpio pin number the sensor is on parameters: - in: body name: Sensor description: Sensor object to be added to the hub schema: $ref: '#/definitions/Post_Sensor' responses: 201: description: Returns the information received about the sensor """ payload = request.get_json() webid = payload.get("id") sensor = Sensor.get_by_webid(webid) if sensor: abort(409) pin = payload.get('pin') sensor_type = payload.get('type') if sensor_type == "door": sensor_type = "DOOR" elif sensor_type == "temperature": sensor_type = "TEMP" elif sensor_type == "humidity": sensor_type = "HUMI" elif sensor_type == "trigger": sensor_type = "TRIG" elif sensor_type == "led": sensor_type = "LED" else: abort(400) sensor = Sensor(node_id, pin, sensor_type, webid=webid) return json.jsonify({'sensor': {'node_id': node_id, 'pin': pin, 'sensor_type': sensor_type}}), 201
def testGeoFenceAlarm(self): self.geosensor = SensorType.Create(self.e) schema = { 'location': { 'unit': 'deg', 'label': "Location", 'role': [COLUMN.LOCATION], 'type': 'latlng' } } self.geosensor.Update(name="Geo Sensor", schema=json.dumps(schema)) self.geosensor.put() # Create off route alarm self.offroute_alarm = Rule.Create(self.e) self.offroute_alarm.Update(name="Off Route", sensortype_id=self.spedometer.key().id(), column="location", trigger=RULE.GEOFENCE_OUT, value_complex=json.dumps(DUMMY_GEOFENCE)) self.offroute_alarm.put() self.process = ProcessTask.Create(self.e) self.process.Update(rule_ids=[self.offroute_alarm.key().id()]) self.process.put() self.vehicle_2 = Sensor.Create(self.e, TEST_SENSOR_ID, self.geosensor.key().id()) self.vehicle_2.Update(name="Vehicle Sensor 2") # Apply our process to our sensor self.sp = SensorProcessTask.Create(self.e, self.process, self.vehicle_2) self.sp.put() # Process 8 location datapoints (3 in bounds, 3 out, 2 back in) BATCH_1 = { 'location': ["%s,%s" % (coord[0], coord[1]) for coord in ROUTE_DIVERSION] } self.__createNewRecords(BATCH_1, first_dt=datetime.now() - timedelta(minutes=20), interval_secs=30) self.__runProcessing() # Confirm off-route alarm fired upon datapoint 4, and deactivates on 7 (back in fence) alarms = Alarm.Fetch(self.vehicle_2, self.offroute_alarm) self.assertEqual(len(alarms), 1) a = alarms[0] first_record_in_alarm = a.first_record self.assertEqual(a.duration().seconds, 60) # 3 datapoints, 30 second gap oob_record = ROUTE_DIVERSION[3] self.assertEqual(first_record_in_alarm.columnValue('location'), "%s,%s" % (oob_record[0], oob_record[1]))
def setUp(self): self.set_application(tst_app) self.setup_testbed() self.init_datastore_stub() self.init_memcache_stub() self.init_taskqueue_stub() self.init_mail_stub() self.register_search_api_stub() self.init_urlfetch_stub() self.init_modules_stub() # Create enterprise, sensortype and sensor self.e = Enterprise.Create() self.e.Update(name="Test Ent", timezone="Africa/Nairobi") self.e.put() self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False) self.owner.Update(name=OWNER_NAME, currency="KES") self.owner.put() self.spedometer = SensorType.Create(self.e) schema = { 'speed': { 'unit': 'kph' }, 'bearing': { 'unit': 'deg' }, 'location': { 'unit': 'degrees' }, 'hard_braking': { 'unit': 'boolean' } } self.spedometer.Update(name="Geo Sensor", schema=json.dumps(schema)) self.spedometer.put() self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID, self.spedometer.key().id()) self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(), name="Vehicle Sensor 1", contacts={"owner": self.owner.key().id()}) self.vehicle_1.put() # Create alarm self.speeding_alarm = Rule.Create(self.e) self.speeding_alarm.Update(name="Speeding", sensortype_id=self.spedometer.key().id(), column="speed", trigger=RULE.CEILING, value2=80.0, alert_contacts=["owner"], alert_message=SPEEDING_ALERT_MESSAGE, duration=0) self.speeding_alarm.put()
def addSensor(len, index, addr, type, storage): for i in range(len): a=Sensor() a.sensor_index=index[i] a.storage=storage a.type=type a.location=addr[i] a.save()
def __init__(self, sensor_id, start_time, wait_interval = 60): Process.__init__(self) self.daemon = True self.wait_interval = wait_interval sensor = Sensor.query.filter(Sensor.id == sensor_id).first() if sensor: self.sensor = sensor else: self.sensor = Sensor.create(name = 'started at %s'%datetime.utcnow().ctime()) print '*********** Created new sensor' print self.sensor
def post(self): args = parser.parse_args() rpiId = int(args.rpiId) temp = float(args.temp) d = list(map(int, args.date.split('-'))) d = date(d[0], d[1], d[2]) t = list(map(int, args.time.split(':'))) t = time(t[0], t[1]) sensor = Sensor(rpiId=rpiId, temp=temp, date=d, time=t) db.session.add(sensor) db.session.commit() return {'status': 'OK'}
def getTask(task_id): mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB') cursor = mariadb_connection.cursor() cursor.execute("SELECT * FROM Sensor WHERE ID={}".format(task_id)) entry = cursor.fetchall() data = Sensor(entry[0][0], entry[0][1], entry[0][2]) closeConnection() return data.data
def testGeoJsonIn(self): uri = "/%s/inbox/json/%s" % (self.e.key().id(), TEST_SENSOR_ID) lat = 1.3 lon = 36.9 MOVE_SIZE = 0.01 MAX_ACCEL = 10 N_POINTS = 10 DELAY_SECS = 1 now = datetime.now() - timedelta(seconds=60) # Populate dummy data with random moves data = [] target_accel_mags = [] for x in range(N_POINTS): now += timedelta(seconds=DELAY_SECS) lat += (random.random() - 0.5) * MOVE_SIZE lon += (random.random() - 0.5) * MOVE_SIZE loc = "%s,%s" % (lat, lon) ax = (random.random() * MAX_ACCEL) - MAX_ACCEL / 2 ay = (random.random() * MAX_ACCEL) - MAX_ACCEL / 2 az = (random.random() * MAX_ACCEL) - MAX_ACCEL / 2 accel_mag = math.sqrt(pow(ax, 2) + pow(ay, 2) + pow(az, 2)) target_accel_mags.append(accel_mag) data.append({ 'timestamp': tools.unixtime(dt=now), # milliseconds 'location': loc, 'ax': ax, 'ay': ay, 'az': az }) last_loc = loc body = json.dumps(data) response = self.post(uri, body) self.assertEqual(response.status_int, 200) content = json.loads(response.normal_body) self.assertTrue(content['success']) self.assertEqual(content['data']['count'], N_POINTS) # Fetch created records from db records = Record.Fetch(self.geosensor1) self.assertEqual(len(records), N_POINTS) last_r = records[0] self.assertEqual(tools.unixtime(last_r.dt_recorded), tools.unixtime(now)) accel_mags = [r.columnValue('accel_mag') for r in records] self.assertListEqual(accel_mags, list(reversed(target_accel_mags))) # Confirm sensor state update self.geosensor1 = Sensor.get(self.geosensor1.key()) # Refetch from db self.assertEqual(self.geosensor1.location, db.GeoPt(last_loc))
def sensor(request): sensor_name = request.GET.get("sensor", "") value = request.GET.get("value", "") time = request.GET.get("time", "") from django.utils.timezone import get_current_timezone from django.utils import timezone if len(time) == 0: time_p = timezone.now() else: time_p = datetime.datetime.fromtimestamp(int(time), tz=get_current_timezone()) print time_p objs = Sensor.objects.filter(name=sensor_name) sensor = None if len(objs) > 0: sensor = objs[0] else: sensor = Sensor() sensor.name = sensor_name sensor.save() try: latest = Value.objects.filter(sensor=sensor).order_by("-pub_date")[0] # print "latest",str(latest) if time_p < latest.pub_date: print "WARNNING: Sensor time should be greater than last in DB" if latest.value == float(value): result = "No need to update data for sensor %s" % sensor print result HttpResponse(result) except IndexError: pass v = Value(sensor=sensor, pub_date=time_p, value=float(value)) v.save() return HttpResponse(str(sensor.name) + ":" + str(value))
def create_sensor(): data = request.json zone = db.session.query(Zone).get(request.json["zoneId"]) sensor_type = db.session.query(SensorType).get(data["typeId"]) sensor = Sensor( channel=data["channel"], zone=zone, sensor_type=sensor_type, description=data["description"], ) db.session.add(sensor) db.session.commit() return process_ipc_response(IPCClient().update_configuration())
def new(): """ New sensor form to create a sensor. """ form = SensorForm(request.form) if form.validate_on_submit(): sensor = Sensor(form.name.data, form.attribute.data, form.comment.data, form.c_1.data, form.c_2.data) db.session.add(sensor) db.session.commit() flash('You have successfully added a new sensor.', 'success') return redirect(url_for('sensors.view', id=sensor.id)) return render_template('sensors/new.html', form=form)
def testGeoJsonIn(self): uri = "/%s/inbox/json/%s" % (self.e.key().id(), TEST_SENSOR_ID) lat = 1.3 lon = 36.9 MOVE_SIZE = 0.01 MAX_ACCEL = 10 N_POINTS = 10 DELAY_SECS = 1 now = datetime.now() # Populate dummy data with random moves data = [] target_accel_mags = [] for x in range(N_POINTS): now += timedelta(seconds=DELAY_SECS) lat += (random.random()-0.5) * MOVE_SIZE lon += (random.random()-0.5) * MOVE_SIZE loc = "%s,%s" % (lat, lon) ax = (random.random() * MAX_ACCEL) - MAX_ACCEL/2 ay = (random.random() * MAX_ACCEL) - MAX_ACCEL/2 az = (random.random() * MAX_ACCEL) - MAX_ACCEL/2 accel_mag = math.sqrt(pow(ax,2)+pow(ay,2)+pow(az,2)) target_accel_mags.append(accel_mag) data.append({ 'timestamp': tools.unixtime(dt=now), # milliseconds 'location': loc, 'ax': ax, 'ay': ay, 'az': az }) last_loc = loc body = json.dumps(data) response = self.post(uri, body) self.assertEqual(response.status_int, 200) content = json.loads(response.normal_body) self.assertTrue(content['success']) self.assertEqual(content['data']['count'], N_POINTS) # Fetch created records from db records = Record.Fetch(self.geosensor1) self.assertEqual(len(records), N_POINTS) last_r = records[0] self.assertEqual(tools.unixtime(last_r.dt_recorded), tools.unixtime(now)) accel_mags = [r.columnValue('accel_mag') for r in records] self.assertListEqual(accel_mags, list(reversed(target_accel_mags))) # Confirm sensor state update self.geosensor1 = Sensor.get(self.geosensor1.key()) # Refetch from db self.assertEqual(self.geosensor1.location, db.GeoPt(last_loc))
def get_readings_by_date_test(): termometer = Sensor.find("Termometer") expected_readings_len = 24 - 12 + 1 begin = datetime(2020, 11, 26, 17, 12) end = datetime(2020, 11, 26, 17, 24) readings = termometer.get_readings_by_date(begin, end) if len(readings) != expected_readings_len: print("get_readings_by_date_test: FAILED") print(f"Expected outcome {expected_readings_len}, " f"Actual outcome {len(readings)}") else: print("get_readings_by_date_test: PASSED")
def sensor_delete(sensor_id): """ Delete a Sensor --- tags: - sensors responses: 200: description: Returns "Deleted" """ sensor = Sensor.get_by_webid(sensor_id) node = Node.get_by_id(sensor.node_id) node.remove_sensor(sensor.id) return json.jsonify({'message': 'Deleted'}), 201
def seed_site(sensors = 1, days = 7, interval_seconds = 3600): site = Site.create(name = 'seeded_site') node = Node.create(name = 'seeded_node', site = site, latitude = 35.146623 + random() / 100.0, longitude = 139.9835682 + random() / 100.0) sensortype = SensorType.create(name = 'HC SR-04', unit = 'cm') for i in range(sensors): sensor = Sensor.create(sensortype = sensortype, node = node, name = 'water distance %s'%i) timestamp = datetime.utcnow() - timedelta(days = 7) data = loggeobrowngen() n_readings = 0 while timestamp < datetime.utcnow(): Reading.create(sensor = sensor, value = data.next(), timestamp = timestamp) timestamp += timedelta(seconds = interval_seconds) n_readings += 1 data.close() return {'site': site, 'node': node}
def addsensor(): form = AddSensorForm() if form.validate_on_submit(): with create_session() as session: if not check_if_sensor_id_exists(form, session, Sensor): sensor = Sensor(place_id=form.sensor_place.data, sensor_id=form.sensor_id.data, gateway_id=form.sensor_gateway.data) session.add(sensor) update_record_status(form, session, Record) flash("Sensor added successfully", "success") else: flash("Sensor ID already registered in database", "error") return redirect(url_for('sensors')) return render_template("sensor-add.html", form=form)
def getTasks(amount): mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB') cursor = mariadb_connection.cursor() all_data = [] cursor.execute("SELECT * FROM Sensor") all_entries = cursor.fetchall() for row in all_entries: entry = Sensor(row[0], row[1], row[2]) all_data.append(entry.data) closeConnection() return all_data
def setUp(self): self.set_application(tst_app) self.setup_testbed() self.init_datastore_stub() self.init_memcache_stub() self.init_taskqueue_stub() self.register_search_api_stub() # Create enterprise, sensortype and sensor self.e = Enterprise.Create() self.e.Update(name="Test Ent") self.e.put() self.geosensor = SensorType.Create(self.e) schema = { 'location': { 'unit': 'deg', 'label': "Location", 'role': [COLUMN.LOCATION] }, 'ax': {}, 'ay': { 'unit': 'm/s^2', 'type': 'number' }, 'az': { 'unit': 'm/s^2', 'type': 'number' }, 'accel_mag': { 'unit': 'm/2^2', 'label': "Acceleration Magnitude", 'calculation': "SQRT([ax]^2 + [ay]^2 + [az]^2)" } } self.geosensor.Update(name="Geo Sensor", schema=json.dumps(schema)) self.geosensor.put() self.geosensor1 = Sensor.Create(self.e, TEST_SENSOR_ID, self.geosensor.key().id()) self.geosensor1.Update(sensortype_id=self.geosensor.key().id(), name="Geo Sensor 1") self.geosensor1.put()
def post(self): parser = reqparse.RequestParser(bundle_errors = True) parser.add_argument('node_id', type=int, location='form', required=True, help='<int> node_id required') parser.add_argument('sensortype_id', type=int, location='form', required=True, help='<int> sensortype_id required') parser.add_argument('name', type=int, location='form', required=False, help='<int> sensortype_id optional') args = parser.parse_args() node = Node.query.filter_by(id = args['node_id']).first() if not node: return jsonify(ApiError('node {} not found'.format(args['node_id']))) sensortype = SensorType.query.filter_by(id = args['sensortype_id']).first() if not sensortype: return jsonify(ApiError('sensortype {} not found'.format(args['sensortype_id']))) sensor = Sensor.create(node = node, sensortype = sensortype, name = args['name']) if sensor: return jsonify(ApiObjects(sensor.json())) else: return jsonify(ApiObjects())
def data(temp, hum, pres, pm2_5, pm10, pwd): if pwd == app.config['PASS']: now = datetime.now() sensor_names = ['temp', 'hum', 'pres', 'PM 2.5', 'PM 10'] sensor_units = ['°C', '%', 'hPa', 'μg /m³', 'μg /m³'] values = [temp, hum, pres, pm2_5, pm10] for (sensor_name, unit, value) in zip(sensor_names, sensor_units, values): sensor = Sensor.query.filter_by(name=sensor_name).first() if sensor is None: sensor = Sensor(name=sensor_name, unit=unit) db.session.add(sensor) db.session.commit() data = SensorData(date=time.mktime(now.timetuple()), value=value) sensor.data.append(data) db.session.add(data) db.session.commit() return redirect("/", code=303)
def setUp(self): self.set_application(tst_app) self.setup_testbed() self.init_datastore_stub() self.init_memcache_stub() self.init_taskqueue_stub() self.init_mail_stub() self.register_search_api_stub() self.init_urlfetch_stub() self.init_modules_stub() # Create enterprise, sensortype and sensor self.e = Enterprise.Create() self.e.Update(name="Test Ent", timezone="Africa/Nairobi") self.e.put() self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False) self.owner.Update(name=OWNER_NAME, currency="KES") self.owner.put() self.tracker = SensorType.Create(self.e) schema = { 'bearing': { 'unit': 'deg' }, 'location': { 'unit': 'deg', 'label': "Location", 'role': [COLUMN.LOCATION], 'type': 'latlng' } } self.tracker.Update(name="Geo Sensor", schema=json.dumps(schema)) self.tracker.put() self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID, self.tracker.key().id()) self.vehicle_1.Update(sensortype_id=self.tracker.key().id(), name="Vehicle Sensor 1", contacts={"owner": self.owner.key().id()}) self.vehicle_1.put()
def put_sql(name, value): """Connect to sql and put in values.""" session = Session() sensor = session.query(Sensor).filter(Sensor.name == name).first() print(sensor) if sensor: """Make timesensor post.""" time_data = SensorTimeData(data=value) sensor.timedata = sensor.timedata + [time_data] session.add(time_data) sensor.value = value session.add(sensor) else: sensor = Sensor(name=name, value=value) session.add(sensor) session.commit() session.close()
def init(db): try: db.session.query(SensorType).delete() db.session.query(Device).delete() db.session.query(Sensor).delete() db.session.query(Contact).delete() db.session.query(Relay).delete() except: pass st_t = SensorType(unit=u'°C', description=u'Temperatura', name='temperature') st_h = SensorType(unit=u'%', description=u'Vlažnost', name='humidity') st_b = SensorType(unit=u'V', description=u'Baterija', name='battery') d_zg = Device(description='Zgoraj') d_sp = Device(description='Spodaj') zgt = Sensor(sensor_code='ZGT', description='Temperatura (zgoraj)', max_possible_value=40, max_warning_value=33, min_possible_value=-10, min_warning_value=20, observable_measurements=3, observable_alarming_measurements=2, enable_warnings=True, device=d_zg, type=st_t, emit_every=5) zgb = Sensor(sensor_code='ZGB', description='Baterija (zgoraj)', max_possible_value=6, min_possible_value=0, min_warning_value=3.3, observable_measurements=3, observable_alarming_measurements=2, enable_warnings=True, device=d_zg, type=st_b, emit_every=10) spb = Sensor(sensor_code='SPB', description='Baterija (spodaj)', max_possible_value=6, min_possible_value=0, min_warning_value=3.3, observable_measurements=3, observable_alarming_measurements=2, enable_warnings=True, device=d_sp, type=st_b, emit_every=10) spt = Sensor(sensor_code='SPT', description='Temperatura (spodaj)', max_possible_value=40, max_warning_value=34, min_possible_value=-10, min_warning_value=20, observable_measurements=3, observable_alarming_measurements=2, enable_warnings=True, device=d_sp, type=st_t, emit_every=5) zgh = Sensor(sensor_code='ZGH', description=u'Vlažnost (zgoraj)', max_possible_value=100, max_warning_value=90, min_possible_value=0, min_warning_value=10, observable_measurements=3, observable_alarming_measurements=2, enable_warnings=False, device=d_zg, type=st_h, emit_every=5) sph = Sensor(sensor_code='SPH', description=u'Vlažnost (spodaj)', max_possible_value=100, max_warning_value=90, min_possible_value=0, min_warning_value=10, observable_measurements=3, observable_alarming_measurements=2, enable_warnings=False, device=d_sp, type=st_h, emit_every=5) c = Contact(name='Admin', phone='+123456789', email='admin') user = User(email='admin') user.password = '******' user.ping() for l in ['A', 'B']: for i in range(8): code = '%s%d' % (l, i) description = 'Rele %s' % code db.session.add( Relay(description=description, switch_on_text='ON', switch_off_text='OFF')) db.session.add(zgt) db.session.add(spt) db.session.add(zgh) db.session.add(sph) db.session.add(spb) db.session.add(zgb) db.session.add(c) db.session.add(user) db.session.commit()
from external_db import get_all from models import Sensor, Reading, User, save_external_db_record # Copy database to local database readings = get_all() for reading in readings: save_external_db_record(reading) # Grant sudo user all sensors sensors = Sensor.get() sudo = User.find("sudo") for sensor in sensors: sudo.grant_sensor_access(sensor)
def env_live_01(): session.add_all([ User(name="Administrator", role=ROLE_ADMIN, access_code="1234"), User(name="Chuck.Norris", role=ROLE_USER, access_code="1111"), ]) print(" - Created users") z1 = Zone(name="No delay", description="Alert with no delay") z2 = Zone(name="Away delayed", away_alert_delay=20, description="Alert delayed when armed AWAY") z3 = Zone(name="Stay delayed", stay_alert_delay=20, description="Alert delayed when armed STAY") z4 = Zone(name="Stay", stay_alert_delay=None, description="No alert when armed STAY") z5 = Zone(name="Away/Stay delayed", away_alert_delay=40, stay_alert_delay=20, description="Alert delayed when armed AWAY/STAY") z6 = Zone(name="Tamper", disarmed_delay=0, away_alert_delay=None, stay_alert_delay=None, description="Sabotage alert") session.add_all([z1, z2, z3, z4, z5, z6]) print(" - Created zones") session.add_all(SENSOR_TYPES) print(" - Created sensor types") s1 = Sensor(channel=0, sensor_type=SENSOR_TYPES[0], zone=z5, description="Garage") s2 = Sensor(channel=1, sensor_type=SENSOR_TYPES[0], zone=z5, description="Hall") s3 = Sensor(channel=2, sensor_type=SENSOR_TYPES[2], zone=z5, description="Front door") s4 = Sensor(channel=3, sensor_type=SENSOR_TYPES[0], zone=z3, description="Kitchen") s5 = Sensor(channel=4, sensor_type=SENSOR_TYPES[0], zone=z1, description="Living room") s6 = Sensor(channel=5, sensor_type=SENSOR_TYPES[0], zone=z4, description="Children's room") s7 = Sensor(channel=6, sensor_type=SENSOR_TYPES[0], zone=z4, description="Bedroom") s8 = Sensor(channel=7, sensor_type=SENSOR_TYPES[1], zone=z6, description="Tamper") session.add_all([s1, s2, s3, s4, s5, s6, s7, s8]) print(" - Created sensors") kt1 = KeypadType(1, "DSC", "DSC keybus (DSC PC-1555RKZ)") session.add_all([kt1]) print(" - Created keypad types") k1 = Keypad(keypad_type=kt1) session.add_all([k1]) print(" - Created keypads") session.commit()
def create_sensor(): sensor = request.get_json() sos_res = Sensor().create(sensor) response = make_response(sos_res.text, sos_res.status_code) response.headers['Content-Type'] = 'application/json; charset=utf-8' return response
def testStateUpdates(self): self.geosensor1 = Sensor.get(self.geosensor1.key()) # Refetch from db self.geosensor1.update_state(COLUMN.LOCATION, NBO_LOC) self.assertEqual(self.geosensor1.location, db.GeoPt(NBO_LOC))
from models import User, Sensor, Reading from time import sleep from datetime import datetime, timedelta import random sensors = { "Termometer (mock)": ("Celsius", "Temperature"), "Hygrometer (mock)": ("%", "Humidity"), "Manometer (mock)": ("bar", "Pressure") } users = ["John", "Alex", "Rob", "Matt"] for sensor_name, (unit, quantity) in sensors.items(): Sensor.create(sensor_name, quantity) # For the sake of tests for sensor_name, (unit, quantity) in sensors.items(): for i in range(120, 180, 1): t = datetime(2020, 11, 26, 17, i % 60, 0) Reading.create(str(random.randint(20, 27)), unit, Sensor.find(sensor_name).id, timestamp=t) # Let's have 4 readings per hour start_date = datetime.utcnow() - timedelta(days=4) now = datetime.utcnow() sampling_interval = timedelta(minutes=15) for sensor_name, (unit, quantity) in sensors.items(): sample_date = start_date
def create_update_sensor(message, address, signal_strength): try: current_time = datetime.datetime.now().replace(microsecond=0) name = message[0] float = True if message[1] == 'UP' else False trip_time = current_time if float else None battery = int(message[2]) / 10 temperature = int(message[3]) / 10 # delete the sensor if there is data when the same sensor name but different address sensor = Sensor.query.filter(Sensor.name == name, Sensor.address != address).first() if sensor: db.session.delete(sensor) db.session.commit() sensor = Sensor.query.filter_by(address=address).first() if not sensor: # does not exist, create one land = Land.query.filter_by(number=1).first() sensor = Sensor(name=name, battery=battery, float=float, temperature=temperature, signal_strength=signal_strength, land_id=land.id, address=address, last_update=current_time, trip_time=trip_time) db.session.add(sensor) db.session.commit() # add sensor configs for each config page config_pages = Config.query.all() for config_page in config_pages: sensor_config = SensorConfig(sensor_id=sensor.id, config_id=config_page.id) db.session.add(sensor_config) else: # exists, update the name and the date sensor.name = name sensor.status = True sensor.float = float sensor.trip_time = trip_time sensor.battery = battery sensor.temperature = temperature sensor.signal_strength = signal_strength sensor.last_update = current_time db.session.commit() return { 'id': sensor.id, 'name': name, 'last_update': str(current_time), 'battery': battery, 'float': float, 'temperature': temperature, 'signal_strength': signal_strength }, sensor except Exception as e: print(e) print("INVALID DATA FROM SENSORS")
def testGeoRadiusAlarm(self): # Create in radius alarm self.in_radius_alarm = Rule.Create(self.e) self.in_radius_alarm.Update( name="In Town", sensortype_id=self.tracker.key().id(), column="location", trigger=RULE.GEORADIUS_IN, value2=RADIUS, # m value_complex=json.dumps(RADIUS_CENTER), alert_contacts=["owner"], consecutive_limit=RULE.DISABLED, duration=0) self.in_radius_alarm.put() self.process = ProcessTask.Create(self.e) self.process.Update(rule_ids=[self.in_radius_alarm.key().id()]) self.process.put() self.vehicle_2 = Sensor.Create(self.e, TEST_SENSOR_ID, self.tracker.key().id()) self.vehicle_2.Update(name="Vehicle Sensor 2") # Apply our process to our sensor self.sp = SensorProcessTask.Create(self.e, self.process, self.vehicle_2) self.sp.put() INTERVAL_SECS = 4 test_data_start = datetime.now() - timedelta(minutes=20) # Process first data points entering radius BATCH_1 = { 'location': ["%s,%s" % (coord[0], coord[1]) for coord in ENTERS_RADIUS] } last_record = self.__createNewRecords(BATCH_1, first_dt=test_data_start, interval_secs=INTERVAL_SECS) self.__runProcessing() # Confirm in-radius alarm fired upon datapoint 4... alarms = Alarm.Fetch(self.vehicle_2, self.in_radius_alarm) self.assertEqual(len(alarms), 1) a = alarms[0] # Process second batch of data points exiting radius BATCH_2 = { 'location': ["%s,%s" % (coord[0], coord[1]) for coord in EXITS_RADIUS] } self.__createNewRecords(BATCH_2, interval_secs=INTERVAL_SECS) self.__runProcessing() # Confirm we still just have the single alarm record alarms = Alarm.Fetch(self.vehicle_2, self.in_radius_alarm) self.assertEqual(len(alarms), 1) a = alarms[0] duration_td = a.duration() self.assertIsNotNone(duration_td) # 3 datapoints in radius print a.json()