永磁同步电机无感FOC（龙伯格观测器）算法技术总结-实战篇

文章目录

  • 1、ST龙伯格算法分析（定点数）
    • 1.1 符号说明
    • 1.2 最大感应电动势计算
    • 1.3 系数计算
    • 1.4 龙伯格观测器计算
    • 1.5 锁相环计算
    • 1.6 观测器增益计算
    • 1.7 锁相环PI计算（ST）
    • 1.8 平均速度的用意
  • 2、启动策略
    • 2.1 V/F压频比控制
    • 2.2 I/F压频比控制
  • 3、算法开发
    • 3.1 Luenberger核心算法模块
      • 3.1.1 Luenberger.h
      • 3.1.2 Luenberger.c
    • 3.2 三段式启动状态机模块
      • 3.2.1 mc_statemachine.h
      • 3.2.2 mc_statemachine.c
    • 3.3 初始化及函数调用
      • 3.3.1 初始化
      • 3.3.2 反馈速度处理
      • 3.3.3 FOC模块处理

龙伯格观测+PLL理论篇： https://blog.csdn.net/qq_28149763/article/details/136346434
说明：关键代码已在本文给出（源码不开源，抱歉）

1、ST龙伯格算法分析（定点数）

1.1 符号说明

在这里插入图片描述

1.2 最大感应电动势计算

在这里插入图片描述

1.3 系数计算

在这里插入图片描述

1.4 龙伯格观测器计算

在这里插入图片描述

1.5 锁相环计算

在这里插入图片描述

1.6 观测器增益计算

在这里插入图片描述
在这里插入图片描述

1.7 锁相环PI计算（ST）

在这里插入图片描述

1.8 平均速度的用意

在这里插入图片描述

2、启动策略

在这里插入图片描述

2.1 V/F压频比控制

在这里插入图片描述

2.2 I/F压频比控制

在这里插入图片描述

3、算法开发

在这里插入图片描述

3.1 Luenberger核心算法模块

3.1.1 Luenberger.h

/**
  ******************************************************************************
  * @file    Luenberger.h
  * @author  hlping
  * @version V1.0.0
  * @date    2023-12-28
  * @brief   
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */

#ifndef __LUENBERGER_H
#define __LUENBERGER_H

/* *INDENT-OFF* */
#ifdef __cplusplus
extern "C"
{
    #endif

    /* Includes -----------------------------------------------------------------*/
    #include <types.h>
    #include "mc_math.h"
    #include "foc.h"

    /* Macros -------------------------------------------------------------------*/
    #define BUFFER_SIZE (u16)64
    #define BUF_POW2    LOG2(BUFFER_SIZE)

    #define F1            (s16)(16384)
    #define F2            (s16)(8192)
    #define F1LOG         LOG2(F1)
    #define F2LOG         LOG2(F2)

    #define PLL_KP_F      (s16)(16384)
    #define PLL_KI_F      (u16)(65535)
    #define KPLOG         LOG2(PLL_KP_F)
    #define KILOG         LOG2(PLL_KI_F)
    #define PI 			      3.14159265358979

    #define VARIANCE_THRESHOLD  0.0625            

    typedef struct
    {
        s32 K1;
        s32 K2;
        s16 hC2;
        s16 hC4;
        s16 hF1;
        s16 hF2;
        s16 hF3;
        s16 hC1;
        s16 hC3;
        s16 hC5;
        s16 hC6;
        s32 wIalfa_est;
        s32 wIbeta_est;
        s32 wBemf_alfa_est;
        s32 wBemf_beta_est;
        s32 hBemf_alfa_est;
        s32 hBemf_beta_est;
    }STO_Observer_t;

    typedef struct
    {
        s16 Rs;
        u16 Rs_factor;
        s16 Ls;
        u32 Ls_factor;
        u16 Pole;
        u16 pwm_frequency;
        u32 max_speed_rpm;
        s16 max_voltage;
        s16 max_current;
        s16 motor_voltage_constant;
        s16 motor_voltage_constant_factor;
        float motor_voltage_constant_f;
        u16 max_bemf_voltage;
    }STO_Parameter_t;

    typedef struct
    {
        bool_t Max_Speed_Out;
        bool_t Min_Speed_Out;
        bool_t Is_Speed_Reliable;
        s16 hSpeed_Buffer[BUFFER_SIZE];
        u16 bSpeed_Buffer_Index;
        s32 wMotorMaxSpeed_dpp;
        u16 hPercentageFactor;
        s16 hRotor_Speed_dpp;
        s32 wSpeed_PI_integral_sum;
        s16 hSpeed_P_Gain;
        s16 hSpeed_I_Gain;
        s32 speed_sum;
    }STO_Speed_t;

    typedef struct
    {
        STO_Observer_t STO_Observer;
        STO_Speed_t STO_Speed;
        STO_Parameter_t STO_Parameter;
        s16 hRotor_El_Angle;
        s16 hRotor_Speed;
        s16 hLast_Rotor_Speed;
        s16 hRotor_avSpeed;
    }STO_luenberger;

    /* Typedefs -----------------------------------------------------------------*/


    /* Function declarations ----------------------------------------------------*/
    void STO_InitSpeedBuffer(STO_luenberger *pHandle);
    void STO_Init(STO_luenberger *pHandle);
    void STO_Update_Constant(STO_luenberger *pHandle);
    void STO_Set_k1k2(STO_luenberger *pHandle,s32 pk1,s32 pk2);
    void STO_PLL_Set_Gains(STO_luenberger *pHandle,s16 pkp,s16 pki);
    void STO_Gains_Init(STO_luenberger *pHandle);
    s16 Speed_PI(STO_luenberger *pHandle,s16 hAlfa_Sin, s16 hBeta_Cos);
    s16 Calc_Rotor_Speed(STO_luenberger *pHandle,s16 hBemf_alfa, s16 hBemf_beta);
    void Store_Rotor_Speed(STO_luenberger *pHandle,s16 hRotor_Speed);
    s16 STO_Get_Speed(STO_luenberger *pHandle);
    s16 STO_Get_Electrical_Angle(STO_luenberger *pHandle);
    void STO_Set_Electrical_Angle(STO_luenberger *pHandle,s16 eiAngle);
    void STO_Calc_Speed(STO_luenberger *pHandle);
    void STO_CalcElAngle(STO_luenberger *pHandle,FOCVars_t *pfoc, s16 hBusVoltage);


    /* *INDENT-OFF* */
    #ifdef __cplusplus
}
#endif
/* *INDENT-ON* */

#endif /* __LUENBERGER_H */

/**** END OF FILE ****/

3.1.2 Luenberger.c

在这里插入图片描述

/**
  ******************************************************************************
  * @file    Luenberger.c
  * @author  hlping
  * @version V1.0.0
  * @date    2023-12-28
  * @brief   
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "Luenberger.h"

/* Private define ------------------------------------------------------------*/

/**
* @brief 初始化观测器速度缓冲区
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @return 无返回值
*/
void STO_InitSpeedBuffer(STO_luenberger *pHandle)
{
	u8 i;

	/*init speed buffer*/
	for (i=0;i<BUFFER_SIZE;i++)
	{
		pHandle->STO_Speed.hSpeed_Buffer[i] = 0x00;
	}
	pHandle->STO_Speed.bSpeed_Buffer_Index = 0;
}

