Fix examples

Author: ducky64

edg/abstract_parts/AbstractPowerConverters.py

@@ -394,7 +394,7 @@ def generate(self) -> None:
     self.assign(self.actual_inductor_current_ripple, values.ripple_scale / self.inductor.actual_inductance)
 
     self.connect(self.switch, self.inductor.a.adapt_to(VoltageSink(
-      current_draw=self.pwr_out.link().current_drawn * values.effective_dutycycle
+      current_draw=values.inductor_avg_current
     )))
     self.connect(self.pwr_out, self.inductor.b.adapt_to(VoltageSource(
       voltage_out=self.output_voltage,
@@ -586,13 +586,13 @@ def generate(self) -> None:
     self.assign(self.actual_inductor_current_ripple, values.ripple_scale / self.inductor.actual_inductance)
 
     self.connect(self.pwr_in, self.inductor.a.adapt_to(VoltageSink(
-      current_draw=self.pwr_out.link().current_drawn / (1 - values.dutycycle)
+      current_draw=values.inductor_avg_current
     )))
     self.connect(self.switch, self.inductor.b.adapt_to(VoltageSource(
       voltage_out=self.output_voltage,
       current_limits=BuckConverterPowerPath._ilim_expr(self.inductor.actual_current_rating, self.sw_current_limits,
                                                        self.actual_inductor_current_ripple)
-                     / (1 - values.effective_dutycycle)
+                     * (1 - values.effective_dutycycle.upper)
     )))
 
     self.in_cap = self.Block(DecouplingCapacitor(
@@ -714,13 +714,18 @@ def generate(self) -> None:
         BuckConverterPowerPath._buck_inductor_filter,
         combined_inductor_avg_current.upper, combined_ripple_scale, combined_min_ripple)
     ))
-    self.connect(self.switch_in, self.inductor.a)
-    self.connect(self.switch_out, self.inductor.b)
+    self.connect(self.switch_in, self.inductor.a.adapt_to(VoltageSink(
+      current_draw=combined_inductor_avg_current
+    )))
+    self.connect(self.switch_out, self.inductor.b.adapt_to(VoltageSource(
+      voltage_out=self.output_voltage,
+      current_limits=BuckConverterPowerPath._ilim_expr(self.inductor.actual_current_rating, self.sw_current_limits,
+                                                       self.actual_inductor_current_ripple)
+                     * (1 - boost_values.effective_dutycycle.upper)
+    )))
     self.assign(self.actual_inductor_current_ripple, combined_ripple_scale / self.inductor.actual_inductance)
-    self.assign(self.actual_avg_current_rating,
-                BuckConverterPowerPath._ilim_expr(self.inductor.actual_current_rating, self.sw_current_limits,
-                                                  self.actual_inductor_current_ripple))
-    self.assign(self.actual_inductor_current, combined_inductor_avg_current + self.actual_inductor_current_ripple / 2)
+    self.assign(self.actual_inductor_current_peak,
+                combined_inductor_avg_current + self.actual_inductor_current_ripple / 2)
 
     self.in_cap = self.Block(DecouplingCapacitor(
       capacitance=buck_values.input_capacitance.intersect(boost_values.input_capacitance) * Farad,

edg/parts/BuckBoostConverter_Custom.py

@@ -18,6 +18,19 @@ def __init__(self, voltage_out: RangeLike, a_current_limits: RangeLike, b_curren
     ), [Output])  # exterior source: set output voltage + Ilim
 
 
+class VoltageSourceConnector(DummyDevice, NetBlock):
+  """Connects two voltage sources together (inductor output to FET center 'source')."""
+  @init_in_parent
+  def __init__(self, a_current_draw: RangeLike, b_current_draw: RangeLike) -> None:
+    super().__init__()
+    self.a = self.Port(VoltageSink(
+      current_draw=a_current_draw
+    ), [Input])  # FET top: set output voltage, allow instantaneous current draw
+    self.b = self.Port(VoltageSink(
+      current_draw=b_current_draw
+    ), [Output])  # exterior source: set output voltage + Ilim
+
+
 class CustomSyncBuckBoostConverterPwm(DiscreteBoostConverter, Resettable):
   """Custom synchronous buck-boost with four PWMs for the switches.
   Because of the MOSFET body diode, will probably be fine-ish if the buck low-side FET and the boost high-side FET
@@ -65,9 +78,10 @@ def contents(self):
                                           self.power_path.efficiency)),
       self.buck_sw.pwr
     )
-    self.connect(  # current draw used to size FETs, size for peak current
+    (self._sw_in_force, ), _ = self.chain(  # current draw used to size FETs, size for peak current
       self.buck_sw.out,
-      self.power_path.switch_in.adapt_to(VoltageSink(current_draw=self.power_path.actual_inductor_current))
+      self.Block(ForcedVoltageCurrentDraw(self.power_path.actual_inductor_current_peak)),
+      self.power_path.switch_in
     )
 
     self.boost_sw = self.Block(FetHalfBridge(frequency=self.frequency, fet_rds=self.rds_on))
@@ -78,11 +92,13 @@ def contents(self):
     (self.boost_pwr_conn, ), _ = self.chain(
       self.boost_sw.pwr,
       self.Block(VoltageSinkConnector(self.output_voltage,
-                                      self.power_path.actual_inductor_current,
-                                      self.power_path.actual_avg_current_rating)),
+                                      Range.all(),  # unused, port actually in reverse
+                                      self.power_path.switch_out.current_limits)),
       self.pwr_out
     )
-    self.connect(  # current draw used to size FETs, size for peak current
-      self.power_path.switch_out.adapt_to(VoltageSink(current_draw=self.power_path.actual_inductor_current)),
+    (self._sw_out_force, ), _ = self.chain(  # current draw used to size FETs, size for peak current
+      self.power_path.switch_out,
+      self.Block(VoltageSourceConnector(Range.exact(0),
+                                        self.power_path.actual_inductor_current_peak)),
       self.boost_sw.out
     )