csu3_am335x/EVSE/Projects/DQD480/Apps/ModuleInternalComm/FanBoard.c

#include <stdio.h>      /*標準輸入輸出定義*/
#include <stdlib.h>     /*標準函數庫定義*/
#include <string.h>
#include <stdint.h>
#include <time.h>
#include <unistd.h>

#include <sys/time.h>
#include <sys/timeb.h>

#include "../ShareMemory/shmMem.h"
#include "../Config.h"
#include "../Log/log.h"
#include "Module_InternalComm.h"
#include "internalComm.h"

//------------------------------------------------------------------------------
static struct SysConfigData *pSysConfig = NULL;
static struct SysInfoData *pSysInfo = NULL;
static struct AlarmCodeData *pAlarmCode = NULL;
static struct FanModuleData *ShmFanModuleData = NULL;
static struct PsuData *ShmPsuData = NULL;
static DcCommonInfo* ShmDcCommonData = NULL;

static int Uart5Fd = 0;
static struct timeval gFanBoardRunTimer;

static uint16_t _setFanSpeed = 0;
static uint16_t fanSpeedSmoothValue = 500;

//------------------------------------------------------------------------------
static void SetFanModuleSpeed(void)
{
    {
        FanSpeed _fanSpeed = {0};

        _setFanSpeed += fanSpeedSmoothValue;

        if (_setFanSpeed >= ShmFanModuleData->SetFan1Speed) {
            _setFanSpeed = ShmFanModuleData->SetFan1Speed;
        }

        //printf("_setFanSpeed = %d ", _setFanSpeed);
        _fanSpeed.speed[0] = _setFanSpeed;

        _fanSpeed.speed[1] = _setFanSpeed;

        _fanSpeed.speed[2] = _setFanSpeed;

        _fanSpeed.speed[3] = _setFanSpeed;

        if (Config_Fan_Speed(Uart5Fd, ADDR_FAN, &_fanSpeed) == PASS) {
            //log_info("successfully Fan");
        }
    }
}

// 風扇速度
static void GetFanSpeed(void)
{
    FanSpeed fanSpeed = {0};

    //log_info("Get fan board speed ");
    if (Query_Fan_Speed(Uart5Fd, ADDR_FAN, &fanSpeed) == PASS) {
        ShmFanModuleData->PresentFan1Speed = fanSpeed.speed[0];
        ShmFanModuleData->PresentFan2Speed = fanSpeed.speed[1];
        ShmFanModuleData->PresentFan3Speed = fanSpeed.speed[2];
        ShmFanModuleData->PresentFan4Speed = fanSpeed.speed[3];
//      log_info("SystemFanRotaSpeed_1 = %d ", fanSpeed.speed[0]);
//      log_info("SystemFanRotaSpeed_2 = %d ", fanSpeed.speed[1]);
//      log_info("SystemFanRotaSpeed_3 = %d ", fanSpeed.speed[2]);
//      log_info("SystemFanRotaSpeed_4 = %d ", fanSpeed.speed[3]);
        // Config_Fan_Speed(Uart5Fd, ADDR_FAN, &fanSpeed[0]);
        //SysInfoData (SystemFanRotaSpeed)
    }
}

static void GetFanSpeedByFunction(void)
{

    // 風控修改 :
    // ******************************************************* //
    //
    //       當前PSU輸出總 KW       PSU Temp
    // 30 x -------------------- x ---------- + 14 x (PSU Temp - 45)
    //       當前樁最大功率 KW         45
    //
    // ******************************************************* //

    // 當前樁最大功率 KW : ShmPsuData->SystemAvailablePower
    uint32_t _maxPower = ShmPsuData->SystemAvailablePower;
    // 當前PSU輸出總 KW & PSU Temp :
    uint8_t temp = 0;
    uint8_t index = 0;
    uint8_t count = 0;
    uint8_t gunIndex = 0;
    uint8_t _temp_diff = 0;
    float power = 0;
    double _pw_rate = 0;
    double _temp_rate = 0;
    struct ChargingInfoData *pDcChargingInfo = NULL;

    for (index = 0; index < ShmPsuData->GroupCount; index++) {
        for (count = 0; count < ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity; count++) {
            if (temp < ShmPsuData->PsuGroup[index].PsuModule[count].ExletTemp) {
                temp = ShmPsuData->PsuGroup[index].PsuModule[count].ExletTemp;
            }
        }
    }

    for (gunIndex = 0; gunIndex < pSysConfig->TotalConnectorCount; gunIndex++) {
        pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(gunIndex);

        power += (pDcChargingInfo->PresentChargingPower * 10);
    }

    if (_maxPower > 0) {
        _pw_rate = power / (double)_maxPower;
    }

    if (temp > 0) {
        _temp_rate = (double)temp / 50;
    }

    if (temp > 45) {
        _temp_diff = temp - 70;
    }

    ShmFanModuleData->TestFanSpeed = (((50 * _pw_rate * _temp_rate) + (0.5 * _temp_diff)) / 100) * MAX_FAN_SPEED;

    if (ShmFanModuleData->TestFanSpeed > MAX_FAN_SPEED) {
        ShmFanModuleData->TestFanSpeed = MAX_FAN_SPEED;
    }

    if (ShmFanModuleData->TestFanSpeed < 0) {
        ShmFanModuleData->TestFanSpeed = 0;
    }
//
//  printf("power = %f ", power);
//  printf("_maxPower = %d ", _maxPower);
//  printf("temp = %d ", temp);
//
//  printf("_pw_rate = %f ", _pw_rate);
//  printf("_temp_rate = %f ", _temp_rate);
//  printf("_temp_diff = %d ", _temp_diff);
//  printf("fan rate = %f ", (30 * _pw_rate * _temp_rate + 14 * _temp_diff));
//  printf("ShmFanModuleData->TestFanSpeed = %d ", ShmFanModuleData->TestFanSpeed);
}

