Пример #1
0
def _process_message(data):
    """ Process a data message and save it """

    
    reading_date = parser.parse(data['time'])
    try:
        # Check if the reading for this time already exists (ignore if so)
        Reading.objects.get(time = reading_date)
        return False
    except:
        pass
    
    # Save the reading into the DB
    reading = Reading()
    reading.time = reading_date
    reading.temperature = Decimal(str(data['temperature']))
    reading.meter_id = data['sensor_id']
    reading.meter_type = int(data['meter_type'])
    reading.ch1_wattage = Decimal(str(data['ch1']))
    if data.has_key('ch2'):
        reading.ch2_wattage = Decimal(str(data['ch2']))
    if data.has_key('ch3'):
        reading.ch3_wattage = Decimal(str(data['ch3']))
    
    reading.save()
Пример #2
0
 def submit( cls, uid, readingType, readingValue ):
     assert isinstance( uid, str )
     assert isinstance( readingType, str )
     assert isinstance( readingValue, float )
     
     source = cls.getSource( uid )
     
     reading = Reading( readingSource=source,
                        value=readingValue,
                        readingType=readingType )
     
     reading.put()
     
     return reading.addtime
Пример #3
0
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}
Пример #4
0
def add_reading():
    response = {"errors": None}
    reading = json.loads(request.data)
    try:
        mac_addr = reading["mac_address"]
    except KeyError:
        response["errors"] = "Please provide a valid mac address."
    print(reading)
    temperature = float(reading["temperature"])
    humidity = float(reading["humidity"])
    light_intensity = float(reading["light_intensity"])
    soil_moisture = float(reading["soil_moisture"])
    if mac_addr is not None:
        plant = Plant.query.filter_by(mac_address=mac_addr).first()
        reading = Reading(time=time.time(),
                          plant_id=plant.id,
                          temperature=temperature,
                          humidity=humidity,
                          light_intensity=light_intensity,
                          soil_moisture=soil_moisture,
                          mac_address=mac_addr,
                          moisture_index=None)
        db.session.add(reading)
        db.session.commit()
    return response
Пример #5
0
 def test_sanitizing_ecg_data_nullifies_readings_with_240_alphabets(self):
     now = tm.time()
     reading = Reading(time = now, values = ['A'] * 240)
     self.ecg_data.inject(reading = reading)
     data = sanitize(self.ecg_data)
     last_values = data.iloc[-1]["values"]
     self.assertTrue(np.nan in last_values, "Oops! null not returned for invalid chunk")
Пример #6
0
def update_database():
    last_data = {'readings': {'temp': 0, 'humidity': 0}, 'parameters': None}
    while 1:
        update_time = timezone.now()
        data = (yield)
        if (round(last_data["readings"]["temp"]) != round(
                data["readings"]["temp"])) or (round(
                    last_data["readings"]["humidity"]) != round(
                        data["readings"]["humidity"])):
            try:
                reading_record = Reading.objects.get(pk=1)
            except Reading.DoesNotExist:
                reading_record = Reading(time=update_time,
                                         temperature=data["readings"]["temp"],
                                         humidity=data["readings"]["humidity"])
            else:
                reading_record.time = update_time
                reading_record.temperature = data["readings"]["temp"]
                reading_record.humidity = data["readings"]["humidity"]
            reading_record.save()
        if last_data["parameters"] != data["parameters"]:
            setting_record = Setting(time=update_time,
                                     mode=data["parameters"]["mode"],
                                     temperature=data["parameters"]["temp"],
                                     humidity=data["parameters"]["humidity"])
            setting_record.save()
        last_data = data
