hpm_mcl_encoder.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
#ifndef HPM_MCL_ENCODER_H
#define HPM_MCL_ENCODER_H
#include "hpm_mcl_common.h"
#include "hpm_mcl_filter.h"
 
enum {
    mcl_encoder_start_sample_error = MAKE_STATUS(mcl_group_encoder, 0),
    mcl_encoder_get_tick_error = MAKE_STATUS(mcl_group_encoder, 1),
    mcl_encoder_update_tick_error = MAKE_STATUS(mcl_group_encoder, 2),
    mcl_encoder_get_theta_error = MAKE_STATUS(mcl_group_encoder, 3),
    mcl_encoder_not_ready = MAKE_STATUS(mcl_group_encoder, 4),
    mcl_encoder_get_uvw_error = MAKE_STATUS(mcl_group_encoder, 5),
};
 
typedef enum {
    encoder_status_null = 0,
    encoder_status_init = 1,
    encoder_status_run = 2,
    encoder_status_fail = 3,
} mcl_encoder_status_t;
 
typedef enum {
    encoder_method_t,
    encoder_method_m,
    encoder_method_m_t,
    encoder_method_pll,
    encoder_method_user,
} mcl_encoder_cal_speed_function_t;
 
 
typedef struct {
    bool u;
    bool v;
    bool w;
} mcl_encoder_uvw_level_t;
 
typedef struct  mcl_encoder_callback {
    hpm_mcl_stat_t (*init)(void);
    _FUNC_OPTIONAL_ hpm_mcl_stat_t (*update_trig_lead_tick)(uint32_t lead_tick);
    _FUNC_OPTIONAL_ hpm_mcl_stat_t (*get_lead_tick)(uint32_t *lead_tick);
    hpm_mcl_stat_t (*start_sample)(void);
    hpm_mcl_stat_t (*get_theta)(float *theta);
    _FUNC_OPTIONAL_ hpm_mcl_stat_t (*get_absolute_theta)(float *theta);
    _FUNC_OPTIONAL_ hpm_mcl_stat_t (*get_uvw_level)(mcl_encoder_uvw_level_t *level);
    _FUNC_OPTIONAL_ hpm_mcl_stat_t (*process_by_user)(float theta, float *speed, float *theta_forecast);
} mcl_encoder_callback_t;
 
#define MCL_ENCODER_CAL_STRUCT_MAX_MEMMORY  (16)
typedef struct {
    float theta_last;
    float speed_last;
    float ts_sigma;
} mcl_encoder_cal_speed_t_function_t;
 
typedef struct {
    float theta_last;
    float ts_sigma;
} mcl_encoder_cal_speed_m_function_t;
 
typedef struct {
    float theta_last;
    float ts_sigma;
    float theta_sigma;
    float speed_filter_last;
    float speed_last;
} mcl_encoder_cal_speed_m_t_function_t;
 
typedef struct {
    float kp;   
    float ki;   
} mcl_encoder_cal_speed_pll_cfg_t;
 
typedef struct {
    mcl_encoder_cal_speed_pll_cfg_t *cfg;
    float *period_call_time_s;
    float pi_integrator;
    float omega_integrator;
    float theta_last;
} mcl_encoder_cal_speed_pll_function_t;
 
typedef struct {
    uint8_t disable_start_sample_interrupt;
    uint64_t communication_interval_us; 
    mcl_encoder_cal_speed_function_t speed_cal_method;
    mcl_encoder_cal_speed_pll_cfg_t cal_speed_pll_cfg;
    float timeout_s;                  
    float speed_abs_switch_m_t;     
    uint32_t precision;     
    float period_call_time_s;   
    mcl_encoder_callback_t callback;
} mcl_encoer_cfg_t;
 
 
typedef struct {
    union {
        mcl_encoder_cal_speed_t_function_t t_method;
        mcl_encoder_cal_speed_m_function_t m_method;
        mcl_encoder_cal_speed_m_t_function_t m_t_method;
        mcl_encoder_cal_speed_pll_function_t pll_method;
        uint32_t memory[MCL_ENCODER_CAL_STRUCT_MAX_MEMMORY];
    } cal_speed;
    mcl_filter_iir_df1_t *iirfilter;
    mcl_encoder_status_t status;
    mcl_encoer_cfg_t *cfg;
    int32_t *mcu_clock_tick;
    int32_t *pole_num;
    hall_phase_t *phase;
    float theta_initial;
    float *current_loop_ts;
    mcl_user_value_t force_set_theta;
    struct {
        float speed;
        float theta;
        float theta_forecast;
    } result;
    struct {
        bool *enable;
        float *theta;
    } sensorless;
} mcl_encoder_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
hpm_mcl_stat_t hpm_mcl_encoder_init(mcl_encoder_t *encoder, mcl_cfg_t *mcl_cfg, mcl_encoer_cfg_t *encoder_cfg, mcl_filter_iir_df1_t *iir);
 
hpm_mcl_stat_t hpm_mcl_encoder_start_sample(mcl_encoder_t *encoder);
 
hpm_mcl_stat_t hpm_mcl_encoder_set_initial_theta(mcl_encoder_t *encoder, float theta);
 
hpm_mcl_stat_t hpm_mcl_encoder_process(mcl_encoder_t *encoder, uint32_t tick_deta);
 
hpm_mcl_stat_t hpm_mcl_encoder_set_status(mcl_encoder_t *encoder, mcl_encoder_status_t status);
 
float hpm_mcl_encoder_get_theta(mcl_encoder_t *encoder);
 
float hpm_mcl_encoder_get_speed(mcl_encoder_t *encoder);
 
float hpm_mcl_encoder_get_forecast_theta(mcl_encoder_t *encoder);
 
float hpm_mcl_encoder_get_raw_theta(mcl_encoder_t *encoder);
 
void hpm_mcl_encoder_force_theta(mcl_encoder_t *encoder, float theta, bool enable);
 
hpm_mcl_stat_t hpm_mcl_encoder_get_absolute_theta(mcl_encoder_t *encoder, float *theta);
 
hpm_mcl_stat_t hpm_mcl_encoder_get_uvw_status(mcl_encoder_t *encoder, mcl_encoder_uvw_level_t *level);
 
float hpm_mcl_encoder_get_sensorless_theta(mcl_encoder_t *encoder);
 
 
#ifdef __cplusplus
}
#endif
 
#endif