static void SetRtcData_Fan(void)
{
    struct timeb csuTime;
    struct tm* tmCSU;
    Rtc rtc = { 0 };

    ftime(&csuTime);
    tmCSU = localtime(&csuTime.time);
    //  log_info("Time : %04d-%02d-%02d %02d:%02d:%02d ", tmCSU->tm_year + 1900,
    //          tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
    //          tmCSU->tm_sec);

    rtc.RtcData[0] = '0' + (tmCSU->tm_year + 1900) / 1000 % 10;
    rtc.RtcData[1] = '0' + (tmCSU->tm_year + 1900) / 100 % 10;
    rtc.RtcData[2] = '0' + (tmCSU->tm_year + 1900) / 10 % 10;
    rtc.RtcData[3] = '0' + (tmCSU->tm_year + 1900) / 1 % 10;

    rtc.RtcData[4] = '0' + (tmCSU->tm_mon + 1) / 10 % 10;
    rtc.RtcData[5] = '0' + (tmCSU->tm_mon + 1) / 1 % 10;

    rtc.RtcData[6] = '0' + (tmCSU->tm_mday) / 10 % 10;
    rtc.RtcData[7] = '0' + (tmCSU->tm_mday) / 1 % 10;

    rtc.RtcData[8] = '0' + (tmCSU->tm_hour) / 10 % 10;
    rtc.RtcData[9] = '0' + (tmCSU->tm_hour) / 1 % 10;

    rtc.RtcData[10] = '0' + (tmCSU->tm_min) / 10 % 10;
    rtc.RtcData[11] = '0' + (tmCSU->tm_min) / 1 % 10;

    rtc.RtcData[12] = '0' + (tmCSU->tm_sec) / 10 % 10;
    rtc.RtcData[13] = '0' + (tmCSU->tm_sec) / 1 % 10;

    if (Config_Rtc_Data(Uart5Fd, ADDR_FAN, &rtc) == PASS) {
        //log_info("SetRtc (FB) sucessfully. ");
    }
}

static void SetModelName_Fan(void)
{
    if (Config_Model_Name(Uart5Fd, ADDR_FAN, pSysConfig->ModelName) == PASS) {
        log_info("Set Model name PASS = %s ", pSysConfig->ModelName);
    }
}

static void GetFwAndHwVersion_Fan(void)
{
    Ver ver = { 0 };

    if (Query_FW_Ver(Uart5Fd, ADDR_FAN, &ver) == PASS) {
        // FanModuleData
        strcpy((char*)ShmFanModuleData->version, ver.Version_FW);
        // SystemInfo
        strcpy((char*)pSysInfo->FanModuleFwRev, ver.Version_FW);
        //log_info("GetFwAndHwVersion_Fan s1 = %s ", ver.Version_FW);
    }

    if (Query_HW_Ver(Uart5Fd, ADDR_FAN, &ver) == PASS) {
        // SystemInfo
        strcpy((char*)pSysInfo->FanModuleHwRev, ver.Version_FW);
        //log_info("GetFwAndHwVersion_Fan s2 = %s ", ver.Version_HW);
    }
}

static void fanBoardSelfTest(void)
{
    if (ShmFanModuleData->SelfTest_Comp == YES) {
        return;
    }

    GetFwAndHwVersion_Fan();
    SetModelName_Fan();
    SetRtcData_Fan();
    sleep(1);
    gettimeofday(&gFanBoardRunTimer, NULL);
}

static void fanBoardPorcess(void)
{
    if (ShmFanModuleData->SelfTest_Comp == NO) {
        return;
    }

    if (ShmFanModuleData->SelfTest_Comp == YES ||
        strlen((char*)pSysInfo->FanModuleFwRev) != 0 ||
        pSysInfo->FanModuleFwRev[0] != '\0') {
        ShmFanModuleData->SelfTest_Comp = YES;

        if (GetTimeoutValue(gFanBoardRunTimer) / 1000 >= 1000) {
            //GetPsuTempForFanSpeed();
            GetFanSpeedByFunction();
            GetFanSpeed();
            pSysInfo->SystemFanRotaSpeed = _setFanSpeed;
            gettimeofday(&gFanBoardRunTimer, NULL);

            ShmFanModuleData->SetFan1Speed = ShmFanModuleData->TestFanSpeed;
            ShmFanModuleData->SetFan2Speed = ShmFanModuleData->TestFanSpeed;
            ShmFanModuleData->SetFan3Speed = ShmFanModuleData->TestFanSpeed;
            ShmFanModuleData->SetFan4Speed = ShmFanModuleData->TestFanSpeed;

            //log_info("set fan = %d ", ShmFanModuleData->SetFan1Speed);
            SetFanModuleSpeed();
        }
    }
}

void FanBoardTask(int uartFD)
{
#if defined NO_FAN_BOARD || defined DD360ComBox
#endif //defined NO_FAN_BOARD || defined DD360ComBox

    pid_t pid = fork();

    if (pid == 0) {
        int isContinue = 1;

        //share memory mapping
        pSysConfig = (struct SysConfigData *)GetShmSysConfigData();
        pSysInfo = (struct SysInfoData *)GetShmSysInfoData();
        pAlarmCode = (struct AlarmCodeData *)GetShmAlarmCodeData();
        ShmFanModuleData = (struct FanModuleData *)GetShmFanModuleData();
        ShmPsuData = (struct PsuData *)GetShmPsuData();

        Uart5Fd = uartFD;

        while (isContinue) {
            fanBoardSelfTest();

            fanBoardPorcess();
            usleep(100000);
        }
    }
}