/**
* @brief 初始化观测器
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @return 无返回值
*/
void STO_Init(STO_luenberger *pHandle)
{
	pHandle->STO_Observer.wIalfa_est = 0;
	pHandle->STO_Observer.wIbeta_est = 0;
	pHandle->STO_Observer.wBemf_alfa_est = 0;
	pHandle->STO_Observer.wBemf_beta_est = 0;
	
	pHandle->STO_Speed.Is_Speed_Reliable = FALSE;
	pHandle->STO_Speed.wSpeed_PI_integral_sum = 0;
	pHandle->STO_Speed.Max_Speed_Out = FALSE;
	pHandle->STO_Speed.Min_Speed_Out = FALSE;
	pHandle->STO_Speed.hRotor_Speed_dpp = 0;
	pHandle->STO_Speed.speed_sum = 0;
	
	pHandle->hRotor_avSpeed=0;
	pHandle->hRotor_El_Angle = 0;            //could be used for start-up procedure
	pHandle->hRotor_avSpeed = 0;

	STO_InitSpeedBuffer(pHandle);

//	hSpeed_P_Gain = 1638;  //0.1*16384
//	hSpeed_I_Gain = 0;
}

/**
* @brief 设置观测器增益参数
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @param pk1 增益参数1
* @param pk2 增益参数2
* @return 无返回值
*/
void STO_Set_k1k2(STO_luenberger *pHandle,s32 pk1,s32 pk2)
{
  pHandle->STO_Observer.K1 = pk1;
	pHandle->STO_Observer.K2 = pk2;
}

/**
* @brief 设置观测器PLL增益参数
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @param pkp PLL比例增益参数
* @param pki PLL积分增益参数
* @return 无返回值
*/
void STO_PLL_Set_Gains(STO_luenberger *pHandle,s16 pkp,s16 pki)
{
  pHandle->STO_Speed.hSpeed_P_Gain = pkp;
	pHandle->STO_Speed.hSpeed_I_Gain = pki;
}

/**
* @brief 更新观测器常数参数
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @return 无返回值
*/
void STO_Update_Constant(STO_luenberger *pHandle)
{
	float temp_rs;
	float temp_ls;
	
	temp_rs=pHandle->STO_Parameter.Rs/(float)pHandle->STO_Parameter.Rs_factor;
	temp_ls=pHandle->STO_Parameter.Ls/(float)pHandle->STO_Parameter.Ls_factor;
	
  pHandle->STO_Observer.hC1 = (s32)(pHandle->STO_Observer.hF1 * temp_rs/(temp_ls*pHandle->STO_Parameter.pwm_frequency));
	//pHandle->STO_Observer.hC2 = (s32)(hF1 * k1/(float)(pHandle->STO_Parameter.pwm_frequency));
	pHandle->STO_Observer.hC2 = (s32)(pHandle->STO_Observer.K1);//�����Ǵ������ģ�����Ҫ�ڳ���Ƶ��
	pHandle->STO_Observer.hC3 = (s32)(pHandle->STO_Observer.hF1 * pHandle->STO_Parameter.max_bemf_voltage/(temp_ls*pHandle->STO_Parameter.max_current*pHandle->STO_Parameter.pwm_frequency));
	//pHandle->STO_Observer.hC4 = (s32)(((k2 * max_current/(max_bemf_voltage))*hF2)/(float)pHandle->STO_Parameter.pwm_frequency);
	//pHandle->STO_Observer.hC4 = (s32)(hF1 * k2/(float)(pHandle->STO_Parameter.pwm_frequency));
	pHandle->STO_Observer.hC4 = (s32)(pHandle->STO_Observer.K2);//�����Ǵ������ģ�����Ҫ�ڳ���Ƶ��
  pHandle->STO_Observer.hC5 = (s32)(pHandle->STO_Observer.hF1 * pHandle->STO_Parameter.max_voltage/(temp_ls*pHandle->STO_Parameter.max_current*pHandle->STO_Parameter.pwm_frequency));

//	hC1 = pHandle->STO_Observer.hC1;
//	hC2 = pHandle->STO_Observer.hC2;
//	hC3 = pHandle->STO_Observer.hC3;
//	hC4 = pHandle->STO_Observer.hC4;
//	hC5 = pHandle->STO_Observer.hC5;
}

/**
* @brief 初始化观测器增益参数
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @return 无返回值
*/
void STO_Gains_Init(STO_luenberger *pHandle)
{
	s16 htempk;
		
	pHandle->STO_Observer.hF3 = 1;
	htempk = (s16)((100*65536)/(F2*2*PI));	//100 rad/s
	while (htempk != 0)
	{
		htempk /= 2;
		pHandle->STO_Observer.hF3 *= 2;
	}
	pHandle->STO_Observer.hC6 = (s16)((F2 * pHandle->STO_Observer.hF3 * 2 * PI)/65536);//10000
	
	pHandle->STO_Observer.hF1 = F1;
	pHandle->STO_Observer.hF2 = F2;
	
	pHandle->STO_Parameter.motor_voltage_constant_f = (float)(pHandle->STO_Parameter.motor_voltage_constant/(float)pHandle->STO_Parameter.motor_voltage_constant_factor);
	pHandle->STO_Parameter.max_bemf_voltage = (u16)((1.2 * pHandle->STO_Parameter.max_speed_rpm*pHandle->STO_Parameter.motor_voltage_constant_f*SQRT_2)/(1000*SQRT_3));
//	pHandle->STO_Parameter.max_current = (u16)(pHandle->STO_Parameter.max_current);
//	pHandle->STO_Parameter.max_voltage = (s16)(pHandle->STO_Parameter.max_voltage);
	
  STO_Update_Constant(pHandle);
	
//	hSpeed_P_Gain = PLL_KP_GAIN;
//	hSpeed_I_Gain = PLL_KI_GAIN;

	pHandle->STO_Speed.wMotorMaxSpeed_dpp = (s32)((1.2 * pHandle->STO_Parameter.max_speed_rpm*65536*pHandle->STO_Parameter.Pole)/(float)(pHandle->STO_Parameter.pwm_frequency*60));
	pHandle->STO_Speed.hPercentageFactor = (u16)(VARIANCE_THRESHOLD*128);
}


