MC100/Applications/foc/core/PMSM_FOC_Core.c

#include "arm_math.h"
#include "PMSM_FOC_Core.h"
#include "PMSM_FOC_Params.h"
#include "foc/core/e_ctrl.h"
#include "math/fix_math.h"
#include "math/fast_math.h"
#include "foc/motor/current.h"
#include "foc/motor/hall.h"
#include "foc/core/svpwm.h"
#include "foc/samples.h"
#include "bsp/pwm.h"
#include "libs/logger.h"

PMSM_FOC_Ctrl _gFOC_Ctrl;

static __INLINE void RevPark(DQ_t *dq, float angle, AB_t *alpha_beta) {
	float c,s;
	SinCos_Lut(angle, &s, &c);

	alpha_beta->a = dq->d * c - dq->q * s;
	alpha_beta->b = dq->d * s + dq->q * c;
}

static __INLINE void Clark(float A, float B, float C, AB_t *alpha_beta){
	alpha_beta->a = A;
	alpha_beta->b = ONE_BY_SQRT3 * (B - C);
}

static __INLINE void Park(AB_t *alpha_beta, float angle, DQ_t *dq) {
	float c,s;
	SinCos_Lut(angle, &s, &c);

	dq->d = alpha_beta->a * c + alpha_beta->b * s;
	dq->q = -alpha_beta->a * s + alpha_beta->b * c;
}

static __INLINE float Circle_Limitation(DQ_t *vdq, float vDC, float module, DQ_t *out) {
	float sq_vdq = vdq->d * vdq->d + vdq->q * vdq->q;
	float vDC_m = vDC * module;
	float sq_vDC = vDC_m * vDC_m;
	if (sq_vdq > sq_vDC) {
		float r = sqrtf(sq_vDC / sq_vdq);
		out->d = vdq->d * r;
		out->q = vdq->q * r;
		return r;
	}
	out->d = vdq->d;
	out->q = vdq->q;
	return 1.0f; // s16q5 32 means int 1
}

static __INLINE void FOC_Set_DqRamp(dq_Rctrl *c, float target, int time) {	
	float cp = c->s_Cp;
	c->s_FinalTgt = target; 
	c->s_Step = (c->s_FinalTgt - cp) / time;
	if ((c->s_Step == 0) && (c->s_FinalTgt - cp > 0)) {
		if (c->s_FinalTgt - cp > 0) {
			c->s_Step = 0.001;	
		}else if (c->s_FinalTgt - cp < 0){
			c->s_Step = 0.001;
		}
	}
}

static __INLINE float FOC_Get_DqRamp(dq_Rctrl *c) {
	if (++c->n_StepCount == c->n_CtrlCount) {
		c->s_Cp += c->s_Step;
		if (c->s_Step < 0) {
			if (c->s_Cp < c->s_FinalTgt) {
				c->s_Cp = c->s_FinalTgt;
			}
		}else {
			if (c->s_Cp > c->s_FinalTgt) {
				c->s_Cp = c->s_FinalTgt;
			}
		}
		c->n_StepCount = 0;
	}
	return c->s_Cp;
}

static __INLINE void FOC_DqRamp_init(dq_Rctrl *c, int count) {
	c->n_CtrlCount = count;
	c->n_StepCount = 0;
	c->s_Cp = 0;
	c->s_FinalTgt = 0;
	c->s_Step = 0;
}

static __INLINE void FOC_Set_iDqRamp(dq_Rctrl *c, float target) {
	FOC_Set_DqRamp(c, target, (IDQ_CTRL_TS/SPD_CTRL_TS - 1));
}

static __INLINE void FOC_Set_vDqRamp(dq_Rctrl *c, float target) {
	FOC_Set_DqRamp(c, target, (VDQ_RAMP_FINAL_TIME/VDQ_RAMP_TS));
}


static void PMSM_FOC_Reset_PID(void) {
	PI_Controller_Reset(_gFOC_Ctrl.pi_ctl_id, 0);
	PI_Controller_Reset(_gFOC_Ctrl.pi_ctl_iq, 0);
	PI_Controller_Reset(_gFOC_Ctrl.pi_ctl_spd, 0);
	PI_Controller_Reset(_gFOC_Ctrl.pi_ctl_fw, 0);
}


