GxEPD2_BW< GxEPD2_Type, page_height > Class Template Reference

#include <GxEPD2_BW.h>

Inheritance diagram for GxEPD2_BW< GxEPD2_Type, page_height >:

Public Member Functions
	GxEPD2_BW (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	drawGreyPixel (int16_t x, int16_t y, uint8_t grey)
void	init (uint32_t serial_diag_bitrate=0)
void	init (uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration=10, 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	drawGreyPixmap (const uint8_t pixmap[], int16_t depth, int16_t x, int16_t y, int16_t w, int16_t h)
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_BW< GxEPD2_Type, page_height >

Definition at line 82 of file GxEPD2_BW.h.

Constructor & Destructor Documentation

GxEPD2_BW()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 89 of file GxEPD2_BW.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);
      _reverse = (epd2_instance.panel == GxEPD2::GDE0213B1);
      _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_BW< GxEPD2_Type, page_height >::clearScreen ( uint8_t value = 0xFF )

inline

Definition at line 609 of file GxEPD2_BW.h.

    {
      epd2.clearScreen(value);
    }

display()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 241 of file GxEPD2_BW.h.

    {
      if (partial_update_mode) epd2.writeImage(_buffer, 0, 0, WIDTH, _page_height);
      else epd2.writeImageForFullRefresh(_buffer, 0, 0, WIDTH, _page_height);
      epd2.refresh(partial_update_mode);
      if (epd2.hasFastPartialUpdate)
      {
        epd2.writeImageAgain(_buffer, 0, 0, WIDTH, _page_height);
      }
      if (!partial_update_mode) epd2.powerOff();
    }

displayWindow()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 259 of file GxEPD2_BW.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);
      uint16_t y_part = _reverse ? HEIGHT - h - y : y;
      epd2.writeImagePart(_buffer, x, y_part, WIDTH, _page_height, x, y, w, h);
      epd2.refresh(x, y, w, h);
      if (epd2.hasFastPartialUpdate)
      {
        epd2.writeImagePartAgain(_buffer, x, y_part, WIDTH, _page_height, x, y, w, h);
      }
    }

drawGreyPixel()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_BW< GxEPD2_Type, page_height >::drawGreyPixel ( int16_t x, int16_t y, uint8_t grey )

inline

Definition at line 161 of file GxEPD2_BW.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 >= _pw_w) || (y < 0) || (y >= _pw_h)) return;
      // adjust for current page
      y -= _current_page * _page_height;
      // check if in current page
      if ((y < 0) || (y >= _page_height)) return;
      uint16_t i = x / 4 + y * (_pw_w / 4);
      _buffer[i] = (_buffer[i] & (0xFF ^ (3 << 2 * (3 - x % 4))));
      _buffer[i] = (_buffer[i] | ((grey >> 6) << 2 * (3 - x % 4)));
    }

drawGreyPixmap()

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_BW< GxEPD2_Type, page_height >::drawGreyPixmap ( const uint8_t pixmap[], int16_t depth, int16_t x, int16_t y, int16_t w, int16_t h )

inline

Definition at line 514 of file GxEPD2_BW.h.

    {
      switch (depth)
      {
        case 1:
          {
            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(&pixmap[j * byteWidth + i / 8]);
#else
                  byte = pixmap[j * byteWidth + i / 8];
#endif
                }
                uint16_t color = byte & 0x80 ? 0xFFFF : 0x0000;
                drawPixel(x + i, y + j, color);
              }
            }
          }
          break;
        case 2:
          {
            int16_t byteWidth = (w + 3) / 4; // 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 & 3) byte <<= 2;
                else
                {
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
                  byte = pgm_read_byte(&pixmap[j * byteWidth + i / 4]);
#else
                  byte = pixmap[j * byteWidth + i / 4];
#endif
                }
                drawGreyPixel(x + i, y + j, byte & 0xC0);
              }
            }
          }
          break;
        case 4:
          {
            int16_t byteWidth = (w + 1) / 2; // 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 & 1) byte <<= 4;
                else
                {
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
                  byte = pgm_read_byte(&pixmap[j * byteWidth + i / 2]);
#else
                  byte = pixmap[j * byteWidth + i / 2];
#endif
                }
                uint8_t grey = byte & 0xF0;
                if ((grey < 0xF0) && (grey >= 0xA0)) grey = 0x80; // light grey demo limit for 4bpp
                else if ((grey < 0xF0) && (grey > 0x00)) grey = 0x40;  // dark grey
                drawGreyPixel(x + i, y + j, grey);
              }
            }
          }
          break;
        case 8:
          {
            uint8_t byte = 0;
            for (int16_t j = 0; j < h; j++)
            {
              for (int16_t i = 0; i < w; i++ )
              {
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
                byte = pgm_read_byte(&pixmap[j * w + i]);
#else
                byte = pixmap[j * w + i];
#endif
                drawGreyPixel(x + i, y + j, byte);
              }
            }
          }
          break;
      }
    }