/**
* @brief 计算电机旋转速度的PID控制器
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @param hAlfa_Sin e_alpha*sin
* @param hBeta_Cos e_beta*cos
* @return 返回计算得到的电机旋转速度
*/
s16 Speed_PI(STO_luenberger *pHandle,s16 hAlfa_Sin, s16 hBeta_Cos)
{
	s32 wSpeed_PI_error, wOutput;
	s32 wSpeed_PI_proportional_term, wSpeed_PI_integral_term;

	wSpeed_PI_error = hBeta_Cos - hAlfa_Sin;
#if 0		//????
	if(wSpeed_PI_error > 50)
		wSpeed_PI_error = 50;
	else if(wSpeed_PI_error < -50)
		wSpeed_PI_error = -50;
#endif
	wSpeed_PI_proportional_term = pHandle->STO_Speed.hSpeed_P_Gain * wSpeed_PI_error;  // !!!p
	wSpeed_PI_integral_term = pHandle->STO_Speed.hSpeed_I_Gain * wSpeed_PI_error;      // !!!i

	if ( (pHandle->STO_Speed.wSpeed_PI_integral_sum >= 0) && (wSpeed_PI_integral_term >= 0) && (pHandle->STO_Speed.Max_Speed_Out == FALSE) )
	{
		if ((s32)(pHandle->STO_Speed.wSpeed_PI_integral_sum + wSpeed_PI_integral_term) < 0)
		{
			pHandle->STO_Speed.wSpeed_PI_integral_sum = S32_MAX;
		}
		else
		{
			pHandle->STO_Speed.wSpeed_PI_integral_sum += wSpeed_PI_integral_term;  //integral
		}
	}
	else if ( (pHandle->STO_Speed.wSpeed_PI_integral_sum <= 0) && (wSpeed_PI_integral_term <= 0) && (pHandle->STO_Speed.Min_Speed_Out == FALSE) )
	{
		if((s32)(pHandle->STO_Speed.wSpeed_PI_integral_sum + wSpeed_PI_integral_term) > 0)
		{
			pHandle->STO_Speed.wSpeed_PI_integral_sum = -S32_MAX;
		}
		else
		{
			pHandle->STO_Speed.wSpeed_PI_integral_sum += wSpeed_PI_integral_term;   //integral
		}
	}
	else
	{
		pHandle->STO_Speed.wSpeed_PI_integral_sum += wSpeed_PI_integral_term;   //integral
	}

	wOutput = (wSpeed_PI_proportional_term >> KPLOG) + (pHandle->STO_Speed.wSpeed_PI_integral_sum >> KILOG);

	if (wOutput > pHandle->STO_Speed.wMotorMaxSpeed_dpp)
	{
		pHandle->STO_Speed.Max_Speed_Out = TRUE;
		wOutput = pHandle->STO_Speed.wMotorMaxSpeed_dpp;
	}
	else if (wOutput < (-pHandle->STO_Speed.wMotorMaxSpeed_dpp))
	{
		pHandle->STO_Speed.Min_Speed_Out = TRUE;
		wOutput = -pHandle->STO_Speed.wMotorMaxSpeed_dpp;
	}
	else
	{
		pHandle->STO_Speed.Max_Speed_Out = FALSE;
		pHandle->STO_Speed.Min_Speed_Out = FALSE;
	}

  return ((s16)wOutput);
}

/**
* @brief 锁相环计算电机控制器旋转速度
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @param hBemf_alfa BEMF alpha轴反电动势观测值
* @param hBemf_beta BEMF beta轴反电动势观测值
* @return 返回计算得到的电机旋转速度
*/
s16 Calc_Rotor_Speed(STO_luenberger *pHandle,s16 hBemf_alfa, s16 hBemf_beta)
{
	s32 wAlfa_Sin_tmp, wBeta_Cos_tmp;
	s16 hOutput;
	Trig_Components Local_Components;

	Local_Components = Trig_Functions(pHandle->hRotor_El_Angle);

	/* Alfa & Beta BEMF multiplied by hRotor_El_Angle Cos & Sin*/
	wAlfa_Sin_tmp = (s32)(hBemf_alfa * Local_Components.hSin);
	wBeta_Cos_tmp = (s32)(hBemf_beta * Local_Components.hCos);
	//alfa_sin_test = wAlfa_Sin_tmp >> 15;
	//beta_cos_test = wBeta_Cos_tmp >> 15;
	/* Speed PI regulator */
	hOutput = Speed_PI(pHandle,(s16)(wAlfa_Sin_tmp >> 15), (s16)(wBeta_Cos_tmp >> 15));

	return (hOutput);
}

/**
* @brief 将电机旋转速度存储数组中
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @param hRotor_Speed 要存储的电机旋转速度
* @return 无返回值
*/
void Store_Rotor_Speed(STO_luenberger *pHandle,s16 hRotor_Speed)
{
	static s32 start_flag;

	pHandle->STO_Speed.hSpeed_Buffer[pHandle->STO_Speed.bSpeed_Buffer_Index] = hRotor_Speed;
	pHandle->STO_Speed.speed_sum += pHandle->STO_Speed.hSpeed_Buffer[pHandle->STO_Speed.bSpeed_Buffer_Index];
	if(++(pHandle->STO_Speed.bSpeed_Buffer_Index) >= BUFFER_SIZE) //16
	{
		pHandle->STO_Speed.bSpeed_Buffer_Index = 0;
		start_flag = 1;
	}
	if(start_flag == 0)
	{
		pHandle->hRotor_avSpeed = pHandle->STO_Speed.speed_sum / pHandle->STO_Speed.bSpeed_Buffer_Index;
	}
	else
	{
		pHandle->hRotor_avSpeed = pHandle->STO_Speed.speed_sum >> BUF_POW2;
		pHandle->STO_Speed.speed_sum -= pHandle->STO_Speed.hSpeed_Buffer[pHandle->STO_Speed.bSpeed_Buffer_Index];
	}
	pHandle->STO_Speed.hRotor_Speed_dpp = pHandle->hRotor_avSpeed;
/*
	bSpeed_Buffer_Index++;
	if (bSpeed_Buffer_Index == BUFFER_SIZE) //64
	{
		bSpeed_Buffer_Index = 0;
		STO_Calc_Speed();
	}
	hSpeed_Buffer[bSpeed_Buffer_Index] = hRotor_Speed;
*/
}

/**
* @brief 获取电机旋转速度
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @return 返回电机旋转速度
*/
s16 STO_Get_Speed(STO_luenberger *pHandle)
{
	return (pHandle->hRotor_avSpeed);
}

/**
* @brief 获取电机转子的电角度
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @return 返回电机电角位
*/
s16 STO_Get_Electrical_Angle(STO_luenberger *pHandle)
{
	return (pHandle->hRotor_El_Angle);
}

/**
* @brief 设置电机转子的电角度
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @param eiAngle 设置的电机电角位
* @return 无返回值
*/
void STO_Set_Electrical_Angle(STO_luenberger *pHandle,s16 eiAngle)
{
	pHandle->hRotor_El_Angle = eiAngle;
}

/**
* @brief 计算观测速度
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @return 无返回值
*/
void STO_Calc_Speed(STO_luenberger *pHandle)
{
	s32 wAverage_Speed = 0;
	s32 wError;
	s32 wAverageQuadraticError = 0;
	u8 i;

	for (i = 0; i < BUFFER_SIZE; i++)
	{
		wAverage_Speed += pHandle->STO_Speed.hSpeed_Buffer[i];
	}

	wAverage_Speed = wAverage_Speed >> BUF_POW2;

	pHandle->STO_Speed.hRotor_Speed_dpp = (s16)(wAverage_Speed);

	for (i = 0; i < BUFFER_SIZE; i++)
	{
		wError = pHandle->STO_Speed.hSpeed_Buffer[i] - wAverage_Speed;
		wError = (wError * wError);
		wAverageQuadraticError += (u32)(wError);
	}

	//It computes the measurement variance
	wAverageQuadraticError= wAverageQuadraticError >> BUF_POW2;

	//The maximum variance acceptable is here calculated as ratio of average speed
	wAverage_Speed = (s32)(wAverage_Speed * wAverage_Speed);
	wAverage_Speed = (wAverage_Speed >> 7) * pHandle->STO_Speed.hPercentageFactor;

#if 0 // for debug only
	QuadraticError = wAverageQuadraticError;
	AverageSpeed = wAverage_Speed;
#endif

	if (wAverageQuadraticError > wAverage_Speed)
	{
		pHandle->STO_Speed.Is_Speed_Reliable = FALSE;
	}
	else
	{
		pHandle->STO_Speed.Is_Speed_Reliable = TRUE;
	}
}


