motor_ctl-1/3.BasicFunction/Source/tmag5273.c

/*
 * tmag5273.c
 *
 *  Created on: 2025��1��10��
 *      Author: zhouxiong9
 */

#include "tmag5273.h"
#include <ti/driverlib/dl_i2c.h>
#include "ti_msp_dl_config.h"

#define TMAG5273A1_ADDRESS             0x35

#define DEVICE_CONFIG_1                0x00
#define DEVICE_CONFIG_2                0x01
#define SENSOR_CONFIG_1                0x02
#define SENSOR_CONFIG_2                0x03
#define X_THR_CONFIG                   0x04
#define Y_THR_CONFIG                   0x05
#define Z_THR_CONFIG                   0x06
#define T_CONFIG                       0x07
#define INT_CONFIG_1                   0x08
#define MAG_GAIN_CONFIG                0x09
#define MAG_OFFSET_CONFIG_1            0x0A
#define MAG_OFFSET_CONFIG_2            0x0B
#define I2C_ADDRESS                    0x0C
#define DEVICE_ID                      0x0D
#define MANUFACTURER_ID_LSB            0x0E
#define MANUFACTURER_ID_MSB            0x0F
#define T_MSB_RESULT                   0x10
#define T_LSB_RESULT                   0x11
#define X_MSB_RESULT                   0x12
#define X_LSB_RESULT                   0x13
#define Y_MSB_RESULT                   0x14
#define Y_LSB_RESULT                   0x15
#define Z_MSB_RESULT                   0x16
#define Z_LSB_RESULT                   0x17
#define CONV_STATUS                    0x18
#define ANGLE_RESULT_MSB               0x19
#define ANGLE_RESULT_LSB               0x1A
#define MAGNITUDE_RESULT               0x1B
#define DEVICE_STATUS                  0x1C

enum I2cControllerStatus {
    I2C_STATUS_IDLE = 0,
    I2C_STATUS_TX_STARTED,
    I2C_STATUS_TX_INPROGRESS,
    I2C_STATUS_TX_COMPLETE,
    I2C_STATUS_RX_STARTED,
    I2C_STATUS_RX_INPROGRESS,
    I2C_STATUS_RX_COMPLETE,
    I2C_STATUS_ERROR,
} gI2cControllerStatus;

ULONG gTxLen, gTxCount, gRxCount, gRxLen;
UBYTE gTxPacket[128];
UBYTE gRxPacket[128];