void PMSM_FOC_CoreInit(void) {
	_gFOC_Ctrl.pi_ctl_id = &PI_Ctrl_ID;
	_gFOC_Ctrl.pi_ctl_iq = &PI_Ctrl_IQ;
	_gFOC_Ctrl.pi_ctl_spd = &PI_Ctrl_Spd;
	_gFOC_Ctrl.pi_ctl_fw = &PI_Ctrl_fw;
	memset(&_gFOC_Ctrl.in, 0, sizeof(_gFOC_Ctrl.in));
	memset(&_gFOC_Ctrl.out, 0, sizeof(_gFOC_Ctrl.out));
	_gFOC_Ctrl.params.s_maxiDC = (MAX_iDQ);
	_gFOC_Ctrl.params.s_maxiDC = (MAX_iDC);
	_gFOC_Ctrl.params.s_maxRPM = (MAX_SPEED);
	_gFOC_Ctrl.params.n_modulation = SVM_Modulation;
	_gFOC_Ctrl.params.n_PhaseFilterCeof = (0.2f);
	_gFOC_Ctrl.params.maxvDQ.d = MAX_vDC;
	_gFOC_Ctrl.params.minvDQ.d = -MAX_vDC;
	_gFOC_Ctrl.params.maxvDQ.q = MAX_vDC;
	_gFOC_Ctrl.params.minvDQ.q = -MAX_vDC;
	_gFOC_Ctrl.params.s_maxIdq = MAX_iDQ;
	_gFOC_Ctrl.params.s_minIdq = -MAX_iDQ;
	_gFOC_Ctrl.params.n_poles = MOTOR_POLES;
	_gFOC_Ctrl.out.n_RunMode = OPEN_MODE;
	_gFOC_Ctrl.out.f_vdqRation = 0;
	_gFOC_Ctrl.in.s_manualAngle = 0x3D00;
	_gFOC_Ctrl.in.s_vDC = (MAX_vDC);
	
	FOC_DqRamp_init(&_gFOC_Ctrl.idq_ctl[0], 1);
	FOC_DqRamp_init(&_gFOC_Ctrl.idq_ctl[1], 1);

	FOC_DqRamp_init(&_gFOC_Ctrl.vdq_ctl[0], (IDQ_CTRL_TS/VDQ_RAMP_TS));
	FOC_DqRamp_init(&_gFOC_Ctrl.vdq_ctl[1], (IDQ_CTRL_TS/VDQ_RAMP_TS));	
	PMSM_FOC_Reset_PID();
}


static __INLINE void PMSM_FOC_Update_Hardware(void) {
	if (_gFOC_Ctrl.in.s_manualAngle != 0x3D00) {
		_gFOC_Ctrl.in.s_motAngle = _gFOC_Ctrl.in.s_manualAngle;
		_gFOC_Ctrl.in.s_hallAngle = hall_sensor_get_theta();
	}else {
		_gFOC_Ctrl.in.s_hallAngle = hall_sensor_get_theta();
		_gFOC_Ctrl.in.s_motAngle = _gFOC_Ctrl.in.s_hallAngle;
	}

	_gFOC_Ctrl.in.s_motRPM = hall_sensor_get_speed() / _gFOC_Ctrl.params.n_poles;
	_gFOC_Ctrl.in.s_vDC = get_vbus_float();
	//sample current
	phase_current_get(_gFOC_Ctrl.in.s_iABC);

#ifdef PHASE_LFP
	LowPass_Filter(_gFOC_Ctrl.in.s_iABCFilter[0], _gFOC_Ctrl.in.s_iABC[0], _gFOC_Ctrl.params.n_PhaseFilterCeof);
	LowPass_Filter(_gFOC_Ctrl.in.s_iABCFilter[1], _gFOC_Ctrl.in.s_iABC[1], _gFOC_Ctrl.params.n_PhaseFilterCeof);
	LowPass_Filter(_gFOC_Ctrl.in.s_iABCFilter[2], _gFOC_Ctrl.in.s_iABC[2], _gFOC_Ctrl.params.n_PhaseFilterCeof);
#endif	
}

