PCB Reflow Hot Plate

/*
 * SSD1306 OLED display library for ATtiny1614
 * based on SSD1306_I2C library
 * by John Bradnam
 */

#pragma once

#include <Wire.h>
#include "fontVSx8.h"

#define SSD1306_SCREEN_WIDTH 128          // OLED display width, in pixels
#define SSD1306_SCREEN_HEIGHT 64          // OLED display height, in pixels


#define SSD1306_BLACK 0   ///< Draw 'off' pixels
#define SSD1306_WHITE 1   ///< Draw 'on' pixels
#define SSD1306_INVERSE 2 ///< Invert pixels

#define SSD1306_MEMORYMODE 0x20          ///< See datasheet
#define SSD1306_COLUMNADDR 0x21          ///< See datasheet
#define SSD1306_PAGEADDR 0x22            ///< See datasheet
#define SSD1306_SETCONTRAST 0x81         ///< See datasheet
#define SSD1306_CHARGEPUMP 0x8D          ///< See datasheet
#define SSD1306_SEGREMAP 0xA0            ///< See datasheet
#define SSD1306_DISPLAYALLON_RESUME 0xA4 ///< See datasheet
#define SSD1306_DISPLAYALLON 0xA5        ///< Not currently used
#define SSD1306_NORMALDISPLAY 0xA6       ///< See datasheet
#define SSD1306_INVERTDISPLAY 0xA7       ///< See datasheet
#define SSD1306_SETMULTIPLEX 0xA8        ///< See datasheet
#define SSD1306_DISPLAYOFF 0xAE          ///< See datasheet
#define SSD1306_DISPLAYON 0xAF           ///< See datasheet
#define SSD1306_COMSCANINC 0xC0          ///< Not currently used
#define SSD1306_COMSCANDEC 0xC8          ///< See datasheet
#define SSD1306_SETDISPLAYOFFSET 0xD3    ///< See datasheet
#define SSD1306_SETDISPLAYCLOCKDIV 0xD5  ///< See datasheet
#define SSD1306_SETPRECHARGE 0xD9        ///< See datasheet
#define SSD1306_SETCOMPINS 0xDA          ///< See datasheet
#define SSD1306_SETVCOMDETECT 0xDB       ///< See datasheet

#define SSD1306_SETLOWCOLUMN 0x00        ///< Not currently used
#define SSD1306_SETHIGHCOLUMN 0x10       ///< Not currently used
#define SSD1306_SETSTARTLINE 0x40        ///< See datasheet
#define SSD1306_DEACTIVATE_SCROLL 0x2E   ///< Stop scroll

#define SSD1306_EXTERNALVCC 0x01         ///< External display voltage source
#define SSD1306_SWITCHCAPVCC 0x02        ///< Gen. display voltage from 3.3V
#define SSD1306_I2CADDR 0x3C

// SOME DEFINES AND STATIC VARIABLES USED INTERNALLY -----------------------

#define WIRE_MAX 32 ///< Use common Arduino core default

#define ssd1306_swap(a, b)                                                     \
  (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b))) ///< No-temp-var swap operation

#define TRANSACTION_START Wire.setClock(400000UL);  //Set before I2C transfer
#define TRANSACTION_END Wire.setClock(100000UL); //Restore after I2C xfer 

// VARIABLES ---------------------------------------------------------------

uint8_t screenBuf[SSD1306_SCREEN_WIDTH * ((SSD1306_SCREEN_HEIGHT + 7) / 8)]; ///Buffer data used for display buffer.
int xPos; // Current plot X position  
int yPos; // Current plot Y position
bool largeDigits = false;

// FUNCTIONS ---------------------------------------------------------------

void ssd1306_command1(uint8_t c);
void ssd1306_commandList(const uint8_t *c, uint8_t n);
void initDisplay(uint8_t vcs);
void drawPixel(int16_t x, int16_t y, uint16_t color);
void clearDisplay(void); 
void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
void drawFastHLineInternal(int16_t x, int16_t y, int16_t w, uint16_t color);
void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
void drawFastVLineInternal(int16_t x, int16_t __y, int16_t __h, uint16_t color);
bool getPixel(int16_t x, int16_t y);
void MoveTo(int x, int y);
void DrawTo(int x, int y);
void DrawCircle(int radius); 
uint8_t ReverseByte(uint8_t x);
int PlotChar(int c, int x, int y);
void PlotText(String s);
void useLargeDigits(bool use);
void refreshDisplay(void);