/**
* @brief 观测器观测电角度
* @param pHandle 指向STO_luenberger结构体的指针，用于存储控制器的状态信息
* @param pfoc 指向FOCVars_t结构体的指针，用于存储电压和电流信息
* @param hBusVoltage 输入电压
* @return 无返回值
*/
void STO_CalcElAngle(STO_luenberger *pHandle,FOCVars_t *pfoc, s16 hBusVoltage)
{
	s32 wIalfa_est_Next, wIbeta_est_Next;
	s32 wBemf_alfa_est_Next, wBemf_beta_est_Next;

	s16 hValfa, hVbeta;
	s16 hIalfa_err, hIbeta_err;
	s32 bDirection;
	s16 hRotor_Speed;

	if (pHandle->STO_Observer.wBemf_alfa_est > (s32)(S16_MAX * pHandle->STO_Observer.hF2))
	{
		pHandle->STO_Observer.wBemf_alfa_est = S16_MAX * pHandle->STO_Observer.hF2;
	}
	else if (pHandle->STO_Observer.wBemf_alfa_est <= (s32)(S16_MIN * pHandle->STO_Observer.hF2))
	{
		pHandle->STO_Observer.wBemf_alfa_est = -S16_MAX * pHandle->STO_Observer.hF2;
	}

	if (pHandle->STO_Observer.wBemf_beta_est > (s32)(S16_MAX * pHandle->STO_Observer.hF2))
	{
		pHandle->STO_Observer.wBemf_beta_est = S16_MAX * pHandle->STO_Observer.hF2;
	}
	else if (pHandle->STO_Observer.wBemf_beta_est <= (s32)(S16_MIN * pHandle->STO_Observer.hF2))
	{
		pHandle->STO_Observer.wBemf_beta_est = -S16_MAX * pHandle->STO_Observer.hF2;
	}

	if (pHandle->STO_Observer.wIalfa_est > (s32)(S16_MAX * pHandle->STO_Observer.hF1))
	{
		pHandle->STO_Observer.wIalfa_est = S16_MAX * pHandle->STO_Observer.hF1;
	}
	else if (pHandle->STO_Observer.wIalfa_est <= (s32)(S16_MIN * pHandle->STO_Observer.hF1))
	{
		pHandle->STO_Observer.wIalfa_est = -S16_MAX * pHandle->STO_Observer.hF1;
	}

	if (pHandle->STO_Observer.wIbeta_est > S16_MAX * pHandle->STO_Observer.hF1)
	{
		pHandle->STO_Observer.wIbeta_est = S16_MAX * pHandle->STO_Observer.hF1;
	}
	else if (pHandle->STO_Observer.wIbeta_est <= S16_MIN * pHandle->STO_Observer.hF1)
	{
		pHandle->STO_Observer.wIbeta_est = -S16_MAX * pHandle->STO_Observer.hF1;
	}

	hIalfa_err = (s16)((pHandle->STO_Observer.wIalfa_est >> F1LOG)- pfoc->Ialphabeta.alpha);
	hIbeta_err = (s16)((pHandle->STO_Observer.wIbeta_est >> F1LOG)- pfoc->Ialphabeta.beta);

	hValfa = (s16)((pfoc->Valphabeta.alpha * hBusVoltage) >> 15);   //�������ߵ�ѹĿ���Ǽ�С���ߵ�ѹ������ϵͳ��Ӱ��
	hVbeta = (s16)((pfoc->Valphabeta.beta * hBusVoltage) >> 15);    //�������ߵ�ѹĿ���Ǽ�С���ߵ�ѹ������ϵͳ��Ӱ��

	/*alfa axes observer*/
	wIalfa_est_Next = (s32)(pHandle->STO_Observer.wIalfa_est - (s32)(pHandle->STO_Observer.hC1 * (s16)(pHandle->STO_Observer.wIalfa_est >> F1LOG))
	                  +(s32)(pHandle->STO_Observer.hC2 * hIalfa_err)+(s32)(pHandle->STO_Observer.hC5 * hValfa)
	                  -(s32)(pHandle->STO_Observer.hC3 * (s16)(pHandle->STO_Observer.wBemf_alfa_est >> F2LOG)));
	//I(n+1)=I(n)-rs*T/Ls*I(n)+K1*(I(n)-i(n))+T/Ls*V-T/Ls*emf
	wBemf_alfa_est_Next = (s32)(pHandle->STO_Observer.wBemf_alfa_est + (s32)(pHandle->STO_Observer.hC4 * hIalfa_err)
	                      +(s32)(pHandle->STO_Observer.hC6 * pHandle->STO_Speed.hRotor_Speed_dpp * (pHandle->STO_Observer.wBemf_beta_est / (pHandle->STO_Observer.hF2 * pHandle->STO_Observer.hF3))));//(wBemf_beta_est>>20)));
	//emf(n+1)=emf(n)+K2*(I(n)-i(n))+p*w*emfb*T

	/*beta axes observer*/
	wIbeta_est_Next = (s32)(pHandle->STO_Observer.wIbeta_est - (s32)(pHandle->STO_Observer.hC1 * (s16)(pHandle->STO_Observer.wIbeta_est >> F1LOG))
						+(s32)(pHandle->STO_Observer.hC2 * hIbeta_err)+(s32)(pHandle->STO_Observer.hC5 * hVbeta)
						-(s32)(pHandle->STO_Observer.hC3 * (s16)(pHandle->STO_Observer.wBemf_beta_est >> F2LOG)));

	wBemf_beta_est_Next = (s32)(pHandle->STO_Observer.wBemf_beta_est + (s32)(pHandle->STO_Observer.hC4 * hIbeta_err)
	                       -(s32)(pHandle->STO_Observer.hC6 * pHandle->STO_Speed.hRotor_Speed_dpp * (pHandle->STO_Observer.wBemf_alfa_est / (pHandle->STO_Observer.hF2 * pHandle->STO_Observer.hF3))));//(wBemf_alfa_est>>20)));

  /* Extrapolation of present rotation direction, necessary for PLL */
	if (pHandle->STO_Speed.hRotor_Speed_dpp >= 0)
	{
		bDirection = -1;
	}
	else
	{
		bDirection = 1;
	}

  /*Calls the PLL blockset*/

	pHandle->STO_Observer.hBemf_alfa_est = pHandle->STO_Observer.wBemf_alfa_est >> F2LOG;
	pHandle->STO_Observer.hBemf_beta_est = pHandle->STO_Observer.wBemf_beta_est >> F2LOG;

	pHandle->hRotor_Speed = Calc_Rotor_Speed(pHandle,(s16)(pHandle->STO_Observer.hBemf_alfa_est * bDirection),(s16)(-pHandle->STO_Observer.hBemf_beta_est * bDirection));

	if(pfoc->Vqd.q > 0)
	{
		if(pHandle->hRotor_Speed < 0)
		{
			pHandle->hRotor_Speed = -pHandle->hRotor_Speed;
		}
	}
	else //MotorCtrl.Dir == CCW
	{
		if(pHandle->hRotor_Speed > 0)
		{
			pHandle->hRotor_Speed = -pHandle->hRotor_Speed;
		}
	}

	Store_Rotor_Speed(pHandle,pHandle->hRotor_Speed);
	pHandle->hRotor_El_Angle = (s16)(pHandle->hRotor_El_Angle + pHandle->hRotor_Speed);
	/*storing previous values of currents and bemfs*/
	pHandle->STO_Observer.wIalfa_est = wIalfa_est_Next;
	pHandle->STO_Observer.wBemf_alfa_est = wBemf_alfa_est_Next;

	pHandle->STO_Observer.wIbeta_est = wIbeta_est_Next;
	pHandle->STO_Observer.wBemf_beta_est = wBemf_beta_est_Next;
}
/**** END OF FILE ****/

