Big rewrite !!!
Data objects has subclasses for GPS, system and BME280 and moved to module
This commit is contained in:
Pierrick C
parent
9b36c49893
commit
fba971349c
|
|
@ -0,0 +1,421 @@
|
|||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
"""Cameteo module
|
||||
|
||||
Data classes for GPS, BME280 sensors and some system stuff
|
||||
Function to handle data files rotation and set internal RTC date from other
|
||||
(more reliable) sources.
|
||||
"""
|
||||
|
||||
import os
|
||||
import time
|
||||
import rtc
|
||||
import microcontroller
|
||||
import board
|
||||
from busio import I2C, UART
|
||||
from analogio import AnalogIn
|
||||
from digitalio import DigitalInOut, Direction
|
||||
from adafruit_bme280 import Adafruit_BME280_I2C
|
||||
from adafruit_gps import GPS
|
||||
|
||||
TIME_FORMAT = "{:04}/{:02}/{:02}_{:02}:{:02}:{:02}" # Date/time format
|
||||
|
||||
# Set the pin N°13 to use the onboard LED as read-only/read-write indicator
|
||||
# (RED = read-only, no data recorded)
|
||||
LED13 = DigitalInOut(board.D13)
|
||||
LED13.direction = Direction.OUTPUT
|
||||
LED13.value = False
|
||||
|
||||
###########
|
||||
# Classes #
|
||||
###########
|
||||
|
||||
class Data:
|
||||
"""Class for handling data"""
|
||||
|
||||
def __init__(self,
|
||||
name,
|
||||
update_interval=10,
|
||||
write_interval=300,
|
||||
send_interval=60,
|
||||
debug=False):
|
||||
|
||||
self.name = name
|
||||
self.data = {}
|
||||
self.debug = debug
|
||||
self.update_interval = update_interval
|
||||
self.write_interval = write_interval
|
||||
self.send_interval = send_interval
|
||||
self._last_update = 0
|
||||
self._last_backup = 0
|
||||
self._last_send = 0
|
||||
|
||||
# Check if data directories exists if we need to use them
|
||||
if self.write_interval >= 0:
|
||||
try:
|
||||
if 'data' not in os.listdir():
|
||||
os.mkdir('data')
|
||||
os.mkdir('data/hourly')
|
||||
os.mkdir('data/daily')
|
||||
elif 'hourly' not in os.listdir('data'):
|
||||
os.mkdir('data/hourly')
|
||||
elif 'daily' not in os.listdir('data'):
|
||||
os.mkdir('data/daily')
|
||||
except OSError as err:
|
||||
print("Err {}: readonly".format(err))
|
||||
self.write_interval = -1 # to avoid trying again till next reset
|
||||
# Turn onboard led on to indicate read-only error
|
||||
LED13.value = True
|
||||
|
||||
def __str__(self):
|
||||
"""Serialize data for visualization on serial console"""
|
||||
output = self.name + ":\n"
|
||||
for item in self.data.items():
|
||||
output += "\t{0}: {1}\n".format(*item)
|
||||
return output
|
||||
|
||||
def __repr__(self):
|
||||
return self.name
|
||||
|
||||
def update(self, current, verbose=True):
|
||||
"""Read the data from sensors and update the data dict variable"""
|
||||
if self.debug:
|
||||
print("Update {} : Current : {} | Last : {} | Interval : {}".format(
|
||||
self.name,
|
||||
current,
|
||||
self._last_update,
|
||||
self.update_interval))
|
||||
if current - self._last_update >= self.update_interval:
|
||||
self._last_update = current
|
||||
self._update()
|
||||
if verbose:
|
||||
print(self)
|
||||
|
||||
def _update(self):
|
||||
"""Here comes specific update code"""
|
||||
pass
|
||||
|
||||
@property
|
||||
def json(self):
|
||||
"""Serialized data to compact json-formatted string"""
|
||||
output = '{"' + self.name + '":{'
|
||||
first_data = True
|
||||
for name, value in self.data.items():
|
||||
if first_data:
|
||||
comma = ""
|
||||
first_data = False
|
||||
else:
|
||||
comma = ","
|
||||
output = '{}{}"{}":"{}"'.format(output, comma, name, value)
|
||||
output = output + '}}'
|
||||
return output
|
||||
|
||||
def csv(self, header=False):
|
||||
"""Serialized data values (or keys if header=True) as CSV line"""
|
||||
if header:
|
||||
return ";".join(self.data.keys())
|
||||
|
||||
return ";".join(self.data.values())
|
||||
|
||||
def write_on_flash(self, current, verbose=True):
|
||||
"""Save the current data as csv file on SPI flash"""
|
||||
if self.write_interval >= 0:
|
||||
if self.debug:
|
||||
print("Write {} : Current : {} | Last : {} | Interval : {}".format(
|
||||
self.name,
|
||||
current,
|
||||
self._last_backup,
|
||||
self.write_interval))
|
||||
if current - self._last_backup >= self.write_interval:
|
||||
self._last_backup = current
|
||||
file_name = "{}.csv".format(self.name)
|
||||
file_path = "data/"
|
||||
try:
|
||||
#Check if the file exists. If not, creates it with CSV header
|
||||
if file_name not in os.listdir(file_path):
|
||||
with open("/".join((file_path, file_name)), "w") as csv_file:
|
||||
csv_file.write(self.csv(header=True))
|
||||
csv_file.write("\n")
|
||||
if verbose:
|
||||
print("File created : {}".format(file_name))
|
||||
|
||||
with open("/".join((file_path, file_name)), "a") as csv_file:
|
||||
csv_file.write(self.csv())
|
||||
csv_file.write("\n")
|
||||
if verbose:
|
||||
print("Written data : \n{}".format(self.csv()))
|
||||
|
||||
except OSError as err:
|
||||
print("Err {}: readonly".format(err))
|
||||
# to avoid trying again till next reset
|
||||
self.write_interval = -1
|
||||
# Turn onboard led on to indicate read-only filesystem
|
||||
LED13.value = True
|
||||
|
||||
def send_json(self, current, uart, verbose=True):
|
||||
"""Send JSON string over UART"""
|
||||
if self.debug:
|
||||
print("Send {} : Current : {} | Last : {} | Interval : {}".format(
|
||||
self.name,
|
||||
current,
|
||||
self._last_send,
|
||||
self.send_interval))
|
||||
if current - self._last_send >= self.send_interval:
|
||||
self._last_send = current
|
||||
uart.write(self.json)
|
||||
uart.write("\n")
|
||||
if verbose:
|
||||
print(self.json)
|
||||
#print("\n")
|
||||
|
||||
|
||||
class SysData(Data):
|
||||
"""Subclass for Feather board data"""
|
||||
|
||||
def __init__(self, name="SYS", update_interval=10, write_interval=300,
|
||||
send_interval=60, debug=False):
|
||||
|
||||
Data.__init__(self, name=name,
|
||||
update_interval=update_interval,
|
||||
write_interval=write_interval,
|
||||
send_interval=send_interval,
|
||||
debug=debug)
|
||||
|
||||
self.data = {'time': "2000/01/01_00:00:00",
|
||||
'vbat': int(),
|
||||
'cput': float()}
|
||||
|
||||
# Battery voltage
|
||||
self.vbat = AnalogIn(board.VOLTAGE_MONITOR)
|
||||
self._rtc = rtc.RTC()
|
||||
|
||||
def _update(self):
|
||||
""" Update data from Feather board"""
|
||||
self.data['time'] = TIME_FORMAT.format(*self._rtc.datetime[0:6])
|
||||
self.data['cput'] = round(microcontroller.cpu.temperature, 2)
|
||||
|
||||
# Note about v_bat calculation :
|
||||
# 0.000100708 = 2*3.3/65536 with
|
||||
# 2 : voltage is divided by 2
|
||||
# 3.3 : Vref = 3.3V
|
||||
# 65536 : 16bit ADC
|
||||
val = 0
|
||||
samples = 10
|
||||
for sample in range(samples):
|
||||
val += self.vbat.value
|
||||
time.sleep(0.01)
|
||||
self.data['vbat'] = round(val/samples*0.000100708, 3)
|
||||
|
||||
|
||||
class BME280Data(Data):
|
||||
"""Subclass for BME280 sensor"""
|
||||
|
||||
def __init__(self, name="BME", update_interval=10, write_interval=300,
|
||||
send_interval=60, debug=False):
|
||||
|
||||
Data.__init__(self, name=name,
|
||||
update_interval=update_interval,
|
||||
write_interval=write_interval,
|
||||
send_interval=send_interval,
|
||||
debug=debug)
|
||||
|
||||
self.data = {'time' : "2000/01/01_00:00:00",
|
||||
'temp': float(),
|
||||
'hum': int(),
|
||||
'press': float()}
|
||||
# BME280 sensors (I2C)
|
||||
# i2c addresses for BME280 breakout :
|
||||
# 0x77 = adafruit breakout board
|
||||
# 0x76 = tiny cheap chinese board
|
||||
self.bme280 = Adafruit_BME280_I2C(I2C(board.SCL, board.SDA),
|
||||
address=0x76)
|
||||
|
||||
def _update(self):
|
||||
"""Update data from BME280"""
|
||||
self.data['time'] = TIME_FORMAT.format(*time.localtime()[0:6])
|
||||
self.data['temp'] = round(self.bme280.temperature, 1)
|
||||
self.data['hum'] = int(self.bme280.humidity)
|
||||
self.data['press'] = round(self.bme280.pressure, 2)
|
||||
|
||||
def rgb(self, neopixel_max=70):
|
||||
"""Convert atmospheric data from BME280 sensor into NeoPixel color as
|
||||
a tuple (RED, BLUE, GREEN):
|
||||
* RED => temperature : max = 35degC, min =10degC (range 25°C)
|
||||
* BLUE => humidity : max= 100%, mini=0%
|
||||
* GREEN => pression : mini=960hPa, maxi = 1030hPa (range 70hPa)
|
||||
"""
|
||||
# RED componant calculation from temperature data
|
||||
# 10 is the min temperature, 25 is the range
|
||||
# (10+25=35°C = max temperature)
|
||||
red = int((self.data['temp']-10)*neopixel_max/25)
|
||||
if red > neopixel_max:
|
||||
red = neopixel_max
|
||||
if red < 0:
|
||||
red = 0
|
||||
|
||||
# BLUE componant calculation: very simple! By definition relative
|
||||
# humidity cannot be more than 100 or less than 0, physically
|
||||
blue = int(self.data['hum']*neopixel_max/100)
|
||||
|
||||
# GREEN component calculation : 960 is the minimum pressure and 70 is
|
||||
# the range (960+70 = 1030hPa = max pressure)
|
||||
green = int((self.data['press']-960)*neopixel_max/70)
|
||||
if green > neopixel_max:
|
||||
green = neopixel_max
|
||||
if green < 0:
|
||||
green = 0
|
||||
|
||||
if self.debug:
|
||||
print("Col:{}".format((red, green, blue)))
|
||||
|
||||
return (red, green, blue)
|
||||
|
||||
|
||||
class GPSData(Data):
|
||||
"""Sub class for GPS"""
|
||||
|
||||
def __init__(self, name="GPS",
|
||||
update_interval=0, write_interval=60, send_interval=60,
|
||||
enable=True, enable_pin=DigitalInOut(board.A5),
|
||||
rtc=None, debug=False):
|
||||
|
||||
Data.__init__(self, name=name,
|
||||
update_interval=update_interval,
|
||||
write_interval=write_interval,
|
||||
send_interval=send_interval,
|
||||
debug=debug)
|
||||
|
||||
self.data = {'time': "2000/01/01_00:00:00",
|
||||
'lat': float(),
|
||||
'lon': float(),
|
||||
'alt': float(),
|
||||
'qual': int(),
|
||||
'age': int()}
|
||||
self._rtc = rtc
|
||||
self._enable = enable
|
||||
self._gps_last_fix = int()
|
||||
self._gps_current_fix = int()
|
||||
|
||||
# Set the pin to control the power to GPS module
|
||||
self._gps_en_pin = enable_pin
|
||||
self._gps_en_pin.direction = Direction.OUTPUT
|
||||
|
||||
self._gps = GPS(UART(board.TX, board.RX, baudrate=9600, timeout=3000)) #, debug=self.debug)
|
||||
|
||||
if self._enable:
|
||||
self.enable()
|
||||
else:
|
||||
self.disable()
|
||||
|
||||
def _update(self):
|
||||
self._gps.update()
|
||||
|
||||
if self._enable:
|
||||
self._gps_current_fix = int(time.monotonic())
|
||||
self.data['time'] = TIME_FORMAT.format(
|
||||
self._gps.timestamp_utc.tm_year,
|
||||
self._gps.timestamp_utc.tm_mon,
|
||||
self._gps.timestamp_utc.tm_mday,
|
||||
self._gps.timestamp_utc.tm_hour,
|
||||
self._gps.timestamp_utc.tm_min,
|
||||
self._gps.timestamp_utc.tm_sec)
|
||||
if self._rtc is not None:
|
||||
set_clock_from_localtime(self._rtc)
|
||||
if self._gps.has_fix:
|
||||
self._gps_last_fix = self._gps_current_fix
|
||||
self.data['lat'] = self._gps.latitude
|
||||
self.data['lon'] = self._gps.longitude
|
||||
self.data['alt'] = self._gps.altitude_m
|
||||
self.data['qual'] = self._gps.fix_quality
|
||||
self.data['age'] = 0
|
||||
else:
|
||||
self.data['age'] = int(self._gps_current_fix - self._gps_last_fix)
|
||||
else:
|
||||
self.data = {}
|
||||
|
||||
def enable(self):
|
||||
"""Enable GPS module"""
|
||||
# Set GPS module on FeatherWing board
|
||||
|
||||
if not self._enable:
|
||||
self._enable = True
|
||||
self._gps_en_pin.value = not self._enable # Set enable pin high to disable GPS module
|
||||
time.sleep(0.1)
|
||||
|
||||
# Turn on the basic GGA and RMC info
|
||||
self._gps.send_command('PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
|
||||
self._gps.send_command('PMTK220,1000') # 1000 ms refresh rate
|
||||
|
||||
if self._rtc is not None:
|
||||
rtc.set_time_source(self._rtc)
|
||||
if self.debug:
|
||||
print("GPS is the time source!")
|
||||
|
||||
def disable(self):
|
||||
"""Disable GPS module"""
|
||||
if self._enable:
|
||||
self._enable = False
|
||||
self._gps_en_pin.value = not self._enable # Set enable pin high to disable GPS module
|
||||
# Switch backto internal RTC
|
||||
rtc.set_time_source(rtc.RTC())
|
||||
|
||||
|
||||
#############
|
||||
# Functions #
|
||||
#############
|
||||
|
||||
def rotate_files(last_time, debug=False):
|
||||
"""Check if files need to rotate
|
||||
=> every new hour
|
||||
=> every new day
|
||||
"""
|
||||
current_time = time.localtime()
|
||||
if debug:
|
||||
print(last_time[3])
|
||||
print(current_time[3])
|
||||
|
||||
# If the hour changed : copy current data.csv to hourly directory
|
||||
if current_time[3] != last_time[3]:
|
||||
print("Time to move hourly data !")
|
||||
os.rename("data/data.csv", "data/hourly/{:02}.csv".format(last_time[3]))
|
||||
|
||||
# If the day changed : copy content of hourly to daily directories
|
||||
if current_time[2] != last_time[2]:
|
||||
print("Time to move daily data !")
|
||||
# Create new dir for the date of yesterday
|
||||
newdir = "data/daily/{}{:02}{:02}".format(*last_time[0:3])
|
||||
os.mkdir(newdir)
|
||||
# Move each "hourly file" to the new directory
|
||||
for file in os.listdir('data/hourly'):
|
||||
print("Move {} to {}".format(file, newdir))
|
||||
os.rename("data/hourly/{}".format(file), "{}/{}".format(newdir, file))
|
||||
|
||||
# Finally update last_time, each time
|
||||
return current_time
|
||||
|
||||
|
||||
def set_clock_from_localtime(clock, treshold=2.0):
|
||||
"""
|
||||
Compare internal RTC and date-time from time.localtime() and set
|
||||
the RTC date/time to this value if the difference is more or equal to
|
||||
threshold (in seconds).
|
||||
The source of time.localtime() can be set with rtc.set_time_source()
|
||||
"""
|
||||
|
||||
# Max difference between GPS and internal RTC (in seconds):
|
||||
if abs(time.mktime(time.localtime()) - time.mktime(clock.datetime)) >= treshold:
|
||||
# print("Clock difference with GPS!")
|
||||
# print("Previous date/time : " + TIME_FORMAT.format(*clock.datetime[0:6]))
|
||||
clock.datetime = time.localtime() # Trust localtime if there is a bias
|
||||
print("Clocks synced !")
|
||||
|
|
@ -45,329 +45,43 @@ __version__ = 0.2
|
|||
|
||||
#######################
|
||||
import time
|
||||
import gc
|
||||
import os
|
||||
import rtc
|
||||
import microcontroller
|
||||
import gc
|
||||
import board
|
||||
from busio import UART
|
||||
# import micropython
|
||||
from busio import I2C, UART
|
||||
from analogio import AnalogIn
|
||||
from digitalio import DigitalInOut, Direction
|
||||
from adafruit_bme280 import Adafruit_BME280_I2C
|
||||
from adafruit_gps import GPS
|
||||
import neopixel
|
||||
|
||||
import cameteo
|
||||
|
||||
##########
|
||||
# config #
|
||||
##########
|
||||
|
||||
print_data_flag = True # Print data on USB UART / REPL output ?
|
||||
send_json_flag = True # Send data as JSON on second UART ?
|
||||
backup_data_flag = True # Write data as CSV files on onboard SPI Flash ?
|
||||
neopixel_flag = True # Display atmospheric data as color on onboard neopixel ?
|
||||
gps_enable_flag = True # Use GPS module ?
|
||||
PRINT_DATA = True # Print data on USB UART / REPL output ?
|
||||
DATA_TO_NEOPIXEL = True # Display atmospheric data as color on onboard neopixel ?
|
||||
GPS_ENABLE = True # Use GPS module ?
|
||||
UPDATE_INTERVAL = 10 # Interval between data acquisition (in seconds)
|
||||
WRITE_INTERVAL = 60 # Interval between data written on flash Memory
|
||||
SEND_INTERVAL = 60 # Interval between packet of data sent to Rpi
|
||||
TIME_FORMAT = "{:04}/{:02}/{:02}_{:02}:{:02}:{:02}" # Date/time format
|
||||
NEOPIXEL_MAX_VALUE = 70 # max value instead of brightness to spare some mem
|
||||
|
||||
###########
|
||||
# Classes #
|
||||
###########
|
||||
|
||||
|
||||
class Data:
|
||||
"""Class for handling data"""
|
||||
|
||||
def __init__(self):
|
||||
self.data = {'SYS': {'time': "2000/01/01_00:00:00",
|
||||
'vbat': int(),
|
||||
'cput': float()},
|
||||
'BME': {'temp': float(),
|
||||
'hum': int(),
|
||||
'press': float()},
|
||||
'GPS': {'time': "2000/01/01_00:00:00",
|
||||
'lat': float(),
|
||||
'lon': float(),
|
||||
'alt': float(),
|
||||
'qual': int(),
|
||||
'age': int()}}
|
||||
self._gps_last_fix = int()
|
||||
self._gps_current_fix = int()
|
||||
|
||||
def update(self):
|
||||
"""Read the data from various sensors and update the data dict variable"""
|
||||
# Data from Feather board
|
||||
self.data['SYS']['time'] = TIME_FORMAT.format(*clock.datetime[0:6])
|
||||
self.data['SYS']['vbat'] = round(measure_vbat(), 3)
|
||||
self.data['SYS']['cput'] = round(microcontroller.cpu.temperature, 2)
|
||||
|
||||
# Data from BME280
|
||||
self.data['BME']['temp'] = round(bme280.temperature, 1)
|
||||
self.data['BME']['hum'] = int(bme280.humidity)
|
||||
self.data['BME']['press'] = round(bme280.pressure, 2)
|
||||
|
||||
if gps_enable_flag:
|
||||
self._gps_current_fix = int(time.monotonic())
|
||||
self.data['GPS']['time'] = TIME_FORMAT.format(
|
||||
gps.timestamp_utc.tm_year,
|
||||
gps.timestamp_utc.tm_mon,
|
||||
gps.timestamp_utc.tm_mday,
|
||||
gps.timestamp_utc.tm_hour,
|
||||
gps.timestamp_utc.tm_min,
|
||||
gps.timestamp_utc.tm_sec)
|
||||
if gps.has_fix:
|
||||
self._gps_last_fix = self._gps_current_fix
|
||||
self.data['GPS']['lat'] = gps.latitude
|
||||
self.data['GPS']['lon'] = gps.longitude
|
||||
self.data['GPS']['alt'] = gps.altitude_m
|
||||
self.data['GPS']['qual'] = gps.fix_quality
|
||||
self.data['GPS']['age'] = 0
|
||||
else:
|
||||
self.data['GPS']['age'] = int(self._gps_current_fix
|
||||
- self._gps_last_fix)
|
||||
else:
|
||||
self.data['GPS'] = None
|
||||
|
||||
def show(self):
|
||||
"""Serialize data for visualization on serial console"""
|
||||
for source, val in self.data.items():
|
||||
print(source + ": ")
|
||||
if val is not None:
|
||||
for name, value in val.items():
|
||||
print("\t{0}: {1}".format(name, value))
|
||||
|
||||
@property
|
||||
def json(self):
|
||||
"""Serialized data to compact json-formatted string"""
|
||||
output = '{'
|
||||
first_source = True
|
||||
for source, val in self.data.items():
|
||||
if first_source:
|
||||
first_source = False
|
||||
comma_src = ""
|
||||
else:
|
||||
comma_src = ","
|
||||
output = '{}{}"{}":'.format(output, comma_src, source)
|
||||
if val is not None:
|
||||
output = output + '{'
|
||||
first_data = True
|
||||
for name, value in val.items():
|
||||
if first_data:
|
||||
comma = ""
|
||||
first_data = False
|
||||
else:
|
||||
comma = ","
|
||||
output = '{}{}"{}":"{}"'.format(output, comma, name, value)
|
||||
output = output + '}'
|
||||
output = output + '}'
|
||||
return output
|
||||
|
||||
@property
|
||||
def rgb(self):
|
||||
"""Convert atmospheric data from BME280 sensor into NeoPixel color as
|
||||
a tuple (RED, BLUE, GREEN):
|
||||
* RED => temperature : max = 35degC, min =10degC (range 25°C)
|
||||
* BLUE => humidity : max= 100%, mini=0%
|
||||
* GREEN => pression : mini=960hPa, maxi = 1030hPa (range 70hPa)
|
||||
"""
|
||||
# RED componant calculation from temperature data
|
||||
# 10 is the min temperature, 25 is the range
|
||||
# (10+25=35°C = max temperature)
|
||||
red = int((self.data['BME']['temp']-10)*NEOPIXEL_MAX_VALUE/25)
|
||||
if red > NEOPIXEL_MAX_VALUE:
|
||||
red = NEOPIXEL_MAX_VALUE
|
||||
if red < 0:
|
||||
red = 0
|
||||
|
||||
# BLUE componant calculation: very simple! By definition relative
|
||||
# humidity cannot be more than 100 or less than 0, physically
|
||||
blue = int(self.data['BME']['hum']*NEOPIXEL_MAX_VALUE/100)
|
||||
|
||||
# GREEN component calculation : 960 is the minimum pressure and 70 is
|
||||
# the range (960+70 = 1030hPa = max pressure)
|
||||
green = int((self.data['BME']['press']-960)*NEOPIXEL_MAX_VALUE/70)
|
||||
if green > NEOPIXEL_MAX_VALUE:
|
||||
green = NEOPIXEL_MAX_VALUE
|
||||
if green < 0:
|
||||
green = 0
|
||||
|
||||
if print_data_flag:
|
||||
print("Col:{}".format((red, green, blue)))
|
||||
|
||||
return (red, green, blue)
|
||||
|
||||
def write_on_flash(self):
|
||||
"""Save the current data as csv file on SPI flash"""
|
||||
global backup_data_flag
|
||||
try:
|
||||
with open("data/data.csv", "a") as csv_file:
|
||||
if gps_enable_flag:
|
||||
csv_file.write("{};{};{};{};{};{};{};{};{};{}\n".format(
|
||||
self.data['SYS']['time'],
|
||||
self.data['BME']['temp'],
|
||||
self.data['BME']['hum'],
|
||||
self.data['BME']['press'],
|
||||
self.data['SYS']['vbat'],
|
||||
self.data['GPS']['time'],
|
||||
self.data['GPS']['lon'],
|
||||
self.data['GPS']['lat'],
|
||||
self.data['GPS']['alt'],
|
||||
self.data['GPS']['qual'],
|
||||
))
|
||||
else:
|
||||
csv_file.write("{};{};{};{};{};;;;;\n".format(
|
||||
self.data['SYS']['time'],
|
||||
self.data['BME']['temp'],
|
||||
self.data['BME']['hum'],
|
||||
self.data['BME']['press'],
|
||||
self.data['SYS']['vbat'],
|
||||
))
|
||||
|
||||
except OSError as err:
|
||||
print("Err {}: readonly".format(err))
|
||||
# to avoid trying again till next reset
|
||||
backup_data_flag = False
|
||||
# Turn onboard led on to indicate read-only error
|
||||
led13.value = True
|
||||
|
||||
#############
|
||||
# Functions #
|
||||
#############
|
||||
|
||||
|
||||
def check_data_dir():
|
||||
"""Check if data directories exists"""
|
||||
global backup_data_flag
|
||||
try:
|
||||
if 'data' not in os.listdir():
|
||||
os.mkdir('data')
|
||||
os.mkdir('data/hourly')
|
||||
os.mkdir('data/daily')
|
||||
elif 'hourly' not in os.listdir('data'):
|
||||
os.mkdir('data/hourly')
|
||||
elif 'daily' not in os.listdir('data'):
|
||||
os.mkdir('data/daily')
|
||||
except OSError as err:
|
||||
print("Err {}: readonly".format(err))
|
||||
backup_data_flag = False # to avoid trying again till next reset
|
||||
# Turn onboard led on to indicate read-only error
|
||||
led13.value = True
|
||||
|
||||
|
||||
def rotate_files(last_time):
|
||||
"""Check if files need to rotate
|
||||
=> every new hour
|
||||
=> every new day
|
||||
"""
|
||||
current_time = clock.datetime
|
||||
|
||||
# If the hour changed : copy current data.csv to hourly directory
|
||||
if current_time[3] != last_time[3] and backup_data_flag:
|
||||
print("Time to move hourly data !")
|
||||
os.rename("data/data.csv", "data/hourly/{:02}.csv".format(last_time[3]))
|
||||
|
||||
# If the day changed : copy content of hourly to daily directories
|
||||
if current_time[2] != last_time[2] and backup_data_flag:
|
||||
print("Time to move daily data !")
|
||||
# Create new dir for the date of yesterday
|
||||
newdir = "data/daily/{}{:02}{:02}".format(*last_time[0:3])
|
||||
os.mkdir(newdir)
|
||||
# Move each "hourly file" to the new directory
|
||||
for file in os.listdir('data/hourly'):
|
||||
print("Move {} to {}".format(file, newdir))
|
||||
os.rename("data/hourly/{}".format(file), "{}/{}".format(newdir, file))
|
||||
|
||||
# Finally update last_time, each time
|
||||
return current_time
|
||||
|
||||
|
||||
def set_clock_from_gps(treshold=5.0):
|
||||
"""Compare internal RTC and date-time from GPS (if enable and fixed) and set
|
||||
the RTC date time to GPS date-time if the difference is more or equal to
|
||||
threshold (in seconds)"""
|
||||
|
||||
if gps_enable_flag:
|
||||
gps_datetime = time.struct_time((gps.timestamp_utc.tm_year,
|
||||
gps.timestamp_utc.tm_mon,
|
||||
gps.timestamp_utc.tm_mday,
|
||||
gps.timestamp_utc.tm_hour,
|
||||
gps.timestamp_utc.tm_min,
|
||||
gps.timestamp_utc.tm_sec, 0, 0, 0))
|
||||
# Max difference between GPS and internal RTC (in seconds):
|
||||
if abs(time.mktime(gps_datetime) - time.mktime(clock.datetime)) >= treshold:
|
||||
# print("Clock difference with GPS!")
|
||||
# print("Previous date/time : " + TIME_FORMAT.format(*clock.datetime[0:6]))
|
||||
clock.datetime = gps_datetime # Trust GPS if there is a bias
|
||||
print("Clocks synced !")
|
||||
|
||||
|
||||
def measure_vbat(samples=10, timestep=0.01):
|
||||
"""Measure Vbattery as the mean of n samples with timestep second between
|
||||
each measurement"""
|
||||
# Note about v_bat calculation :
|
||||
# 0.000100708 = 2*3.3/65536 with
|
||||
# 2 : voltage is divided by 2
|
||||
# 3.3 : Vref = 3.3V
|
||||
# 65536 : 16bit ADC
|
||||
val = 0
|
||||
for sample in range(samples):
|
||||
val = val + vbat.value
|
||||
time.sleep(timestep)
|
||||
return val/samples*0.000100708
|
||||
WRITE_INTERVAL = 60 # Interval between data written on flash Memory (-1 to disable)
|
||||
SEND_INTERVAL = 60 # Interval between packet of data sent to Rpi (-1 to disable)
|
||||
NEOPIXEL_MAX_VALUE = 70 # max value instead of brightness to spare some mem
|
||||
|
||||
#########
|
||||
# Setup #
|
||||
#########
|
||||
|
||||
|
||||
gc.collect()
|
||||
# micropython.mem_info()
|
||||
|
||||
# Enable RTC of the feather M0 board
|
||||
clock = rtc.RTC()
|
||||
# clock.datetime = time.struct_time((2018, 7, 29, 15, 31, 30, 0, 0, 0))
|
||||
|
||||
# BME280 sensors (I2C)
|
||||
i2c = I2C(board.SCL, board.SDA)
|
||||
# i2c addresses for BME280 breakout :
|
||||
# 0x77 = adafruit breakout board
|
||||
# 0x76 = tiny chinese board
|
||||
bme280 = Adafruit_BME280_I2C(i2c, address=0x76)
|
||||
|
||||
# Battery voltage
|
||||
vbat = AnalogIn(board.VOLTAGE_MONITOR)
|
||||
|
||||
# Set the pin to control the power to GPS module
|
||||
gps_en_pin = DigitalInOut(board.A5)
|
||||
gps_en_pin.direction = Direction.OUTPUT
|
||||
|
||||
# Set the pin N°13 to use the onboard LED as read-only/read-write indicator
|
||||
led13 = DigitalInOut(board.D13)
|
||||
led13.direction = Direction.OUTPUT
|
||||
led13.value = False
|
||||
|
||||
# Set GPS module on FeatherWing board
|
||||
gps_en_pin.value = not gps_enable_flag # Set enable pin high to disable GPS module
|
||||
if gps_enable_flag:
|
||||
gps_uart = UART(board.TX, board.RX,
|
||||
baudrate=9600, timeout=3000)
|
||||
gps = GPS(gps_uart)
|
||||
# Turn on the basic GGA and RMC info
|
||||
gps.send_command('PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
|
||||
gps.send_command('PMTK220,1000') # 1000 ms refresh rate
|
||||
CLOCK = rtc.RTC()
|
||||
|
||||
# Second UART to communicate with raspberry pi (throught GPIO)
|
||||
if send_json_flag:
|
||||
rpi_uart = UART(board.A2, board.A3,
|
||||
baudrate=115200, timeout=2000)
|
||||
if SEND_INTERVAL >= 0:
|
||||
rpi_uart = UART(board.A2, board.A3, baudrate=115200, timeout=2000)
|
||||
|
||||
# Set onboard Neopixel : used as atmo data output
|
||||
# brightness is fixed to 1 to spare some memory. Use NEOPIXEL_MAX_VALUE instead
|
||||
if neopixel_flag:
|
||||
if DATA_TO_NEOPIXEL:
|
||||
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=1)
|
||||
else:
|
||||
# if neopixel is disable : turn off the LED
|
||||
|
|
@ -375,45 +89,37 @@ else:
|
|||
pixel[0] = (0, 0, 0)
|
||||
pixel = None
|
||||
|
||||
# Finally check if data directories exist
|
||||
check_data_dir()
|
||||
sys_data = cameteo.SysData(debug=False)
|
||||
bme_data = cameteo.BME280Data()
|
||||
gps_data = cameteo.GPSData(rtc=CLOCK)
|
||||
|
||||
data = [gps_data, sys_data, bme_data]
|
||||
|
||||
# Init timers
|
||||
last_update = last_sent_packet = last_written_data = time.monotonic()
|
||||
last_rotation = time.localtime()
|
||||
|
||||
#############
|
||||
# Main loop #
|
||||
#############
|
||||
|
||||
data = Data()
|
||||
|
||||
# Init timers
|
||||
last_update = last_sent_packet = last_written_data = time.monotonic()
|
||||
last_rotation = clock.datetime
|
||||
|
||||
while True:
|
||||
|
||||
if gps_enable_flag:
|
||||
gps.update()
|
||||
set_clock_from_gps()
|
||||
current_time = time.monotonic()
|
||||
|
||||
current = time.monotonic()
|
||||
if current - last_update >= UPDATE_INTERVAL:
|
||||
last_update = current
|
||||
data.update()
|
||||
if print_data_flag:
|
||||
data.show()
|
||||
if neopixel_flag:
|
||||
pixel[0] = data.rgb
|
||||
for src in data:
|
||||
src.update(current_time, verbose=PRINT_DATA)
|
||||
|
||||
if send_json_flag and current - last_sent_packet >= SEND_INTERVAL:
|
||||
last_sent_packet = current
|
||||
rpi_uart.write(data.json + '\n')
|
||||
print(data.json + '\n')
|
||||
# First check if files need to rotate
|
||||
last_rotation = cameteo.rotate_files(last_rotation, debug=True)
|
||||
|
||||
for src in data:
|
||||
src.write_on_flash(current_time)
|
||||
src.send_json(current_time, uart=rpi_uart, verbose=PRINT_DATA)
|
||||
|
||||
# # First check if files need to rotate
|
||||
# last_rotation = rotate_files(last_rotation)
|
||||
|
||||
if backup_data_flag and current - last_written_data >= WRITE_INTERVAL:
|
||||
last_written_data = current
|
||||
# First check if files need to rotate
|
||||
last_rotation = rotate_files(last_rotation)
|
||||
print("Backup data...")
|
||||
data.write_on_flash()
|
||||
|
||||
gc.collect()
|
||||
# micropython.mem_info(1)
|
||||
|
|
|
|||
Loading…
Reference in New Issue