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

news2025/7/4 13:31:07

文章目录

  • 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.coloradmin.cn/o/1478200.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Redis---持久化

Redis---持久化

Redis是内存数据库&#xff0c;是把数据存储在内存中的&#xff0c;但是内存中的数据不是持久的&#xff0c;如果想要做到持久&#xff0c;那么就需要让redis将数据存储到硬盘上。 Redis持久化有两种策略&#xff1a; RDB > Redis DataBase RDB机制采取的是定期备份AOF …
阅读更多...
Kaggle 竞赛入门

Kaggle 竞赛入门

打比赛不用写算法源码&#xff0c;应用的时候不用自己写。学习的时候可以自己写。 Kaggle 竞赛入门 认识 Kaggle 平台Kaggle竞赛知识前提结构化数据前提图像数据文本数据 Kaggle竞赛套路一个赛题的完整流程 认识 Kaggle 平台 Kaggle 官网 主页&#xff0c;比赛&#xff08;数据…
阅读更多...
Linux系统Docker部署Nexus Maven并实现远程访问本地管理界面

Linux系统Docker部署Nexus Maven并实现远程访问本地管理界面

文章目录 1. Docker安装Nexus2. 本地访问Nexus3. Linux安装Cpolar4. 配置Nexus界面公网地址5. 远程访问 Nexus界面6. 固定Nexus公网地址7. 固定地址访问Nexus Nexus是一个仓库管理工具&#xff0c;用于管理和组织软件构建过程中的依赖项和构件。它与Maven密切相关&#xff0c;可…
阅读更多...
计算机网络原理--传输层

计算机网络原理--传输层

&#x1f3a5; 个人主页&#xff1a;Dikz12&#x1f4d5;格言&#xff1a;那些在暗处执拗生长的花&#xff0c;终有一日会馥郁传香欢迎大家&#x1f44d;点赞✍评论⭐收藏 目录 TCP/IP五层&#xff08;或四层&#xff09;模型 传输层 TCP和UDP的区别 UDP协议 校验和 如何…
阅读更多...
配置前端项目到 github-pages

配置前端项目到 github-pages

Quickstart for GitHub Pages - GitHub Docs
阅读更多...
腾讯云优惠：2024云服务器租用价格表，买前必看

腾讯云优惠：2024云服务器租用价格表，买前必看

一张表看懂腾讯云服务器租用优惠价格表&#xff0c;一目了然&#xff0c;腾讯云服务器分为轻量应用服务器和云服务器CVM&#xff0c;CPU内存配置从2核2G、2核4G、4核8G、8核16G、4核16G、8核32G、16核32G、16核64等配置可选&#xff0c;公网带宽1M、3M、5M、12M、18M、22M、28M…
阅读更多...
LINUX基础培训二十五之shell表达式与运算

LINUX基础培训二十五之shell表达式与运算

一、条件表达式 条件表达式是用于判断条件是否满足的逻辑表达式&#xff0c;当条件为真&#xff0c;返回0&#xff0c;否则返回1。 常用语法&#xff1a; 1、test 测试表达式 2、[ 测试表达式 ] #两边需要有空格 3、[[ 测试表达式 ]] 4、(( 测试表达式 )) 第一种和第二种是等…
阅读更多...
鸿蒙这么大声势，为何迟迟看不见岗位？最新数据来了

鸿蒙这么大声势，为何迟迟看不见岗位？最新数据来了

对于鸿蒙生态建设而言&#xff0c;2024年可谓至关重要&#xff0c;而生态建设的前提&#xff0c;就是要有足够的开发人才。与之对应的&#xff0c;今年春招市场上与鸿蒙相关岗位和人才旺盛的热度&#xff0c;一方面反应了鸿蒙生态的逐渐壮大&#xff0c;另一方面也让人们对鸿蒙…
阅读更多...
Tomcat源码解析(二)： Bootstrap和Catalina

Tomcat源码解析(二)： Bootstrap和Catalina

Tomcat源码系列文章 Tomcat源码解析(一)&#xff1a; Tomcat整体架构 Tomcat源码解析(二)&#xff1a; Bootstrap和Catalina 目录 一、基础组件1、Lifecycle生命周期顶级接口2、组件的默认实现 二、启动类Bootstrap1、main2、init3、load与start 三、加载Catalina1、load2、s…
阅读更多...
2024腾讯云优惠券免费领取_代金券查询和使用方法

2024腾讯云优惠券免费领取_代金券查询和使用方法

腾讯云代金券领取渠道有哪些&#xff1f;腾讯云官网可以领取、官方媒体账号可以领取代金券、完成任务可以领取代金券&#xff0c;大家也可以在腾讯云百科蹲守代金券&#xff0c;因为腾讯云代金券领取渠道比较分散&#xff0c;腾讯云百科txybk.com专注汇总优惠代金券领取页面&am…
阅读更多...
工厂模式 详解 设计模式

