def __init__(self,btnGap=200,):
self.btnGap = btnGap
i2c = I2C(scl=Pin(4),sda=Pin(5))
self.d = ssd1306.SSD1306_I2C(128, 64, i2c)
self.p = Pressure(i2c)
self.pwm = PWM(Pin(13))
self.pwm.duty(0)
self.pwm.freq(90) # pwm duty 19 - 134
self.button = Pin(12, Pin.IN,Pin.PULL_UP)
self.led = Pin(16,Pin.OUT)
self.led.off() # this turn on board led off
self.adc = ADC(0)
self.pwr = Pin(14, Pin.OUT,)
self.pwr.off()
self.t1 = 0
self.t2 = 0
self.title = 'Liquid Monitor'
self.pump = False
self.speed = 0
self.cond = 0
self.pumpON = False
self.initSpeed = 300
self.btnExit = False
self.lastCond = 0
self.pressure=0
self.temp=0
def __init__(self, refPath, dataPath, dbFilename):
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.AUTO_START_GPIO_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.__i2c = I2C(2)
self.__analog = Analog(sel.__i2c.getLock(), 0x49)
self.default = Default()
self.database = Database(dataPath, dbFilename)
self.waterlevel = Waterlevel(debug, self.database)
self.light = Light(self.database)
self.curtain = Curtain(self.database)
self.pressure = Pressure(self.database, self.default, self.__analog)
self.temperature = Temperature("28-0417716a37ff", self.database)
self.redox = Redox(debug, self.database, self.default, self.__analog)
self.ph = PH(debug, self.database, self.default, self.__analog,
self.temperature)
self.robot = Robot(debug, self.database)
self.pump = Pump(debug, self.database, self.default, self.robot,
self.redox, self.ph, self.temperature)
self.panel = Panel(debug, self.database, self.default, self.pump,
self.redox, self.ph, self.__i2c)
self.statistic = Statistic(debug, self.pump, self.robot, self.redox,
self.ph, self.temperature, self.pressure,
self.waterlevel)
self.refPath = refPath
self.__autoSaveTick = 0
self.__today = date.today().day - 1
debug.TRACE(debug.DEBUG, "Initialisation done (Verbosity level: %s)\n",
debug)
def generate(self):
self.states = []
print "\n[trace] - Generate states - Generate quantity combinations:"
# Generate all quantities for each state.
states_q = itertools.product(Inflow.get_quantities(),
Volume.get_quantities(),
Outflow.get_quantities(),
Height.get_quantities(),
Pressure.get_quantities())
# Create objects for each state.
for state_q in states_q:
self.states.append(
BonusState(Inflow(state_q[0], None), Volume(state_q[1], None),
Outflow(state_q[2], None), Height(state_q[3], None),
Pressure(state_q[4], None)))
pprint.pprint(self.states)
print "[trace] - Generate states - " +\
str(len(self.states)) + " current states"
print "\n[trace] - Generate states - remove constraints:"
self.remove_inconsistencies()
pprint.pprint(self.states)
print "[trace] - Generate states - " +\
str(len(self.states)) + " current states"
print "\n[trace] - Generate states - Calculate derivitives:"
self.calc_derives()
pprint.pprint(self.states)
print "[trace] - Generate states - " +\
str(len(self.states)) + " current states"
print "\n[trace] - Generate states - Unpack the inflow derivitives"
self.unpack_inflow()
print "\n[trace] - Generate states - Set state ids"
# At this point all valid states are created and should receive an id
for i, state in enumerate(self.states):
state.set_id(i)
pprint.pprint(self.states)
print "[trace] - Generate states - " +\
str(len(self.states)) + " current states"
print "\n[trace] - Create paths - Start"
self.create_paths()
pprint.pprint(self.paths)
print "[trace] - Generate states - " +\
str(len(self.paths)) + " current paths"
print "[trace] - Create paths - End\n"
return self.states, self.paths
class WaterColumn:
state = states.NoWhere()
measure_location = ""
pin_valve = -1
pin_pump = -1
pressureSensor = Pressure()
rws = government.RWS()
counter = 0;
previous_level = 0
previous_desired = 0
def __init__(self, location, channel, pin_valve, pin_pump ):
self.channel = channel
self.measure_location = location
self.pin_pump = pin_pump
self.pin_valve = pin_valve
self.zero = False
self.empty = False
self.lock = asyncio.Lock()
def getWaterLevel(self):
async with self.lock:
if (self.zero):
return 0, True
if (self.empty):
return constants.NAP_COLUMN_LEVEL, True
return self.rws.getWaterLevel(self.measure_location)
def setLevelToZero(self):
async with self.lock:
#only set when empty is false
self.zero = not self.empty
def setLevelToEmpty(self):
async with self.lock:
#only set when zero is false
self.empty = not self.zero
def setToNormal(self):
async with self.lock:
self.zero = False
self.empty = False
def runWorlds(self, screen):
while True:
#NAP start + NAP level equals column height
level_column = constants.NAP_COLUMN_LEVEL + self.pressureSensor.getColumnLevel(self.channel)
level_desired, ok = self.getWaterLevel()
if (ok):
self.previous_desired = level_desired
else:
#print("error")
level_desired = self.previous_desired
if (ok):
self.state = self.state.execute(self.measure_location, level_column, level_desired, self.pin_valve, self.pin_pump, screen)
else:
self.state = states.Error()
#check if an hardware error is occuring
if (self.previous_level == level_column and level_desired > level_column):
self.counter += 1
if (self.counter > constants.TEN_S_EQUAL_ERROR_COUNT): #no change in water level after x iterations, something is wrong -> Error
self.state = states.Error()
else:
self.counter = 0
self.previous_level = level_column
#print ("Level Desired Column {0:2.2f}".format(level_desired))
screen.writeToScreen(self.channel, self.measure_location, self.state.getName(), level_column , level_desired)
time.sleep(constants.COLUMN_WAIT)
class Controller:
def __init__(
self,
btnGap=200,
):
self.btnGap = btnGap
i2c = I2C(scl=Pin(5), sda=Pin(4))
self.d = ssd1306.SSD1306_I2C(128, 64, i2c)
self.p = Pressure(i2c)
self.pwm = PWM(Pin(13))
self.pwm.duty(0)
self.pwm.freq(90) # pwm duty 19 - 134
self.button = Pin(12, Pin.IN, Pin.PULL_UP)
self.led = Pin(2, Pin.OUT)
self.led.on() # this turn on board led off
self.adc = ADC(0)
self.pwr = Pin(
14,
Pin.OUT,
)
self.pwr.off()
self.t1 = 0
self.t2 = 0
self.title = 'Liquid Monitor'
self.pump = False
self.speed = 0
self.cond = 0
self.pumpON = False
self.initSpeed = 300
self.btnExit = False
self.lastCond = 0
self.pressure = 0
self.temp = 0
def ledON(self):
self.led.off()
def ledOFF(self):
self.led.on()
def setPump(self, value):
self.pwm.duty(int(value))
def measure(self, wait=0, N=3):
"measure method"
res = []
for i in range(N):
res.append(self.singleM(wait))
utime.sleep_ms(50)
self.cond = sum(res) // N
# measure temperatuer and pressurre
self.pressure, self.temp = self.p.read()
def singleM(self, wait=0):
self.pwr.on()
utime.sleep_ms(wait)
cond = self.adc.read()
self.pwr.off()
return cond
def update(self):
"determine if need to turn on pump"
if self.pump:
if self.cond >= 20:
self.lastCond = self.cond
self.speed -= 30
if self.speed <= 200:
self.speed = 0
self.setPump(self.speed)
else:
self.speed += 10
if self.speed <= 200:
self.speed = 200
self.speed = min(1024, self.speed)
self.setPump(self.speed)
else:
self.setPump(0)
self.speed = 0
def show(self):
self.d.fill(0)
self.d.text(self.title, 0, 2)
self.d.text('Cond. :{:>6d}'.format(self.cond), 0, 20)
self.d.text('LastC. :{:>6d}'.format(self.lastCond), 0, 31)
self.d.text('Pump :{:>6}'.format(self.speed if self.pump else "OFF"),
0, 42)
self.d.text('PSI:{:>4.1f} T: {:.1f}'.format(self.pressure, self.temp),
0, 53)
self.d.show()
def text(self, header="", msg=""):
self.d.fill(0)
self.d.text(header, 0, 2)
for i in range(len(msg) // 16 + 1):
self.d.text(msg[i * 16:(i + 1) * 16], 0, i * 10 + 16)
self.d.show()
def monitorButton(self):
self.t1 = utime.ticks_ms()
while True:
self.t2 = utime.ticks_ms()
if self.button.value() == 0:
self.pump = not self.pump
break
if (self.t2 - self.t1 >= self.btnGap) or (
(self.t2 - self.t1) <= 0):
break
while (self.button.value() == 0):
self.ledON()
utime.sleep_ms(50)
self.ledOFF()
utime.sleep_ms(50)
if (utime.ticks_ms() - self.t1) > 3000:
self.title = "System Exited."
self.show()
self.btnExit = True
raise Exception('exit')
class Manager:
AUTO_START_GPIO_PIN = 16
ONCE_BY_HOUR_TICK = 360 # 1h
def __init__(self, refPath, dataPath, dbFilename):
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.AUTO_START_GPIO_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.__i2c = I2C(2)
self.__analog = Analog(sel.__i2c.getLock(), 0x49)
self.default = Default()
self.database = Database(dataPath, dbFilename)
self.waterlevel = Waterlevel(debug, self.database)
self.light = Light(self.database)
self.curtain = Curtain(self.database)
self.pressure = Pressure(self.database, self.default, self.__analog)
self.temperature = Temperature("28-0417716a37ff", self.database)
self.redox = Redox(debug, self.database, self.default, self.__analog)
self.ph = PH(debug, self.database, self.default, self.__analog,
self.temperature)
self.robot = Robot(debug, self.database)
self.pump = Pump(debug, self.database, self.default, self.robot,
self.redox, self.ph, self.temperature)
self.panel = Panel(debug, self.database, self.default, self.pump,
self.redox, self.ph, self.__i2c)
self.statistic = Statistic(debug, self.pump, self.robot, self.redox,
self.ph, self.temperature, self.pressure,
self.waterlevel)
self.refPath = refPath
self.__autoSaveTick = 0
self.__today = date.today().day - 1
debug.TRACE(debug.DEBUG, "Initialisation done (Verbosity level: %s)\n",
debug)
def __del__(self):
GPIO.cleanup()
def __onceByHour(self):
if self.__autoSaveTick == self.ONCE_BY_HOUR_TICK:
self.database.backup()
self.__autoSaveTick = 0
# All seems to be OK, we can remove the previous version
backup = os.path.join(self.refPath, "PoolSurvey_bak")
if os.path.exists(backup):
os.system("rm -frd %s" % backup)
self.__autoSaveTick += 1
def __onceByDay(self):
if self.__today != date.today().day:
self.__today = date.today().day
self.pressure.onceByDay()
self.pump.onceByDay()
self.statistic.onceByDay()
def isAutoStart(self):
return GPIO.input(self.AUTO_START_GPIO_PIN) == GPIO.LOW
def start(self):
debug.TRACE(debug.DEBUG, "Manager is started\n")
self.__running = True
while self.__running:
debug.TAG(debug.DETAIL, "%ds Tick" % REFRESH_TICK)
self.temperature.update()
self.__onceByDay()
self.pump.update()
if self.pump.guardPeriodElapsed():
self.robot.update()
self.ph.update()
self.redox.update()
self.waterlevel.update()
self.pressure.update()
self.panel.update()
self.statistic.update()
self.__onceByHour()
time.sleep(REFRESH_TICK)
debug.TRACE(debug.DEBUG, "Manager is stopped\n")
self.pump.switchOff()
self.statistic.save()
def stop(self):
self.__running = False
"""Main module that runs continously to monitor
assorted sensors"""
import time
import json
import graphyte
from pressure import Pressure
from vacuum import Vacuum
from dust import Dust
from temperature import Temperature
from relative_humidity import RelativeHumidity
T = Temperature()
P = Pressure()
V = Vacuum()
D = Dust()
RH = RelativeHumidity()
with open('sensorConfig.json') as json_file:
FILE_DATA = json.load(json_file)
graphyte.init(FILE_DATA["ip address"]
) # initializes Grafana to send data to this ip address
RUN = True
while RUN:
VACUUM_DATA = V.vacuum()
PRESSURE_DATA = P.pressure()
DUST_DATA = D.dust()
comms = Comms()
wifi = WiFiManager()
comms.add_manager(0, wifi)
manager = DataManager(csv_file=csv_file)
acc = Accelerometer(
py, config.manager_mqtt_user + "/feeds/" + config.manager_mqtt_name +
".acceleration")
manager.add_sensor(acc)
light = Light(
py, config.manager_mqtt_user + "/feeds/" + config.manager_mqtt_name +
".light-1", config.manager_mqtt_user + "/feeds/" +
config.manager_mqtt_name + ".light-2")
manager.add_sensor(light)
press = Pressure(
py, config.manager_mqtt_user + "/feeds/" + config.manager_mqtt_name +
".pressure")
manager.add_sensor(press)
temphum = TempHum(
py, config.manager_mqtt_user + "/feeds/" + config.manager_mqtt_name +
".temperature", config.manager_mqtt_user + "/feeds/" +
config.manager_mqtt_name + ".humidity")
manager.add_sensor(temphum)
batt = Battery(
py, config.manager_mqtt_user + "/feeds/" + config.manager_mqtt_name +
".voltage")
manager.add_sensor(batt)
try:
if not comms.connect():
comms.disconnect()