3.2 三段式启动状态机模块

3.2.1 mc_statemachine.h

mc_statemachine.h定义相关变量和结构体以及函数申明：

/**
  ******************************************************************************
  * @file    mc_statemachine.h
  * @author  hlping
  * @version V1.0.0
  * @date    2022-11-28
  * @brief   
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */

#ifndef __MC_STATEMACHINE_H
#define __MC_STATEMACHINE_H

/* *INDENT-OFF* */
#ifdef __cplusplus
extern "C"
{
#endif

/* Includes -----------------------------------------------------------------*/
#include <types.h>
#include "Luenberger.h"

/* Macros -------------------------------------------------------------------*/


/* Typedefs -----------------------------------------------------------------*/
#define OPEN_LOOP		  	0
#define CLOSE_LOOP			1
#define IDLE_STATE			2
#define CLOSE_SWITCH		3

#define OPENLOOPTIMEINSEC  8.0

typedef enum{
	MOTOR_STOP=0,			
	MOTOR_INIT=1,			
	MOTOR_START=2,		
	MOTOR_RUN=3,			
	MOTOR_FAULT=4,			
	MOTOR_BRAKE=5			
} MCStatus_t;

//typedef struct
//{
//	MCStatus_t Status;
//	u32 StatusMacCnt;
//	u32 Dir;				
//	bool_t DirChangeFlag;	
//	bool_t StartupFlag;		

//	s16 SpdRampRef;		
//	s16 SpdRef;			
//}mc_control_t;

typedef struct
{
	u32 State;
	u32 Angle;
	s16 LockCnt;
	
	u16 pole;
	u32 pwm_frequency;
	float looptimeinsec;
	//u32 time;
	u32 locktime;
	u16 initialSpeedinRpm;
	u16 start_iq;
	u16 start_iq_max;
	u16 min_iq;
	u16 start_vq;
	u16 endSpeedOpenloop;
	u16 inc_iq;
	u32 ramp_time;
	u32 delta_startup_ramp;
	
	s16 ElangleError;
	bool_t speed_loop_enable;
	bool_t current_loop_enable;
}mc_openloop_t;

/* Function declarations ----------------------------------------------------*/
void mc_statemachine_init(mc_openloop_t *ploop);
void mc_statemachine_process(mc_openloop_t *popen,STO_luenberger *pHandle,FOCVars_t *pfoc,s16 hBusVoltage);
u16 mc_get_state(mc_openloop_t *ploop);
bool_t mc_get_speed_loop_enable(mc_openloop_t *ploop);
void mc_set_speed_loop_enable(mc_openloop_t *ploop,bool_t state);
bool_t mc_get_current_loop_enable(mc_openloop_t *ploop);
void mc_set_current_loop_enable(mc_openloop_t *ploop,bool_t state);
void mc_set_vf_iqRef(FOCVars_t *pfoc,int16_t piqref);
void mc_parameter_init(mc_openloop_t *ploop);

/* *INDENT-OFF* */
#ifdef __cplusplus
}
#endif
/* *INDENT-ON* */

#endif /* __MC_STATEMACHINE_H */

/**** END OF FILE ****/

3.2.2 mc_statemachine.c

在这里插入图片描述

/**
  ******************************************************************************
  * @file    mc_statemachine.c
  * @author  hlping
  * @version V1.0.0
  * @date    2023-01-08
  * @brief   
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "mc_statemachine.h"
#include "public_global.h"

/* Variable definitions ------------------------------------------------------*/
/**
* @brief 初始化电机启动控制器状态机
* @param ploop 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @return 无返回值
*/
void mc_statemachine_init(mc_openloop_t *ploop)
{
	 ploop->speed_loop_enable = FALSE;
	 ploop->current_loop_enable = FALSE;
//	 locktime = ploop->time;
//   ploop->Angle = 0;
//	 ploop->State = IDLE_STATE;
//	 ploop->LockCnt = 0;
//	 endSpeedOpenloop = ploop->endSpeedOpenloop;
	 ploop->looptimeinsec = 1/(float)ploop->pwm_frequency;
	 ploop->inc_iq = 32767 * (ploop->start_iq_max - ploop->start_iq)/ploop->locktime;
	 ploop->ramp_time = (u32)(ploop->endSpeedOpenloop * ploop->pole * 65536 * ploop->looptimeinsec * 65536 /60 );
	 ploop->delta_startup_ramp = (u32)((ploop->ramp_time/OPENLOOPTIMEINSEC)/(float)ploop->pwm_frequency);
}