drawImage() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_BW< 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 664 of file GxEPD2_BW.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_BW< 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 660 of file GxEPD2_BW.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_BW< 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 651 of file GxEPD2_BW.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_BW< 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 673 of file GxEPD2_BW.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_BW< 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 668 of file GxEPD2_BW.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_BW< 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 655 of file GxEPD2_BW.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_BW< 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 488 of file GxEPD2_BW.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_BW< 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 679 of file GxEPD2_BW.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_BW< GxEPD2_Type, page_height >::drawPaged ( void(* drawCallback )(const void *), const void * pv )

inline

Definition at line 407 of file GxEPD2_BW.h.

    {
      if (1 == _pages)
      {
        fillScreen(GxEPD_WHITE);
        drawCallback(pv);
        if (_using_partial_mode)
        {
          uint32_t offset = _reverse ? (HEIGHT - _pw_h) * _pw_w / 8 : 0;
          epd2.writeImage(_buffer + offset, _pw_x, _pw_y, _pw_w, _pw_h);
          epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
          if (epd2.hasFastPartialUpdate)
          {
            epd2.writeImageAgain(_buffer + offset, _pw_x, _pw_y, _pw_w, _pw_h);
            //epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h); // not needed
          }
        }
        else // full update
        {
          epd2.writeImageForFullRefresh(_buffer, 0, 0, WIDTH, HEIGHT);
          epd2.refresh(false);
          if (epd2.hasFastPartialUpdate)
          {
            epd2.writeImageAgain(_buffer, 0, 0, WIDTH, HEIGHT);
            //epd2.refresh(true); // not needed
            epd2.powerOff();
          }
        }
        return;
      }
      if (_using_partial_mode)
      {
        for (uint16_t phase = 1; phase <= 2; phase++)
        {
          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);
              uint32_t offset = _reverse ? (_page_height - (dest_ye - dest_ys)) * _pw_w / 8 : 0;
              if (phase == 1) epd2.writeImage(_buffer + offset, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
              else epd2.writeImageAgain(_buffer + offset, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
            }
          }
          epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
          if (!epd2.hasFastPartialUpdate) break;
          // else make both controller buffers have equal content
        }
      }
      else // full update
      {
        for (_current_page = 0; _current_page < _pages; _current_page++)
        {
          uint16_t page_ys = _current_page * _page_height;
          fillScreen(GxEPD_WHITE);
          drawCallback(pv);
          epd2.writeImageForFullRefresh(_buffer, 0, page_ys, WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
        }
        epd2.refresh(false); // full update after first phase
        if (epd2.hasFastPartialUpdate)
        {
          // make both controller buffers have equal content
          for (_current_page = 0; _current_page < _pages; _current_page++)
          {
            uint16_t page_ys = _current_page * _page_height;
            fillScreen(GxEPD_WHITE);
            drawCallback(pv);
            epd2.writeImageAgain(_buffer, 0, page_ys, WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
          }
          //epd2.refresh(true); // partial update after second phase // not needed
        }
        epd2.powerOff();
      }
      _current_page = 0;
    }

drawPixel()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 117 of file GxEPD2_BW.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;
      if (_reverse) y = _page_height - y - 1;
      // check if in current page
      if ((y < 0) || (y >= int16_t(_page_height))) return;
      uint16_t i = x / 4 + y * (_pw_w / 4);
      _buffer[i] = (_buffer[i] & (0xFF ^ (3 << 2 * (3 - x % 4))));
      if (color > 0)
      {
        uint8_t brb = 0x03;
        if (color != GxEPD_WHITE)
        {
          uint32_t brightness = (uint32_t(color & 0xF800) + uint32_t((color & 0x07E0) << 5) + uint32_t((color & 0x001F) << 11));
          brb = uint8_t((brightness - 1) / 0xC000ul); // GxEPD_LIGHTGREY is one too high
        }
        _buffer[i] = (_buffer[i] | (brb << 2 * (3 - x % 4)));
      }
    }

fillScreen()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 229 of file GxEPD2_BW.h.

    {
      uint32_t brightness = (uint32_t(color & 0xF800) + uint32_t((color & 0x07E0) << 5) + uint32_t((color & 0x001F) << 11));
      uint8_t brb = uint8_t((brightness - 1) / 0xC000ul); // GxEPD_LIGHTGREY is one too high
      uint8_t data = brb * 0b01010101;
      for (uint16_t x = 0; x < sizeof(_buffer); x++)
      {
        _buffer[x] = data;
      }
    }

