mtpa.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2024 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef MTPA_H
#define MTPA_H
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <math.h>
 
#include "math_types.h"
 
#define MTPA_LUT_INDEX_LD_MAX            20
 
 
#define MTPA_LUT_INDEX_LQ_MAX            20
 
#define MTPA_LUT_DELTA_CURRENT_LD_A      0.5
 
#define MTPA_LUT_DELTA_CURRENT_LD_A      0.5
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef struct _MTPA_Obj_
{
    MATH_Vec2 Idq_ref_A;            
    float32_t angleCurrent_rad;     
    float32_t Is_ref_A;             
    float32_t kconst;               
    float32_t gconst;               
    float32_t deltaIs_Ld_A;         
    float32_t deltaIs_Lq_A;         
    uint32_t  indexMax_Ld;          
    uint32_t  indexMax_Lq;          
    bool      flagEnable;           
} MTPA_Obj, *MTPA_Handle;
 
 
extern const float32_t MTPA_Ld_tableData_H[MTPA_LUT_INDEX_LD_MAX + 1];
 
extern const float32_t MTPA_Lq_tableData_H[MTPA_LUT_INDEX_LQ_MAX + 1];
 
//*****************************************************************************
//
// Prototypes for the APIs
//
//*****************************************************************************
 
//*****************************************************************************
//*****************************************************************************
extern void MTPA_computeParameters(MTPA_Handle handle,
                                   const float32_t Ls_d_H,
                                   const float32_t Ls_q_H,
                                   const float32_t flux_Wb);
 
//*****************************************************************************
//
//
//*****************************************************************************
extern MTPA_Handle     MTPA_init(void *pMemory, const size_t numBytes);
 
//*****************************************************************************
//*****************************************************************************
static inline void MTPA_disable(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    obj->flagEnable = false;
 
    return;
} // end of MTPA_disable() function
 
//*****************************************************************************
//*****************************************************************************
static inline void MTPA_enable(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    obj->flagEnable = true;
 
    return;
} // end of MTPA_enable() function
 
//*****************************************************************************
//*****************************************************************************
static inline float32_t *MTPA_getCurrentAnglePhase_rad_addr(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    return(&(obj->angleCurrent_rad));
} // end of MTPA_getCurrentAnglePhase_rad_addr() function
 
//*****************************************************************************
//*****************************************************************************
static inline float32_t MTPA_getCurrentAngle_rad(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    return(obj->angleCurrent_rad);
} // end of MTPA_getCurrentAngle_rad() function
 
//*****************************************************************************
//*****************************************************************************
static inline float32_t MTPA_getKconst(MTPA_Handle handle)
{
  MTPA_Obj *obj = (MTPA_Obj *)handle;
 
  return(obj->kconst);
} // end of MTPA_getKconst() function
 
//*****************************************************************************
//*****************************************************************************
static inline float32_t *MTPA_getIs_ref_A_addr(MTPA_Handle handle)
{
  MTPA_Obj *obj = (MTPA_Obj *)handle;
 
  return(&(obj->Is_ref_A));
} // end of CTRL_getId_A_addr() function
 
//*****************************************************************************
//*****************************************************************************
static inline bool MTPA_getFlagEnable(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    return(obj->flagEnable);
} // end of MTPA_getFlagEnable() function
 
//*****************************************************************************
//*****************************************************************************
static inline float32_t MTPA_getId_ref_A(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    return(obj->Idq_ref_A.value[0]);
} // end of MTPA_getId_ref_A() function
 
//*****************************************************************************
//*****************************************************************************
static inline float32_t MTPA_getIq_ref_A(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    return(obj->Idq_ref_A.value[1]);
} // end of MTPA_getIq_ref_A() function
 
//*****************************************************************************
//*****************************************************************************
static inline float32_t MTPA_getIs_ref_A(MTPA_Handle handle)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    return(obj->Is_ref_A);
} // end of MTPA_getIs_ref_A() function
 
//*****************************************************************************
//*****************************************************************************
static inline
void MTPA_setFlagEnable(MTPA_Handle handle, const bool flagEnable)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    obj->flagEnable = flagEnable;
 
    return;
} // end of MTPA_setFlag_enable() function
 
//*****************************************************************************
//*****************************************************************************
static inline
void MTPA_setCurrentAngle_rad(MTPA_Handle handle, const float32_t angleCurrent_rad)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    obj->angleCurrent_rad = angleCurrent_rad;
 
  return;
} // end of MTPA_setCurrentAngle_rad() function
 
