SerialWombatAbstractScaledOutput.h

Go to the documentation of this file.

#pragma once
/*
Copyright 2021-2025 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 SerialWombatAbstractScaledOutput 
{
public:
    SerialWombatAbstractScaledOutput(SerialWombatChip& sw):_asosw(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 RampMode{
     RAMP_MODE_BOTH = 0,
    RAMP_MODE_INCREMENT = 1,
    RAMP_MODE_DECREMENT = 2, 
    };
 

    int16_t writeTimeout(uint16_t timeout_mS, uint16_t timeoutOutputValue)
    {
 
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            1,
            SW_LE16(timeout_mS),
            SW_LE16(timeoutOutputValue),
            };
        
        int16_t result = _asosw.sendPacket(tx);
 
        return(result);
 
    }

    int16_t writeEndstops(
        uint8_t endstop0Pin = 0xFF,
        uint16_t endstop0TriggerValue = 0x0000,
        uint16_t endstop0OutputValue = 0x0000,
        bool endstop0GreaterThanOrEqual = false,
        uint8_t endstop1Pin = 0xFF,
        uint16_t endstop1TriggerValue = 0x0000,
        uint16_t endstop1OutputValue = 0x0000,
        bool endstop1GreaterThanOrEqual = false)
    {
        
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                0x0C, // Set endstop 0 trigger and output values
                SW_LE16(endstop0TriggerValue),
                SW_LE16(endstop0OutputValue)
            };
            int16_t result = _asosw.sendPacket(tx);
            if (result < 0)
            {
                return(result);
            }
        }
 
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                0x0D, // Set endstop 1 trigger and output values
                SW_LE16(endstop1TriggerValue),
                SW_LE16(endstop1OutputValue)
            };
                int16_t result = _asosw.sendPacket(tx);
            if (result < 0)
            {
                return(result);
            }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                0x0B, // Set endstop pins and comparison modes
                endstop0Pin,
                (uint8_t)(endstop0GreaterThanOrEqual ? 1 : 0),
                endstop1Pin,
                (uint8_t)(endstop1GreaterThanOrEqual ? 1 : 0)
            };
            return(_asosw.sendPacket(tx));
        
        }
 
    }

    int16_t writeScalingEnabled(bool enabled, uint8_t sourcePin)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),   swPinModeNumber(),
            0, //Enable/disable scaling, set source pin
            enabled,
            sourcePin,
            0x55, 0x55};
        
        int16_t result = _asosw.sendPacket(tx);
        return(result);
    }

    int16_t writeInputScaling(uint16_t inputMin, uint16_t inputMax)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            2,  // Set input scaling
            SW_LE16(inputMin),
            SW_LE16(inputMax),
            };
        return(_asosw.sendPacket(tx));
    }

    int16_t writeOutputScaling(uint16_t outputMin, uint16_t outputMax)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            5,  //Set output scaling
            SW_LE16(outputMin),
            SW_LE16(outputMax),
            };
        return(_asosw.sendPacket(tx));
    }

    int16_t writeScalingInvertedInput(bool inverted)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            3,  // Set inverted/not inverted
            inverted,
            0x55,0x55,0x55,
        };
        return(_asosw.sendPacket(tx));
    }

    int16_t writeScalingTargetValue(uint16_t target)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            6,  // Set target value for PID controller
            SW_LE16(target),0x55,0x55,
        };
        return(_asosw.sendPacket(tx));
    }

    int16_t writeRateControl(Period samplePeriod, uint16_t maximumChangecounts, uint16_t maximumDecrementCounts = 0)
    {
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                4, // Set filter mode
                1, // Filter mode rate control
                SW_LE16(maximumChangecounts),0x55,
            };
            int16_t result = _asosw.sendPacket(tx);
            if (result < 0)
            {
                return(result);
            }
        }
        if (maximumDecrementCounts > 0)
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                8, // Set filter mode
                SW_LE16(maximumDecrementCounts),0x55,0x55
            };
            int16_t result = _asosw.sendPacket(tx);
            if (result < 0)
            {
                return(result);
            }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            7, // Set Sample Rate
            (uint8_t)samplePeriod,
            0x55,0x55,0x55,
        };
        return(_asosw.sendPacket(tx));
        }
    }

    int16_t write1stOrderFiltering(Period samplePeriod, uint16_t filterConstant)
    {
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                4, // Set filter mode
                2, // Filter mode 1st Order
                SW_LE16(filterConstant),0x55,
            };
            int16_t result = _asosw.sendPacket(tx);
            if (result < 0)
            {
                return(result);
            }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            7, // Set Sample Rate
            (uint8_t)samplePeriod,
            0x55,0x55,0x55,
            };
            return(_asosw.sendPacket(tx));
        }
    }

    int16_t writeHysteresis(uint16_t lowLimit, uint16_t lowOutputValue, uint16_t highLimit, uint16_t highOutputValue, uint16_t initialOutputValue)
    {
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                50, // Set hysteresis high limit/output
                SW_LE16(highLimit),
                SW_LE16(highOutputValue)
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
 
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                51, // Set hysteresis low limit/output
                SW_LE16(lowLimit),
                SW_LE16(lowOutputValue)
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                52, // Set hysteresis low limit/output
                SW_LE16(initialOutputValue),
                0x55,0x55
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        return(0);
    }

    int16_t writeRamp(uint16_t slowIncrement, uint16_t incrementThreshold, uint16_t fastIncrement,Period samplePeriod, RampMode rampMode)
    {
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                7, // Set Sample Rate
                    (uint8_t) samplePeriod, 
                0x55,0x55,0x55
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                60, // Set ramp slow increment, threshold
                SW_LE16(slowIncrement),
                SW_LE16(incrementThreshold)
            
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                61, // Set ramp fast increment, mode
                SW_LE16(fastIncrement),
                (uint8_t) rampMode, 0x55
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        return 0;
 
    }

    int16_t writePID(uint16_t kp, uint16_t ki, uint16_t kd,uint16_t target,Period samplePeriod, uint8_t targetPin = 255, bool biDirectional = false)
    {
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                100, // Set kp and ki
                SW_LE16(kp),
                SW_LE16(ki)
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                101, // Set kd
                SW_LE16(kd),
                0x55,0x55
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        writeScalingTargetValue(target);
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            7, // Set Sample Rate
            (uint8_t)samplePeriod,
            0x55,0x55,0x55,
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                102, // Reset Integrator
                0x55,0x55,0x55,0x55
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        {
            uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
                pin(),
                swPinModeNumber(),
                109, // Configure target and bidirectional
                targetPin,
                biDirectional,
                0x55,0x55
            };
            int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
        }
        return 0;
 
    }
 

    uint16_t readLastOutputValue()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
            9, // Read Last Value
            0x55, 0x55,0x55,0x55,
        };
        uint8_t rx[8];
        if (_asosw.sendPacket(tx, rx) >= 0)
        {
            return(rx[4] + (uint16_t)rx[5] * 256);
        }
        else
        {
            return (0);
        }
 
    }
 
    int16_t writeScalingTargetValueResetIntegrator(uint16_t target)
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        110, // Write target Value and Reset Integrator
        (byte)(target & 0xFF),(byte)(target >> 8),0x55,0x55
        };
        return _asosw.sendPacket(tx);
    }
    int32_t PIDGetLastError()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        103, // Get Last Error
        0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
 
        _asosw.sendPacket(tx, rx);
        int32_t returnVal;
        memcpy(&returnVal,&rx[4],4);
        return returnVal;
 
    }
 
 
    int32_t PIDGetLastIntegrator()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        104, // Get Last Integrator
        0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
 
        _asosw.sendPacket(tx, rx);
 
        int32_t returnVal;
        memcpy(&returnVal,&rx[4],4);
        return returnVal;
    }
 
    int32_t PIDGetLastIntegratorEffort()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        105, // Get Last Integrator Effort
        0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
 
        _asosw.sendPacket(tx, rx);
 
        int32_t returnVal;
        memcpy(&returnVal,&rx[4],4);
        return returnVal;
    }
 
    int32_t PIDGetLastProportionalEffort()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        106, // Get Last Proportional Effort
        0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
 
        _asosw.sendPacket(tx, rx);
 
        int32_t returnVal;
        memcpy(&returnVal,&rx[4],4);
        return returnVal;
    }
 
    int32_t PIDGetLastDerivativeEffort()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        107, // Get Last Derivative Effort
        0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
 
        _asosw.sendPacket(tx, rx);
 
        int32_t returnVal;
        memcpy(&returnVal,&rx[4],4);
        return returnVal;
    }
 
    int32_t PIDGetLastEffort()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        108, // Get Last Total Effort
        0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
 
        _asosw.sendPacket(tx, rx);
 
        int32_t returnVal;
        memcpy(&returnVal,&rx[4],4);
        return returnVal;
    }
 
    uint16_t ReadLastTarget()
    {
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        111, // Get Last Target
        0x55,0x55,0x55,0x55
        };
        uint8_t rx[8];
 
        _asosw.sendPacket(tx, rx);
 
        return ((uint16_t)(rx[4] + 256 * rx[5]));
    }

    int16_t Enable2DLookupOutputScaling(uint16_t IndexInUserMemory 
    )
    {
        uint8_t tx[] = {(uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
            pin(),
            swPinModeNumber(),
        10, // Set 2D Lookup Index 
        SW_LE16(IndexInUserMemory),0x55,0x55 };
        return _asosw.sendPacket(tx);
    }

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