ATY_LIB/Doing/AD5933_ATY.c

/**
* @file AD5933_ATY.c
*
* @param Project DEVICE_GENERAL_ATY_LIB
*
* @author ATY
*
* @copyright
*       - Copyright 2017 - 2026 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*
* @brief functions of AD5933 for C platform
*
* @version
*       - 1_01_24015 > ATY
*           -# Preliminary version, first Release
********************************************************************************
*/

#ifndef __AD5933_ATY_C
#define __AD5933_ATY_C

#include "AD5933_ATY.h"

/******************************* For user *************************************/

/******************************************************************************/


uint8_t AD5933_Write(uint8_t addr, uint8_t* data_t, uint8_t len, struct AD5933_ATY_Dev* dev)
{
    uint8_t errCode = 0;
    __ATY_LOCK(dev);
    errCode = dev->i2cProcess(dev->addr, data_t, len, __ATY_RW_W);
    __ATY_UNLOCK(dev);
    return errCode;
}

uint8_t AD5933_Read(uint8_t addr, uint8_t* data_t, uint8_t len, struct AD5933_ATY_Dev* dev)
{
    uint8_t errCode = 0;
    __ATY_LOCK(dev);
    errCode = dev->i2cProcess(dev->addr, data_t, len, __ATY_RW_R);
    __ATY_UNLOCK(dev);
    return errCode;
}

uint8_t AD5933_WriteReg(uint8_t reg, uint8_t data, struct AD5933_ATY_Dev* dev)
{
    uint8_t errCode = 0;
    uint8_t data_t[2] = {reg, data};
    errCode = AD5933_Write(dev->addr, data_t, 2, dev);
    return errCode;
}

uint8_t AD5933_ReadReg(uint8_t reg, uint8_t* data, struct AD5933_ATY_Dev* dev)
{
    uint8_t errCode = 0;
    uint8_t data_t[2] = {reg, 0xB0};
    errCode = AD5933_Write(dev->addr, data_t, 2, dev);
    errCode = AD5933_Read(dev->addr, data_t, 2, dev);
    *data = data_t[1];
    return errCode;
}
void AD5933_Init(struct AD5933_ATY_Dev* dev)
{
    // Transmit	to start frequency register
    // program 30khz start frequency assuming internal osc of 16.776Khz
    AD5933_WriteReg(0x84, 0x45, dev);
    AD5933_WriteReg(0x83, 0xA6, dev);
    AD5933_WriteReg(0x82, 0x0E, dev);

    // Transmit to frequency increment register
    // program 1Khz frequency increment assuming internal osc of 16.776Khz
    AD5933_WriteReg(0x87, 0x02, dev);
    AD5933_WriteReg(0x86, 0x7D, dev);
    AD5933_WriteReg(0x85, 0x00, dev);

    // Transmit to NUMBER OF INCREMENTS register
    // program 10 frequency increments
    AD5933_WriteReg(0x89, 0x0A, dev);
    AD5933_WriteReg(0x88, 0x00, dev);

    // Transmit to settling time cycles register
    // program 15 output cycles at each frequency before a adc conversion
    AD5933_WriteReg(0x8B, 0x0F, dev);
    AD5933_WriteReg(0x8A, 0x00, dev);


    // Transmit to CONTROL register
    // place the AD5933 in standby mode
    AD5933_WriteReg(0x80, 0xB0, dev);

    // Choose the internal system clock
    AD5933_WriteReg(0x81, 0x00, dev);

    // Choose range 1 (2vp-p, 1.6v) PGA = x1
    AD5933_WriteReg(0x80, 0x01, dev);

    // initialise the sensor with contents of start frequency regsister with range 1 (2vp-p, 1.6v) PGA = x1
    AD5933_WriteReg(0x80, 0x10, dev);
    // start of frequency swee, devp  (2vp-p, 1.6v) PGA = x1
    AD5933_WriteReg(0x80, 0x20, dev);
    // initialise the sweep sequence
    AD5933_Measure(dev);

    // //issue a measure temperature command to the control register
    // AD5933_WriteReg(0x80, 0x90, dev);
    // // read the temperature data and send to uart
    // Measure_Temp(dev);

}

// status reg D0 = valid temp, D1 = valid real/imag data, D2 = frequency sweep complete
void AD5933_Measure(struct AD5933_ATY_Dev* dev)
{
    while(1){
        // D1 status reg loop
        uint8_t status = 0;
        AD5933_ReadReg(0x8F, &status, dev);
        // mask off the valid data bit
        status = (status & 0x02);                
        for(uint16_t i = 0; i < 10000; i++){}
        // printf("Status: %02X\r\n", status);
        // valid data should be present after start freqy command
        if(((status) | 0xFD) == 0xFF)  
        {
            // D1 true condition
            AD5933_ReadReg(0x8F, &status, dev);
            // D2 test condition
            if((status | 0xFB) != 0xFF)
            {
                uint8_t real_byte_high = 0, real_byte_low = 0, imag_byte_high = 0, imag_byte_low = 0;
                AD5933_ReadReg(0x94, &real_byte_high, dev);
                AD5933_ReadReg(0x95, &real_byte_low, dev);
                AD5933_ReadReg(0x96, &imag_byte_high, dev);
                AD5933_ReadReg(0x97, &imag_byte_low, dev);

                uint16_t real_data = ((real_byte_high << 8) | real_byte_low);
                uint16_t imag_data = ((imag_byte_high << 8) | imag_byte_low);

                // printf("Original real register = 0x%02x\r\n", (unsigned int)((unsigned short)real_data));
                // printf("Orocessed real register = %d(decimal equivilant)\r\n", (int)real_data);

                // printf("Original imag register = 0x%02X\r\n", (unsigned int)((unsigned short)imag_data));
                // printf("Orocessed imag register = %d(decimal equivilant)\r\n", (int)imag_data);

                printf("%d %d\r\n", (uint16_t)real_data, (uint16_t)imag_data);

                // increment to the next frequency
                status = 0x30;
                AD5933_WriteReg(0x80, status, dev);

            }
            else // End of frequency sweep exit loop
            {
                // printf("Status: %02X\r\n", status);
                // printf("end sweep\r\n");
                break;
            }
        }
    }
}

#endif /* __AD5933_ATY_C */

/************************************ etc *************************************/
// void LOG_ALL(uint8_t* str){ printf((const char*)str); }

/* init */
// uint8_t AD5933_1_I2C(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw){
//     if(rw == __ATY_RW_W)
//         return (uint8_t)HAL_I2C_Master_Transmit(&hi2c1, (addr << 1 | 0), data_t, len, 1000);
//     else if(rw == __ATY_RW_R)
//         return (uint8_t)HAL_I2C_Master_Receive(&hi2c1, (addr << 1 | 1), data_t, len, 1000);
// }

// struct AD5933_ATY_Dev AD5933_ATY_t_1 = {
//     .addr = AD5933_ADDRESS,
//     .i2cProcess = AD5933_1_I2C,
//     .lock = __ATY_UNLOCKED,
//     .debugEnable = 0,
// };

/* use */
// AD5933_SetValue(0xF0, &AD5933_ATY_t_1);
// AD5933_GetValue(&getValue, &AD5933_ATY_t_1);
/******************************************************************************/

/******************************** End Of File *********************************/