DIY Wind Simulator with RPM gauge

/*
 * Copyright (c) 2021 MotionSystems.eu
 *
 * Licensed under:
 * Creative Commons Attribution-NonCommercial-NoDerivs (CC-BY-NC-ND)
 * https://creativecommons.org/licenses/by-nc-nd/4.0/
 */
 
namespace AtmegaTimers
{
    static constexpr const struct Prescaler
    {
        uint8_t       clockSelectBits;
        unsigned int  divider;
        unsigned long limit;
    } TIM1_PRESCALERS[] = {     // ATmega328P PDF, page 110
        {                         _BV(CS10), 1,    65536ul * 1    }, // 0 0 1 | clk/1
        {             _BV(CS11)            , 8,    65536ul * 8    }, // 0 1 0 | clk/8
        {             _BV(CS11) | _BV(CS10), 64,   65536ul * 64   }, // 0 1 1 | clk/64
        { _BV(CS12)                        , 256,  65536ul * 256  }, // 1 0 0 | clk/256
        { _BV(CS12) |             _BV(CS10), 1024, 65536ul * 1024 }, // 1 0 1 | clk/1024
    }, TIM2_PRESCALERS[] = {    // ATmega328P PDF, page 131
        {                         _BV(CS20), 1,    256ul   * 1    }, // 0 0 1 | clkT2S/1
        {             _BV(CS21)            , 8,    256ul   * 8    }, // 0 1 0 | clkT2S/8
        {             _BV(CS21) | _BV(CS20), 32,   256ul   * 32   }, // 0 1 1 | clkT2S/32
        { _BV(CS22)                        , 64,   256ul   * 64   }, // 1 0 0 | clkT2S/64
        { _BV(CS22)             | _BV(CS20), 128,  256ul   * 128  }, // 1 0 1 | clkT2S/128
        { _BV(CS22) | _BV(CS21)            , 256,  256ul   * 256  }, // 1 1 0 | clkT2S/256
        { _BV(CS22) | _BV(CS21) | _BV(CS20), 1024, 256ul   * 1024 }, // 1 1 1 | clkT2S/1024
    };
 
    template <size_t N>
    void findPrescaler(const Prescaler (&prescalers)[N],
                       unsigned long reqTimerTicks,
                       uint8_t&  clockSelectBits,
                       uint16_t& period)
    {
        clockSelectBits = 0;
        period          = 0;
 
        for (const auto& prescaler : prescalers)
        {
            if (reqTimerTicks <= prescaler.limit)
            {
                clockSelectBits = prescaler.clockSelectBits;
                period = static_cast<uint16_t>(reqTimerTicks / prescaler.divider - 1);
                break;
            }
        }
    }
}
 
namespace PwmGeneratorTIM1
{
    static constexpr const int OUTPUT_PINS[] = { 9, 10 };
 
    static constexpr const unsigned int DUTY_MAX = 1023ul;
 
    void init(unsigned int freq_Hz)
    {
        auto timerTicks = static_cast<unsigned long>(clockCyclesPerMicrosecond() * 1000000ul / 2)
                          / (max(1u, freq_Hz));
 
        uint8_t  clockSelectBits = 0;
        uint16_t pwmPeriod = 0;
        findPrescaler(AtmegaTimers::TIM1_PRESCALERS, timerTicks, clockSelectBits, pwmPeriod);
 
        TCCR1A = 0; // clear control register
 
        pinMode(OUTPUT_PINS[0], OUTPUT);
        TCCR1A |= _BV(COM1A1); // Compare output mode
 
        pinMode(OUTPUT_PINS[1], OUTPUT);
        TCCR1A |= _BV(COM1B1); // Compare output mode
 
        ICR1   = pwmPeriod;
        TCCR1B = _BV(WGM13) | // PWM, phase and frequency correct
                 clockSelectBits;
    }
 
    inline void setPwmDuty(int pin, unsigned int duty)
    {
        unsigned long tmp = ICR1; // get maximum period
        tmp *= min(duty, DUTY_MAX);
        tmp >>= 10; // 0 to 1023
        static_assert(DUTY_MAX == 1023ul, "");
 
        switch (pin)
        {
            case OUTPUT_PINS[0]: OCR1A = tmp; break;
            case OUTPUT_PINS[1]: OCR1B = tmp; break;
            default:                          break;
        }
    }
}
 
namespace FreqGeneratorTIM2
{
    static constexpr const int OUTPUT_PIN = 11;
 
    inline constexpr unsigned long periodToTick(unsigned long period_us)
    {
        return period_us * clockCyclesPerMicrosecond() / 2;
    }
 
    void init()
    {
        pinMode(OUTPUT_PIN, OUTPUT);
    }
 
    void setPeriodInTicks(unsigned long timerTicks)
    {
        if (timerTicks == 0)
        {
            TCCR2A &= ~_BV(COM2A0); // Do not toggle OC2A on compare match
            return;
        }
 
        uint8_t  clockSelectBits = 0;
        uint16_t compareValue    = 0;
        findPrescaler(AtmegaTimers::TIM2_PRESCALERS, timerTicks, clockSelectBits, compareValue);
 
        OCR2A  = compareValue;     // OCR2A is PB3, mapped to Arduino Uno pin 11 (OUTPUT_PIN)
        TCCR2A = (_BV(WGM21) |     // 2 Clear Timer on Compare Match (CTC) Mode
                 ( _BV(COM2A0)));  // Toggle OC2A on compare match
        TCCR2B = clockSelectBits;
    }
}
 