/**
* @brief 处理电机启动控制器状态机
* @param popen 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @param pHandle 指向STO_luenberger结构体的指针，用于存储观测器状态
* @param pfoc 指向FOCVars_t结构体的指针，用于存储FOC相关变量
* @param hBusVoltage 输入电压，单位为V
* @return 无返回值
*/
void mc_statemachine_process(mc_openloop_t *popen,STO_luenberger *pHandle,FOCVars_t *pfoc,s16 hBusVoltage)
{
  if(popen->LockCnt >= popen->locktime && popen->State != IDLE_STATE)
		STO_CalcElAngle(pHandle,pfoc, hBusVoltage);
	
	if(popen->State == OPEN_LOOP)
	{
		if(popen->LockCnt < popen->locktime) 			//LOCK
		{
			static s32 iq_ref_temp = 0;

			if (popen->LockCnt == 0)
				iq_ref_temp = 0;
			
			popen->LockCnt++;
			
//			if( FOCVars.Vqd.q > 0)       //��ת
//				iq_ref_temp += inc_iq;
//			else if(FOCVars.Vqd.q < 0)   //��ת
//				iq_ref_temp -= inc_iq;
//			else                         //ֹͣ  
//				iq_ref_temp = 0;
			iq_ref_temp += popen->inc_iq;
			
			FOCVars.Iqdref.q = iq_ref_temp >> 15;
		}
		else if(popen->Angle < popen->ramp_time) 			//SPEED RAMP
		{
			if (popen->Angle == 0)
			{	
				//FOCVars.Vqd.q = popen->start_vq * 32767 ;
				FOCVars.Vqd.q = popen->start_vq ;
				FOCVars.Vqd.d = 0 ;
			}
			
			popen->Angle += popen->delta_startup_ramp;		
			
			if( FOCVars.Vqd.q > 0)       //正转
				FOCVars.hElAngle += (popen->Angle >> 16);
			else if(FOCVars.Vqd.q < 0)   //反转
				FOCVars.hElAngle -= (popen->Angle >> 16);		
		}
		else
		{
			popen->State = CLOSE_LOOP;
//#ifndef NDEBUG
//			OpenLoopSpeed = STO_Get_Speed();	// for test only
//#endif
			#if 0  //just for test,openloop for observation angle
			popen->speed_loop_enable = FALSE;
			popen->current_loop_enable = FALSE;
			#else
			popen->speed_loop_enable = TRUE;
			popen->current_loop_enable = TRUE;
			#endif

			popen->ElangleError = STO_Get_Electrical_Angle(pHandle) - FOCVars.hElAngle;
			//FOCVars.hElAngle = STO_Get_Electrical_Angle(pHandle);
		}
		
	}
	else if(popen->State == CLOSE_LOOP)
	{
    FOCVars.hElAngle = STO_Get_Electrical_Angle(pHandle) - popen->ElangleError;
//		FOCVars.hElAngle = STO_Get_Electrical_Angle(pHandle) - (popen->ElangleError>>2);
//		//s16 err = popen->ElangleError>>2;
//		if(popen->ElangleError > 0)
//			popen->ElangleError--;
//		else if(popen->ElangleError < 0)
//			popen->ElangleError++;

	}	
}

/**
* @brief 初始化电机控制器参数
* @param ploop 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @return 无返回值
*/
void mc_parameter_init(mc_openloop_t *ploop)
{
  ploop->State = OPEN_LOOP;     //开环启动
	ploop->Angle = 0;           //如等于RAMP_TIME就意味着跳过RAMP阶段，直接速度闭环
	ploop->LockCnt = 0;
	
	ploop->speed_loop_enable = FALSE;  
	ploop->current_loop_enable = FALSE;
}

/**
* @brief 设置电机控制器的中间变量
* @param pfoc 指向FOCVars_t结构体的指针，用于存储电机控制器的中间变量
* @param piqref 输入的iq参考值
* @return 无返回值
*/
void mc_set_vf_iqRef(FOCVars_t *pfoc,int16_t piqref)
{
   pfoc->Iqdref.q = piqref;
	 pfoc->Iqdref.d = 0;
}

/**
* @brief 获取电机控制器的状态
* @param ploop 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @return 返回控制器的状态
*/
u16 mc_get_state(mc_openloop_t *ploop)
{
   return (ploop->State);
}

/**
* @brief 获取电机控制器是否启用速度环
* @param ploop 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @return 返回true或false，表示是否启用速度环
*/
bool_t mc_get_speed_loop_enable(mc_openloop_t *ploop)
{
   return (ploop->speed_loop_enable);
}

/**
* @brief 设置电机控制器是否启用速度环
* @param ploop 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @param state 设置为true或false，表示是否启用速度环
* @return 无返回值
*/
void mc_set_speed_loop_enable(mc_openloop_t *ploop,bool_t state)
{
   ploop->speed_loop_enable = state;
}

/**
* @brief 获取电机控制器是否启用电流环
* @param ploop 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @return 返回true或false，表示是否启用电流环
*/
bool_t mc_get_current_loop_enable(mc_openloop_t *ploop)
{
   return (ploop->current_loop_enable);
}

/**
* @brief 设置电机控制器是否启用电流环
* @param ploop 指向mc_openloop_t结构体的指针，用于存储控制器的状态信息
* @param state 设置为true或false，表示是否启用电流环
* @return 无返回值
*/
void mc_set_current_loop_enable(mc_openloop_t *ploop,bool_t state)
{
   ploop->current_loop_enable = state;
}


/**** END OF FILE ****/

3.3 初始化及函数调用

定义全局变量：

STO_luenberger        STO_LBG;     //龙伯格观测器相关变量
mc_openloop_t         mc_openloop; //三段式启动相关变量

3.3.1 初始化

当编码器类型为ENCODER_TYPE_UNKNOWN时为无感运行模式：

if(sensor_peripheral.Encoder_Sensor.encType == ENCODER_TYPE_UNKNOWN)//just for sensorless
	{
		sensor_peripheral.Encoder_Sensor.encRes=65535;
			/* init Luenberger parameter */
	  STO_Parameter_t Parameter={
	     .Rs = 55,                                         //0.055 pMotorParSet.tBasePar.resist[A_AXIS]
		   .Rs_factor = 1000,
		   .Ls = 21,                                         //2.1e-4 pMotorParSet.tBasePar.inductance[A_AXIS]
		   .Ls_factor = 100000,
		   .Pole = pMotorParSet.tBasePar.poles[A_AXIS],      //4
		   .pwm_frequency = SAMPLE_FREQUENCY,                //10000
		   //.max_speed_rpm = pMotorParSet.tBasePar.ratedVel[A_AXIS]*60/sensor_peripheral.Encoder_Sensor.encRes,//rpm
			 .max_speed_rpm = 3000,//rpm
		   .max_voltage = (s16)(ProtectPar.regenOn/1000),           //36000 mV
		   //.max_current = pMotorParSet.tBasePar.maxPhaseCurr[A_AXIS]/1000,  //A
			 .max_current = 31,                                //A
		   .motor_voltage_constant = 4,                      //4v/1000rpm
		   .motor_voltage_constant_factor = 1,
	  };
		memcpy(&STO_LBG.STO_Parameter,&Parameter,sizeof(STO_Parameter_t));
		STO_Init(&STO_LBG);
	  STO_Set_k1k2(&STO_LBG,-24225,25925);
	  STO_Gains_Init(&STO_LBG);
    STO_PLL_Set_Gains(&STO_LBG,638,45);  
			
		mc_openloop_t   openloop={
		  .State= IDLE_STATE,
			.Angle = 0,
			.LockCnt = 0,
			.pole = pMotorParSet.tBasePar.poles[A_AXIS],
			.pwm_frequency = SAMPLE_FREQUENCY,
			.looptimeinsec = 1/(float)SAMPLE_FREQUENCY,
			.locktime = SAMPLES_PER_50MSECOND,
			.start_iq = 0,             //Q轴启动电流
			.start_iq_max = 3000,      //mA
			.endSpeedOpenloop = 300,   //rpm
			.start_vq = 4000,         //VF启动电压
		};
		memcpy(&mc_openloop,&openloop,sizeof(mc_openloop_t));
		mc_statemachine_init(&mc_openloop);
	}

3.3.2 反馈速度处理

在这里插入图片描述