static __INLINE void PMSM_FOC_Update_PI_Ctrls(void) {
	/* update speed pi ctrl */
	if (_gFOC_Ctrl.params.s_maxIdq != _gFOC_Ctrl.pi_ctl_spd->max) {
		_gFOC_Ctrl.pi_ctl_spd->max = _gFOC_Ctrl.params.s_maxIdq;
	}
	if (_gFOC_Ctrl.params.s_minIdq != _gFOC_Ctrl.pi_ctl_spd->min) {
		_gFOC_Ctrl.pi_ctl_spd->min = _gFOC_Ctrl.params.s_minIdq;
	}
	/* update id pi ctrl */
	if (_gFOC_Ctrl.params.maxvDQ.d != _gFOC_Ctrl.pi_ctl_id->max) {
		_gFOC_Ctrl.pi_ctl_id->max = _gFOC_Ctrl.params.maxvDQ.d;
	}
	if (_gFOC_Ctrl.params.minvDQ.d != _gFOC_Ctrl.pi_ctl_id->min) {
		_gFOC_Ctrl.pi_ctl_id->min = _gFOC_Ctrl.params.minvDQ.d;
	}
	/* update iq pi ctrl */
	if (_gFOC_Ctrl.params.maxvDQ.q != _gFOC_Ctrl.pi_ctl_iq->max) {
		_gFOC_Ctrl.pi_ctl_iq->max = _gFOC_Ctrl.params.maxvDQ.q;
	}
	if (_gFOC_Ctrl.params.minvDQ.q != _gFOC_Ctrl.pi_ctl_iq->min) {
		_gFOC_Ctrl.pi_ctl_iq->min = _gFOC_Ctrl.params.minvDQ.q;
	}	
}

void PMSM_FOC_Schedule(void) {
	AB_t vAB;
#ifdef PHASE_LFP	
	float *iabc = _gFOC_Ctrl.in.s_iABCFilter;
#else
	float *iabc = _gFOC_Ctrl.in.s_iABC;
#endif
	_gFOC_Ctrl.ctrl_count++;

	PMSM_FOC_Update_Hardware();

	if (_gFOC_Ctrl.out.n_RunMode != OPEN_MODE) {

		PMSM_FOC_Update_PI_Ctrls();
	
		Clark(iabc[0], iabc[1], iabc[2], &vAB);

		Park(&vAB, _gFOC_Ctrl.in.s_motAngle, &_gFOC_Ctrl.out.s_RealIdq);

		float target_d = FOC_Get_DqRamp(&_gFOC_Ctrl.idq_ctl[0]);
		float err = target_d - _gFOC_Ctrl.out.s_RealIdq.d;
		_gFOC_Ctrl.in.s_targetVdq.d = PI_Controller_run(_gFOC_Ctrl.pi_ctl_id, err);

		float target_q = FOC_Get_DqRamp(&_gFOC_Ctrl.idq_ctl[1]);
		err = target_q - (_gFOC_Ctrl.out.s_RealIdq.q);
		_gFOC_Ctrl.in.s_targetVdq.q = PI_Controller_run(_gFOC_Ctrl.pi_ctl_iq, err);

	}else {
		_gFOC_Ctrl.in.s_targetVdq.d = FOC_Get_DqRamp(&_gFOC_Ctrl.vdq_ctl[0]);
		_gFOC_Ctrl.in.s_targetVdq.q = FOC_Get_DqRamp(&_gFOC_Ctrl.vdq_ctl[1]);
	}
	_gFOC_Ctrl.out.f_vdqRation = Circle_Limitation(&_gFOC_Ctrl.in.s_targetVdq, _gFOC_Ctrl.in.s_vDC, _gFOC_Ctrl.params.n_modulation, &_gFOC_Ctrl.out.s_OutVdq);
	
	RevPark(&_gFOC_Ctrl.out.s_OutVdq, _gFOC_Ctrl.in.s_motAngle, &vAB);
	
	SVM_Duty_Fix(&vAB, _gFOC_Ctrl.in.s_vDC, FOC_PWM_Half_Period, &_gFOC_Ctrl.out);

	phase_current_point(&_gFOC_Ctrl.out);

	pwm_update_duty(_gFOC_Ctrl.out.n_Duty[0], _gFOC_Ctrl.out.n_Duty[1], _gFOC_Ctrl.out.n_Duty[2]);
	pwm_update_sample(_gFOC_Ctrl.out.n_Sample1, _gFOC_Ctrl.out.n_Sample2, _gFOC_Ctrl.out.n_CPhases);

	if (_gFOC_Ctrl.ctrl_count % 5 == 0) {
		//plot_2data16(FtoS16x1000(_gFOC_Ctrl.out.s_RealIdq.d), FtoS16x1000(_gFOC_Ctrl.out.s_RealIdq.q));
		plot_1data16(_gFOC_Ctrl.in.s_motRPM);
		//plot_2data16(FtoS16(_gFOC_Ctrl.in.s_hallAngle), FtoS16(_gFOC_Ctrl.in.s_motAngle));
		//plot_3data16(FtoS16x1000(iabc[0]), FtoS16x1000(_gFOC_Ctrl.in.s_targetVdq.d), FtoS16x1000(_gFOC_Ctrl.out.s_RealIdq.d));
		//plot_3data16(FtoS16x1000(iabc[0]), FtoS16x1000(iabc[1]), FtoS16(_gFOC_Ctrl.in.s_hallAngle)*10);
		//plot_1data16(FtoS16(_gFOC_Ctrl.in.s_hallAngle));
	}	
}