Пример #7
0
def update_database():
    last_data = {'readings': {'temp': 0, 'humidity': 0}, 'parameters': None}
    while 1:
        update_time = timezone.now()
        data = (yield)
        # Round current temperature and humidity readings
        temperature_rounded = round(data["readings"]["temp"])
        humidity_rounded = round(data["readings"]["humidity"])

        # Compare rounded current readings against the rounded previous readings
        if (round(last_data["readings"]["temp"]) != temperature_rounded) or (
                round(last_data["readings"]["humidity"]) != humidity_rounded):
            try:
                reading_record = Reading.objects.get(pk=1)
            except Reading.DoesNotExist:
                reading_record = Reading(time=update_time,
                                         temperature=temperature_rounded,
                                         humidity=humidity_rounded)
            else:
                reading_record.time = update_time
                reading_record.temperature = temperature_rounded
                reading_record.humidity = humidity_rounded
            reading_record.save()
        if last_data["parameters"] != data["parameters"]:
            setting_record = Setting(time=update_time,
                                     source=0,
                                     mode=data["parameters"]["mode"],
                                     temperature=data["parameters"]["temp"],
                                     humidity=data["parameters"]["humidity"])
            setting_record.save()
        last_data = data
Пример #8
0
 def _getReadings(cls, uid, readingType ):
     """
     Get all the readings of a particular type
     """
     source = cls.getSource( uid )
     
     r = Reading.all()
     r.filter( "readingSource =", source )
     r.filter( "readingType =", readingType )
     r.order("-adddate")
     return [ re for re in r ]
Пример #9
0
def do_reading():
    """ Process reading """

    name = request.form.get('name')
    spread_id = request.form.get('spread_id')

    new_reading = Reading(name=name, spread_id=spread_id)

    db.session.add(new_reading)
    db.session.commit()

    return redirect('/readings')
Пример #10
0
async def api_create_reading(request, *, name, author, content):
    #check_admin(request)
    if not name or not name.strip():
        raise APIValueError('name', 'name cannot be empty.')
    if not author or not author.strip():
        raise APIValueError('author', 'author cannot be empty.')
    if not content or not content.strip():
        raise APIValueError('content', 'content cannot be empty.')
    reading = Reading(name=name.strip(),
                      author=author.strip(),
                      content=content.strip())
    await reading.save()
    return reading
Пример #11
0
	def post(self):
		parser = reqparse.RequestParser(bundle_errors = True)
		parser.add_argument('sensor_id', type=int, location='form', required=True, help='<int> sensor_id required')
		parser.add_argument('value', type=float, location='form', required=True, help='<float> value required')
		parser.add_argument('timestamp', type=float, location='form', required=True, help='<float> epoch timestamp required')
		args = parser.parse_args()

		sensor = Sensor.query.filter_by(id = args['sensor_id']).first()
		if not sensor:
			return jsonify(ApiError('sensor {} not found'.format(args['sensor_id'])))
		
		reading = Reading.create(sensor = sensor, value = args['value'], timestamp = args['timestamp'])
		return jsonify(ApiObjects(reading.json()))
Пример #12
0
def handle_mqtt_message(client, userdata, message):
    if message.topic == "SmartPlant_pairing":
        msg = message.payload.decode()
        print(msg)
        macform = MacAdressValidationForm()
        macform.addr.data = msg
        if macform.validate():
            with application.app_context():
                found = Device.query.filter_by(mac_address=msg).first()
                if not found:
                    device = Device(msg, time.time())
                    db.session.add(device)
                else:
                    found.last_seen = time.time()
                db.session.commit()
    elif message.topic == "SmartPlant":
        msg = message.payload.decode()
        msg = msg.replace('nan', '"nan"')
        print(msg)
        reading_data = json.loads(msg)

        # If no data for a field, do not save the reading.
        for i in reading_data.keys():
            if reading_data[i] == "nan":
                print("Failed to get complete reading data.")
                return None
        with application.app_context():
            plant = Plant.query.filter_by(
                mac_address=reading_data["mac_address"]).one_or_none()
            if plant and Reading.query.filter_by(
                    time=reading_data["time"],
                    mac_address=reading_data["mac_address"]).count() == 0:
                reading = Reading(
                    time=reading_data["time"],
                    plant_id=plant.id,
                    temperature=reading_data["temp"],
                    humidity=reading_data["humidity"],
                    light_intensity=reading_data["light_intensity"],
                    soil_moisture=reading_data['soil_moisture'] *
                    100,  # CONVERT TO PERCENTAGE for database.
                    moisture_index=reading_data["moisture_index"],
                    mac_address=reading_data["mac_address"])
                plant_health_alert(plant, plant.get_problems(reading))
                db.session.add(reading)
                db.session.commit()
            else:
                print("Similar recording.")