// LOW-LEVEL UTILS ---------------------------------------------------------

void ssd1306_command1(uint8_t c) 
{
  Wire.beginTransmission(SSD1306_I2CADDR);
  Wire.write((uint8_t)0x00); // Co = 0, D/C = 0
  Wire.write(c);
  Wire.endTransmission();
}

void ssd1306_commandList(const uint8_t *c, uint8_t n) 
{
  Wire.beginTransmission(SSD1306_I2CADDR);
  Wire.write((uint8_t)0x00); // Co = 0, D/C = 0
  uint16_t bytesOut = 1;
  while (n--) {
    if (bytesOut >= WIRE_MAX) {
      Wire.endTransmission();
      Wire.beginTransmission(SSD1306_I2CADDR);
      Wire.write((uint8_t)0x00); // Co = 0, D/C = 0
      bytesOut = 1;
    }
    Wire.write(pgm_read_byte(c++));
    bytesOut++;
  }
  Wire.endTransmission();
}

// ALLOCATE & INIT DISPLAY -------------------------------------------------

/*!
    @param  vcs
            VCC selection. Pass SSD1306_SWITCHCAPVCC to generate the display
            voltage (step up) from the 3.3V source, or SSD1306_EXTERNALVCC
            otherwise. Most situations with Adafruit SSD1306 breakouts will
            want SSD1306_SWITCHCAPVCC.
    @return true on successful allocation/init, false otherwise.
            Well-behaved code should check the return value before
            proceeding.
    @note   MUST call this function before any drawing or updates!
*/
void initDisplay(uint8_t vcs) 
{
  //Create display buffer and clear  
  clearDisplay();

  Wire.begin();

  TRANSACTION_START

  // Init sequence
  static const uint8_t PROGMEM init1[] = {SSD1306_DISPLAYOFF,         // 0xAE
                                          SSD1306_SETDISPLAYCLOCKDIV, // 0xD5
                                          0x80, // the suggested ratio 0x80
                                          SSD1306_SETMULTIPLEX}; // 0xA8
  ssd1306_commandList(init1, sizeof(init1));
  ssd1306_command1(SSD1306_SCREEN_HEIGHT - 1);

  static const uint8_t PROGMEM init2[] = {SSD1306_SETDISPLAYOFFSET, // 0xD3
                                          0x0,                      // no offset
                                          SSD1306_SETSTARTLINE | 0x0, // 0x40 | line #0
                                          SSD1306_CHARGEPUMP};        // 0x8D
  ssd1306_commandList(init2, sizeof(init2));

  ssd1306_command1((vcs == SSD1306_EXTERNALVCC) ? 0x10 : 0x14);

  static const uint8_t PROGMEM init3[] = {SSD1306_MEMORYMODE, // 0x20
                                          0x0, // 0x0 act like ks0108
                                          SSD1306_SEGREMAP | 0x1, // 0xA0 | 0x1
                                          SSD1306_COMSCANDEC}; // 0C8
  ssd1306_commandList(init3, sizeof(init3));

	// (SSD1306_SCREEN_WIDTH == 128) && (SSD1306_SCREEN_HEIGHT == 64))
  ssd1306_command1(SSD1306_SETCOMPINS); // 0xDA
  ssd1306_command1(0x12);
  ssd1306_command1(SSD1306_SETCONTRAST); // 0x81
  ssd1306_command1((vcs == SSD1306_EXTERNALVCC) ? 0x9F : 0xCF);

  ssd1306_command1(SSD1306_SETPRECHARGE); // 0xD9
  ssd1306_command1((vcs == SSD1306_EXTERNALVCC) ? 0x22 : 0xF1);
  static const uint8_t PROGMEM init5[] = {
      SSD1306_SETVCOMDETECT, // 0xDB
      0x40,
      SSD1306_DISPLAYALLON_RESUME, // 0xA4
      SSD1306_NORMALDISPLAY,       // 0xA6
      SSD1306_DEACTIVATE_SCROLL,   // 0x2E
      SSD1306_DISPLAYON};          // 0xAF Main screen turn on
  ssd1306_commandList(init5, sizeof(init5));

  TRANSACTION_END
}

// DRAWING FUNCTIONS -------------------------------------------------------

