Desk Clock Calendar on DS3231MZ + and Arduino with 2 display

// This code will only work on boards with an ATmega328PB chip, for example
// https://amperka.ru/product/iskra-nano-pro-headless
// It uses the 2nd hardware SPI on the pins
// A0-MISO1, A1-SCK1, A6-SS1, A7-MOSI1
#define PE2 2
#define PE3 3

// Initialization of 2 hardware SPI (Master)
void iSPI2Init () {
  DDRE |= (1 << PE2) | (1 << PE3);                //   SS1,MOSI1
  DDRC |= (1 << PC1);                             // ,SCK1  
  PORTE |= (1 << PE2);                            //  "1"   SS
  SPCR1 = (1 << SPE) | (1 << MSTR);               // Enable SPI, Master, set clock rate fck/4 | (1 << SPR0); fck/16
}

void iwriteByte (uint16_t memAddress, uint8_t b) {
  uint8_t HB = memAddress >> 8;
  uint8_t LB = memAddress;
  PORTE &= ~(1 << PE2);                   //  "0"   SS1
  SPDR1 = B00000010;                      //      
  while (!(SPSR1 & (1 << SPIF1))) ;       //   
  SPDR1 = HB;                             //   
  while (!(SPSR1 & (1 << SPIF1))) ;       //   
  SPDR1 = LB;                             //   
  while (!(SPSR1 & (1 << SPIF1))) ;       //   
  SPDR1 = b;                              //    
  while (!(SPSR1 & (1 << SPIF1))) ;       //   
  PORTE |= (1 << PE2);                    //  "1"   SS

}

uint8_t ireadByte  (uint16_t memAddress) {
  uint8_t HB = memAddress >> 8;
  uint8_t LB = memAddress;
  PORTE &= ~(1 << PE2);                   //  "0"   SS1
  SPDR1 = B00000011;                      //      
  while (!(SPSR1 & (1 << SPIF1))) ;       //   
  SPDR1 = HB;                             //   
  while (!(SPSR1 & (1 << SPIF1))) ;       //   
  SPDR1 = LB;                             //   
  while (!(SPSR1 & (1 << SPIF1))) ;       //   
  SPDR1 = 255;                            //     
  while (!(SPSR1 & (1 << SPIF1))) ;       //     
  PORTE |= (1 << PE2);                    //  "1"   SS
  return (SPDR1);                         //    
}

#define BPIN A2
uint8_t AB;
uint8_t ABOld;
uint8_t BT1;
uint8_t BT2;
uint8_t BT3;
uint8_t BT4;
//uint8_t BT5;

uint8_t GetAB() {                                           //   
  static int   count;
  static int   oldKeyValue;                                 //       
  static int   innerKeyValue;
  uint8_t actualKeyValue = (analogRead(BPIN) / 171);        //   
  if (innerKeyValue != actualKeyValue) {                    //     
    count = 0;                                              //      
    innerKeyValue = actualKeyValue;                         //   
  }
  else {
    count += 1;                                             //  
  }
  if ((count >= 10) && (actualKeyValue != oldKeyValue)) {   //   ,    
    oldKeyValue = actualKeyValue;                           //   
  }
  return    oldKeyValue;
}

uint16_t xC = 50; //  
uint16_t yC = 25; //  

uint16_t XC = 0; //   X
uint16_t YC = 0; //   Y

unsigned int f_div(unsigned int x, unsigned int y) {
  unsigned int result;
  result = (x - (x % y)) / y;
  return result;
}

//   
uint8_t wd(uint8_t dd, uint8_t mm, uint8_t yy ) {
  byte a = f_div((14 - mm), 12);
  unsigned int y = yy - a;
  byte m = mm + 12 * a - 2;
  unsigned int y4 = f_div(y, 4);
  byte y100 = f_div(y, 100);
  byte y400 = f_div(y, 400);
  byte x = f_div(31 * m, 12);
  byte wd = (dd + y + y4 - y100 + y400 + x) % 7;  //
  return wd;
}