void AxisVelocityCalc()
{

	float	ftempll;	
	
	if(sensor_peripheral.Encoder_Sensor.encType != ENCODER_TYPE_UNKNOWN)
	{
	   	pAxisPar.vel[A_AXIS][2] = sensor_peripheral.Encoder_Sensor.deltaPos * SAMPLE_FREQUENCY; //TODO: 
	    ftempll = (float) pAxisPar.vel[A_AXIS][2];
	    
	    ftempll =_filterPar._velFdk(&ftempll,&_filterPar);//250 point  1.5us
	    pAxisPar.vel[A_AXIS][1] = (long) ftempll;
	    pAxisPar.vel[A_AXIS][0] = pAxisPar.vel[A_AXIS][1];
	}else
	{
		  pAxisPar.vel[A_AXIS][2] = STO_Get_Speed(&STO_LBG)*sensor_peripheral.Encoder_Sensor.encRes/(pMotorParSet.tBasePar.poles[A_AXIS] * 2 * PI);//we->rpm->plus; //TODO: 
	    ftempll = (float) pAxisPar.vel[A_AXIS][2];
	    
	    ftempll =_filterPar._velFdk(&ftempll,&_filterPar);//250 point  1.5us
	    pAxisPar.vel[A_AXIS][1] = (long) ftempll;
	    pAxisPar.vel[A_AXIS][0] = pAxisPar.vel[A_AXIS][1];
	
	}
}

3.3.3 FOC模块处理

/**
  * @brief  FOC function
	* @param  None
  * @retval None
**/
void FOC_Model(void)
{
    FOCVars.Iqdref.q = pMotorParSet.currRef[A_AXIS];//*1.414; // RMS result
    FOCVars.Iqdref.d = 0;
//    FOC_Cal(&FOCVars);
		FOCVars.Ialphabeta = Clark(FOCVars.Iab);
		FOCVars.Iqd = Park(FOCVars.Ialphabeta, FOCVars.hElAngle);	

		FOCVars.IqdErr.d = FOCVars.Iqdref.d - FOCVars.Iqd.d;
		FOCVars.IqdErr.q = FOCVars.Iqdref.q - FOCVars.Iqd.q;
		
	  if(sensor_peripheral.Encoder_Sensor.encType != ENCODER_TYPE_UNKNOWN)
		{
				FOCVars.Vqd.d = PI_Controller(&PidIdHandle, FOCVars.IqdErr.d);
		
		    PidIqHandle.hKpGain = PidIdHandle.hKpGain;
		    PidIqHandle.hKiGain = PidIdHandle.hKiGain;
		    FOCVars.Vqd.q = PI_Controller(&PidIqHandle, FOCVars.IqdErr.q);
		}else
		{
			  if(mc_get_current_loop_enable(&mc_openloop) == TRUE)
				{
				    FOCVars.Vqd.d = PI_Controller(&PidIdHandle, FOCVars.IqdErr.d);
				    
		        PidIqHandle.hKpGain = PidIdHandle.hKpGain;
		        PidIqHandle.hKiGain = PidIdHandle.hKiGain;
		        FOCVars.Vqd.q = PI_Controller(&PidIqHandle, FOCVars.IqdErr.q);
				}
		
				//mc_statemachine_process(&mc_openloop,&STO_LBG,&FOCVars,sensor_peripheral.pVbusPar.glVBus);//放在这里主要是可以重置FOCVars.Vqd.q
				mc_statemachine_process(&mc_openloop,&STO_LBG,&FOCVars,24000);//放在这里主要是可以重置FOCVars.Vqd.q
		}


#if 1
	  //STO_CalcElAngle(&FOCVars,sensor_peripheral.pVbusPar.glVBus);
	  glDebugTestD[12] = STO_Get_Speed(&STO_LBG)*sensor_peripheral.Encoder_Sensor.encRes/(pMotorParSet.tBasePar.poles[A_AXIS] * 2 * PI);//we->rpm->plus
    glDebugTestD[13] = STO_Get_Electrical_Angle(&STO_LBG);
    glDebugTestD[16] = FOCVars.hElAngle;
#endif
	  
		FOCVars.Vqd = Circle_LimitationFunc(&FOCVars.CircleLimitationFoc, FOCVars.Vqd); //340 point
		FOCVars.Valphabeta = Rev_Park(FOCVars.Vqd,  FOCVars.hElAngle);								//TODO: USING COSA COSB  calc infront.....
		FOCVars.DutyCycle = SVPWM_3ShuntCalcDutyCycles(&FOCVars);						
		
    pMotorParSet.va[A_AXIS] = MID_PWM_CLK_PRD - FOCVars.DutyCycle.CntPhA;
    pMotorParSet.vb[A_AXIS] = MID_PWM_CLK_PRD - FOCVars.DutyCycle.CntPhB;
    pMotorParSet.vc[A_AXIS] = MID_PWM_CLK_PRD - FOCVars.DutyCycle.CntPhC;
}

实际效果（约100rpm）
在这里插入图片描述
目前代码还有优化空间：实现正反转（反转先降速切开环，反向开环拖动，最后切闭环）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/420793.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

msvcp140.dll安装教程_最新msvcp140.dll丢失的解决方法

msvcp140.dll安装教程_最新msvcp140.dll丢失的解决方法

msvcp140.dll 是一个动态链接库 (DLL) 文件&#xff0c;它是 Microsoft Visual C 运行时库的一部分&#xff0c;特别对应的是 Visual Studio 2015 版本编译的 C 应用程序所需的关键组件。DLL 文件的设计目的是为了实现代码和数据的共享&#xff0c;这样多个应用程序就可以在同一…
阅读更多...
C# 解决uploadify插件上传时造成session丢失问题

C# 解决uploadify插件上传时造成session丢失问题

出现的问题&#xff1a; 在应用uploadify插件实现上传图片时&#xff0c;报了HTTP Error&#xff0c;经过在Network查看上传方法报错码是302&#xff0c;那这里就可以知道问题是什么了&#xff0c;HTTP 302是请求被重定向&#xff0c;如果你的uploadify处理上传方法有session验…
阅读更多...
Vue3_2024_1天【Vue3创建和响应式，对比Vue2】

Vue3_2024_1天【Vue3创建和响应式，对比Vue2】

前言&#xff1a; Vue3对比Vue2版本&#xff0c;它在性能、功能、易用性和可维护性方面都有显著的提升和改进。 性能优化&#xff1a;模板编译器的优化、对Proxy的支持以及使用了更加高效的Virtual DOM算法等。这使得Vue3的打包大小减少了41%&#xff0c;初次渲染提速55%&#…
阅读更多...
【K8S类型系统】一文梳理 K8S 各类型概念之间的关系（GVK/GVR/Object/Schema/RestMapper）

【K8S类型系统】一文梳理 K8S 各类型概念之间的关系（GVK/GVR/Object/Schema/RestMapper）

参考 k8s 官方文档 https://kubernetes.io/zh-cn/docs/reference/https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.29/ 重点 Kubernetes源码学习-kubernetes基础数据结构 - 知乎 重点 Kubernetes类型系统 | 李乾坤的博客 重点 k8s源码学习-三大核心数…
阅读更多...
Harbor 的安装及使用

Harbor 的安装及使用

Harbor 安装官网手册&#xff1a; https://goharbor.io/docs/2.10.0/install-config/download-installer/ Harbor 发布包地址&#xff1a; https://github.com/goharbor/harbor/releases Harbor 的架构查看&#xff1a; https://github.com/goharbor/harbor/wiki/Architectur…
阅读更多...
​MPV，汽车产品里一个特殊品类的进化过程