void PMSM_FOC_LogDebug(void) {
	//sys_debug("Duty %d, %d, %d\n", _gFOC_Ctrl.out.n_Duty[0], _gFOC_Ctrl.out.n_Duty[1], _gFOC_Ctrl.out.n_Duty[2]);
	sys_debug("Vdq %f, %f-->%f, %f, %f\n", S16Q5toF(_gFOC_Ctrl.in.s_targetVdq.d), S16Q5toF(_gFOC_Ctrl.in.s_targetVdq.q), S16Q5toF(_gFOC_Ctrl.out.s_OutVdq.d), S16Q5toF(_gFOC_Ctrl.out.s_OutVdq.q), S16Q14toF(_gFOC_Ctrl.out.f_vdqRation));
	sys_debug("VBUS: %f, %d, %d\n", S16Q5toF(get_vbus_sfix5()), _gFOC_Ctrl.out.n_Sample1, _gFOC_Ctrl.out.n_Sample2);
	//sys_debug("iABC %f, %f, %f\n", S16Q5toF(_gFOC_Ctrl.in.s_iABC[0]), S16Q5toF(_gFOC_Ctrl.in.s_iABC[1]), S16Q5toF(_gFOC_Ctrl.in.s_iABC[2]));
	//plot_1data16(_gFOC_Ctrl.in.s_iABC[0]);
	//sys_debug("sample %d, %d\n", _gFOC_Ctrl.out.n_Sample1, _gFOC_Ctrl.out.n_Sample2);
}

/*called in media task */
u8 PMSM_FOC_CtrlMode(void) {
	if (!_gFOC_Ctrl.in.b_motEnable) {
		_gFOC_Ctrl.out.n_RunMode = OPEN_MODE;
	}else if (!_gFOC_Ctrl.in.b_motEnable || _gFOC_Ctrl.in.n_ctlMode == OPEN_MODE) {
		_gFOC_Ctrl.out.n_RunMode = OPEN_MODE;
	}else if (_gFOC_Ctrl.in.n_ctlMode == SPD_MODE || _gFOC_Ctrl.in.b_cruiseEna){
		_gFOC_Ctrl.out.n_RunMode = SPD_MODE;
	}else {
		_gFOC_Ctrl.out.n_RunMode = TRQ_MODE;
	}
	return _gFOC_Ctrl.out.n_RunMode;
}

