diff --git a/.DS_Store b/.DS_Store index 2b1913b..43760d9 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/FileSets/.DS_Store b/FileSets/.DS_Store index f82ff61..e1f69b4 100644 Binary files a/FileSets/.DS_Store and b/FileSets/.DS_Store differ diff --git a/FileSets/fileList b/FileSets/fileList new file mode 100644 index 0000000..dffadd7 --- /dev/null +++ b/FileSets/fileList @@ -0,0 +1 @@ +/opt/victronenergy/dbus-systemcalc-py/delegates/relaystate.py diff --git a/FileSets/gpio_list b/FileSets/gpio_list index 757ef1f..70aa4c5 100644 --- a/FileSets/gpio_list +++ b/FileSets/gpio_list @@ -1,4 +1,4 @@ -#### modified for use by the RpiGpio package +#### modified for use by the RpiGpio package on Raspberry PI platforms ONLY # This is a list of gpio pins, set by the script /etc/rcS.d/S90gpio_pins.sh # They are documented at: https://github.com/victronenergy/venus/wiki/bbb-gpio @@ -12,21 +12,14 @@ # Relay 2 Pin 11 / GPIO 17 17 out relay_2 -#### Relay 3 - 6 do NOT work on PI 4 and makes systemcalc crash! -#### This package includes mods to relaystate.py -#### However, PageSettingsRelay.qml needs to be updated for the additional relays -#### in order to control them manually from the GUI -#### many other modifications are needed to hook up other functions to anything but Relay 1 -#### These modifications are NOT included in this package - # Relay 3 Pin 13 / GPIO 27 -#27 out relay_3 +27 out relay_3 # Relay 4 Pin 15 / GPIO 22 -#22 out relay_4 +22 out relay_4 # Relay 5 Pin 16 / GPIO 23 -#23 out relay_5 +23 out relay_5 # Relay 6 Pin 18 / GPIO 24 -#24 out relay_6 +24 out relay_6 # these have pull UPs # Digital input 1 Pin 29 / GPIO 05 diff --git a/FileSets/v2.40/.DS_Store b/FileSets/v2.40/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/FileSets/v2.40/.DS_Store differ diff --git a/FileSets/v2.40/relaystate.py b/FileSets/v2.40/relaystate.py new file mode 100644 index 0000000..019f260 --- /dev/null +++ b/FileSets/v2.40/relaystate.py @@ -0,0 +1,107 @@ +import gobject +import logging +import os +import traceback +from glob import glob + +# Victron packages +from ve_utils import exit_on_error + +from delegates.base import SystemCalcDelegate + +class RelayState(SystemCalcDelegate): + RELAY_GLOB = '/dev/gpio/relay_*' + + def __init__(self): + SystemCalcDelegate.__init__(self) + self._relays = {} + + def get_input(self): + return [ + ('com.victronenergy.settings', [ + '/Settings/Relay/Function'])] # Managed by the gui + + def get_settings(self): + return [ + ('/Relay/0/State', '/Settings/Relay/0/InitialState', 0, 0, 1), + ('/Relay/1/State', '/Settings/Relay/1/InitialState', 0, 0, 1), + ('/Relay/2/State', '/Settings/Relay/2/InitialState', 0, 0, 1), + ('/Relay/3/State', '/Settings/Relay/3/InitialState', 0, 0, 1), + ('/Relay/4/State', '/Settings/Relay/4/InitialState', 0, 0, 1), + ('/Relay/5/State', '/Settings/Relay/5/InitialState', 0, 0, 1), + ('/Relay/6/State', '/Settings/Relay/6/InitialState', 0, 0, 1) + ] + + @property + def relay_function(self): + return self._dbusmonitor.get_value('com.victronenergy.settings', + '/Settings/Relay/Function') + + def set_sources(self, dbusmonitor, settings, dbusservice): + SystemCalcDelegate.set_sources(self, dbusmonitor, settings, dbusservice) + relays = sorted(glob(self.RELAY_GLOB)) + + if len(relays) == 0: + logging.info('No relays found') + return + + self._relays.update({'/Relay/{}/State'.format(i): os.path.join(r, 'value') \ + for i, r in enumerate(relays) }) + + gobject.idle_add(exit_on_error, self._init_relay_state) + for dbus_path in self._relays.iterkeys(): + self._dbusservice.add_path(dbus_path, value=None, writeable=True, + onchangecallback=self._on_relay_state_changed) + + logging.info('Relays found: {}'.format(', '.join(self._relays.values()))) + + def _init_relay_state(self): + if self.relay_function is None: + return True # Try again on the next idle event + + for dbus_path, path in self._relays.iteritems(): + if self.relay_function != 2 and dbus_path == '/Relay/0/State': + continue # Skip primary relay if function is not manual + state = self._settings[dbus_path] + self._dbusservice[dbus_path] = state + self.__on_relay_state_changed(dbus_path, state) + + # Sync state back to dbus + self._update_relay_state() + + # Watch changes and update dbus. Do we still need this? + gobject.timeout_add(5000, exit_on_error, self._update_relay_state) + return False + + def _update_relay_state(self): + # @todo EV Do we still need this? Maybe only at startup? + for dbus_path, file_path in self._relays.items(): + try: + with open(file_path, 'rt') as r: + state = int(r.read().strip()) + self._dbusservice[dbus_path] = state + except (IOError, ValueError): + traceback.print_exc() + return True + + def __on_relay_state_changed(self, dbus_path, state): + try: + path = self._relays[dbus_path] + with open(path, 'wt') as w: + w.write(str(state)) + except IOError: + traceback.print_exc() + return False + return True + + def _on_relay_state_changed(self, dbus_path, value): + try: + state = int(bool(value)) + except ValueError: + traceback.print_exc() + return False + try: + return self.__on_relay_state_changed(dbus_path, state) + finally: + # Remember the state to restore after a restart + self._settings[dbus_path] = state diff --git a/FileSets/v2.40/relaystate.py.orig b/FileSets/v2.40/relaystate.py.orig new file mode 100644 index 0000000..9d5eaaf --- /dev/null +++ b/FileSets/v2.40/relaystate.py.orig @@ -0,0 +1,102 @@ +import gobject +import logging +import os +import traceback +from glob import glob + +# Victron packages +from ve_utils import exit_on_error + +from delegates.base import SystemCalcDelegate + +class RelayState(SystemCalcDelegate): + RELAY_GLOB = '/dev/gpio/relay_*' + + def __init__(self): + SystemCalcDelegate.__init__(self) + self._relays = {} + + def get_input(self): + return [ + ('com.victronenergy.settings', [ + '/Settings/Relay/Function'])] # Managed by the gui + + def get_settings(self): + return [ + ('/Relay/0/State', '/Settings/Relay/0/InitialState', 0, 0, 1), + ('/Relay/1/State', '/Settings/Relay/1/InitialState', 0, 0, 1) + ] + + @property + def relay_function(self): + return self._dbusmonitor.get_value('com.victronenergy.settings', + '/Settings/Relay/Function') + + def set_sources(self, dbusmonitor, settings, dbusservice): + SystemCalcDelegate.set_sources(self, dbusmonitor, settings, dbusservice) + relays = sorted(glob(self.RELAY_GLOB)) + + if len(relays) == 0: + logging.info('No relays found') + return + + self._relays.update({'/Relay/{}/State'.format(i): os.path.join(r, 'value') \ + for i, r in enumerate(relays) }) + + gobject.idle_add(exit_on_error, self._init_relay_state) + for dbus_path in self._relays.iterkeys(): + self._dbusservice.add_path(dbus_path, value=None, writeable=True, + onchangecallback=self._on_relay_state_changed) + + logging.info('Relays found: {}'.format(', '.join(self._relays.values()))) + + def _init_relay_state(self): + if self.relay_function is None: + return True # Try again on the next idle event + + for dbus_path, path in self._relays.iteritems(): + if self.relay_function != 2 and dbus_path == '/Relay/0/State': + continue # Skip primary relay if function is not manual + state = self._settings[dbus_path] + self._dbusservice[dbus_path] = state + self.__on_relay_state_changed(dbus_path, state) + + # Sync state back to dbus + self._update_relay_state() + + # Watch changes and update dbus. Do we still need this? + gobject.timeout_add(5000, exit_on_error, self._update_relay_state) + return False + + def _update_relay_state(self): + # @todo EV Do we still need this? Maybe only at startup? + for dbus_path, file_path in self._relays.items(): + try: + with open(file_path, 'rt') as r: + state = int(r.read().strip()) + self._dbusservice[dbus_path] = state + except (IOError, ValueError): + traceback.print_exc() + return True + + def __on_relay_state_changed(self, dbus_path, state): + try: + path = self._relays[dbus_path] + with open(path, 'wt') as w: + w.write(str(state)) + except IOError: + traceback.print_exc() + return False + return True + + def _on_relay_state_changed(self, dbus_path, value): + try: + state = int(bool(value)) + except ValueError: + traceback.print_exc() + return False + try: + return self.__on_relay_state_changed(dbus_path, state) + finally: + # Remember the state to restore after a restart + self._settings[dbus_path] = state diff --git a/FileSets/v2.65/.DS_Store b/FileSets/v2.65/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/FileSets/v2.65/.DS_Store differ diff --git a/FileSets/relaystate.py Modified for relay 3-6.py b/FileSets/v2.65/relaystate.py similarity index 69% rename from FileSets/relaystate.py Modified for relay 3-6.py rename to FileSets/v2.65/relaystate.py index 70d17bd..c77abf9 100644 --- a/FileSets/relaystate.py Modified for relay 3-6.py +++ b/FileSets/v2.65/relaystate.py @@ -1,6 +1,3 @@ -#### This file has been automatically modified add relays 3-6 -#### Search for MODIFIED to find changes - import gobject import logging import os @@ -14,10 +11,6 @@ class RelayState(SystemCalcDelegate): RELAY_GLOB = '/dev/gpio/relay_*' - FUNCTION_ALARM = 0 - FUNCTION_MANUAL = 2 - FUNCTION_BMS_STOPCHARGE = 4 - FUNCTION_BMS_STOPDISCHARGE = 5 def __init__(self): SystemCalcDelegate.__init__(self) @@ -26,14 +19,12 @@ def __init__(self): def get_input(self): return [ ('com.victronenergy.settings', [ - '/Settings/Relay/Function', - '/Settings/Relay/1/Function'])] # Managed by the gui + '/Settings/Relay/Function'])] # Managed by the gui -#### MODIFIED - added relay 2 - 6 def get_settings(self): return [ - ('/Relay/0/State', '/Settings/Relay/0/InitialState', 0, 0, 1), - ('/Relay/1/State', '/Settings/Relay/1/InitialState', 0, 0, 1), + ('/Relay/0/State', '/Settings/Relay/0/InitialState', 0, 0, 1), + ('/Relay/1/State', '/Settings/Relay/1/InitialState', 0, 0, 1), ('/Relay/2/State', '/Settings/Relay/2/InitialState', 0, 0, 1), ('/Relay/3/State', '/Settings/Relay/3/InitialState', 0, 0, 1), ('/Relay/4/State', '/Settings/Relay/4/InitialState', 0, 0, 1), @@ -46,11 +37,6 @@ def relay_function(self): return self._dbusmonitor.get_value('com.victronenergy.settings', '/Settings/Relay/Function') - @property - def relay1_function(self): - return self._dbusmonitor.get_value('com.victronenergy.settings', - '/Settings/Relay/1/Function') - def set_sources(self, dbusmonitor, settings, dbusservice): SystemCalcDelegate.set_sources(self, dbusmonitor, settings, dbusservice) relays = sorted(glob(self.RELAY_GLOB)) @@ -69,33 +55,20 @@ def set_sources(self, dbusmonitor, settings, dbusservice): logging.info('Relays found: {}'.format(', '.join(self._relays.values()))) - def set_relay(self, dbus_path, state): - self._dbusservice[dbus_path] = state - self.__on_relay_state_changed(dbus_path, state) - - def set_function(self, func, state): - """ Find a relay bound to the relevant function, and set state. """ - for p, r in ((self.relay_function, '/Relay/0/State'), - (self.relay1_function, '/Relay/1/State')): - if p == func and self._dbusservice[r] != state: - self.set_relay(r, state) - def _init_relay_state(self): if self.relay_function is None: return True # Try again on the next idle event for dbus_path, path in self._relays.iteritems(): - if dbus_path == '/Relay/0/State' and self.relay_function != self.FUNCTION_MANUAL: + if self.relay_function != 2 and dbus_path == '/Relay/0/State': continue # Skip primary relay if function is not manual - if dbus_path == '/Relay/1/State' and self.relay1_function != self.FUNCTION_MANUAL: - continue # Skip secondary relay if function is not manual - try: state = self._settings[dbus_path] except KeyError: pass else: - self.set_relay(dbus_path, state) + self._dbusservice[dbus_path] = state + self.__on_relay_state_changed(dbus_path, state) # Sync state back to dbus self._update_relay_state() diff --git a/FileSets/v2.65/relaystate.py.orig b/FileSets/v2.65/relaystate.py.orig new file mode 100644 index 0000000..6815da8 --- /dev/null +++ b/FileSets/v2.65/relaystate.py.orig @@ -0,0 +1,106 @@ +import gobject +import logging +import os +import traceback +from glob import glob + +# Victron packages +from ve_utils import exit_on_error + +from delegates.base import SystemCalcDelegate + +class RelayState(SystemCalcDelegate): + RELAY_GLOB = '/dev/gpio/relay_*' + + def __init__(self): + SystemCalcDelegate.__init__(self) + self._relays = {} + + def get_input(self): + return [ + ('com.victronenergy.settings', [ + '/Settings/Relay/Function'])] # Managed by the gui + + def get_settings(self): + return [ + ('/Relay/0/State', '/Settings/Relay/0/InitialState', 0, 0, 1), + ('/Relay/1/State', '/Settings/Relay/1/InitialState', 0, 0, 1) + ] + + @property + def relay_function(self): + return self._dbusmonitor.get_value('com.victronenergy.settings', + '/Settings/Relay/Function') + + def set_sources(self, dbusmonitor, settings, dbusservice): + SystemCalcDelegate.set_sources(self, dbusmonitor, settings, dbusservice) + relays = sorted(glob(self.RELAY_GLOB)) + + if len(relays) == 0: + logging.info('No relays found') + return + + self._relays.update({'/Relay/{}/State'.format(i): os.path.join(r, 'value') \ + for i, r in enumerate(relays) }) + + gobject.idle_add(exit_on_error, self._init_relay_state) + for dbus_path in self._relays.iterkeys(): + self._dbusservice.add_path(dbus_path, value=None, writeable=True, + onchangecallback=self._on_relay_state_changed) + + logging.info('Relays found: {}'.format(', '.join(self._relays.values()))) + + def _init_relay_state(self): + if self.relay_function is None: + return True # Try again on the next idle event + + for dbus_path, path in self._relays.iteritems(): + if self.relay_function != 2 and dbus_path == '/Relay/0/State': + continue # Skip primary relay if function is not manual + try: + state = self._settings[dbus_path] + except KeyError: + pass + else: + self._dbusservice[dbus_path] = state + self.__on_relay_state_changed(dbus_path, state) + + # Sync state back to dbus + self._update_relay_state() + + # Watch changes and update dbus. Do we still need this? + gobject.timeout_add(5000, exit_on_error, self._update_relay_state) + return False + + def _update_relay_state(self): + # @todo EV Do we still need this? Maybe only at startup? + for dbus_path, file_path in self._relays.items(): + try: + with open(file_path, 'rt') as r: + state = int(r.read().strip()) + self._dbusservice[dbus_path] = state + except (IOError, ValueError): + traceback.print_exc() + return True + + def __on_relay_state_changed(self, dbus_path, state): + try: + path = self._relays[dbus_path] + with open(path, 'wt') as w: + w.write(str(state)) + except IOError: + traceback.print_exc() + return False + return True + + def _on_relay_state_changed(self, dbus_path, value): + try: + state = int(bool(value)) + except ValueError: + traceback.print_exc() + return False + try: + return self.__on_relay_state_changed(dbus_path, state) + finally: + # Remember the state to restore after a restart + self._settings[dbus_path] = state diff --git a/FileSets/v2.80~11/.DS_Store b/FileSets/v2.80~11/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/FileSets/v2.80~11/.DS_Store differ diff --git a/FileSets/v2.80~11/relaystate.py b/FileSets/v2.80~11/relaystate.py new file mode 100644 index 0000000..3e5501a --- /dev/null +++ b/FileSets/v2.80~11/relaystate.py @@ -0,0 +1,111 @@ +from gi.repository import GLib +import logging +import os +import traceback +from glob import glob + +# Victron packages +from ve_utils import exit_on_error + +from delegates.base import SystemCalcDelegate + +class RelayState(SystemCalcDelegate): + RELAY_GLOB = '/dev/gpio/relay_*' + + def __init__(self): + SystemCalcDelegate.__init__(self) + self._relays = {} + + def get_input(self): + return [ + ('com.victronenergy.settings', [ + '/Settings/Relay/Function'])] # Managed by the gui + + def get_settings(self): + return [ + ('/Relay/0/State', '/Settings/Relay/0/InitialState', 0, 0, 1), + ('/Relay/1/State', '/Settings/Relay/1/InitialState', 0, 0, 1), + ('/Relay/2/State', '/Settings/Relay/2/InitialState', 0, 0, 1), + ('/Relay/3/State', '/Settings/Relay/3/InitialState', 0, 0, 1), + ('/Relay/4/State', '/Settings/Relay/4/InitialState', 0, 0, 1), + ('/Relay/5/State', '/Settings/Relay/5/InitialState', 0, 0, 1), + ('/Relay/6/State', '/Settings/Relay/6/InitialState', 0, 0, 1) + ] + + @property + def relay_function(self): + return self._dbusmonitor.get_value('com.victronenergy.settings', + '/Settings/Relay/Function') + + def set_sources(self, dbusmonitor, settings, dbusservice): + SystemCalcDelegate.set_sources(self, dbusmonitor, settings, dbusservice) + relays = sorted(glob(self.RELAY_GLOB)) + + if len(relays) == 0: + logging.info('No relays found') + return + + self._relays.update({'/Relay/{}/State'.format(i): os.path.join(r, 'value') \ + for i, r in enumerate(relays) }) + + GLib.idle_add(exit_on_error, self._init_relay_state) + for dbus_path in self._relays.keys(): + self._dbusservice.add_path(dbus_path, value=None, writeable=True, + onchangecallback=self._on_relay_state_changed) + + logging.info('Relays found: {}'.format(', '.join(self._relays.values()))) + + def _init_relay_state(self): + if self.relay_function is None: + return True # Try again on the next idle event + + for dbus_path, path in self._relays.items(): + if self.relay_function != 2 and dbus_path == '/Relay/0/State': + continue # Skip primary relay if function is not manual + try: + state = self._settings[dbus_path] + except KeyError: + pass + else: + self._dbusservice[dbus_path] = state + self.__on_relay_state_changed(dbus_path, state) + + # Sync state back to dbus + self._update_relay_state() + + # Watch changes and update dbus. Do we still need this? + GLib.timeout_add(5000, exit_on_error, self._update_relay_state) + return False + + def _update_relay_state(self): + # @todo EV Do we still need this? Maybe only at startup? + for dbus_path, file_path in self._relays.items(): + try: + with open(file_path, 'rt') as r: + state = int(r.read().strip()) + self._dbusservice[dbus_path] = state + except (IOError, ValueError): + traceback.print_exc() + return True + + def __on_relay_state_changed(self, dbus_path, state): + try: + path = self._relays[dbus_path] + with open(path, 'wt') as w: + w.write(str(state)) + except IOError: + traceback.print_exc() + return False + return True + + def _on_relay_state_changed(self, dbus_path, value): + try: + state = int(bool(value)) + except ValueError: + traceback.print_exc() + return False + try: + return self.__on_relay_state_changed(dbus_path, state) + finally: + # Remember the state to restore after a restart + self._settings[dbus_path] = state diff --git a/FileSets/v2.80~11/relaystate.py.orig b/FileSets/v2.80~11/relaystate.py.orig new file mode 100644 index 0000000..16e25e4 --- /dev/null +++ b/FileSets/v2.80~11/relaystate.py.orig @@ -0,0 +1,106 @@ +from gi.repository import GLib +import logging +import os +import traceback +from glob import glob + +# Victron packages +from ve_utils import exit_on_error + +from delegates.base import SystemCalcDelegate + +class RelayState(SystemCalcDelegate): + RELAY_GLOB = '/dev/gpio/relay_*' + + def __init__(self): + SystemCalcDelegate.__init__(self) + self._relays = {} + + def get_input(self): + return [ + ('com.victronenergy.settings', [ + '/Settings/Relay/Function'])] # Managed by the gui + + def get_settings(self): + return [ + ('/Relay/0/State', '/Settings/Relay/0/InitialState', 0, 0, 1), + ('/Relay/1/State', '/Settings/Relay/1/InitialState', 0, 0, 1) + ] + + @property + def relay_function(self): + return self._dbusmonitor.get_value('com.victronenergy.settings', + '/Settings/Relay/Function') + + def set_sources(self, dbusmonitor, settings, dbusservice): + SystemCalcDelegate.set_sources(self, dbusmonitor, settings, dbusservice) + relays = sorted(glob(self.RELAY_GLOB)) + + if len(relays) == 0: + logging.info('No relays found') + return + + self._relays.update({'/Relay/{}/State'.format(i): os.path.join(r, 'value') \ + for i, r in enumerate(relays) }) + + GLib.idle_add(exit_on_error, self._init_relay_state) + for dbus_path in self._relays.keys(): + self._dbusservice.add_path(dbus_path, value=None, writeable=True, + onchangecallback=self._on_relay_state_changed) + + logging.info('Relays found: {}'.format(', '.join(self._relays.values()))) + + def _init_relay_state(self): + if self.relay_function is None: + return True # Try again on the next idle event + + for dbus_path, path in self._relays.items(): + if self.relay_function != 2 and dbus_path == '/Relay/0/State': + continue # Skip primary relay if function is not manual + try: + state = self._settings[dbus_path] + except KeyError: + pass + else: + self._dbusservice[dbus_path] = state + self.__on_relay_state_changed(dbus_path, state) + + # Sync state back to dbus + self._update_relay_state() + + # Watch changes and update dbus. Do we still need this? + GLib.timeout_add(5000, exit_on_error, self._update_relay_state) + return False + + def _update_relay_state(self): + # @todo EV Do we still need this? Maybe only at startup? + for dbus_path, file_path in self._relays.items(): + try: + with open(file_path, 'rt') as r: + state = int(r.read().strip()) + self._dbusservice[dbus_path] = state + except (IOError, ValueError): + traceback.print_exc() + return True + + def __on_relay_state_changed(self, dbus_path, state): + try: + path = self._relays[dbus_path] + with open(path, 'wt') as w: + w.write(str(state)) + except IOError: + traceback.print_exc() + return False + return True + + def _on_relay_state_changed(self, dbus_path, value): + try: + state = int(bool(value)) + except ValueError: + traceback.print_exc() + return False + try: + return self.__on_relay_state_changed(dbus_path, state) + finally: + # Remember the state to restore after a restart + self._settings[dbus_path] = state diff --git a/ReadMe b/ReadMe index 595c515..7fa8810 100644 --- a/ReadMe +++ b/ReadMe @@ -11,18 +11,12 @@ The Raspberry PI default is for the first 8 GPIO pins to have pull UPs and the remaining have pull DOWNs. This makes some digital input pins behave differently This script installs a DT overlay that switches to pull UPs for all digital input pins +This package adds 4 more relays. + Only the first relay can be assigned to a function: alarm, genertor start/stop or pump. Others are only provided manual on/off control from the menu. -Adding additional relays to gpio_list causes systemcalc to crash -/opt/victronenergy/dbus-systemcalc-py/delegates/relaystate.py can be modified to prevent the crash -however the GUI needs to be modified to bring these relays to the user for on/off manual control - -The ability to assign functions to other than the first relay requires significant rework to all -code that access relays - a significant effort -Changes to add more relay functionality is NOT part of this package! -but some code is in place but commented out -look in relaystate.py, gpio_list and later in this script +The remaining 5 relays are manual on/off only. This script should be run manually initally. It will then called from reinstallMods to reinstall functionality after a Venus update @@ -46,16 +40,16 @@ https://github.com/kwindrem/RpiGpioSetup/archive/current.tar.gz rename the resulting .tar.gz file to venus-data.tar.gz copy the venus-data.tar.gz to a USB stick, put the stick in the Venus device and reboot. -When Venus boots, it will unarchive the file to /data/RpiGpioSetup-current +When Venus boots, it will unarchive the file to /data/RpiGoipSetup-current Move the directory into it's active locaiton: -rm -rf /data/RpiGpioSetup -mv /data/RpiGpioSetup-current /data/RpiGpioSetup +rm -rf /data/RpiGoipSetup +mv /data/RpiGoipSetup-current /data/RpiGoipSetup Repeat the above for SetupHelper if you haven't done so for another package. Finally, run the setup script to complete the installation -/data/RpiGpioSetup/setup +/data/RpiGoipSetup/setup You will need root access to the Venus device. Instructions can be found here: https://www.victronenergy.com/live/ccgx:root_access diff --git a/setup b/setup index 4803932..db9514e 100755 --- a/setup +++ b/setup @@ -1,6 +1,6 @@ #!/bin/bash -# adds additional digital inputs and relay outputs +# adds additional digital inputs and relay outputs to the Raspberry Pi platforms # the stock RPI Venus distribution includes two relays and two digital inputs # adding the additional GPIO pins to /etc/venus/gpio_list @@ -13,14 +13,8 @@ # # Only the first relay can be assigned to a function: alarm, genertor start/stop or pump. # Others are only provided manual on/off control from the menu. -# Two relays are supported. Adding additional relays to gpio_list causes systemcalc to crash -# /opt/victronenergy/dbus-systemcalc-py/delegates/relaystate.py can be modified to prevent the crash -# however the GUI needs to be modified to bring these relays to the user for on/off manual control -# The ability to assign functions to other than the first relay requires significant rework to all -# code that access relays -# Changes to support more than two relays and more than one assignalble relay is NOT part of this update -# but code is in place but commented out -# look in relaystate.py, gpio_list and later in this script +# Six relays are supported. Only the first relay can be assigned to functions +# The remaining relays are manual on/off only. # run manually initally, then called from reinstallMods # to uninstall/deactivate, call this script with "uninstall" as first parameter @@ -77,10 +71,14 @@ fi #### installing if [ $scriptAction == 'INSTALL' ] ; then + updateActiveFile "$gpioListFile" + + # modify relaystate.py for additional relays to prevent system calc crash + updateActiveFile "$relayStateFile" # install DT overlay to for pull-ups on all digital inputs - updateActiveFile $pkgFileSets/VenusGpioOverlay.dtb "$overlayFile" + updateActiveFile $pkgFileSets/VenusGpioOverlay.dtb "$overlayFile" if [ $(grep -c "VenusGpioOverlay" "$configFile") == 0 ]; then logMessage "activating GPIO DT overlay" @@ -89,12 +87,6 @@ if [ $scriptAction == 'INSTALL' ] ; then echo "#### end change all digital inputs to pull ups" >> "$configFile" filesUpdated=true fi - - # modify relaystate.py for additional relays to prevent system calc crash - #### this modification is commented out because additional work is needed - #### to make these relays useful - #updateActiveFile "$relayStateFile" - #fi fi # uninstalling - check scriptAction again @@ -102,8 +94,7 @@ fi if [ $scriptAction == 'UNINSTALL' ] ; then restoreActiveFile "$gpioListFile" restoreActiveFile "$overlayFile" -# restoreActiveFile "$relayStateFile" -# fi + restoreActiveFile "$relayStateFile" # remove mods from configFile - do not use restore in case other mods were made manually if [ -f "$configFile" ]; then diff --git a/timeStamp b/timeStamp index a83a327..2ff8399 100644 --- a/timeStamp +++ b/timeStamp @@ -1 +1 @@ -1628210974 +1632614290 diff --git a/version b/version index 28c2139..d9fb9c7 100644 --- a/version +++ b/version @@ -1 +1 @@ -v2.1 +v3.0