IoAbstraction.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2018 https://www.thecoderscorner.com (Dave Cherry).
 * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
 */
 
#ifndef _BASIC_IO_ABSTRACTION_H_
#define _BASIC_IO_ABSTRACTION_H_
 
#include "PlatformDetermination.h"
#include "BasicIoAbstraction.h"
 
#define SHIFT_REGISTER_OUTPUT_CUTOVER 32
 
#if defined(IOA_USE_MBED) || defined(BUILD_FOR_PICO_CMAKE)
#if defined(IOA_USE_MBED)
#include <mbed.h>
#endif
enum ShiftBitOrder { MSBFIRST, LSBFIRST };
uint8_t shiftIn(pinid_t dataPin, pinid_t clockPin, ShiftBitOrder bitOrder);
#else
#include <Arduino.h>
#endif
 
struct ShiftRegConfig {
    pinid_t clock;
    pinid_t data;
    pinid_t latch;
    uint8_t numDevices;
 
    ShiftRegConfig(pinid_t clock, pinid_t data, pinid_t latch, uint8_t numDevices) : clock(clock), data(data), latch(latch), numDevices(numDevices) {}
    ShiftRegConfig() : clock(IO_PIN_NOT_DEFINED), data(IO_PIN_NOT_DEFINED), latch(IO_PIN_NOT_DEFINED), numDevices(0) {}
};
 
class ShiftRegisterIoAbstraction : public BasicIoAbstraction {
private:
    uint32_t toWrite;
    uint32_t lastRead;
    bool needsWrite;
 
    uint8_t numOfDevicesRead;
    pinid_t readDataPin;
    pinid_t readLatchPin;
    pinid_t readClockPin;
 
    uint8_t numOfDevicesWrite;
    pinid_t writeDataPin;
    pinid_t writeLatchPin;
    pinid_t writeClockPin;
    bool needsInit;
public:
    ShiftRegisterIoAbstraction(pinid_t readClockPin, pinid_t readDataPin, pinid_t readLatchPin,
                               pinid_t writeClockPin, pinid_t writeDataPin, pinid_t writeLatchPin, uint8_t numRead, uint8_t numWrite);
    ShiftRegisterIoAbstraction(const ShiftRegConfig& readConfig, const ShiftRegConfig& writeConfig);
    ~ShiftRegisterIoAbstraction() override { }
    void initDevice();
 
    void pinDirection(pinid_t pin, uint8_t mode) override;
    void writeValue(pinid_t pin, uint8_t value) override;
    uint8_t readValue(pinid_t pin) override;
    void attachInterrupt(pinid_t, RawIntHandler, uint8_t) override {;}
    bool runLoop() override;
    
    void writePort(pinid_t port, uint8_t portVal) override;
 
    uint8_t readPort(pinid_t port) override;
};
 
class ShiftRegisterIoAbstraction165In : public BasicIoAbstraction {
private:
    uint32_t lastRead;
    uint8_t numOfDevicesRead;
    pinid_t readDataPin;
    pinid_t readLatchPin;
    pinid_t readClockPin;
    bool needsInit;
 
public:
    ShiftRegisterIoAbstraction165In(pinid_t readClockPin, pinid_t readDataPin, pinid_t readLatchPin, pinid_t numRead);
    ShiftRegisterIoAbstraction165In(ShiftRegConfig config);
    ~ShiftRegisterIoAbstraction165In() override = default;
    void initDevice();
 
    void pinDirection(pinid_t pin, uint8_t mode) override { }
 
    uint8_t readValue(pinid_t pin) override;
    bool runLoop() override;
    uint8_t readPort(pinid_t port) override;
 
    //
    // Features not implemented on this abstaction
    //
    void writePort(pinid_t port, uint8_t portVal) override { }
    void writeValue(pinid_t pin, uint8_t value) override { }
    void attachInterrupt(pinid_t, RawIntHandler, uint8_t) override { }
 
    uint8_t shiftInFor165() const;
};
 
IoAbstractionRef inputOutputFromShiftRegister(uint8_t readClockPin, uint8_t readDataPin, uint8_t readLatchPin, uint8_t numOfReadDevices,
                                              uint8_t writeClockPin, uint8_t writeDataPin, uint8_t writeLatchPin, uint8_t numOfWriteDevices);
 
IoAbstractionRef inputOutputFromShiftRegister(uint8_t readClockPin, uint8_t readDataPin, uint8_t readLatchPin,
                                              uint8_t writeClockPin, uint8_t writeDataPin, uint8_t writeLatchPin);
 
IoAbstractionRef inputOnlyFromShiftRegister(uint8_t readClockPin, uint8_t dataPin, uint8_t latchPin, uint8_t numOfDevicesRead = 1);
 
IoAbstractionRef outputOnlyFromShiftRegister(uint8_t writeClockPin, uint8_t writeDataPin, uint8_t writeLatchPin, uint8_t numOfDevicesWrite = 1);
 
IoAbstractionRef inputFrom74HC165ShiftRegister(pinid_t readClkPin, pinid_t dataPin, pinid_t latchPin, pinid_t numOfDevices = 1);
 
// this defines the number of IOExpanders can be put into a multi IO expander.
#ifndef MAX_ALLOWABLE_DELEGATES
#define MAX_ALLOWABLE_DELEGATES 8
#endif // defined MAX_ALLOWABLE_DELEGATES
 
typedef uint8_t (*ExpanderOpFn)(IoAbstractionRef ref, uint8_t pin, uint8_t val);
 
class MultiIoAbstraction : public BasicIoAbstraction {
private:
    IoAbstractionRef delegates[MAX_ALLOWABLE_DELEGATES];
    pinid_t limits[MAX_ALLOWABLE_DELEGATES];
    uint8_t numDelegates;
public:
    explicit MultiIoAbstraction(pinid_t arduinoPinsNeeded = 100);
    ~MultiIoAbstraction() override;
    void addIoExpander(IoAbstractionRef expander, pinid_t numOfPinsNeeded);
    void addIoDevice(BasicIoAbstraction& expander, pinid_t pinsNeeded) { addIoExpander(&expander, pinsNeeded);}
 
    void pinDirection(pinid_t pin, uint8_t mode) override;
 
    void writeValue(pinid_t pin, uint8_t value) override;
 
    uint8_t readValue(pinid_t pin) override;
 
    void writePort(pinid_t port, uint8_t portVal) override;
 
    uint8_t readPort(pinid_t port) override;
 
    void attachInterrupt(pinid_t pin, RawIntHandler intHandler, uint8_t mode) override;
 
    bool runLoop() override;
private:
    uint8_t doExpanderOp(pinid_t pin, uint8_t aVal, ExpanderOpFn fn);
};
 
typedef MultiIoAbstraction* MultiIoAbstractionRef;
 
inline MultiIoAbstractionRef multiIoExpander(pinid_t arduinoPinRange) { return new MultiIoAbstraction(arduinoPinRange); }
 
inline void multiIoAddExpander(MultiIoAbstractionRef multiIo, IoAbstractionRef expander, pinid_t pinRange) { multiIo->addIoExpander(expander, pinRange); }
 
#include "TaskManagerIO.h"
#include "SwitchInput.h"
#include "IoLogging.h"
 
#endif