SerialWombat.h

Go to the documentation of this file.

#ifndef SERIAL_WOMBAT_H__
#define SERIAL_WOMBAT_H__
 
/*
Copyright 2020-2026 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 "Stream.h"
//#include "Serial.h" // Using "" rather than <> for compatibility with Visual C++ simulation project
#include "Wire.h"// Using "" rather than <> for compatibility with Visual C++ simulation project
#include "Arduino.h"
#ifndef INPUT 
#define INPUT 0x0
#endif
 

 
 
#include "SerialWombatErrors.h"

#define SW_LE16(_a)  (uint8_t)((_a) & 0xFF), (uint8_t)((_a) >>8)  

#define SW_LE32(_a)  (uint8_t)((_a) & 0xFF), (uint8_t)((_a) >>8) , (uint8_t)((_a) >>16), (uint8_t)((_a) >>24)
 
#define ARRAY_UINT32(_array,_index) ((((uint32_t) _array[_index +3])<<24) + (((uint32_t) _array[_index +2])<<16) + (((uint32_t) _array[_index +1])<<8) + _array[_index])
#define SW18AB_LATEST_FIRMWARE 226
#define SW08B_LATEST_FIRMWARE 226
#define SW4B_LATEST_FIRMWARE 203
 
typedef enum
{
    SW_LOW = 0,
    SW_HIGH = 1,
    SW_INPUT = 2,
}SerialWombatPinState_t;
 

enum class SerialWombatDataSource{
 
    SW_DATA_SOURCE_PIN_0 = 0, 
    SW_DATA_SOURCE_PIN_1 = 1, 
    SW_DATA_SOURCE_PIN_2 = 2, 
    SW_DATA_SOURCE_PIN_3 = 3, 
    SW_DATA_SOURCE_PIN_4 = 4, 
    SW_DATA_SOURCE_PIN_5 = 5, 
    SW_DATA_SOURCE_PIN_6 = 6, 
    SW_DATA_SOURCE_PIN_7 = 7, 
    SW_DATA_SOURCE_PIN_8 = 8, 
    SW_DATA_SOURCE_PIN_9 = 9, 
    SW_DATA_SOURCE_PIN_10 = 10, 
    SW_DATA_SOURCE_PIN_11 = 11, 
    SW_DATA_SOURCE_PIN_12 = 12, 
    SW_DATA_SOURCE_PIN_13 = 13, 
    SW_DATA_SOURCE_PIN_14 = 14, 
    SW_DATA_SOURCE_PIN_15 = 15, 
    SW_DATA_SOURCE_PIN_16 = 16, 
    SW_DATA_SOURCE_PIN_17 = 17, 
    SW_DATA_SOURCE_PIN_18 = 18, 
    SW_DATA_SOURCE_PIN_19 = 19, 
//  SW_DATA_SOURCE_PIN_20 = 20,
//  SW_DATA_SOURCE_PIN_21 = 21,
//  SW_DATA_SOURCE_PIN_22 = 22,
//  SW_DATA_SOURCE_PIN_23 = 23,
//  SW_DATA_SOURCE_PIN_24 = 24,
//  SW_DATA_SOURCE_PIN_25 = 25,
//  SW_DATA_SOURCE_PIN_26 = 26,
//  SW_DATA_SOURCE_PIN_27 = 27,
//  SW_DATA_SOURCE_PIN_28 = 28,
//  SW_DATA_SOURCE_PIN_29 = 29,
//  SW_DATA_SOURCE_PIN_30 = 30,
//  SW_DATA_SOURCE_PIN_31 = 31,
//  SW_DATA_SOURCE_PIN_32 = 32,
//  SW_DATA_SOURCE_PIN_33 = 33,
//  SW_DATA_SOURCE_PIN_34 = 34,
//  SW_DATA_SOURCE_PIN_35 = 35,
//  SW_DATA_SOURCE_PIN_36 = 36,
//  SW_DATA_SOURCE_PIN_37 = 37,
//  SW_DATA_SOURCE_PIN_38 = 38,
//  SW_DATA_SOURCE_PIN_39 = 39,
//  SW_DATA_SOURCE_PIN_40 = 40,
//  SW_DATA_SOURCE_PIN_41 = 41,
//  SW_DATA_SOURCE_PIN_42 = 42,
//  SW_DATA_SOURCE_PIN_43 = 43,
//  SW_DATA_SOURCE_PIN_44 = 44,
//  SW_DATA_SOURCE_PIN_45 = 45,
//  SW_DATA_SOURCE_PIN_46 = 46,
//  SW_DATA_SOURCE_PIN_47 = 47,
//  SW_DATA_SOURCE_PIN_48 = 48,
//  SW_DATA_SOURCE_PIN_49 = 49,
//  SW_DATA_SOURCE_PIN_50 = 50,
//  SW_DATA_SOURCE_PIN_51 = 51,
//  SW_DATA_SOURCE_PIN_52 = 52,
//  SW_DATA_SOURCE_PIN_53 = 53,
//  SW_DATA_SOURCE_PIN_54 = 54,
//  SW_DATA_SOURCE_PIN_55 = 55,
//  SW_DATA_SOURCE_PIN_56 = 56,
//  SW_DATA_SOURCE_PIN_57 = 57,
//  SW_DATA_SOURCE_PIN_58 = 58,
//  SW_DATA_SOURCE_PIN_59 = 59,
//  SW_DATA_SOURCE_PIN_60 = 60,
//  SW_DATA_SOURCE_PIN_61 = 61,
//  SW_DATA_SOURCE_PIN_62 = 62,
//  SW_DATA_SOURCE_PIN_63 = 63,
    SW_DATA_SOURCE_INCREMENTING_NUMBER = 65, 
    SW_DATA_SOURCE_1024mvCounts = 66 , 
    SW_DATA_SOURCE_FRAMES_RUN_LSW = 67, 
    SW_DATA_SOURCE_FRAMES_RUN_MSW = 68, 
    SW_DATA_SOURCE_OVERRUN_FRAMES = 69, 
    SW_DATA_SOURCE_TEMPERATURE = 70, 
    SW_DATA_SOURCE_PACKETS_RECEIVED = 71, 
    SW_DATA_SOURCE_ERRORS = 72, 
    SW_DATA_SOURCE_DROPPED_FRAMES = 73, 
    SW_DATA_SOURCE_SYSTEM_UTILIZATION = 74, 
    SW_DATA_SOURCE_VCC_mVOLTS = 75, 
    SW_DATA_SOURCE_VBG_COUNTS_VS_VREF = 76, 
                        
 SW_DATA_SOURCE_RESET_REGISTER = 77, 
            SW_DATA_SOURCE_LFSR = 78, 
            SW_DATA_COM_ADDRESS_LOW = 79, 
            SW_DATA_COM_ADDRESS_HIGH = 80, 
    SW_DATA_SOURCE_0x55 = 85, 
    SW_DATA_SOURCE_PIN_0_MV = 100, 
    SW_DATA_SOURCE_PIN_1_MV = 101, 
    SW_DATA_SOURCE_PIN_2_MV = 102, 
    SW_DATA_SOURCE_PIN_3_MV = 103, 
    SW_DATA_SOURCE_PIN_4_MV = 104, 
    //NOT ANALOG            SW_DATA_SOURCE_PIN_5_MV = 105,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_6_MV = 106,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_7_MV = 107,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_8_MV = 108,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_9_MV = 109,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_10_MV = 110,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_11_MV = 111,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_12_MV = 112,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_13_MV = 113,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_14_MV = 114,
    //NOT ANALOG            SW_DATA_SOURCE_PIN_15_MV = 115,
    SW_DATA_SOURCE_PIN_16_MV = 116, 
    SW_DATA_SOURCE_PIN_17_MV = 117, 
    SW_DATA_SOURCE_PIN_18_MV = 118, 
    SW_DATA_SOURCE_PIN_19_MV = 119, 
    SW_DATA_SOURCE_2HZ_SQUARE = 164, 
    SW_DATA_SOURCE_2HZ_SAW = 165,
//            SW_DATA_SOURCE_2HZ_SIN = 166,
SW_DATA_SOURCE_1HZ_SQUARE = 167,
SW_DATA_SOURCE_1HZ_SAW = 168,
//           SW_DATA_SOURCE_1HZ_SIN = 169,
SW_DATA_SOURCE_2SEC_SQUARE = 170,
SW_DATA_SOURCE_2SEC_SAW = 171,
//          SW_DATA_SOURCE_2SEC_SIN = 172,
SW_DATA_SOURCE_8SEC_SQUARE = 173,
SW_DATA_SOURCE_8SEC_SAW = 174,
//         SW_DATA_SOURCE_8SEC_SIN = 175,
SW_DATA_SOURCE_65SEC_SQUARE = 176,
SW_DATA_SOURCE_65SEC_SAW = 177,
//        SW_DATA_SOURCE_65SEC_SIN = 178,
            SW_DATA_SOURCE_NONE = 255,
};
 
#define ERROR_HOST_INCORRECT_NUMBER_BYTES_WRITTEN 0x10000 
#define ERROR_HOST_DATA_TOO_LONG 0x10001  
#define ERROR_HOST_NACK_ADDRESS 0x10002  
#define ERROR_HOST_NACK_DATA 0x10003   
#define ERROR_HOST_OTHER_I2C_ERROR 0x10004 
 
#define WOMBAT_MAXIMUM_PINS 20
 
enum class SerialWombatCommands
{
    CMD_ECHO ='!', 
    CMD_READ_BUFFER_ASCII = 'G',
    CMD_ASCII_SET_PIN ='P', 
    CMD_RESET = 'R', 
    CMD_SET_BUFFER_ASCII = 'S',
    CMD_RESYNC = 'U',
    CMD_VERSION = 'V',
    CMD_SUPPLYVOLTAGE = 'v',
    COMMAND_BINARY_READ_PIN_BUFFFER = 0x81, 
    COMMAND_BINARY_SET_PIN_BUFFFER = 0x82, 
    COMMAND_BINARY_READ_USER_BUFFER = 0x83, 
    COMMAND_BINARY_WRITE_USER_BUFFER = 0x84, 
    COMMAND_BINARY_WRITE_USER_BUFFER_CONTINUE = 0x85, 
    COMMAND_BINARY_PIN_POLL_THRESHOLD = 0x8F, 
    COMMAND_BINARY_QUEUE_INITIALIZE = 0x90, 
    COMMAND_BINARY_QUEUE_ADD_BYTES = 0x91, 
    COMMAND_BINARY_QUEUE_ADD_7BYTES = 0x92, 
    COMMAND_BINARY_QUEUE_READ_BYTES = 0x93, 
    COMMAND_BINARY_QUEUE_INFORMATION = 0x94, 
    COMMAND_BINARY_QUEUE_CLONE = 0x95, 
    COMMAND_BINARY_CONFIG_DATALOGGER = 0x96, 
    COMMAND_BINARY_CONFIGURE = 0x9F, 
    COMMAND_BINARY_READ_RAM = 0xA0, 
    COMMAND_BINARY_READ_FLASH = 0xA1, 
    COMMAND_BINARY_READ_EEPROM = 0xA2, 
    COMMAND_BINARY_WRITE_RAM = 0xA3, 
    COMMAND_BINARY_WRITE_FLASH = 0xA4, 
    COMMAND_CALIBRATE_ANALOG = 0xA5, 
    COMMAND_ENABLE_2ND_UART = 0xA6, 
    COMMAND_READ_LAST_ERROR_PACKET = 0xA7, 
    COMMAND_UART0_TX_7BYTES = 0xB0, 
    COMMAND_UART0_RX_7BYTES = 0xB1, 
    COMMAND_UART1_TX_7BYTES = 0xB2, 
    COMMAND_UART1_RX_7BYTES = 0xB3, 
    COMMAND_BINARY_TEST_SEQUENCE = 0xB4,
    COMMAND_BINARY_RW_PIN_MEMORY = 0xB5,
    COMMAND_CAPTURE_STARTUP_SEQUENCE = 0xB6,
    COMMAND_ADJUST_FREQUENCY = 0xB7,
        COMMAND_SET_PIN_HW = 0xB8, 
        COMMAND_BINARY_SET_ADDRESS = 0xB9, 
    CONFIGURE_PIN_MODE0 = 200, 
    CONFIGURE_PIN_MODE1 = 201, 
    CONFIGURE_PIN_MODE2 = 202, 
    CONFIGURE_PIN_MODE3 = 203, 
    CONFIGURE_PIN_MODE4 = 204, 
    CONFIGURE_PIN_MODE5 = 205, 
    CONFIGURE_PIN_MODE6 = 206, 
    CONFIGURE_PIN_MODE7 = 207, 
    CONFIGURE_PIN_MODE8 = 208, 
    CONFIGURE_PIN_MODE9 = 209, 
    CONFIGURE_PIN_MODE10 = 210, 
    CONFIGURE_PIN_OUTPUTSCALE = 210, 
    CONFIGURE_PIN_MODE_DISABLE = 219, 
    CONFIGURE_PIN_INPUTPROCESS = 211, 
    CONFIGURE_CHANNEL_MODE_CHECK_MODE_SUPPORTED = 218, 
    CONFIGURE_PIN_MODE_HW_0 = 220, 
    CONFIGURE_CHANNEL_MODE_HW_1 = 221, 
    CONFIGURE_CHANNEL_MODE_HW_2 = 222, 
    CONFIGURE_CHANNEL_MODE_HW_3 = 223, 
 
};
 
 
typedef enum {
    PIN_MODE_DIGITALIO = 0, 
    PIN_MODE_CONTROLLED = 1, 
    PIN_MODE_ANALOGINPUT = 2, 
    PIN_MODE_SERVO = 3, 
    PIN_MODE_THROUGHPUT_CONSUMER = 4, 
    PIN_MODE_QUADRATUREENCODER = 5, 
    PIN_MODE_HBRIDGE = 6, 
    PIN_MODE_WATCHDOG = 7, 
    PIN_MODE_PROTECTED_OUTPUT = 8, 
    PIN_MODE_DEBOUNCE = 10, 
    PIN_MODE_TM1637 = 11, 
    PIN_MODE_WS2812 = 12, 
    PIN_MODE_SW_UART = 13, 
    PIN_MODE_INPUT_PROCESSOR = 14, 
    PIN_MODE_MATRIX_KEYPAD = 15, 
    PIN_MODE_PWM = 16, 
    PIN_MODE_UART_RX_TX = 17, 
    PIN_MODE_PULSETIMER = 18, 
    PIN_MODE_FRAME_TIMER = 21, 
    PIN_MODE_SW18AB_CAPTOUCH = 22, 
    PIN_MODE_UART1_RX_TX = 23, 
    PIN_MODE_RESISTANCEINPUT = 24, 
    PIN_MODE_PULSE_ON_CHANGE = 25, 
    PIN_MODE_HS_SERVO = 26, 
    PIN_MODE_ULTRASONIC_DISTANCE = 27, 
    PIN_MODE_LIQUIDCRYSTAL = 28, 
    PIN_MODE_HS_CLOCK = 29, 
    PIN_MODE_HS_COUNTER = 30, 
    PIN_MODE_VGA = 31, 
    PIN_MODE_PS2KEYBOARD = 32, 
    PIN_MODE_I2C_CONTROLLER = 33, 
    PIN_MODE_QUEUED_PULSE_OUTPUT = 34, 
    PIN_MODE_FREQUENCY_OUTPUT = 36, 
    PIN_MODE_IRRX = 37, 
    PIN_MODE_IRTX = 38, 
    PIN_MODE_BLINK = 40, 
    PIN_MODE_SPI = 41, 
    PIN_MODE_RANDOMBLINK = 42, 
    PIN_MODE_CHARLIEPLEX = 43, 
    PIN_MODE_UNKNOWN = 255, 
}SerialWombatPinMode_t;
 
class SerialWombatChip;
 
typedef void  (*SerialWombatErrorHandler_t) (uint16_t errorNumber, SerialWombatChip* sw);

class SerialWombatChip
{
private:
 
    char version[8] = { 0 };
    HardwareSerial * SerialInstance = NULL;
    TwoWire* i2cInterface = NULL;
    uint8_t _pinmode[WOMBAT_MAXIMUM_PINS]={}; // Includes Pullup
    bool _pullDown[WOMBAT_MAXIMUM_PINS]={};
    bool _openDrain[WOMBAT_MAXIMUM_PINS]={};
    bool _highLow[WOMBAT_MAXIMUM_PINS] = {};
    bool _asleep = false;
    SerialWombatErrorHandler_t errorHandler = NULL;
    bool _currentlyCommunicating = false;
public:
    uint16_t _supplyVoltagemV = 0;

    uint8_t model[4] = { 0 };

    uint8_t fwVersion[4] = { 0 };

    uint8_t uniqueIdentifier[16];

    uint8_t uniqueIdentifierLength = 0;

    uint16_t deviceIdentifier;

    uint16_t deviceRevision;
    uint16_t errorCount = 0;

    bool inBoot = false;

    int16_t lastErrorCode = 0;

    
    void configureDigitalPin(uint8_t pin, uint8_t highLow)
    {
        uint8_t tx[8] = { 200,pin,0,0,0,0,0,0x55 };
        uint8_t rx[8];
        switch (_pinmode[pin])
        {
        case INPUT: // Arduino input
        {
            tx[3] = 2; //Input
        }
        break;
        case OUTPUT:
        {
            if (highLow == LOW)
            {
                tx[3] = 0;
            }
            else if (highLow == HIGH)
            {
                tx[3] = 1;
            }
            else 
            { 
                return; 
            }
        }
        break;
        case INPUT_PULLUP:
        {
            tx[3] = 2; //Input
            tx[4] = 1; //Pullup on
        }
        break;
        default:
        {
            return;
        }
        }
        tx[6] = _openDrain[pin];
        tx[5] = _pullDown[pin];
        sendPacket(tx, rx, true);
    }

    uint32_t sendReadyTime = 0;

    int16_t initialize() 
    {
        lastErrorCode = 0;
        readVersion();
        readSupplyVoltage_mV();
        readUniqueIdentifier();
        readDeviceIdentifier();
        return(lastErrorCode);
    }
        
    void readUniqueIdentifier()
    {
        uniqueIdentifierLength = 0;
        if (version[0] == 'S' && version[1] == '0' && version[2] == '4')
        { //16F15214
            for (uint32_t address = 0x8100; address <= 0x8108; ++address)
            {
                uint32_t data = readFlashAddress(address);
                uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)data;
                ++uniqueIdentifierLength;
                /* Always zero... leave out
                uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)(data>>8);
                ++uniqueIdentifierLength;
                */
            }
        }
        else if (isSW18())
        {
            for (uint32_t address = 0x801600; address <= 0x801608; address += 2)
            {
                uint32_t data = readFlashAddress(address);
                uniqueIdentifier[uniqueIdentifierLength] = data;
                ++uniqueIdentifierLength;
                uniqueIdentifier[uniqueIdentifierLength] = data >> 8;
                ++uniqueIdentifierLength;
                uniqueIdentifier[uniqueIdentifierLength] = data >> 16;
                ++uniqueIdentifierLength;
            }
        }
        else if (isSW08())
        { //CH32V003
            for (uint32_t address = 0x1FFFF7E8; address <= 0x1FFFF7F0; address += 4)
            {
                uint32_t data = readFlashAddress(address);
                uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)data;
                ++uniqueIdentifierLength;
                uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)(data >> 8);
                ++uniqueIdentifierLength;
                uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)(data >> 16);
                ++uniqueIdentifierLength;
                uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)(data >> 24);
                ++uniqueIdentifierLength;
            }
        }
        
    }

 
    void readDeviceIdentifier() 
    {
        if (version[0] == 'S' && version[1] == '0' && version[2] == '4')
        { //16F15214
            
                uint32_t data = readFlashAddress(0x8006);
                deviceIdentifier = (uint16_t)data;
                data = readFlashAddress(0x8005);
                deviceRevision = (uint16_t)data;
        }
        else if (isSW18())
        {
            uint32_t data = readFlashAddress(0xFF0000);
            deviceIdentifier = (uint16_t)data;
            data = readFlashAddress(0xFF0002);
            deviceRevision = (uint16_t)data & 0xF;
        }
    }

    uint16_t returnErrorCode(uint8_t* rx)
    {
        uint16_t result = rx[1] - '0';
        result *= 10;
        result += rx[2] - '0';
        result *= 10;
        result += rx[3] - '0';
        result *= 10;
        result += rx[4] - '0';
        result *= 10;
        result += rx[5] - '0';
        return(result);
    }
 
 
    
