ATY_LIB/Doing/AHT20_ATY.c

/**
* @file AHT20_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 AHT20 for C platform
*
* @version
*       - 1_01_220804 > ATY
*           -# Preliminary version, first Release
*       - 1_02_220901 > ATY
*           -# Init tmp to zero, test AHT20_Init()
*       - 1_02_231229 > ATY
*           -# add multy addr and channel
********************************************************************************
*/

#ifndef __AHT20_ATY_C
#define __AHT20_ATY_C

#include "AHT20_ATY.h"

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

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

/**
 * @brief   AHT20 soft reset
 * @param   channel chip channel
 */
void AHT20_SoftReset(uint8_t channel)
{
    uint8_t temp_uint8 = 0;
    I2C_WriteReg(ATH20_ADDRESS, AHT20_SOFT_RST, &temp_uint8, 0, channel);
}

/**
 * @brief   read AHT20 status reg
 * @param   channel chip channel
 * @return  reg data
 */
uint8_t AHT20_ReadStatusCmd(uint8_t channel)
{
    uint8_t temp_uint8 = 0;
    I2C_ReadReg(ATH20_ADDRESS, AHT20_STATUS, &temp_uint8, 1, channel);
    return temp_uint8;
}

/**
 * @brief   AHT20 chip initialization
 * @param   channel chip channel
 */
void AHT20_IcInitCmd(uint8_t channel)
{
    const uint8_t temp_uint8[2] = {0x08, 0x00};
    // temp_uint8[0] = 0x00;
    // temp_uint8[1] = 0x00;
    // I2C_WriteReg(ATH20_ADDRESS, AHT20_NOR_MODE, temp_uint8, 2, channel);
    // temp_uint8[0] = 0x08;
    // temp_uint8[1] = 0x00;
    I2C_WriteReg(ATH20_ADDRESS, AHT20_INIT, temp_uint8, 2, channel);
    // I2C_WriteReg(ATH20_ADDRESS, 0xE1, temp_uint8, 2, channel);
}


/**
 * @brief   get AHT20 busy flag
 * @param   channel chip channel
 * @return  busy flag: 1 - busy, 0 - leisure
 */
uint8_t AHT20_ReadBusyCmd(uint8_t channel)
{
    uint8_t temp_uint8 = 0;
    temp_uint8 = AHT20_ReadStatusCmd(channel);
    return (temp_uint8 >> 7) & 0x01;
}

/**
 * @brief   read AHT20 calibration enable
 * @param   channel chip channel
 * @return  calibration state: 1 - calibrate done, 0 - not calibrated
 */
uint8_t AHT20_ReadCalEnableCmd(uint8_t channel)
{
    uint8_t temp_uint8 = 0;
    temp_uint8 = AHT20_ReadStatusCmd(channel);
    return (temp_uint8 >> 3) & 0x01;
}

/**
 * @brief   AHT20 measure command
 * @param   channel chip channel
 */
void AHT20_TrigMeasure(uint8_t channel)
{
    const uint8_t temp_uint8[2] = {0x33, 0x00};
    // temp_uint8[0] = 0x33;
    // temp_uint8[1] = 0x00;
    I2C_WriteReg(ATH20_ADDRESS, AHT20_TRIG_MEASURE, temp_uint8, 2, channel);
}

/**
 * @brief   AHT20 measure command
 * @param   data_t group to save origin reg data
 * @param   channel chip channel
 * @todo    change to Write function
 */
void AHT20_ReadData(uint8_t* data_t, uint8_t channel)
{
    I2C_Read(ATH20_ADDRESS, data_t, 6, channel);    // todo: not tested

    // I2C_Start();
    // I2C_WriteRegByte(ATH20_ADDRESS << 1 | 1);
    // I2C_WaitAck(I2C_WAIT_ACK_TIME);
    // data_t[0] = I2C_ReadByte(1);
    // data_t[1] = I2C_ReadByte(1);
    // data_t[2] = I2C_ReadByte(1);
    // data_t[3] = I2C_ReadByte(1);
    // data_t[4] = I2C_ReadByte(1);
    // data_t[5] = I2C_ReadByte(0);
    // I2C_Stop();
}

/**
 * @brief   reset AHT20 reg setting
 * @param   regAddr reg address
 * @param   channel chip channel
 * @note    generally not needed
 */
void AHT20_RegReset(uint8_t regAddr, uint8_t channel)
{
    uint8_t temp_uint8[3] = {0};
    temp_uint8[0] = 0x00;
    temp_uint8[1] = 0x00;
    temp_uint8[2] = 0x00;
    I2C_WriteReg(ATH20_ADDRESS, regAddr, temp_uint8, 2, channel);
    DelayMs(5);
    I2C_ReadReg(ATH20_ADDRESS, AHT20_STATUS, temp_uint8, 3, channel);
    DelayMs(10);
    I2C_WriteReg(ATH20_ADDRESS, 0xB0 | regAddr, temp_uint8 + 1, 2, channel);
}

/**
 * @brief   reset AHT20 reg setting
 * @param   channel chip channel
 * @note    generally not needed
 */
void AHT20_RegInit(uint8_t channel)
{
    AHT20_RegReset(0x1B, channel);
    AHT20_RegReset(0x1C, channel);
    AHT20_RegReset(0x1D, channel);
}