/*!
    @brief  Set/clear/invert a single pixel. This is also invoked by the
            Adafruit_GFX library in generating many higher-level graphics
            primitives.
    @param  x
            Column of display -- 0 at left to (screen width - 1) at right.
    @param  y
            Row of display -- 0 at top to (screen height -1) at bottom.
    @param  color
            Pixel color, one of: SSD1306_BLACK, SSD1306_WHITE or
            SSD1306_INVERSE.
    @return None (void).
    @note   Changes buffer contents only, no immediate effect on display.
            Follow up with a call to display(), or with other graphics
            commands as needed by one's own application.
*/
void drawPixel(int16_t x, int16_t y, uint16_t color) 
{
  if ((x >= 0) && (x < SSD1306_SCREEN_WIDTH) && (y >= 0) && (y < SSD1306_SCREEN_HEIGHT)) 
  {
    // Pixel is in-bounds. Rotate coordinates if needed.
    /*
    switch (getRotation()) 
    {
      case 1:
        ssd1306_swap(x, y);
        x = SSD1306_SCREEN_WIDTH - x - 1;
        break;
      case 2:
        x = SSD1306_SCREEN_WIDTH - x - 1;
        y = SSD1306_SCREEN_HEIGHT - y - 1;
        break;
      case 3:
        ssd1306_swap(x, y);
        y = SSD1306_SCREEN_HEIGHT - y - 1;
        break;
    }
    */
    switch (color) 
    {
      case SSD1306_WHITE:
        screenBuf[x + (y / 8) * SSD1306_SCREEN_WIDTH] |= (1 << (y & 7));
        break;
      case SSD1306_BLACK:
        screenBuf[x + (y / 8) * SSD1306_SCREEN_WIDTH] &= ~(1 << (y & 7));
        break;
      case SSD1306_INVERSE:
        screenBuf[x + (y / 8) * SSD1306_SCREEN_WIDTH] ^= (1 << (y & 7));
        break;
    }
  }
}

/*!
    @brief  Clear contents of display buffer (set all pixels to off).
    @return None (void).
    @note   Changes buffer contents only, no immediate effect on display.
            Follow up with a call to display(), or with other graphics
            commands as needed by one's own application.
*/
void clearDisplay(void) 
{
  memset(&screenBuf, 0, SSD1306_SCREEN_WIDTH * ((SSD1306_SCREEN_HEIGHT + 7) / 8));
}

/*!
    @brief  Draw a horizontal line. This is also invoked by the Adafruit_GFX
            library in generating many higher-level graphics primitives.
    @param  x
            Leftmost column -- 0 at left to (screen width - 1) at right.
    @param  y
            Row of display -- 0 at top to (screen height -1) at bottom.
    @param  w
            Width of line, in pixels.
    @param  color
            Line color, one of: SSD1306_BLACK, SSD1306_WHITE or SSD1306_INVERSE.
    @return None (void).
    @note   Changes buffer contents only, no immediate effect on display.
            Follow up with a call to display(), or with other graphics
            commands as needed by one's own application.
*/
void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) 
{
  bool bSwap = false;
  /*
  switch (rotation) 
  {
    case 1:
      // 90 degree rotation, swap x & y for rotation, then invert x
      bSwap = true;
      ssd1306_swap(x, y);
      x = SSD1306_SCREEN_WIDTH - x - 1;
      break;
    case 2:
      // 180 degree rotation, invert x and y, then shift y around for height.
      x = SSD1306_SCREEN_WIDTH - x - 1;
      y = SSD1306_SCREEN_HEIGHT - y - 1;
      x -= (w - 1);
      break;
    case 3:
      // 270 degree rotation, swap x & y for rotation,
      // then invert y and adjust y for w (not to become h)
      bSwap = true;
      ssd1306_swap(x, y);
      y = SSD1306_SCREEN_HEIGHT - y - 1;
      y -= (w - 1);
      break;
  }
  */

  if (bSwap)
    drawFastVLineInternal(x, y, w, color);
  else
    drawFastHLineInternal(x, y, w, color);
}