public:
    SerialWombatChip();
    int16_t begin(HardwareSerial& serial, bool reset = true)
    {
        SerialInstance = &serial;
        SerialInstance->begin(115200);
        SerialInstance->setTimeout(2);
        SerialInstance->write((uint8_t*)"UUUUUUUU", 8);
        delay(5);
        while (SerialInstance->read() >= 0);
        if (reset)
        {
            hardwareReset();
            sendReadyTime = millis() + 1000;
            return(1);
        }
        else
        {
            return initialize();
        }
        
        
    }

    int16_t begin(uint8_t i2cAddress);

    int16_t begin(TwoWire& wire, uint8_t i2cAddress, bool reset = true) 
    {   
            i2cInterface = &wire;
            address = i2cAddress;
 
            Wire.beginTransmission(i2cAddress);
            int error = Wire.endTransmission();
 
 
            if (error != 0)
            {
                return(-1);
            }
 
            if (reset)
            {
                hardwareReset();
                sendReadyTime = millis() + 250;
                return(1);
            }
            else
            {
                sendReadyTime = 0;
                return initialize();
 
            }
    }
 
    ~SerialWombatChip();

    int sendPacket( uint8_t tx[], uint8_t rx[]);

    int sendPacket(uint8_t tx[]);

    int sendPacket(uint8_t tx[], uint8_t rx[], bool retryIfEchoDoesntMatch, uint8_t beginningBytesToMatch = 8, uint8_t endBytesToMatch = 0);
    int sendPacket(uint8_t tx[], bool retryIfEchoDoesntMatch);

 
    int sendPacketNoResponse(uint8_t tx[]);

    char* readVersion(void) 
    {
        uint8_t tx[] = { 'V',0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        memcpy(version, &rx[1], 7);
        version[7] = '\0';
        memcpy(model, &rx[1], 3);
        model[3] = '\0';
        fwVersion[0] = rx[5];
        fwVersion[1] = rx[6];
        fwVersion[2] = rx[7];
        return (version);
    }

    uint32_t readVersion_uint32(void) 
    {
        readVersion();
        return (
            ((uint32_t)fwVersion[0] - '0') * 100 +
            ((uint32_t)fwVersion[1] - '0') * 10 +
        (uint32_t)fwVersion[2] - '0');
    }

    bool isLatestFirmware(void)
    {
        uint32_t v = readVersion_uint32();
        if (isSW18())
        {
            //Hack for the irrx release
            return (v == SW18AB_LATEST_FIRMWARE );
        }
        else if (isSW08())
        {
            //Hack for the irrx release
            return (v == SW08B_LATEST_FIRMWARE );
        }
        else
        {
            return (v == SW4B_LATEST_FIRMWARE);
 
        }
    }

    uint16_t readPublicData(uint8_t pin)
    {
        uint8_t tx[] = { 0x81,pin,255,255,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        return(rx[2] + (uint16_t)rx[3] * 256);
    }

    uint16_t readPublicData(SerialWombatDataSource dataSource)
    {
        return (readPublicData((uint8_t)dataSource));
    }

    uint16_t writePublicData(uint8_t pin, uint16_t value)
    {
        uint8_t tx[] = { 0x82,pin,(uint8_t)(value & 0xFF),(uint8_t)(value >> 8) ,255,0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        return (rx[2] + rx[3] * 256);
    }

    uint16_t writePublicData(uint8_t firstPin, uint16_t firstValue, uint8_t secondPin,uint16_t secondValue)
    {
        uint8_t tx[] = { 0x82,firstPin,(uint8_t)(firstValue & 0xFF),(uint8_t)(firstValue >> 8) ,secondPin,(uint8_t)(secondValue & 0xFF),(uint8_t)(secondValue >> 8) ,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        return (rx[2] + rx[3] * 256);
    }
 
    uint32_t comparePublicDataToThreshold(uint16_t threshold = 0)
    {
        uint8_t tx[] = { (uint8_t) SerialWombatCommands::COMMAND_BINARY_PIN_POLL_THRESHOLD,SW_LE16(threshold) ,0x55, 0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        return (ARRAY_UINT32(rx,1));
    }

 
    uint16_t readSupplyVoltage_mV(void) 
    {
        if (isSW18() || isSW08())
        {
            _supplyVoltagemV = readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_VCC_mVOLTS);
        }
        else
        {
            int32_t counts = readPublicData(66); // Get FVR counts (1.024 v)
            if (counts > 0)
            {
                uint32_t mv = 1024 * 65536 / counts;
                _supplyVoltagemV = (uint16_t)mv;
            }
            else
            {
                _supplyVoltagemV = 0;
            }
        }
        return(_supplyVoltagemV);
    }
 

    int16_t readTemperature_100thsDegC(void)
    {
        if (isSW18())
        {
            int32_t result = readPublicData(70);
            if (result >= 32768)
            {
                result = result - 65536;
            }
            return ((int16_t)result);
        }
        else
        {
            return 2500;
        }
    }

    void hardwareReset() 
    {
        uint8_t tx[9] = "ReSeT!#*";
        sendPacketNoResponse(tx);
    }

    void pinMode(uint8_t pin, uint8_t mode, bool pullDown = false, bool openDrain = false) 
    {
        if (pin >= WOMBAT_MAXIMUM_PINS)
        {
            return;
        }
        _pullDown[pin] = pullDown;
        _openDrain[pin] = openDrain;
        _pinmode[pin] = mode;
        configureDigitalPin(pin, mode);
    }

    void digitalWrite(uint8_t pin, uint8_t val)
    {
        configureDigitalPin(pin, val);
    }

    int digitalRead(uint8_t pin) 
    {
        if (readPublicData(pin) > 0)
        {
            return (HIGH);
        }
        else
        {
            return (LOW);
        }
    }

    int analogRead(uint8_t pin)
    {
        uint8_t tx[] = { 200,pin,PIN_MODE_ANALOGINPUT,0,0,0,0,0 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        return (readPublicData(pin) >> 6); // Scale from 16 bit value to 10 bit value.
    }

    void analogWrite(uint8_t pin, int val)
    {
        uint8_t dutyCycleLow = 0;
        if (val == 255)
        {
            dutyCycleLow = 255;
        }
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE0,pin,PIN_MODE_PWM,pin,dutyCycleLow,(uint8_t) val,false,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
    }

    bool queryVersion()
    {
        uint8_t tx[8] = { 'V',0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        if (rx[0] == 'V' && (rx[1] == 'S' || rx[1] == 'B'))
        {
            model[0] = rx[1];
            model[1] = rx[2];
            model[2] = rx[3];
            model[3] = 0;
            fwVersion[0] = rx[5];
            fwVersion[1] = rx[6];
            fwVersion[2] = rx[7];
            fwVersion[3] = 0;
 
            inBoot = (rx[1] == 'B');
            return (true);
        }
        return (false);
    }

    uint32_t readFramesExecuted()
    {
        uint8_t tx[8] = { 0x81,67,68,0x55,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        uint32_t returnval = rx[2] + (((uint32_t)rx[3]) << 8) + (((uint32_t)rx[4]) << 16) + (((uint32_t)rx[5]) << 24);
            return (returnval);
    }

 
    uint16_t readOverflowFrames()
    {
        return readPublicData(69);
    }

    void jumpToBoot()
    {
        uint8_t tx[] = "BoOtLoAd";
        sendPacket(tx);
    }

    uint8_t readRamAddress(uint16_t address)
    {
        uint8_t tx[8] = { 0xA0,SW_LE16(address),0x55,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        return(rx[3]);
    }

 
    int16_t writeRamAddress(uint16_t address, uint8_t value)
    {
        uint8_t tx[8] = { 0xA3,SW_LE16(address),0,0,value,0x55,0x55};
        return sendPacket(tx);
    }

 
    uint32_t readFlashAddress(uint32_t address)
    {
        uint8_t tx[8] = { 0xA1,SW_LE32(address),0x55,0x55,0x55 };
        uint8_t rx[8];
        sendPacket(tx, rx);
        return(((uint32_t)rx[4]) + (((uint32_t)rx[5]) <<8) + (((uint32_t)rx[6]) <<16) + (((uint32_t)rx[7]) <<24));
    }

     int16_t readUserBuffer(uint16_t index, uint8_t* buffer, uint16_t count)
    {
        uint16_t bytesRead = 0;
        while (bytesRead < count)
        {
            byte tx[] = {(byte)SerialWombatCommands::COMMAND_BINARY_READ_USER_BUFFER, (byte)(index & 0xFF), (byte)(index >> 8), 0x55, 0x55, 0x55, 0x55, 0x55};
            byte rx[8];
            int16_t result = sendPacket(tx,  rx);
            if (result >= 0)
            {
                for (int i = 1; i < 8; ++i)
                {
                    buffer[bytesRead] = rx[i];
                    ++bytesRead;
                    ++index;
                    if (bytesRead >= count)
                    {
                        break;
                    }
                }
            }
            else
            {
                return (bytesRead);
            }
        }
        return (bytesRead);
    }

    void sleep4B()
    {
        uint8_t tx[8] = { 'S','l','E','e','P','!','#','*'};
        sendPacket(tx);
        _asleep = true;
    }

    void sleep8B(uint16_t delay)
    {
        uint8_t tx[8] = { 'S','l','E','e','P','!',SW_LE16(delay)};
 
        sendPacket(tx);
        _asleep = true;
    }

    void wake()
    {
        uint8_t tx[8] = { '!','!','!','!','!','!','!','!' };
        sendPacket(tx);
    }

    bool isSW04()
    {
        return ( model[1] == '0' && model[2] == '4');
    }
 

    bool isSW18()
    {
        return ( model[1] == '1' && model[2] == '8');
    }

    bool isSW08()
    {
        return ( model[1] == '0' && model[2] == '8');
    }

    bool isConfiguredWithStartupCommands()
    {
        if (isSW08())
        {
            for (uint32_t address = 0x08003F00; address < 0x08003FC0; address += 4)
            {
                uint32_t flashData = readFlashAddress(address);
                if (flashData != 0xFFFFFFFF)
                {
                    return true;
                }
            }
            return false;
        }
        else if (isSW18())
        {
            // TODO: Implement startup command detection for Serial Wombat 18AB.
            return false;
        }
        return false;
    }

    bool isPinModeSupported(int pinMode, bool supressErrorReporting = true)
    {
        SerialWombatErrorHandler_t tempErrorHandler =  errorHandler;
        if (supressErrorReporting)
        {
        registerErrorHandler(NULL);
        }
        bool result =  isPinModeSupported((SerialWombatPinMode_t)pinMode);
        registerErrorHandler(tempErrorHandler);
 
        return result;
    }

    bool isPinModeSupported(SerialWombatPinMode_t pinMode)
    {
        if (isSW04())
        {
            switch (pinMode)
            {
                case PIN_MODE_DIGITALIO:
                case PIN_MODE_ANALOGINPUT:
                case PIN_MODE_CONTROLLED:
                case PIN_MODE_SERVO:
                case PIN_MODE_PWM:
                case PIN_MODE_DEBOUNCE:
                case PIN_MODE_QUADRATUREENCODER:
                case PIN_MODE_WATCHDOG:
                case PIN_MODE_PULSETIMER:
                case PIN_MODE_PROTECTED_OUTPUT:
                    return true;
 
                default:
                    return false;
            }
        }
 
        uint8_t tx[8] = {(uint8_t)SerialWombatCommands::CONFIGURE_CHANNEL_MODE_CHECK_MODE_SUPPORTED, 1, (uint8_t)pinMode, 0x55, 0x55, 0x55, 0x55, 0x55};
            int16_t returnVal = sendPacket(tx);
            returnVal *= -1;
            return (returnVal != SW_ERROR_UNKNOWN_PIN_MODE);
    }
 
 
 

    int16_t eraseFlashPage(uint32_t address)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_BINARY_WRITE_FLASH,
            0, //Erase Page
            SW_LE32(address),
            0x55,0x55 };
          #ifdef ESP32 // ESP32 times out early, even if you set the I2C timeout command.
        sendPacketNoResponse(tx);
        delay(40);
        return(8);
#else
        return sendPacket(tx);
           #endif
    }
 

    int16_t writeFlashRow(uint32_t address)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_BINARY_WRITE_FLASH,
            1, // Write entire row
            SW_LE32(address),0x55,0x55 };
#ifdef ESP32
        return sendPacketNoResponse(tx);
 
#else
        return sendPacket(tx);
#endif
    }
 
 
 

    int16_t setThroughputPin(uint8_t pin)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE0,pin,PIN_MODE_FRAME_TIMER,0x55,0x55,0x55,0x55,0x55 };
        return sendPacket(tx);
    }

    int16_t setThroughputPin(uint32_t address)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_BINARY_SET_ADDRESS,SW_LE32(address),0x55,0x55,0x55 };
        return sendPacket(tx);
    }

    int writeUserBuffer(uint16_t index, uint8_t* buffer, uint16_t count)
    {
        uint16_t bytesSent = 0;
        if (count == 0)
        {
            return 0;
        }
 
        { // Send first packet of up to 4 bytes
            uint8_t bytesToSend = 4;
            if (count < 4)
            {
                bytesToSend = (uint8_t)count;
                count = 0;
            }
            else
            {
                count -= 4;
            }
 
            uint8_t tx[8] = { 0x84,SW_LE16(index), bytesToSend,0x55,0x55,0x55,0x55 };
            uint8_t rx[8];
 
            uint8_t i;
            for (i = 0; i < bytesToSend; ++i)
            {
                tx[4 + i] = buffer[i];
            }
            int result = sendPacket(tx, rx);
            if (rx[0] == 'E')
            {
                return (result);
            }
            bytesSent = bytesToSend;
        }
        while (count >= 7)  // Continue sending
        {
 
            count -= 7;
            uint8_t tx[8] = { 0x85,0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
            uint8_t rx[8];
            uint8_t i;
            for (i = 0; i < 7; ++i)
            {
                tx[1 + i] = buffer[bytesSent + i];
            }
            int result = sendPacket(tx, rx);
            if (rx[0] == 'E')
            {
                return (result);
            }
            bytesSent += 7;
        }
        while (count > 0)
        {
 
            { // Send first packet of up to 4 bytes
                uint8_t bytesToSend = 4;
                if (count < 4)
                {
                    bytesToSend = (uint8_t)count;
                    count = 0;
                }
                else
                {
                    count -= 4;
                }
 
                uint8_t tx[8] = { 0x84,SW_LE16(index + bytesSent), bytesToSend,0x55,0x55,0x55,0x55 };
                uint8_t rx[8];
 
                uint8_t i;
                for (i = 0; i < bytesToSend; ++i)
                {
                    tx[4 + i] = buffer[i + bytesSent];
                }
                int result = sendPacket(tx, rx);
                if (rx[0] == 'E')
                {
                    return (result);
                }
                bytesSent += bytesToSend;
            }
        }
        return(bytesSent);
        
 
    }

    int writeUserBuffer(uint16_t index, char* s)
    {
        return writeUserBuffer(index, (uint8_t*)s, (uint16_t)strlen(s));
    }

    int writeUserBuffer(uint16_t index, const char s[])
    {
        return writeUserBuffer(index, (uint8_t*)s, (uint16_t)strlen(s));
    }
 
 

    int16_t writeFrameTimerPin(uint8_t pin)
{
    uint8_t tx[] = { 0xC8 ,pin,(uint8_t)PIN_MODE_FRAME_TIMER,0x55,0x55,0x55,0x55,0x55 };
    return sendPacket(tx);
}
    

    static uint8_t find(bool keepTrying = false)
    {
        do
        {
            for (int i2cAddress = 0x60; i2cAddress <= 0x6F; ++i2cAddress)
            {
                Wire.beginTransmission(i2cAddress);
                int error = Wire.endTransmission();
 
 
                if (error == 0)
                {
                    uint8_t tx[8] = { 'V',0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
                    uint8_t rx[8];
                    Wire.beginTransmission(i2cAddress);
                    Wire.write(tx, 8);
                    Wire.endTransmission();
                    Wire.requestFrom((uint8_t)i2cAddress, (uint8_t)8);
 
                    int count = 0;
                    while (Wire.available() && count < 8)
                    {
                        rx[count] = Wire.read();
                        ++count;
                    }
                    if (count == 8)
                    {
                        if (rx[0] == 'V' && (rx[1] == 'S' || rx[1]=='B'))
                        {
                            return(i2cAddress); // Found one.
                        }
                    }
                }
            }
            delay(0);
        }while (keepTrying);
                return(0);  // Didn't find one.
    }
 

    int16_t readLastErrorCommand(uint8_t* cmd)
{
 
    uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_READ_LAST_ERROR_PACKET, 0,0x55,0x55,0x55,0x55,0x55,0x55 };
    uint8_t rx[8];
    if (sendPacket(tx, rx) >= 0)
    {
        for (int i = 1; i < 8; ++i)
        {
            cmd[i - 1] = rx[i];
        }
    }
    else
    {
        return (lastErrorCode);
    }
    tx[1] = 7;
    if (sendPacket(tx, rx) >= 0)
    {
        cmd[7] = rx[1];
    }
    return(lastErrorCode);
}

    void registerErrorHandler(SerialWombatErrorHandler_t handler)
    {
        errorHandler = handler;
    }

    uint8_t address = 0;

    uint8_t communicationErrorRetries = 5;

    int16_t echo(uint8_t data[], uint8_t count = 7)
    {
        uint8_t tx[] = "!UUUUUUU";
        for (int i = 0; i < 7 && i < count; ++i)
        {
            tx[i + 1] = (uint8_t)data[i];
        }
        return sendPacket(tx);
    }

 
    int16_t echo(char* data)
    {
        int length = strlen(data);
        uint8_t tx[] = "!UUUUUUU";
        for (int i = 0; i < 7 && i < length; ++i)
        {
            tx[i + 1] = (uint8_t)data[i];
        }
        return sendPacket(tx);
    }

    uint32_t readBirthday()
    {
        if (isSW18())
        {
            uint32_t birthday = (readFlashAddress(0x2A00C) >> 8) & 0xFF;
            birthday *= 100;
            birthday += (readFlashAddress(0x2A00C)) & 0xFF;
            birthday *= 100;
            birthday += readFlashAddress(0x2A00E) & 0xFF;
            birthday *= 100;
            birthday += readFlashAddress(0x2A010) & 0xFF;
            return (birthday);
        }
        return 0;
    }

    int16_t readBrand(char* data)
    {
        uint8_t length = 0;
        if (isSW18())
        {
            for (int i = 0; i < 32; ++i)
            {
                uint32_t val = readFlashAddress(0x2A020 + i * 2) ;
                if ((val & 0xFF) != 0xFF)
                {
                    data[i ] = (char)(val & 0xFF);
                    ++length;
                }       
                else
                {
                    data[length] = 0;
                    return (length);
                }
            }
            data[length] = 0;
            return (length);
        }
 
        data[0] = 0;
        return 0 ;
    }
 
};

