state_sequence.h

Go to the documentation of this file.

/**
 * @file    state_sequence.h
 *
 * @date May 18, 2014
 * @author Andrey Belomutskiy, (c) 2012-2020
 */
 
#pragma once
 
#include <stdint.h>
#include "rusefi_enums.h"
#include <rusefi/expected.h>
 
enum class TriggerValue : uint8_t {
    FALL = 0,
    RISE = 1
};
 
// see also 'HW_EVENT_TYPES'
typedef enum {
    SHAFT_PRIMARY_FALLING = 0,
    SHAFT_PRIMARY_RISING = 1,
    SHAFT_SECONDARY_FALLING = 2,
    SHAFT_SECONDARY_RISING = 3,
} trigger_event_e;
 
/**
 * This layer has two primary usages:
 * 1) 'simple' PWM generation is used to produce actuator square control wave
 * 2) 'complex' PWM generation is used for trigger simulator.
 * Some triggers like Nissan 360 slot optical wheel need a lot of points to describe the shape of the wave.
 * Looks like 252 is explained by 60 tooth * 2 (number of fronts) * 2 (number of crank rotations within engine cycle)
 */
#ifndef PWM_PHASE_MAX_COUNT
// as of April 2020, trigger which requires most array length is REMIX_66_2_2_2
// we can probably reduce RAM usage if we have more custom logic of triggers with large number of tooth while
// pretty easy logic. like we do not need to REALLY have an array to remember the shape of evenly spaces 360 or 60/2 trigger :)
// todo https://github.com/rusefi/rusefi/issues/3003
#define PWM_PHASE_MAX_COUNT 280
#endif /* PWM_PHASE_MAX_COUNT */
#define PWM_PHASE_MAX_WAVE_PER_PWM 2
 
typedef TriggerValue pin_state_t;
 
/**
 * This class represents multi-channel logical signals with shared time axis
 *
 * This is a semi-abstract interface so that implementations can exist for either regularized
 * patterns (60-2, etc) or completely arbitrary patterns stored in arrays.
 */
class MultiChannelStateSequence {
public:
    /**
     * values in the (0..1] range which refer to points within the period at at which pin state
     * should be changed So, in the simplest case we turn pin off at 0.3 and turn it on at 1 -
     * that would give us a 70% duty cycle PWM
     */
    virtual float getSwitchTime(int phaseIndex) const = 0;
    virtual pin_state_t getChannelState(int channelIndex, int phaseIndex) const = 0;
 
    // Make sure the switch times are in order and end at the very end.
    void checkSwitchTimes(float scale) const;
 
    // Find the exact angle, or unexpected if it doesn't exist
    expected<int> findAngleMatch(float angle) const;
 
    // returns the index at which given value would need to be inserted into sorted array
    int findInsertionAngle(float angle) const;
 
    uint16_t phaseCount = 0; // Number of timestamps
    uint16_t waveCount = 0; // Number of waveforms
};
 
template<unsigned max_phase>
class MultiChannelStateSequenceWithData : public MultiChannelStateSequence {
public:
    float getSwitchTime(int phaseIndex) const override {
        return switchTimes[phaseIndex];
    }
 
    pin_state_t getChannelState(int channelIndex, int phaseIndex) const override {
        if (channelIndex >= waveCount) {
            // todo: would be nice to get this asserting working
            //criticalError("channel index %d/%d", channelIndex, waveCount);
        }
        return ((waveForm[phaseIndex] >> channelIndex) & 1) ? TriggerValue::RISE : TriggerValue::FALL;
    }
 
    void reset() {
        waveCount = 0;
    }
 
    void setSwitchTime(const int phaseIndex, const float value) {
        switchTimes[phaseIndex] = value;
    }
 
    void setChannelState(const int channelIndex, const int phaseIndex, pin_state_t state) {
        if (channelIndex >= waveCount) {
            // todo: would be nice to get this asserting working
            //criticalError("channel index %d/%d", channelIndex, waveCount);
        }
        uint8_t & ref = waveForm[phaseIndex];
        ref = (ref & ~(1U << channelIndex)) | ((state == TriggerValue::RISE ? 1 : 0) << channelIndex);
    }
 
private:
    float switchTimes[max_phase];
    uint8_t waveForm[max_phase];
};