GaN FOC Drive — SVPWM Inverter + Motor

// FOC core — Clarke, Park, SVPWM, PMSM dq model
type DQ = { d:number; q:number };
type AB = { a:number; b:number };

const SQRT3 = Math.sqrt(3);

// Clarke amplitude-invariant (ia+ib+ic=0)
function clarke(ia:number, ib:number, ic:number): AB {
  return { a: (2/3)*(ia - 0.5*ib - 0.5*ic), b: (2/3)*(SQRT3/2*ib - SQRT3/2*ic) };
}
function invClarke(ab:AB): [number,number,number] {
  const ia = ab.a;
  const ib = -0.5*ab.a + SQRT3/2*ab.b;
  const ic = -0.5*ab.a - SQRT3/2*ab.b;
  return [ia, ib, ic];
}
function park(ab:AB, theta:number): DQ {
  const c=Math.cos(theta), s=Math.sin(theta);
  return { d: ab.a*c + ab.b*s, q: -ab.a*s + ab.b*c };
}
function invPark(dq:DQ, theta:number): AB {
  const c=Math.cos(theta), s=Math.sin(theta);
  return { a: dq.d*c - dq.q*s, b: dq.d*s + dq.q*c };
}

function svpwm(valpha:number, vbeta:number, Vdc:number, fsw:number){
  const Vref = Math.hypot(valpha, vbeta);
  const Vlim = Vdc / Math.sqrt(3); // linear limit
  const V = Math.min(Vref, Vlim);
  let ang = Math.atan2(vbeta, valpha); // 0..2pi
  if(ang<0) ang+=2*Math.PI;
  const sector = Math.floor(ang / (Math.PI/3)) + 1; // 1..6
  const theta = ang - (sector-1)*(Math.PI/3); // 0..60deg
  const T = 1/fsw;
  const T1 = Math.sqrt(3)*T*V/Vdc*Math.sin(Math.PI/3 - theta);
  const T2 = Math.sqrt(3)*T*V/Vdc*Math.sin(theta);
  const T0 = Math.max(0, T - T1 - T2);
  const mod = V / Vlim;
  return { Vref, Vlim: V, mod, ang, sector, theta, T1, T2, T0, T };
}

// dead-time voltage error per phase
function vDead(td:number, fsw:number, Vdc:number, i:number): number {
  // V_dead = td * fsw * Vdc * sign(I)  (average over Ts)
  return td * fsw * Vdc * Math.sign(i);
}

// PMSM dq electrical dynamics
function dqDeriv(id:number,iq:number,vd:number,vq:number,we:number,R:number,L:number,psi:number){
  const didt = (vd - R*id + we*L*iq)/L;
  const diqt = (vq - R*iq - we*L*id - we*psi)/L;
  return { didt, diqt };
}
function torque(p:number, psi:number, iq:number, Ld:number, Lq:number, id:number){
  return 1.5 * p * (psi*iq + (Ld - Lq)*id*iq);
}

// PI + feedforward
function piFOC(e:number, int:number, Kp:number, Ki:number, we:number, L:number, iq:number, extra=0){
  return Kp*e + Ki*int + we*L*iq + extra;
}