firstPage()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 303 of file GxEPD2_BW.h.

    {
      fillScreen(GxEPD_WHITE);
      _current_page = 0;
      _second_phase = false;
    }

hibernate()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 698 of file GxEPD2_BW.h.

    {
      epd2.hibernate();
    }

init() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_BW< 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 220 of file GxEPD2_BW.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_BW< GxEPD2_Type, page_height >::init ( uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 10, bool pulldown_rst_mode = false )

inline

Definition at line 209 of file GxEPD2_BW.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_BW< GxEPD2_Type, page_height >::init ( uint32_t serial_diag_bitrate = 0 )

inline

Definition at line 195 of file GxEPD2_BW.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_BW< GxEPD2_Type, page_height >::mirror ( bool m )

inline

Definition at line 111 of file GxEPD2_BW.h.

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

nextPage()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 310 of file GxEPD2_BW.h.

    {
      if (1 == _pages)
      {
        if (_using_partial_mode)
        {
          uint32_t offset = _reverse ? (HEIGHT - _pw_h) * _pw_w / 8 : 0;
          epd2.writeImage(_buffer + offset, _pw_x, _pw_y, _pw_w, _pw_h);
          epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
          if (epd2.hasFastPartialUpdate)
          {
            epd2.writeImageAgain(_buffer + offset, _pw_x, _pw_y, _pw_w, _pw_h);
            //epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h); // not needed
          }
        }
        else // full update
        {
          epd2.writeImageForFullRefresh(_buffer, 0, 0, WIDTH, HEIGHT);
          epd2.refresh(false);
          if (epd2.hasFastPartialUpdate)
          {
            epd2.writeImageAgain(_buffer, 0, 0, WIDTH, HEIGHT);
            //epd2.refresh(true); // not needed
          }
          epd2.powerOff();
        }
        return false;
      }
      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(")");
          uint32_t offset = _reverse ? (_page_height - (dest_ye - dest_ys)) * _pw_w / 8 : 0;
          if (!_second_phase) epd2.writeImage(_buffer + offset, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
          else epd2.writeImageAgain(_buffer + offset, _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;
              fillScreen(GxEPD_WHITE);
              return true;
            }
          }
          return false;
        }
        fillScreen(GxEPD_WHITE);
        return true;
      }
      else // full update
      {
        if (!_second_phase) epd2.writeImageForFullRefresh(_buffer, 0, page_ys, WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
        else epd2.writeImageAgain(_buffer, 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.hasFastPartialUpdate)
          {
            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_BW< GxEPD2_Type, page_height >::pageHeight ( )

inline

Definition at line 106 of file GxEPD2_BW.h.

    {
      return _page_height;
    }

pages()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 101 of file GxEPD2_BW.h.

    {
      return _pages;
    }

powerOff()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 693 of file GxEPD2_BW.h.

    {
      epd2.powerOff();
    }

refresh() [1/2]

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 683 of file GxEPD2_BW.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_BW< GxEPD2_Type, page_height >::refresh ( int16_t x, int16_t y, int16_t w, int16_t h )

inline

Definition at line 688 of file GxEPD2_BW.h.

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

setFullWindow()

template<typename GxEPD2_Type , const uint16_t page_height>

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

inline

Definition at line 275 of file GxEPD2_BW.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_BW< GxEPD2_Type, page_height >::setPartialWindow ( uint16_t x, uint16_t y, uint16_t w, uint16_t h )

inline

Definition at line 289 of file GxEPD2_BW.h.

    {
      _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 8
      _pw_w += _pw_x % 8;
      if (_pw_w % 8 > 0) _pw_w += 8 - _pw_w % 8;
      _pw_x -= _pw_x % 8;
    }

writeImage() [1/3]

template<typename GxEPD2_Type , const uint16_t page_height>

void GxEPD2_BW< 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 631 of file GxEPD2_BW.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_BW< 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 627 of file GxEPD2_BW.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_BW< 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 618 of file GxEPD2_BW.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_BW< 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 640 of file GxEPD2_BW.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_BW< 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 635 of file GxEPD2_BW.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_BW< 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 622 of file GxEPD2_BW.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_BW< 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 646 of file GxEPD2_BW.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_BW< GxEPD2_Type, page_height >::writeScreenBuffer ( uint8_t value = 0xFF )

inline

Definition at line 613 of file GxEPD2_BW.h.

    {
      epd2.writeScreenBuffer(value);
    }

Member Data Documentation

epd2

template<typename GxEPD2_Type , const uint16_t page_height>

GxEPD2_Type GxEPD2_BW< GxEPD2_Type, page_height >::epd2

Definition at line 85 of file GxEPD2_BW.h.

---

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

• src/drivers/GxEPD2_BW.h