def pyload_simulate(self, configrsc: str, procimg: str, clean_existing: bool):
"""Start the simulator for piControl on local computer."""
pi.logger.debug("ConnectionManager.start_simulate")
if not exists(procimg) or clean_existing:
with open(procimg, "wb") as fh:
fh.write(b'\x00' * 4096)
try:
import revpimodio2
# Prepare process image with default values for outputs
self._revpi_output = revpimodio2.RevPiModIO(configrsc=configrsc, procimg=procimg)
self._revpi_output.setdefaultvalues()
self._revpi_output.writeprocimg()
# This is our simulator to work with
self._revpi = revpimodio2.RevPiModIO(simulator=True, configrsc=configrsc, procimg=procimg)
self._revpi.setdefaultvalues()
self._revpi.writeprocimg()
self.xml_funcs = ["psstart", "psstop", "ps_devices", "ps_inps", "ps_outs", "ps_values", "ps_setvalue"]
self.connection_established.emit()
except Exception as e:
pi.logger.exception(e)
self.connection_error_observed.emit(str(e))
self._revpi_output = None
self._revpi = None
if settings.value("simulator/stop_remove", False, bool):
remove(procimg)
return self._revpi is not None
def initialize_revpimodio(self):
if self.revpi: # clean if already existent
self.revpi.cleanup()
self.revpi = None
if not os.path.isfile("/etc/revpi/config.rsc") and not os.path.isfile(
"/opt/KUNBUS/config.rsc"):
logging.error(
"No hardware configuration found. Please configure hardware in PiCtory!"
)
while not os.path.isfile(
"/etc/revpi/config.rsc") and not os.path.isfile(
"/opt/KUNBUS/config.rsc"):
time.sleep(60)
logging.info("New hardware configuration found. Continuing..")
# init RevPiModIO with auto refresh
# shared_procimg set to true ist not recommended (slow speed)
# if its too slow, either we make our own cycle_cloop where we update the reg_events on our own or
# we change the revpimodio2 lib so outputs set by other processes are read into the buffers. currently
# external output changes are ignored and all values are taken from the intern buffers
self.revpi = revpimodio2.RevPiModIO(autorefresh=True,
shared_procimg=True)
def __init__(self):
logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"),
format='%(asctime)s;<%(levelname)s>;%(message)s')
logging.info("Init")
if len(sys.argv) > 1:
self.config_file = sys.argv[1]
self.load_config()
self.init_channels()
#MQTT init
self.mqttclient = mqtt.Client()
self.mqttclient.on_connect = self.mqtt_on_connect
#RPI init
self.rpi = revpimodio2.RevPiModIO(autorefresh=True,
direct_output=True,
configrsc='/config.rsc')
self.rpi.handlesignalend(self.programend)
#Register program end event
atexit.register(self.programend)
logging.info("init done")
def __init__(self):
"""Init MyRevPiApp class."""
# Instantiate RevPiModIO
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
# Handle SIGINT / SIGTERM to exit program cleanly
self.rpi.handlesignalend(self.cleanup_revpi)
# Register events for main_switch
self.rpi.io.main_switch.reg_event(self.event_main_on, edge=revpimodio2.RISING)
self.rpi.io.main_switch.reg_event(self.event_main_off, edge=revpimodio2.FALLING)
# Register events for switch_1
self.rpi.io.switch_1.reg_event(self.event_switch_1_on, edge=revpimodio2.RISING)
self.rpi.io.switch_1.reg_event(self.event_switch_1_off, edge=revpimodio2.FALLING)
# Register events for switch_2
self.rpi.io.switch_2.reg_event(self.event_switch_2_on, edge=revpimodio2.RISING)
self.rpi.io.switch_2.reg_event(self.event_switch_2_off, edge=revpimodio2.FALLING)
# initialize output to False = 0 = off = no-lights
self.rpi.io.main_relay.value = False
self.rpi.io.relay_1.value = False
self.rpi.io.relay_2.value = False
# initialize states
self.main_state = False
self.state_1_on = False
self.state_2_on = False
def cleanup_revpi(self):
"""Cleanup function to leave the RevPi in a defined state."""
# Switch off LED and outputs before exit program
self.rpi.io.main_relay.value = False
self.rpi.io.relay_1.value = False
self.rpi.io.relay_2.value = False
self.rpi = revpimodio2.RevPiModIO(autorefresh=False)
def __init__(self):
self.timer_thread = TimerThread()
self.timer_thread.update_signal.connect(self.update_lcd)
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
self.rpi.handlesignalend(self.cleanup_revpi)
self.rpi.io.I_1.reg_event(toggle_input, prefire=True)
self.rpi.io.I_1.reg_event(self.send_toggle_signal)
def __init__(self):
self.revPi = revpimodio2.RevPiModIO(autorefresh=True)
self.revPi.handlesignalend(self.cleanup_revpi)
self.tl1 = TraficLight(revPi=self.revPi,
ioGreen='O_3',
ioOrange='O_2',
ioRed='O_1')
def __init__(self, **kwargs):
#--------------------------------------------------------------------
# Arbrittues
#--------------------------------------------------------------------
# Reference to the pi
self.__rpi = revpimodio2.RevPiModIO(autorefresh=True)
# Handle SIGINT / SIGTERM to exit program cleanly
self.__rpi.handlesignalend(self.cleanup_revpi)
def cleanup_revpi(self):
"""Cleanup function to leave the RevPi in a defined state, stop opc server and exit."""
self.rpi.core.a1green.value = False
self.rpi.core.a1red.value = False
self.rpi.io.main_relay.value = False
self.rpi.io.relay_1.value = False
self.rpi.io.relay_2.value = False
self.rpi = revpimodio2.RevPiModIO(autorefresh=False)
self.opc_server.stop()
print("exit")
# self.master.destroy()
exit(1)
def loadrevpimodio(self):
"""Instantiiert das RevPiModIO Modul.
@return None or Exception"""
# RevPiModIO-Modul Instantiieren
if self.rpi is not None:
self.rpi.cleanup()
proginit.logger.debug("create revpimodio2 object for ProcimgServer")
try:
self.rpi = revpimodio2.RevPiModIO(
configrsc=proginit.pargs.configrsc,
procimg=proginit.pargs.procimg,
replace_io_file=self.replace_ios,
shared_procimg=True,
)
self.rpi.debug = -1
if self.replace_ios:
proginit.logger.info("loaded replace_ios to ProcimgServer")
except Exception as e:
try:
self.rpi = revpimodio2.RevPiModIO(
configrsc=proginit.pargs.configrsc,
procimg=proginit.pargs.procimg,
shared_procimg=True,
)
self.rpi.debug = -1
proginit.logger.warning(
"replace_ios_file not loadable for ProcimgServer - using "
"defaults now | {0}".format(e))
except Exception as e:
self.rpi = None
proginit.logger.error(
"piCtory configuration not loadable for ProcimgServer | "
"{0}".format(e))
return e
proginit.logger.debug("created revpimodio2 object")
def __init__(self):
self.profile_path = "/home/pi/ksg_edge_deploy/socket_project/config.json" #revpi edge path
self._profile = get_profile(self.profile_path)
self.image_path = self._profile.get("IMGPATH")
self.sensor_profile = self._profile.get("sensor_list")
self.normalization_profile = self._profile.get("data_information")
self.sampling_time = 0.02 #20ms
self.before_buffer = []
self.after_buffer = []
self.rev = revpimodio2.RevPiModIO(autorefresh=True,
procimg=self.image_path)
self.rev.cycletime = 1000
self.IO = self.rev.io
def __init__(self, master=None):
"""Init MyRevPiApp class."""
# Instantiate RevPiModIO
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
# Handle SIGINT / SIGTERM to exit program cleanly
self.rpi.handlesignalend(self.cleanup_revpi)
# Register event to toggle output O_1 with input I_1
self.rpi.io.main_switch.reg_event(self.event_main_on,
edge=revpimodio2.RISING)
self.rpi.io.main_switch.reg_event(self.event_main_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_3 with input I_3
self.rpi.io.switch_1.reg_event(self.event_switch_1_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_1.reg_event(self.event_switch_1_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_5 with input I_5
self.rpi.io.switch_2.reg_event(self.event_switch_2_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_2.reg_event(self.event_switch_2_off,
edge=revpimodio2.FALLING)
self.rpi.core.a1green.value = True # program is loaded and active
self.rpi.io.main_relay.value = False # O 1 (output 1) right side connector on DIO is odd input/output nr
self.rpi.io.relay_1.value = False # O 3
self.rpi.io.relay_2.value = False # O 5
self.rpi.mainloop(blocking=False)
self.main_state = False
self.state_1_on = False
self.state_2_on = False
# Handle tkinter part
super().__init__(master)
self.master.protocol("WM_DELETE_WINDOW", self.cleanup_revpi)
self.master.wm_title("plc program")
self.master.wm_resizable(width=False, height=False)
fontlabel = ('helvetica', 15, 'bold')
self.btn_stop = Button(self.master,
text="Stop running PLC program",
font=fontlabel)
self.btn_stop["command"] = self.cleanup_revpi
self.btn_stop.grid(row=0, column=0)
def closeapp(self):
# tkinker
self.master.destroy()
# Switch off LED and outputs to leave RevPi in defined state before exit program
self.rpi.core.a1green.value = False
self.rpi.io.main_relay.value = False
self.rpi.io.relay_1.value = False
self.rpi.io.relay_2.value = False
self.rpi = revpimodio2.RevPiModIO(autorefresh=False)
self.main_state = False
self.door_1_state = False
self.door_2_state = False
def __init__(self):
self.ledThred = None
self.revpi = revpimodio2.RevPiModIO(autorefresh=True)
self.revpi.core.A1 = revpimodio2.GREEN
# Handle SIGINT / SIGTERM to exit program cleanly
self.revpi.handlesignalend(self.cleanup_revpi)
# Register events to all Inputs
#self.revpi.io.I_1.reg_event(self.event_input_changed, edge=revpimodio2.BOTH)
for device in self.revpi.device:
# Use only DIO, DI, DO, AIO Devices
if device.type == "LEFT_RIGHT":
for io in device.get_inputs():
io.reg_event(self.event_input_changed)
def __init__(self, master=None):
super().__init__(master)
self.pack()
# RevPiModIO verwenden mit autorefresh=True!
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
# Button erstellen und "click_an" als Event binden
self.btn_an = tkinter.Button(self)
self.btn_an["text"] = "anschalten"
self.btn_an["command"] = self.click_an
self.btn_an.pack()
# Button erstellen und "click_aus" als Event binden
self.btn_aus = tkinter.Button(self)
self.btn_aus["text"] = "ausschalten"
self.btn_aus["command"] = self.click_aus
self.btn_aus.pack()
def __init__(self):
"""Init MyRevPiApp class."""
# Instantiate RevPiModIO
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
# Handle SIGINT / SIGTERM to exit program cleanly
self.rpi.handlesignalend(self.cleanup_revpi)
# Register event to toggle output O_1 with input I_1
self.rpi.io.main_switch.reg_event(self.event_main_on,
edge=revpimodio2.RISING)
self.rpi.io.main_switch.reg_event(self.event_main_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_3 with input I_3
self.rpi.io.switch_1.reg_event(self.event_switch_1_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_1.reg_event(self.event_switch_1_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_5 with input I_5
self.rpi.io.switch_2.reg_event(self.event_switch_2_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_2.reg_event(self.event_switch_2_off,
edge=revpimodio2.FALLING)
self.rpi.core.a1green.value = True # program is loaded and active
self.rpi.core.a1red.value = False
self.rpi.core.a2green.value = False
self.rpi.core.a2red.value = False
self.rpi.io.main_relay.value = False # O 1 (output 1) right side connector on DIO is odd input/output nr
self.rpi.io.relay_1.value = False # O 3
self.rpi.io.relay_2.value = False # O 5
self.main_state = False
self.state_1_on = False
self.state_2_on = False
def test_replace_io(self):
"""Test replace_io file.
@return 0 if successful testet"""
print("Test replace_io data:")
file = self.gc["DEFAULT"].get("replace_ios")
if file is None:
print("\tFile MISSING")
return 1
print("\tFile: {0}\n".format(file))
try:
import revpimodio2
except Exception as e:
print("\tERROR: {0}".format(e))
return 1
try:
rpi = revpimodio2.RevPiModIO(
configrsc=proginit.pargs.configrsc,
procimg=proginit.pargs.procimg,
monitoring=True,
debug=True,
replace_io_file=file,
)
except Exception as e:
print(e)
return 1
else:
print("\tPrinting replaced IOs:")
for io in rpi.io:
if isinstance(io, revpimodio2.io.StructIO):
print("\t\tNew io: {0}".format(io.name))
rpi.cleanup()
return 0
def _loadrevpimodio(self):
"""Instantiiert das RevPiModIO Modul.
@return None or Exception"""
self._reloadmodio = False
self._exported_ios = []
# RevPiModIO-Modul Instantiieren
if self._rpi is not None:
self._rpi.cleanup()
proginit.logger.debug("create revpimodio2 object for MQTT")
try:
# Vollzugriff und Eventüberwachung
self._rpi = revpimodio2.RevPiModIO(
autorefresh=self._send_events,
monitoring=not self._write_outputs,
configrsc=proginit.pargs.configrsc,
procimg=proginit.pargs.procimg,
replace_io_file=self._replace_ios,
shared_procimg=True,
)
self._rpi.debug = -1
if self._replace_ios:
proginit.logger.info("loaded replace_ios to MQTT")
except Exception as e:
try:
# Lesend und Eventüberwachung
self._rpi = revpimodio2.RevPiModIO(
autorefresh=self._send_events,
monitoring=not self._write_outputs,
configrsc=proginit.pargs.configrsc,
procimg=proginit.pargs.procimg,
shared_procimg=True,
)
self._rpi.debug = -1
proginit.logger.warning(
"replace_ios_file not loadable for MQTT - using "
"defaults now | {0}".format(e))
except Exception as e:
self._rpi = None
proginit.logger.error(
"piCtory configuration not loadable for MQTT | "
"{0}".format(e))
raise e
# Exportierte IOs laden
for dev in self._rpi.device:
for io in dev.get_allios(export=True):
io.reg_event(self._evt_io)
self._exported_ios.append(io)
# CoreIOs prüfen und zu export hinzufügen
lst_coreio = []
if self._rpi.core:
if self._rpi.core.a1green.export:
lst_coreio.append(self._rpi.core.a1green)
if self._rpi.core.a1red.export:
lst_coreio.append(self._rpi.core.a1red)
if self._rpi.core.a2green.export:
lst_coreio.append(self._rpi.core.a2green)
if self._rpi.core.a2red.export:
lst_coreio.append(self._rpi.core.a2red)
if self._rpi.core.wd.export:
lst_coreio.append(self._rpi.core.wd)
# Connect-IOs anhängen
if type(self._rpi.core) == revpimodio2.device.Connect:
if self._rpi.core.a3green.export:
lst_coreio.append(self._rpi.core.a3green)
if self._rpi.core.a3red.export:
lst_coreio.append(self._rpi.core.a3red)
if self._rpi.core.x2in.export:
lst_coreio.append(self._rpi.core.x2in)
if self._rpi.core.x2out.export:
lst_coreio.append(self._rpi.core.x2out)
# IOs exportieren und Events anmelden
for io in lst_coreio:
io.reg_event(self._evt_io)
self._exported_ios.append(io)
proginit.logger.debug("created revpimodio2 object")
ct.var.mrk_t_forklift = False
rpi.io.forklift.value = False
rpi.io.load_pos.value = 0
rpi.io.more_left.value = False
rpi.io.more_right.value = False
rpi.io.h_red.value = False
rpi.io.h_green.value = False
def cleanup():
rpi.io.program_running.value = False
# One global RevPiModIO instance for all modules and classes
rpi = revpimodio2.RevPiModIO(autorefresh=True)
# Configure IO of profinet device
rpi.io.b_position1.replace_io("position", "H", byteorder="big")
# Configure IO of panel device
rpi.io.p_byte1.replace_io("p_online", "?", bit=0)
rpi.io.r_byte1.replace_io("program_running", "?", bit=0)
rpi.io.r_byte2.replace_io("more_left", "?", bit=0)
rpi.io.r_byte2.replace_io("more_right", "?", bit=1)
rpi.io.r_byte2.replace_io("forklift", "?", bit=2)
rpi.io.r_position1.replace_io("load_pos", "h")
# Export replaced ios for revpipyload and NetIO clients
def __init__(self):
self.revpi = revpimodio2.RevPiModIO(autorefresh=False)
runner = Process(target=runner, args=(queue, event))
runner.daemon = True
runner.start()
item = [0.0, False]
while run:
try:
item = queue.get(timeout=1)
#logging.debug("Vakthund: Ingen körning meddelad")
except Exception as error:
#logging.debug("Vakthund: Timeout {}".format(str(error)))
pass
if item[1] is True and item[0] + 3 < time():
print('Vakthund: Mer än 3 sekunder sen')
runner.terminate()
modio = revpimodio2.RevPiModIO(autorefresh=False)
modio.setdefaultvalues()
modio.writeprocimg()
logging.debug('Process avslutad')
exit()
else:
#print('Vakthund: I tid eller körning pågår ej')
pass
sleep(0.04)
event.set()
print('Avslutar huvudprocess')
runner.join()
import os
try:
raw_input # Python 2
except NameError:
raw_input = input # Python 3
def eventfunction(ioname, iovalue):
#print("Event {} has the value of {}".format(ioname,iovalue))
print(iovalue)
if len(sys.argv) > 2:
cmd = sys.argv[1]
pin_input = sys.argv[2]
if cmd=="in":
rpi_in = revpimodio2.RevPiModIO(autorefresh=True,direct_output=True)
#rpi_in.handlesignalend()
#rpi.mainloop()
rpi_in.io[pin_input].reg_event(eventfunction)
rpi_in.mainloop(blocking=False)
while True:
try:
data = raw_input()
if "close" in data:
sys.exit(0)
except (EOFError, SystemExit):
#sys.exit(0)
os._exit(0)
if cmd=="out":
output_value = sys.argv[3]
rpi_out = revpimodio2.RevPiModIO(autorefresh=True,direct_output=True)
def __init__(self):
"""Init MyRevPiApp class."""
self.main_state = False
self.state_1_on = False
self.state_2_on = False
self.trigger = 0
self.trigger_system_on_trigger = 1
self.trigger_system_off_trigger = 2
self.trigger_door_outside_open = 3
self.trigger_door_outside_close = 4
self.trigger_door_inside_open = 5
self.trigger_door_inside_close = 6
# self.system_on_time
# self.system_off_time
# self.system_delta_time = 0.0
# self.system_running_time = 0.0
self.system_sum_time = 0
self.door_count = 0
self.door_outside_time_opened = 0.0
self.door_outside_time_closed = 0.0
self.door_outside_delta_time_open = 0.0
self.door_outside_sum_time_open = 0.0
self.door_inside_time_opened = 0.0
self.door_inside_time_closed = 0.0
self.door_inside_delta_time_open = 0.0
self.door_inside_sum_time_open = 0.0
self.open_percentage = 0
self.door_open_time = 0.0
self.door_outside_share_percentage = 50 # = door_outside/(door_outside+door_inside)time
print("put all switches in off mode")
# Instantiate RevPiModIO
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
# standard cycletime on Core-3 is 20 (msec), by uncommenting next line you extend it to 50 msec
# might be needed if once more print statements are used in event handlers
# self.rpi.cycletime = 50
# Handle SIGINT / SIGTERM to exit program cleanly
self.rpi.handlesignalend(self.cleanup_revpi)
# Register event to toggle output O_1 with input I_1
self.rpi.io.main_switch.reg_event(self.event_main_on,
edge=revpimodio2.RISING)
self.rpi.io.main_switch.reg_event(self.event_main_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_3 with input I_3
self.rpi.io.switch_1.reg_event(self.event_switch_1_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_1.reg_event(self.event_switch_1_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_5 with input I_5
self.rpi.io.switch_2.reg_event(self.event_switch_2_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_2.reg_event(self.event_switch_2_off,
edge=revpimodio2.FALLING)
self.rpi.core.a1green.value = True # program is loaded and active
self.rpi.core.a1red.value = False
self.rpi.core.a2green.value = False
self.rpi.core.a2red.value = False
self.rpi.io.main_relay.value = False # O 1 (output 1) right side connector on DIO is odd input/output nr
self.rpi.io.relay_1.value = False # O 3
self.rpi.io.relay_2.value = False # O 5
print(
'starting OPC server on core-3: (url 0.0.0.0 (192.168.1.3 or 192.168.0.3 or 10.0.0.3 or 10.0.1.3):4840)'
)
self.opc_server = Server(shelffile="/home/pi/RevPi-OPC-Server")
# shelffile is trick with freeopcua to speedup loading of xml object base
self.opc_url = "opc.tcp://0.0.0.0:4840"
self.opc_server.set_endpoint(self.opc_url)
# TODO security
print('starting OPC server .. (namespace)')
self.opc_name = "RevPi-opcua-server"
self.addspace = self.opc_server.register_namespace(self.opc_name)
print('starting OPC server ... (variables)')
self.opc_node = self.opc_server.get_objects_node()
self.param = self.opc_node.add_object(self.addspace, "Parameters")
self.opc_time = self.param.add_variable(self.addspace, "Time",
0) # opc i=2
self.opc_trigger = self.param.add_variable(self.addspace, "Trigger",
0) # opc i=3
self.opc_warehouse_state = self.param.add_variable(
self.addspace, "System state", 0) # opc i=4
self.opc_door_outside = self.param.add_variable(
self.addspace, "Outside door", 0) # opc i=5
self.opc_door_inside = self.param.add_variable(self.addspace,
"Inside door",
0) # opc i=6
self.opc_open_percentage = self.param.add_variable(
self.addspace, "Door open %", 0.0) # opc i=7
self.opc_door_outside_share_percentage = self.param.add_variable(
self.addspace, "Outside/Inside share", 0.0)
self.opc_time.set_writable()
self.opc_trigger.set_writable()
self.opc_warehouse_state.set_writable()
self.opc_door_outside.set_writable()
self.opc_door_inside.set_writable()
self.opc_open_percentage.set_writable()
self.opc_door_outside_share_percentage.set_writable()
self.opc_server.start()
print("OPC UA Server started at {}".format(self.opc_url))
def __init__(self, master=None):
self.main_state = False
self.door_1_state = False
self.door_2_state = False
self.door_count = 0
self.system_on_time = 0
self.system_on = time.time()
self.system_delta_time = 0
self.door_open_time = 0
self.door_time = 0
# Instantiate RevPiModIO
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
# Handle SIGINT / SIGTERM to exit program cleanly
self.rpi.handlesignalend(self.closeapp)
# Register event to toggle output O_1 with input I_1
self.rpi.io.main_switch.reg_event(self.event_main_switch_on,
edge=revpimodio2.RISING)
self.rpi.io.main_switch.reg_event(self.event_main_switch_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_3 with input I_3
self.rpi.io.switch_1.reg_event(self.event_switch_1_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_1.reg_event(self.event_switch_1_off,
edge=revpimodio2.FALLING)
# Register event to toggle output O_5 with input I_5
self.rpi.io.switch_2.reg_event(self.event_switch_2_on,
edge=revpimodio2.RISING)
self.rpi.io.switch_2.reg_event(self.event_switch_2_off,
edge=revpimodio2.FALLING)
self.rpi.core.a1green.value = False
self.rpi.io.main_relay.value = False
self.rpi.io.relay_1.value = False
self.rpi.io.relay_2.value = False
# Start RevPi event system without blocking here
self.rpi.mainloop(blocking=False)
# Handle tkinter part
super().__init__(master)
self.master.protocol("WM_DELETE_WINDOW", self.closeapp)
self.master.wm_title("Warehouse")
self.master.wm_resizable(width=False, height=False)
fontlabel = ('helvetica', 15, 'bold')
# top row names
self.lbl_main = Label(self.master,
text="System",
width=15,
font=fontlabel)
self.lbl_main.grid(row=0, column=0)
self.lbl_door_1 = Label(self.master,
text="Outside Door",
width=15,
font=fontlabel)
self.lbl_door_1.grid(row=0, column=1)
self.lbl_door_2 = Label(self.master,
text="Inside Door",
width=15,
font=fontlabel)
self.lbl_door_2.grid(row=0, column=2)
self.lbl_info = Label(self.master,
text="Data",
width=15,
font=fontlabel)
self.lbl_info.grid(row=0, column=3)
# top row with switches (buttons) in on state (red, grayed in off mode)
self.btn_main_on = Button(self.master, text="Turn System On", width=15)
# only screen control after physical switch (event_main_switch) is turned on,
# then comment line below out and comment event_button_main_on out too.
self.btn_main_on["command"] = self.event_button_main_on
self.btn_main_on.grid(row=1, column=0)
self.btn_door_1_open = Button(self.master,
text="Open Outside Door",
width=15)
self.btn_door_1_open["command"] = self.event_button_open_door_1
self.btn_door_1_open.grid(row=1, column=1)
self.btn_door_2_open = Button(self.master,
text="Open Inside Door",
width=15)
self.btn_door_2_open["command"] = self.event_button_open_door_2
self.btn_door_2_open.grid(row=1, column=2)
self.lbl_energy = Label(self.master,
text="loss: 0",
width=15,
height=4)
self.lbl_energy.grid(row=1, column=3)
# Status information in middle row
self.lbl_state_main = Label(self.master,
bg='light grey',
text="OFF",
width=15,
height=4)
self.lbl_state_main.grid(row=2, column=0)
self.lbl_state_door_1 = Label(self.master,
bg='light grey',
text="Closed",
width=15,
height=4)
self.lbl_state_door_1.grid(row=2, column=1)
self.lbl_state_door_2 = Label(self.master,
bg='light grey',
text="Closed",
width=15,
height=4)
self.lbl_state_door_2.grid(row=2, column=2)
self.lbl_count = Label(self.master, text="# door: 0", width=15)
self.lbl_count.grid(row=2, column=3)
# bottom row with switches (buttons) in off state (black button grayed in on)
self.btn_main_off = Button(self.master,
text="Turn System Off",
width=15)
self.btn_main_off.config(bg='#00C1FF', fg='white')
self.btn_main_off["command"] = self.event_button_main_off
self.btn_main_off.grid(row=3, column=0)
self.btn_door_1_close = Button(self.master,
text="Close Outside Door",
width=15)
self.btn_door_1_close.config(bg='#00C1FF', fg='white')
self.btn_door_1_close["command"] = self.event_button_close_door_1
self.btn_door_1_close.grid(row=3, column=1)
self.btn_door_2_close = Button(self.master,
text="Close Inside Door",
width=15)
self.btn_door_2_close.config(bg='#00C1FF', fg='white')
self.btn_door_2_close["command"] = self.event_button_close_door_2
self.btn_door_2_close.grid(row=3, column=2)
self.lbl_system_on = Label(self.master, text="time on: 0", width=15)
self.lbl_system_on.grid(row=3, column=3)
self.btn_stop = Button(self.master, text="Stop")
self.btn_stop["command"] = self.closeapp
self.btn_stop.grid(row=4, column=3)
def __init__(self):
# RevPiModIO Instantieren
self.revpi = revpimodio2.RevPiModIO(autorefresh=False)
def main():
global main_state, state_1, state_2
main_state = False
state_1 = False
state_2 = False
rpi = revpimodio2.RevPiModIO(autorefresh=True)
def event_main_on(ioname, iovalue):
global main_state
rpi.io.main_relay.value = True
main_state = True
def event_main_off(ioname, iovalue):
global main_state
rpi.io.main_relay.value = False
rpi.io.relay_1.value = False
rpi.io.relay_2.value = False
main_state = False
def event_switch_1_on(ioname, iovalue):
global main_state, state_1, state_2
if main_state and not state_2:
rpi.io.relay_1.value = True
state_1 = True
def event_switch_1_off(ioname, iovalue):
global main_state, state_1
if main_state:
rpi.io.relay_1.value = False
state_1 = False
def event_switch_2_on(ioname, iovalue):
global main_state, state_1, state_2
if main_state and not state_1:
rpi.io.relay_2.value = True
state_2 = True
def event_switch_2_off(ioname, iovalue):
global main_state, state_2
if main_state:
rpi.io.relay_2.value = False
state_2 = False
# Register event to main_switch, switch_1 and switch_2
rpi.io.main_switch.reg_event(event_main_on, edge=revpimodio2.RISING)
rpi.io.main_switch.reg_event(event_main_off, edge=revpimodio2.FALLING)
rpi.io.switch_1.reg_event(event_switch_1_on, edge=revpimodio2.RISING)
rpi.io.switch_1.reg_event(event_switch_1_off, edge=revpimodio2.FALLING)
rpi.io.switch_2.reg_event(event_switch_2_on, edge=revpimodio2.RISING)
rpi.io.switch_2.reg_event(event_switch_2_off, edge=revpimodio2.FALLING)
# initialize output to False = 0 = off = no-lights
rpi.io.main_relay.value = False
rpi.io.relay_1.value = False
rpi.io.relay_2.value = False
rpi.mainloop(blocking=False)
# We stay here, switch on the LED A1 every sec, till rpi.exitsignal.wait returns True after SIGINT/SIGTERM
while not rpi.exitsignal.wait(1):
rpi.core.a1green.value = not rpi.core.a1green.value
# exit/terminate program and reset output to False
rpi.io.main_relay.value = False
rpi.io.relay_1.value = False
rpi.io.relay_2.value = False
revpimodio2.RevPiModIO(autorefresh=False)