class SerialWombat18ABOscillatorTuner
{
private:
    SerialWombatChip& _sw;
    uint32_t lastMillis = 0;
    uint32_t lastFrames = 0;
public:
    SerialWombat18ABOscillatorTuner(SerialWombatChip& serialWombatChip) : _sw(serialWombatChip) { }

    void update() {
        uint32_t m = millis();
        if (lastMillis == 0)
        {
            lastMillis = m;
            uint32_t frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            uint16_t frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
            if (frames != _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW))
            {
                frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
                frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            }
            frames <<= 16;
            frames += frameslsb;
            lastFrames = frames;
 
        }
        else if ((m - lastMillis) < 10000)
        {
            //Do nothing
        }
        else if (m < lastMillis)
        {
            //Has it been 47 days already?
            lastMillis = 0;
        }
        else
        {
            uint32_t diff = m - lastMillis;
 
            uint32_t frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            uint16_t frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
            
            if (frames != _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW))
            {
                frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
                frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            }
            frames <<= 16;
            frames += frameslsb;
            uint32_t framesDif = frames - lastFrames;
 
            if (diff > framesDif )
            {
                // Running  slow
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::COMMAND_ADJUST_FREQUENCY,
                    SW_LE16(1),//Counts to increment
                    SW_LE16(0), // Counts to decrement
                    0x55,0x55,0x55};
                _sw.sendPacket(tx);
            }
            else if (diff < framesDif)
            {
                // Running mfast
                uint8_t tx[] = { (uint8_t)SerialWombatCommands::COMMAND_ADJUST_FREQUENCY,
                    SW_LE16(0),//Counts to increment
                    SW_LE16(1), // Counts to decrement
                    0x55,0x55,0x55 };
                _sw.sendPacket(tx);
 
            }
 
            lastMillis = m;
            lastFrames = frames;
 
        }
        
    }
    
};
 

