SerialWombatAnalogInput.h

Go to the documentation of this file.

#pragma once
/*
Copyright 2020-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 <stdint.h>
#include "SerialWombat.h"

 
 
enum class AnalogInputPublicDataOutput {
    AnalogInputPublicDataOutput_Raw = 0,  
    AnalogInputPublicDataOutput_Filtered = 1,   
    AnalogInputPublicDataOutput_Averaged = 2,   
    AnalogInputPublicDataOutput_Minimum = 3, 
    AnalogInputPublicDataOutput_Maximum = 4, 
};

class SerialWombatAnalogInput : public SerialWombatPin
{
public:
    SerialWombatAnalogInput(SerialWombatChip& SerialWombatChip):SerialWombatPin(SerialWombatChip){}
 
    
 
    

    int16_t begin(uint8_t pin, uint16_t averageSamples = 64, uint16_t filterConstant = 0xFF80, AnalogInputPublicDataOutput output = AnalogInputPublicDataOutput::AnalogInputPublicDataOutput_Raw)
    {
        _pin = pin;
        _pinMode = PIN_MODE_ANALOGINPUT;
        int16_t result = initPacketNoResponse(0,0,0,0,0,0);
        if (result < 0) { return result; }
        //uint8_t tx1[] = { 201,_pin,PIN_MODE_ANALOGINPUT,SW_LE16(averageSamples) ,SW_LE16(filterConstant),(uint8_t)output };
        return initPacketNoResponse(1,averageSamples,filterConstant,(uint8_t)output);
    }
 

    uint16_t readVoltage_mV()
    {
        uint16_t reading = _sw.readPublicData(_pin);
        uint32_t x = ((uint32_t) reading ) * _sw._supplyVoltagemV;
        uint16_t returnval = x >> 16;
        return (returnval);
    }

    uint16_t readCounts()
    {
        return (_sw.readPublicData(_pin));
    }

    uint16_t readFiltered_mV() 
    {
        uint32_t x = readFilteredCounts(); // Counts ranging from 0 to 65535
        x *= _sw._supplyVoltagemV;
        return ((uint16_t)(x >> 16));
    }

    uint16_t readFilteredCounts()
    {
        uint8_t tx[] = { 204,_pin,PIN_MODE_ANALOGINPUT,0x55,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
 
        _sw.sendPacket(tx, rx, true, 3,1);
 
        return(rx[5] + rx[6] * 256);
    }

    uint16_t readAveraged_mV()
    {
        uint32_t x = readAveragedCounts(); // Counts ranging from 0 to 65535
        x *= _sw._supplyVoltagemV;
        return ((uint16_t)(x >> 16));
    }

    uint16_t readAveragedCounts()
    {
        uint8_t tx[] = { 204,_pin,PIN_MODE_ANALOGINPUT,0x55,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        _sw.sendPacket(tx, rx,true,3,1); 
        return(rx[3] + rx[4] * 256);
    }

    uint16_t updateSupplyVoltage_mV()
    {
        return  _sw.readSupplyVoltage_mV();
    }
 

    uint16_t readMaximum_mV(bool resetAfterRead = false)
    {
        uint8_t tx[] = { 203,_pin,PIN_MODE_ANALOGINPUT,0,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        if (resetAfterRead)
        {
            tx[3] = 1;
        }
        _sw.sendPacket(tx, rx);
        return(rx[5] + rx[6] * 256);
    }
 

    \param resetAfterRead If True, maximum value is set to 0 after read so that subsequent values become maximum.  Also resets minimum to next sample.
    
    \return A 16 bit unsigned value indicating maximum A/D Counts
    */
    uint16_t readMaximumCounts(bool resetAfterRead = false)
    {
        uint8_t tx[] = { 203,_pin,PIN_MODE_ANALOGINPUT,0,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        if (resetAfterRead)
        {
            tx[3] = 1;
        }
        _sw.sendPacket(tx, rx);
        return(rx[5] + rx[6] * 256);
    }

    \param resetAfterRead If True, minimum value is set to 0 after read so that subsequent values become minimum.  Also resets maximum to next sample.
    
    \return A 16 bit unsigned value indicating measurement in mV
    */
    uint16_t readMinimum_mV(bool resetAfterRead = false)
    {
        uint32_t x = readMaximumCounts(resetAfterRead); // Counts ranging from 0 to 65535
        x *= _sw._supplyVoltagemV;
        return ((uint16_t)(x >> 16));
    }
 

    uint16_t readMinimumCounts(bool resetAfterRead = false)
    {
        uint8_t tx[] = { 203,_pin,PIN_MODE_ANALOGINPUT,0,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        if (resetAfterRead)
        {
            tx[3] = 1;
        }
        _sw.sendPacket(tx, rx);
        return(rx[3] + rx[4] * 256);
    }
 
    
private:
    
};

class SerialWombatAnalogInput_18AB : public SerialWombatAnalogInput, public SerialWombatAbstractProcessedInput
{
public:
 
    SerialWombatAnalogInput_18AB(SerialWombatChip& serialWombat):SerialWombatAnalogInput(serialWombat),SerialWombatAbstractProcessedInput(serialWombat){}
 
    uint8_t pin() { return _pin; }
    uint8_t swPinModeNumber() { return _pinMode; }
};