ExcessiveMotion_controller-software/controller-firmware/python/src/cascaded_PI_controller.py

from amaranth import *
from amaranth.sim import Simulator
from amaranth.back import verilog
from amaranth.hdl import Array
from src.convergent_round import convergentRound
from src.biquad import biquad_32


class cascaded_PI_controller(Elaboratable):


        
    def __init__(self, instances) -> None:

        self.instances = instances
        

        # Ports
        self.address = Signal(16)
        self.writeData = Signal(32)
        self.readData = Signal(32)
        self.writeEnable = Signal()

        # internal signals
        self.selectedInstance = Signal(range(self.instances))

        self.startUpdate = Signal()
        self.updateDone = Signal()

        # per-instance signals
        self.positionCmd = Array(Signal(shape=signed(64), name=f"posCMD_{_}") for _ in range(self.instances))
        self.positionCmdOld = Array(Signal(shape=signed(64), name=f"posCMDold_{_}") for _ in range(self.instances))
        self.positionFbk = Array(Signal(shape=signed(64), name=f"posFBK_{_}") for _ in range(self.instances))
        self.positionError = Array(Signal(shape=signed(64), name=f"posError_{_}") for _ in range(self.instances))
        self.positionIntegralLimit = Array(Signal(shape=signed(32), name=f"posIlim_{_}") for _ in range(self.instances))
        self.positionIntegral = Array(Signal(shape=signed(32), name=f"posIntegral_{_}") for _ in range(self.instances))
        self.positionIntegralGain = Array(Signal(shape=signed(32), name=f"posIgain_{_}") for _ in range(self.instances))
        self.positionProportionalGain = Array(Signal(shape=signed(32), name=f"posPgain_{_}") for _ in range(self.instances))

        self.velocityCmd = Array(Signal(shape=signed(32), name=f"velCMD_{_}") for _ in range(self.instances))
        self.velocityFFCmd = Array(Signal(shape=signed(32), name=f"velFFCMD_{_}") for _ in range(self.instances))
        self.velocityFbk = Array(Signal(shape=signed(32), name=f"velFBK_{_}") for _ in range(self.instances))
        self.estimateVelocityFbk = Array(Signal(1, name=f"velEstimateFbkEnable_{_}") for _ in range(self.instances))
        self.velocityError = Array(Signal(shape=signed(32), name=f"velError_{_}") for _ in range(self.instances))
        self.velocityIntegralLimit = Array(Signal(shape=signed(32), name=f"velIlim_{_}") for _ in range(self.instances))
        self.velocityIntegral = Array(Signal(shape=signed(32), name=f"velIntegral_{_}") for _ in range(self.instances))
        self.velocityIntegralGain = Array(Signal(shape=signed(32), name=f"velIgain_{_}") for _ in range(self.instances))
        self.velocityProportionalGain = Array(Signal(shape=signed(32), name=f"velPgain_{_}") for _ in range(self.instances))
        self.velocityFilterZeroCoeff_0 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.velocityFilterZeroCoeff_1 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.velocityFilterZeroCoeff_2 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.velocityFilterPoleCoeff_1 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.velocityFilterPoleCoeff_2 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.velocityFilterDn_0 = Array(Signal(shape=signed(48)) for _ in range(self.instances))
        self.velocityFilterDn_1 = Array(Signal(shape=signed(48)) for _ in range(self.instances))
        
        self.torqueFFCmd = Array(Signal(shape=signed(32)) for _ in range(self.instances))
        self.torqueCmd = Array(Signal(shape=signed(32)) for _ in range(self.instances))
        self.torqueFilterZeroCoeff_0 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.torqueFilterZeroCoeff_1 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.torqueFilterZeroCoeff_2 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.torqueFilterPoleCoeff_1 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.torqueFilterPoleCoeff_2 = Array(Signal(shape=signed(36)) for _ in range(self.instances))
        self.torqueFilterDn_0 = Array(Signal(shape=signed(48)) for _ in range(self.instances))
        self.torqueFilterDn_1 = Array(Signal(shape=signed(48)) for _ in range(self.instances))

    def elaborate(self, platform):
        m = Module()

        m.submodules.rounder = self.rounder = convergentRound(48+32, 48)
        m.submodules.filter = self.filter = biquad_32(signed_=True, constrainOutput_=True)
        
        # handle reading/writing data

        # update loops

        self.velAccum = Signal(shape=signed(64))

        self.multiplier = Signal(shape=signed(48+32))
        self.multA = Signal(shape=signed(32))
        self.multB = Signal(shape=signed(48))

        self.addAccum = Signal(shape=signed(34))

        m.d.comb += self.multiplier.eq(self.multA * self.multB)


        with m.FSM(init="done"):
            with m.State("done"):
                m.d.sync += self.updateDone.eq(1)
                with m.If(self.startUpdate):
                    m.d.sync += self.updateDone.eq(0)
                    m.next = "prepare_pos_loop"

            #### POSITION LOOP ####

            with m.State("prepare_pos_loop"):
                m.d.sync += self.positionError[self.selectedInstance].eq(self.positionFbk[self.selectedInstance] - self.positionCmd[self.selectedInstance])
                
                with m.If(self.estimateVelocityFbk[self.selectedInstance]):
                   m.d.sync += self.velocityFbk[self.selectedInstance].eq(self.positionCmd[self.selectedInstance] - self.positionCmdOld[self.selectedInstance])

                m.d.sync += self.positionCmdOld[self.selectedInstance].eq(self.positionCmd[self.selectedInstance])
                m.d.sync += self.addAccum.eq(self.velocityFFCmd[self.selectedInstance])
                m.next = "pos_p_gain_mult"

            with m.State("pos_p_gain_mult"):
                m.d.sync += self.multA.eq(self.positionError[self.selectedInstance])
                m.d.sync += self.multB.eq(self.positionProportionalGain[self.selectedInstance])
                m.next = "pos_p_gain_round"

            with m.State("pos_p_gain_round"):
                m.d.comb += self.rounder.input.eq(self.multiplier.shift_left(1))

                m.next = "pos_p_gain_overflow_check"

            with m.State("pos_p_gain_overflow_check"):
                with m.If(self.rounder.output > 2**31-1):   # positive overflow
                    m.d.sync += self.addAccum.eq(self.addAccum + 2**31-1)
                with m.Elif(self.rounder.output < -2**31):   # negative overflow
                    m.d.sync += self.addAccum.eq(self.addAccum - 2**31)
                with m.Else():
                    m.d.sync += self.addAccum.eq(self.addAccum + self.rounder.output)

                m.next = "pos_i_gain_mult"

            with m.State("pos_i_gain_mult"):
                m.d.sync += self.multA.eq(self.positionError[self.selectedInstance])
                m.d.sync += self.multB.eq(self.positionIntegralGain[self.selectedInstance])
                m.next = "pos_i_gain_round"

            with m.State("pos_i_gain_round"):
                m.d.comb += self.rounder.input.eq(self.multiplier.shift_left(1))

                m.next = "pos_i_accum"

            with m.State("pos_i_accum"):
                m.d.sync += self.positionIntegral[self.selectedInstance].eq(self.positionIntegral[self.selectedInstance] + self.rounder.output)

                m.next = "pos_i_limit_check"

            with m.State("pos_i_limit_check"):
                with m.If(self.positionIntegral[self.selectedInstance] > self.positionIntegralLimit[self.selectedInstance]):   # positive limit reached
                    m.d.sync += self.positionIntegral[self.selectedInstance].eq(2**31-1)
                with m.Elif(self.positionIntegral[self.selectedInstance] < -self.positionIntegralLimit[self.selectedInstance]):   # negative limit reached
                    m.d.sync += self.positionIntegral[self.selectedInstance].eq(-2**31)
                
                m.next = "vel_cmd_accum"

            with m.State("vel_cmd_accum"):
                m.d.sync += self.addAccum.eq(self.addAccum + self.positionIntegral[self.selectedInstance])

                m.next = "vel_cmd_accum_overflow_check"

            with m.State("vel_cmd_accum_overflow_check"):
                with m.If(self.addAccum > 2**31-1):   # positive overflow
                    m.d.sync += self.velocityCmd[self.selectedInstance].eq(2**31-1)
                with m.Elif(self.rounder.output < -2**31):   # negative overflow
                    m.d.sync += self.velocityCmd[self.selectedInstance].eq(-2**31)
                with m.Else():
                    m.d.sync += self.velocityCmd[self.selectedInstance].eq(self.addAccum)

                m.next = "prepare_vel_loop"


            #### VELOCITY LOOP ####


            with m.State("prepare_vel_loop"):
                m.d.sync += self.filter.input.eq(self.velocityFbk[self.selectedInstance] - self.velocityCmd[self.selectedInstance])
                m.d.sync += self.filter.dn_0.eq(self.velocityFilterDn_0[self.selectedInstance])
                m.d.sync += self.filter.dn_1.eq(self.velocityFilterDn_1[self.selectedInstance])
                m.d.sync += self.filter.poleCoeff_1.eq(self.velocityFilterPoleCoeff_1[self.selectedInstance])
                m.d.sync += self.filter.poleCoeff_2.eq(self.velocityFilterPoleCoeff_2[self.selectedInstance])
                m.d.sync += self.filter.zeroCoeff_0.eq(self.velocityFilterZeroCoeff_0[self.selectedInstance])
                m.d.sync += self.filter.zeroCoeff_1.eq(self.velocityFilterZeroCoeff_1[self.selectedInstance])
                m.d.sync += self.filter.zeroCoeff_2.eq(self.velocityFilterZeroCoeff_2[self.selectedInstance])
                m.d.sync += self.filter.update.eq(1)

                m.d.sync == self.addAccum.eq(self.torqueFFCmd[self.selectedInstance])

                m.next = "vel_error_filter"

            with m.State("vel_error_filter"):
                m.d.sync += self.filter.update.eq(0)
                with m.If(self.filter.updateDone):
                    m.d.sync += self.velocityFilterDn_0[self.selectedInstance].eq(self.filter.dn_0)
                    m.d.sync += self.velocityFilterDn_1[self.selectedInstance].eq(self.filter.dn_1)
                    m.d.sync += self.velocityError[self.selectedInstance].eq(self.filter.output)
                    m.next = "vel_p_gain_mult"

            with m.State("vel_p_gain_mult"):
                m.d.sync += self.multA.eq(self.velocityError[self.selectedInstance])
                m.d.sync += self.multB.eq(self.velocityProportionalGain[self.selectedInstance])
                m.next = "vel_p_gain_round"

            with m.State("vel_p_gain_round"):
                m.d.comb += self.rounder.input.eq(self.multiplier.shift_left(1))

                m.next = "vel_p_gain_overflow_check"

            with m.State("vel_p_gain_overflow_check"):
                with m.If(self.rounder.output > 2**31-1):   # positive overflow
                    m.d.sync += self.addAccum.eq(self.addAccum + 2**31-1)
                with m.Elif(self.rounder.output < -2**31):   # negative overflow
                    m.d.sync += self.addAccum.eq(self.addAccum - 2**31)
                with m.Else():
                    m.d.sync += self.addAccum.eq(self.addAccum + self.rounder.output)

                m.next = "vel_i_gain_mult"

            with m.State("vel_i_gain_mult"):
                m.d.sync += self.multA.eq(self.velocityError[self.selectedInstance])
                m.d.sync += self.multB.eq(self.velocityIntegralGain[self.selectedInstance])
                m.next = "vel_i_gain_round"

            with m.State("vel_i_gain_round"):
                m.d.comb += self.rounder.input.eq(self.multiplier.shift_left(1))

                m.next = "vel_i_accum"

            with m.State("vel_i_accum"):
                m.d.sync += self.velocityIntegral[self.selectedInstance].eq(self.velocityIntegral[self.selectedInstance] + self.rounder.output)

                m.next = "vel_i_limit_check"

            with m.State("vel_i_limit_check"):
                with m.If(self.velocityIntegral[self.selectedInstance] > self.velocityIntegralLimit[self.selectedInstance]):   # positive limit reached
                    m.d.sync += self.velocityIntegral[self.selectedInstance].eq(2**31-1)
                with m.Elif(self.velocityIntegral[self.selectedInstance] < -self.velocityIntegralLimit[self.selectedInstance]):   # negative limit reached
                    m.d.sync += self.velocityIntegral[self.selectedInstance].eq(-2**31)
                
                m.next = "torque_cmd_accum"

            with m.State("torque_cmd_accum"):
                m.d.sync += self.addAccum.eq(self.addAccum + self.velocityIntegral[self.selectedInstance])

                m.next = "torque_cmd_accum_overflow_check_and_filter"

            with m.State("torque_cmd_accum_overflow_check_and_filter"):
                with m.If(self.addAccum > 2**31-1):   # positive overflow
                    m.d.sync += self.filter.input.eq(2**31-1)
                with m.Elif(self.rounder.output < -2**31):   # negative overflow
                    m.d.sync += self.filter.input.eq(-2**31)
                with m.Else():
                    m.d.sync += self.filter.input.eq(self.addAccum)

                m.d.sync += self.filter.dn_0.eq(self.torqueFilterDn_0[self.selectedInstance])
                m.d.sync += self.filter.dn_1.eq(self.torqueFilterDn_1[self.selectedInstance])
                m.d.sync += self.filter.poleCoeff_1.eq(self.torqueFilterPoleCoeff_1[self.selectedInstance])
                m.d.sync += self.filter.poleCoeff_2.eq(self.torqueFilterPoleCoeff_2[self.selectedInstance])
                m.d.sync += self.filter.zeroCoeff_0.eq(self.torqueFilterZeroCoeff_0[self.selectedInstance])
                m.d.sync += self.filter.zeroCoeff_1.eq(self.torqueFilterZeroCoeff_1[self.selectedInstance])
                m.d.sync += self.filter.zeroCoeff_2.eq(self.torqueFilterZeroCoeff_2[self.selectedInstance])
                m.d.sync += self.filter.update.eq(1)

                m.next = "torque_filter"

            with m.State("torque_filter"):
                m.d.sync += self.filter.update.eq(0)
                with m.If(self.filter.updateDone):
                    m.d.sync += self.torqueFilterDn_0[self.selectedInstance].eq(self.filter.dn_0)
                    m.d.sync += self.torqueFilterDn_1[self.selectedInstance].eq(self.filter.dn_1)
                    m.d.sync += self.torqueCmd[self.selectedInstance].eq(self.filter.output)
                    m.next = "done"


        return m
    

dut = cascaded_PI_controller(1)

async def PIBench(ctx):

    ctx.set(dut.positionProportionalGain[0], 2**31-1)
    ctx.set(dut.positionIntegralGain[0], 2**31-1)
    ctx.set(dut.positionIntegralLimit[0], 2**31-1)
    for i in range(1000):
        ctx.set(dut.positionCmd[0],i)
        ctx.set(dut.startUpdate, 1)
        await ctx.tick()

        while(not ctx.get(dut.updateDone)):
            await ctx.tick()
            ctx.set(dut.startUpdate, 0)
    
    #TODO: write full test bench

            
if __name__ == "__main__":

    sim = Simulator(dut)
    sim.add_clock(1/int(100e6))
    sim.add_testbench(PIBench)
    with sim.write_vcd("cascaded_PI_controller.vcd"):
        sim.run()

    # if (True):  # export
    #     top = cascaded_PI_controller(1)
    #     with open("controller-firmware/src/amaranth sources/cascaded_PI_controller.v", "w") as f:
    #         f.write(verilog.convert(top, name="cascaded_PI_controller", ports=[top.ports]))