lcd5110.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef LC5110_HH
#define LC5110_HH
 
#include <string.h>
 
#include "../bits.h"
#include "../flash.h"
#include "../gpio.h"
#include "../spi.h"
#include "../time.h"
#include "display.h"
#include "font.h"
 
namespace devices::display
{
    enum class TemperatureCoefficient : uint8_t
    {
        TC0_1mV_K = 0x04,
        TC1_9mV_K = 0x05,
        TC2_17mV_K = 0x06,
        TC3_24mV_K = 0x07
    };
 
    // Forward declaration to allow traits definition
    template<board::DigitalPin, board::DigitalPin, board::DigitalPin> class LCD5110; 
    // Traits for Nokia displays
    template<board::DigitalPin SCE, board::DigitalPin DC, board::DigitalPin RST>
    struct DisplayDeviceTrait<LCD5110<SCE, DC, RST>> : 
        DisplayDeviceTrait_impl<bool, 84, 48, true, true> {};
 
    template<board::DigitalPin SCE, board::DigitalPin DC, board::DigitalPin RST> class LCD5110 : 
        public spi::SPIDevice<SCE, spi::ChipSelect::ACTIVE_LOW, spi::compute_clockrate(4'000'000UL)>
    {
    private:
        using TRAITS = DisplayDeviceTrait<LCD5110<SCE, DC, RST>>;
        static constexpr uint8_t WIDTH = TRAITS::WIDTH;
        static constexpr uint8_t HEIGHT = TRAITS::HEIGHT;
        using DRAW_CONTEXT = DrawContext<bool, true>;
 
    public:
        void reset()
        {
            // Reset device according to datasheet
            gpio::FastPinType<RST>::set_mode(gpio::PinMode::OUTPUT, false);
            time::delay_us(1);
            gpio::FastPinType<RST>::set();
        }
 
        void set_display_bias(uint8_t bias = DEFAULT_BIAS)
        {
            if (bias > MAX_BIAS) bias = MAX_BIAS;
            this->start_transfer();
            send_command_(FUNCTION_SET_MASK | FUNCTION_SET_EXTENDED);
            send_command_(EXTENDED_SET_BIAS | bias);
            send_command_(FUNCTION_SET_MASK);
            this->end_transfer();
        }
 
        void set_display_contrast(uint8_t contrast = DEFAULT_VOP)
        {
            if (contrast > MAX_VOP) contrast = MAX_VOP;
            this->start_transfer();
            send_command_(FUNCTION_SET_MASK | FUNCTION_SET_EXTENDED);
            send_command_(EXTENDED_SET_VOP | contrast);
            send_command_(FUNCTION_SET_MASK);
            this->end_transfer();
        }
 
        void set_temperature_control(TemperatureCoefficient coef)
        {
            this->start_transfer();
            send_command_(FUNCTION_SET_MASK | FUNCTION_SET_EXTENDED);
            send_command_(EXTENDED_SET_BIAS | uint8_t(coef));
            send_command_(FUNCTION_SET_MASK);
            this->end_transfer();
        }
 
        void power_down()
        {
            send_command(FUNCTION_SET_MASK | FUNCTION_SET_POWER_DOWN);
        }
 
        void power_up()
        {
            send_command(FUNCTION_SET_MASK);
        }
 
        void blank()
        {
            send_command(DISPLAY_CONTROL_MASK | DISPLAY_CONTROL_BLANK);
        }
 
        void full()
        {
            send_command(DISPLAY_CONTROL_MASK | DISPLAY_CONTROL_FULL);
        }
 
        void invert()
        {
            send_command(DISPLAY_CONTROL_MASK | DISPLAY_CONTROL_INVERSE);
        }
 
        void normal()
        {
            send_command(DISPLAY_CONTROL_MASK | DISPLAY_CONTROL_NORMAL);
        }
 
    protected:
        LCD5110()
        {
            erase();
        }
 
        void erase()
        {
            memset(display_, 0, sizeof(display_));
        }
 
        // NOTE Coordinates must have been first verified by caller
        bool set_pixel(uint8_t x, uint8_t y, const DRAW_CONTEXT& context)
        {
            // Convert to (r,c)
            const uint8_t c = x;
            const uint8_t r = y / ROW_HEIGHT;
            const uint8_t offset = y % ROW_HEIGHT;
            uint8_t mask = bits::BV8(offset);
            // Get pointer to pixel byte
            uint8_t* pix_column = get_display(r, c);
            // Evaluate final pixel color based on color_ and mode_
            const bool current = (*pix_column & mask);
            const bool dest = context.draw_mode().pixel_op(current);
 
            // Based on calculated color, set pixel
            if (dest)
            {
                if (current) return false;
                *pix_column |= mask;
            }
            else
            {
                if (!current) return false;
                *pix_column &= uint8_t(~mask);
            }
            return true;
        }
 
        bool is_valid_char_xy(UNUSED uint8_t x, uint8_t y)
        {
            return (y % ROW_HEIGHT) == 0;
        }
 
        // NOTE Coordinates must have been first verified by caller
        uint8_t write_char(uint8_t x, uint8_t y, uint16_t glyph_ref, const DRAW_CONTEXT& context)
        {
            // Check column and row not out of range for characters!
            const uint8_t width = context.font().width();
            uint8_t row = y / ROW_HEIGHT;
            const uint8_t col = x;
            bool add_interchar_space = ((col + width + 1) < WIDTH);
 
            uint8_t glyph_index  = 0;
            for (uint8_t glyph_row = 0; glyph_row < context.font().glyph_rows(); ++glyph_row)
            {
                // Get pointer to first byte in row to write in display buffer
                uint8_t* display_ptr = get_display(row, col);
 
                for (uint8_t i = 0; i <= width; ++i)
                {
                    const bool space_column = (i == width);
                    uint8_t pixel_bar = 0x00;
                    if (!space_column)
                        pixel_bar = context.font().get_char_glyph_byte(glyph_ref, glyph_index);
                    if ((!space_column) || add_interchar_space)
                        *display_ptr = context.draw_mode().bw_pixels_op(pixel_bar, *display_ptr);
                    ++display_ptr;
                    ++glyph_index;
                }
                ++row;
            }
 
            // Return actual width writtent to display
            return width + (add_interchar_space ? 1 : 0);
        }
 
        // Copy invalidated rectangle of display map onto the device
        void update(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2)
        {
            const uint8_t size = (x2 - x1 + 1);
            const uint8_t xmin = x1;
            const uint8_t ymin = y1 / ROW_HEIGHT;
            const uint8_t ymax = y2 / ROW_HEIGHT;
            this->start_transfer();
            for (uint8_t y = ymin; y <= ymax; ++y)
            {
                set_rc_(y, xmin);
                dc_.set();
                const uint8_t* display = get_display(y, xmin);
                this->transfer(display, size);
            }
            this->end_transfer();
        }
 
    private:
        // Internal organization of Nokia pixmap buffer (1 byte = 8 vertical pixels)
        static constexpr uint8_t ROW_HEIGHT = 8;
 
        // Masks for Nokia commands
        static constexpr uint8_t FUNCTION_SET_MASK = bits::BV8(5);
        static constexpr uint8_t FUNCTION_SET_POWER_DOWN = bits::BV8(2);
        static constexpr uint8_t FUNCTION_SET_EXTENDED = bits::BV8(0);
 
        static constexpr uint8_t EXTENDED_SET_BIAS = bits::BV8(4);
        static constexpr uint8_t EXTENDED_SET_VOP = bits::BV8(7);
 
        static constexpr uint8_t DISPLAY_CONTROL_MASK = bits::BV8(3);
        static constexpr uint8_t DISPLAY_CONTROL_BLANK = 0;
        static constexpr uint8_t DISPLAY_CONTROL_NORMAL = bits::BV8(2);
        static constexpr uint8_t DISPLAY_CONTROL_FULL = bits::BV8(0);
        static constexpr uint8_t DISPLAY_CONTROL_INVERSE = bits::BV8(0, 2);
 
        static constexpr uint8_t SET_ROW_ADDRESS = bits::BV8(6);
        static constexpr uint8_t SET_COL_ADDRESS = bits::BV8(7);
 
        // Masks for bias and operation voltage (i.e. contrast)
        static constexpr uint8_t MAX_BIAS = 0x07;
        static constexpr uint8_t DEFAULT_BIAS = 0x04;
        static constexpr uint8_t MAX_VOP = 0x7F;
        static constexpr uint8_t DEFAULT_VOP = 40;
 
        void send_command_(uint8_t command)
        {
            dc_.clear();
            this->transfer(command);
        }
 
        void send_command(uint8_t command)
        {
            this->start_transfer();
            send_command_(command);
            this->end_transfer();
        }
 
        void set_rc_(uint8_t r, uint8_t c)
        {
            dc_.clear();
            this->transfer(r | SET_ROW_ADDRESS);
            this->transfer(c | SET_COL_ADDRESS);
        }
 
        // Get a pointer to display byte at (r,c) coordinates 
        // (r,c) must be valid coordinates in pixmap
        uint8_t* get_display(uint8_t r, uint8_t c)
        {
            return &display_[r * WIDTH + c];
        }
        const uint8_t* get_display(uint8_t r, uint8_t c) const
        {
            return &display_[r * WIDTH + c];
        }
 
        // Display map (copy of chip display map)
        // Format:  R1C1 R1C2 ... R1Cn
        //          R2C1 R2C2 ... R2Cn
        //          ...
        //          RpC1 RpC2 ... RpCn
        uint8_t display_[HEIGHT * WIDTH / ROW_HEIGHT];
 
        // Pin to control data Vs command sending through SPI
        gpio::FAST_PIN<DC> dc_{gpio::PinMode::OUTPUT};
    };
}
 
#endif /* LC5110_HH */