#include <ac_control.h>

Inheritance diagram for AcController:

[legend]

Collaboration diagram for AcController:

[legend]

Public Types
using	interface_t = AcController

Public Member Functions
void	onSlowCallback () override

virtual bool	isAcEnabled () const

Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()

virtual void	setDefaultConfiguration ()

virtual void	onConfigurationChange (engine_configuration_s const *)

virtual void	onFastCallback ()

virtual void	onEngineStop ()

virtual void	onIgnitionStateChanged (bool)

virtual bool	needsDelayedShutoff ()

virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)

Data Fields
Timer	timeSinceStateChange

Data Fields inherited from ac_control_s
int8_t	acButtonState = (int8_t)0

uint8_t	alignmentFill_at_1 [3] = {}

bool	m_acEnabled: 1 {}

bool	engineTooSlow: 1 {}

bool	engineTooFast: 1 {}

bool	noClt: 1 {}

bool	engineTooHot: 1 {}

bool	tpsTooHigh: 1 {}

bool	isDisabledByLua: 1 {}

bool	acCompressorState: 1 {}

bool	acPressureTooLow: 1 {}

bool	acPressureTooHigh: 1 {}

bool	unusedBit_12_10: 1 {}

bool	unusedBit_12_11: 1 {}

bool	unusedBit_12_12: 1 {}

bool	unusedBit_12_13: 1 {}

bool	unusedBit_12_14: 1 {}

bool	unusedBit_12_15: 1 {}

bool	unusedBit_12_16: 1 {}

bool	unusedBit_12_17: 1 {}

bool	unusedBit_12_18: 1 {}

bool	unusedBit_12_19: 1 {}

bool	unusedBit_12_20: 1 {}

bool	unusedBit_12_21: 1 {}

bool	unusedBit_12_22: 1 {}

bool	unusedBit_12_23: 1 {}

bool	unusedBit_12_24: 1 {}

bool	unusedBit_12_25: 1 {}

bool	unusedBit_12_26: 1 {}

bool	unusedBit_12_27: 1 {}

bool	unusedBit_12_28: 1 {}

bool	unusedBit_12_29: 1 {}

bool	unusedBit_12_30: 1 {}

bool	unusedBit_12_31: 1 {}

Static Public Attributes
static constexpr int	PRESSURE_DEADBAND_WIDTH = 5

Private Member Functions
bool	getAcState ()

Private Attributes
Timer	m_timeSinceNoAc

Detailed Description

Definition at line 6 of file ac_control.h.

Member Typedef Documentation

◆ interface_t

using AcController::interface_t = AcController

Definition at line 10 of file ac_control.h.

Member Function Documentation

◆ getAcState()

bool AcController::getAcState ( )

private

Definition at line 16 of file ac_control.cpp.

                              {
    auto rpm = Sensor::getOrZero(SensorType::Rpm);
 
    engineTooSlow = rpm < 500;
 
    if (engineTooSlow) {
        return false;
    }
 
    auto maxRpm = engineConfiguration->maxAcRpm;
    engineTooFast = maxRpm != 0 && maxRpmDeadband.gt(rpm, maxRpm);
    if (engineTooFast) {
        return false;
    }
 
    auto clt = Sensor::get(SensorType::Clt);
 
    noClt = !clt;
    // No AC with failed CLT
    if (noClt) {
        return false;
    }
 
    // Engine too hot, disable
    auto maxClt = engineConfiguration->maxAcClt;
    engineTooHot = (maxClt != 0) && maxCltDeadband.gt(clt.Value, maxClt);
    if (engineTooHot) {
        return false;
    }
 
    // TPS too high, disable
    auto maxTps = engineConfiguration->maxAcTps;
    tpsTooHigh = maxTps != 0 && maxTpsDeadband.gt(Sensor::getOrZero(SensorType::Tps1), maxTps);
    if (tpsTooHigh) {
            return false;
    }
 
    const auto acPressure= Sensor::get(SensorType::AcPressure);
    if (acPressure.Valid) {
        const auto minAcPressure = static_cast<float>(engineConfiguration->minAcPressure);
        acPressureTooLow = minPressureDeadband.lt(acPressure.Value, minAcPressure);
        if (acPressureTooLow) {
            return false;
        }
 
        const auto maxAcPressure = static_cast<float>(engineConfiguration->maxAcPressure);
        acPressureTooHigh = acPressureEnableHysteresis.checkIfLimitIsExceeded(
            acPressure.Value,
            maxAcPressure,
            engineConfiguration->acPressureEnableHyst
        );
        if (acPressureTooHigh) {
            return false;
        }
    }
 
    if (isDisabledByLua) {
        return false;
    }
 
    // All conditions allow AC, simply pass thru switch
    return acButtonState;
}

Referenced by onSlowCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isAcEnabled()

bool AcController::isAcEnabled ( ) const

virtual

Definition at line 101 of file ac_control.cpp.

                                     {
    return m_acEnabled;
}

◆ onSlowCallback()

void AcController::onSlowCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 80 of file ac_control.cpp.

                                  {
    bool isEnabled = getAcState();
 
    m_acEnabled = isEnabled;
 
    if (!isEnabled) {
        // reset the timer if AC is off
        m_timeSinceNoAc.reset();
    }
 
    float acDelay = engineConfiguration->acDelay;
    if (acDelay == 0) {
        // Without delay configured, enable immediately
        acCompressorState = isEnabled;
    } else {
        acCompressorState = isEnabled && m_timeSinceNoAc.hasElapsedSec(acDelay);
    }
 
    enginePins.acRelay.setValue(acCompressorState);
}

Here is the call graph for this function:

Field Documentation

◆ m_timeSinceNoAc

Timer AcController::m_timeSinceNoAc

private

Definition at line 21 of file ac_control.h.

Referenced by onSlowCallback().

◆ PRESSURE_DEADBAND_WIDTH

constexpr int AcController::PRESSURE_DEADBAND_WIDTH = 5

staticconstexpr

Definition at line 8 of file ac_control.h.

◆ timeSinceStateChange

Timer AcController::timeSinceStateChange

Definition at line 16 of file ac_control.h.

Referenced by configureRusefiLuaHooks(), IdleController::getClosedLoop(), and Engine::updateSwitchInputs().

The documentation for this class was generated from the following files:

controllers/actuators/ac_control.h
controllers/actuators/ac_control.cpp

Public Types

Public Member Functions

Data Fields

Static Public Attributes

Private Member Functions

Private Attributes