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 _save_sensor(params):
try:
sensor = Sensor(**params)
sensor.save()
except:
print params
raise
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 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 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 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 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 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 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 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()
#initialize db with first tenants and sensors
import random
from models import engine, db_session, Base, Tenant, Data, Sensor
Base.metadata.create_all(bind=engine)
#add first user
kate = Tenant(name='kate')
db_session.add(kate)
#add second user
kate_multitenancy = Tenant(name='kate_multitenancy')
db_session.add(kate_multitenancy)
#add sensors
t = Sensor(name='temperature')
db_session.add(t)
e = Sensor(name='electricity')
db_session.add(e)
p = Sensor(name='pressure')
db_session.add(p)
users = [kate, kate_multitenancy]
sensors = [e,p,t]
#add 100 entries
n = 100
for i in range(n):
v = random.randrange(200)
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 models import Player
from models import Sensor
import datetime, time
bob = Player(0, "Bob", {"name": "Bob","age": 25,"weight": 180,"height": 6.3})
sensor = Sensor(1, "arduino101", "Bob's Helmet")
bob.associate_sensor(sensor)
from flask import Flask, request, jsonify
app = Flask("Sports Medicine Manager")
@app.route('/api/send_event', methods=["POST"])
def send_event():
sensor.add_datapoint(int(time.time()*1000), float(request.get_data().decode("ascii", "ignore").strip()))
return 'OK'
@app.route("/api/get_datapoints")
def get_datapoints():
return jsonify({"data":sensor.data})
@app.route("/api/get_player_bio")
def get_player_bio():
return jsonify({"info":bob.info})
@app.route('/static/<path:path>')
def send_js(path):
return send_from_directory('static', path)
if __name__ == '__main__':
app.run("0.0.0.0")
import serial
import time
from sys import exit
from models import Arduino, Sensor #Import models from models.py
try:
arduino = Arduino()
except Exception as e:
#Print the erro if it occurs
print(e)
exit()
try:
ldrs = [] #This array stores all of the sensors
ldrs.append(Sensor(1, arduino))
ldrs.append(Sensor(2, arduino))
except Exception as e:
print("Error occured creating sensor")
try:
#Wait for the arduino to return startup message
time.sleep(1)
print(arduino.readBuffer())
while True:
req_id = int(input(">>> "))
if req_id == 0:
arduino.closeConnection()
exit()
#Look if uid exists
for ldr in ldrs:
if __name__ == '__main__':
if len(sys.argv[1:]) != 3:
raise Exception(
'the length of the parameters must be 3: Type Name Port')
# get args
type_ = sys.argv[1]
name = sys.argv[2]
port = int(sys.argv[3])
if type_ == 'actuator':
eq = Actuator(external_ip, port, name)
elif type_ == 'sensor':
eq = Sensor(external_ip, port, name)
else:
raise Exception(f'Received: {type_} must be: actuator or sensor')
# Run a gRPC server with one thread.
server = grpc.server(futures.ThreadPoolExecutor(max_workers=1))
# Adds the servicer class to the server.
messages_pb2_grpc.add_EquipmentServiceServicer_to_server(eq, server)
server.add_insecure_port(f'{ip}:{port}')
server.start()
print(f'API server started. Listening at {ip}:{port}.')
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 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")
from models import Sensor, Arduino, storeReadings
from cred import *
import time
import json
import boto3
def toTemp(current):
return ((400/61)*float(current)) - (1636/61)
client = boto3.client('kinesis')
arduino = Arduino()
ldrs = [] #This array stores all of the sensors
ldrs.append(Sensor(1, arduino, "sensor1"))
ldrs.append(Sensor(2, arduino, "sensor2"))
ldrs.append(Sensor(3, arduino, "sensor3"))
ldrs.append(Sensor(4, arduino, "sensor4"))
sensor = Sensor(1, arduino, "test")
time.sleep(2)
try:
while True:
readings = sensor.getReading()
reading_dict = json.dumps({'sensor1':toTemp(readings[0]), 'sensor2':toTemp(readings[1]), 'sensor3':toTemp(readings[2]), 'sensor4':toTemp(readings[3])})
response = client.put_record(StreamName="testStream", Data=reading_dict, PartitionKey="partitionkey")
print(reading_dict)
except KeyboardInterrupt:
print("exiting")
arduino.closeConnection()
