Motor_PMSM/Application/FOC/foc_api.c

#include <string.h>
#include "libs/task.h"
#include "bsp/bsp.h"
#include "foc/foc_api.h"
#include "foc/park_clark.h"
#include "foc/svpwm.h"
#include "foc/foc_core.h"
#include "foc/foc_stm.h"
#include "foc/phase_current.h"
#include "foc/hall_sensor.h"
#include "foc/vbus_sensor.h"
#include "foc/ntc_sensor.h"
#include "foc/gas_sensor.h"

extern motor_foc_t g_foc;
static u32 foc_measure_task(void);
static void foc_defulat_value(void);

void foc_init(void) {
	foc_defulat_value();
	
	HAL_ADC1_Enable();
	/* init pwm hardware timer */
	PWM_TimerEnable();
	/* enable tim4 to run the foc normal task */
	TIM4_Enable();

	hall_sensor_init();
	vbus_sensor_init();
	ntc_sensor_init();

	task_start(foc_measure_task, 0);
}

static void foc_defulat_value(void){
	g_foc.state = IDLE;
	g_foc.mosfec_gate = false;
	g_foc.vbus = MAX_VBUS_VOLTAGE;
	g_foc.state = IDLE;
	g_foc.mode = FOC_MODE_OPEN_LOOP;
	g_foc.alpha_beta.alpha = 0;
	g_foc.alpha_beta.beta = 0;
	g_foc.dq_command.Id = 0;
	g_foc.dq_command.Iq = 0;
	g_foc.foc_fault = foc_success;
	g_foc.is_ready = false;
	g_foc.speed_command = -1;
	memset(&g_foc.phase_time, 0, sizeof(g_foc.phase_time));
	g_foc.sector = 0;
	g_foc.dq_last.Id = 0;
	g_foc.dq_last.Iq = 0;
	phase_current_init(&g_foc.current_samp);
	ramp_ctrl_init(&g_foc.voltage_ramp);
	ramp_ctrl_init(&g_foc.current_ramp);
	ramp_ctrl_init(&g_foc.speed_ramp);
	pi_clear(&g_foc.id_controller);
	pi_clear(&g_foc.iq_controller);
	pi_clear(&g_foc.speed_controller);	
}

float speed_to_voltage(u16 rpm) {
	return foc_get_vbus_voltage() * rpm / MAX_SPEED_RPM;
}

float speed_to_current(u16 rpm) {
	return MAX_CURRENT * rpm / MAX_SPEED_RPM;
}

void foc_clear(void) {
	PWM_Stop();
	g_foc.mosfec_gate = false;
	foc_defulat_value();
	hall_sensor_init();
}

u32 foc_get_speed(void) {
	float speed = hall_sensor_avg_speed()/(g_foc.motor_param.poles);
	//printf("avg speed %f, %d\n", speed, g_foc.motor_p.poles);
	return abs(speed);
}

bool foc_is_ready(void){
	return g_foc.is_ready;
}

foc_fault_t foc_set_ready(bool ready) {
	if (ready == foc_is_ready()) {
		return foc_success;
	}
	normal_task_enable(false);
	if (foc_stm_nextstate(ready?START:ANY_STOP) == NoError) {
		g_foc.is_ready = ready;
		normal_task_enable(true);
		return foc_success;
	}	
	normal_task_enable(true);
	return foc_not_allowed;
}

void foc_set_dq_command(float d, float q) {
	g_foc.dq_command.Vd = d;
	g_foc.dq_command.Vq = q;
}

void foc_set_voltage_ramp(float final){
	printf("voltage %f\n", final);
	ramp_set_target(&g_foc.voltage_ramp, g_foc.dq_last.Vq, final, START_RAMP_DURATION);
	ramp_exc(&g_foc.voltage_ramp);
}

void foc_set_speed_ramp(u16 rpm){
	ramp_set_target(&g_foc.speed_ramp, foc_get_speed(), rpm, SPEED_RAMP_DURATION);
	ramp_exc(&g_foc.speed_ramp);
}

void foc_set_controller_mode(control_mode_t mode) {
	g_foc.mode = mode;
}
/*
void foc_set_start_ramp(float v) {
	ramp_set_target(&g_foc.voltage_ramp, g_foc.dq_v.Vq, v, START_RAMP_DURATION);
}*/

void foc_set_ref_speed(u16 rpm) {
	normal_task_enable(false);
	if (g_foc.state == IDLE || g_foc.state == ANY_STOP) {
		normal_task_enable(true);
		return;
	}
	g_foc.speed_command = rpm;
	if (g_foc.mode == FOC_MODE_OPEN_LOOP) {
		foc_set_voltage_ramp(speed_to_voltage(rpm));
	}
	normal_task_enable(true);
}

foc_fault_t foc_start_motor(void){
	return foc_stm_nextstate(START);
}

foc_fault_t foc_stop_motor(void) {
	return foc_stm_nextstate(ANY_STOP);
}

void foc_current_calibrate(void){
	g_foc.current_samp.adc_offset_a = 0;
	g_foc.current_samp.adc_offset_b = 0;
	g_foc.current_samp.adc_offset_c = 0;

	PWM_Disable_Channels();
	//foc_pwm_start(false);

	task_udelay(10);
	
	phase_current_init(&g_foc.current_samp);
	g_foc.current_samp.is_calibrating = true;
	g_foc.current_samp.sector = SECTOR_5;
	foc_pwm_start(true);
	HAL_ADC1_InJ_StartConvert();
	while(g_foc.current_samp.offset_sample_count != 0){};
	
	foc_pwm_start(false);
	task_udelay(100);
	phase_current_init(&g_foc.current_samp);	
	g_foc.current_samp.sector = SECTOR_1;
	foc_pwm_start(true);
	while(g_foc.current_samp.offset_sample_count != 0){};
	g_foc.current_samp.is_calibrating = false;
	foc_pwm_start(false);
	PWM_Enable_Channels();
}

float foc_get_vbus_voltage(void){
	return g_foc.vbus;
}
static u32 foc_measure_task(void){
	vbus_sample_voltage();
	ntc_sensor_sample();
	LowPass_Filter(g_foc.vbus, vbus_get_voltage(), 0.1f);
	wdog_reload();
	return 1;
}