//*****************************************************************************
//*****************************************************************************
static inline
void MTPA_setId_ref_A(MTPA_Handle handle, const float32_t Id_ref_A)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    obj->Idq_ref_A.value[0] = Id_ref_A;
 
    return;
} // end of MTPA_setId_ref_A() function
 
//*****************************************************************************
//*****************************************************************************
static inline
void MTPA_setIq_ref_A(MTPA_Handle handle, const float32_t Iq_ref_A)
{
  MTPA_Obj *obj = (MTPA_Obj *)handle;
 
  obj->Idq_ref_A.value[1] = Iq_ref_A;
 
  return;
} // end of MTPA_setIq_ref_A() function
 
//*****************************************************************************
//*****************************************************************************
static inline void
MTPA_setIs_ref_A(MTPA_Handle handle, const float32_t Is_ref_A)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    obj->Is_ref_A = Is_ref_A;
 
    return;
} // end of MTPA_setIs_ref_A() function
 
//*****************************************************************************
//*****************************************************************************
static inline 
float32_t MTPA_updateLs_d_withLUT(MTPA_Handle handle, const float32_t Is_A)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    uint32_t indexLdCnt = 0;
 
    indexLdCnt = (uint32_t)(Is_A/obj->deltaIs_Ld_A);
 
    if(indexLdCnt > obj->indexMax_Ld)
    {
        indexLdCnt = obj->indexMax_Ld;
    }
 
    return(MTPA_Ld_tableData_H[indexLdCnt]);
} // end of MTPA_updateLs_d_withLUT() function
 
//*****************************************************************************
//*****************************************************************************
static inline 
float32_t MTPA_updateLs_q_withLUT(MTPA_Handle handle, const float32_t Is_A)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    uint16_t indexLqCnt = 0;
 
    indexLqCnt = (uint16_t)(Is_A/obj->deltaIs_Lq_A);
 
    if(indexLqCnt > obj->indexMax_Lq)
    {
        indexLqCnt = obj->indexMax_Lq;
    }
 
    return(MTPA_Ld_tableData_H[indexLqCnt]);
} // end of MTPA_updateLs_q_withLUT() function
 
//*****************************************************************************
//*****************************************************************************
static __attribute__((always_inline))
void MTPA_computeCurrentReference(MTPA_Handle handle, const float32_t Is_ref_A)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
 
    obj->Is_ref_A = fabsf(Is_ref_A);
 
    // Perform the Maximum torque per ampere (MTPA)
    if(MTPA_getFlagEnable(handle) == true &&
    (obj->kconst != 0.0) && (obj->Is_ref_A != 0.0))
    {
        obj->Idq_ref_A.value[0] = obj->kconst -
                    (float32_t)sqrtf((obj->kconst * obj->kconst) +
                    (0.5f * (obj->Is_ref_A * obj->Is_ref_A)));
 
        obj->Idq_ref_A.value[1] = sqrtf((obj->Is_ref_A * obj->Is_ref_A) -
                    (obj->Idq_ref_A.value[0] * obj->Idq_ref_A.value[0]));
 
        if(Is_ref_A < 0.0)
        {
            obj->Idq_ref_A.value[1] = -obj->Idq_ref_A.value[1];
        }
    }
    else
    {
        obj->Idq_ref_A.value[0] = 0.0;
        obj->Idq_ref_A.value[1] = Is_ref_A;
    }
 
    return;
} // end of MTPA_computeCurrentReference() function
 
 
//*****************************************************************************
//*****************************************************************************
static __attribute__((always_inline))
float32_t MTPA_computeCurrentAngle(MTPA_Handle handle, const float32_t Is_ref_A)
{
    MTPA_Obj *obj = (MTPA_Obj *)handle;
 
    obj->Is_ref_A = fabsf(Is_ref_A);
 
    if(MTPA_getFlagEnable(handle) == true)
    {
        // Perform the Maximum torque per ampere (MTPA)
        if((obj->kconst != 0.0) && (obj->Is_ref_A != 0.0))
        {
            obj->gconst = obj->kconst / obj->Is_ref_A;
 
            obj->angleCurrent_rad = acosf(obj->gconst -
                                    sqrtf(obj->gconst * obj->gconst + 0.5f));
        }
        else
        {
            obj->angleCurrent_rad = MATH_PI_OVER_TWO;
        }
    }
    else
    {
        obj->angleCurrent_rad = MATH_PI_OVER_TWO;
    }
 
    return(obj->angleCurrent_rad);
} // end of MTPA_computeCurrentAngle() function
 
#ifdef __cplusplus
}
#endif
 
#endif // MTPA_H