vgatextcontroller.h

Go to the documentation of this file.

/*
  Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  All rights reserved.

  This file is part of FabGL Library.

  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>

#include "rom/lldesc.h"
#include "driver/gpio.h"

#include "fabglconf.h"
#include "fabutils.h"
#include "devdrivers/swgenerator.h"
#include "dispdrivers/vgacontroller.h"
#include "fonts/font_8x14.h"


namespace fabgl {


#define VGATextController_CHARWIDTH      8    // max 8
#define VGATextController_CHARWIDTHBYTES ((VGATextController_CHARWIDTH + 7) / 8)
#define VGATextController_CHARHEIGHT     14
#define VGATextController_COLUMNS        80
#define VGATextController_ROWS           34
#define VGATextController_WIDTH          640
#define VGATextController_HEIGHT         480

#define VGATextController_MODELINE       VGA_640x480_60Hz






class VGATextController  : public TextualDisplayController {

public:

  VGATextController();
  ~VGATextController();

  void begin(gpio_num_t redGPIO, gpio_num_t greenGPIO, gpio_num_t blueGPIO, gpio_num_t HSyncGPIO, gpio_num_t VSyncGPIO);

  void begin(gpio_num_t red1GPIO, gpio_num_t red0GPIO, gpio_num_t green1GPIO, gpio_num_t green0GPIO, gpio_num_t blue1GPIO, gpio_num_t blue0GPIO, gpio_num_t HSyncGPIO, gpio_num_t VSyncGPIO);

  void begin();

  void setResolution(char const * modeline = nullptr, int viewPortWidth = -1, int viewPortHeight = -1, bool doubleBuffered = false);

  void setTextMap(uint32_t const * map, int rows);

  void adjustMapSize(int * columns, int * rows);

  int getColumns()                         { return VGATextController_COLUMNS; }
  int getRows()                            { return VGATextController_ROWS; }

  void enableCursor(bool value)            { m_cursorEnabled = value; }
  void setCursorPos(int row, int col)      { m_cursorRow = row; m_cursorCol = col; m_cursorCounter = 0; }
  void setCursorSpeed(int value)           { m_cursorSpeed = value; }
  void setCursorForeground(Color value);
  void setCursorBackground(Color value);


private:

  void setResolution(VGATimings const& timings);
  void init(gpio_num_t VSyncGPIO);
  void setupGPIO(gpio_num_t gpio, int bit, gpio_mode_t mode);
  void freeBuffers();

  void fillDMABuffers();
  uint8_t packHVSync(bool HSync, bool VSync);
  uint8_t preparePixelWithSync(RGB222 rgb, bool HSync, bool VSync);

  uint8_t IRAM_ATTR preparePixel(RGB222 rgb) { return m_HVSync | (rgb.B << VGA_BLUE_BIT) | (rgb.G << VGA_GREEN_BIT) | (rgb.R << VGA_RED_BIT); }

  static void ISRHandler(void * arg);


  static volatile int        s_scanLine;
  static uint32_t            s_blankPatternDWord;
  static uint32_t *          s_fgbgPattern;
  static int                 s_textRow;
  static bool                s_upperRow;
  static lldesc_t volatile * s_frameResetDesc;

  VGATimings                 m_timings;

  GPIOStream                 m_GPIOStream;
  int                        m_bitsPerChannel;  // 1 = 8 colors, 2 = 64 colors, set by begin()
  lldesc_t volatile *        m_DMABuffers;
  int                        m_DMABuffersCount;

  uint32_t *                 m_lines;

  int                        m_rows;

  volatile uint8_t *         m_blankLine; // for vertical porch lines
  volatile uint8_t *         m_syncLine;  // for vertical sync lines

  intr_handle_t              m_isr_handle;

  // contains H and V signals for visible line
  volatile uint8_t           m_HVSync;

  uint8_t *                  m_charData;
  uint32_t const *           m_map;

  // cursor props
  bool                       m_cursorEnabled;
  int                        m_cursorCounter; // trip from -m_cursorSpeed to +m_cursorSpeed (>= cursor is visible)
  int                        m_cursorSpeed;
  int                        m_cursorRow;
  int                        m_cursorCol;
  uint8_t                    m_cursorForeground;
  uint8_t                    m_cursorBackground;

};



}