/**
 * @brief   AHT20 all initialize
 * @param   channel chip channel
 * @return  errCode, 0: success, !0: error
 */
uint8_t AHT20_Init(uint8_t channel)
{
    uint8_t errCount = 5;

    while(errCount--)
    {
        DelayMs(40);               // wait time after power on
        if((AHT20_ReadStatusCmd(channel) & 0x18) != 0x18)
        {
            AHT20_SoftReset(channel);
            AHT20_IcInitCmd(channel);
            AHT20_RegInit(channel);
            DelayMs(10);
            continue;
        }
        else
            break;
    }
    if(errCount == 0)
        return 1;

    errCount = 5;
    while(errCount--)
    {
        // check if calibrate over
        if(AHT20_ReadCalEnableCmd(channel) == 0)
        {
            DelayMs(10);
            // if not calibrated, reset to retry
            AHT20_IcInitCmd(channel);
            // AHT20_SoftReset();
            DelayMs(200);          // time not sure
        }
        else
            break;
    }
    if(errCount == 0)
        return 2;

    return 0;
}


/*
0x1C 93 61 76 05 42
TEM:25.2HUM:57.5
*/
/**
 * @brief   read and split data to origin hum & tem
 * @param   ht group to save hum & tem data
 * @param   channel chip channel
 * @return  errCode, 0: success, !0: error
 */
uint8_t AHT20_ReadHT(uint32_t* ht, uint8_t channel)
{
    uint8_t errCount = 5;
    uint8_t temp_uint8[6] = {0};
    uint32_t RetuData = 0;

    AHT20_TrigMeasure(channel);

    while(errCount--)
    {
        // wait 75ms for measure finished, busy flag Bit7 set to 0
        DelayMs(80);
        AHT20_ReadData(temp_uint8, channel);
        if((temp_uint8[0] & 0x68) == 0x08)
        {
            // origin hum data
            RetuData = temp_uint8[1];
            RetuData = (RetuData << 8) | temp_uint8[2];
            RetuData = (RetuData << 8) | temp_uint8[3];
            RetuData = RetuData >> 4;
            ht[0] = RetuData;

            // origin tem data
            RetuData = temp_uint8[3] & 0x0F;
            RetuData = (RetuData << 8) | temp_uint8[4];
            RetuData = (RetuData << 8) | temp_uint8[5];
            ht[1] = RetuData;

            return 0;
        }
    }
    return 1;
}

/**
 * @brief   calculate result from 20bit origin data, RH=%, T=C
 * @param   ht input origin data, always bigger than 0
 * @param   aht float data after calculate
 * @return  errCode, 0: success, 1: out of range
 */
uint8_t AHT20_CalcResult(uint32_t* ht, float* aht)
{
    aht[0] = (double)ht[0] * 100 / 1024 / 1024; // hum
    aht[1] = (double)ht[1] * 200 / 1024 / 1024; // tem

    // limit data range, RH = 0~100%, Temperature = -40~85C(+50)
    if((aht[0] >= 0) && (aht[0] <= 100) && (aht[1] >= 10) && (aht[1] <= 135))
        return 0;
    else
        return 1;
}

/**
 * @brief   calculate result from 20bit origin data, RH=%, T=C
 * @param   ht data group to save th value
 * @param   channel chip channel
 * @return  errCode, 0: success, !0: error
 */
uint8_t AHT20_TemHumGet(uint16_t* ht, uint8_t channel)
{
    static uint8_t AHT20_InitFlag = 0;
    if(AHT20_InitFlag == 0)
    {
        if(AHT20_Init(channel) == 1)
        {
            AHT20_InitFlag = 2;     // init fail
        }
        else
        {
            AHT20_InitFlag = 1;
        }
    }
    if(AHT20_InitFlag == 2)
    {
#ifdef __DEBUG_AHT20_ATY
        printf("\r\n0xFF");
#endif /* __DEBUG_AHT20_ATY */
        return 0xFF;
    }
    else if(AHT20_InitFlag == 1)
    {
        // Init success
        uint32_t tempHT_uint32[2] = {0};
        float tempHT_f[2] = {0};
        if(AHT20_ReadHT(tempHT_uint32, channel) == 0)
        {
            if((tempHT_uint32[0] && tempHT_uint32[1]) != 0)
            {
                AHT20_CalcResult(tempHT_uint32, tempHT_f);
                ht[0] = ((tempHT_f[0] * 1000) + 5) / 10;
                ht[1] = ((tempHT_f[1] * 1000) + 5) / 10;
#ifdef __DEBUG_AHT20_ATY
                printf("\r\nHum: %.2f - Tem: %.2f", tempHT_f[0], tempHT_f[1] - 50);
#endif /* __DEBUG_AHT20_ATY */
            }
            else
            {
#ifdef __DEBUG_AHT20_ATY
                printf("\r\n0xFD");
#endif /* __DEBUG_AHT20_ATY */
                return 0xFD;
            }
        }
        else
        {
#ifdef __DEBUG_AHT20_ATY
            printf("\r\n0xFE");
#endif /* __DEBUG_AHT20_ATY */
            return 0xFE;
        }
    }

    return 0;
}


// todo: not tested
// void main()
// {
//     SHT3X_InitBegin(addr, channel);
//     while(1)
//     {
//         AHT20_TemHumGet();
//         DelayMs(2000);
//     }
// }



#endif /* __AHT20_ATY_C */

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