SerialWombatAbstractProcessedInput.h

Go to the documentation of this file.

#pragma once
/*
Copyright 2021-2024 Broadwell Consulting Inc.
 
"Serial Wombat" is a registered trademark of Broadwell Consulting Inc. in
the United States.  See SerialWombat.com for usage guidance.
 
Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
*/
 
#include "SerialWombat.h"
#include "limits.h"

 

class SerialWombatAbstractProcessedInput 
{
public:
    SerialWombatAbstractProcessedInput(SerialWombatChip& sw):_pisw(sw){}
 
 
    enum  Period {
        PERIOD_1mS = 0,
        PERIOD_2mS = 1,
        PERIOD_4mS = 2,
        PERIOD_8mS = 3,
        PERIOD_16mS = 4,
        PERIOD_32mS = 5,
        PERIOD_64mS = 6,
        PERIOD_128mS = 7,
        PERIOD_256mS = 8,
        PERIOD_512mS = 9,
        PERIOD_1024mS = 10,
 
    };
 
    enum OutputValue {
        RAW = 0,  
        FIRST_ORDER_FILTERED = 1, 
        AVERAGE = 2, 
    };
 
    enum Transform {
        NONE = 0,  
        SCALE_RANGE = 1,  
        LINEAR_MXB = 2  
    };

    int16_t writeInverted(bool inverted)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            3,
            (uint8_t) inverted,
            0x55,0x55,0x55
        };
 
        int16_t result = _pisw.sendPacket(tx);
 
        return(result);
    }

    int16_t writeFirstOrderFilteringConstant(uint16_t constant)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            11,
            SW_LE16(constant),
            0x55,0x55
        };
        return (_pisw.sendPacket(tx));
    }

    int16_t writeAveragingNumberOfSamples(uint16_t numberOfSamples)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            1,
            SW_LE16(numberOfSamples),
            0x55,0x55
        };
 
        int16_t result = _pisw.sendPacket(tx);
 
        return(result);
    }

    int16_t writeExcludeBelowAbove(uint16_t low, uint16_t high)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            2,
            SW_LE16(low),
            SW_LE16(high)
        };
 
        int16_t result = _pisw.sendPacket(tx);
 
        return(result);
    }
 

    int16_t configureQueue(SerialWombatQueue* queue, Period period, bool queueHighByte = true, bool queueLowByte = true)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            5,
            SW_LE16(queue->startIndex)
            ,(uint8_t)period,
            (uint8_t)((((uint8_t) queueHighByte) << (uint8_t)1) | (uint8_t)queueLowByte)
        };
        int16_t result = _pisw.sendPacket(tx);
        return(result);
    }

    int16_t configureOutputValue(OutputValue outputValue)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            4,
            (uint8_t)outputValue,
            0x55,0x55,0x55
        };
 
        int16_t result = _pisw.sendPacket(tx);
 
        return(result);
    }

    int16_t writeTransformScaleRange(uint16_t min, uint16_t max)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            6,
            SW_LE16(min),
            SW_LE16(max)
        };
 
        int16_t result = _pisw.sendPacket(tx);
 
        return(result);
    }

    int16_t writeTransformLinearMXB(int32_t m, int32_t b)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            7,
            SW_LE32(((uint32_t)m)),
        };
 
        int16_t result = _pisw.sendPacket(tx);
        if (result < 0)
        {
            return(result);
        }
 
        uint8_t tx2[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            8,
            SW_LE32(((uint32_t)b)),
        };
        result = _pisw.sendPacket(tx2);
        return(result);
    }

 
    int16_t configureIntegrator(
            uint16_t negativeMaxIndex, 
            uint16_t negativeMidIndex, 
                    uint16_t negativeDeadZone, 
            uint16_t positiveDeadZone, 
            uint16_t positiveMidIndex,
                    uint16_t positiveMaxIndex,
            uint16_t midIncrement,  
            uint16_t maxIncrement,  
            uint16_t initialValue, 
            uint8_t updateFrequencyMask = 0 
            )
        {
            {
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
                12,
                SW_LE16(negativeMaxIndex),
                SW_LE16(negativeMidIndex)
                };
                int16_t result = _pisw.sendPacket(tx);
 
                if (result < 0) return (result);
            }
            {
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
                13,
                SW_LE16(negativeDeadZone),
                SW_LE16(positiveDeadZone),
                };
                int16_t result = _pisw.sendPacket(tx);
 
                if (result < 0) return (result);
            }
            {
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
                14,
                SW_LE16(positiveMidIndex),
                SW_LE16(positiveMaxIndex),
                };
                int16_t result = _pisw.sendPacket(tx);
 
                if (result < 0) return (result);
            }
            {
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
                15,
                SW_LE16(initialValue),
                0,0
                };
                int16_t result = _pisw.sendPacket(tx);
 
                if (result < 0)  return (result);
            }
            {
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
                16,
                SW_LE16(midIncrement),
                SW_LE16(maxIncrement),
                };
                int16_t result = _pisw.sendPacket(tx);
 
                return (result);
            }
            {
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
                17,
                updateFrequencyMask,
                0,0,0
                };
                int16_t result = _pisw.sendPacket(tx);
 
                return (result);
            }
        }

    int16_t writeProcessedInputEnable(bool enabled)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            0,
            (uint8_t)enabled,
            0x55,0x55,0x55
        };
 
        int16_t result = _pisw.sendPacket(tx);
 
        return(result);
    }

    uint16_t readMinimum(bool resetAfterRead = false)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            9,
            (uint8_t)resetAfterRead,
            0x55,0x55,0x55
        };
        uint8_t rx[8];
        int16_t result = _pisw.sendPacket(tx,rx);
        if (result < 0)
        {
            return (65535);
        }
        return(rx[4] + 256*rx[5]);
    }

    uint16_t readMaximum(bool resetAfterRead = false)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            10,
            (uint8_t)resetAfterRead,
            0x55,0x55,0x55
        };
        uint8_t rx[8];
        int16_t result = _pisw.sendPacket(tx, rx);
        if (result < 0)
        {
            return (65535);
        }
        return(rx[4] + 256 * rx[5]);
    }

    uint16_t readAverage()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            11,
            0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
        int16_t result = _pisw.sendPacket(tx, rx);
        if (result < 0)
        {
            return (0);
        }
        return(rx[4] + 256 * rx[5]);
    }

    uint16_t readFiltered()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS,
            pin(),
            swPinModeNumber(),
            11,
            0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
        int16_t result = _pisw.sendPacket(tx, rx);
        if (result < 0)
        {
            return (0);
        }
        return(rx[6] + 256 * rx[7]);
    }

    virtual uint8_t pin() = 0;

    virtual uint8_t swPinModeNumber() = 0;
 
private:
    SerialWombatChip& _pisw;
};