MockIoAbstraction.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 _MOCK_IO_ABSTRACTION_H_
#define _MOCK_IO_ABSTRACTION_H_
 
#include <IoAbstraction.h>
 
enum MockIoError {
    NO_ERROR = 0,
    PIN_TOO_HIGH = 1,
    READ_NOT_INPUT = 2,
    WRITE_NOT_OUTPUT = 3,
};
 
class MockedIoAbstraction : public BasicIoAbstraction {
private:
    uint8_t pinModes[16];
    uint16_t *readValues;
    uint16_t *writeValues;
    int runLoopCalls;
    int numberOfCycles;
    
    MockIoError error;
    
    RawIntHandler intHandler;
    uint8_t intPin;
    uint8_t intMode;
 
public:
    MockedIoAbstraction(int numberOfCycles = 6) {
        for(int i=0;i<16;i++) pinModes[i] = 0xff;
        error = NO_ERROR;
 
        this->numberOfCycles = numberOfCycles;
        readValues = new uint16_t[numberOfCycles];
        writeValues = new uint16_t[numberOfCycles];
 
        resetIo();
    }
 
    virtual ~MockedIoAbstraction() { 
         delete readValues;
         delete writeValues;
    }
 
    void resetIo() {
        for(int i=0; i<numberOfCycles; i++) {
            readValues[i] = 0;
            writeValues[i] = 0;
        }
        runLoopCalls = 0;
    }
 
 
    void pinDirection(pinid_t pin, uint8_t mode) override {
        checkPinInRange(pin);
        pinModes[pin] = mode;
    }
 
    void writeValue(pinid_t pin, uint8_t value) override {
        checkPinInRange(pin);
 
        if(pinModes[pin] != OUTPUT) error = WRITE_NOT_OUTPUT;
        bitWrite(writeValues[runLoopCalls], pin, value != 0);
    }
 
    uint8_t readValue(pinid_t pin) override {
        checkPinInRange(pin);
        if(pinModes[pin] != INPUT && pinModes[pin] != INPUT_PULLUP) error = READ_NOT_INPUT;
        return bitRead(readValues[runLoopCalls], pin);
    }
 
    void attachInterrupt(pinid_t pin, RawIntHandler interruptHandler, uint8_t mode) override {
        this->intHandler = interruptHandler;
        this->intPin = pin;
        this->intMode = mode;
    }
 
    bool runLoop() override { 
        // copy over the last written values (as they are generally additive) and bump counter.
        uint16_t currentWritten = writeValues[runLoopCalls];
 
        runLoopCalls++;
        runLoopCalls = runLoopCalls % numberOfCycles; // dont exceed array
 
        writeValues[runLoopCalls] = currentWritten;
        return true;
    }
 
    void writePort(pinid_t pin, uint8_t portVal) override {
 
        checkPinInRange(pin);
 
        if(pin < 8) {
            checkPinsAre(OUTPUT, 0, 7);
            writeValues[runLoopCalls] = (writeValues[runLoopCalls] & 0xff00) | portVal;
        }
        else {
            checkPinsAre(OUTPUT, 8, 15);
            writeValues[runLoopCalls] = (writeValues[runLoopCalls] & 0x00ff) | (portVal << 8);
        }
    }
 
    virtual uint8_t readPort(pinid_t pin) {
        checkPinInRange(pin);
 
        if(pin < 8) {
            checkPinsAre(INPUT, 0, 7);
            return readValues[runLoopCalls];
        }
        else {
            checkPinsAre(INPUT, 8, 15);
            return readValues[runLoopCalls] >> 8;
        }
    }
 
    int getNumberOfRunLoops() {return runLoopCalls;}
 
    uint16_t getWrittenValuesForRunLoop(int runLoop) { return writeValues[runLoop]; }
 
    void setValueForReading(int runLoopNo, uint16_t val) {readValues[runLoopNo] = val;}
 
    uint16_t getWrittenValue(int runLoopNo) {return writeValues[runLoopNo];}
 
    MockIoError getErrorMode() {return error;}
 
    void clearError() { error = NO_ERROR; }
 
    RawIntHandler getInterruptFunction() {return intHandler;}
 
    bool isIntRegisteredAs(uint8_t pin, uint8_t mode) {
        return intPin == pin && intMode == mode && intHandler != NULL;
    }
private:
    void checkPinInRange(int pin) {
        if(pin > 15) error = PIN_TOO_HIGH;
    }
    void checkPinsAre(uint8_t mode, uint8_t start, uint8_t end) {
        for(int i = start; i < end; ++i) {
            if(mode == OUTPUT) {
                if(pinModes[i] != OUTPUT) error = WRITE_NOT_OUTPUT;
            }
            else if(mode == INPUT) {
                if(pinModes[i] != INPUT && pinModes[i] != INPUT_PULLUP) error = READ_NOT_INPUT;
            }
        }
    }
};
 
class LoggingIoAbstraction : public BasicIoAbstraction {
private:
    IoAbstractionRef delegate;
    uint32_t writeVals;
    int ports;
public:    
    LoggingIoAbstraction(IoAbstractionRef delegate, int ports) { 
        this->delegate = delegate; 
        this->ports = ports;
        writeVals = 0;
    }
 
    void pinDirection(pinid_t pin, uint8_t mode) override { delegate->pinDirection(pin, mode); }
 
    void writeValue(pinid_t pin, uint8_t value) override {
        bitWrite(writeVals, pin, value);
        delegate->writeValue(pin, value); 
    }
    uint8_t readValue(pinid_t pin) override { return delegate->readValue(pin); }
 
    void attachInterrupt(pinid_t pin, RawIntHandler interruptHandler, uint8_t mode) override { delegate->attachInterrupt(pin, interruptHandler, mode); }
 
    void writePort(pinid_t pin, uint8_t portVal) override {
        if(pin < 8) {
            writeVals &= 0xffffff00L;
            writeVals |= (uint32_t)portVal;
        }
        else if(pin < 16) {
            writeVals &= 0xffff00ffL;
            writeVals |= ((uint32_t)portVal<<8);
        }
        else if(pin < 24) {
            writeVals &= 0xff00ffffL;
            writeVals |= ((uint32_t)portVal<<16);
        }
        else {
            writeVals &= 0x00ffffffL;
            writeVals |= ((uint32_t)portVal<<24);
        }
        delegate->writePort(pin, portVal);
    }
    uint8_t readPort(pinid_t pin) override { return delegate->readPort(pin);}
 
    bool runLoop() override { 
        serlogF(SER_DEBUG, "Port write ");
        uint32_t val = writeVals;
        for(int i=0;i<ports;i++) {
            printHexZeroPad(val);
            val = val >> 8;
        }
        bool ret = delegate->runLoop();
        serlogF(SER_DEBUG, "read ");
        for(int i=0;i<ports;i++) {
            printHexZeroPad(delegate->readPort(i * 8));
        }
        serlogF(SER_DEBUG, "EOL");
        return ret;
    }
 
    void printHexZeroPad(uint8_t val) {
        serlog3(SER_DEBUG, hexchar(val / 16), hexchar(val % 16), ' ');
    }
 
    char hexchar(uint8_t ch) {
        return ch < 10 ? ch + '0' : (ch-10) + 'A';
    }
};
 
#endif // _MOCK_IO_ABSTRACTION_H_