/*!
    @brief  Draw a horizontal line with a width and color. Used by public
   methods drawFastHLine,drawFastVLine
        @param x
                   Leftmost column -- 0 at left to (screen width - 1) at right.
        @param y
                   Row of display -- 0 at top to (screen height -1) at bottom.
        @param w
                   Width of line, in pixels.
        @param color
               Line color, one of: SSD1306_BLACK, SSD1306_WHITE or
   SSD1306_INVERSE.
    @return None (void).
    @note   Changes buffer contents only, no immediate effect on display.
            Follow up with a call to display(), or with other graphics
            commands as needed by one's own application.
*/
void drawFastHLineInternal(int16_t x, int16_t y, int16_t w, uint16_t color) 
{

  if ((y >= 0) && (y < SSD1306_SCREEN_HEIGHT)) { // Y coord in bounds?
    if (x < 0) {                  // Clip left
      w += x;
      x = 0;
    }
    if ((x + w) > SSD1306_SCREEN_WIDTH) { // Clip right
      w = (SSD1306_SCREEN_WIDTH - x);
    }
    if (w > 0) { // Proceed only if width is positive
      uint8_t *pBuf = &screenBuf[(y / 8) * SSD1306_SCREEN_WIDTH + x], mask = 1 << (y & 7);
      switch (color) 
      {
        case SSD1306_WHITE:
          while (w--) {
            *pBuf++ |= mask;
          };
          break;
        case SSD1306_BLACK:
          mask = ~mask;
          while (w--) {
            *pBuf++ &= mask;
          };
          break;
        case SSD1306_INVERSE:
          while (w--) {
            *pBuf++ ^= mask;
          };
          break;
      }
    }
  }
}

/*!
    @brief  Draw a vertical line. This is also invoked by the Adafruit_GFX
            library in generating many higher-level graphics primitives.
    @param  x
            Column of display -- 0 at left to (screen width -1) at right.
    @param  y
            Topmost row -- 0 at top to (screen height - 1) at bottom.
    @param  h
            Height of line, in pixels.
    @param  color
            Line color, one of: SSD1306_BLACK, SSD1306_WHITE or SSD1306_INVERSE.
    @return None (void).
    @note   Changes buffer contents only, no immediate effect on display.
            Follow up with a call to display(), or with other graphics
            commands as needed by one's own application.
*/
void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) 
{
  bool bSwap = false;
  /*
  switch (rotation) 
  {
    case 1:
      // 90 degree rotation, swap x & y for rotation,
      // then invert x and adjust x for h (now to become w)
      bSwap = true;
      ssd1306_swap(x, y);
      x = SSD1306_SCREEN_WIDTH - x - 1;
      x -= (h - 1);
      break;
    case 2:
      // 180 degree rotation, invert x and y, then shift y around for height.
      x = SSD1306_SCREEN_WIDTH - x - 1;
      y = SSD1306_SCREEN_HEIGHT - y - 1;
      y -= (h - 1);
      break;
    case 3:
      // 270 degree rotation, swap x & y for rotation, then invert y
      bSwap = true;
      ssd1306_swap(x, y);
      y = SSD1306_SCREEN_HEIGHT - y - 1;
      break;
  }
  */

  if (bSwap)
    drawFastHLineInternal(x, y, h, color);
  else
    drawFastVLineInternal(x, y, h, color);
}

