Logic Namespace Reference

This module contains the logic of the firmware. More...

Enumerations
enum	UserAction : uint8_t { UA_None, UA_NewSetPoint, UA_DisableFlash }
	The action the user would like to do. More...

Functions
UserAction	getUserAction ()
	Wait for the button release to get the selected user action. More...
void	configurationMode ()
	The configuration mode. More...
void	testMode ()
	The test mode. More...
void	main ()
	The main loop of the firmware. More...

Variables
const char cFirmwareSignature []	PROGMEM = "FW" LR_FIRMWARE_VERSION ":LuckyResistor"
	A message for the release version written into the image. More...

Detailed Description

This module contains the logic of the firmware.

Enumeration Type Documentation

UserAction

enum Logic::UserAction : uint8_t

The action the user would like to do.

Enumerator
UA_None	No action, the user accidentally pressed the button.
UA_NewSetPoint	Write a new set-point with the current value.
UA_DisableFlash	Disable the annoying flashing until a new set-point is written.

Definition at line 58 of file Logic.cpp.

                : uint8_t {
    UA_None, 
    UA_NewSetPoint, 
    UA_DisableFlash, 
};

Function Documentation

configurationMode()

void Logic::configurationMode

(

)

The configuration mode.

A sub logic entered if the button is pressed on the interface.

Definition at line 97 of file Logic.cpp.

{
    // Check the requested user action.
    const UserAction userAction = getUserAction();
    if (userAction == UA_NewSetPoint) {
        // Write the current oscillator frequency as new set-point to the settings.
        Settings::setSetPointFrequency(currentOscillatorFrequency+Configuration::cSetPointCompensation);
        Settings::write();
    } else if (userAction == UA_DisableFlash) {
        Settings::setSetPointFrequency(Configuration::cDisabledSetPointFrequency);
        Settings::write();
    }
    // Just ignore the action otherwise.
}

getUserAction()

UserAction Logic::getUserAction

(

)

Wait for the button release to get the selected user action.

Returns

The selected user action.

Definition at line 69 of file Logic.cpp.

{
    // Pulse green for ~3 seconds while the button is pressed.
    for (uint8_t i = 0; i < Configuration::cLogicPulsesForUserAction; ++i) {
        Display::pulse(Display::Green);
        if (!Hardware::isButtonPressed()) {
            // Abort if the button is released in this state.
            return UA_None;
        }
    }
    // After green, pulse for ~3 seconds in red.
    for (uint8_t i = 0; i < Configuration::cLogicPulsesForUserAction; ++i) {
        Display::pulse(Display::Red);
        if (!Hardware::isButtonPressed()) {
            // A new set point shall be selected.
            Display::flash(Display::Green, 3);
            return UA_NewSetPoint;
        }
    }
    // The flash should be disabled until a new set-point is written.
    Display::flash(Display::Red, 3);
    return UA_DisableFlash;
}

main()

void Logic::main

(

)

The main loop of the firmware.

Definition at line 139 of file Logic.cpp.

{
    // Setup everything.
    Hardware::setup();
    
    // Test loop (disabled in production)
    do {        
        // Time elapsed since at this point, after power level on MCU reached 2V:
        // BOD off       SUT = 0b10: ~60ms
        // BOD on (1.8V) SUT = 0b00:  ~4ms
    
        // Oscillator is working after 1ms, no delay required.
    
        // Step 1: Check the battery level
        currentVoltage = Hardware::getVoltageValue();
        if (currentVoltage < Configuration::cMinimumVoltageValue) {
            // Signal low battery using two short flashes.
            Display::flash(Display::Red, 2);
            // Wait until the button is released
            while (Hardware::isButtonPressed()) {}
            goto lDone;
        } else if (Configuration::cTestModeEnabled && currentVoltage > Configuration::cTestVoltageValue) {
            testMode();
        }
        if (Configuration::cPowerSave) {
            Hardware::shutdownVoltageMeasurement();
        }
    
        // Step 2: Measure the current frequency of the oscillator.
        currentOscillatorFrequency = Hardware::getOscillatorFrequency();
        if (Configuration::cPowerSave) {
            Hardware::shutdownOscillatorCounter();
        }
        
        // Step 3: Read the reference frequency from the EEPROM.
        Settings::read();
        const uint8_t setpointOscillatorFrequency = Settings::getSetPointFrequency();

        // Step 4: Check if the button is pressed.
        if (Configuration::cConfigurationModeEnabled && Hardware::isButtonPressed()) {
            // Go to the configuration mode.
            configurationMode();
        } else {
            // Just check the status and give a signal if we are below set-point.
            if (currentOscillatorFrequency >= setpointOscillatorFrequency) {
                // Send a single flash signal.
                Display::flash(Display::Green, 1);
            }
        }
        
        // Wait 5s if the test loop is enabled.
        if (Configuration::cTestLoopEnabled) {
            Tool::delayMs(2000);
        }

        if (Configuration::cFirmwareSignatureEnabled) {
            // On "use" the firmware identifier to keep it in memory.
            pgm_read_byte(cFirmwareSignature);
        }
        
    } while (Configuration::cTestLoopEnabled); 

lDone:
    // Log the current values if the logger is activated.
    if (Configuration::cLoggingEnabled) {
        Logger::log(currentOscillatorFrequency, currentVoltage, Hardware::isButtonPressed());
    }

    // Send the done signal and repeat until the system timer turns off the power.
    while (1) {
        Hardware::sendDoneSignal();
    }
}

testMode()

void Logic::testMode

(

)

The test mode.

A sub logic entered if the supply voltage is >4V.

Definition at line 118 of file Logic.cpp.

{
    while (1) { 
        for (uint8_t i = 0; i < 4; i++) {
            Display::dimSignal(Display::Red);
            Display::dimSignal(Display::Green);
        }
        for (uint8_t i = 0; i < 100; ++i) {
            currentOscillatorFrequency = Hardware::getOscillatorFrequency();
            if (currentOscillatorFrequency > Configuration::cTestHighOscillator) {
                Display::dimSignal(Display::Green);
            } else if (currentOscillatorFrequency < Configuration::cTestLowOscillator) {
                Display::dimSignal(Display::Red);
            } else {
                Tool::delayMs(100);
            }
        }
    }
}

Variable Documentation

PROGMEM

const char cFirmwareSignature [] Logic::PROGMEM = "FW" LR_FIRMWARE_VERSION ":LuckyResistor"

A message for the release version written into the image.

Definition at line 53 of file Logic.cpp.