SimRacing.h

Go to the documentation of this file.

/*
 *  Project     Sim Racing Library for Arduino
 *  @author     David Madison
 *  @link       github.com/dmadison/Sim-Racing-Arduino
 *  @license    LGPLv3 - Copyright (c) 2022 David Madison
 *
 *  This file is part of the Sim Racing Library for Arduino.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef SIM_RACING_LIB_H
#define SIM_RACING_LIB_H
 
#include <Arduino.h>
 
namespace SimRacing {
    using PinNum = int16_t;
 
    const PinNum UnusedPin = -1;
 
 
    enum Axis : uint8_t {
        X = 0,  
        Y = 1,  
    };
 
 
    class DeviceConnection {
    public:
        enum ConnectionState {
            Disconnected,  
            PlugIn,        
            Connected,     
            Unplug,        
        };
 
        DeviceConnection(PinNum pin, bool invert = false, unsigned long detectTime = 250);
 
        void poll();
 
        ConnectionState getState() const;
 
        bool isConnected() const;
 
        void setStablePeriod(unsigned long t);
 
    private:
        bool readPin() const;
 
        PinNum pin;                  
        bool inverted;               
        unsigned long stablePeriod;  
 
        ConnectionState state;       
        bool pinState;               
        unsigned long lastChange;    
    };
 
 
    class AnalogInput {
    public:
        static const int Min = 0;     
        static const int Max = 1023;  
 
        AnalogInput(PinNum pin);
 
        virtual bool read();
 
        long getPosition(long rMin = Min, long rMax = Max) const;
 
        int getPositionRaw() const;
 
        int getMin() const { return this->cal.min; }
 
        int getMax() const { return this->cal.max; }
 
        bool isInverted() const;
 
        void setPosition(int newPos);
 
        void setInverted(bool invert = true);
 
        struct Calibration {
            int min;  
            int max;  
        };
 
        void setCalibration(Calibration newCal);
 
    private:
        PinNum pin;              
        int position;            
        Calibration cal;         
    };
 
 
    class Peripheral {
    public:
        virtual void begin() {};
 
        virtual bool update() = 0;
 
        virtual bool isConnected() const { return true; }
    };
 
 
    enum Pedal {
        Gas = 0,
        Accelerator = Gas,
        Throttle = Gas,
        Brake = 1,
        Clutch = 2,
    };
 
    class Pedals : public Peripheral {
    public:
        using PedalID = SimRacing::Pedal;
 
        Pedals(AnalogInput* dataPtr, uint8_t nPedals, PinNum detectPin);
 
        virtual void begin();
 
        virtual bool update();
 
        long getPosition(PedalID pedal, long rMin = 0, long rMax = 100) const;
 
        int getPositionRaw(PedalID pedal) const;
 
        bool hasPedal(PedalID pedal) const;
 
        int getNumPedals() const { return this->NumPedals; }
 
        bool positionChanged() const { return changed; }
 
        void setCalibration(PedalID pedal, AnalogInput::Calibration cal);
 
        void serialCalibration(Stream& iface = Serial);
        
        bool isConnected() const { return detector.isConnected(); }
 
        static String getPedalName(PedalID pedal);
 
    private:
        AnalogInput* pedalData;     
        const int NumPedals;        
        DeviceConnection detector;  
        bool changed;               
    };
 
 
    class TwoPedals : public Pedals {
    public:
        TwoPedals(PinNum pinGas, PinNum pinBrake, PinNum pinDetect = UnusedPin);
 
        void setCalibration(AnalogInput::Calibration gasCal, AnalogInput::Calibration brakeCal);
 
    private:
        static const uint8_t NumPedals = 2;  
        AnalogInput pedalData[NumPedals];    
    };
 
 
    class ThreePedals : public Pedals {
    public:
        ThreePedals(PinNum pinGas, PinNum pinBrake, PinNum pinClutch, PinNum pinDetect = UnusedPin);
 
        void setCalibration(AnalogInput::Calibration gasCal, AnalogInput::Calibration brakeCal, AnalogInput::Calibration clutchCal);
 
    private:
        static const uint8_t NumPedals = 3;  
        AnalogInput pedalData[NumPedals];    
    };
 
 
 
    class Shifter : public Peripheral {
    public:
        Shifter(int8_t min, int8_t max);
    
        int8_t getGear() const { return currentGear; }
 
        static char getGearChar(int gear);
 
        char getGearChar() const;
 
        static String getGearString(int gear);
 
        String getGearString() const;
 
        bool gearChanged() const { return changed; }
 
        int8_t getGearMin() { return MinGear; }
 
        int8_t getGearMax() { return MaxGear; }
 
    protected:
        const int8_t MinGear;  
        const int8_t MaxGear;  
 
        int8_t currentGear;    
        bool changed;          
    };
 
 
    class AnalogShifter : public Shifter {
    public:
        AnalogShifter(PinNum pinX, PinNum pinY, PinNum pinRev = UnusedPin, PinNum pinDetect = UnusedPin);
 
        virtual void begin();
 
        virtual bool update();
 
        long getPosition(Axis ax, long rMin = AnalogInput::Min, long rMax = AnalogInput::Max) const;
 
        int getPositionRaw(Axis ax) const;
 
        bool getReverseButton() const;
 
        struct GearPosition {
            int x;  
            int y;  
        };
 
        void setCalibration(
            GearPosition neutral,
            GearPosition g1, GearPosition g2, GearPosition g3, GearPosition g4, GearPosition g5, GearPosition g6,
            float engagePoint = CalEngagementPoint, float releasePoint = CalReleasePoint, float edgeOffset = CalEdgeOffset);
 
        void serialCalibration(Stream& iface = Serial);
 
        bool isConnected() const { return detector.isConnected(); }
 
    private:
        static const float CalEngagementPoint; 
 
        static const float CalReleasePoint;
 
        static const float CalEdgeOffset;
 
        /*** Internal calibration struct */
        struct Calibration {
            int    neutralX;  
            int    neutralY;  
            int  oddTrigger;  
            int  oddRelease;  
            int evenTrigger;  
            int evenRelease;  
            int    leftEdge;  
            int   rightEdge;  
        } calibration;
 
        AnalogInput analogAxis[2];  
        PinNum pinReverse;          
        DeviceConnection detector;  
    };
 
 
 
    class Handbrake : public Peripheral {
    public:
        Handbrake(PinNum pinAx, PinNum pinDetect = UnusedPin);
 
        virtual void begin();
 
        virtual bool update();
 
        long getPosition(long rMin = 0, long rMax = 100) const;
 
        int getPositionRaw() const;
 
        bool positionChanged() const { return changed; }
 
        void setCalibration(AnalogInput::Calibration newCal);
 
        void serialCalibration(Stream& iface = Serial);
 
        bool isConnected() const { return detector.isConnected(); }
 
    private:
        AnalogInput analogAxis;     
        DeviceConnection detector;  
        bool changed;               
    };
 
 
    class LogitechPedals : public ThreePedals {
    public:
        LogitechPedals(PinNum pinGas, PinNum pinBrake, PinNum pinClutch, PinNum pinDetect = UnusedPin);
    };
 
    class LogitechDrivingForceGT_Pedals : public TwoPedals {
    public:
        LogitechDrivingForceGT_Pedals(PinNum pinGas, PinNum pinBrake, PinNum pinDetect = UnusedPin);
    };
 
    class LogitechShifter : public AnalogShifter {
    public:
        LogitechShifter(PinNum pinX, PinNum pinY, PinNum pinRev = UnusedPin, PinNum pinDetect = UnusedPin);
    };
 
 
#if defined(__AVR_ATmega32U4__) || defined(SIM_RACING_DOXYGEN)
    #define SHIFTER_SHIELD_V1_PINS A1, A0, 14, A2
 
    #define PEDAL_SHIELD_V1_PINS A2, A1, A0, 10
#endif
 
}  // end SimRacing namespace
 
#endif