工厂模式 详解 设计模式

工厂模式 其主要目的是封装对象的创建过程&#xff0c;使客户端代码和具体的对象实现解耦。这样子就不用每次都new对象&#xff0c;更换对象的话&#xff0c;所有new对象的地方也要修改&#xff0c;违背了开闭原则&#xff08;对扩展开放&#xff0c;对修改关闭&#xff09;。…
阅读更多...
spring6学习笔记

spring6学习笔记

1.环境准备 1.idea建立一个空项目&#xff0c;jdk要求是17 2.Maven配置&#xff08;和mybatis里一样&#xff09; 3.新建一个模块 2.ocp原则 3.依赖倒置原则&#xff08;DIP&#xff09; 什么是依赖倒置原则? 1.面向接口编程&#xff0c;面向抽象编程&#xff0c;不要面向…
阅读更多...
Windows安装VNC连接工具并结合cpolar实现远程内网Ubuntu系统桌面

Windows安装VNC连接工具并结合cpolar实现远程内网Ubuntu系统桌面

文章目录 前言1. ubuntu安装VNC2. 设置vnc开机启动3. windows 安装VNC viewer连接工具4. 内网穿透4.1 安装cpolar【支持使用一键脚本命令安装】4.2 创建隧道映射4.3 测试公网远程访问 5. 配置固定TCP地址5.1 保留一个固定的公网TCP端口地址5.2 配置固定公网TCP端口地址5.3 测试…
阅读更多...
回溯【基础算法精讲 14】

回溯【基础算法精讲 14】

视频地址 : 回溯算法套路①子集型回溯【基础算法精讲 14】_哔哩哔哩_bilibili 基本概念 1 . 例子 例如从abc和def(n 2)中各选出一个组成新的字符串? 如果n很大 , 这个时候for循环的表达能力有限 ; 2 . 原问题 和 子问题 3 . 增量构造答案 这个增量构造答案的过程就是回溯…
阅读更多...
java之Bean对象

java之Bean对象

1. 什么是Bean&#xff1f; Bean被实例化的&#xff0c;是被Spring框架所管理的Java对象。 Spring容器会自动完成Bean的实例化。将所创建的的Bean自动注入到Ioc容器中以供调用。 spring框架中 IOC容器中管理的对象就是Bean对象 2. 第三方bean Bean 因为第三方bean&#xff0…
阅读更多...
SQL函数学习记录

SQL函数学习记录

聚合函数 函数是编程语言的基础之一&#xff0c;在对数字的运算中&#xff0c;我们用的最多的就是聚合函数&#xff0c;本篇接下来就详细阐述下SQL中聚合函数的运用。 什么是聚合函数&#xff08;aggregate function&#xff09;&#xff1f; 聚合函数指的是对一组值执行计算…
阅读更多...
手撕LRU缓存——LinkedHashMap简易源码

手撕LRU缓存——LinkedHashMap简易源码

题目链接&#xff1a;https://leetcode.cn/problems/lru-cache/description/?envTypestudy-plan-v2&envIdtop-100-liked 原理非常简单&#xff0c;一个双端链表配上一个hash表。 首先我们要知道什么是LRU就是最小使用淘汰。怎么淘汰&#xff0c;链表尾部就是最不常用的直接…
阅读更多...
92、评估代码生成操作带来的性能提升

92、评估代码生成操作带来的性能提升

本节评估一下，通过代码生成操作之后，对于模型的性能提升。 评估下性能 在相同的环境下，分别运行 4th_no_malloc 和 5th_codegen 下的 compile.sh 脚本进行代码编译，然后运行编译后生成的可执行文件 ./resnet。 可以分别获取到权值预加载前后的性能指标。 注意：不同电脑机…
阅读更多...
可视化图文报表

可视化图文报表

Apache Echarts介绍 Apache Echarts是一款基于Javascript的数据可视化图表库&#xff0c;提供直观&#xff0c;生动&#xff0c;可交互&#xff0c;可个性化定制的数据可视化图表。 官网&#xff1a;Apache ECharts 入门案例&#xff1a; <!DOCTYPE html> <html>…
阅读更多...
Git教程-Git的基本使用

Git教程-Git的基本使用

Git是一个强大的分布式版本控制系统&#xff0c;它不仅用于跟踪代码的变化&#xff0c;还能够协调多个开发者之间的工作。在软件开发过程中&#xff0c;Git被广泛应用于协作开发、版本管理和代码追踪等方面。以下是一个详细的Git教程&#xff0c;我们将深入探讨Git的基本概念和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023