Пример #13
0
	def post(self):
		parser = reqparse.RequestParser(bundle_errors = True)		
		parser.add_argument('format', type=str, required = True, choices = ['json', 'compact'], help='<str> data format [json|compact]')
		parser.add_argument('readings', type=str, required = True, help='<str> multiple readings')
		parser.add_argument('node_id', type=int, help='<int> node_id required')
		parser.add_argument('timestamp', type=str, location = 'form', required = False, help='<str> timestamp required. Format: %Y-%m-%d %H:%M:%S')
		args = parser.parse_args()
		stored_readings = list()
		if args['format'] == 'compact':
			try:
				timestamp = '20' + args['timestamp']	
				timestamp = datetime.strptime(timestamp, '%Y-%m-%d %H:%M:%S')
			except (ValueError, TypeError):
				timestamp = datetime.utcnow()
				#return jsonify(ApiError('could not parse timestamp: {}'.format(args['timestamp'])))

			try:
				readings = args['readings'].split(';')
				unpacked = map(lambda r: tuple(r.split(',')), readings)
				for r in unpacked: assert len(r) == 2
			except Exception:
				return jsonify(ApiError('Could not store data. Please submit data in the format "sensor_id,value;sensor_id,value;..."'))	

			# node = Node.query.filter_by(id = args['node_id']).first()
			# if not node:
			# 	return jsonify(ApiError('no such node: {}'.format(args['node_id'])))

			for sensor_id, value in unpacked:
				try:
					sensor_id = int(sensor_id)
				except ValueError:
					return jsonify(ApiError('could not convert sensor_id into integer: {}'.format(sensor_id)))
				sensor = Sensor.query.filter_by(id = sensor_id).first()
				if not sensor:
					return jsonify(ApiError('sensor {} not found'.format(sensor_id)))
				try:
					value = float(value)
				except ValueError:
					return jsonify(ApiError('value could not be converted to a number: {}'.format(value)))
				reading = Reading.create(sensor = sensor, value = value, timestamp = timestamp)
				stored_readings.append(reading.json())
			return jsonify(ApiObjects(stored_readings))
Пример #14
0
def add_currently_reading(isbn, user_id):
    try:
        book = db.session.query(Book).filter_by(ISBN=isbn).first()
        book_id = book.book_id

        db.session.add(
            Reading(user_id=user_id,
                    book_id=book_id,
                    start_date=datetime.date.today()))
        db.session.add(
            Activity(user_id=user_id,
                     action_id=IS_READING_ACTION_ID,
                     object_id=BOOK_OBJECT_ID,
                     date_created=datetime.datetime.now(),
                     target_id=book_id))
        db.session.commit()

        return make_response(jsonify({"success": "Added to bookshelf"}), 201)
    except AttributeError:
        traceback.print_exc()
        return make_response(jsonify({"error": "Failed to add to shelf"}), 404)