class SerialWombat8BOscillatorTuner
{
private:
    SerialWombatChip& _sw;
    uint32_t lastMillis = 0;
    uint32_t lastFrames = 0;
 
    // CH32V003 RCC_CTLR low byte.  The Serial Wombat 8B firmware RAM read/write
    // commands use 16-bit addresses for memory-mapped register access.
    static const uint16_t CH32V003_RCC_CTLR_LOW = 0x1000;
    static const uint8_t CH32V003_HSITRIM_MASK = 0xF8;
    static const uint8_t CH32V003_HSITRIM_SHIFT = 3;
 
    uint8_t readTrim()
    {
        return ((_sw.readRamAddress(CH32V003_RCC_CTLR_LOW) & CH32V003_HSITRIM_MASK) >> CH32V003_HSITRIM_SHIFT);
    }
 
    void writeTrim(uint8_t trim)
    {
        uint8_t rccCtlrLow = _sw.readRamAddress(CH32V003_RCC_CTLR_LOW);
        rccCtlrLow &= ~CH32V003_HSITRIM_MASK;
        rccCtlrLow |= (uint8_t)((trim & 0x1F) << CH32V003_HSITRIM_SHIFT);
        _sw.writeRamAddress(CH32V003_RCC_CTLR_LOW, rccCtlrLow);
    }
 
public:
    SerialWombat8BOscillatorTuner(SerialWombatChip& serialWombatChip) : _sw(serialWombatChip) { }

