GxEPD2_7C< GxEPD2_Type, page_height > Class Template Reference

#include <GxEPD2_7C.h>

Inheritance diagram for GxEPD2_7C< GxEPD2_Type, page_height >:

Public Member Functions
	GxEPD2_7C (GxEPD2_Type epd2_instance)
uint16_t	pages ()
uint16_t	pageHeight ()
bool	mirror (bool m)
void	drawPixel (int16_t x, int16_t y, uint16_t color)
void	init (uint32_t serial_diag_bitrate=0)
void	init (uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration=20, bool pulldown_rst_mode=false)
void	init (uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration, bool pulldown_rst_mode, SPIClass &spi, SPISettings spi_settings)
void	fillScreen (uint16_t color)
void	display (bool partial_update_mode=false)
void	displayWindow (uint16_t x, uint16_t y, uint16_t w, uint16_t h)
void	setFullWindow ()
void	setPartialWindow (uint16_t x, uint16_t y, uint16_t w, uint16_t h)
void	firstPage ()
bool	nextPage ()
void	drawPaged (void(*drawCallback)(const void *), const void *pv)
void	drawInvertedBitmap (int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color)
void	clearScreen (uint8_t value=0xFF)
void	writeScreenBuffer (uint8_t value=0xFF)
void	writeImage (const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
void	writeImagePart (const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
void	writeImage (const uint8_t *black, const uint8_t *color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
void	writeImage (const uint8_t *black, const uint8_t *color, int16_t x, int16_t y, int16_t w, int16_t h)
void	writeImagePart (const uint8_t *black, const uint8_t *color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
void	writeImagePart (const uint8_t *black, const uint8_t *color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h)
void	writeNative (const uint8_t *data1, const uint8_t *data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
void	drawImage (const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
void	drawImagePart (const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
void	drawImage (const uint8_t *black, const uint8_t *color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
void	drawImage (const uint8_t *black, const uint8_t *color, int16_t x, int16_t y, int16_t w, int16_t h)
void	drawImagePart (const uint8_t *black, const uint8_t *color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
void	drawImagePart (const uint8_t *black, const uint8_t *color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h)
void	drawNative (const uint8_t *data1, const uint8_t *data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
void	refresh (bool partial_update_mode=false)
void	refresh (int16_t x, int16_t y, int16_t w, int16_t h)
void	powerOff ()
void	hibernate ()

Public Attributes
GxEPD2_Type	epd2

Detailed Description

template<typename GxEPD2_Type, const uint16_t page_height>
class GxEPD2_7C< GxEPD2_Type, page_height >

Definition at line 36 of file GxEPD2_7C.h.

Constructor & Destructor Documentation

GxEPD2_7C()

template<typename GxEPD2_Type , const uint16_t page_height>

GxEPD2_7C< GxEPD2_Type, page_height >::GxEPD2_7C ( GxEPD2_Type epd2_instance )

inline

Definition at line 43 of file GxEPD2_7C.h.

                                         : GxEPD2_GFX_BASE_CLASS(GxEPD2_Type::WIDTH, GxEPD2_Type::HEIGHT), epd2(epd2_instance)
#endif
    {
      _page_height = page_height;
      _pages = (HEIGHT / _page_height) + ((HEIGHT % _page_height) > 0);
      _mirror = false;
      _using_partial_mode = false;
      _current_page = 0;
      setFullWindow();
    }

Member Function Documentation

clearScreen()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::clearScreen ( uint8_t value = 0xFF )

inline

Definition at line 339 of file GxEPD2_7C.h.

    {
      epd2.clearScreen(value);
    }

display()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::display ( bool partial_update_mode = false )

inline

Definition at line 149 of file GxEPD2_7C.h.

    {
      epd2.writeNative(_pixel_buffer, 0, 0, 0, WIDTH, _page_height);
      epd2.refresh(partial_update_mode);
      if (!partial_update_mode) epd2.powerOff();
    }

displayWindow()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::displayWindow ( uint16_t x, uint16_t y, uint16_t w, uint16_t h )

inline

Definition at line 162 of file GxEPD2_7C.h.

    {
      x = gx_uint16_min(x, width());
      y = gx_uint16_min(y, height());
      w = gx_uint16_min(w, width() - x);
      h = gx_uint16_min(h, height() - y);
      _rotate(x, y, w, h);
      epd2.writeNativePart(_pixel_buffer, 0, x, y, WIDTH, _page_height, x, y, w, h);
      epd2.refresh(x, y, w, h);
    }

drawImage() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawImage ( const uint8_t * black, const uint8_t * color, int16_t x, int16_t y, int16_t w, int16_t h )

inline

Definition at line 394 of file GxEPD2_7C.h.

    {
      epd2.drawImage(black, color, x, y, w, h, false, false, false);
    }

drawImage() [2/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawImage ( const uint8_t * black, const uint8_t * color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm )

inline

Definition at line 390 of file GxEPD2_7C.h.

    {
      epd2.drawImage(black, color, x, y, w, h, invert, mirror_y, pgm);
    }

drawImage() [3/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawImage ( const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false )

inline

Definition at line 381 of file GxEPD2_7C.h.

    {
      epd2.drawImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
    }

drawImagePart() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawImagePart ( const uint8_t * black, const uint8_t * color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h )

inline

Definition at line 403 of file GxEPD2_7C.h.

    {
      epd2.drawImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, false, false, false);
    }

drawImagePart() [2/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawImagePart ( const uint8_t * black, const uint8_t * color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm )

inline

Definition at line 398 of file GxEPD2_7C.h.

    {
      epd2.drawImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
    }

drawImagePart() [3/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawImagePart ( const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false )

inline

Definition at line 385 of file GxEPD2_7C.h.

    {
      epd2.drawImagePart(bitmap, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
    }

drawInvertedBitmap()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawInvertedBitmap ( int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color )

inline

Definition at line 312 of file GxEPD2_7C.h.

    {
      // taken from Adafruit_GFX.cpp, modified
      int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
      uint8_t byte = 0;
      for (int16_t j = 0; j < h; j++)
      {
        for (int16_t i = 0; i < w; i++ )
        {
          if (i & 7) byte <<= 1;
          else
          {
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
            byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
#else
            byte = bitmap[j * byteWidth + i / 8];
#endif
          }
          if (!(byte & 0x80))
          {
            drawPixel(x + i, y + j, color);
          }
        }
      }
    }

drawNative()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawNative ( const uint8_t * data1, const uint8_t * data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm )

inline

Definition at line 409 of file GxEPD2_7C.h.

    {
      epd2.drawNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
    }

drawPaged()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawPaged ( void(* drawCallback )(const void *), const void * pv )

inline

Definition at line 277 of file GxEPD2_7C.h.

    {
      if (_using_partial_mode)
      {
        for (_current_page = 0; _current_page < _pages; _current_page++)
        {
          uint16_t page_ys = _current_page * _page_height;
          uint16_t page_ye = _current_page < (_pages - 1) ? page_ys + _page_height : HEIGHT;
          uint16_t dest_ys = _pw_y + page_ys; // transposed
          uint16_t dest_ye = gx_uint16_min(_pw_y + _pw_h, _pw_y + page_ye);
          if (dest_ye > dest_ys)
          {
            fillScreen(GxEPD_WHITE);
            drawCallback(pv);
            epd2.writeNative(_pixel_buffer, 0, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
          }
        }
        epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
      }
      else // full update
      {
        epd2.setPaged(); // for GxEPD2_154c paged workaround
        for (_current_page = 0; _current_page < _pages; _current_page++)
        {
          uint16_t page_ys = _current_page * _page_height;
          fillScreen(GxEPD_WHITE);
          drawCallback(pv);
          epd2.writeNative(_pixel_buffer, 0, 0, page_ys, WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
        }
        epd2.refresh(false); // full update
        epd2.powerOff();
      }
      _current_page = 0;
    }

drawPixel()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::drawPixel ( int16_t x, int16_t y, uint16_t color )

inline

Definition at line 70 of file GxEPD2_7C.h.

    {
      if ((x < 0) || (x >= width()) || (y < 0) || (y >= height())) return;
      if (_mirror) x = width() - x - 1;
      // check rotation, move pixel around if necessary
      switch (getRotation())
      {
        case 1:
          _swap_(x, y);
          x = WIDTH - x - 1;
          break;
        case 2:
          x = WIDTH - x - 1;
          y = HEIGHT - y - 1;
          break;
        case 3:
          _swap_(x, y);
          y = HEIGHT - y - 1;
          break;
      }
      // transpose partial window to 0,0
      x -= _pw_x;
      y -= _pw_y;
      // clip to (partial) window
      if ((x < 0) || (x >= int16_t(_pw_w)) || (y < 0) || (y >= int16_t(_pw_h))) return;
      // adjust for current page
      y -= _current_page * _page_height;
      // check if in current page
      if ((y < 0) || (y >= int16_t(_page_height))) return;
      uint32_t i = x / 2 + uint32_t(y) * (_pw_w / 2);
      uint8_t pv = color7(color);
      if (x & 1) _pixel_buffer[i] = (_pixel_buffer[i] & 0xF0) | pv;
      else _pixel_buffer[i] = (_pixel_buffer[i] & 0x0F) | (pv << 4);
    }

fillScreen()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::fillScreen ( uint16_t color )

inline

Definition at line 138 of file GxEPD2_7C.h.

    {
      uint8_t pv = color7(color);
      uint8_t pv2 = pv | pv << 4;
      for (uint32_t x = 0; x < sizeof(_pixel_buffer); x++)
      {
        _pixel_buffer[x] = pv2;
      }
    }

firstPage()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::firstPage ( )

inline

Definition at line 202 of file GxEPD2_7C.h.

    {
      fillScreen(GxEPD_WHITE);
      _current_page = 0;
      _second_phase = false;
      epd2.setPaged(); // for GxEPD2_565c paged workaround
    }

hibernate()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::hibernate ( )

inline

Definition at line 428 of file GxEPD2_7C.h.

    {
      epd2.hibernate();
    }

init() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::init ( uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration, bool pulldown_rst_mode, SPIClass & spi, SPISettings spi_settings )

inline

Definition at line 129 of file GxEPD2_7C.h.

    {
      epd2.selectSPI(spi, spi_settings);
      epd2.init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
      _using_partial_mode = false;
      _current_page = 0;
      setFullWindow();
    }

init() [2/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::init ( uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 20, bool pulldown_rst_mode = false )

inline

Definition at line 118 of file GxEPD2_7C.h.

    {
      epd2.init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
      _using_partial_mode = false;
      _current_page = 0;
      setFullWindow();
    }

init() [3/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::init ( uint32_t serial_diag_bitrate = 0 )

inline

Definition at line 105 of file GxEPD2_7C.h.

    {
      epd2.init(serial_diag_bitrate);
      _using_partial_mode = false;
      _current_page = 0;
      setFullWindow();
    }

mirror()

template<typename GxEPD2_Type , const uint16_t page_height>

bool GxEPD2_7C< GxEPD2_Type, page_height >::mirror ( bool m )

inline

Definition at line 64 of file GxEPD2_7C.h.

    {
      _swap_ (_mirror, m);
      return m;
    }

nextPage()

template<typename GxEPD2_Type , const uint16_t page_height>

bool GxEPD2_7C< GxEPD2_Type, page_height >::nextPage ( )

inline

Definition at line 210 of file GxEPD2_7C.h.

    {
      uint16_t page_ys = _current_page * _page_height;
      if (_using_partial_mode)
      {
        //Serial.print("  nextPage("); Serial.print(_pw_x); Serial.print(", "); Serial.print(_pw_y); Serial.print(", ");
        //Serial.print(_pw_w); Serial.print(", "); Serial.print(_pw_h); Serial.print(") P"); Serial.println(_current_page);
        uint16_t page_ye = _current_page < int16_t(_pages - 1) ? page_ys + _page_height : HEIGHT;
        uint16_t dest_ys = _pw_y + page_ys; // transposed
        uint16_t dest_ye = gx_uint16_min(_pw_y + _pw_h, _pw_y + page_ye);
        if (dest_ye > dest_ys)
        {
          //Serial.print("writeImage("); Serial.print(_pw_x); Serial.print(", "); Serial.print(dest_ys); Serial.print(", ");
          //Serial.print(_pw_w); Serial.print(", "); Serial.print(dest_ye - dest_ys); Serial.println(")");
          epd2.writeNative(_pixel_buffer, 0, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
        }
        else
        {
          //Serial.print("writeImage("); Serial.print(_pw_x); Serial.print(", "); Serial.print(dest_ys); Serial.print(", ");
          //Serial.print(_pw_w); Serial.print(", "); Serial.print(dest_ye - dest_ys); Serial.print(") skipped ");
          //Serial.print(dest_ys); Serial.print(".."); Serial.println(dest_ye);
        }
        _current_page++;
        if (_current_page == int16_t(_pages))
        {
          _current_page = 0;
          if (!_second_phase)
          {
            epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
            if (epd2.hasFastPartialUpdate)
            {
              _second_phase = true;
              return true;
            }
          }
          return false;
        }
        fillScreen(GxEPD_WHITE);
        return true;
      }
      else // full update
      {
        epd2.writeNative(_pixel_buffer, 0, 0, page_ys, WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
        _current_page++;
        if (_current_page == int16_t(_pages))
        {
          _current_page = 0;
          if ((epd2.panel == GxEPD2::GDEW0154Z04) && (_pages > 1))
          {
            if (!_second_phase)
            {
              epd2.refresh(false); // full update after first phase
              _second_phase = true;
              fillScreen(GxEPD_WHITE);
              return true;
            }
            else epd2.refresh(true); // partial update after second phase
          } else epd2.refresh(false); // full update after only phase
          epd2.powerOff();
          return false;
        }
        fillScreen(GxEPD_WHITE);
        return true;
      }
    }

pageHeight()

template<typename GxEPD2_Type , const uint16_t page_height>

uint16_t GxEPD2_7C< GxEPD2_Type, page_height >::pageHeight ( )

inline

Definition at line 59 of file GxEPD2_7C.h.

    {
      return _page_height;
    }

pages()

template<typename GxEPD2_Type , const uint16_t page_height>

uint16_t GxEPD2_7C< GxEPD2_Type, page_height >::pages ( )

inline

Definition at line 54 of file GxEPD2_7C.h.

    {
      return _pages;
    }

powerOff()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::powerOff ( )

inline

Definition at line 423 of file GxEPD2_7C.h.

    {
      epd2.powerOff();
    }

refresh() [1/2]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::refresh ( bool partial_update_mode = false )

inline

Definition at line 413 of file GxEPD2_7C.h.

    {
      epd2.refresh(partial_update_mode);
      if (!partial_update_mode) epd2.powerOff();
    }

refresh() [2/2]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::refresh ( int16_t x, int16_t y, int16_t w, int16_t h )

inline

Definition at line 418 of file GxEPD2_7C.h.

    {
      epd2.refresh(x, y, w, h);
    }

setFullWindow()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::setFullWindow ( )

inline

Definition at line 173 of file GxEPD2_7C.h.

    {
      _using_partial_mode = false;
      _pw_x = 0;
      _pw_y = 0;
      _pw_w = WIDTH;
      _pw_h = HEIGHT;
    }

setPartialWindow()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::setPartialWindow ( uint16_t x, uint16_t y, uint16_t w, uint16_t h )

inline

Definition at line 187 of file GxEPD2_7C.h.

    {
      if (!epd2.hasPartialUpdate) return;
      _pw_x = gx_uint16_min(x, width());
      _pw_y = gx_uint16_min(y, height());
      _pw_w = gx_uint16_min(w, width() - _pw_x);
      _pw_h = gx_uint16_min(h, height() - _pw_y);
      _rotate(_pw_x, _pw_y, _pw_w, _pw_h);
      _using_partial_mode = true;
      // make _pw_x, _pw_w multiple of 2
      _pw_w += _pw_x % 2;
      if (_pw_w % 2 > 0) _pw_w += 2 - _pw_w % 2;
      _pw_x -= _pw_x % 2;
    }

writeImage() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeImage ( const uint8_t * black, const uint8_t * color, int16_t x, int16_t y, int16_t w, int16_t h )

inline

Definition at line 361 of file GxEPD2_7C.h.

    {
      epd2.writeImage(black, color, x, y, w, h, false, false, false);
    }

writeImage() [2/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeImage ( const uint8_t * black, const uint8_t * color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm )

inline

Definition at line 357 of file GxEPD2_7C.h.

    {
      epd2.writeImage(black, color, x, y, w, h, invert, mirror_y, pgm);
    }

writeImage() [3/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeImage ( const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false )

inline

Definition at line 348 of file GxEPD2_7C.h.

    {
      epd2.writeImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
    }

writeImagePart() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeImagePart ( const uint8_t * black, const uint8_t * color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h )

inline

Definition at line 370 of file GxEPD2_7C.h.

    {
      epd2.writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, false, false, false);
    }

writeImagePart() [2/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeImagePart ( const uint8_t * black, const uint8_t * color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm )

inline

Definition at line 365 of file GxEPD2_7C.h.

    {
      epd2.writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
    }

writeImagePart() [3/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeImagePart ( const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap, int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false )

inline

Definition at line 352 of file GxEPD2_7C.h.

    {
      epd2.writeImagePart(bitmap, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
    }

writeNative()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeNative ( const uint8_t * data1, const uint8_t * data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm )

inline

Definition at line 376 of file GxEPD2_7C.h.

    {
      epd2.writeNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
    }

writeScreenBuffer()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_7C< GxEPD2_Type, page_height >::writeScreenBuffer ( uint8_t value = 0xFF )

inline

Definition at line 343 of file GxEPD2_7C.h.

    {
      epd2.writeScreenBuffer(value);
    }

Member Data Documentation

epd2

template<typename GxEPD2_Type , const uint16_t page_height>

GxEPD2_Type GxEPD2_7C< GxEPD2_Type, page_height >::epd2

Definition at line 39 of file GxEPD2_7C.h.

---

The documentation for this class was generated from the following file:

• src/drivers/GxEPD2_7C.h