dev_fan.c

Go to the documentation of this file.

 
 
 
#include "dev_fan.h"
#include "dev_temp.h"
#include "config/macros.h"
 
 
FAN_DATA_t devFanData;
FAN_DATA_t* devFanDataPtr = &devFanData;
 
enum FAN_SETTINGS_e {
    NO_CHANGE     = 0,
    CHANGE_SPEED  = 1,
};
typedef enum FAN_SETTINGS_e FAN_SETTINGS_t;
 
static FAN_SETTINGS_t changeSpeed = CHANGE_SPEED;
 
//Private Function Call Prototypes
static uint16_t Convert_From_Percentage (uint8_t percentage);
static uint8_t Convert_From_Raw(uint16_t raw);
static void Override_Speed(void);
static void Calculate_Speed(void);
static void Update_Speed(void);
 
 
 
void Dev_Fan_Initialize(void)
{
    devFanData.CurrentSpeedPercent = 0 ;
    devFanData.TargetSpeedPercent = INIT_SPEED_PERCENT;
    devFanData.MaxSpeedPercent = MAX_SPEED_PERCENT;
    devFanData.Tick = 5 ;
    devFanData.StepSizePercent = STEP_SIZE ;
    devFanData.TargetSpeedRaw = 0 ;
    devFanData.CurrentSpeedRaw = 0 ;
    devFanData.MaxSpeedRaw = Convert_From_Percentage(MAX_SPEED_PERCENT);
    //dev_fan_data.hystersis_raw = Convert_From_Percentage(HYSTERESIS);
    devFanData.OverrideFlag = 0 ;
}
 
 
void Dev_Fan_Task_100ms(void) 
{
    static uint8_t currentTickCount;
   
    if (devFanData.OverrideFlag == 1) 
    {
        changeSpeed = CHANGE_SPEED;
        Override_Speed();
        Calculate_Speed();
        Update_Speed();     
    }
    else if (++currentTickCount >= devFanData.Tick) 
    {
        Calculate_Speed();
        Update_Speed();
        currentTickCount = 0;
    }
}
 
 
void Dev_Fan_Task_1s(void) 
{
    static uint8_t fanSpeedPercent = 0;
    uint16_t TCelsiusNTC = Dev_Temp_Get_Temperature_Celcius();//
    
    if(TCelsiusNTC > H_TEMPERATURE_THRESHOLD){
        fanSpeedPercent += 2;
        // Fan speed maximum clamping value
        if(fanSpeedPercent >= MAX_SPEED_PERCENT){
            fanSpeedPercent = MAX_SPEED_PERCENT;
        }
        else{}
    }
    else if(TCelsiusNTC < L_TEMPERATURE_THRESHOLD){
        fanSpeedPercent -= 2;
        // Fan speed minimum clamping value
        if(fanSpeedPercent <= 10){
            fanSpeedPercent = 10;//hw request to have a minimum load on auxiliary supply
        } 
        else{}
    }
    else{}
        
    Dev_Fan_Set_Speed(fanSpeedPercent);
}        
 
 
void Dev_Fan_Set_Override(void) 
{
    devFanData.OverrideFlag = 1;
    Override_Speed();
}
 
 
void Dev_Fan_Set_Speed(uint8_t target_speed_percent) 
{
    if (target_speed_percent <= MAX_SPEED_PERCENT)
    {
        devFanData.TargetSpeedPercent = target_speed_percent;
    }
}
 
 
static uint16_t Convert_From_Percentage(uint8_t percentage_value) 
{
    return (percentage_value * MULTIPLIER) ;
}
 
 
static void Override_Speed(void) 
{
    devFanData.TargetSpeedPercent = MAX_SPEED_PERCENT;
    devFanData.Tick = MIN_TICK;
}
 
 
static void Calculate_Speed(void) 
{
    devFanData.TargetSpeedPercent -= (devFanData.TargetSpeedPercent % devFanData.StepSizePercent);
    
    devFanData.TargetSpeedRaw = Convert_From_Percentage(devFanData.TargetSpeedPercent);
    
    if (devFanData.CurrentSpeedRaw > (devFanData.TargetSpeedRaw ))
    {
        devFanData.CurrentSpeedRaw -= Convert_From_Percentage(devFanData.StepSizePercent); 
        changeSpeed = CHANGE_SPEED;
    }
        
    else if (devFanData.CurrentSpeedRaw < (devFanData.TargetSpeedRaw )) 
    {
        devFanData.CurrentSpeedRaw += Convert_From_Percentage(devFanData.StepSizePercent) ;
        changeSpeed = CHANGE_SPEED;
    } 
    else 
    {
        changeSpeed = NO_CHANGE;
    }
} 
 
 
static void Update_Speed(void) 
{
    if (changeSpeed != NO_CHANGE)
    {
        if (devFanData.CurrentSpeedRaw > devFanData.MaxSpeedRaw)
        {
            devFanData.CurrentSpeedRaw = devFanData.MaxSpeedRaw;
        }
        FAN_PWM_DutyCycleSet(devFanData.CurrentSpeedRaw);
        devFanData.CurrentSpeedPercent = Convert_From_Raw(devFanData.CurrentSpeedRaw);
    }
}
 
 
static uint8_t Convert_From_Raw(uint16_t raw) 
{
    return ( raw * 0.02 );  //TODO: recalculate math
}