    void update() {
        uint32_t m = millis();
        if (lastMillis == 0)
        {
            lastMillis = m;
            uint32_t frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            uint16_t frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
            if (frames != _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW))
            {
                frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
                frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            }
            frames <<= 16;
            frames += frameslsb;
            lastFrames = frames;
 
        }
        else if ((m - lastMillis) < 10000)
        {
            //Do nothing
        }
        else if (m < lastMillis)
        {
            //Has it been 47 days already?
            lastMillis = 0;
        }
        else
        {
            uint32_t diff = m - lastMillis;
 
            uint32_t frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            uint16_t frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
            
            if (frames != _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW))
            {
                frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
                frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
            }
            frames <<= 16;
            frames += frameslsb;
            uint32_t framesDif = frames - lastFrames;
 
            if (diff > framesDif )
            {
                // Running slow
                uint8_t trim = readTrim();
                if (trim < 31)
                {
                    writeTrim(trim + 1);
                }
            }
            else if (diff < framesDif)
            {
                // Running fast
                uint8_t trim = readTrim();
                if (trim > 0)
                {
                    writeTrim(trim - 1);
                }
 
            }
 
            lastMillis = m;
            lastFrames = frames;
 
        }
        
    }
    
};
 
/*
End of cross platform code synchronization.  Random string to help the compare tool sync lines:
asdkj38vjn1nasdnvuwlamafdjiivnowalskive
*/

