TFTControllerGeneric.h

Go to the documentation of this file.

/*
  Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  Copyright (c) 2019-2022 Fabrizio Di Vittorio.
  All rights reserved.
 
 
* Please contact fdivitto2013@gmail.com if you need a commercial license.
 
 
* This library and related software is available under GPL v3.
 
  FabGL is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  FabGL is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
 
 
#include <stdint.h>
#include <stddef.h>
 
#ifdef ARDUINO
  #include "SPI.h"
#endif
 
#include "freertos/FreeRTOS.h"
 
#include "driver/spi_master.h"
 
#include "fabglconf.h"
#include "fabutils.h"
#include "displaycontroller.h"
 
 
#define TFT_CASET      0x2A
#define TFT_RASET      0x2B
#define TFT_RAMWR      0x2C
#define TFT_MADCTL     0x36
 
 
 
namespace fabgl {
 
 
 
enum class TFTOrientation {
  Rotate0,            
  Rotate90,           
  Rotate180,          
  Rotate270,          
};
 
 
class TFTController : public GenericBitmappedDisplayController {
 
public:
 
  // unwanted methods
  TFTController(TFTController const&) = delete;
  void operator=(TFTController const&)   = delete;
 
  TFTController();
 
  ~TFTController();
 
  #ifdef ARDUINO
  void begin(SPIClass * spi, gpio_num_t DC, gpio_num_t RESX = GPIO_UNUSED, gpio_num_t CS = GPIO_UNUSED);
  #endif
 
  #ifdef ARDUINO
  void begin(SPIClass * spi, int DC, int RESX = -1, int CS = -1);
  #endif
 
  void begin(int SCK, int MOSI, int DC, int RESX, int CS, int host);
 
  void begin();
 
  void end();
 
  void setResolution(char const * modeline, int viewPortWidth = -1, int viewPortHeight = -1, bool doubleBuffered = false);
 
  // abstract method of BitmappedDisplayController
  void suspendBackgroundPrimitiveExecution();
 
  // abstract method of BitmappedDisplayController
  void resumeBackgroundPrimitiveExecution();
 
  // abstract method of BitmappedDisplayController
  NativePixelFormat nativePixelFormat() { return NativePixelFormat::RGB565BE; }
 
  virtual int colorsCount()             { return 1 << 16; }
 
  void setScreenCol(int value);
 
  void setScreenRow(int value);
 
  int screenCol() { return m_screenCol; }
 
  int screenRow() { return m_screenRow; }
 
  void readScreen(Rect const & rect, RGB888 * destBuf);
 
  void reset() { hardReset(); softReset(); }
 
  void setOrientation(TFTOrientation value, bool force = false);
 
  void setReverseHorizontal(bool value);
 
 
protected:
 
  virtual void softReset() = 0;
 
  virtual void setupOrientation();
 
  // abstract method of BitmappedDisplayController
  int getBitmapSavePixelSize() { return 2; }
 
  void setupGPIO();
 
  void hardReset();
 
  void sendRefresh();
 
  void sendScreenBuffer(Rect updateRect);
  void writeCommand(uint8_t cmd);
  void writeByte(uint8_t data);
  void writeWord(uint16_t data);
  void writeData(void * data, size_t size);
 
  void SPIBegin();
  void SPIEnd();
 
  void SPIBeginWrite();
  void SPIEndWrite();
  void SPIWriteByte(uint8_t data);
  void SPIWriteWord(uint16_t data);
  void SPIWriteBuffer(void * data, size_t size);
 
  void allocViewPort();
  void freeViewPort();
 
  static void updateTaskFunc(void * pvParameters);
 
  // abstract method of BitmappedDisplayController
  void setPixelAt(PixelDesc const & pixelDesc, Rect & updateRect);
 
  // abstract method of BitmappedDisplayController
  void clear(Rect & updateRect);
 
  // abstract method of BitmappedDisplayController
  void drawEllipse(Size const & size, Rect & updateRect);
 
  void VScroll(int scroll, Rect & updateRect);
 
  void HScroll(int scroll, Rect & updateRect);
 
  // abstract method of BitmappedDisplayController
  void drawGlyph(Glyph const & glyph, GlyphOptions glyphOptions, RGB888 penColor, RGB888 brushColor, Rect & updateRect);
 
  // abstract method of BitmappedDisplayController
  void swapBuffers();
 
  // abstract method of BitmappedDisplayController
  void invertRect(Rect const & rect, Rect & updateRect);
 
  // abstract method of BitmappedDisplayController
  void copyRect(Rect const & source, Rect & updateRect);
 
  // abstract method of BitmappedDisplayController
  void swapFGBG(Rect const & rect, Rect & updateRect);
 
  // abstract method of BitmappedDisplayController
  void absDrawLine(int X1, int Y1, int X2, int Y2, RGB888 color);
 
  // abstract method of BitmappedDisplayController
  void rawFillRow(int y, int x1, int x2, RGB888 color);
 
  void rawFillRow(int y, int x1, int x2, uint16_t pattern);
 
  void swapRows(int yA, int yB, int x1, int x2);
 
  void rawInvertRow(int y, int x1, int x2);
 
  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_Native(int destX, int destY, Bitmap const * bitmap, int X1, int Y1, int XCount, int YCount);
 
  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_Mask(int destX, int destY, Bitmap const * bitmap, void * saveBackground, int X1, int Y1, int XCount, int YCount);
 
  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_RGBA2222(int destX, int destY, Bitmap const * bitmap, void * saveBackground, int X1, int Y1, int XCount, int YCount);
 
  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_RGBA8888(int destX, int destY, Bitmap const * bitmap, void * saveBackground, int X1, int Y1, int XCount, int YCount);
 
 
  #ifdef ARDUINO
  SPIClass *         m_spi;
  #endif
 
  spi_host_device_t  m_SPIHost;
  gpio_num_t         m_SCK;
  gpio_num_t         m_MOSI;
  gpio_num_t         m_DC;
  gpio_num_t         m_RESX;
  gpio_num_t         m_CS;
 
  spi_device_handle_t m_SPIDevHandle;
 
  uint16_t * *       m_viewPort;
 
  int16_t            m_screenWidth;
  int16_t            m_screenHeight;
  int16_t            m_screenCol;
  int16_t            m_screenRow;
 
  // view port size when rotation is 0 degrees
  int16_t            m_rot0ViewPortWidth;
  int16_t            m_rot0ViewPortHeight;
 
  // maximum width and height the controller can handle (ie 240x320)
  int16_t            m_controllerWidth;
  int16_t            m_controllerHeight;
 
  // offsets used on rotating
  int16_t            m_rotOffsetX;
  int16_t            m_rotOffsetY;
 
  TaskHandle_t       m_updateTaskHandle;
 
  volatile int       m_updateTaskFuncSuspended;             // 0 = enabled, >0 suspended
  volatile bool      m_updateTaskRunning;
 
  TFTOrientation     m_orientation;
  bool               m_reverseHorizontal;
 
};
 
 
} // end of namespace