SerialWombatMatrixKeypad.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 "Stream.h"
#include "SerialWombat.h"
 
class SerialWombatMatrixKeypad :
    public Stream
{
public:
    SerialWombatMatrixKeypad(SerialWombatChip& serialWombat):_sw(serialWombat)
    {
        _sw = serialWombat;
    }

    int16_t begin(uint8_t controlPin, 
        uint8_t row0pin, uint8_t row1pin, uint8_t row2pin, uint8_t row3pin, 
        uint8_t column0pin, uint8_t column1pin, uint8_t column2pin, uint8_t column3pin, 
        uint8_t bufferMode = 0, uint8_t queueMode = 1, uint8_t rowTiming = 5)
    {
        _pin = controlPin;
 
        uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE0,
                            _pin,
                            (uint8_t)PIN_MODE_MATRIX_KEYPAD ,
                            row0pin,
                            row1pin,
                            row2pin,
                            row3pin,
                            column0pin };
        int16_t result = _sw.sendPacket(tx);
        if (result < 0)
        {
            return result;
        }
 
        uint8_t tx5[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE5,
                            _pin,
                            (uint8_t)PIN_MODE_MATRIX_KEYPAD ,
                            column1pin,
                            column2pin,
                            column3pin,
                            bufferMode,
                            queueMode };
        result =  _sw.sendPacket(tx5);
        if (result < 0)
        {
            return result;
        }
        uint8_t tx8[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE8,
                            _pin,
                            (uint8_t)PIN_MODE_MATRIX_KEYPAD ,
rowTiming, 
0x55,
0x55,
0x55,
0x55
                            };
        return _sw.sendPacket(tx8);
    }
    

    int16_t writeQueueMask(uint16_t mask)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE7,
            _pin, (uint8_t)PIN_MODE_MATRIX_KEYPAD,
            SW_LE16(mask),0x55,0x55,0x55 };
        return _sw.sendPacket(tx);
    }

    int16_t writeAsciiTable(uint8_t tableIndex, uint8_t asciiValue )
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE9,
            _pin, (uint8_t)PIN_MODE_MATRIX_KEYPAD,
            tableIndex,asciiValue,0x55,0x55,0x55};
        return _sw.sendPacket(tx);
    }

    int available()
    {
        uint8_t tx[8] = { 201, _pin, (uint8_t)PIN_MODE_MATRIX_KEYPAD, 0,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        _sw.sendPacket(tx, rx);
        return (rx[4]);
    }

    int read()
    {
        uint8_t tx[8] = { 202, _pin,(uint8_t)PIN_MODE_MATRIX_KEYPAD, 1,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        if (_sw.sendPacket(tx, rx) < 0)
        {
            return -1;
        }
 
        if (rx[3] != 0)
        {
            return (rx[4]);
        }
        else
        {
            return (-1);
        }
    }

    void flush()
    {
    //TODO  
    }

    int peek()
    {
        uint8_t tx[8] = { 203, _pin,(uint8_t)PIN_MODE_MATRIX_KEYPAD,0x55,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        _sw.sendPacket(tx, rx);
        if (rx[4] > 0)
        {
            return (rx[5]);
        }
        else
        {
            return (-1);
        }
    }

    size_t write(uint8_t data)
{
    (void)data; // Avoid compiler warning about unused parameter
    
    return (1);
}

    size_t write(const uint8_t* buffer, size_t size)
{
    (void)buffer; // Avoid compiler warning about unused parameter
    return(size);
}

    int availableForWrite()
    {
        return(0);
    }

    size_t readBytes(char* buffer, size_t length)
{
    int index = 0;
    int bytesAvailable = 0;
    uint32_t timeoutMillis = millis() + timeout;
    while (length > 0 && timeoutMillis > millis())
    {
        int bytecount = 4;
        if (length < 4)
        {
            bytecount = length;
        }
        {
 
            uint8_t tx[8] = { 202, _pin,(uint8_t)PIN_MODE_MATRIX_KEYPAD, (uint8_t)bytecount,0x55,0x55,0x55,0x55 };
            uint8_t rx[8];
            _sw.sendPacket(tx, rx);
            bytesAvailable = rx[3];
 
            if (bytesAvailable == 0)
            {
                continue;
            }
            else
            {
                timeoutMillis = millis() + timeout;
            }
            uint8_t bytesReturned = bytecount;
            if (rx[3] < bytecount)
            {
                bytesReturned = rx[3];
            }
            for (int i = 0; i < bytesReturned; ++i)
            {
                buffer[index] = rx[i + 4];
                ++index;
                --bytesAvailable;
                --length;
 
            }
        }
 
    }
    return (index);
}

    void setTimeout(long timeout_mS)
    {
        if (timeout_mS == 0)
        {
            timeout = 0x80000000;
        }
        else
        {
            timeout = timeout_mS;
        }
    }
 

    SerialWombatMatrixKeypad operator=(SerialWombatMatrixKeypad& kp)
    {
        return kp;
    }
 
 
     SerialWombatChip& _sw;
     uint8_t _pin = 255;
protected:
     uint32_t timeout = 1;
};
 

class SerialWombatMatrixButton : public SerialWombatAbstractButton
{
public:
    SerialWombatMatrixButton(SerialWombatMatrixKeypad& kp, uint8_t keyIndex):SerialWombatAbstractButton(),_keypad(kp)
    {
        _keypad = kp;
        _keyIndex = keyIndex;
    }

    bool digitalRead()
{
    uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE6,
                    _keypad._pin,
                    PIN_MODE_MATRIX_KEYPAD,
                    0,
                    _keyIndex,0x55,0x55,0x55 };
    uint8_t rx[8];
    int result = _keypad._sw.sendPacket(tx, rx);
    if (result >= 0)
    {
        transitions = rx[4] + 256 * rx[5];
 
            return (rx[3] > 0);
    }
    return(0);
}

    uint16_t readDurationInFalseState_mS()
{
    uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE6,
                    _keypad._pin,
                    PIN_MODE_MATRIX_KEYPAD,
                    0,
                    _keyIndex,0x55,0x55,0x55 };
    uint8_t rx[8];
    int result = _keypad._sw.sendPacket(tx, rx);
    if (result >= 0)
    {
        transitions = rx[4] + 256 * rx[5];
        uint16_t time = rx[6] + 256 * rx[7];
        if (rx[3] == 0)
        {
            return(time);
        }   
    }
    return(0);
}

    uint16_t readDurationInTrueState_mS()
{
    uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE6,
                    _keypad._pin,
                    PIN_MODE_MATRIX_KEYPAD,
                    0,
                    _keyIndex,0x55,0x55,0x55 };
    uint8_t rx[8];
    int result = _keypad._sw.sendPacket(tx, rx);
    if (result >= 0)
    {
        transitions = rx[4] + 256 * rx[5];
        uint16_t time = rx[6] + 256 * rx[7];
        if (rx[3] == 1)
        {
            return(time);
        }
    }
    return(0);
}

    bool readTransitionsState(bool resetTransitionCount = true)
{
    return digitalRead();
}
 
private:
    SerialWombatMatrixKeypad& _keypad;
    uint8_t _keyIndex;
};