def pumpswitchOff(request):
#lcd = Lcd()
#lcd.clear()
#lcd.display_string("pump off",1)
relay = Relay()
relay.switch(3, 0)
response_mesage = {"result": "pump is off"}
return JsonResponse(response_mesage)
def setLightOff(test=False):
"Check the time and determine if the lights need to be changed"
relay = Relay()
state = relay.getState(lightPin)
on = True
if state is on:
print('set light off')
send_message('notifications', 'set light off')
relay.setOff(lightPin)
def final():
Relay.setup() # Initialize relay
PIR_test.setup() # initialize PIR
settings.init() # Initialize arrays and variables
DHT11.update() # Update values
updatedisplay()
setduration()
print('Starting Irrigation Now')
Relay.irrigate()
def __init__(self, logger=None):
self._logger = logger
if logger == None:
self._logger = Logger("Humidifier", Logger.INFO)
self._logger.debug("initialize Fan object")
self._relay = Relay(self._logger)
self._pin = 29
self._couch = CouchUtil(self._logger)
# flag for if in testing
self._test = False
def adjustThermostat(low, high):
"""Turn the fan on or off in relationship to target temperature range / and time of day?"""
si = si7021()
relay = Relay()
temp = si.getTempF()
relay.setOn(fanPin)
state = relay.getState(fanPin)
on_ = True
off_ = False
if state is on_ and temp < low:
print('turn fan off')
send_message('notifications', 'turn fan off')
relay.setOff(fanPin)
state = off_
if state is off_ and temp > high:
print('turn fan on')
send_message('notifications', 'turn fan on')
relay.setOn(fanPin)
state = on_
print(temp)
# display state
if state is on_:
print('fan is on')
else:
print('fan is off')
def __init__(self, logger=None):
'''Initialize the object'''
self.solenoidPin = Relay4
if logger==None:
self._logger = Logger('Solenoid', Logger.INFO)
else:
self._logger = logger
self._relay=Relay(self._logger)
self._couch=CouchUtil(self._logger)
self._test = False
self.activity_type = 'State_Change'
def flush(): # Function to flush the system
global flushed_flag
Relay.all_relay_off() # Close all relays
Relay.pump_on() # Turn the pump on
Relay.flush_on() # Open the flush solenoid
time.sleep(180) # Flush for 3 minutes
Relay.all_relay_off() # Close all relays, stop the pump and close flush valve
flushed_flag = 1 # Set flag to 1 so program doesn't flush twice on one sample
def status():
stat = {
"HVAC-pi": "v1.0",
"Timestamp": "",
"Relay": {},
"Therm": {},
"Power": {},
"Stats": {}
}
ows = Therm.status()
logger.debug(ows)
stat["Therm"] = ows
pwr = Power.status()
logger.debug(pwr)
stat["Power"] = pwr
rly = Relay.status()
stat["Relay"] = rly
sts = Stats.status()
stat["Stats"] = sts
stat["Timestamp"] = int(time.time())
return json.dumps(stat, indent=2)
class Pump:
def __init__(self):
'''Initialize the object'''
self.solenoidPin = Relay4
self.Relay=Relay()
self._logger = get_logger('Solenoid')
self.activity_type = 'State_Change'
def on(self, test=False):
self.Relay.set_off(self.solenoidPin)
self._logger.debug("{}".format("Open Solenoid"))
self.logState("Open")
def off(self, test=False):
self.Relay.set_on(self.solenoidPin)
self._logger.debug("{}".format("Close Solenoid"))
self.logState("Closed")
def getState(self, test=False):
state=self.Relay.get_state(self.solenoidPin)
if state==0:
return "On"
else:
return "Off"
def logState(self, value, test=False):
status_qualifier='Success'
if test:
status_qualifier='Test'
saveList(['State_Change', '', 'Pump', 'Reservoir', 'State', value, 'state', 'Solenoid', status_qualifier, ''])
def test(self):
print "Pump Test"
print "On"
self.on(True)
print "State: ", self.getState()
time.sleep(5)
print "Off"
self.off(True)
print "State: ", self.getState()
def test2(self):
state=self.getState(True)
print "State: ", state
def suck_it(sample_counter):
Relay.relay_init() # Initialize all the GPIO pins
global flushed_flag # Give access to global variable
sample_pin = Relay.get_pin(sample_counter) # Sample counter. Counts four samples. This needs to come from main loop
while in_position: # in_position variable checks location of USV against the target GPS location
if flushed_flag: # If the system is flushed...
Relay.pump_on() # Turn the pump on
Relay.solenoid_on(sample_pin) # Turn the specific solenoid on given by sample variable
while ~finished_pump: # Monitor finished-pump which is updated by the water flow meter
if water_flow < 1: # if the water flow drops below 1V <-------------------------------------------------- needs empirical evidence
Relay.all_relay_off() # Turn off all the relays
flushed_flag = 0
return
else:
flush() # Start the flush
def __init__(self, filepath, t=1, h=1, w=1):
self.filepath = filepath
## initialize T probe
if t:
self.probe_T = Temp.Temp()
## initialize heat
if h:
self.heat = Relay.Relay(21)
## initialize sound
if w:
self.warning = Sound.Sound()
def startService():
print(">> Water Level Monitoring Started!")
global status
sensor = InputDevice(18)
x = 1
while True:
if not sensor.is_active:
if (x == 0):
print("Tank Full!")
status = 1
Relay.switch("post/motor", "0")
MQTT_Publisher.publish("get/water", "1")
x = 1
else:
if (x == 1):
status = 0
print("Water Level Dropped!")
MQTT_Publisher.publish("get/water", "0")
x = 0
sleep(1)
class Light(object):
def __init__(self):
self.r = Relay()
self.logger = get_logger('Light')
def set_on(self, test=False):
"Check state and turn on if needed"
if self.get_state() == 0:
self.r.set_on(lightPin, test)
self.log_state("On", test)
self.logger.debug('Light turned ON')
else:
self.logger.debug('Light already ON - no change')
def set_off(self, test=False):
'''Check state and turn off if needed'''
if self.get_state() == 1:
self.r.set_off(lightPin, test)
self.log_state("Off", test)
self.logger.debug('Light turned OFf')
else:
self.logger.debug('Light already OFF - no change')
def get_state(self, test=False):
'''Check the GPIO
'''
return self.r.get_state(lightPin)
def log_state(self, value, test=False):
"""
Create Environment Observation
"""
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
saveList([
'State_Change', '', 'Top', 'Lights', 'State', value, 'Lights',
'state', status_qualifier, ''
])
class Light(object):
def __init__(self):
self.r = Relay()
def setLightOn(self, test=False):
"Check the time and determine if the lights need to be changed"
self.r.setOn(lightPin, test)
self.logState("On", test)
def setLightOff(self, test=False):
'''Turn light relay off'''
self.r.setOff(lightPin, test)
self.logState("Off", test)
def getState(self, test=False):
return self.r.getState(lightPin, test)
def logState(self, value, test=False):
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
jsn = makeEnvJson('State_Change', 'Lights', 'Top', 'State', value,
'Lights', status_qualifier)
CouchDB.logEnvObsvJSON(jsn)
def test(self):
print "Test Light"
print "Light State: ", self.getState(True)
print "Turn Light On"
self.setLightOn(True)
print "Light State: ", self.getState(True)
print "Turn Light Off"
self.setLightOff(True)
print "Light State: ", self.getState(True)
print "Turn Light On"
self.setLightOn(True)
print "Light State: ", self.getState(True)
print "Done"
class Pump:
def __init__(self, logger=None):
'''Initialize the object'''
self.solenoidPin = Relay4
if logger==None:
self._logger = Logger('Solenoid', Logger.INFO)
else:
self._logger = logger
self._relay=Relay(self._logger)
self._couch=CouchUtil(self._logger)
self._test = False
self.activity_type = 'State_Change'
def on(self):
self._relay.set_off(self.solenoidPin)
self._logger.debug("{}".format("Open Solenoid"))
self.logState("Open")
def off(self):
self._relay.set_on(self.solenoidPin)
self._logger.debug("{}".format("Close Solenoid"))
self.logState("Closed")
def getState(self):
state=self._relay.get_state(self.solenoidPin)
if state==0:
return "On"
else:
return "Off"
def logState(self, value):
status_qualifier='Success'
if self._test:
status_qualifier='Test'
self._couch.saveList(['State_Change', '', 'Pump', 'Reservoir', 'State', value, 'state', 'Solenoid', status_qualifier, ''])
def main():
board = Board()
relay = Relay()
lcd = Lcd()
while (1):
light = int(board.light())
lcd.display_string("Control: %d" % (board.control()), 1)
lcd.display_string("Light: %d" % (light), 2)
lcd.display_string("Temprature: %d" % (board.temperature()), 3)
lcd.display_string("Custom: %d" % (board.custom()), 4)
if light >= 175:
relay.on(0)
if light >= 200:
relay.on(1)
if light <= 125:
relay.off(1)
if light <= 50:
relay.off(0)
time.sleep(1)
def __init__(self):
confs = utils.getConfiguration(self.name)
if confs != None:
try:
self.controller_name = str(confs['controller_name'])
self.controller_id = int(confs['controller_id'])
except:
print("Notice: some of the Water Pump pins are not used")
print("WaterPumpController initialized - configuration found")
else:
newConfs = [('controller_name', None), ('controller_id', None)]
utils.setConfiguration(self.name, newConfs)
print(
"WaterPumpController initialized - Warning: new configuration")
if self.controller_name.upper() == 'relay'.upper():
self.controller = Relay.Relay()
def AirOn(update: Update, context: CallbackContext) -> None:
"""Send a message when the command /start is issued."""
update.message.reply_text('공기청정기를 작동시킵니다.')
Relay.relay(1, 0)
update.message.reply_text('공기청정기 작동이 되었습니다!')
def AirOff(update: Update, context: CallbackContext) -> None:
"""Send a message when the command /start is issued."""
update.message.reply_text('공기청정기 작동을 멈춤니다.')
Relay.relay(1, 1)
update.message.reply_text('공기청정기가 작동이 멈췄습니다!')
def DehumidOn(update: Update, context: CallbackContext) -> None:
"""Send a message when the command /start is issued."""
update.message.reply_text('제습기를 작동시킵니다.')
Relay.relay(2, 0)
update.message.reply_text('제습기 작동되었습니다!')
def start_brew(self):
##initialize sound for acoustic warnings
self.sound = Sound.Sound()
##initialize temperature probe
self.temperature = Temp.Temp()
##initialize relay for heat
self.heat = Relay.Relay(21)
self.notification = push.Push()
##TODO - plotting -
thread.start_new_thread(self.plot_data, ())
self.status = "heating to mash"
self.notification.sendString(self.TITLE, self.status)
##TODO - telegram -
thread.start_new_thread(self.telegramchat, ())
##increase to mash temperature
# elapsed_time_tmash=self.temperature.increase_to(self.mash_temp, self.heat)
##acoustic warning -insertgrain-
self.notification.sendString(self.TITLE, self.INSERTGRAIN)
self.status = "mash"
##keep tmash constant for mash_time taken from recipe
# self.temperature.keep_constant(self.mash_temp, self.mash_time, self.heat)
##acoustic warning -removegrain-
##self.sound.play(self.REMOVEGRAIN)
self.notification.sendString(self.TITLE, self.REMOVEGRAIN)
self.status = "heating to boil"
##increase temperature for boiling
elapsed_time_tboil = self.temperature.increase_to(
self.boil_temp, self.heat)
##start timers
##end of boiling - timer -
timer_end = Timer.Timer(self.boil_time * 60, self.notification,
self.BOILEND)
##insert cooling element -timer-
timer_coolinginsert = Timer.Timer(
(self.boil_time - 15) * 60, self.notification, self.COOLINGINSERT)
timer_end.start()
timer_coolinginsert.start()
if self.hop_bitter:
##timer for inserting hops for bittering
timer_hop_bitter = Timer.Timer(
(self.boil_time - self.hop_bitter.boil_time) * 60,
self.notification, self.HOPBITTER)
timer_hop_bitter.start()
if self.hop_taste:
if (self.hop_taste.boil_time > 0):
##timer for inserting hops for taste
timer_hop_taste = Timer.Timer(
(self.boil_time - self.hop_taste.boil_time) * 60,
self.notification, self.HOPTASTE)
timer_hop_taste.start()
if self.hop_flav:
if (self.hop_flav.boil_time > 0):
##timer for inserting hops for flavour
timer_hop_flav = Timer.Timer(
(self.boil_time - self.hop_flav.boil_time) * 60,
self.notification, self.HOPFLAV)
timer_hop_flav.start()
##boil -> keep resistance always on for boil time
##start boiling for boil time -heat always on-
self.status = "boil"
self.notification.sendString(self.TITLE, self.status)
self.temperature.boil(self.boil_time, self.heat)
##boil end
##switch off heat
self.status = "end"
self.heat.off()
self.notification.sendString(self.TITLE, self.BOILEND)
print "BREW END"
self.plot = 1
self.chat = 1
self.save_data()
print "data saved!"
print ""
# This will import the sleep function for the timer below.
from time import sleep
#Duration
durationInMin = 8 * 60
#durationInMin = 5
#set up the relay objects
relays = ["P8_8", "P8_9"]
# #use a dictionary comprehension to create Stations
# holder = {pinNum:Station(name = pinNum,pinNum=pinNum) for pinNum in relays}
# for x in holder:
# holder[x].setup()
# print("Station name is "+holder[x].name +". Station pinNum is "+holder[x].pinNum)
relay1 = Relay("P8_8")
relay2 = Relay("P8_8")
relay1.setup()
relay2.setup()
relay1.on()
sleep(120)
relay1.off()
relay2.on()
sleep(120)
relay2.off()
class R2D2:
def __init__(self):
logging.basicConfig(format="%(levelname)s (%(asctime)s): %(message)s", datefmt="%I:%M:%S %p", level=logging.INFO, filename="/var/tmp/R2D2.log")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
atexit.register(self.Exit)
self.MCP3008 = MCP3008(spi=SPI.SpiDev(0, 0))
self.Voltage = VoltageDivider(self.MCP3008, 0, 984.0, 101.0)
self.Current = ACS711EX(self.MCP3008, 1)
self.BrightnessControl = Potentiometer(self.MCP3008, 2)
self.Battery = LiPo(self.Voltage, self.Current, 6, 10)
self.DomeLightsRelay = self.Relay1 = Relay(16)
self.DomeServosRelay = self.Relay2 = Relay(17)
self.DomeMotorRelay = self.Relay3 = Relay(18)
self.Relay4 = Relay(19)
self.Relay5 = Relay(20)
self.SoundRelay = self.Relay6 = Relay(21)
self.BodyServosRelay = self.Relay7 = Relay(22)
self.BodyLightsRelay = self.Relay8 = Relay(23)
self.Relay9 = Relay(24)
self.Relay10 = Relay(25)
self.Relay11 = Relay(26)
self.Relay12 = Relay(27)
self.Network = Network()
self.Head = HeadMotor(self.DomeMotorRelay)
self.Sound = Sound()
self.StatusDisplay = StatusDisplay(self)
self.FrontLogicDisplay = FrontLogicDisplay(self.DomeLightsRelay)
self.RearLogicDisplay = RearLogicDisplay(self.DomeLightsRelay)
self.FrontProcessStateIndicator = FrontProcessStateIndicator(self.DomeLightsRelay)
self.RearProcessStateIndicator = RearProcessStateIndicator(self.DomeLightsRelay)
self.FrontHoloProjector = FrontHoloProjector(self.DomeLightsRelay)
self.TopHoloProjector = TopHoloProjector(self.DomeLightsRelay)
self.RearHoloProjector = RearHoloProjector(self.DomeLightsRelay)
self.MagicPanel = MagicPanel(self.DomeLightsRelay)
self.LifeFormScanner = LifeFormScanner(self.DomeServosRelay)
self.DomePanels = Panels()
self.BodyServos = Maestro("00126418")
self.LeftUtilityArm = MaestroServo(self.BodyServos, 16, 2390, 1520, 20, 1)
self.RightUtilityArm = MaestroServo(self.BodyServos, 17, 2390, 1520, 20, 1)
def Exit(self):
self.Relay1.Disable()
self.Relay2.Disable()
self.Relay3.Disable()
self.Relay4.Disable()
self.Relay5.Disable()
self.Relay6.Disable()
self.Relay7.Disable()
self.Relay8.Disable()
self.Relay9.Disable()
self.Relay10.Disable()
self.Relay11.Disable()
self.Relay12.Disable()
self.StatusDisplay.SetBacklight(False)
self.StatusDisplay.Clear()
self.BodyServos.Close()
GPIO.cleanup()
def SetBrightness(self, brightness, limit = True):
if self.DomeLightsRelay.Enabled:
self.FrontLogicDisplay.SetBrightness(min(127, brightness / 2) if limit else brightness)
self.RearLogicDisplay.SetBrightness(min(127, brightness / 2) if limit else brightness)
self.FrontProcessStateIndicator.SetBrightness(min(127, brightness / 2) if limit else brightness)
self.RearProcessStateIndicator.SetBrightness(min(127, brightness / 2) if limit else brightness)
self.FrontHoloProjector.SetBrightness(brightness)
self.TopHoloProjector.SetBrightness(brightness)
self.RearHoloProjector.SetBrightness(brightness)
self.MagicPanel.SetBrightness(brightness)
def SetDefault(self):
if self.DomeLightsRelay.Enabled:
self.FrontLogicDisplay.SetDefault()
self.RearLogicDisplay.SetDefault()
self.FrontProcessStateIndicator.SetDefault()
self.RearProcessStateIndicator.SetDefault()
self.FrontHoloProjector.SetDefault()
self.TopHoloProjector.SetDefault()
self.RearHoloProjector.SetDefault()
self.MagicPanel.SetDefault()
self.LifeFormScanner.SetDefault()
def SetError(self):
if self.DomeLightsRelay.Enabled:
self.FrontLogicDisplay.SetError()
self.RearLogicDisplay.SetError()
self.FrontProcessStateIndicator.SetError()
self.RearProcessStateIndicator.SetError()
self.FrontHoloProjector.SetError()
self.TopHoloProjector.SetError()
self.RearHoloProjector.SetError()
self.MagicPanel.SetError()
self.LifeFormScanner.SetError()
def SetOff(self):
if self.DomeLightsRelay.Enabled:
self.FrontLogicDisplay.SetOff()
self.RearLogicDisplay.SetOff()
self.FrontProcessStateIndicator.SetOff()
self.RearProcessStateIndicator.SetOff()
self.FrontHoloProjector.SetOff()
self.TopHoloProjector.SetOff()
self.RearHoloProjector.SetOff()
self.MagicPanel.SetOff()
self.LifeFormScanner.SetOff()
def startRelay1(routeNumber):
if 1 == routeNumber:
# Relay input 1,3 On
Relay.startFunc(0, 1)
Relay.startFunc(2, 1)
time.sleep(5)
# Relay input 1,3 Off
Relay.startFunc(0, 0)
Relay.startFunc(2, 0)
startRelay(2)
else:
# Relay input 2,4 On
Relay.startFunc(1, 1)
Relay.startFunc(3, 1)
time.sleep(5)
# Relay input 2,4 Off
Relay.startFunc(1, 0)
Relay.startFunc(3, 0)
startRelay(1)
def __init__(self):
logging.basicConfig(format="%(levelname)s (%(asctime)s): %(message)s", datefmt="%I:%M:%S %p", level=logging.INFO, filename="/var/tmp/R2D2.log")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
atexit.register(self.Exit)
self.MCP3008 = MCP3008(spi=SPI.SpiDev(0, 0))
self.Voltage = VoltageDivider(self.MCP3008, 0, 984.0, 101.0)
self.Current = ACS711EX(self.MCP3008, 1)
self.BrightnessControl = Potentiometer(self.MCP3008, 2)
self.Battery = LiPo(self.Voltage, self.Current, 6, 10)
self.DomeLightsRelay = self.Relay1 = Relay(16)
self.DomeServosRelay = self.Relay2 = Relay(17)
self.DomeMotorRelay = self.Relay3 = Relay(18)
self.Relay4 = Relay(19)
self.Relay5 = Relay(20)
self.SoundRelay = self.Relay6 = Relay(21)
self.BodyServosRelay = self.Relay7 = Relay(22)
self.BodyLightsRelay = self.Relay8 = Relay(23)
self.Relay9 = Relay(24)
self.Relay10 = Relay(25)
self.Relay11 = Relay(26)
self.Relay12 = Relay(27)
self.Network = Network()
self.Head = HeadMotor(self.DomeMotorRelay)
self.Sound = Sound()
self.StatusDisplay = StatusDisplay(self)
self.FrontLogicDisplay = FrontLogicDisplay(self.DomeLightsRelay)
self.RearLogicDisplay = RearLogicDisplay(self.DomeLightsRelay)
self.FrontProcessStateIndicator = FrontProcessStateIndicator(self.DomeLightsRelay)
self.RearProcessStateIndicator = RearProcessStateIndicator(self.DomeLightsRelay)
self.FrontHoloProjector = FrontHoloProjector(self.DomeLightsRelay)
self.TopHoloProjector = TopHoloProjector(self.DomeLightsRelay)
self.RearHoloProjector = RearHoloProjector(self.DomeLightsRelay)
self.MagicPanel = MagicPanel(self.DomeLightsRelay)
self.LifeFormScanner = LifeFormScanner(self.DomeServosRelay)
self.DomePanels = Panels()
self.BodyServos = Maestro("00126418")
self.LeftUtilityArm = MaestroServo(self.BodyServos, 16, 2390, 1520, 20, 1)
self.RightUtilityArm = MaestroServo(self.BodyServos, 17, 2390, 1520, 20, 1)
class Fan(object):
"""Code associated with the exhaust fan"""
relay = None
target_temp = 0
def __init__(self):
self.logger = get_logger("Fan")
self.logger.debug("initialize Fan object")
self.relay = Relay()
self.fan_relay = fanPin
def set_fan_on(self):
"""Turn the fan on
Args:
None
Returns:
None
Raises:
None
"""
self.logger.debug("In set_fan_on")
self.relay.set_state(self.fan_relay, ON)
def set_fan_off(self):
"""Turn the fan off
Args:
None
Returns:
None
Raises:
None
"""
self.logger.debug("In set_fan_off")
self.relay.set_state(self.fan_relay, OFF)
def adjust(self, temp, test=False):
"""Determine if the fan should change state
Args:
temp: current temperature
test: flag for testing
Returns:
None
Raises:
None
"""
self.logger.debug("In adjust")
fan_state = self.relay.get_state(self.fan_relay)
target_temp = env['thermostat']['targetTemp']
msg = "{} {} {} {} {} {}".format("Temp:", temp, " Target Temp:", target_temp, " Fan State:", fan_state)
self.logger.info(msg)
if temp > target_temp and not fan_state:
self.set_fan_on()
self.log_state("On", test)
self.logger.debug("Turning fan on")
elif temp <= target_temp and fan_state:
self.set_fan_off()
self.log_state("Off", test)
self.logger.debug("Turning fan on")
else:
self.logger.debug("No change to fan")
def log_state(self, value, test=False):
"""Send state change to database
Args:
value: state change
test: flag for testing
Returns:
None
Raises:
None
"""
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
saveList(['State_Change', '', 'Side', 'Fan', 'State', value, 'state', 'Fan', status_qualifier, ''])
def __init__(self):
self.r = Relay()
self.logger = get_logger('Light')
def message(client, feed_id, payload):
Relay.switch("post/"+feed_id, payload)
def startRoute(self):
self.isOpen = True
Relay.startFunc(self.light1, 1)
Relay.startFunc(self.light2, 1)
def __init__(self):
self.logger = get_logger("Fan")
self.logger.debug("initialize Fan object")
self.relay = Relay()
self.fan_relay = fanPin
def stopRoute(self):
self.isOpen = False
Relay.startFunc(self.light1, 0)
Relay.startFunc(self.light2, 0)