/* MPTA, 弱磁, 功率限制 */
static __INLINE void PMSM_FOC_idq_Assign(void) {
	_gFOC_Ctrl.in.s_targetIdq.d = 0;
	_gFOC_Ctrl.in.s_targetIdq.q = _gFOC_Ctrl.in.s_targetTrq;
	FOC_Set_iDqRamp(&_gFOC_Ctrl.idq_ctl[0], _gFOC_Ctrl.in.s_targetIdq.d);
	FOC_Set_iDqRamp(&_gFOC_Ctrl.idq_ctl[1], _gFOC_Ctrl.in.s_targetIdq.q);
}

/*called in media task */
void PMSM_FOC_idqCalc(void) {
	if (_gFOC_Ctrl.out.n_RunMode == TRQ_MODE) {
		_gFOC_Ctrl.in.s_targetTrq = (eCtrl_get_RefTorque());
	}else {
		float errRef = min(eCtrl_get_RefSpd(), _gFOC_Ctrl.params.s_maxRPM) - _gFOC_Ctrl.in.s_motRPM;
		_gFOC_Ctrl.in.s_targetTrq = PI_Controller_run(_gFOC_Ctrl.pi_ctl_spd, errRef);
		
	}
	PMSM_FOC_idq_Assign();
}

void PMSM_FOC_Start(u8 nCtrlMode) {
	if (_gFOC_Ctrl.in.b_motEnable) {
		return;
	}
	PMSM_FOC_CoreInit();
	_gFOC_Ctrl.in.n_ctlMode = nCtrlMode;
	_gFOC_Ctrl.in.b_motEnable = true;
}

void PMSM_FOC_Stop(void) {
	if (!_gFOC_Ctrl.in.b_motEnable) {
		return;
	}
	_gFOC_Ctrl.in.b_motEnable = false;
}

bool PMSM_FOC_Is_Start(void) {
	return _gFOC_Ctrl.in.b_motEnable;
}

void PMSM_FOC_iBusLimit(float ibusLimit) {
	_gFOC_Ctrl.params.s_maxiDC = (ibusLimit);
}

void PMSM_FOC_SpeedLimit(float speedLimit) {
	_gFOC_Ctrl.params.s_maxRPM = (speedLimit);
}

s32q4_t PMSM_FOC_GetSpeedLimit(void) {
	return _gFOC_Ctrl.params.s_maxRPM;
}

void PMSM_FOC_VbusVoltage(float vbusVol) {
	_gFOC_Ctrl.in.s_vDC = vbusVol;
}

void PMSM_FOC_SetCtrlMode(u8 mode) {
	_gFOC_Ctrl.in.n_ctlMode = mode;
}

void PMSM_FOC_SetOpenVdq(float vd, float vq) {
	FOC_Set_vDqRamp(&_gFOC_Ctrl.vdq_ctl[0], vd);
	FOC_Set_vDqRamp(&_gFOC_Ctrl.vdq_ctl[1], vq);
}


bool PMSM_FOC_EnableCruise(bool enable) {
	if (enable != _gFOC_Ctrl.in.b_cruiseEna) {
		s32q4_t motSpd = PMSM_FOC_GetSpeed();
		if (motSpd < MIN_CRUISE_RPM) { //
			PMSM_FOC_SetErrCode(FOC_NowAllowed_With_Speed);
			return false;
		}
		eCtrl_set_TargetSpeed(motSpd);
		_gFOC_Ctrl.in.b_cruiseEna = enable;
	}
	
	return true;
}

bool PMSM_FOC_Is_CruiseEnabled(void) {
	return (_gFOC_Ctrl.in.b_cruiseEna && (_gFOC_Ctrl.out.n_RunMode == SPD_MODE));
}

bool PMSM_FOC_Set_Speed(float rpm) {
	if (_gFOC_Ctrl.in.b_cruiseEna) {
		return false;
	}
	eCtrl_set_TargetSpeed(rpm);
	return true;
}

bool PMSM_FOC_Set_Trque(float Trq) {
	eCtrl_set_TrqCurrent(Trq);
	return true;
}