/*!
    @brief  Draw a vertical line with a width and color. Used by public method
   drawFastHLine,drawFastVLine
        @param x
                   Leftmost column -- 0 at left to (screen width - 1) at right.
        @param __y
                   Row of display -- 0 at top to (screen height -1) at bottom.
        @param __h height of the line in pixels
        @param color
                   Line color, one of: SSD1306_BLACK, SSD1306_WHITE or
   SSD1306_INVERSE.
    @return None (void).
    @note   Changes buffer contents only, no immediate effect on display.
            Follow up with a call to display(), or with other graphics
            commands as needed by one's own application.
*/
void drawFastVLineInternal(int16_t x, int16_t __y, int16_t __h, uint16_t color) 
{

  if ((x >= 0) && (x < SSD1306_SCREEN_WIDTH)) { // X coord in bounds?
    if (__y < 0) {               // Clip top
      __h += __y;
      __y = 0;
    }
    if ((__y + __h) > SSD1306_SCREEN_HEIGHT) { // Clip bottom
      __h = (SSD1306_SCREEN_HEIGHT - __y);
    }
    if (__h > 0) { // Proceed only if height is now positive
      // this display doesn't need ints for coordinates,
      // use local byte registers for faster juggling
      uint8_t y = __y, h = __h;
      uint8_t *pBuf = &screenBuf[(y / 8) * SSD1306_SCREEN_WIDTH + x];

      // do the first partial byte, if necessary - this requires some masking
      uint8_t mod = (y & 7);
      if (mod) {
        // mask off the high n bits we want to set
        mod = 8 - mod;
        // note - lookup table results in a nearly 10% performance
        // improvement in fill* functions
        // uint8_t mask = ~(0xFF >> mod);
        static const uint8_t PROGMEM premask[8] = {0x00, 0x80, 0xC0, 0xE0,
                                                   0xF0, 0xF8, 0xFC, 0xFE};
        uint8_t mask = pgm_read_byte(&premask[mod]);
        // adjust the mask if we're not going to reach the end of this byte
        if (h < mod)
          mask &= (0XFF >> (mod - h));

        switch (color) 
        {
          case SSD1306_WHITE:
            *pBuf |= mask;
            break;
          case SSD1306_BLACK:
            *pBuf &= ~mask;
            break;
          case SSD1306_INVERSE:
            *pBuf ^= mask;
            break;
        }
        pBuf += SSD1306_SCREEN_WIDTH;
      }

      if (h >= mod) { // More to go?
        h -= mod;
        // Write solid bytes while we can - effectively 8 rows at a time
        if (h >= 8) {
          if (color == SSD1306_INVERSE) {
            // separate copy of the code so we don't impact performance of
            // black/white write version with an extra comparison per loop
            do {
              *pBuf ^= 0xFF; // Invert byte
              pBuf += SSD1306_SCREEN_WIDTH; // Advance pointer 8 rows
              h -= 8;        // Subtract 8 rows from height
            } while (h >= 8);
          } else {
            // store a local value to work with
            uint8_t val = (color != SSD1306_BLACK) ? 255 : 0;
            do {
              *pBuf = val;   // Set byte
              pBuf += SSD1306_SCREEN_WIDTH; // Advance pointer 8 rows
              h -= 8;        // Subtract 8 rows from height
            } while (h >= 8);
          }
        }

        if (h) { // Do the final partial byte, if necessary
          mod = h & 7;
          // this time we want to mask the low bits of the byte,
          // vs the high bits we did above
          // uint8_t mask = (1 << mod) - 1;
          // note - lookup table results in a nearly 10% performance
          // improvement in fill* functions
          static const uint8_t PROGMEM postmask[8] = {0x00, 0x01, 0x03, 0x07,
                                                      0x0F, 0x1F, 0x3F, 0x7F};
          uint8_t mask = pgm_read_byte(&postmask[mod]);
          switch (color) 
          {
            case SSD1306_WHITE:
              *pBuf |= mask;
              break;
            case SSD1306_BLACK:
              *pBuf &= ~mask;
              break;
            case SSD1306_INVERSE:
              *pBuf ^= mask;
              break;
          }
        }
      }
    } // endif positive height
  }   // endif x in bounds
}

/*!
    @brief  Return color of a single pixel in display buffer.
    @param  x
            Column of display -- 0 at left to (screen width - 1) at right.
    @param  y
            Row of display -- 0 at top to (screen height -1) at bottom.
    @return true if pixel is set (usually SSD1306_WHITE, unless display invert
   mode is enabled), false if clear (SSD1306_BLACK).
    @note   Reads from buffer contents; may not reflect current contents of
            screen if display() has not been called.
*/
bool getPixel(int16_t x, int16_t y) 
{
  if ((x >= 0) && (x < SSD1306_SCREEN_WIDTH) && (y >= 0) && (y < SSD1306_SCREEN_HEIGHT)) 
  {
    /*
    // Pixel is in-bounds. Rotate coordinates if needed.
    switch (getRotation()) 
    {
      case 1:
        ssd1306_swap(x, y);
        x = SSD1306_SCREEN_WIDTH - x - 1;
        break;
      case 2:
        x = SSD1306_SCREEN_WIDTH - x - 1;
        y = SSD1306_SCREEN_HEIGHT - y - 1;
        break;
      case 3:
        ssd1306_swap(x, y);
        y = SSD1306_SCREEN_HEIGHT - y - 1;
        break;
    }
    */
    return (screenBuf[x + (y / 8) * SSD1306_SCREEN_WIDTH] & (1 << (y & 7)));
  }
  return false; // Pixel out of bounds
}

// Move current plot position to x,y
void MoveTo(int x, int y) 
{
  xPos = x;
  yPos = y;
}

// Draw a line to x,y
void DrawTo(int x, int y) 
{
  int sx, sy, e2, err;
  int dx = abs(x - xPos);
  int dy = abs(y - yPos);
  if (xPos < x) sx = 1; else sx = -1;
  if (yPos < y) sy = 1; else sy = -1;
  err = dx - dy;
  for (;;) {
    drawPixel(xPos, yPos, SSD1306_WHITE);
    if (xPos==x && yPos==y) return;
    e2 = err<<1;
    if (e2 > -dy) { err = err - dy; xPos = xPos + sx; }
    if (e2 < dx) { err = err + dx; yPos = yPos + sy; }
  }
}