Пример #15
0
    def post(self):
        parser = reqparse.RequestParser()
        print request.headers
        #parser.add_argument('X-Temperature', required=True, location='headers', help="Temperature can't be blank!")
        parser.add_argument('Content-Type',
                            required=True,
                            location='headers',
                            help="Temperature can't be blank!")
        #parser.add_argument('X-Sensor-Id', required=True, location='headers', help="Sensor-Id can't be blank!")
        args = parser.parse_args()
        print args
        idx = args['Content-Type'].find('Temperature: ')
        temperature = args['Content-Type'][idx + 13:idx + 15]
        idx = args['Content-Type'].find('Sensor-Id: ')
        sensor_id = args['Content-Type'][idx + 11]

        print "TEMP:", temperature
        print "ID:", sensor_id
        reading = Reading(temperature, sensor_id)
        db.session.add(reading)
        db.session.commit()
        return ReadingSerializer(reading).data, 201
Пример #16
0
def add_record():
    content = request.json

    # check for duplicate timestamp
    same_times = Reading.query.filter_by(time=content["time"]).first()
    if same_times is None:
        reading = Reading(baro_temp=content["baro_temp"],
                          baro_pressure=content["baro_pressure"],
                          cpu_temp=content["cpu_temp"],
                          humid_temp=content["humid_temp"],
                          humid_humid=content["humid_humid"],
                          light=content["light"],
                          time=content["time"],
                          soil_moisture=content["soil_moisture"],
                          water_level=content["water_level"],
                          pump_status=content["pump_status"])
        db.session.add(reading)
        db.session.commit()
        return "Record Added {}".format(reading.id)

    else:
        return ('duplicate timestamp')
def update_database():
	last_data = {'readings':{'temp':0,'humidity':0}, 'parameters':None}
	while 1:
		update_time = timezone.now()
		data = (yield)
		if (round(last_data["readings"]["temp"]) != round(data["readings"]["temp"])) or (round(last_data["readings"]["humidity"]) != round(data["readings"]["humidity"])):
			try:
				reading_record = Reading.objects.get(pk=1)
			except Reading.DoesNotExist:
				reading_record = Reading(time=update_time, temperature=data["readings"]["temp"], humidity=data["readings"]["humidity"])
			else:
				reading_record.time = update_time
				reading_record.temperature = data["readings"]["temp"]
				reading_record.humidity = data["readings"]["humidity"]
			reading_record.save()
		if last_data["parameters"] != data["parameters"]:
			setting_record = Setting(time=update_time, mode=data["parameters"]["mode"], temperature=data["parameters"]["temp"], humidity=data["parameters"]["humidity"])
			setting_record.save()
		last_data = data
def update_database():
	last_data = {'readings':{'temp':0,'humidity':0}, 'parameters':None}
	while 1:
		update_time = timezone.now()
		data = (yield)
		# Round current temperature and humidity readings
		temperature_rounded = round(data["readings"]["temp"])
		humidity_rounded = round(data["readings"]["humidity"])

		# Compare rounded current readings against the rounded previous readings
		if (round(last_data["readings"]["temp"]) != temperature_rounded) or (round(last_data["readings"]["humidity"]) != humidity_rounded):
			try:
				reading_record = Reading.objects.get(pk=1)
			except Reading.DoesNotExist:
				reading_record = Reading(time=update_time, temperature=temperature_rounded, humidity=humidity_rounded)
			else:
				reading_record.time = update_time
				reading_record.temperature = temperature_rounded
				reading_record.humidity = humidity_rounded
			reading_record.save()
		if last_data["parameters"] != data["parameters"]:
			setting_record = Setting(time=update_time, source=0, mode=data["parameters"]["mode"], temperature=data["parameters"]["temp"], humidity=data["parameters"]["humidity"])
			setting_record.save()
		last_data = data
Пример #19
0
	def run(self):
		for value in loggeobrowngen():
			reading = Reading.create(sensor = self.sensor, value = value, timestamp = datetime.now())
			print reading
			time.sleep(self.wait_interval)