//     
uint8_t mCOUNT (uint8_t mm, uint16_t yy) {
  //         29
  if (mm == 2) {
    if ( ((yy % 4 == 0) && (yy % 100 != 0)) || (yy % 400 == 0) ) return 29;
  }
  //   
  uint8_t daysmm[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  return daysmm[mm - 1];
}

//  
const char *months[]  = {
  "January",   // 0
  "February",  // 1
  "March",     // 2
  "April",   // 3
  "May",      // 4
  "June",     // 5
  "July",     // 6
  "August",   // 7
  "September", // 8
  "October",  // 9
  "November",   // 10
  "December",  // 11
};

//  
void icalendarPrint (uint8_t dd, uint8_t mm, uint16_t yy) {
  //    6  7  = 42 
  uint8_t virtMon [42];
  //  
  for (int8_t i = 0; i < 42; i++) virtMon[i] = 0;
  //     
  uint8_t virt1wd = 0;
  //  
  uint8_t virtOLDmm = 0;
  //     
  uint8_t virtCurCOUNT = 0;
  //     
  uint8_t virtOldCOUNT = 0;
  //     
  uint8_t virtIndex = 0;
  //      
  virt1wd = wd(1, mm, yy);
  //   
  if (mm == 1) virtOLDmm = 12; else virtOLDmm = mm - 1;
  //      
  virtCurCOUNT = mCOUNT(mm, yy);
  //      
  virtOldCOUNT = mCOUNT(virtOLDmm, yy);
  //    
  virtIndex = 0;
  // 1-   .
  if (virt1wd == 0) {
    //       
    for (int8_t i = 6; i >= 0; i--) {
      virtMon[virtIndex] = virtOldCOUNT - i;
      virtIndex++;
    }
  } else {
    //        
    for (int8_t i = virt1wd - 1; i >= 0; i--) {
      virtMon[virtIndex] = virtOldCOUNT - i;
      virtIndex++;
    }
  }
  //      
  for (int8_t i = 1; i <= virtCurCOUNT; i++) {
    virtMon[virtIndex] = i;
    virtIndex++;
  }
  //    1    
  uint8_t z = virtIndex;
  for (int8_t i = z; i <= 41; i++) {
    virtMon[virtIndex] = i - z + 1;
    virtIndex++;
  }

  //     

  //    
  String S = "";              //   
  S = String(dd) + ' ' + months[mm - 1] + ' ' + String(yy);
  iGrayString (xC, yC, S, &iFont22, 0, 1);

  //    
  uint16_t xc = 0;
  uint16_t yc = 0;
  yc = yc + 25;
  //   
  iGrayString (xC + xc, yC + yc,   "Mo Tu We Th Fr Sa Su" , &iFont22, 0, 1);
  yc = yc + 25;
  //   

  //      
  uint8_t pen = 3;
  uint8_t back = 1;
  uint8_t pbID = 0;

  for (int row = 0; row <= 5; row++) {
    for (int col = 0; col <= 6; col++) {
      uint8_t w = virtMon[col + row * 7];
      S = w;
      
      //   
      if (w == 1) pbID++;   //    1-   
      //   - / 
      if (pbID == 1) pen = 0; else pen = 3;

      //      
      if ((pbID == 1) && (w == dd)) {
        pen = 1;
        back = 3;
        iGrayString(xC + xc, yC + yc, " ", &iFont22, pen, back);
      } else back = 1;

      if (w < 10) xc = xc + 16;

      //  
      iGrayString(xC + xc, yC + yc, S, &iFont22, pen, back);

      if (w < 10) xc = xc + 24; else xc = xc + 40;
    }
    yc = yc + 25;
    xc = 0;
  }
}

#include <Arduino.h>
// Pin definition
#define BUSY_PIN        5
#define RST_PIN         6
#define DC_PIN          9
#define CS_PIN          7

// Display resolution
#define EPD_WIDTH       400
#define EPD_HEIGHT      300
// EPD4IN2 commands
#define PANEL_SETTING                               0x00
#define POWER_SETTING                               0x01
#define POWER_OFF                                   0x02
#define POWER_OFF_SEQUENCE_SETTING                  0x03
#define POWER_ON                                    0x04
#define POWER_ON_MEASURE                            0x05
#define BOOSTER_SOFT_START                          0x06
#define DEEP_SLEEP                                  0x07
#define DATA_START_TRANSMISSION_1                   0x10
#define DATA_STOP                                   0x11
#define DISPLAY_REFRESH                             0x12
#define DATA_START_TRANSMISSION_2                   0x13
#define LUT_FOR_VCOM                                0x20
#define LUT_WHITE_TO_WHITE                          0x21
#define LUT_BLACK_TO_WHITE                          0x22
#define LUT_WHITE_TO_BLACK                          0x23
#define LUT_BLACK_TO_BLACK                          0x24
#define PLL_CONTROL                                 0x30
#define TEMPERATURE_SENSOR_COMMAND                  0x40
#define TEMPERATURE_SENSOR_SELECTION                0x41
#define TEMPERATURE_SENSOR_WRITE                    0x42
#define TEMPERATURE_SENSOR_READ                     0x43
#define VCOM_AND_DATA_INTERVAL_SETTING              0x50
#define LOW_POWER_DETECTION                         0x51
#define TCON_SETTING                                0x60
#define RESOLUTION_SETTING                          0x61
#define GSST_SETTING                                0x65
#define GET_STATUS                                  0x71
#define AUTO_MEASUREMENT_VCOM                       0x80
#define READ_VCOM_VALUE                             0x81
#define VCM_DC_SETTING                              0x82
#define PARTIAL_WINDOW                              0x90
#define PARTIAL_IN                                  0x91
#define PARTIAL_OUT                                 0x92
#define PROGRAM_MODE                                0xA0
#define ACTIVE_PROGRAMMING                          0xA1
#define READ_OTP                                    0xA2
#define POWER_SAVING                                0xE3


extern const unsigned char EPD_4IN2_4Gray_lut_vcom[] =
{
  0x00  , 0x0A , 0x00 , 0x00 , 0x00 , 0x01,
  0x60  , 0x14 , 0x14 , 0x00 , 0x00 , 0x01,
  0x00  , 0x14 , 0x00 , 0x00 , 0x00 , 0x01,
  0x00  , 0x13 , 0x0A , 0x01 , 0x00 , 0x01,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
};
extern const unsigned char EPD_4IN2_4Gray_lut_ww[] =
{
  0x40  , 0x0A , 0x00 , 0x00 , 0x00 , 0x01,
  0x90  , 0x14 , 0x14 , 0x00 , 0x00 , 0x01,
  0x10  , 0x14 , 0x0A , 0x00 , 0x00 , 0x01,
  0xA0  , 0x13 , 0x01 , 0x00 , 0x00 , 0x01,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
};
extern const unsigned char EPD_4IN2_4Gray_lut_bw[] = {
  0x40  , 0x0A , 0x00 , 0x00 , 0x00 , 0x01,
  0x90  , 0x14 , 0x14 , 0x00 , 0x00 , 0x01,
  0x00  , 0x14 , 0x0A , 0x00 , 0x00 , 0x01,
  0x99  , 0x0C , 0x01 , 0x03 , 0x04 , 0x01,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
};

extern const unsigned char EPD_4IN2_4Gray_lut_wb[] = {
  0x40  , 0x0A , 0x00 , 0x00 , 0x00 , 0x01,
  0x90  , 0x14 , 0x14 , 0x00 , 0x00 , 0x01,
  0x00  , 0x14 , 0x0A , 0x00 , 0x00 , 0x01,
  0x99  , 0x0B , 0x04 , 0x04 , 0x01 , 0x01,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
};


extern const unsigned char EPD_4IN2_4Gray_lut_bb[] = {
  0x80  , 0x0A , 0x00 , 0x00 , 0x00 , 0x01,
  0x90  , 0x14 , 0x14 , 0x00 , 0x00 , 0x01,
  0x20  , 0x14 , 0x0A , 0x00 , 0x00 , 0x01,
  0x50  , 0x13 , 0x01 , 0x00 , 0x00 , 0x01,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
  0x00  , 0x00 , 0x00 , 0x00 , 0x00 , 0x00,
};

void DigitalWrite(int pin, int value) {
  digitalWrite(pin, value);
}

int DigitalRead(int pin) {
  return digitalRead(pin);
}

void DelayMs(unsigned int delaytime) {
  delay(delaytime);
}

void SpiTransfer(unsigned char data) {
  digitalWrite(CS_PIN, LOW);
  SPI.transfer(data);
  digitalWrite(CS_PIN, HIGH);
}

void SendCommand(unsigned char command) {
  DigitalWrite(DC_PIN, LOW);
  SpiTransfer(command);
}

void WaitUntilIdle(void) {
  SendCommand(0x71);
  while (DigitalRead(BUSY_PIN) == 0) {     //0: busy, 1: idle
    DelayMs(100);
    SendCommand(0x71);
  }
}

void Reset(void) {
  DigitalWrite(RST_PIN, LOW);
  DelayMs(200);
  DigitalWrite(RST_PIN, HIGH);
  DelayMs(200);
}

void SendData(unsigned char data) {
  DigitalWrite(DC_PIN, HIGH);
  SpiTransfer(data);
}


int iInit_4Gray(void) {
  pinMode(CS_PIN, OUTPUT);
  pinMode(RST_PIN, OUTPUT);
  pinMode(DC_PIN, OUTPUT);
  pinMode(BUSY_PIN, INPUT);
  SPI.begin();
  SPI.beginTransaction(SPISettings(2000000, MSBFIRST, SPI_MODE0));
  Reset();
  SendCommand(0x01);      //POWER SETTING
  SendData (0x03);
  SendData (0x00);       //VGH=20V,VGL=-20V
  SendData (0x2b);    //VDH=15V
  SendData (0x2b);    //VDL=-15V
  SendData (0x13);
  SendCommand(0x06);         //booster soft start
  SendData (0x17);    //A
  SendData (0x17);    //B
  SendData (0x17);    //C
  SendCommand(0x04);
  WaitUntilIdle();
  SendCommand(0x00);      //panel setting
  SendData(0x3f);   //KW-3f   KWR-2F  BWROTP 0f BWOTP 1f
  SendCommand(0x30);      //PLL setting
  SendData (0x3c);        //100hz
  SendCommand(0x61);      //resolution setting
  SendData (0x01);    //400
  SendData (0x90);
  SendData (0x01);    //300
  SendData (0x2c);
  SendCommand(0x82);      //vcom_DC setting
  SendData (0x12);
  SendCommand(0X50);      //VCOM AND DATA INTERVAL SETTING
  SendData(0x97);
}

void set4Gray_lut(void)
{
  unsigned int count;
  {
    SendCommand(0x20);              //vcom
    for (count = 0; count < 42; count++)
    {
      SendData(EPD_4IN2_4Gray_lut_vcom[count]);
    }

    SendCommand(0x21);              //red not use
    for (count = 0; count < 42; count++)
    {
      SendData(EPD_4IN2_4Gray_lut_ww[count]);
    }

    SendCommand(0x22);              //bw r
    for (count = 0; count < 42; count++)
    {
      SendData(EPD_4IN2_4Gray_lut_bw[count]);
    }

    SendCommand(0x23);              //wb w
    for (count = 0; count < 42; count++)
    {
      SendData(EPD_4IN2_4Gray_lut_wb[count]);
    }

    SendCommand(0x24);              //bb b
    for (count = 0; count < 42; count++)
    {
      SendData(EPD_4IN2_4Gray_lut_bb[count]);
    }

    SendCommand(0x25);              //vcom
    for (count = 0; count < 42; count++)
    {
      SendData(EPD_4IN2_4Gray_lut_ww[count]);
    }
  }
}

void iSet_4GrayDisplay()
{
  int x = 0;
  int y = 0;
  int w = 400;
  int l = 300;
  int i, j, k, m;
  int z = 0;
  unsigned char temp1, temp2, temp3;
  /****Color display description****
        white  gray1  gray2  black
    0x10|  01     01     00     00
    0x13|  01     00     01     00
  *********************************/
  SendCommand(0x10);
  z = 0;
  x = x / 8 * 8;
  for (m = 0; m < EPD_HEIGHT; m++)
    for (i = 0; i < EPD_WIDTH / 8; i++)
    {
      if (i >= x / 8 && i < (x + w) / 8 && m >= y && m < y + l) {

        temp3 = 0;
        for (j = 0; j < 2; j++)
        {
          temp1 = ireadByte(z * 2 + j);
          for (k = 0; k < 2; k++)
          {
            temp2 = temp1 & 0xC0 ;
            if (temp2 == 0xC0)
              temp3 |= 0x01;//white
            else if (temp2 == 0x00)
              temp3 |= 0x00;  //black
            else if (temp2 == 0x80)
              temp3 |= 0x01;  //gray1
            else //0x40
              temp3 |= 0x00; //gray2
            temp3 <<= 1;

            temp1 <<= 2;
            temp2 = temp1 & 0xC0 ;
            if (temp2 == 0xC0) //white
              temp3 |= 0x01;
            else if (temp2 == 0x00) //black
              temp3 |= 0x00;
            else if (temp2 == 0x80)
              temp3 |= 0x01; //gray1
            else    //0x40
              temp3 |= 0x00;  //gray2
            if (j != 1 || k != 1)
              temp3 <<= 1;

            temp1 <<= 2;
          }
        }
        z++;
        SendData(temp3);

      } else {
        SendData(0xff);
      }
    }
  // new  data
  SendCommand(0x13);
  z = 0;
  for (m = 0; m < EPD_HEIGHT; m++)
    for (i = 0; i < EPD_WIDTH / 8; i++)
    {
      if (i >= x / 8 && i < (x + w) / 8 && m >= y && m < y + l) {

        temp3 = 0;
        for (j = 0; j < 2; j++)
        {
          temp1 = ireadByte(z * 2 + j);
          for (k = 0; k < 2; k++)
          {
            temp2 = temp1 & 0xC0 ;
            if (temp2 == 0xC0)
              temp3 |= 0x01;//white
            else if (temp2 == 0x00)
              temp3 |= 0x00;  //black
            else if (temp2 == 0x80)
              temp3 |= 0x00;  //gray1
            else //0x40
              temp3 |= 0x01; //gray2
            temp3 <<= 1;

            temp1 <<= 2;
            temp2 = temp1 & 0xC0 ;
            if (temp2 == 0xC0) //white
              temp3 |= 0x01;
            else if (temp2 == 0x00) //black
              temp3 |= 0x00;
            else if (temp2 == 0x80)
              temp3 |= 0x00; //gray1
            else    //0x40
              temp3 |= 0x01;  //gray2
            if (j != 1 || k != 1)
              temp3 <<= 1;

            temp1 <<= 2;
          }
        }
        z++;
        SendData(temp3);
      } else {
        SendData(0xff);
      }
    }
  set4Gray_lut();
  SendCommand(DISPLAY_REFRESH);
  DelayMs(100);
  WaitUntilIdle();
}

void iSleep() {
  SendCommand(VCOM_AND_DATA_INTERVAL_SETTING);
  SendData(0x17);                       //border floating
  SendCommand(VCM_DC_SETTING);          //VCOM to 0V
  SendCommand(PANEL_SETTING);
  DelayMs(100);

  SendCommand(POWER_SETTING);           //VG&VS to 0V fast
  SendData(0x00);
  SendData(0x00);
  SendData(0x00);
  SendData(0x00);
  SendData(0x00);
  DelayMs(100);

  SendCommand(POWER_OFF);          //power off
  WaitUntilIdle();
  SendCommand(DEEP_SLEEP);         //deep sleep
  SendData(0xA5);
}

void iClear_4Gray() {
  for (uint16_t i = 0; i < 30000; i++)
  {
    iwriteByte(i, 255);
  }
}

void iTest_4Gray() {
  uint16_t j = 0;
  uint16_t i = 0;
  for (uint16_t k = 0; k < 300; k++) {
    for (i = 0; i < 96; i = i + 16)  {
      iwriteByte(j + i + 0, B00000000); // 
      iwriteByte(j + i + 1, B00000000);
      iwriteByte(j + i + 2, B00000000);
      iwriteByte(j + i + 3, B00000000);
      iwriteByte(j + i + 4, B01010101); // 
      iwriteByte(j + i + 5, B01010101);
      iwriteByte(j + i + 6, B01010101);
      iwriteByte(j + i + 7, B01010101);
      iwriteByte(j + i + 8, B10101010); // 
      iwriteByte(j + i + 9, B10101010);
      iwriteByte(j + i + 10, B10101010);
      iwriteByte(j + i + 11, B10101010);
      iwriteByte(j + i + 12, B11111111); // 
      iwriteByte(j + i + 13, B11111111);
      iwriteByte(j + i + 14, B11111111);
      iwriteByte(j + i + 15, B11111111);
    }
    iwriteByte(j + i + 0, B00000000); // 
    iwriteByte(j + i + 1, B00000000); //  !
    iwriteByte(j + i + 2, B00000000);
    iwriteByte(j + i + 3, B00000000);
    j = j + 100;
  }
}

#define Bpix 0  //  
#define Wpix 1  //  
#define WGpix 2  //  
#define BGpix 3  //  
// EPD_WIDTH       400
// EPD_HEIGHT      300
// MEM 0....29999

void iGrayAbsolutePixel(uint32_t x, uint32_t y, int colored) {
  if (x < 0 || x >= EPD_WIDTH || y < 0 || y >= EPD_HEIGHT) return;
  //      
  uint16_t memPix = (x + y * EPD_WIDTH) / 4;
  //    
  uint8_t b = ireadByte(memPix);

  if (colored == 0) {
    //   00
    if ((x % 4) == 0) b &= ~ B11000000;
    if ((x % 4) == 1) b &= ~ B00110000;
    if ((x % 4) == 2) b &= ~ B00001100;
    if ((x % 4) == 3) b &= ~ B00000011;
  }

  if (colored == 1) {
    //   11
    if ((x % 4) == 0) b |= B11000000;
    if ((x % 4) == 1) b |= B00110000;
    if ((x % 4) == 2) b |= B00001100;
    if ((x % 4) == 3) b |= B00000011;
  }

  if (colored == 2) {
    //   10
    if ((x % 4) == 0) {
      bitSet(b, 7);
      bitClear(b, 6);
    }
    if ((x % 4) == 1) {
      bitSet(b, 5);
      bitClear(b, 4);
    }
    if ((x % 4) == 2) {
      bitSet(b, 3);
      bitClear(b, 2);
    }
    if ((x % 4) == 3) {
      bitSet(b, 1);
      bitClear(b, 0);
    }

  }

  if (colored == 3) {
    //   01
    if ((x % 4) == 0) {
      bitSet(b, 6);
      bitClear(b, 7);
    }
    if ((x % 4) == 1) {
      bitSet(b, 4);
      bitClear(b, 5);
    }
    if ((x % 4) == 2) {
      bitSet(b, 2);
      bitClear(b, 3);
    }
    if ((x % 4) == 3) {
      bitSet(b, 0);
      bitClear(b, 1);
    }
  }
  iwriteByte(memPix, b);
}

/*
  //       + 
  uint8_t convBIT(uint8_t isx) {
  uint8_t conv = 0;
  bitWrite(conv, 7, bitRead(isx, 0));
  bitWrite(conv, 6, bitRead(isx, 1));
  bitWrite(conv, 5, bitRead(isx, 2));
  bitWrite(conv, 4, bitRead(isx, 3));
  bitWrite(conv, 3, bitRead(isx, 4));
  bitWrite(conv, 2, bitRead(isx, 5));
  bitWrite(conv, 1, bitRead(isx, 6));
  bitWrite(conv, 0, bitRead(isx, 7));
  return ~ conv;
  }
*/

// ,Y, ,  ,  
void iGrayString (uint16_t X, uint16_t Y, String S, iFONT* font, uint8_t fC, uint8_t bC) {

  //      (UTF-8 )  
  uint8_t printChar[50];
  //  
  uint8_t countChar = 0;

  //    UTF-8   
  for (int i = 0; i < S.length(); i++) {
    uint8_t st = S.charAt(i);
    if (st == 208) continue;
    if (st == 209) continue;
    //      
    printChar[countChar] = searchChar(st, font->StartS);
    countChar ++;
  }

  //   W  
  uint16_t W = 0;
  W = countChar * font->XX;
  //      8
  if (W % 8 != 0) W = W / 8 * 8 + 8;

  //      
  uint16_t H = font->YY;

  //      
  uint16_t CountSyB = font->XX;
  if (CountSyB % 8 != 0) CountSyB = CountSyB / 8 * 8 + 8;
  uint8_t TrueWidth = CountSyB;
  CountSyB = CountSyB * font->YY / 8;

  //    y ( H)
  for (int yy = 0; yy < H; yy++) {

    uint16_t xxx = 0;

    for (int k = 0; k < countChar; k++) {       //     

      //  1-    x
      for (int xx = 0; xx < font->XX; xx++) {
        uint8_t p = 0;
        uint8_t ss = 0;
        ss = convBIT(pgm_read_byte(&font->SS[CountSyB * printChar[k] + (xx + yy * TrueWidth) / 8]));
        if (ss & (0x80 >> (xx % 8))) p = bC; else p = fC;
        //  
        iGrayAbsolutePixel(X + xxx + xx, Y + yy+1, p);
        
        //    
        if (yy==0) iGrayAbsolutePixel(X + xxx + xx, Y, bC);
        
        //    
        if (yy==H-1) iGrayAbsolutePixel(X + xxx + xx, Y + font->YY + 1, bC);
              
      }
      xxx = xxx + (font->XX);
      //    (8  )
      if (printChar[k] == 64) xxx = xxx - font->Space; // " "
      if (printChar[k] == 78 - font->StartS) xxx = xxx - font->Space; // "."
      if (printChar[k] == 76 - font->StartS) xxx = xxx - font->Space; // ","
      if (printChar[k] == 90 - font->StartS) xxx = xxx - font->Space; // ":"
      if (printChar[k] == 91 - font->StartS) xxx = xxx - font->Space; // ";"
      if (printChar[k] == 65) xxx = xxx - font->Space; // "!"
    }                                           //      

  }
}




































void iTestAbsolutePixel () {
  for (int y = 0; y < 50; y++) {
    for (int x = 0; x < 400; x++) {
      iGrayAbsolutePixel(x, y , Bpix);
    }
  }
  for (int y = 50; y < 100; y++) {
    for (int x = 0; x < 400; x++) {
      iGrayAbsolutePixel(x, y , BGpix);
    }
  }
  for (int y = 100; y < 150; y++) {
    for (int x = 0; x < 400; x++) {
      iGrayAbsolutePixel(x, y , WGpix);
    }
  }
  for (int y = 150; y < 200; y++) {
    for (int x = 0; x < 400; x++) {
      iGrayAbsolutePixel(x, y , Wpix);
    }
  }
  for (int y = 200; y < 250; y++) {
    for (int x = 0; x < 400; x++) {
      iGrayAbsolutePixel(x, y , BGpix);
    }
  }
  for (int y = 250; y < 300; y++) {
    for (int x = 0; x < 400; x++) {
      iGrayAbsolutePixel(x, y , WGpix);
    }
  }
}

// http://we.easyelectronics.ru/lcd_gfx/oled-sh1106.html
#define VCCSTATE SH1106_SWITCHCAPVCC
#define WIDTH     128
#define HEIGHT     64
#define NUM_PAGE    8    /* number of pages */
#define OLED_DC     9
#define OLED_RST    8
#define OLED_CS    10
#define SPI_MOSI   11    /* connect to the DIN pin of OLED */
#define SPI_SCK    13    /* connect to the CLK pin of OLED */

// SH1106 30000....31023    SH1106
#define SHMem 30000

//    SH1106
const unsigned char IMAGE_SH1106[1024] PROGMEM = {
  0x08, 0x12, 0x40, 0xA1, 0xC7, 0x7B, 0xFF, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x06, 0x1E, 0x36, 0x84, 0x5D, 0x73, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x06, 0x78, 0x31, 0x0C, 0xFB, 0x89, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x05, 0x00, 0x08, 0x0D, 0xFB, 0x95, 0xFF, 0x7E, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x08, 0x7E, 0x30, 0x4D, 0xF7, 0xB7, 0xFF, 0x6C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x40, 0x7F, 0x10, 0x6B, 0xF1, 0xDF, 0xF7, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x0C, 0x37, 0x00, 0x47, 0x2B, 0x9F, 0x7E, 0x67, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x09, 0xB6, 0x00, 0x4E, 0x6F, 0xBF, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x19, 0xF0, 0x60, 0x8C, 0xCD, 0x3F, 0xBD, 0xB7, 0xFF, 0xCF, 0xFF, 0xFF, 0xE7, 0xFF, 0xFF, 0xFF,
  0x03, 0x06, 0x64, 0x0C, 0x1E, 0x3C, 0x3B, 0x7F, 0xFF, 0xC7, 0xFF, 0xFF, 0xE1, 0xFF, 0xFF, 0xFF,
  0x40, 0x89, 0x50, 0x0C, 0x5E, 0x3E, 0x03, 0xEF, 0xFF, 0xCD, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF, 0xFF,
  0x09, 0xC3, 0x10, 0x88, 0xF1, 0xBE, 0x07, 0x3F, 0xF7, 0xBB, 0xFF, 0xFF, 0xE0, 0x3F, 0xFF, 0xFF,
  0x01, 0xC7, 0x39, 0x6C, 0x47, 0x3C, 0x27, 0x3F, 0xFB, 0x7F, 0xFF, 0xFF, 0xC0, 0x1F, 0xFF, 0xFF,
  0x69, 0x66, 0x01, 0x61, 0x1F, 0x61, 0x27, 0x3F, 0xEC, 0x7F, 0xFF, 0xFF, 0xE0, 0x0F, 0xFF, 0xFF,
  0x5B, 0x8E, 0x01, 0x23, 0x0E, 0x4D, 0xE6, 0x7F, 0xED, 0xFF, 0xFF, 0xFF, 0xE0, 0x07, 0xFF, 0xFF,
  0x83, 0x80, 0x01, 0x40, 0x0F, 0x4B, 0x40, 0xE7, 0xE1, 0x3F, 0xFF, 0xFF, 0xF0, 0x07, 0xFF, 0xFF,
  0x07, 0x18, 0x99, 0x06, 0x3F, 0x83, 0x82, 0x00, 0x46, 0x3F, 0xFF, 0xFF, 0xF8, 0x03, 0x0F, 0xFF,
  0x00, 0x12, 0x80, 0x2E, 0x2B, 0x2F, 0x80, 0x3B, 0xEC, 0x73, 0xFF, 0xFF, 0xF8, 0x02, 0x07, 0xFF,
  0x0F, 0x00, 0x18, 0x4C, 0x3C, 0x4D, 0x02, 0xFE, 0x78, 0x77, 0xFF, 0xFF, 0xFC, 0x00, 0x03, 0xFF,
  0x30, 0x48, 0x1C, 0x09, 0x18, 0xCC, 0x0E, 0x7C, 0x60, 0x27, 0xFF, 0xFF, 0xFF, 0x00, 0x03, 0xFF,
  0x23, 0x11, 0x88, 0x1B, 0x30, 0xC8, 0x6F, 0x78, 0xF0, 0x07, 0xFF, 0xFF, 0xFF, 0x00, 0x03, 0xFF,
  0xD2, 0x33, 0x00, 0x87, 0x80, 0x82, 0x0F, 0x1B, 0xB1, 0x3F, 0xFF, 0xFF, 0xFF, 0x80, 0x03, 0xFF,
  0x94, 0x37, 0x08, 0x0E, 0x86, 0x07, 0x8F, 0x12, 0x20, 0x3F, 0xFF, 0xFF, 0xFF, 0x80, 0x03, 0xFF,
  0x84, 0xA0, 0x04, 0x1C, 0x12, 0x0D, 0x9E, 0x62, 0x42, 0x1F, 0xFF, 0xFF, 0xFF, 0x00, 0x67, 0xFF,
  0x81, 0x83, 0x00, 0x3D, 0x00, 0x03, 0x9E, 0xF0, 0x80, 0x9F, 0xFF, 0xFF, 0xFE, 0x00, 0x3F, 0xFF,
  0x03, 0x86, 0x60, 0x38, 0x00, 0x07, 0x8C, 0xF2, 0x0F, 0xDF, 0x7F, 0xFF, 0xFE, 0xE0, 0x3F, 0xFF,
  0x0F, 0x86, 0x48, 0x00, 0x20, 0x0C, 0x1D, 0xE2, 0x0D, 0x9F, 0x2F, 0xFF, 0xFF, 0xE0, 0x3F, 0xFF,
  0x4F, 0x82, 0x00, 0x01, 0x40, 0x10, 0x13, 0xF1, 0x2C, 0x19, 0xFF, 0xFF, 0xFF, 0xE0, 0x3F, 0xFF,
  0x4F, 0x00, 0x2E, 0x00, 0x00, 0x01, 0x83, 0xF8, 0x09, 0x73, 0xFF, 0xFF, 0xFF, 0xE0, 0x1F, 0xFF,
  0x06, 0x10, 0x5E, 0x64, 0x00, 0x0D, 0xC7, 0xE0, 0x01, 0x87, 0xFF, 0xF9, 0xFF, 0xE0, 0x1F, 0xFF,
  0x20, 0x00, 0x7E, 0x20, 0xC3, 0x4D, 0xCF, 0xC8, 0x52, 0x3F, 0xFF, 0xF7, 0xFF, 0xE0, 0x1F, 0xFF,
  0x00, 0x01, 0x38, 0x00, 0xC6, 0x6D, 0xCB, 0x80, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0x90, 0x1F, 0xFF,
  0x00, 0x19, 0x3A, 0x09, 0x96, 0x69, 0xE1, 0x00, 0x80, 0x7F, 0xFF, 0x7F, 0xF7, 0x38, 0x1F, 0xFF,
  0x18, 0x01, 0x68, 0x00, 0x24, 0x68, 0xE0, 0x00, 0x00, 0xE7, 0xFF, 0x77, 0xF7, 0x38, 0x3F, 0xFF,
  0x00, 0x80, 0x68, 0x10, 0x40, 0xC0, 0x06, 0x1C, 0x00, 0xDE, 0xFF, 0xFF, 0xF7, 0x7C, 0x7F, 0xFF,
  0x00, 0x04, 0x40, 0x90, 0x00, 0x01, 0x80, 0x20, 0x00, 0x0E, 0xCE, 0xFE, 0xF7, 0x7F, 0xFF, 0xFF,
  0x00, 0x44, 0x61, 0x10, 0x40, 0x0B, 0xC0, 0x00, 0x38, 0xF4, 0xFF, 0x79, 0xEE, 0x3F, 0xFF, 0xFF,
  0x04, 0x00, 0x44, 0x03, 0x00, 0x08, 0x60, 0x00, 0x7F, 0xF1, 0xBF, 0x7C, 0xCD, 0xF7, 0xFF, 0xFF,
  0x04, 0x00, 0x0E, 0x06, 0x00, 0x09, 0x40, 0x08, 0x99, 0x3F, 0xBA, 0xDD, 0xDB, 0xFF, 0xFF, 0xFF,
  0x04, 0x83, 0x06, 0x0A, 0x00, 0x9B, 0x80, 0x31, 0xD6, 0x37, 0xF0, 0xFA, 0x27, 0xFF, 0xBF, 0xFF,
  0x00, 0x01, 0x10, 0x0C, 0x10, 0x53, 0x40, 0x63, 0xCA, 0x2F, 0x63, 0xD8, 0x0B, 0xFE, 0xFF, 0xFF,
  0x8C, 0x00, 0x10, 0x00, 0x20, 0x43, 0x80, 0xC7, 0x88, 0xFF, 0x5B, 0xC2, 0x1F, 0xFC, 0x1F, 0xFF,
  0x8E, 0x04, 0x04, 0x1C, 0x00, 0xDB, 0x00, 0xE7, 0x00, 0x3B, 0x3C, 0x1A, 0x3F, 0x9C, 0x3F, 0xFF,
  0x44, 0x20, 0x00, 0x80, 0x18, 0x58, 0x10, 0x00, 0xC0, 0xF7, 0x70, 0x04, 0x5F, 0xBE, 0xFF, 0xFF,
  0x60, 0x20, 0x00, 0x80, 0xF8, 0xC0, 0x81, 0x00, 0xC1, 0x33, 0x03, 0x08, 0x7F, 0xF1, 0xFF, 0xFF,
  0x61, 0xC0, 0x02, 0x01, 0xF8, 0x09, 0x00, 0x04, 0x01, 0x08, 0x06, 0x39, 0x7F, 0xE1, 0xFF, 0xFF,
  0x04, 0x84, 0x80, 0x00, 0xA0, 0x82, 0x40, 0x0F, 0x61, 0x08, 0x64, 0x33, 0xFE, 0xC0, 0xFF, 0xF7,
  0x8C, 0x04, 0x08, 0x00, 0xC1, 0x04, 0x03, 0x1D, 0x73, 0x06, 0x70, 0xE2, 0xF9, 0x41, 0xFF, 0xFF,
  0x08, 0x10, 0x66, 0x08, 0x00, 0x18, 0x90, 0x00, 0x1E, 0x5C, 0xE0, 0xCC, 0xF8, 0x03, 0xFF, 0xFF,
  0x06, 0x00, 0xE4, 0x10, 0xD0, 0x38, 0x11, 0x91, 0xBC, 0x79, 0x83, 0x0D, 0x9A, 0x06, 0xFD, 0xFF,
  0x00, 0x41, 0x80, 0x12, 0x80, 0xFA, 0x11, 0x37, 0x02, 0xF8, 0x06, 0x1D, 0x80, 0x0B, 0xBD, 0xFF,
  0x70, 0x00, 0x00, 0x30, 0x80, 0x50, 0x61, 0x24, 0x7E, 0xF0, 0xA0, 0xC8, 0x68, 0x7F, 0xB5, 0xFF,
  0xF8, 0x00, 0x40, 0x06, 0x98, 0xB0, 0x09, 0x20, 0xFE, 0xE0, 0x27, 0xC8, 0xC8, 0x7E, 0x37, 0xFF,
  0x78, 0x80, 0x11, 0x7C, 0x30, 0xC1, 0x9C, 0x0D, 0xEE, 0xE3, 0x03, 0x0D, 0x80, 0x1B, 0xC7, 0x6F,
  0x20, 0xC0, 0x00, 0x00, 0x40, 0x42, 0x3C, 0x11, 0x3C, 0x01, 0x0E, 0x18, 0x00, 0x36, 0x0F, 0xEF,
  0x00, 0xE0, 0x40, 0x44, 0x0E, 0x80, 0x7C, 0x30, 0x7D, 0x06, 0x1E, 0x38, 0x10, 0x00, 0x3F, 0xFF,
  0x80, 0xF0, 0x00, 0x00, 0x1E, 0x04, 0xF8, 0x23, 0xF1, 0xC0, 0x9E, 0x70, 0x68, 0x10, 0x1D, 0x9F,
  0x18, 0xA2, 0x04, 0x03, 0x7C, 0x0C, 0xF0, 0x47, 0xF1, 0x1C, 0x1E, 0x70, 0x00, 0xEE, 0x0F, 0x8F,
  0x06, 0x42, 0x84, 0xC2, 0x62, 0x20, 0x08, 0x40, 0xD3, 0x3C, 0x1E, 0xA0, 0x40, 0xBC, 0x77, 0xFF,
  0x20, 0x08, 0x84, 0x06, 0x06, 0x03, 0x81, 0x01, 0xE5, 0x34, 0x90, 0x01, 0x30, 0xE8, 0xFF, 0xFF,
  0x76, 0x01, 0x12, 0x1E, 0x1C, 0x63, 0x82, 0x5F, 0xCE, 0x39, 0x02, 0x19, 0x80, 0x80, 0xFF, 0xFF,
  0x58, 0x31, 0x00, 0x3E, 0x08, 0xC3, 0x25, 0x9F, 0x3C, 0xB0, 0x20, 0x01, 0x80, 0x21, 0xFE, 0xFF,
  0x01, 0xB8, 0x00, 0xF8, 0xE1, 0x00, 0x49, 0x1C, 0x7D, 0x30, 0x00, 0x11, 0x06, 0xE1, 0xF3, 0xFF,
  0x03, 0xE0, 0x00, 0xF0, 0xF8, 0x60, 0x91, 0x3C, 0x79, 0xA2, 0x00, 0x9C, 0x2C, 0xC3, 0xFF, 0xFF
};

void SPIWrite(uint8_t *buffer, int bufferLength) {
  int i;
  for (i = 0; i < bufferLength; i++) {
    SPI.transfer(buffer[i]);
  }
}

void command(uint8_t cmd) {
  digitalWrite(OLED_DC, LOW);
  SPIWrite(&cmd, 1);
}

void iSH1106_begin()
{
  pinMode(OLED_RST, OUTPUT);
  pinMode(OLED_DC, OUTPUT);
  pinMode(OLED_CS, OUTPUT);
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV128);
  digitalWrite(OLED_CS, LOW);
  digitalWrite(OLED_RST, HIGH);
  delay(10);
  digitalWrite(OLED_RST, LOW);
  delay(10);
  digitalWrite(OLED_RST, HIGH);
  command(0xA8);  //    
  command(0x3F);
  command(127);   // 
  command(0x01);
  command(0xA1);  //     .
  command(0xC0);  //   
  command(0xDA);  //  
  command(0x12);
  command(0xD3);  // Set Display Offset
  command(0x00);
  command(0x40);  // Set Display Start Line 0
  command(0xAF);  // Display ON
  digitalWrite(OLED_CS, HIGH); //!!!!!!!!!!!!!!!!!!!
}