void DrawCircle(int radius) 
{
  int x1 = xPos, y1 = yPos, dx = 1, dy = 1;
  int x = radius - 1, y = 0;
  int err = dx - (radius<<1);
  while (x >= y) {
    drawPixel(x1-x, y1+y, SSD1306_WHITE); drawPixel(x1+x, y1+y, SSD1306_WHITE);
    drawPixel(x1-y, y1+x, SSD1306_WHITE); drawPixel(x1+y, y1+x, SSD1306_WHITE);
    drawPixel(x1-y, y1-x, SSD1306_WHITE); drawPixel(x1+y, y1-x, SSD1306_WHITE);
    drawPixel(x1-x, y1-y, SSD1306_WHITE); drawPixel(x1+x, y1-y, SSD1306_WHITE);
    if (err > 0) {
      x = x - 1; dx = dx + 2;
      err = err - (radius<<1) + dx;
    } else {
      y = y + 1; err = err + dy;
      dy = dy + 2;
    }
  }
}

uint8_t ReverseByte(uint8_t x) 
{
  x = ((x >> 1) & 0x55) | ((x << 1) & 0xaa);
  x = ((x >> 2) & 0x33) | ((x << 2) & 0xcc);
  x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0);
  return x;    
}

//Plot character and return width
int PlotChar(int c, int x, int y) 
{
  if (largeDigits && c >= 0x30 && c <= 0x39)
  {
    c = c + 0x26;  //(0x56 - 0x30) or 'V' - '0' gives offset to big numbers
  }
  c = c - 32;
  int cnt = pgm_read_byte(&ssd1306xled_fontVSx8[c][0]);  //Get width of character
  for (int8_t i = 0; i < cnt; i++) { // Char bitmap = 5 columns
    uint8_t line = pgm_read_byte(&ssd1306xled_fontVSx8[c][i+1]);
    for (int8_t j = 0; j < 8; j++, line >>= 1) {
      drawPixel(x + i, y + j, (line & 1) ? SSD1306_WHITE : SSD1306_BLACK);
    }
  }
  return cnt;
}

// Plot text starting at the current plot position
void PlotText(String s) 
{
  int p = 0;
  while (1) {
    char c = s[p++];
    if (c == 0) return;
    xPos += PlotChar(c, xPos, yPos);  //Add width of character to X position
  }
}

void useLargeDigits(bool use)
{
  largeDigits = use;
}

// REFRESH DISPLAY ---------------------------------------------------------

/*!
    @brief  Push data currently in RAM to SSD1306 display.
    @return None (void).
    @note   Drawing operations are not visible until this function is
            called. Call after each graphics command, or after a whole set
            of graphics commands, as best needed by one's own application.
*/
void refreshDisplay(void) 
{
  TRANSACTION_START
  static const uint8_t PROGMEM dlist1[] = {
      SSD1306_PAGEADDR,
      0,                      // Page start address
      0xFF,                   // Page end (not really, but works here)
      SSD1306_COLUMNADDR, 0}; // Column start address
  ssd1306_commandList(dlist1, sizeof(dlist1));
  ssd1306_command1(SSD1306_SCREEN_WIDTH - 1); // Column end address

#if defined(ESP8266)
  // ESP8266 needs a periodic yield() call to avoid watchdog reset.
  // With the limited size of SSD1306 displays, and the fast bitrate
  // being used (1 MHz or more), I think one yield() immediately before
  // a screen write and one immediately after should cover it.  But if
  // not, if this becomes a problem, yields() might be added in the
  // 32-byte transfer condition below.
  yield();
#endif
  uint16_t count = SSD1306_SCREEN_WIDTH * ((SSD1306_SCREEN_HEIGHT + 7) / 8);
  uint8_t *ptr = screenBuf;
  Wire.beginTransmission(SSD1306_I2CADDR);
  Wire.write((uint8_t)0x40);
  uint16_t bytesOut = 1;
  while (count--) {
    if (bytesOut >= WIRE_MAX) {
      Wire.endTransmission();
      Wire.beginTransmission(SSD1306_I2CADDR);
      Wire.write((uint8_t)0x40);
      bytesOut = 1;
    }
    Wire.write(*ptr++);
    bytesOut++;
  }
  Wire.endTransmission();
  TRANSACTION_END
#if defined(ESP8266)
  yield();
#endif
}