namespace
{
    enum
    {
        BlowerLeft  = 0,
        BlowerRight = 1,
 
        BlowersCount = 2,
 
        BusyWaitTimeout       = 5,
        InactivityTimeout     = 3000,
        PwmDutyUpdateInterval = 20,
 
        SerialSpeed = 115200,
 
        PwmFrequency = 14500, // Incorrect value might overheat the transistor
        PwmDutyMin   = 100,   // Minimum PWM that makes any sense for blower
        PwmDutyMax   = 1023,  // It has to be <= PwmGeneratorTIM1::DUTY_MAX,
                              // put less than DUTY_MAX if the power supply turns off
        PwmDutyStep  = 40,
 
        RpmHzFor3000 = 200, // TODO: Change this value to match your RPM gauge!
 
        MaxSpeedFromPC             = 99,
        MaxBlowerSpeedDigitsFromPC = 2,
        MaxRpmDigitsFromPC         = 5
    };
 
    static_assert(static_cast<unsigned int>(PwmDutyMax) <= PwmGeneratorTIM1::DUTY_MAX, "");
    static_assert(RpmHzFor3000 >= 200, "Value less than 200 will cut anything below 1000 RPM");
 
    static struct
    {
        int current;
        int required;
    } g_pwmDuties[] = {
        { 0, 0 },
        { 0, 0 }
    };
 
    static unsigned long g_rpmReqTicks        = 0;
    static unsigned long g_dataReceivedMark   = 0;
    static unsigned long g_pwmDutyUpdateMark  = 0;
 
    bool isDataAvailable()
    {
        auto mark = millis();
        while (Serial.available() == 0)
        {
            if (millis() > mark + BusyWaitTimeout)
            {
                return false;
            }
        }
        return true;
    }
 
    bool readNumberFromSerial(long& value, int maxDigits)
    {
        value = 0;
        for (int i = 0; i < maxDigits; ++i)
        {
            if (! isDataAvailable())
            {
                return false;
            }
 
            auto tmp = Serial.read();
            if (! isDigit(tmp))
            {
                return false;
            }
 
            value *= 10;
            value += (tmp - '0');
        }
        return true;
    }
}
 
void setup()
{
    PwmGeneratorTIM1::init(PwmFrequency);
    PwmGeneratorTIM1::setPwmDuty(PwmGeneratorTIM1::OUTPUT_PINS[0], 0);
    PwmGeneratorTIM1::setPwmDuty(PwmGeneratorTIM1::OUTPUT_PINS[1], 0);
 
    FreqGeneratorTIM2::init();
    FreqGeneratorTIM2::setPeriodInTicks(0);
 
    Serial.begin(SerialSpeed);
}
 
void loop()
{
    auto ok   = readData();
    auto mark = millis();
 
    if (ok)
    {
        g_dataReceivedMark = mark;
    }
    else if (mark > g_dataReceivedMark + InactivityTimeout)
    {
        for (int i = 0; i < BlowersCount; ++i)
        {
            g_pwmDuties[i].required = 0;
        }
 
        g_rpmReqTicks = 0;
    }
 
    FreqGeneratorTIM2::setPeriodInTicks(g_rpmReqTicks);
 
    auto diff = mark - g_pwmDutyUpdateMark;
    if (diff < PwmDutyUpdateInterval)
    {
        return;
    }
 
    g_pwmDutyUpdateMark = mark;
 
    // To compensate not perfect intervals
    auto step = static_cast<int>(PwmDutyStep * diff / PwmDutyUpdateInterval);
    for (int i = 0; i < BlowersCount; ++i)
    {
        auto& info = g_pwmDuties[i];
        if (info.required == 0)
        {
            info.current = 0;
        }
        else if (info.required > info.current)
        {
            info.current = min(info.required, info.current + step);
        }
        else
        {
            info.current = max(info.required, info.current - step);
        }
 
        PwmGeneratorTIM1::setPwmDuty(PwmGeneratorTIM1::OUTPUT_PINS[i], info.current);
    }
}
 
bool readData()
{
    if (! isDataAvailable())
    {
        return false;
    }
 
    auto cmd = Serial.read();
 
    switch (cmd)
    {
        case 'L': return readDataBlower(BlowerLeft);
        case 'R': return readDataBlower(BlowerRight);
        case 'e': /*TODO: Shift light ON*/
        case 'E': return readDataRpm();
        default:  return false;
    }
}
 
bool readDataBlower(int blowerIndex)
{
    long speed = 0;
 
    if (readNumberFromSerial(speed, MaxBlowerSpeedDigitsFromPC))
    {
        g_pwmDuties[blowerIndex].required = 0 == speed
            ? 0
            : map(speed, 1, MaxSpeedFromPC, PwmDutyMin, PwmDutyMax);
 
        return true;
    }
 
    return false;
}
 
bool readDataRpm()
{
    long rpm = 0;
 
    if (readNumberFromSerial(rpm, MaxRpmDigitsFromPC))
    {
        static constexpr const auto FACTOR = 1000000ul * 3000/*rpm*/ / RpmHzFor3000;
        g_rpmReqTicks = FreqGeneratorTIM2::periodToTick(FACTOR / static_cast<unsigned long>(rpm));
 
        return true;
    }
 
    return false;
}