void iSH1106_clear()
{
  for (uint16_t i = 0; i < 1024; i++)
  {
    iwriteByte(SHMem + i, 0);
  }
}

void iSH1106_display(uint8_t* buffer)
{
  uint8_t page;
  uint8_t *pBuf = buffer;

  for (page = 0; page < 8; page++) {
    /* set page address */
    command(0xB0 + page);
    /* set low column address */
    command(0x02);
    /* set high column address */
    command(0x10);
    /* write data */
    digitalWrite(OLED_DC, HIGH);
    SPIWrite(pBuf, WIDTH);
    pBuf += WIDTH;
  }
}


void iSH1106ShowMem () {
  digitalWrite(OLED_CS, LOW);  //   SPI
  uint16_t stepoled_buf = 0;              //    
  for (int8_t page = 7; page > -1; page--) {
    command(0xB0 + page);                 //   
    /* set low column address */
    command(0x02);
    /* set high column address */
    command(0x10);
    digitalWrite(OLED_DC, HIGH);          //    

    for (int j = 0; j < 16; j++) {        // 16  1  
      for (int8_t i = 7; i > -1; i--) {   //   7....0  
        uint8_t data = 0;
        bitWrite(data, 7, bitRead(ireadByte(SHMem + stepoled_buf + 0  +  j), i));
        bitWrite(data, 6, bitRead(ireadByte(SHMem + stepoled_buf + 16 +  j), i));
        bitWrite(data, 5, bitRead(ireadByte(SHMem + stepoled_buf + 32 +  j), i));
        bitWrite(data, 4, bitRead(ireadByte(SHMem + stepoled_buf + 48 +  j), i));
        bitWrite(data, 3, bitRead(ireadByte(SHMem + stepoled_buf + 64 +  j), i));
        bitWrite(data, 2, bitRead(ireadByte(SHMem + stepoled_buf + 80 +  j), i));
        bitWrite(data, 1, bitRead(ireadByte(SHMem + stepoled_buf + 96 +  j), i));
        bitWrite(data, 0, bitRead(ireadByte(SHMem + stepoled_buf + 112 + j), i));
        SPI.transfer(data);               //   
      }
    }
    stepoled_buf = stepoled_buf + 128;
  }
  digitalWrite(OLED_CS, HIGH);  //   SPI
}


void iSH1106_test(){
    for (int i = 0; i < 1024; i++) {
    iwriteByte(i + SHMem, pgm_read_byte(&IMAGE_SH1106[i]));    
  }
}