Пример #20
0
def upload_file():
    if request.method == 'POST':
        f_image = request.files.getlist('image')[0]
        f_audio = request.files.getlist('audio')[0]
        pi_id = request.form['pi_i']
        r_ids = json.loads(request.form['r_ids'])
        pi_serial = request.form['pi_s']
        r = True if request.form['r'] == 'T' else False
        d = request.form['d']
        k = request.form['k']
        i = request.form['i']
        w = request.form['w']
        s = request.form['s']
        spect = list(map(lambda x: array(x), json.loads(request.form['spe'])))
        laser = list(map(lambda x: string_t(x),
                         json.loads(request.form['la'])))
        led = list(map(lambda x: string_t(x), json.loads(request.form['le'])))
        uv = list(map(lambda x: string_t(x), json.loads(request.form['uv'])))
        read_image = f_image.read()
        read_audio = f_audio.read()
        s3_image_return = s3.Bucket(Config.S3_BUCKET).put_object(
            Key=k, Body=read_image)
        s3_audio_return = s3.Bucket(Config.S3_BUCKET).put_object(
            Key=i, Body=read_audio)
        if (len(spect[0]) and len(spect)):
            result = Result(pi_id=pi_id,
                            pi_serial=pi_serial,
                            s3_key=k,
                            etag=s3_image_return.e_tag,
                            ripe=r,
                            timestamp=d,
                            weather=w,
                            slap_type=s,
                            s3_audio_key=i,
                            etag_audio=s3_audio_return.e_tag)
            db.session.add(result)
            for i, s in enumerate(spect):
                reading = Reading(id=r_ids[i],
                                  timestamp=d,
                                  pi_id=pi_id,
                                  pi_serial=pi_serial,
                                  reading=db.cast(s, ARRAY(db.Integer)),
                                  laser=laser[i],
                                  led=led[i],
                                  uv=uv[i])
                result.readings.append(reading)
                db.session.add(reading)
        else:
            result = Result(pi_id=pi_id,
                            pi_serial=pi_serial,
                            s3_key=k,
                            etag=s3_image_return.e_tag,
                            ripe=r,
                            timestamp=d,
                            weather=w,
                            slap_type=s,
                            s3_audio_key=i,
                            etag_audio=s3_audio_return.e_tag)
            db.session.add(result)

        db.session.commit()
        #eval_result = predictor.eval_result(read_file)

        #print("result:",str(result))
        #print("eval:",str(eval_result))
        return (str(result))
    else:
        return ("POST API Endpoint only")
Пример #21
0
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
    while sample_date < now:
        Reading.create(str(random.randint(20, 27)),
                       unit,
                       Sensor.find(sensor_name).id,
                       timestamp=sample_date)
        sample_date = sample_date + sampling_interval
Пример #22
0
db.session.add(Card(number=1, arcana="Major", name="The Magician"))
db.session.add(Card(number=2, arcana="Major", name="The High Priestess"))
db.session.add(Card(number=3, arcana="Major", name="The Empress"))
db.session.add(Card(number=4, arcana="Major", name="The Emperor"))
db.session.add(Card(number=5, arcana="Major", name="The Heirophant"))
db.session.add(Card(number=6, arcana="Major", name="The Lovers"))
db.session.add(Card(number=7, arcana="Major", name="The Chariot"))

db.session.add(
    Spread(name="Three Card Spread",
           num_of_cards=3,
           image_url="/",
           description="..."))

db.session.add(
    Spread(name="Celtic Cross",
           num_of_cards=10,
           image_url="/",
           description="..."))

db.session.add(Placement(spread_id=1, num=1, details="past"))
db.session.add(Placement(spread_id=1, num=2, details="present"))
db.session.add(Placement(spread_id=1, num=3, details="future"))

db.session.add(Reading(spread_id=1, thoughts="meow"))

db.session.add(ReadingCardPlacement(reading_id=1, card_num=3, placement_id=1))
db.session.add(ReadingCardPlacement(reading_id=1, card_num=7, placement_id=2))
db.session.add(ReadingCardPlacement(reading_id=1, card_num=0, placement_id=3))

db.session.commit()