Support operation on nodes w/o phase relay

PV control works but number of phases can't be changed.
Number of phases as reported by wallbox are used.

- new PhaseMode.DISABLED
  Prevents any attempts to switch phase relay.
  Phase control buttons are disabled in UI.
- new config: enable_phase_switching_on_host_only
  If set, node name passed as parameter to pvcontrol must match this
  config value to enable phase control.

Author: stephanme

pvcontrol/__main__.py

@@ -24,6 +24,7 @@
 parser.add_argument("-w", "--wallbox", default="SimulatedWallbox")
 parser.add_argument("-a", "--car", default="SimulatedCar")
 parser.add_argument("-c", "--config", default="{}")
+parser.add_argument("--hostname", default="", help="server hostname, can be used to enable/disable phase relay on k8s")
 parser.add_argument("--host", default="0.0.0.0", help="server host (default: 0.0.0.0)")
 parser.add_argument("--port", type=int, default=8080, help="server port (default: 8080)")
 parser.add_argument("--basehref", help="URL prefix to match ng base-href param (no leading /)")
@@ -42,6 +43,7 @@
 logger.info(f"Wallbox: {args.wallbox}")
 logger.info(f"Car:     {args.car}")
 logger.info(f"config:  {args.config}")
+logger.info(f"hostname:{args.hostname}")
 config = json.loads(args.config)
 for c in ["wallbox", "meter", "car", "controller"]:
     if c not in config:
@@ -50,7 +52,7 @@
 wallbox = WallboxFactory.newWallbox(args.wallbox, **config["wallbox"])
 meter = MeterFactory.newMeter(args.meter, wallbox, **config["meter"])
 car = CarFactory.newCar(args.car, **config["car"])
-controller = ChargeControllerFactory.newController(meter, wallbox, **config["controller"])
+controller = ChargeControllerFactory.newController(meter, wallbox, args.hostname, **config["controller"])
 
 controller_scheduler = Scheduler(controller.get_config().cycle_time, controller.run)
 controller_scheduler.start()

pvcontrol/chargecontroller.py

@@ -37,6 +37,7 @@ class ChargeMode(str, enum.Enum):
 
 @enum.unique
 class PhaseMode(str, enum.Enum):
+    DISABLED = "DISABLED"  # phase relay is not in operation
     AUTO = "AUTO"  # PV switches between 1 and 3 phases
     CHARGE_1P = "CHARGE_1P"
     CHARGE_3P = "CHARGE_3P"
@@ -53,6 +54,7 @@ class ChargeControllerData(BaseData):
 class ChargeControllerConfig(BaseConfig):
     cycle_time: int = 30  # [s] control loop cycle time, used by scheduler
     enable_phase_switching: bool = True  # set to False of phase relay is not in operation
+    enable_phase_switching_on_host_only = ""  # if set, phase switching is only allowed when running on specified host (env var: HOSTNAME)
     enable_auto_phase_switching: bool = True  # automatic phase switching depending on available PV
     enable_charging_when_connecting_car: ChargeMode = ChargeMode.OFF
     line_voltage: float = 230  # [V]
@@ -80,7 +82,8 @@ class ChargeController(BaseService[ChargeControllerConfig, ChargeControllerData]
         "pvcontrol_controller_charged_energy_wh_total", "Energy charged into car by source", ["source"]
     )
 
-    def __init__(self, config: ChargeControllerConfig, meter: Meter, wallbox: Wallbox):
+    # hostname - optional parameter to enable/disable phase switching depending on where pvcontrol runs (k8s hostname)
+    def __init__(self, config: ChargeControllerConfig, meter: Meter, wallbox: Wallbox, hostname=""):
         super().__init__(config)
         self._meter = meter
         self._wallbox = wallbox