class SerialWombat : public SerialWombatChip {};  
 
 
 
 

void SerialWombatSerialErrorHandlerBrief(uint16_t error, SerialWombatChip* sw);

void SerialWombatSerialErrorHandlerVerbose(uint16_t error, SerialWombatChip* sw);
 
#include "SerialWombatPin.h"
#include "SerialWombatQueue.h"
#include "SerialWombat18ABDataLogger.h"
#include "SerialWombatAbstractButton.h"
#include "SerialWombatAbstractProcessedInput.h"
#include "SerialWombatAbstractScaledOutput.h"
#include "SerialWombatBlink.h"
#include "SerialWombat18CapTouch.h"
#include "SerialWombat18ABVGA.h"
#include "SerialWombatAnalogInput.h"
#include "SerialWombatCharlieplex.h"
#include "SerialWombatDebouncedInput.h"
#include "SerialWombatDigitalInput.h"
#include "SerialWombatDigitalOutput.h"
#include "SerialWombatFrequencyOutput.h"
#include "SerialWombatHBridge.h"
#include "SerialWombatHSClock.h"
#include "SerialWombatHSCounter.h"
#include "SerialWombatIRRx.h"
#include "SerialWombatIRTx.h"
#include "SerialWombatLiquidCrystal.h"
#include "SerialWombatMatrixKeypad.h"
#include "SerialWombatProcessedInputPin.h"
#include "SerialWombatProtectedOutput.h"
#include "SerialWombatPS2Keyboard.h"
#include "SerialWombatPulseOnChange.h"
#include "SerialWombatPulseTimer.h"
#include "SerialWombatPWM.h"
#include "SerialWombatQuadEnc.h"
#include "SerialWombatQueuedPulseOutput.h"
#include "SerialWombatRandomBlink.h"
#include "SerialWombatResistanceInput.h"
#include "SerialWombatServo.h"
#include "SerialWombatSPI.h"
#include "SerialWombatTM1637.h"
#include "SerialWombatUART.h"
#include "SerialWombatUltrasonicDistanceSensor.h"
#include "SerialWombatWatchdog.h"
#include "SerialWombatWS2812.h"
#include "SerialWombatThroughputConsumer.h"
#include "PCB0030_Bridge.h"
#include "PCB0031_Grip.h"
#include "PCB0041_Remcon.h"
#include "PCB0042_LSD.h"
#include "PCB0046_HSD.h"
#include "PCB0048_Mux.h"
 
#endif