char TMAG5273_WriteReg(UBYTE addr, UBYTE regaddr, UBYTE num, UBYTE *regdata)
{
    UWORD i;

    gI2cControllerStatus = I2C_STATUS_IDLE;
    gTxLen = num+1;

    gTxPacket[0] = regaddr;
    for(i=1; i<=num; i++)
    {
        gTxPacket[i] = (UBYTE)regdata[i-1];
    }

    gTxCount = DL_I2C_fillControllerTXFIFO(I2C_0_INST, &gTxPacket[0], gTxLen);

    if (gTxCount < gTxLen)
    {
        DL_I2C_enableInterrupt(I2C_0_INST, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
    }
    else
    {
        DL_I2C_disableInterrupt(I2C_0_INST, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
    }

    gI2cControllerStatus = I2C_STATUS_TX_STARTED;
    while (!(DL_I2C_getControllerStatus(I2C_0_INST) & DL_I2C_CONTROLLER_STATUS_IDLE));
    DL_I2C_startControllerTransfer(I2C_0_INST, addr, DL_I2C_CONTROLLER_DIRECTION_TX, gTxLen);

    while ((gI2cControllerStatus != I2C_STATUS_TX_COMPLETE) && (gI2cControllerStatus != I2C_STATUS_ERROR))
    {
        __WFE();
    }

    while (DL_I2C_getControllerStatus(I2C_0_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);

    while (!(DL_I2C_getControllerStatus(I2C_0_INST) & DL_I2C_CONTROLLER_STATUS_IDLE));
    delay_cycles(1000);

    return 0;
}

char TMAG5273_ReadData(UBYTE addr, UBYTE regaddr, UBYTE num, UBYTE* Read)
{
    UBYTE data[2], i;
    data[0] = regaddr;

    gI2cControllerStatus = I2C_STATUS_IDLE;
    DL_I2C_fillControllerTXFIFO(I2C_0_INST, &data[0], 1);
    DL_I2C_disableInterrupt(I2C_0_INST, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
    gI2cControllerStatus = I2C_STATUS_TX_STARTED;
    while (!(DL_I2C_getControllerStatus(I2C_0_INST) & DL_I2C_CONTROLLER_STATUS_IDLE));
    DL_I2C_startControllerTransfer(I2C_0_INST, addr, DL_I2C_CONTROLLER_DIRECTION_TX, 1);
    while ((gI2cControllerStatus != I2C_STATUS_TX_COMPLETE) && (gI2cControllerStatus != I2C_STATUS_ERROR))
    {
        __WFE();
    }
    while (DL_I2C_getControllerStatus(I2C_0_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);

    while (!(DL_I2C_getControllerStatus(I2C_0_INST) & DL_I2C_CONTROLLER_STATUS_IDLE));
    // delay_cycles(1000);

    gRxLen = num;
    gRxCount = 0;
    gI2cControllerStatus = I2C_STATUS_RX_STARTED;
    DL_I2C_startControllerTransfer(I2C_0_INST, addr, DL_I2C_CONTROLLER_DIRECTION_RX, gRxLen);
    while (gI2cControllerStatus != I2C_STATUS_RX_COMPLETE)
    {
        __WFE();
    }
    while (DL_I2C_getControllerStatus(I2C_0_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);

    for(i=0; i<num; i++)
    {
        Read[i] = gRxPacket[i];
    }

    return 0;
}

void I2C_0_INST_IRQHandler(void)
{
    switch (DL_I2C_getPendingInterrupt(I2C_0_INST)) {
        case DL_I2C_IIDX_CONTROLLER_RX_DONE:
            gI2cControllerStatus = I2C_STATUS_RX_COMPLETE;
            break;
        case DL_I2C_IIDX_CONTROLLER_TX_DONE:
            DL_I2C_disableInterrupt(
                    I2C_0_INST, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
            gI2cControllerStatus = I2C_STATUS_TX_COMPLETE;
            break;
        case DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER:
            gI2cControllerStatus = I2C_STATUS_RX_INPROGRESS;
            /* Receive all bytes from target */
            while (DL_I2C_isControllerRXFIFOEmpty(I2C_0_INST) != true) {
                if (gRxCount < gRxLen) {
                    gRxPacket[gRxCount++] =
                        DL_I2C_receiveControllerData(I2C_0_INST);
                } else {
                    /* Ignore and remove from FIFO if the buffer is full */
                    DL_I2C_receiveControllerData(I2C_0_INST);
                }
            }
            break;
        case DL_I2C_IIDX_CONTROLLER_TXFIFO_TRIGGER:
            gI2cControllerStatus = I2C_STATUS_TX_INPROGRESS;
            /* Fill TX FIFO with next bytes to send */
            if (gTxCount < gTxLen) {
                gTxCount += DL_I2C_fillControllerTXFIFO(
                        I2C_0_INST, &gTxPacket[gTxCount], gTxLen - gTxCount);
            }
            break;
            /* Not used for this example */
        case DL_I2C_IIDX_CONTROLLER_ARBITRATION_LOST:
        case DL_I2C_IIDX_CONTROLLER_NACK:
            if ((gI2cControllerStatus == I2C_STATUS_RX_STARTED) ||
                (gI2cControllerStatus == I2C_STATUS_TX_STARTED)) {
                /* NACK interrupt if I2C Target is disconnected */
                gI2cControllerStatus = I2C_STATUS_ERROR;
            }
        case DL_I2C_IIDX_CONTROLLER_RXFIFO_FULL:
        case DL_I2C_IIDX_CONTROLLER_TXFIFO_EMPTY:
        case DL_I2C_IIDX_CONTROLLER_START:
        case DL_I2C_IIDX_CONTROLLER_STOP:
        case DL_I2C_IIDX_CONTROLLER_EVENT1_DMA_DONE:
        case DL_I2C_IIDX_CONTROLLER_EVENT2_DMA_DONE:
        default:
            break;
    }
}

UBYTE tmag5273_GetDevID(void)
{
    UBYTE Result;

    TMAG5273_ReadData(TMAG5273A1_ADDRESS, DEVICE_ID, 1, &Result);
    return Result;
}

UWORD tmag5273_GetMANUFACTURER_ID(void)
{
    UWORD Result;
    UBYTE Rs1, Rs2;

    TMAG5273_ReadData(TMAG5273A1_ADDRESS, MANUFACTURER_ID_LSB, 1, &Rs1);
    TMAG5273_ReadData(TMAG5273A1_ADDRESS, MANUFACTURER_ID_MSB, 1, &Rs2);
    Result = (Rs2 << 8) + Rs1;
    return Result;
}

SBYTE tmag5273_Init(void)
{
    UBYTE tmp[2];

    tmp[0] = 0x00;
    TMAG5273_WriteReg(TMAG5273A1_ADDRESS, DEVICE_CONFIG_1, 1, tmp);
    tmp[0] = 0x02;
    TMAG5273_WriteReg(TMAG5273A1_ADDRESS, DEVICE_CONFIG_2, 1, tmp);
    tmp[0] = 0x7C;
    TMAG5273_WriteReg(TMAG5273A1_ADDRESS, SENSOR_CONFIG_1, 1, tmp);
    tmp[0] = 0x04;
    TMAG5273_WriteReg(TMAG5273A1_ADDRESS, SENSOR_CONFIG_2, 1, tmp);
    tmp[0] = 0x01;
    TMAG5273_WriteReg(TMAG5273A1_ADDRESS, T_CONFIG, 1, tmp);

    return 0;
}

SLONG tmag5273_GetXData(void) //uT
{
    UBYTE xMLSB[2];
    UWORD xData = 0;
    SLONG Out = 0;

    TMAG5273_ReadData(TMAG5273A1_ADDRESS, X_MSB_RESULT, 2, xMLSB);

    xData = xMLSB[1] + (xMLSB[0] << 8);
    if(xData & 0x8000)
        Out = ((-32768 + (xData & 0x7FFF)) * 40000) >> 15;
    else
        Out = ((xData & 0x7FFF) * 40000) >> 15;

    return Out;
}

SLONG tmag5273_GetYData(void) //uT
{
    UBYTE yMLSB[2];
    SWORD yData = 0;
    SLONG Out = 0;

    TMAG5273_ReadData(TMAG5273A1_ADDRESS, Y_MSB_RESULT, 2, yMLSB);

    yData = yMLSB[1] + (yMLSB[0] << 8);
    if(yData & 0x8000)
        Out = ((-32768 + (yData & 0x7FFF)) * 40000) >> 15;
    else
        Out = ((yData & 0x7FFF) * 40000) >> 15;

    return Out;
}

SLONG tmag5273_GetZData(void) //uT
{
    UBYTE zMLSB[2];
    SWORD zData = 0;
    SLONG Out = 0;

    TMAG5273_ReadData(TMAG5273A1_ADDRESS, Z_MSB_RESULT, 2, zMLSB);

    zData = zMLSB[1] + (zMLSB[0] << 8);
    if(zData & 0x8000)
        Out = ((-32768 + (zData & 0x7FFF)) * 40000) >> 15;
    else
        Out = ((zData & 0x7FFF) * 40000) >> 15;

    return Out;
}

SWORD tmag5273_GetTemp(void) //0.01℃
{
    UBYTE tMLSB[2];
    UWORD tData = 0;
    SWORD Result;

    TMAG5273_ReadData(TMAG5273A1_ADDRESS, T_MSB_RESULT, 2, tMLSB);

    tData = tMLSB[1] + (tMLSB[0] << 8);
    Result = 2500 + (((tData - 17508) * 213) >> 7); //100 * 60.1 * 128

    return Result;
}


UWORD tmag5273_GetAngle(void) //x16
{
    UBYTE agMLSB[2] = {0, 0};
    UWORD Result;

    TMAG5273_ReadData(TMAG5273A1_ADDRESS, ANGLE_RESULT_MSB, 2, agMLSB);
    Result = agMLSB[1] + (agMLSB[0] << 8);

    return Result;
}