SerialWombatLiquidCrystal.h

Go to the documentation of this file.

#pragma once
/*
Copyright 2022-2023 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"
 


 
class 
    SerialWombatLiquidCrystal : public Print, public SerialWombatPin
{
public:
    SerialWombatLiquidCrystal(SerialWombatChip& serialWombat, uint8_t rs, uint8_t enable, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7):SerialWombatPin(serialWombat)
    {
        _pinMode = PIN_MODE_LIQUIDCRYSTAL;
        _pin = enable;
        _rs = rs;
        _d4 = d4;
        _d5 = d5;
        _d6 = d6;
        _d7 = d7;
    }
 

    int16_t begin(uint8_t cols = 80, uint8_t rows = 1)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE0,
                        _pin,
                        _pinMode,
                        _rs,
                        _d4,
                        _d5,
                        _d6,
                        _d7 };
        int16_t result = _sw.sendPacket(tx);
        if (result < 0)
        {
            return (result);
        }
        _rows = rows;
        _columns = cols;
        result = setRowOffsets(0, 0x40, cols, 0x40 + cols);
        if (result < 0)
        {
            return (result);
        }
 
        return(0);
    }

    int16_t clear(bool delayAfterClear = true)
    {
        return command(0x01);  // Clear display
        if (delayAfterClear)
        {
            delay(2);
        }
    }
 

    int16_t home(bool delayAfterHome = true)
    {
        return command(0x02);  // Clear display
        if (delayAfterHome)
        {
            delay(2);
        }
    }

    int16_t setCursor(uint8_t col, uint8_t row)
    {
        if (row >= _rows)
        {
            return -1;
        }
 
        if (col >= _columns)
        {
            return -1;
        }
        return command(0x80 + _offsets[row] + col);
    }

    int16_t noCursor()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                        _pin,
                        _pinMode,
                        0, // DisplayControl
                        (uint8_t)~0x02, // And Mask
                        0, // OR MASK
                        0x55,0x55
        };
        return _sw.sendPacket(tx);
    }

    int16_t cursor()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                        _pin,
                        _pinMode,
                                0, // DisplayControl
                        0xFF, // And Mask
                        0x02, // OR MASK
                        0x55,0x55
        };
        return _sw.sendPacket(tx);
    }

    int16_t blink()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                        _pin,
                        _pinMode,
                                0, // DisplayControl
 
                        0xFF, // And Mask
                        0x01, // OR MASK
                        0x55,0x55
        };
        return _sw.sendPacket(tx);
    }

    int16_t noBlink()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                        _pin,
                        _pinMode,
                                0, // DisplayControl
 
                        (uint8_t)~0x01, // And Mask
                        0, // OR MASK
                        0x55,0x55
        };
        return _sw.sendPacket(tx);
    }
 

    int16_t display()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                            _pin,
                            _pinMode,
                                0, // DisplayControl
 
                            0xFF, // And Mask
                            0x04, // OR MASK
                            0x55,0x55
        };
        return _sw.sendPacket(tx);
    }

    int16_t noDisplay()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                        _pin,
                        _pinMode,
                                0, // DisplayControl
 
                        (uint8_t)~0x04, // And Mask
                        0, // OR MASK
                        0x55,0x55
        };
        return _sw.sendPacket(tx);
    }

    int16_t scrollDisplayLeft()
    {
        return command(0x18); // Display Move left LCD
        
    }

    int16_t scrollDisplayRight()
    {
        return command(0x1C); // Display Move right LCD
    }

    int16_t autoscroll()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                        _pin,
                        _pinMode,
                                1, // DisplayMode
                        0xFF, // And Mask
                        0x01, // OR MASK
                        0x55,0x55
        };
        return _sw.sendPacket(tx);
    }
 

    int16_t noAutoscroll()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                    _pin,
                    _pinMode,
                            1, // DisplayMode
                    (uint8_t)~0x01, // And Mask
                    0x00, // OR MASK
                    0x55,0x55
        };
        return _sw.sendPacket(tx);
    }
 

    int16_t leftToRight()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                    _pin,
                    _pinMode,
                            1, // DisplayMode
                    0xFF, // And Mask
                    0x02, // OR MASK
                    0x55,0x55
        };
        return _sw.sendPacket(tx);
    }

    int16_t rightToLeft()
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE3,
                    _pin,
                    _pinMode,
                            1, // DisplayMode
                    (uint8_t)~0x02, // And Mask
                    0x00, // OR MASK
                    0x55,0x55
        };
        return _sw.sendPacket(tx);
    }

    size_t write(uint8_t data)
{
    uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE4,
    _pin,
    (uint8_t)PIN_MODE_LIQUIDCRYSTAL,
        2, // Data
        data,
        0x55,
        0x55,
        0x55
    };
    if (_sw.sendPacket(tx) >= 0)
    {
        return 1;
    }
    return 0;
}

    size_t write(uint8_t* buffer, size_t count)
    {
        size_t sent = 0;
        while (sent < count - 5) 
        {
            uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE5,
            _pin,
            (uint8_t)PIN_MODE_LIQUIDCRYSTAL,
                buffer[sent],
                buffer[sent + 1],
                buffer[sent + 2],
                buffer[sent + 3],
                buffer[sent + 4],       
            };
            if (_sw.sendPacket(tx) < 0)
            {
                return sent;
            }
            sent += 5;
        }
        while (sent < count - 1)  
        {
            uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE4,
            _pin,
            (uint8_t)PIN_MODE_LIQUIDCRYSTAL,
                2, // Data
                buffer[sent],
                2, // Data
                buffer[sent + 1],
                0x55
            };
            if (_sw.sendPacket(tx) < 0)
            {
                return sent;
            }
            sent += 2;
        }
        if (sent < count)
        {
            uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE4,
               _pin,
               (uint8_t)PIN_MODE_LIQUIDCRYSTAL,
                   2, // Data
                   buffer[sent],
                  0x55,
                0x55,
                0x55
            };
            if (_sw.sendPacket(tx) >= 0)
            {
                ++sent;
            }
        }
        return sent;
    }

    int16_t createChar(uint8_t index, uint8_t bitmap[])
    {
        if (index >= 8)
        {
            return (-1);
        }
        int16_t result = command((uint8_t)(0x40 | (index << 3))); // Set character ram location
        if (result < 0)
        {
            return result;
        }
        for (int i = 0; i < 8; ++i)
        {
            result =(int16_t) write(bitmap[i]);
            if (result < 0)
            {
                return result;
            }
        }
        return 0;
    }

    int16_t setRowOffsets(uint8_t row1, uint8_t row2, uint8_t row3, uint8_t row4)
    {
        _offsets[0] = row1;
        _offsets[1] = row2;
        _offsets[2] = row3;
        _offsets[3] = row4;
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE8,
                    _pin,
                    _pinMode,
                        0,row1,0x55,0x55
        };
        int16_t result = _sw.sendPacket(tx); if (result < 0) { return result; };
        tx[3] = 1; tx[4] = row2;
        result = _sw.sendPacket(tx); if (result < 0) { return result; };
        tx[3] = 2; tx[4] = row3;
        result = _sw.sendPacket(tx); if (result < 0) { return result; };
        tx[3] = 3; tx[4] = row4;
        result = _sw.sendPacket(tx); if (result < 0) { return result; };
        return(0);
    }

    int16_t command(uint8_t cmd)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE4,
        _pin,
        (uint8_t)PIN_MODE_LIQUIDCRYSTAL,
            1, // Command
            cmd, 
            0x55,
            0x55,
            0x55
        };
        return _sw.sendPacket(tx);
    }

    uint8_t pin() { return _pin; }

    uint8_t swPinModeNumber() { return _pinMode; }

    int16_t initializeBufferCopy(uint16_t bufferIndex, uint8_t width = 255)
    {
        if (width == 255)
        {
            width = _columns;
        }
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE6,
        _pin,
        (uint8_t)PIN_MODE_LIQUIDCRYSTAL,
            (byte)(bufferIndex & 0xFF),
            (byte)(bufferIndex >>8),
            width,
            0x55,
            0x55,
 
        };
        return _sw.sendPacket(tx);
    }
//TODO  int16_t dataMonitor(uint8_t pin, uint8_t col, uint8_t row, uint8_t index, bool hex=false);

    int16_t beginE2(uint8_t e2Pin)
    {
        uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE7,
        _pin,
        (uint8_t)PIN_MODE_LIQUIDCRYSTAL,
            e2Pin,
            0x55,
            0x55,
            0x55,
            0x55,
 
        };
        return _sw.sendPacket(tx);
    }
 
    using Print::write;  //Inherit the write commands from print.
 
 
private:
    uint8_t _rs = 255,
        _d4 = 255,
        _d5 = 255,
        _d6 = 255,
        _d7 = 255;
    uint8_t _rows = 2;
    uint8_t _columns = 40;
    uint8_t _offsets[8] = { 0,64,20,84,0,64,20,84 };
 
};