​MPV，汽车产品里一个特殊品类的进化过程

「汽车」可能是整个工业革命以来&#xff0c;所诞生出的最有趣的工业产品。 它不仅能产生工业的机械美&#xff0c;还诞生了一个独立的文化体系&#xff0c;在汽车的发展过程中&#xff0c;我们也能看到一些本来应功能而诞生的产品&#xff0c;最终走向了千家万户。 MPV 就是…
阅读更多...
如何设置从小程序跳转到其它小程序

如何设置从小程序跳转到其它小程序

​有的商家有多个小程序&#xff0c;希望能够通过一个小程序链接到所有其它小程序&#xff0c;用户可以通过点击跳转链接实现从一个小程序跳转到另一个小程序。要怎么才能实现这样的跳转呢。下面具体介绍。 1. 设置跳转。在小程序管理员后台->分类管理&#xff0c;添加一个…
阅读更多...
js截取图片地址后面的参数和在路径中截取文件名或后缀名

js截取图片地址后面的参数和在路径中截取文件名或后缀名

文章目录 前言截取地址 &#xff1f;后面的参数在路径中截取文件名或后缀名总结 前言 在处理网页上的图片资源或者其他类型的文件资源时&#xff0c;你可能会遇到需要使用这些技巧的情况。以下是一些具体的使用场景&#xff1a; 动态修改图片参数&#xff1a;如果你有一个图片U…
阅读更多...
社交APP开发能给用户带来什么

社交APP开发能给用户带来什么

现在的社交软件也非常的多&#xff0c;每款社交软件都有自己的特色&#xff0c;社交软件是日常中必备的软件&#xff0c;不管是生活交流还是感情工作交流都是比较方便的&#xff0c;因为社交软件满足了日常的远程交流问题&#xff0c;所以开发社交软件也会逐渐的流行起来的。 …
阅读更多...
LeetCode240题：搜索二维矩阵II（python3）

LeetCode240题：搜索二维矩阵II（python3）

代码思路&#xff1a; “根节点” 对应的是矩阵的 “左下角” 和 “右上角” 元素&#xff0c;以 matrix 中的左下角元素为标志数 flag &#xff0c;则有: 若 flag > target &#xff0c;则 target 一定在 flag 所在行的上方 &#xff0c;即 flag 所在行可被消去&#xff0c…
阅读更多...
NLP - 神经网络与反向传播

NLP - 神经网络与反向传播

使用神经网络进行命名实体识别&#xff08;二值词窗分类&#xff09; 根据上下文窗口 建立词向量 通过一个神经网络层&#xff0c;通过一个逻辑分类器&#xff0c;得到这个概率是属于特定实体词的预测概率。 另一个分类器来比较说明 这个词是哪个实体类型&#xff08;比较概率…
阅读更多...
基于Python3的数据结构与算法 - 07 归并排序

基于Python3的数据结构与算法 - 07 归并排序

一、归并 引入 假设现在的列表分两段有序&#xff0c;如何将其合并成为一个有序列表。 这种操作成为一次归并。 归并的思路 分别对两个列表进行遍历&#xff0c;比较两个列表中的最小值&#xff0c;将更小的取出来。取出后一次进行上操作&#xff0c;直到其中一个列表中的元…
阅读更多...
Servlet 新手村引入-编写一个简单的servlet项目

Servlet 新手村引入-编写一个简单的servlet项目

Servlet 新手村引入-编写一个简单的servlet项目 文章目录 Servlet 新手村引入-编写一个简单的servlet项目一、编写一个 Hello world 项目1.创建项目2.引入依赖3.手动创建一些必要的目录/文件4.编写代码5.打包程序6.部署7.验证程序 二、更方便的处理方案&#xff08;插件引入&am…
阅读更多...
vue3编写H5适配横竖屏

vue3编写H5适配横竖屏

具体思路如下&#xff1a; 1、监听浏览器屏幕变化&#xff0c;通过监听屏幕宽高&#xff0c;辨别出是横屏&#xff0c;还是竖屏状态 在项目的起始根页面进行监听&#xff0c;我就是在App.vue文件下进行监听 代码如下&#xff1a; <template><RouterView /> <…
阅读更多...
Redis 存储原理和数据模型

Redis 存储原理和数据模型

redis 是不是单线程 redis 单线程指的是命令处理在一个单线程中。主线程 redis-server&#xff1a;命令处理、网络事件的监听。 辅助线程 bio_close_file&#xff1a;异步关闭大文件。bio_aof_fsync&#xff1a;异步 aof 刷盘。bio_lazy_free&#xff1a;异步清理大块内存。io_…
阅读更多...
【前端素材】推荐优质在线高端家具电商网页Classi平台模板（附源码）

【前端素材】推荐优质在线高端家具电商网页Classi平台模板（附源码）

一、需求分析 1、系统定义 在线高端家具商城是一个专门销售高端家具产品的电子商务平台&#xff0c;旨在为消费者提供购买高品质家具的便捷渠道。 2、功能需求 在线高端家具商城是一个专门销售高端家具产品的电子商务平台&#xff0c;旨在为消费者提供购买高品质家具的便捷…
阅读更多...
springboot-基础-thymeleaf配置+YAML语法

springboot-基础-thymeleaf配置+YAML语法

备份笔记。所有代码都是2019年测试通过的&#xff0c;如有问题请自行搜索解决&#xff01; 目录 配置thymeleafthymeleaf举例参数设置yaml基础知识YAML语法报错&#xff1a;Expecting a Mapping node but got 其他语法 spring boot不推荐使用jsp。thymeleaf是一个XML/XHTML/HTM…
阅读更多...
react 使用 craco库 配置 @ 路径，以及 jsconfig.json或者tsconfig.json 配置智能提示

react 使用 craco库 配置 @ 路径，以及 jsconfig.json或者tsconfig.json 配置智能提示

使用 craco库 来自定义CRA配置 1、概述 Craco&#xff08;Create React App Configuration Override&#xff09;是一个用于扩展 Create React App&#xff08;CRA&#xff09;配置的工具。通过 Craco&#xff0c;你可以在不弹出 Create React App 的内部配置的情况下&#x…
阅读更多...
Entry First Day 入职恩孚第一天

Entry First Day 入职恩孚第一天

入职第一天&#xff0c;电脑还没配置好就去了工厂。 熟悉了一下设备&#xff0c;切了几个小玩意&#xff0c; hello world 一下。 了解了串行端口的Nodejs的库 https://github.com/serialport/node-serialport&#xff0c;以后要用这个东西和硬件通讯&#xff0c;安装&#…
阅读更多...
CleanMyMac X2024免费Mac电脑清理和优化工具

CleanMyMac X2024免费Mac电脑清理和优化工具

CleanMyMac X是一款专业的 Mac 清理和优化工具&#xff0c;它具备一系列强大的功能&#xff0c;可以帮助用户轻松管理和维护他们的 Mac 电脑。以下是一些关于 CleanMyMac X 的主要功能和特点&#xff1a; 智能清理&#xff1a;CleanMyMac X 能够智能识别并清理 Mac 上的无用文件…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站