コード例 #1
0
    def control(self,
                currentCV: np.ndarray,
                voltageCV: np.ndarray,
                idq0SP: np.ndarray = np.zeros(3),
                **kwargs):
        """
        Performs the calculations for a discrete step of the controller
        Droop-control is started if Vgrid_rms exceeds 200 V, to avoid oscillation with the grid forming inverter

        :param currentCV: 1d-array with 3 entries, one for each phase. The feedback values for current
        :param voltageCV:  1d-array with 3 entries, one for each phase. The feedback values for voltage
        :param idq0SP: The peak current setpoints in the dq0 frame (Additional power output to droop, if == 0, than
            only droop is applied

        :return: Modulation indices for the current sourcing inverter in ABC
        """
        # Calulate P&Q for slave
        instPow = -inst_power(voltageCV, currentCV)
        instQ = -inst_reactive(voltageCV, currentCV)

        Vinst = inst_rms(voltageCV)
        # Get current phase information from the voltage measurement
        self._prev_cossine, self._prev_freq, self._prev_theta = self._pll.step(
            voltageCV)

        # Transform the current feedback to the DQ0 frame
        self._lastIDQ = abc_to_dq0_cos_sin(currentCV, *self._prev_cossine)

        droop = np.zeros(2)
        if Vinst > self.lower_droop_voltage_threshold:
            # Determine the droop power setpoints
            droopPI = (self._PdroopController.step(self._prev_freq) /
                       inst_rms(voltageCV))

            # Determine the droop reactive power set points
            droopQI = (self._QdroopController.step(Vinst) / Vinst)
            droop = np.array([
                droopPI, droopQI
            ]) / 3  # devide by 3 due to here dq, but we want to set the e.g.
            # d-setpoint in the sum of the phases abc

            droop = droop * 1.4142135623730951  # RMS to Peak
            droop = np.clip(droop, -self._i_limit, self._i_limit)

        idq0SP = idq0SP + np.array([-droop[0], +droop[1], 0])
        # Calculate the control applied to the DQ0 currents
        # action space is limited to [-1,1]

        MVdq0 = self._currentPI.step(idq0SP, self._lastIDQ)
        # Transform the outputs from the controllers (dq0) to abc
        # also divide by SQRT(2) to ensure the transform is limited to [-1,1]

        MVabc = dq0_to_abc_cos_sin(MVdq0, *self._prev_cossine)
        self._last_meas = [
            self._prev_theta, instPow, instQ, self._prev_freq, *self._lastIDQ,
            *idq0SP, *MVdq0, *MVabc
        ]
        return MVabc
コード例 #2
0
    def control(self, currentCV: np.ndarray, voltageCV: np.ndarray, **kwargs):
        """
        Performs the calculations for a discrete step of the controller

        :param currentCV: 1d-array with 3 entries, one for each phase in abc. The feedback values for current
        :param voltageCV:  1d-array with 3 entries, one for each phase in abc. The feedback values for voltage

        :return: Modulation index for the inverter in abc
        """

        instPow = -inst_power(voltageCV, currentCV)
        freq = self._PdroopController.step(instPow)
        # Get the next phase rotation angle to implement
        self.phase = phase = self._phaseDDS.step(freq)

        instQ = -inst_reactive(voltageCV, currentCV)
        voltage = self._QdroopController.step(instQ)

        # Transform the feedback to the dq0 frame
        CVIdq0 = abc_to_dq0(currentCV, phase)
        CVVdq0 = abc_to_dq0(voltageCV, phase)

        # If available, calulate load current using observer
        iabc_out_etimate = np.empty(N_PHASE)
        if self._observer is None:
            iabc_out_etimate = np.zeros(N_PHASE)
        else:
            for j in range(N_PHASE):
                iabc_out_etimate[j] = self._observer[j].cal_estimate(
                    y=[currentCV[j], voltageCV[j]], u=self._lastMabc[j])

        i_dq0_out_estimat = abc_to_dq0(iabc_out_etimate, phase)

        # Voltage controller calculations
        VSP = voltage
        # Voltage SP in dq0 (static for the moment)
        SPVdq0 = np.array([VSP, 0, 0])
        SPVabc = dq0_to_abc(SPVdq0, phase)
        SPIdq0 = self._voltagePI.step(SPVdq0, CVVdq0, i_dq0_out_estimat)

        SPIabc = dq0_to_abc(SPIdq0, phase)

        # Current controller calculations
        MVdq0 = self._currentPI.step(SPIdq0, CVIdq0)
        MVabc = dq0_to_abc(MVdq0,
                           phase)  # Transform the MVs back to the abc frame
        self._lastMabc = MVabc
        # Add intern measurment
        self._last_meas = [
            phase, instPow, instQ, freq, *SPVdq0, *SPVabc, *SPIdq0, *SPIabc,
            *CVVdq0, *CVIdq0, *i_dq0_out_estimat, *iabc_out_etimate, *MVdq0,
            *MVabc
        ]

        return MVabc
