MC100/Applications/foc/motor/motor.c

#include "foc/motor/motor.h"
#include "foc/motor/current.h"
#include "foc/core/foc_core.h"
#include "foc/foc_config.h"
#include "foc/samples.h"
#include "math/fast_math.h"
#include "bsp/timer_count32.h"
#include "libs/time_measure.h"
#include "os/os_task.h"
#include "bsp/delay.h"
#include "bsp/bsp.h"
#include "bsp/adc.h"
#include "bsp/pwm.h"

static bool _motor_started = false;
static float _motor_throttle = 0;
static u32 mc_main_task_handler(void *param);

void mc_init(void) {
	PMSM_FOC_CoreInit();
	shark_task_create(mc_main_task_handler, NULL);
}

bool mc_start(u8 mode) {
	if (_motor_started) {
		return true;
	}
	if (mode > TRQ_MODE) {
		PMSM_FOC_SetErrCode(FOC_Param_Err);
		return false;
	}
	if (PMSM_FOC_GetSpeed() > 10) {
		PMSM_FOC_SetErrCode(FOC_NowAllowed_With_Speed);
		return false;
	}
	if (!mc_throttle_released()) {
		PMSM_FOC_SetErrCode(FOC_Throttle_Err);
		return false;
	}
	pwm_turn_on_low_side();
	task_udelay(500);
	phase_current_calibrate();
	PMSM_FOC_Start(mode);
	pwm_start();
	adc_start_convert();
	_motor_throttle = 0;
	_motor_started = true;
	return true;
}

bool mc_stop(void) {
	if (!_motor_started) {
		return true;
	}
	if (PMSM_FOC_GetSpeed() > 10) {
		PMSM_FOC_SetErrCode(FOC_NowAllowed_With_Speed);
		return false;
	}
	if (!mc_throttle_released()) {
		PMSM_FOC_SetErrCode(FOC_Throttle_Err);
		return false;
	}	
	adc_stop_convert();
	pwm_stop();
	PMSM_FOC_Stop();
	_motor_started = false;
	return true;
}

void mc_hall_calibrate(s16 vd) {
	if (PMSM_FOC_Is_Start()) {
		return;
	}
	pwm_turn_on_low_side();
	task_udelay(500);
	phase_current_calibrate();
	PMSM_FOC_Start(OPEN_MODE);
	pwm_start();
	adc_start_convert();
	PMSM_FOC_Set_Vdq(vd, 0);
	delay_ms(1000);

	for (int i = 0; i < 5; i++) {
		for (s16 angle = 0; angle < 360; angle++) {
			PMSM_FOC_Set_Angle(angle);
		}
	}
	delay_ms(1000);

	adc_stop_convert();

	pwm_stop();

	PMSM_FOC_Stop();
}

bool mc_lock_motor(bool lock) {
	if (lock && (PMSM_FOC_GetSpeed() > 10)) {
		PMSM_FOC_SetErrCode(FOC_NowAllowed_With_Speed);
		return false;
	}
	PMSM_FOC_LockMotor(lock); //if mot enabled, foc core will do lock
	if (!_motor_started) {
		if (lock) {
			pwm_start();
			pwm_update_duty(0, 0, 0);
		}else {
			pwm_update_duty(FOC_PWM_Half_Period/2, FOC_PWM_Half_Period/2, FOC_PWM_Half_Period/2);
			pwm_stop();
		}
	}
	return true;
}


bool mc_throttle_released(void) {
	return get_throttle_float() < THROTTLE_LOW_VALUE;
}

static float _get_speed_from_throttle(float throttle) {
	float f_throttle = (throttle);
	if (f_throttle <= (THROTTLE_LOW_VALUE)) {
		return 0;
	}
	float delta = f_throttle - (THROTTLE_LOW_VALUE);

	float ration = delta / (THROTTLE_MAX_VALUE - THROTTLE_LOW_VALUE);

	return (THROTTLE_MIN_RPM + PMSM_FOC_GetSpeedLimit() * ration);
}

static float _get_idq_from_throttle(float throttle) {
	float f_throttle = (throttle);
	if (f_throttle <= (THROTTLE_LOW_VALUE)) {
		return 0;
	}
	float delta = f_throttle - (THROTTLE_LOW_VALUE);

	float ration = delta / (THROTTLE_MAX_VALUE - THROTTLE_LOW_VALUE);

	return (THROTTLE_MIN_IDQ + MAX_iDQ * ration);
}

/*do 50 times filter*/
static void brake_timer_handler(shark_timer_t *t) {
	int count = 50;
	int settimes = 0;
	while(count-- >= 0) {
		bool b1 = gpio_input_bit_get(GPIOB, GPIO_PIN_4) == SET;
		bool b2 = gpio_input_bit_get(GPIOB, GPIO_PIN_5) == SET;
		if (b1 && b2) {
			settimes++;
		}		
	}
	if (settimes == 0) {
		PMSM_FOC_Brake(true);
	}else if (settimes == 50) {
		PMSM_FOC_Brake(false);
	}else {
		//有干扰，do nothing
	}
}

static shark_timer_t _brake_timer = TIMER_INIT(_brake_timer, brake_timer_handler);

void mc_brake_handler(void){
	shark_timer_post(&_brake_timer, 0);
}
void mc_pwm_up_handler(void){
	phase_current_adc_triger();
}

measure_time_t g_meas_foc = {.exec_max_time = 15,};
#define TIME_MEATURE_START() time_measure_start(&g_meas_foc)
#define TIME_MEATURE_END() time_measure_end(&g_meas_foc)

/*ADC 电流采集中断，调用FOC的核心处理函数*/
void mc_phase_current_handler(void) {
	if (phase_current_offset()) {//check if is adc offset checked
		return;
	}
	TIME_MEATURE_START();
	PMSM_FOC_Schedule();
	TIME_MEATURE_END();
}

static u32 mc_main_task_handler(void *param) {
	if (_motor_started) {
		if (get_throttle_float() != _motor_throttle) {
			_motor_throttle = get_throttle_float();
			float speed_Ref = _get_speed_from_throttle(_motor_throttle);
			PMSM_FOC_Set_Speed(speed_Ref);
			float torque_idq = _get_idq_from_throttle(_motor_throttle);
			PMSM_FOC_Set_Current(torque_idq);
		}
	}
	return 0;
}