bool PMSM_FOC_Set_CruiseSpeed(float rpm) {
	if (PMSM_FOC_Is_CruiseEnabled()) {
		eCtrl_set_TargetSpeed(rpm);
		return true;
	}
	PMSM_FOC_SetErrCode(FOC_NotCruiseMode);
	return false;
}

void PMSM_FOC_Set_Angle(float angle) {
	_gFOC_Ctrl.in.s_manualAngle = (angle);
}

s32q4_t PMSM_FOC_GetSpeed(void) {
	return _gFOC_Ctrl.in.s_motRPM;
}


void PMSM_FOC_LockMotor(bool lock) {
	_gFOC_Ctrl.in.b_motLock = lock;
}

void PMSM_FOC_SetSpdPid(float kp, float ki, float max, float min) {
	_gFOC_Ctrl.pi_ctl_spd->kp = S32Q14(kp);
	_gFOC_Ctrl.pi_ctl_spd->ki = S32Q14(ki);
	_gFOC_Ctrl.pi_ctl_spd->max = S32Q14(max);
	_gFOC_Ctrl.pi_ctl_spd->min = S32Q14(min);
}

void PMSM_FOC_SetIDPid(float kp, float ki, float max, float min) {
	_gFOC_Ctrl.pi_ctl_id->kp = S32Q14(kp);
	_gFOC_Ctrl.pi_ctl_id->ki = S32Q14(ki);
	_gFOC_Ctrl.pi_ctl_id->max = S32Q14(max);
	_gFOC_Ctrl.pi_ctl_id->min = S32Q14(min);
}

void PMSM_FOC_SetIQPid(float kp, float ki, float max, float min) {
	_gFOC_Ctrl.pi_ctl_iq->kp = S32Q14(kp);
	_gFOC_Ctrl.pi_ctl_iq->ki = S32Q14(ki);
	_gFOC_Ctrl.pi_ctl_iq->max = S32Q14(max);
	_gFOC_Ctrl.pi_ctl_iq->min = S32Q14(min);
}

void PMSM_FOC_SetTrqPid(float kp, float ki, float max, float min) {

}

void PMSM_FOC_SetFW_I(float kp, float ki, float max, float min) {
	_gFOC_Ctrl.pi_ctl_fw->kp = S32Q14(kp);
	_gFOC_Ctrl.pi_ctl_fw->ki = S32Q14(ki);
	_gFOC_Ctrl.pi_ctl_fw->max = S32Q14(max);
	_gFOC_Ctrl.pi_ctl_fw->min = S32Q14(min);
}

void PMSM_FOC_SetErrCode(u8 error) {
	if (_gFOC_Ctrl.out.n_Error != error) {
		_gFOC_Ctrl.out.n_Error = error;
	}
}

u8 PMSM_FOC_GetErrCode(void) {
	return _gFOC_Ctrl.out.n_Error;
}

//获取母线电流
s16q5_t PMSM_FOC_Get_iDC(void) {
	s32 vd = _gFOC_Ctrl.out.s_OutVdq.d;
	s32 vq = _gFOC_Ctrl.out.s_OutVdq.q;
	s32 id = _gFOC_Ctrl.out.s_RealIdq.d;
	s32 iq = _gFOC_Ctrl.out.s_RealIdq.q;
    /*
		根据公式（等幅值变换，功率不等）:
		iDC x vDC = 2/3(iq x vq + id x vd);
	*/
	s32 m_pow = (vd * id + vq * iq); //s32q10
	s16 iDC = m_pow / _gFOC_Ctrl.in.s_vDC; //s16q5
	return S16Q5toF(iDC) * 0.667f;
}

void PMSM_FOC_Brake(bool brake) {
	_gFOC_Ctrl.in.b_eBrake = brake;
	if (!_gFOC_Ctrl.in.b_motEnable) {
		return;
	}
	if (_gFOC_Ctrl.in.b_eBrake & _gFOC_Ctrl.in.b_cruiseEna) {
		_gFOC_Ctrl.in.b_cruiseEna = false;
	}
	eCtrl_brake_signal(brake);
}