コード例 #3
0
    def calculate(self):
        super().calculate()
        instPow = -inst_power(self.v, self.i)
        freq = self.pdroop_ctl.step(instPow)
        # Get the next phase rotation angle to implement
        phase = self.dds.step(freq)

        instQ = -inst_reactive(self.v, self.i)
        v_refd = self.qdroop_ctl.step(instQ)
        v_refdq0 = np.array([v_refd, 0, 0]) * self.v_ref

        return dict(i_ref=dq0_to_abc(self.i_ref, phase), v_ref=dq0_to_abc(v_refdq0, phase))
コード例 #4
0
    def control(self, currentCV: np.ndarray, voltageCV: np.ndarray, **kwargs):
        instPow = -inst_power(voltageCV, currentCV)
        freq = self._PdroopController.step(instPow)
        # Get the next phase rotation angle to implement
        phase = self._phaseDDS.step(freq)

        instQ = -inst_reactive(voltageCV, currentCV)
        voltage = self._QdroopController.step(instQ)

        VSP = voltage * 1.732050807568877
        # Voltage SP in dq0 (static for the moment)
        SPVdq0 = np.array([VSP, 0, 0])

        # Get the voltage SPs in abc vector
        # print("SPVdq0: {}, phase: {}".format(SPVdq0,phase))
        SPV = dq0_to_abc(SPVdq0, phase)

        # print("QInst: {}, Volt {}".format(instQ,VSP))
        SPI = self._voltagePI.step(SPV, voltageCV)

        # Average voltages from modulation indices created by current controller
        return self._currentPI.step(SPI, currentCV)
コード例 #5
0
    def control(self, currentCV: np.ndarray, voltageCV: np.ndarray, **kwargs):
        """
        Performs the calculations for a discrete step of the controller

        :param currentCV: 1d-array with 3 entries, one for each phase in abc. The feedback values for current
        :param voltageCV:  1d-array with 3 entries, one for each phase in abc. The feedback values for voltage

        :return: Modulation index for the inverter in abc
        """

        instPow = -inst_power(voltageCV, currentCV)
        freq = self._PdroopController.step(instPow)
        # Get the next phase rotation angle to implement
        phase = self._phaseDDS.step(freq)

        instQ = -inst_reactive(voltageCV, currentCV)
        voltage = self._QdroopController.step(instQ)

        # Transform the feedback to the dq0 frame
        CVIdq0 = abc_to_dq0(currentCV, phase)
        CVVdq0 = abc_to_dq0(voltageCV, phase)

        # Voltage controller calculations
        VSP = voltage
        # Voltage SP in dq0 (static for the moment)
        SPVdq0 = np.array([VSP, 0, 0])
        SPIdq0 = self._voltagePI.step(SPVdq0, CVVdq0)

        # Current controller calculations
        MVdq0 = self._currentPI.step(SPIdq0, CVIdq0)

        # Add intern measurment
        self.history.append([
            phase, *SPVdq0, *SPIdq0, *CVVdq0, *CVIdq0, *MVdq0, instPow, instQ,
            freq
        ])

        # Transform the MVs back to the abc frame
        return dq0_to_abc(MVdq0, phase)