@@ -93,6 +96,9 @@ def __init__(self, config: ChargeControllerConfig, meter: Meter, wallbox: Wallbo
         self._last_energy_consumption = 0.0  # total counter value, must be initialized first with data from meter
         self._last_energy_consumption_grid = 0.0  # total counter value, must be initialized first with data from meter
         # config
+        self._enable_phase_switching = self._is_enable_phase_switching(hostname)
+        if not self._enable_phase_switching:
+            self.set_phase_mode(PhaseMode.DISABLED)
         self._min_supported_current = wallbox.get_config().min_supported_current
         self._max_supported_current = wallbox.get_config().max_supported_current
         min_power_1phase = self._min_supported_current * config.line_voltage
@@ -110,11 +116,19 @@ def __init__(self, config: ChargeControllerConfig, meter: Meter, wallbox: Wallbo
         ChargeController._metrics_pvc_controller_charged_energy.labels("grid")
         ChargeController._metrics_pvc_controller_charged_energy.labels("pv")
 
+    def _is_enable_phase_switching(self, hostname: str) -> bool:
+        if self.get_config().enable_phase_switching:
+            require_hostname = self.get_config().enable_phase_switching_on_host_only
+            return not require_hostname or require_hostname == hostname
+        return False
+
     def set_desired_mode(self, mode: ChargeMode) -> None:
         logger.info(f"set_desired_mode: {self.get_data().desired_mode} -> {mode}")
         self.get_data().desired_mode = mode
 
     def set_phase_mode(self, mode: PhaseMode) -> None:
+        if not self._enable_phase_switching:
+            mode = PhaseMode.DISABLED
         self.get_data().phase_mode = mode
 
     @_metrics_pvc_controller_processing.time()
@@ -212,8 +226,7 @@ def _converge_phases(self, m: MeterData, wb: WallboxData) -> bool:
             self._wallbox.trigger_reset()
             return True
 
-        config = self.get_config()
-        if config.enable_phase_switching:
+        if self._enable_phase_switching:
             available_power = -m.power_grid + wb.power
             desired_phases = self._desired_phases(available_power, wb.phases_in)
             if wb.error == 0 and desired_phases != wb.phases_in:
@@ -224,11 +237,7 @@ def _converge_phases(self, m: MeterData, wb: WallboxData) -> bool:
                     # charging off and wait one cylce
                     self._set_allow_charging(False, skip_delay=True)
                 return True
-            else:
-                return False
-        else:
-            self.set_phase_mode(PhaseMode.CHARGE_1P if wb.phases_in == 1 else PhaseMode.CHARGE_3P)
-            return False
+        return False
 
     def _desired_phases(self, available_power: float, current_phases: int):
         # TODO 2 phase charging
@@ -341,5 +350,5 @@ def _set_allow_charging(self, v: bool, skip_delay: bool = False):
 
 class ChargeControllerFactory:
     @classmethod
-    def newController(cls, meter: Meter, wb: Wallbox, **kwargs) -> ChargeController:
-        return ChargeController(ChargeControllerConfig(**kwargs), meter, wb)
+    def newController(cls, meter: Meter, wb: Wallbox, hostname="", **kwargs) -> ChargeController:
+        return ChargeController(ChargeControllerConfig(**kwargs), meter, wb, hostname)

tests/test_chargecontroller.py

@@ -274,25 +274,25 @@ def test_3P(self):
 
         c = self.controller.get_data()
         self.assertEqual(ChargeMode.OFF, c.mode)
-        self.assertEqual(PhaseMode.CHARGE_3P, c.phase_mode)
+        self.assertEqual(PhaseMode.DISABLED, c.phase_mode)
         self.assertEqual(3, self.wallbox.get_data().phases_in)
 
         self.controller.set_phase_mode(PhaseMode.CHARGE_1P)
         self.controller.run()
-        self.assertEqual(PhaseMode.CHARGE_3P, c.phase_mode)
+        self.assertEqual(PhaseMode.DISABLED, c.phase_mode)
         self.assertEqual(3, self.wallbox.get_data().phases_in)
 
     def test_1P(self):
         self.controller.run()  # init
         c = self.controller.get_data()
 
         self.assertEqual(ChargeMode.OFF, c.mode)
-        self.assertEqual(PhaseMode.CHARGE_1P, c.phase_mode)
+        self.assertEqual(PhaseMode.DISABLED, c.phase_mode)
         self.assertEqual(1, self.wallbox.get_data().phases_in)
 
         self.controller.set_phase_mode(PhaseMode.AUTO)
         self.controller.run()
-        self.assertEqual(PhaseMode.CHARGE_1P, c.phase_mode)
+        self.assertEqual(PhaseMode.DISABLED, c.phase_mode)
         self.assertEqual(1, self.wallbox.get_data().phases_in)
 
 

ui/src/app/app.component.scss

@@ -26,12 +26,12 @@ mat-card-content {
 // = mat-primary + mat-body-strong
 .active {
   font-weight: 500;
-  color: mat.get-color-from-palette(themes.$light-primary, 'default');
+  color: mat.get-color-from-palette(themes.$light-primary, 'default') !important;
 }
 :host-context(.dark-theme) {
   .active {
     font-weight: 500;
-    color: mat.get-color-from-palette(themes.$dark-primary, 'default');
+    color: mat.get-color-from-palette(themes.$dark-primary, 'default') !important;
   }
 }
 

ui/src/app/app.component.spec.ts

@@ -161,6 +161,7 @@ describe('AppComponent', () => {
 
     expect(component.pvControl).toEqual(pvControlData);
     expect(component.chargeModeControl.value).toBe(ChargeMode.PV_ONLY);
+    expect(component.phaseModeControl.enabled).toBeTrue();
     expect(component.phaseModeControl.value).toBe(PhaseMode.CHARGE_1P);
     expect(await chargeModePvOnly.isChecked()).toBeTrue();
     expect(await phaseModeCharge1P.isChecked()).toBeTrue();
@@ -248,6 +249,16 @@ describe('AppComponent', () => {
     expect(await phaseModeCharge1P.isChecked()).toBeTrue();
     expect(await phaseModeAuto.isChecked()).toBeFalse();
   });
+
+  it('should support disabled phase relay', async () => {
+    pvControlData.controller.phase_mode = PhaseMode.DISABLED;
+    httpMock.expectOne('./api/pvcontrol').flush(pvControlData);
+    fixture.detectChanges();
+
+    expect(component.phaseModeControl.disabled).toBeTrue();
+    expect(await phaseModeAuto.isChecked()).toBeFalse();
+    expect(await phaseModeAuto.isDisabled()).toBeTrue();
+  });
 });
 
 describe('AppComponent', () => {

ui/src/app/app.component.ts

@@ -58,7 +58,7 @@ export class AppComponent implements OnInit, OnDestroy {
       error: 0,
       allow_charging: false,
       max_current: 0,
-      phases_in: 3,
+      phases_in: 1,
       phases_out: 0,
       power: 0,
       temperature: 0,
@@ -67,7 +67,7 @@ export class AppComponent implements OnInit, OnDestroy {
       error: 0,
       mode: ChargeMode.OFF,
       desired_mode: ChargeMode.OFF,
-      phase_mode: PhaseMode.AUTO,
+      phase_mode: PhaseMode.DISABLED,
     },
     car: {
       error: 0,
@@ -89,7 +89,7 @@ export class AppComponent implements OnInit, OnDestroy {
   chargingStateIcon = 'power_off';
 
   chargeModeControl = this.fb.control(ChargeMode.OFF);
-  phaseModeControl = this.fb.control(PhaseMode.AUTO);
+  phaseModeControl = this.fb.control({value: PhaseMode.DISABLED, disabled: true});
 
   constructor(
     private appRef: ApplicationRef, private fb: FormBuilder, private snackBar: MatSnackBar,
@@ -176,6 +176,11 @@ export class AppComponent implements OnInit, OnDestroy {
         }
         this.chargeModeControl.setValue(mode);
         this.phaseModeControl.setValue(pv.controller.phase_mode);
+        if (pv.controller.phase_mode === PhaseMode.DISABLED) {
+          this.phaseModeControl.disable()
+        } else {
+          this.phaseModeControl.enable()
+        }
       },
       error: () => { }
     });

ui/src/app/pv-control.service.ts

@@ -31,6 +31,7 @@ export enum ChargeMode {
 }
 
 export enum PhaseMode {
+  DISABLED = 'DISABLED',
   AUTO = 'AUTO',
   CHARGE_1P = 'CHARGE_1P',
   CHARGE_3P = 'CHARGE_3P',