NHD-C0216CZ

/*********************************************
 * NHD-C0216CZ-*
 * Serial 2x16 COG Display With Arduino Mega
 * Voltage Regulator switched for 3.3V
 * 
*********************************************/

unsigned char text1[]={"NEWHAVEN Display"};
unsigned char text2[]={"2x16 LCD Module "};
										// Symbol			-	Ardino Pin
#define   SI    22						// Serial Data		-	22
#define   SCL   23						// Serial Clock		-	23
#define   CS    24						// Chip Select 		-	24
#define   RS    25						// Register Select	-	25
#define   RST   26						// Reset			-	26

void data(unsigned char d){
  digitalWrite( CS, LOW);				// Enable Chip
  for (int i = 0 ; i < 8 ; i++){
    if((d & 0x80)== 0x80)         		// Send MSB First
      digitalWrite(SI, HIGH);
    else
      digitalWrite(SI, LOW);
    d = (d<<1);
    digitalWrite( SCL, LOW);	
    digitalWrite( SCL, HIGH);			// Clock Data In
    digitalWrite( SCL, LOW);
  }
  digitalWrite(CS , HIGH);
}


void command (unsigned char c){
  digitalWrite( CS, LOW);				// Enable Chip
  digitalWrite( RS, LOW);
  for (int i = 0 ; i < 8 ; i++){
    if((c & 0x80)== 0x80)         		// Send MSB
      digitalWrite(SI, HIGH);
    else
      digitalWrite(SI, LOW);
    c = (c<<1);
    digitalWrite( SCL, LOW);
    digitalWrite( SCL, HIGH);			// Clock in Command
    digitalWrite( SCL, LOW);
  }
  digitalWrite(CS , HIGH);
  digitalWrite(RS , HIGH);
}

void init1()
//initialize the LCD
{
 digitalWrite(RST, LOW); 				// RST = 0; //RESET
 delay(2);
 digitalWrite(RST, HIGH); 				// RST = 1; //end reset
 delay(20);
 command(0x30); 						// wake up
 delay(2);
 command(0x30); 						// wake up
 command(0x30); 						// wake up
 command(0x39); 						// function set (8Bit Data, 2 Line Mode, Instruction Table 1)
 command(0x14); 						// 1/5 Bias, 183 HZ Frequency
 command(0x56); 						// Booster On
 command(0x6D); 						// Follower ON, Follower Amplification Ratio 3:1
 command(0x70); 						// Contrast = 100000 32/63
 command(0x0C); 						// Display ON, No cursor, No Blinking
 command(0x06); 						// Dntry mode Set, Increment Address Counter, no shift
 command(0x01); 						// Clear Display
 delay(10);
} 

void cgram(){
  command (0x38);						// CGRAM Write Select
  command (0x40);						// CGRAM Address
  
  data(0x00); //        				   Slot 1
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //

  data(0x00); //        						Slot 2
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //

  data(0x00); //							Slot 3
  data(0x00); //
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //

  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //

  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0x00); //
  data(0x00); //

  data(0x00); // 
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0x00); //

  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0x00); //
  data(0xFF); //XXXXXXXX
  data(0x00); //

  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0xFF); //XXXXXXXX
  data(0x00); //
  data(0x00); //
  data(0x00); //

  command(0x38); // End
}

void disp1(){			// Show Text
  int a;
  for(a = 0; a < 16 ; a++){
    data(text1[a]);
  }
  command(0xC0);
  for(a = 0; a < 16 ; a++){
    data(text2[a]);
  }  
}

void setup() {
  DDRA = 0xFF;  						// Port A set to output
  
  init1(); 								// Initalize
  disp1(); 								// Show Text
  cgram(); 								// Fill CGRAM
  delay(1000);
}

void loop() {
  command(0x01); 						// Clear Display
  delay(2);
  command(0x02); 						// Return Home
  delay(5);
  data(0x00);							// Show CGRAM 0
  data(0x01);							// Show CGRAM 1
  data(0x02);							// Show CGRAM 2
  data(0x03);							// Show CGRAM 3
  data(0x04);							// Show CGRAM 4
  data(0x05);							// Show CGRAM 5
  data(0x06);							// Show CGRAM 6
  data(0x07);							// Show CGRAM 7
  while(1);	// Stop
}

NHD-0216KZW

Direct Link

/*
 Demonstrates the use a 2x16 OLED display.
 The LiquidCrystal library works with all LCD displays that are compatible with the Hitachi HD44780 driver. 
 
 This sketch prints to the OLED and shows the time since last reset
 
  The circuit:
 * OLED RS pin to digital pin 12
 * OLED Enable pin to digital pin 11
 * OLED D4 pin to digital pin 5
 * OLED D5 pin to digital pin 4
 * OLED D6 pin to digital pin 3
 * OLED D7 pin to digital pin 2
 * OLED R/W pin to ground

 */

// include the library code:
#include <LiquidCrystal.h>
#include <Time.h>  
#include <Wire.h>  

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  setTime(15,36,30,14,5,2013);
  lcd.begin(16, 2);
  delay(100);               // wait for 1/10 second
}

void loop() {
  digitalClockDisplay();  
  delay(1000);
}

void digitalClockDisplay(){
  // digital clock display of the time
  lcd.setCursor(2, 0);
  delay(10);               // wait for 1/10 second
  lcd.print(hourFormat12());
  printDigits(minute());
  printDigits(second());
  lcd.print(" ");
  if(isAM()){lcd.print("am");}
  else{lcd.print("pm");}
  
  lcd.setCursor(0, 1);
  printDay();
  printMonth();
  lcd.print(day());
  lcd.print(" ");
  lcd.print(year()); 
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  lcd.print(":");
  if(digits < 10)
    lcd.print('0');
  lcd.print(digits);
}

void printDay(){
  int day;
  day = weekday();
  if(day == 1){lcd.print("Sun, ");}
  if(day == 2){lcd.print("Mon, ");}
  if(day == 3){lcd.print("Tue, ");}
  if(day == 4){lcd.print("Wed, ");}
  if(day == 5){lcd.print("Thu, ");}
  if(day == 6){lcd.print("Fri, ");}
  if(day == 7){lcd.print("Sat, ");}
}

void printMonth(){
  int mon;
  mon = month();
  if(mon == 1){lcd.print("Jan ");}
  if(mon == 2){lcd.print("Feb ");}
  if(mon == 3){lcd.print("Mar ");}
  if(mon == 4){lcd.print("Apr ");}
  if(mon == 5){lcd.print("May ");}
  if(mon == 6){lcd.print("Jun ");}
  if(mon == 7){lcd.print("Jul ");}
  if(mon == 8){lcd.print("Aug ");}
  if(mon == 9){lcd.print("Sep ");}
  if(mon == 10){lcd.print("Oct ");}
  if(mon == 11){lcd.print("Nov ");}
  if(mon == 12){lcd.print("Dec ");}
}

NHD-0216KZW & Parallax PIR Motion Sensor

Direct Link

/*
 Demonstrates the use a 2x16 OLED display.
 The LiquidCrystal library works with all LCD displays that are compatible with the Hitachi HD44780 driver. 
 
 This sketch prints to the OLED and shows the time since last reset
 
  The circuit:
 * OLED RS pin to digital pin 12
 * OLED Enable pin to digital pin 11
 * OLED D4 pin to digital pin 5
 * OLED D5 pin to digital pin 4
 * OLED D6 pin to digital pin 3
 * OLED D7 pin to digital pin 2
 * OLED R/W pin to ground to digital pin 13 (PB5)

 * PIR Sensor Output Pin3 to digital pin
 */

// include the library code:
#include <LiquidCrystal.h>
#include <Time.h>  
#include <Wire.h>  

int PIR = 13;  //PIR sensor connected to digital pin 13
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  setTime(15,36,30,14,5,2013);
  lcd.begin(16, 2);
  delay(100);               // wait for 1/10 second
  pinMode(PIR, INPUT);      // sets the digital pin 13 as input
}

void loop() {
  
  if (digitalRead(13) == HIGH){
    lcd.print("CAUTION  CAUTION"); 
    lcd.setCursor(0, 1);
    lcd.print("TRAFFIC  TRAFFIC");  
    lcd.display();
    delay(200);
    lcd.noDisplay();
    delay(200);
  }
  
  else {
    lcd.clear();
    lcd.setCursor(0, 0);
    delay(10);               // wait for 1/10 second
  }
}

NHD-0216AW Arduino Sketch

Direct Link

//---------------------------------------------------------
/*

NHD_0216AW_XB3.ino

Program for writing to Newhaven Display Slim OLEDs based on US2066 controller.

Pick one up today in the Newhaven Display shop!
------> http://www.newhavendisplay.com/oled-slim-character-oleds-c-119_825.html

This code is written for the Arduino Mega.

Copyright (c) 2015 - Newhaven Display International, Inc.

Newhaven Display invests time and resources providing this open source code,
please support Newhaven Display by purchasing products from Newhaven Display!

*/
//---------------------------------------------------------

#include <SPI.h>
#include <Arduino.h>
#include <Wire.h>
#include <avr\io.h>

#include "NHD_US2066.h"
unsigned char text1[] = {" Please Support "};
unsigned char text2[] = {"  Open-Source   "};
unsigned char text3[] = {"   Hardware &   "};
unsigned char text4[] = {"   Software !!  "};

unsigned char text5[] = {"Newhaven Display"};
unsigned char text6[] = {" 2X16 Character "};
unsigned char text7[] = {"  Slim  Design  "};
unsigned char text8[] = {"----------------"};



void output()
{
	int i;

        command(0x01);
        delay(2);
        for(i=0;i<16;i++){
          data(text1[i]);
        }
        
        command(0xA0);
        for(i=0;i<16;i++){
          data(text2[i]);
        }

        delay(2000);

        command(0x01);
        delay(2);
        for (i=0;i<16;i++){
		data(text3[i]);
        }
	
        command(0xA0);
        for (i=0;i<16;i++){
		data(text4[i]);
        }

        delay(3500);
        
        command(0x01);
        delay(2);
        for(i=0;i<16;i++){
          data(text5[i]);
        }
        
        command(0xA0);
        for(i=0;i<16;i++){
          data(text6[i]);
        }

        delay(2000);

        command(0x01);
        delay(2);
        for (i=0;i<16;i++){
		data(text7[i]);
        }
	
        command(0xA0);
        for (i=0;i<16;i++){
		data(text8[i]);
        }

}

void blocks()
{
	int i;

        command(0x01);
        delay(2);

        for(i=0;i<16;i++){
          data(0x1F);
        }

        command(0xA0);
        for(i=0;i<16;i++){
          data(0x1F);
        }
}

void setup()
{
init_oled();
}

void loop() 
{  
  while(1)
  {
    output();
    //blocks();
    delay(2000);
  }
}

NHD-0216MW Arduino Sketch

Direct Link

//---------------------------------------------------------
/*

NHD_0216MW_XB3.ino

Program for writing to Newhaven Display Slim OLEDs based on US2066 controller.

Pick one up today in the Newhaven Display shop!
------> http://www.newhavendisplay.com/oled-slim-character-oleds-c-119_825.html

This code is written for the Arduino Mega.

Copyright (c) 2015 - Newhaven Display International, Inc.

Newhaven Display invests time and resources providing this open source code,
please support Newhaven Display by purchasing products from Newhaven Display!

*/
//---------------------------------------------------------

#include <SPI.h>
#include <Arduino.h>
#include <Wire.h>
#include <avr\io.h>

#include "NHD_US2066.h"
unsigned char text1[] = {" Please Support "};
unsigned char text2[] = {"  Open-Source   "};
unsigned char text3[] = {"   Hardware &   "};
unsigned char text4[] = {"   Software !!  "};

unsigned char text5[] = {"Newhaven Display"};
unsigned char text6[] = {" 2X16 Character "};
unsigned char text7[] = {"  Slim  Design  "};
unsigned char text8[] = {"----------------"};


void output()
{
	int i;

        command(0x01);
        delay(2);
        for(i=0;i<16;i++){
          data(text1[i]);
        }
        
        command(0xA0);
        for(i=0;i<16;i++){
          data(text2[i]);
        }

        delay(2000);

        command(0x01);
        delay(2);
        for (i=0;i<16;i++){
		data(text3[i]);
        }
	
        command(0xA0);
        for (i=0;i<16;i++){
		data(text4[i]);
        }

        delay(3500);
        
        command(0x01);
        delay(2);
        for(i=0;i<16;i++){
          data(text5[i]);
        }
        
        command(0xA0);
        for(i=0;i<16;i++){
          data(text6[i]);
        }

        delay(2000);

        command(0x01);
        delay(2);
        for (i=0;i<16;i++){
		data(text7[i]);
        }
	
        command(0xA0);
        for (i=0;i<16;i++){
		data(text8[i]);
        }
}

void blocks()
{
	int i;

        command(0x01);
        delay(2);

        for(i=0;i<16;i++){
          data(0x1F);
        }

        command(0xA0);
        for(i=0;i<16;i++){
          data(0x1F);
        }
}

void setup()
{
init_oled();
}

void loop() 
{  
  while(1)
  {
    output();
    //blocks();
    delay(2000);
  }
}

NHD-1.27-12896UGC3

Direct Link

//---------------------------------------------------------
/*
NHD_1_27_12896UGC3_example_uno.ino
Program for writing to Newhaven Display 128x96 Graphic Color OLED with SSD1351 controller.
This code is written for the Arduino Uno R3.

(c)2014 Michael LaVine - Newhaven Display International, LLC. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTD[7..0]

#define   SDI_PIN    1    // SDI (serial mode) signal connected to pin 1
#define   SCL_PIN    0    // SCL (serial mdoe) signal connected to pin 0
#define    RS_PIN    8    // RS signal connected to pin 8
#define    RW_PIN    9    // R/W (6800 mode) signal connected to pin 9
#define    WR_PIN    9    // /WR (8080 mode) signal connected to pin 9
#define     E_PIN   10    // E (6800 mode) signal connected to pin 10
#define    RD_PIN   10    // /RD (8080 mode) signal connected to pin 10
#define   RES_PIN   11    // /RES signal connected to pin 11
#define    CS_PIN   12    // /CS signal connected to pin 12
#define   BS1_PIN   A0    // BS1 signal connected to pin A0
#define   BS0_PIN   A1    // BS0 signal connected to pin A1
#define   LVL_DIR   A2    // DIR (direction control) signal of level shifter IC connected to pin A2
#define   LVL_OEN   A3    // /OE (output enable) signal of level shifter IC connected to pin A3

#define    RED  0x0000FF
#define  GREEN  0x00FF00
#define   BLUE  0xFF0000
#define  WHITE  0xFFFFFF
#define  BLACK  0x000000


/*********************************/
/****** INTERFACE SELECTION ******/
/*********************************/

 const unsigned char interface = 1;    // 0 = 8-bit parallel (6800 mode) interface; 1 = 8-bit parallel (8080 mode) interface; 2 = 4-wire SPI interface
 
/*===============================*/
/*===============================*/
/*===============================*/


/*********************************/
/******** FONT TABLE 5x8 *********/
/************* START *************/
/*********************************/

unsigned char Ascii_1[97][5] = {     // Refer to "Times New Roman" Font Database...
                        //   Basic Characters
    {0x00,0x00,0x00,0x00,0x00},     //   (  0)    - 0x0000 Empty set
    {0x00,0x00,0x4F,0x00,0x00},     //   (  1)  ! - 0x0021 Exclamation Mark
    {0x00,0x07,0x00,0x07,0x00},     //   (  2)  " - 0x0022 Quotation Mark
    {0x14,0x7F,0x14,0x7F,0x14},     //   (  3)  # - 0x0023 Number Sign
    {0x24,0x2A,0x7F,0x2A,0x12},     //   (  4)  $ - 0x0024 Dollar Sign
    {0x23,0x13,0x08,0x64,0x62},     //   (  5)  % - 0x0025 Percent Sign
    {0x36,0x49,0x55,0x22,0x50},     //   (  6)  & - 0x0026 Ampersand
    {0x00,0x05,0x03,0x00,0x00},     //   (  7)  ' - 0x0027 Apostrophe
    {0x00,0x1C,0x22,0x41,0x00},     //   (  8)  ( - 0x0028 Left Parenthesis
    {0x00,0x41,0x22,0x1C,0x00},     //   (  9)  ) - 0x0029 Right Parenthesis
    {0x14,0x08,0x3E,0x08,0x14},     //   ( 10)  * - 0x002A Asterisk
    {0x08,0x08,0x3E,0x08,0x08},     //   ( 11)  + - 0x002B Plus Sign
    {0x00,0x50,0x30,0x00,0x00},     //   ( 12)  , - 0x002C Comma
    {0x08,0x08,0x08,0x08,0x08},     //   ( 13)  - - 0x002D Hyphen-Minus
    {0x00,0x60,0x60,0x00,0x00},     //   ( 14)  . - 0x002E Full Stop
    {0x20,0x10,0x08,0x04,0x02},     //   ( 15)  / - 0x002F Solidus
    {0x3E,0x51,0x49,0x45,0x3E},     //   ( 16)  0 - 0x0030 Digit Zero
    {0x00,0x42,0x7F,0x40,0x00},     //   ( 17)  1 - 0x0031 Digit One
    {0x42,0x61,0x51,0x49,0x46},     //   ( 18)  2 - 0x0032 Digit Two
    {0x21,0x41,0x45,0x4B,0x31},     //   ( 19)  3 - 0x0033 Digit Three
    {0x18,0x14,0x12,0x7F,0x10},     //   ( 20)  4 - 0x0034 Digit Four
    {0x27,0x45,0x45,0x45,0x39},     //   ( 21)  5 - 0x0035 Digit Five
    {0x3C,0x4A,0x49,0x49,0x30},     //   ( 22)  6 - 0x0036 Digit Six
    {0x01,0x71,0x09,0x05,0x03},     //   ( 23)  7 - 0x0037 Digit Seven
    {0x36,0x49,0x49,0x49,0x36},     //   ( 24)  8 - 0x0038 Digit Eight
    {0x06,0x49,0x49,0x29,0x1E},     //   ( 25)  9 - 0x0039 Dight Nine
    {0x00,0x36,0x36,0x00,0x00},     //   ( 26)  : - 0x003A Colon
    {0x00,0x56,0x36,0x00,0x00},     //   ( 27)  ; - 0x003B Semicolon
    {0x08,0x14,0x22,0x41,0x00},     //   ( 28)  < - 0x003C Less-Than Sign
    {0x14,0x14,0x14,0x14,0x14},     //   ( 29)  = - 0x003D Equals Sign
    {0x00,0x41,0x22,0x14,0x08},     //   ( 30)  > - 0x003E Greater-Than Sign
    {0x02,0x01,0x51,0x09,0x06},     //   ( 31)  ? - 0x003F Question Mark
    {0x32,0x49,0x79,0x41,0x3E},     //   ( 32)  @ - 0x0040 Commercial At
    {0x7E,0x11,0x11,0x11,0x7E},     //   ( 33)  A - 0x0041 Latin Capital Letter A
    {0x7F,0x49,0x49,0x49,0x36},     //   ( 34)  B - 0x0042 Latin Capital Letter B
    {0x3E,0x41,0x41,0x41,0x22},     //   ( 35)  C - 0x0043 Latin Capital Letter C
    {0x7F,0x41,0x41,0x22,0x1C},     //   ( 36)  D - 0x0044 Latin Capital Letter D
    {0x7F,0x49,0x49,0x49,0x41},     //   ( 37)  E - 0x0045 Latin Capital Letter E
    {0x7F,0x09,0x09,0x09,0x01},     //   ( 38)  F - 0x0046 Latin Capital Letter F
    {0x3E,0x41,0x49,0x49,0x7A},     //   ( 39)  G - 0x0047 Latin Capital Letter G
    {0x7F,0x08,0x08,0x08,0x7F},     //   ( 40)  H - 0x0048 Latin Capital Letter H
    {0x00,0x41,0x7F,0x41,0x00},     //   ( 41)  I - 0x0049 Latin Capital Letter I
    {0x20,0x40,0x41,0x3F,0x01},     //   ( 42)  J - 0x004A Latin Capital Letter J
    {0x7F,0x08,0x14,0x22,0x41},     //   ( 43)  K - 0x004B Latin Capital Letter K
    {0x7F,0x40,0x40,0x40,0x40},     //   ( 44)  L - 0x004C Latin Capital Letter L
    {0x7F,0x02,0x0C,0x02,0x7F},     //   ( 45)  M - 0x004D Latin Capital Letter M
    {0x7F,0x04,0x08,0x10,0x7F},     //   ( 46)  N - 0x004E Latin Capital Letter N
    {0x3E,0x41,0x41,0x41,0x3E},     //   ( 47)  O - 0x004F Latin Capital Letter O
    {0x7F,0x09,0x09,0x09,0x06},     //   ( 48)  P - 0x0050 Latin Capital Letter P
    {0x3E,0x41,0x51,0x21,0x5E},     //   ( 49)  Q - 0x0051 Latin Capital Letter Q
    {0x7F,0x09,0x19,0x29,0x46},     //   ( 50)  R - 0x0052 Latin Capital Letter R
    {0x46,0x49,0x49,0x49,0x31},     //   ( 51)  S - 0x0053 Latin Capital Letter S
    {0x01,0x01,0x7F,0x01,0x01},     //   ( 52)  T - 0x0054 Latin Capital Letter T
    {0x3F,0x40,0x40,0x40,0x3F},     //   ( 53)  U - 0x0055 Latin Capital Letter U
    {0x1F,0x20,0x40,0x20,0x1F},     //   ( 54)  V - 0x0056 Latin Capital Letter V
    {0x3F,0x40,0x38,0x40,0x3F},     //   ( 55)  W - 0x0057 Latin Capital Letter W
    {0x63,0x14,0x08,0x14,0x63},     //   ( 56)  X - 0x0058 Latin Capital Letter X
    {0x07,0x08,0x70,0x08,0x07},     //   ( 57)  Y - 0x0059 Latin Capital Letter Y
    {0x61,0x51,0x49,0x45,0x43},     //   ( 58)  Z - 0x005A Latin Capital Letter Z
    {0x00,0x7F,0x41,0x41,0x00},     //   ( 59)  [ - 0x005B Left Square Bracket
    {0x02,0x04,0x08,0x10,0x20},     //   ( 60)  \ - 0x005C Reverse Solidus
    {0x00,0x41,0x41,0x7F,0x00},     //   ( 61)  ] - 0x005D Right Square Bracket
    {0x04,0x02,0x01,0x02,0x04},     //   ( 62)  ^ - 0x005E Circumflex Accent
    {0x40,0x40,0x40,0x40,0x40},     //   ( 63)  _ - 0x005F Low Line
    {0x01,0x02,0x04,0x00,0x00},     //   ( 64)  ` - 0x0060 Grave Accent
    {0x20,0x54,0x54,0x54,0x78},     //   ( 65)  a - 0x0061 Latin Small Letter A
    {0x7F,0x48,0x44,0x44,0x38},     //   ( 66)  b - 0x0062 Latin Small Letter B
    {0x38,0x44,0x44,0x44,0x20},     //   ( 67)  c - 0x0063 Latin Small Letter C
    {0x38,0x44,0x44,0x48,0x7F},     //   ( 68)  d - 0x0064 Latin Small Letter D
    {0x38,0x54,0x54,0x54,0x18},     //   ( 69)  e - 0x0065 Latin Small Letter E
    {0x08,0x7E,0x09,0x01,0x02},     //   ( 70)  f - 0x0066 Latin Small Letter F
    {0x06,0x49,0x49,0x49,0x3F},     //   ( 71)  g - 0x0067 Latin Small Letter G
    {0x7F,0x08,0x04,0x04,0x78},     //   ( 72)  h - 0x0068 Latin Small Letter H
    {0x00,0x44,0x7D,0x40,0x00},     //   ( 73)  i - 0x0069 Latin Small Letter I
    {0x20,0x40,0x44,0x3D,0x00},     //   ( 74)  j - 0x006A Latin Small Letter J
    {0x7F,0x10,0x28,0x44,0x00},     //   ( 75)  k - 0x006B Latin Small Letter K
    {0x00,0x41,0x7F,0x40,0x00},     //   ( 76)  l - 0x006C Latin Small Letter L
    {0x7C,0x04,0x18,0x04,0x7C},     //   ( 77)  m - 0x006D Latin Small Letter M
    {0x7C,0x08,0x04,0x04,0x78},     //   ( 78)  n - 0x006E Latin Small Letter N
    {0x38,0x44,0x44,0x44,0x38},     //   ( 79)  o - 0x006F Latin Small Letter O
    {0x7C,0x14,0x14,0x14,0x08},     //   ( 80)  p - 0x0070 Latin Small Letter P
    {0x08,0x14,0x14,0x18,0x7C},     //   ( 81)  q - 0x0071 Latin Small Letter Q
    {0x7C,0x08,0x04,0x04,0x08},     //   ( 82)  r - 0x0072 Latin Small Letter R
    {0x48,0x54,0x54,0x54,0x20},     //   ( 83)  s - 0x0073 Latin Small Letter S
    {0x04,0x3F,0x44,0x40,0x20},     //   ( 84)  t - 0x0074 Latin Small Letter T
    {0x3C,0x40,0x40,0x20,0x7C},     //   ( 85)  u - 0x0075 Latin Small Letter U
    {0x1C,0x20,0x40,0x20,0x1C},     //   ( 86)  v - 0x0076 Latin Small Letter V
    {0x3C,0x40,0x30,0x40,0x3C},     //   ( 87)  w - 0x0077 Latin Small Letter W
    {0x44,0x28,0x10,0x28,0x44},     //   ( 88)  x - 0x0078 Latin Small Letter X
    {0x0C,0x50,0x50,0x50,0x3C},     //   ( 89)  y - 0x0079 Latin Small Letter Y
    {0x44,0x64,0x54,0x4C,0x44},     //   ( 90)  z - 0x007A Latin Small Letter Z
    {0x00,0x08,0x36,0x41,0x00},     //   ( 91)  { - 0x007B Left Curly Bracket
    {0x00,0x00,0x7F,0x00,0x00},     //   ( 92)  | - 0x007C Vertical Line
    {0x00,0x41,0x36,0x08,0x00},     //   ( 93)  } - 0x007D Right Curly Bracket
    {0x02,0x01,0x02,0x04,0x02},     //   ( 94)  ~ - 0x007E Tilde
    {0x08,0x0C,0x0E,0x0C,0x08},     //   ( 95)  upward facing triangle/arrow
    {0x08,0x18,0x38,0x18,0x08},     //   ( 96)  downward facing triangle/arrow
};

/*===============================*/
/*======= FONT TABLE 5x8 ========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******* CUSTOM CHARACTERS *******/
/************* START *************/
/*********************************/

const unsigned char A10pt [] = {	// 'A' (11 pixels wide)
	0x0E, 0x00, //     ###    
	0x0F, 0x00, //     ####   
	0x1B, 0x00, //    ## ##   
	0x1B, 0x00, //    ## ##   
	0x13, 0x80, //    #  ###  
	0x31, 0x80, //   ##   ##  
	0x3F, 0xC0, //   ######## 
	0x7F, 0xC0, //  ######### 
	0x60, 0xC0, //  ##     ## 
	0x60, 0xE0, //  ##     ###
	0xE0, 0xE0, // ###     ###
};
const unsigned char D10pt [] = {	// 'D' (9 pixels wide)
	0xFC, 0x00, // ######   
	0xFF, 0x00, // ######## 
	0xC7, 0x00, // ##   ### 
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC3, 0x80, // ##    ###
	0xC7, 0x00, // ##   ### 
	0xFE, 0x00, // #######  
	0xFC, 0x00, // ######
};
const unsigned char E10pt [] = {	// 'E' (7 pixels wide)
	0xFE, // #######
	0xFE, // #######
	0xC0, // ##     
	0xC0, // ##     
	0xFC, // ###### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char H10pt [] = {	// 'H' (8 pixels wide)
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xFF, // ########
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
};
const unsigned char I10pt [] = {	// 'I' (2 pixels wide)
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
};
const unsigned char L10pt [] = {	// 'L' (7 pixels wide)
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char N10pt [] = {	// 'N' (9 pixels wide)
	0xE1, 0x80, // ###    ##
	0xE1, 0x80, // ###    ##
	0xF1, 0x80, // ####   ##
	0xF9, 0x80, // #####  ##
	0xD9, 0x80, // ## ##  ##
	0xDD, 0x80, // ## ### ##
	0xCD, 0x80, // ##  ## ##
	0xC7, 0x80, // ##   ####
	0xC7, 0x80, // ##   ####
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
};
const unsigned char P10pt [] = {	// 'P' (8 pixels wide)
	0xFC, // ######  
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC7, // ##   ###
	0xFE, // ####### 
	0xF8, // #####   
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##
};
const unsigned char S10pt [] = {	// 'S' (7 pixels wide)
	0x7C, //  ##### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xF0, // ####   
	0x7C, //  ##### 
	0x1E, //    ####
	0x06, //      ##
	0x06, //      ##
	0xFE, // #######
	0xF8, // #####
};
const unsigned char V10pt [] = {	// 'V' (10 pixels wide)
	0xE0, 0xC0, // ###     ##
	0xE1, 0xC0, // ###    ###
	0x61, 0x80, //  ##    ## 
	0x71, 0x80, //  ###   ## 
	0x73, 0x00, //  ###  ##  
	0x33, 0x00, //   ##  ##  
	0x3B, 0x00, //   ### ##  
	0x1E, 0x00, //    ####   
	0x1E, 0x00, //    ####   
	0x1C, 0x00, //    ###    
	0x0C, 0x00, //     ##
};
const unsigned char W10pt [] = {	// 'W' (16 pixels wide)
	0xE1, 0x83, // ###    ##     ##
	0xE1, 0xC7, // ###    ###   ###
	0x63, 0xC6, //  ##   ####   ## 
	0x63, 0xC6, //  ##   ####   ## 
	0x72, 0xC6, //  ###  # ##   ## 
	0x32, 0x6C, //   ##  #  ## ##  
	0x36, 0x6C, //   ## ##  ## ##  
	0x3E, 0x6C, //   #####  ## ##  
	0x1C, 0x28, //    ###    # #   
	0x1C, 0x38, //    ###    ###   
	0x1C, 0x38, //    ###    ###
};
const unsigned char Y10pt [] = {	// 'Y' (8 pixels wide)
	0xE3, // ###   ##
	0x66, //  ##  ## 
	0x66, //  ##  ## 
	0x34, //   ## #  
	0x34, //   ## #  
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##
};

/*===============================*/
/*====== CUSTOM CHARACTERS ======*/
/*============= END =============*/
/*===============================*/


/*********************************/
/********** ICON BITMAP **********/
/************* START *************/
/*********************************/

const unsigned char smiley20x20[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x60, 0xa1, 0xca, 0x2e, 0x84, 0xb7, 0x0c, 0x70, 0xac, 
0x0c, 0x70, 0xae, 0x2f, 0x84, 0xb7, 0x60, 0xa1, 0xca, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0x91, 0xc1, 0x41, 0x9b, 0xc7, 0x61, 0xbf, 0xdd, 0x73, 0xdc, 0xef, 0x80, 0xef, 0xfb, 
0x7f, 0xef, 0xfb, 0x73, 0xdc, 0xef, 0x5f, 0xbf, 0xdd, 0x41, 0x9c, 0xc7, 0x41, 0x92, 0xc1, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x37, 0x95, 0xc5, 0x61, 0xc9, 0xe5, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 
0x7a, 0xf5, 0xfe, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x79, 0xf5, 0xfe, 0x5e, 0xca, 0xe5, 0x36, 0x94, 0xc5, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x3f, 0xa0, 0xcd, 0x65, 0xe0, 0xf3, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 
0x71, 0xf4, 0xfe, 0x70, 0xf3, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 0x64, 0xde, 0xf3, 0x3d, 0xa1, 0xcd, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x34, 0x98, 0xca, 0x5d, 0xde, 0xf4, 0x68, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x2c, 0x8f, 0xa2, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x2c, 0x8f, 0xa2, 0x68, 0xf2, 0xfe, 0x67, 0xf3, 0xfe, 0x67, 0xf2, 0xfe, 0x5b, 0xde, 0xf4, 0x33, 0x98, 0xca, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x22, 0x22, 0x22, 0x41, 0x9b, 0xcd, 0x4f, 0xcb, 0xe9, 0x5f, 0xf1, 0xfe, 0x5e, 0xf1, 0xfe, 0x3d, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xa6, 0xbe, 0xc6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xa6, 0xbe, 0xc6, 0x00, 0x46, 0x5d, 0x3e, 0xb5, 0xc6, 0x5f, 0xf1, 0xfe, 0x5f, 0xf1, 0xfe, 0x4c, 0xcb, 0xe9, 0x40, 0x9b, 0xcd, 0x22, 0x22, 0x22, 
0x00, 0x3e, 0x44, 0x38, 0xa5, 0xd5, 0x56, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfc, 0xf6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x37, 0xb4, 0xc6, 0x55, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xa5, 0xd4, 0x00, 0x3e, 0x44, 
0x60, 0xb0, 0xda, 0x40, 0xc4, 0xe7, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x3f, 0xc4, 0xe8, 0x60, 0xb0, 0xda, 
0x30, 0x9c, 0xd3, 0x3e, 0xdb, 0xf5, 0x44, 0xed, 0xfe, 0x44, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x44, 0xed, 0xfe, 0x43, 0xed, 0xfe, 0x3d, 0xda, 0xf5, 0x2f, 0x9c, 0xd3, 
0x0e, 0x8f, 0xd0, 0x39, 0xe8, 0xfd, 0x3b, 0xec, 0xfe, 0x3e, 0xed, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x3f, 0xed, 0xfe, 0x3a, 0xec, 0xfe, 0x38, 0xe8, 0xfd, 0x0e, 0x8f, 0xd0, 
0x0e, 0x94, 0xd5, 0x30, 0xe7, 0xfe, 0x32, 0xeb, 0xfe, 0x4a, 0xee, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 
0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x64, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 0x4a, 0xee, 0xfe, 0x32, 0xeb, 0xfe, 0x30, 0xe7, 0xfd, 0x0e, 0x94, 0xd4, 
0x30, 0xa6, 0xe0, 0x2a, 0xda, 0xf8, 0x2a, 0xe9, 0xfe, 0x60, 0xf1, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 
0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x60, 0xf1, 0xfe, 0x2a, 0xea, 0xfe, 0x29, 0xda, 0xf8, 0x30, 0xa7, 0xde, 
0x61, 0xbe, 0xea, 0x2c, 0xca, 0xf1, 0x23, 0xe9, 0xfe, 0x7b, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 
0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7b, 0xf4, 0xfe, 0x23, 0xe9, 0xfe, 0x2c, 0xc9, 0xf1, 0x61, 0xbe, 0xe9, 
0x00, 0x3e, 0x44, 0x2e, 0xb9, 0xeb, 0x1b, 0xe8, 0xfe, 0x74, 0xf4, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 
0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x74, 0xf4, 0xfe, 0x1b, 0xe7, 0xfe, 0x2d, 0xba, 0xeb, 0x00, 0x3e, 0x44, 
0x22, 0x22, 0x22, 0x40, 0xb9, 0xec, 0x21, 0xd1, 0xf6, 0x56, 0xf0, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 
0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x57, 0xf0, 0xfe, 0x21, 0xd1, 0xf6, 0x3f, 0xb9, 0xec, 0x22, 0x22, 0x22, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2a, 0xb9, 0xef, 0x24, 0xde, 0xfc, 0x79, 0xf5, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 
0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0x79, 0xf5, 0xfe, 0x24, 0xde, 0xfc, 0x2a, 0xb9, 0xef, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2b, 0xc1, 0xf3, 0x29, 0xdf, 0xfd, 0x74, 0xf4, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 
0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0x74, 0xf4, 0xfe, 0x28, 0xe0, 0xfd, 0x2a, 0xc1, 0xf3, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x28, 0xbf, 0xf3, 0x1a, 0xd4, 0xfa, 0x41, 0xec, 0xfe, 0x74, 0xf4, 0xfe, 0x9e, 0xfa, 0xfe, 0xbb, 0xfe, 0xfe, 
0xbb, 0xfe, 0xfe, 0x9e, 0xfa, 0xfe, 0x74, 0xf4, 0xfe, 0x42, 0xec, 0xfe, 0x19, 0xd3, 0xfa, 0x29, 0xbf, 0xf4, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0xc3, 0xf5, 0x2a, 0xc4, 0xf6, 0x1b, 0xd1, 0xfa, 0x0a, 0xdb, 0xfd, 0x01, 0xe2, 0xfe, 
0x01, 0xe2, 0xfe, 0x0a, 0xdb, 0xfd, 0x1b, 0xd1, 0xfa, 0x29, 0xc5, 0xf7, 0x41, 0xc3, 0xf6, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x62, 0xce, 0xf9, 0x32, 0xbe, 0xf6, 0x10, 0xb3, 0xf5, 
0x10, 0xb3, 0xf5, 0x32, 0xbe, 0xf6, 0x62, 0xce, 0xf9, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/*===============================*/
/*========= ICON BITMAP =========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/****** LOW LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Command_12896RGB(unsigned char c)        // send command to OLED
{  
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((c & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   c = c << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
} 

void OLED_Data_12896RGB(unsigned char d)        // send data to OLED
{ 
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((d & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   d = d << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
}

void OLED_SetColumnAddress_12896RGB(unsigned char x_start, unsigned char x_end)    // set column address start + end
{
   OLED_Command_12896RGB(0x15);
   OLED_Data_12896RGB(x_start);
   OLED_Data_12896RGB(x_end);
}

void OLED_SetRowAddress_12896RGB(unsigned char y_start, unsigned char y_end)    // set row address start + end
{
   OLED_Command_12896RGB(0x75);
   OLED_Data_12896RGB(y_start);
   OLED_Data_12896RGB(y_end);
}

void OLED_WriteMemoryStart_12896RGB(void)    // write to RAM command
{
    OLED_Command_12896RGB(0x5C);
}

void OLED_Pixel_12896RGB(unsigned long color)    // write one pixel of a given color
{
        OLED_Data_12896RGB((color>>16));
        OLED_Data_12896RGB((color>>8));
        OLED_Data_12896RGB(color);
}

void OLED_FillScreen_12896RGB(unsigned long color)    // fill screen with a given color
{
   unsigned int i,j;
   OLED_SetColumnAddress_12896RGB(0x00, 0x7F);
   OLED_SetRowAddress_12896RGB(0x00, 0x5F);
   OLED_WriteMemoryStart_12896RGB();
   for(i=0;i<96;i++)
   {
      for(j=0;j<128;j++)
      {
	 OLED_Pixel_12896RGB(color);
      }
   }
}

/*===============================*/
/*===== LOW LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/***** HIGH LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Text_12896RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=0;i<8;i++)     //each character is 8 px tall
    {
        OLED_SetColumnAddress_12896RGB(x_pos, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<5;count++)    //each character is 5px wide
        {
            if((Ascii_1[letter][count] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
        }
        y_pos++;
        mask = mask >> 1;
   }
}

void OLED_Text2x_12896RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text (2x size)
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=1;i<=16;i++)     // each character is 16 pixels tall
    {
        OLED_SetColumnAddress_12896RGB(x_pos, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<10;count++)    // each character is 10 pixels wide
        {
            if((Ascii_1[letter][(count/2)] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
        }
        y_pos++;
        if((i%2)==0)
        {
          mask = mask >> 1;
        }
   }
}

void OLED_NHDText_12896RGB(unsigned long textColor, unsigned long backgroundColor)    // function to show NEWHAVEN DISPLAY
{
    int i;
    int count;
    unsigned char index = 0;
    unsigned char y_pos = 88;
    unsigned char mask = 0x80;
    
    for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_12896RGB(11, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_12896RGB(25, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character W
    {
        OLED_SetColumnAddress_12896RGB(36, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character H
    {
        OLED_SetColumnAddress_12896RGB(56, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((H10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_12896RGB(68, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character V
    {
        OLED_SetColumnAddress_12896RGB(81, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_12896RGB(95, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_12896RGB(107, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;  
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character D
    {
        OLED_SetColumnAddress_12896RGB(25, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character I
    {
        OLED_SetColumnAddress_12896RGB(39, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((I10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character S
    {
        OLED_SetColumnAddress_12896RGB(46, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((S10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character P
    {
        OLED_SetColumnAddress_12896RGB(57, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((P10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character L
    {
        OLED_SetColumnAddress_12896RGB(69, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((L10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_12896RGB(80, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character Y
    {
        OLED_SetColumnAddress_12896RGB(94, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((Y10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
}

void OLED_Icon_12896RGB(unsigned char x_pos, unsigned char y_pos)    // function to show icon
{
   unsigned int i, j;
   unsigned int height = 20;
   unsigned int width  = 20;
   
   OLED_SetColumnAddress_12896RGB(x_pos, (x_pos+width-1));
   OLED_SetRowAddress_12896RGB(y_pos, (y_pos+height-1));
   OLED_WriteMemoryStart_12896RGB();
   for(j=0;j<(height*width*3);j+=3)
   {
      OLED_Data_12896RGB(smiley20x20[j]>>2);
      OLED_Data_12896RGB(smiley20x20[(j+1)]>>2);
      OLED_Data_12896RGB(smiley20x20[(j+2)]>>2);
   }
}

void OLED_Spectrum_12896RGB(void)                  // function to show color spectrum
{
      unsigned char i, j;
      unsigned char blue, green, red;
      
      OLED_SetColumnAddress_12896RGB(0, 127);
      OLED_SetRowAddress_12896RGB(0, 27);
      OLED_WriteMemoryStart_12896RGB();
      for(i=0;i<128;i++)
      {
        OLED_Pixel_12896RGB(WHITE);
      }
      for(i=0;i<26;i++)
      {
        blue = 0x00;
        green = 0x00;
        red = 0x3F;
        OLED_Pixel_12896RGB(WHITE);
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          green += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          red -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          blue += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          green -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          red += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          blue -= 3;
        }
        OLED_Pixel_12896RGB(WHITE);
      }
      for(i=0;i<128;i++)
      {
        OLED_Pixel_12896RGB(WHITE);
      }
}

/*===============================*/
/*==== HIGH LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******** INITIALIZATION *********/
/************ START **************/
/*********************************/

void OLED_Init_12896RGB(void)      //OLED initialization
{
    digitalWrite(RES_PIN, LOW);
    delay(500);
    digitalWrite(RES_PIN, HIGH);
    delay(500);

    OLED_Command_12896RGB(0xFD);	// Command lock setting
    OLED_Data_12896RGB(0x12);		// unlock
    OLED_Command_12896RGB(0xFD);	// Command lock setting
    OLED_Data_12896RGB(0xB1);		// unlock
    OLED_Command_12896RGB(0xAE);
    OLED_Command_12896RGB(0xB3);	// clock & frequency
    OLED_Data_12896RGB(0xF1);		// clock=Diviser+1 frequency=fh 
    OLED_Command_12896RGB(0xCA);	// Duty
    OLED_Data_12896RGB(0x7F);		// OLED _END+1
    OLED_Command_12896RGB(0xA2);  	// Display offset
    OLED_Data_12896RGB(0x00);
    OLED_Command_12896RGB(0xA1);	// Set display start line
    OLED_Data_12896RGB(0x00);		// 0x00 start line
    OLED_Command_12896RGB(0xA0);	// Set Re-map, color depth
    OLED_Data_12896RGB(0xA0);		// 8-bit 262K
    OLED_Command_12896RGB(0xB5);	// set GPIO
    OLED_Data_12896RGB(0x00);		// disabled
    OLED_Command_12896RGB(0xAB);	// Function Set
    OLED_Data_12896RGB(0x01);		// 8-bit interface, internal VDD regulator
    OLED_Command_12896RGB(0xB4);	// set VSL
    OLED_Data_12896RGB(0xA0);		// external VSL
    OLED_Data_12896RGB(0xB5);
    OLED_Data_12896RGB(0x55);
    OLED_Command_12896RGB(0xC1);	// Set contrast current for A,B,C
    OLED_Data_12896RGB(0x8A);		// Color A
    OLED_Data_12896RGB(0x70);		// Color B
    OLED_Data_12896RGB(0x8A);		// Color C
    OLED_Command_12896RGB(0xC7);	// Set master contrast
    OLED_Data_12896RGB(0x0F);		//	
    OLED_Command_12896RGB(0xB9);	// use linear grayscale LUT
    OLED_Command_12896RGB(0xB1);	// Set pre & dis-charge
    OLED_Data_12896RGB(0x32);		// pre=1h, dis=1h  
    OLED_Command_12896RGB(0xBB);	// Set precharge voltage of color A,B,C
    OLED_Data_12896RGB(0x07);		//
    OLED_Command_12896RGB(0xB2);        // display enhancement
    OLED_Data_12896RGB(0xa4);		
    OLED_Data_12896RGB(0x00);
    OLED_Data_12896RGB(0x00);
    OLED_Command_12896RGB(0xB6);	// precharge period
    OLED_Data_12896RGB(0x01);		
    OLED_Command_12896RGB(0xBE);	// Set VcomH
    OLED_Data_12896RGB(0x07);
    OLED_Command_12896RGB(0xA6);	// Normal display
    OLED_Command_12896RGB(0xAF);	// Display on
}

/*===============================*/
/*======= INITIALIZATION ========*/
/*============= END =============*/
/*===============================*/

void setup()                                       // for Arduino, runs first at power on
{
   pinMode(LVL_OEN, OUTPUT);                       // configure LVL_OEN as output
   digitalWrite(LVL_OEN, LOW);
   pinMode(LVL_DIR, OUTPUT);                       // configure LVL_DIR as output
   digitalWrite(LVL_DIR, HIGH);
   DDRD = 0xFF;                                    // configure PORTD as output
   pinMode(RS_PIN, OUTPUT);                        // configure RS_PIN as output
   pinMode(RES_PIN, OUTPUT);                       // configure RES_PIN as output
   pinMode(CS_PIN, OUTPUT);                        // configure CS_PIN as output
   pinMode(BS0_PIN, OUTPUT);                       // configure BS0_PIN as output
   pinMode(BS1_PIN, OUTPUT);                       // configure BS1_PIN as output
   digitalWrite(CS_PIN, HIGH);                     // set CS_PIN
   switch(interface)
   {
     case 0:
       pinMode(RW_PIN, OUTPUT);                    // configure RW_PIN as output
       pinMode(E_PIN, OUTPUT);                     // configure E_PIN as output
       digitalWrite(BS0_PIN, HIGH);                // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // set BS1_PIN
       digitalWrite(RW_PIN, LOW);                  // reset RW_PIN
       digitalWrite(E_PIN, HIGH);                  // set E_PIN
       break;
     case 1: 
       pinMode(WR_PIN, OUTPUT);                    // configure WR_PIN as output
       pinMode(RD_PIN, OUTPUT);                    // configure RD_PIN as output
       digitalWrite(BS0_PIN, LOW);                 // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // reset BS1_PIN
       digitalWrite(WR_PIN, HIGH);                 // set WR_PIN
       digitalWrite(RD_PIN, HIGH);                 // set RD_PIN
       break;
     case 2:
       pinMode(SDI_PIN, OUTPUT);                   // configure SDI_PIN as output
       pinMode(SCL_PIN, OUTPUT);                   // configure SCL_PIN as output
       PORTD = 0x00;                               // reset SDI_PIN and SCL_PIN, ground DB[5..0] of the display
       digitalWrite(BS0_PIN, LOW);                 // reset BS0_PIN
       digitalWrite(BS1_PIN, LOW);                 // reset BS1_PIN
       digitalWrite(WR_PIN, LOW);                  // reset WR_PIN
       digitalWrite(RD_PIN, LOW);                  // reset RD_PIN
       break;
     default:
       break;
   }
}

void loop()                                        // main loop, runs after "setup()"
{  
   OLED_Init_12896RGB();                           // initialize display
   
   OLED_FillScreen_12896RGB(BLACK);                // fill screen with black
   
   OLED_NHDText_12896RGB(GREEN, BLACK);            // show NEWHAVEN DISPLAY
   
   OLED_Text_12896RGB(10, 41, 40, WHITE, BLACK);   // H
   OLED_Text_12896RGB(17, 41, 69, WHITE, BLACK);   // e
   OLED_Text_12896RGB(24, 41, 76, WHITE, BLACK);   // l
   OLED_Text_12896RGB(31, 41, 76, WHITE, BLACK);   // l
   OLED_Text_12896RGB(38, 41, 79, WHITE, BLACK);   // o
   OLED_Text_12896RGB(45, 41, 0, WHITE, BLACK);    //
      
   OLED_Text_12896RGB(52, 41, 55, WHITE, BLACK);   // W
   OLED_Text_12896RGB(59, 41, 79, WHITE, BLACK);   // o
   OLED_Text_12896RGB(66, 41, 82, WHITE, BLACK);   // r
   OLED_Text_12896RGB(73, 41, 76, WHITE, BLACK);   // l
   OLED_Text_12896RGB(80, 41, 68, WHITE, BLACK);   // d
   OLED_Text_12896RGB(87, 41, 1, WHITE, BLACK);    // !
   
   OLED_Icon_12896RGB(102, 35);                    // show icon
   
   OLED_Spectrum_12896RGB();                       // show color spectrum
   
   while(1);                                       // wait here forever
}

NHD-1.5-128128UGC3

Direct Link

//---------------------------------------------------------
/*
NHD_1_5_128128UGC3_example_uno.ino
Program for writing to Newhaven Display 128x128 Graphic Color OLED with SSD1351 controller.
This code is written for the Arduino Uno R3.

(c)2014 Michael LaVine - Newhaven Display International, LLC. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTD[7..0]

#define   SDI_PIN    1    // SDI (serial mode) signal connected to pin 1
#define   SCL_PIN    0    // SCL (serial mdoe) signal connected to pin 0
#define    RS_PIN    8    // RS signal connected to pin 8
#define    RW_PIN    9    // R/W (6800 mode) signal connected to pin 9
#define    WR_PIN    9    // /WR (8080 mode) signal connected to pin 9
#define     E_PIN   10    // E (6800 mode) signal connected to pin 10
#define    RD_PIN   10    // /RD (8080 mode) signal connected to pin 10
#define   RES_PIN   11    // /RES signal connected to pin 11
#define    CS_PIN   12    // /CS signal connected to pin 12
#define   BS1_PIN   A0    // BS1 signal connected to pin A0
#define   BS0_PIN   A1    // BS0 signal connected to pin A1
#define   LVL_DIR   A2    // DIR (direction control) signal of level shifter IC connected to pin A2
#define   LVL_OEN   A3    // /OE (output enable) signal of level shifter IC connected to pin A3

#define    RED  0x0000FF
#define  GREEN  0x00FF00
#define   BLUE  0xFF0000
#define  WHITE  0xFFFFFF
#define  BLACK  0x000000


/*********************************/
/****** INTERFACE SELECTION ******/
/*********************************/

 const unsigned char interface = 1;    // 0 = 8-bit parallel (6800 mode) interface; 1 = 8-bit parallel (8080 mode) interface; 2 = 4-wire SPI interface
 
/*===============================*/
/*===============================*/
/*===============================*/


/*********************************/
/******** FONT TABLE 5x8 *********/
/************* START *************/
/*********************************/

unsigned char Ascii_1[97][5] = {     // Refer to "Times New Roman" Font Database...
                        //   Basic Characters
    {0x00,0x00,0x00,0x00,0x00},     //   (  0)    - 0x0000 Empty set
    {0x00,0x00,0x4F,0x00,0x00},     //   (  1)  ! - 0x0021 Exclamation Mark
    {0x00,0x07,0x00,0x07,0x00},     //   (  2)  " - 0x0022 Quotation Mark
    {0x14,0x7F,0x14,0x7F,0x14},     //   (  3)  # - 0x0023 Number Sign
    {0x24,0x2A,0x7F,0x2A,0x12},     //   (  4)  $ - 0x0024 Dollar Sign
    {0x23,0x13,0x08,0x64,0x62},     //   (  5)  % - 0x0025 Percent Sign
    {0x36,0x49,0x55,0x22,0x50},     //   (  6)  & - 0x0026 Ampersand
    {0x00,0x05,0x03,0x00,0x00},     //   (  7)  ' - 0x0027 Apostrophe
    {0x00,0x1C,0x22,0x41,0x00},     //   (  8)  ( - 0x0028 Left Parenthesis
    {0x00,0x41,0x22,0x1C,0x00},     //   (  9)  ) - 0x0029 Right Parenthesis
    {0x14,0x08,0x3E,0x08,0x14},     //   ( 10)  * - 0x002A Asterisk
    {0x08,0x08,0x3E,0x08,0x08},     //   ( 11)  + - 0x002B Plus Sign
    {0x00,0x50,0x30,0x00,0x00},     //   ( 12)  , - 0x002C Comma
    {0x08,0x08,0x08,0x08,0x08},     //   ( 13)  - - 0x002D Hyphen-Minus
    {0x00,0x60,0x60,0x00,0x00},     //   ( 14)  . - 0x002E Full Stop
    {0x20,0x10,0x08,0x04,0x02},     //   ( 15)  / - 0x002F Solidus
    {0x3E,0x51,0x49,0x45,0x3E},     //   ( 16)  0 - 0x0030 Digit Zero
    {0x00,0x42,0x7F,0x40,0x00},     //   ( 17)  1 - 0x0031 Digit One
    {0x42,0x61,0x51,0x49,0x46},     //   ( 18)  2 - 0x0032 Digit Two
    {0x21,0x41,0x45,0x4B,0x31},     //   ( 19)  3 - 0x0033 Digit Three
    {0x18,0x14,0x12,0x7F,0x10},     //   ( 20)  4 - 0x0034 Digit Four
    {0x27,0x45,0x45,0x45,0x39},     //   ( 21)  5 - 0x0035 Digit Five
    {0x3C,0x4A,0x49,0x49,0x30},     //   ( 22)  6 - 0x0036 Digit Six
    {0x01,0x71,0x09,0x05,0x03},     //   ( 23)  7 - 0x0037 Digit Seven
    {0x36,0x49,0x49,0x49,0x36},     //   ( 24)  8 - 0x0038 Digit Eight
    {0x06,0x49,0x49,0x29,0x1E},     //   ( 25)  9 - 0x0039 Dight Nine
    {0x00,0x36,0x36,0x00,0x00},     //   ( 26)  : - 0x003A Colon
    {0x00,0x56,0x36,0x00,0x00},     //   ( 27)  ; - 0x003B Semicolon
    {0x08,0x14,0x22,0x41,0x00},     //   ( 28)  < - 0x003C Less-Than Sign
    {0x14,0x14,0x14,0x14,0x14},     //   ( 29)  = - 0x003D Equals Sign
    {0x00,0x41,0x22,0x14,0x08},     //   ( 30)  > - 0x003E Greater-Than Sign
    {0x02,0x01,0x51,0x09,0x06},     //   ( 31)  ? - 0x003F Question Mark
    {0x32,0x49,0x79,0x41,0x3E},     //   ( 32)  @ - 0x0040 Commercial At
    {0x7E,0x11,0x11,0x11,0x7E},     //   ( 33)  A - 0x0041 Latin Capital Letter A
    {0x7F,0x49,0x49,0x49,0x36},     //   ( 34)  B - 0x0042 Latin Capital Letter B
    {0x3E,0x41,0x41,0x41,0x22},     //   ( 35)  C - 0x0043 Latin Capital Letter C
    {0x7F,0x41,0x41,0x22,0x1C},     //   ( 36)  D - 0x0044 Latin Capital Letter D
    {0x7F,0x49,0x49,0x49,0x41},     //   ( 37)  E - 0x0045 Latin Capital Letter E
    {0x7F,0x09,0x09,0x09,0x01},     //   ( 38)  F - 0x0046 Latin Capital Letter F
    {0x3E,0x41,0x49,0x49,0x7A},     //   ( 39)  G - 0x0047 Latin Capital Letter G
    {0x7F,0x08,0x08,0x08,0x7F},     //   ( 40)  H - 0x0048 Latin Capital Letter H
    {0x00,0x41,0x7F,0x41,0x00},     //   ( 41)  I - 0x0049 Latin Capital Letter I
    {0x20,0x40,0x41,0x3F,0x01},     //   ( 42)  J - 0x004A Latin Capital Letter J
    {0x7F,0x08,0x14,0x22,0x41},     //   ( 43)  K - 0x004B Latin Capital Letter K
    {0x7F,0x40,0x40,0x40,0x40},     //   ( 44)  L - 0x004C Latin Capital Letter L
    {0x7F,0x02,0x0C,0x02,0x7F},     //   ( 45)  M - 0x004D Latin Capital Letter M
    {0x7F,0x04,0x08,0x10,0x7F},     //   ( 46)  N - 0x004E Latin Capital Letter N
    {0x3E,0x41,0x41,0x41,0x3E},     //   ( 47)  O - 0x004F Latin Capital Letter O
    {0x7F,0x09,0x09,0x09,0x06},     //   ( 48)  P - 0x0050 Latin Capital Letter P
    {0x3E,0x41,0x51,0x21,0x5E},     //   ( 49)  Q - 0x0051 Latin Capital Letter Q
    {0x7F,0x09,0x19,0x29,0x46},     //   ( 50)  R - 0x0052 Latin Capital Letter R
    {0x46,0x49,0x49,0x49,0x31},     //   ( 51)  S - 0x0053 Latin Capital Letter S
    {0x01,0x01,0x7F,0x01,0x01},     //   ( 52)  T - 0x0054 Latin Capital Letter T
    {0x3F,0x40,0x40,0x40,0x3F},     //   ( 53)  U - 0x0055 Latin Capital Letter U
    {0x1F,0x20,0x40,0x20,0x1F},     //   ( 54)  V - 0x0056 Latin Capital Letter V
    {0x3F,0x40,0x38,0x40,0x3F},     //   ( 55)  W - 0x0057 Latin Capital Letter W
    {0x63,0x14,0x08,0x14,0x63},     //   ( 56)  X - 0x0058 Latin Capital Letter X
    {0x07,0x08,0x70,0x08,0x07},     //   ( 57)  Y - 0x0059 Latin Capital Letter Y
    {0x61,0x51,0x49,0x45,0x43},     //   ( 58)  Z - 0x005A Latin Capital Letter Z
    {0x00,0x7F,0x41,0x41,0x00},     //   ( 59)  [ - 0x005B Left Square Bracket
    {0x02,0x04,0x08,0x10,0x20},     //   ( 60)  \ - 0x005C Reverse Solidus
    {0x00,0x41,0x41,0x7F,0x00},     //   ( 61)  ] - 0x005D Right Square Bracket
    {0x04,0x02,0x01,0x02,0x04},     //   ( 62)  ^ - 0x005E Circumflex Accent
    {0x40,0x40,0x40,0x40,0x40},     //   ( 63)  _ - 0x005F Low Line
    {0x01,0x02,0x04,0x00,0x00},     //   ( 64)  ` - 0x0060 Grave Accent
    {0x20,0x54,0x54,0x54,0x78},     //   ( 65)  a - 0x0061 Latin Small Letter A
    {0x7F,0x48,0x44,0x44,0x38},     //   ( 66)  b - 0x0062 Latin Small Letter B
    {0x38,0x44,0x44,0x44,0x20},     //   ( 67)  c - 0x0063 Latin Small Letter C
    {0x38,0x44,0x44,0x48,0x7F},     //   ( 68)  d - 0x0064 Latin Small Letter D
    {0x38,0x54,0x54,0x54,0x18},     //   ( 69)  e - 0x0065 Latin Small Letter E
    {0x08,0x7E,0x09,0x01,0x02},     //   ( 70)  f - 0x0066 Latin Small Letter F
    {0x06,0x49,0x49,0x49,0x3F},     //   ( 71)  g - 0x0067 Latin Small Letter G
    {0x7F,0x08,0x04,0x04,0x78},     //   ( 72)  h - 0x0068 Latin Small Letter H
    {0x00,0x44,0x7D,0x40,0x00},     //   ( 73)  i - 0x0069 Latin Small Letter I
    {0x20,0x40,0x44,0x3D,0x00},     //   ( 74)  j - 0x006A Latin Small Letter J
    {0x7F,0x10,0x28,0x44,0x00},     //   ( 75)  k - 0x006B Latin Small Letter K
    {0x00,0x41,0x7F,0x40,0x00},     //   ( 76)  l - 0x006C Latin Small Letter L
    {0x7C,0x04,0x18,0x04,0x7C},     //   ( 77)  m - 0x006D Latin Small Letter M
    {0x7C,0x08,0x04,0x04,0x78},     //   ( 78)  n - 0x006E Latin Small Letter N
    {0x38,0x44,0x44,0x44,0x38},     //   ( 79)  o - 0x006F Latin Small Letter O
    {0x7C,0x14,0x14,0x14,0x08},     //   ( 80)  p - 0x0070 Latin Small Letter P
    {0x08,0x14,0x14,0x18,0x7C},     //   ( 81)  q - 0x0071 Latin Small Letter Q
    {0x7C,0x08,0x04,0x04,0x08},     //   ( 82)  r - 0x0072 Latin Small Letter R
    {0x48,0x54,0x54,0x54,0x20},     //   ( 83)  s - 0x0073 Latin Small Letter S
    {0x04,0x3F,0x44,0x40,0x20},     //   ( 84)  t - 0x0074 Latin Small Letter T
    {0x3C,0x40,0x40,0x20,0x7C},     //   ( 85)  u - 0x0075 Latin Small Letter U
    {0x1C,0x20,0x40,0x20,0x1C},     //   ( 86)  v - 0x0076 Latin Small Letter V
    {0x3C,0x40,0x30,0x40,0x3C},     //   ( 87)  w - 0x0077 Latin Small Letter W
    {0x44,0x28,0x10,0x28,0x44},     //   ( 88)  x - 0x0078 Latin Small Letter X
    {0x0C,0x50,0x50,0x50,0x3C},     //   ( 89)  y - 0x0079 Latin Small Letter Y
    {0x44,0x64,0x54,0x4C,0x44},     //   ( 90)  z - 0x007A Latin Small Letter Z
    {0x00,0x08,0x36,0x41,0x00},     //   ( 91)  { - 0x007B Left Curly Bracket
    {0x00,0x00,0x7F,0x00,0x00},     //   ( 92)  | - 0x007C Vertical Line
    {0x00,0x41,0x36,0x08,0x00},     //   ( 93)  } - 0x007D Right Curly Bracket
    {0x02,0x01,0x02,0x04,0x02},     //   ( 94)  ~ - 0x007E Tilde
    {0x08,0x0C,0x0E,0x0C,0x08},     //   ( 95)  upward facing triangle/arrow
    {0x08,0x18,0x38,0x18,0x08},     //   ( 96)  downward facing triangle/arrow
};

/*===============================*/
/*======= FONT TABLE 5x8 ========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******* CUSTOM CHARACTERS *******/
/************* START *************/
/*********************************/

const unsigned char A10pt [] = {	// 'A' (11 pixels wide)
	0x0E, 0x00, //     ###    
	0x0F, 0x00, //     ####   
	0x1B, 0x00, //    ## ##   
	0x1B, 0x00, //    ## ##   
	0x13, 0x80, //    #  ###  
	0x31, 0x80, //   ##   ##  
	0x3F, 0xC0, //   ######## 
	0x7F, 0xC0, //  ######### 
	0x60, 0xC0, //  ##     ## 
	0x60, 0xE0, //  ##     ###
	0xE0, 0xE0, // ###     ###
};
const unsigned char D10pt [] = {	// 'D' (9 pixels wide)
	0xFC, 0x00, // ######   
	0xFF, 0x00, // ######## 
	0xC7, 0x00, // ##   ### 
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC3, 0x80, // ##    ###
	0xC7, 0x00, // ##   ### 
	0xFE, 0x00, // #######  
	0xFC, 0x00, // ######
};
const unsigned char E10pt [] = {	// 'E' (7 pixels wide)
	0xFE, // #######
	0xFE, // #######
	0xC0, // ##     
	0xC0, // ##     
	0xFC, // ###### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char H10pt [] = {	// 'H' (8 pixels wide)
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xFF, // ########
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
};
const unsigned char I10pt [] = {	// 'I' (2 pixels wide)
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
};
const unsigned char L10pt [] = {	// 'L' (7 pixels wide)
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char N10pt [] = {	// 'N' (9 pixels wide)
	0xE1, 0x80, // ###    ##
	0xE1, 0x80, // ###    ##
	0xF1, 0x80, // ####   ##
	0xF9, 0x80, // #####  ##
	0xD9, 0x80, // ## ##  ##
	0xDD, 0x80, // ## ### ##
	0xCD, 0x80, // ##  ## ##
	0xC7, 0x80, // ##   ####
	0xC7, 0x80, // ##   ####
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
};
const unsigned char P10pt [] = {	// 'P' (8 pixels wide)
	0xFC, // ######  
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC7, // ##   ###
	0xFE, // ####### 
	0xF8, // #####   
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##
};
const unsigned char S10pt [] = {	// 'S' (7 pixels wide)
	0x7C, //  ##### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xF0, // ####   
	0x7C, //  ##### 
	0x1E, //    ####
	0x06, //      ##
	0x06, //      ##
	0xFE, // #######
	0xF8, // #####
};
const unsigned char V10pt [] = {	// 'V' (10 pixels wide)
	0xE0, 0xC0, // ###     ##
	0xE1, 0xC0, // ###    ###
	0x61, 0x80, //  ##    ## 
	0x71, 0x80, //  ###   ## 
	0x73, 0x00, //  ###  ##  
	0x33, 0x00, //   ##  ##  
	0x3B, 0x00, //   ### ##  
	0x1E, 0x00, //    ####   
	0x1E, 0x00, //    ####   
	0x1C, 0x00, //    ###    
	0x0C, 0x00, //     ##
};
const unsigned char W10pt [] = {	// 'W' (16 pixels wide)
	0xE1, 0x83, // ###    ##     ##
	0xE1, 0xC7, // ###    ###   ###
	0x63, 0xC6, //  ##   ####   ## 
	0x63, 0xC6, //  ##   ####   ## 
	0x72, 0xC6, //  ###  # ##   ## 
	0x32, 0x6C, //   ##  #  ## ##  
	0x36, 0x6C, //   ## ##  ## ##  
	0x3E, 0x6C, //   #####  ## ##  
	0x1C, 0x28, //    ###    # #   
	0x1C, 0x38, //    ###    ###   
	0x1C, 0x38, //    ###    ###
};
const unsigned char Y10pt [] = {	// 'Y' (8 pixels wide)
	0xE3, // ###   ##
	0x66, //  ##  ## 
	0x66, //  ##  ## 
	0x34, //   ## #  
	0x34, //   ## #  
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##
};

/*===============================*/
/*====== CUSTOM CHARACTERS ======*/
/*============= END =============*/
/*===============================*/


/*********************************/
/********** ICON BITMAP **********/
/************* START *************/
/*********************************/

const unsigned char smiley20x20[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x60, 0xa1, 0xca, 0x2e, 0x84, 0xb7, 0x0c, 0x70, 0xac, 
0x0c, 0x70, 0xae, 0x2f, 0x84, 0xb7, 0x60, 0xa1, 0xca, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0x91, 0xc1, 0x41, 0x9b, 0xc7, 0x61, 0xbf, 0xdd, 0x73, 0xdc, 0xef, 0x80, 0xef, 0xfb, 
0x7f, 0xef, 0xfb, 0x73, 0xdc, 0xef, 0x5f, 0xbf, 0xdd, 0x41, 0x9c, 0xc7, 0x41, 0x92, 0xc1, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x37, 0x95, 0xc5, 0x61, 0xc9, 0xe5, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 
0x7a, 0xf5, 0xfe, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x79, 0xf5, 0xfe, 0x5e, 0xca, 0xe5, 0x36, 0x94, 0xc5, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x3f, 0xa0, 0xcd, 0x65, 0xe0, 0xf3, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 
0x71, 0xf4, 0xfe, 0x70, 0xf3, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 0x64, 0xde, 0xf3, 0x3d, 0xa1, 0xcd, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x34, 0x98, 0xca, 0x5d, 0xde, 0xf4, 0x68, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x2c, 0x8f, 0xa2, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x2c, 0x8f, 0xa2, 0x68, 0xf2, 0xfe, 0x67, 0xf3, 0xfe, 0x67, 0xf2, 0xfe, 0x5b, 0xde, 0xf4, 0x33, 0x98, 0xca, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x22, 0x22, 0x22, 0x41, 0x9b, 0xcd, 0x4f, 0xcb, 0xe9, 0x5f, 0xf1, 0xfe, 0x5e, 0xf1, 0xfe, 0x3d, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xa6, 0xbe, 0xc6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xa6, 0xbe, 0xc6, 0x00, 0x46, 0x5d, 0x3e, 0xb5, 0xc6, 0x5f, 0xf1, 0xfe, 0x5f, 0xf1, 0xfe, 0x4c, 0xcb, 0xe9, 0x40, 0x9b, 0xcd, 0x22, 0x22, 0x22, 
0x00, 0x3e, 0x44, 0x38, 0xa5, 0xd5, 0x56, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfc, 0xf6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x37, 0xb4, 0xc6, 0x55, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xa5, 0xd4, 0x00, 0x3e, 0x44, 
0x60, 0xb0, 0xda, 0x40, 0xc4, 0xe7, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x3f, 0xc4, 0xe8, 0x60, 0xb0, 0xda, 
0x30, 0x9c, 0xd3, 0x3e, 0xdb, 0xf5, 0x44, 0xed, 0xfe, 0x44, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x44, 0xed, 0xfe, 0x43, 0xed, 0xfe, 0x3d, 0xda, 0xf5, 0x2f, 0x9c, 0xd3, 
0x0e, 0x8f, 0xd0, 0x39, 0xe8, 0xfd, 0x3b, 0xec, 0xfe, 0x3e, 0xed, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x3f, 0xed, 0xfe, 0x3a, 0xec, 0xfe, 0x38, 0xe8, 0xfd, 0x0e, 0x8f, 0xd0, 
0x0e, 0x94, 0xd5, 0x30, 0xe7, 0xfe, 0x32, 0xeb, 0xfe, 0x4a, 0xee, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 
0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x64, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 0x4a, 0xee, 0xfe, 0x32, 0xeb, 0xfe, 0x30, 0xe7, 0xfd, 0x0e, 0x94, 0xd4, 
0x30, 0xa6, 0xe0, 0x2a, 0xda, 0xf8, 0x2a, 0xe9, 0xfe, 0x60, 0xf1, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 
0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x60, 0xf1, 0xfe, 0x2a, 0xea, 0xfe, 0x29, 0xda, 0xf8, 0x30, 0xa7, 0xde, 
0x61, 0xbe, 0xea, 0x2c, 0xca, 0xf1, 0x23, 0xe9, 0xfe, 0x7b, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 
0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7b, 0xf4, 0xfe, 0x23, 0xe9, 0xfe, 0x2c, 0xc9, 0xf1, 0x61, 0xbe, 0xe9, 
0x00, 0x3e, 0x44, 0x2e, 0xb9, 0xeb, 0x1b, 0xe8, 0xfe, 0x74, 0xf4, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 
0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x74, 0xf4, 0xfe, 0x1b, 0xe7, 0xfe, 0x2d, 0xba, 0xeb, 0x00, 0x3e, 0x44, 
0x22, 0x22, 0x22, 0x40, 0xb9, 0xec, 0x21, 0xd1, 0xf6, 0x56, 0xf0, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 
0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x57, 0xf0, 0xfe, 0x21, 0xd1, 0xf6, 0x3f, 0xb9, 0xec, 0x22, 0x22, 0x22, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2a, 0xb9, 0xef, 0x24, 0xde, 0xfc, 0x79, 0xf5, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 
0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0x79, 0xf5, 0xfe, 0x24, 0xde, 0xfc, 0x2a, 0xb9, 0xef, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2b, 0xc1, 0xf3, 0x29, 0xdf, 0xfd, 0x74, 0xf4, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 
0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0x74, 0xf4, 0xfe, 0x28, 0xe0, 0xfd, 0x2a, 0xc1, 0xf3, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x28, 0xbf, 0xf3, 0x1a, 0xd4, 0xfa, 0x41, 0xec, 0xfe, 0x74, 0xf4, 0xfe, 0x9e, 0xfa, 0xfe, 0xbb, 0xfe, 0xfe, 
0xbb, 0xfe, 0xfe, 0x9e, 0xfa, 0xfe, 0x74, 0xf4, 0xfe, 0x42, 0xec, 0xfe, 0x19, 0xd3, 0xfa, 0x29, 0xbf, 0xf4, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0xc3, 0xf5, 0x2a, 0xc4, 0xf6, 0x1b, 0xd1, 0xfa, 0x0a, 0xdb, 0xfd, 0x01, 0xe2, 0xfe, 
0x01, 0xe2, 0xfe, 0x0a, 0xdb, 0xfd, 0x1b, 0xd1, 0xfa, 0x29, 0xc5, 0xf7, 0x41, 0xc3, 0xf6, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x62, 0xce, 0xf9, 0x32, 0xbe, 0xf6, 0x10, 0xb3, 0xf5, 
0x10, 0xb3, 0xf5, 0x32, 0xbe, 0xf6, 0x62, 0xce, 0xf9, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/*===============================*/
/*========= ICON BITMAP =========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/****** LOW LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Command_128128RGB(unsigned char c)        // send command to OLED
{  
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((c & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   c = c << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
} 

void OLED_Data_128128RGB(unsigned char d)        // send data to OLED
{ 
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((d & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   d = d << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
}

void OLED_SetColumnAddress_128128RGB(unsigned char x_start, unsigned char x_end)    // set column address start + end
{
   OLED_Command_128128RGB(0x15);
   OLED_Data_128128RGB(x_start);
   OLED_Data_128128RGB(x_end);
}

void OLED_SetRowAddress_128128RGB(unsigned char y_start, unsigned char y_end)    // set row address start + end
{
   OLED_Command_128128RGB(0x75);
   OLED_Data_128128RGB(y_start);
   OLED_Data_128128RGB(y_end);
}

void OLED_WriteMemoryStart_128128RGB(void)    // write to RAM command
{
    OLED_Command_128128RGB(0x5C);
}

void OLED_Pixel_128128RGB(unsigned long color)    // write one pixel of a given color
{
        OLED_Data_128128RGB((color>>16));
        OLED_Data_128128RGB((color>>8));
        OLED_Data_128128RGB(color);
}

void OLED_FillScreen_128128RGB(unsigned long color)    // fill screen with a given color
{
   unsigned int i,j;
   OLED_SetColumnAddress_128128RGB(0x00, 0x7F);
   OLED_SetRowAddress_128128RGB(0x00, 0x7F);
   OLED_WriteMemoryStart_128128RGB();
   for(i=0;i<128;i++)
   {
      for(j=0;j<128;j++)
      {
	 OLED_Pixel_128128RGB(color);
      }
   }
}

/*===============================*/
/*===== LOW LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/***** HIGH LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Text_128128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=0;i<8;i++)     //each character is 8 px tall
    {
        OLED_SetColumnAddress_128128RGB(x_pos, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<5;count++)    //each character is 5px wide
        {
            if((Ascii_1[letter][count] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
        }
        y_pos++;
        mask = mask >> 1;
   }
}

void OLED_Text2x_128128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text (2x size)
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=1;i<=16;i++)     // each character is 16 pixels tall
    {
        OLED_SetColumnAddress_128128RGB(x_pos, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<10;count++)    // each character is 10 pixels wide
        {
            if((Ascii_1[letter][(count/2)] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
        }
        y_pos++;
        if((i%2)==0)
        {
          mask = mask >> 1;
        }
   }
}

void OLED_NHDText_128128RGB(unsigned long textColor, unsigned long backgroundColor)    // function to show NEWHAVEN DISPLAY
{
    int i;
    int count;
    unsigned char index = 0;
    unsigned char y_pos = 108;
    unsigned char mask = 0x80;
    
    for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_128128RGB(11, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_128128RGB(25, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character W
    {
        OLED_SetColumnAddress_128128RGB(36, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character H
    {
        OLED_SetColumnAddress_128128RGB(56, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((H10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_128128RGB(68, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character V
    {
        OLED_SetColumnAddress_128128RGB(81, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_128128RGB(95, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_128128RGB(107, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;  
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character D
    {
        OLED_SetColumnAddress_128128RGB(25, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character I
    {
        OLED_SetColumnAddress_128128RGB(39, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((I10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character S
    {
        OLED_SetColumnAddress_128128RGB(46, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((S10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character P
    {
        OLED_SetColumnAddress_128128RGB(57, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((P10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character L
    {
        OLED_SetColumnAddress_128128RGB(69, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((L10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_128128RGB(80, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character Y
    {
        OLED_SetColumnAddress_128128RGB(94, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((Y10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
}

void OLED_Icon_128128RGB(unsigned char x_pos, unsigned char y_pos)    // function to show icon
{
   unsigned int i, j;
   unsigned int height = 20;
   unsigned int width  = 20;
   
   OLED_SetColumnAddress_128128RGB(x_pos, (x_pos+width-1));
   OLED_SetRowAddress_128128RGB(y_pos, (y_pos+height-1));
   OLED_WriteMemoryStart_128128RGB();
   for(j=0;j<(height*width*3);j+=3)
   {
      OLED_Data_128128RGB(smiley20x20[j]>>2);
      OLED_Data_128128RGB(smiley20x20[(j+1)]>>2);
      OLED_Data_128128RGB(smiley20x20[(j+2)]>>2);
   }
}

void OLED_Spectrum_128128RGB(void)                  // function to show color spectrum
{
      unsigned char i, j;
      unsigned char blue, green, red;
      
      OLED_SetColumnAddress_128128RGB(0, 127);
      OLED_SetRowAddress_128128RGB(0, 37);
      OLED_WriteMemoryStart_128128RGB();
      for(i=0;i<128;i++)
      {
        OLED_Pixel_128128RGB(WHITE);
      }
      for(i=0;i<36;i++)
      {
        blue = 0x00;
        green = 0x00;
        red = 0x3F;
        OLED_Pixel_128128RGB(WHITE);
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          green += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          red -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          blue += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          green -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          red += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          blue -= 3;
        }
        OLED_Pixel_128128RGB(WHITE);
      }
      for(i=0;i<128;i++)
      {
        OLED_Pixel_128128RGB(WHITE);
      }
}

/*===============================*/
/*==== HIGH LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******** INITIALIZATION *********/
/************ START **************/
/*********************************/

void OLED_Init_128128RGB(void)      //OLED initialization
{
    digitalWrite(RES_PIN, LOW);
    delay(500);
    digitalWrite(RES_PIN, HIGH);
    delay(500);

    OLED_Command_128128RGB(0xFD);	// Command lock setting
    OLED_Data_128128RGB(0x12);		// unlock
    OLED_Command_128128RGB(0xFD);	// Command lock setting
    OLED_Data_128128RGB(0xB1);		// unlock
    OLED_Command_128128RGB(0xAE);
    OLED_Command_128128RGB(0xB3);	// clock & frequency
    OLED_Data_128128RGB(0xF1);		// clock=Diviser+1 frequency=fh 
    OLED_Command_128128RGB(0xCA);	// Duty
    OLED_Data_128128RGB(0x7F);		// OLED _END+1
    OLED_Command_128128RGB(0xA2);  	// Display offset
    OLED_Data_128128RGB(0x00);
    OLED_Command_128128RGB(0xA1);	// Set display start line
    OLED_Data_128128RGB(0x00);		// 0x00 start line
    OLED_Command_128128RGB(0xA0);	// Set Re-map, color depth
    OLED_Data_128128RGB(0xA0);		// 8-bit 262K
    OLED_Command_128128RGB(0xB5);	// set GPIO
    OLED_Data_128128RGB(0x00);		// disabled
    OLED_Command_128128RGB(0xAB);	// Function Set
    OLED_Data_128128RGB(0x01);		// 8-bit interface, internal VDD regulator
    OLED_Command_128128RGB(0xB4);	// set VSL
    OLED_Data_128128RGB(0xA0);		// external VSL
    OLED_Data_128128RGB(0xB5);
    OLED_Data_128128RGB(0x55);
    OLED_Command_128128RGB(0xC1);	// Set contrast current for A,B,C
    OLED_Data_128128RGB(0x8A);		// Color A
    OLED_Data_128128RGB(0x70);		// Color B
    OLED_Data_128128RGB(0x8A);		// Color C
    OLED_Command_128128RGB(0xC7);	// Set master contrast
    OLED_Data_128128RGB(0x0F);		//	
    OLED_Command_128128RGB(0xB9);	// use linear grayscale LUT
    OLED_Command_128128RGB(0xB1);	// Set pre & dis-charge
    OLED_Data_128128RGB(0x32);		// pre=1h, dis=1h  
    OLED_Command_128128RGB(0xBB);	// Set precharge voltage of color A,B,C
    OLED_Data_128128RGB(0x07);		//
    OLED_Command_128128RGB(0xB2);       // display enhancement
    OLED_Data_128128RGB(0xa4);		
    OLED_Data_128128RGB(0x00);
    OLED_Data_128128RGB(0x00);
    OLED_Command_128128RGB(0xB6);	// precharge period
    OLED_Data_128128RGB(0x01);		
    OLED_Command_128128RGB(0xBE);	// Set VcomH
    OLED_Data_128128RGB(0x07);
    OLED_Command_128128RGB(0xA6);	// Normal display
    OLED_Command_128128RGB(0xAF);	// Display on
}

/*===============================*/
/*======= INITIALIZATION ========*/
/*============= END =============*/
/*===============================*/

void setup()                                       // for Arduino, runs first at power on
{
   pinMode(LVL_OEN, OUTPUT);                       // configure LVL_OEN as output
   digitalWrite(LVL_OEN, LOW);
   pinMode(LVL_DIR, OUTPUT);                       // configure LVL_DIR as output
   digitalWrite(LVL_DIR, HIGH);
   DDRD = 0xFF;                                    // configure PORTD as output
   pinMode(RS_PIN, OUTPUT);                        // configure RS_PIN as output
   pinMode(RES_PIN, OUTPUT);                       // configure RES_PIN as output
   pinMode(CS_PIN, OUTPUT);                        // configure CS_PIN as output
   pinMode(BS0_PIN, OUTPUT);                       // configure BS0_PIN as output
   pinMode(BS1_PIN, OUTPUT);                       // configure BS1_PIN as output
   digitalWrite(CS_PIN, HIGH);                     // set CS_PIN
   switch(interface)
   {
     case 0:
       pinMode(RW_PIN, OUTPUT);                    // configure RW_PIN as output
       pinMode(E_PIN, OUTPUT);                     // configure E_PIN as output
       digitalWrite(BS0_PIN, HIGH);                // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // set BS1_PIN
       digitalWrite(RW_PIN, LOW);                  // reset RW_PIN
       digitalWrite(E_PIN, HIGH);                  // set E_PIN
       break;
     case 1: 
       pinMode(WR_PIN, OUTPUT);                    // configure WR_PIN as output
       pinMode(RD_PIN, OUTPUT);                    // configure RD_PIN as output
       digitalWrite(BS0_PIN, LOW);                 // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // reset BS1_PIN
       digitalWrite(WR_PIN, HIGH);                 // set WR_PIN
       digitalWrite(RD_PIN, HIGH);                 // set RD_PIN
       break;
     case 2:
       pinMode(SDI_PIN, OUTPUT);                   // configure SDI_PIN as output
       pinMode(SCL_PIN, OUTPUT);                   // configure SCL_PIN as output
       PORTD = 0x00;                               // reset SDI_PIN and SCL_PIN, ground DB[5..0] of the display
       digitalWrite(BS0_PIN, LOW);                 // reset BS0_PIN
       digitalWrite(BS1_PIN, LOW);                 // reset BS1_PIN
       digitalWrite(WR_PIN, LOW);                  // reset WR_PIN
       digitalWrite(RD_PIN, LOW);                  // reset RD_PIN
       break;
     default:
       break;
   }
}

void loop()                                         // main loop, runs after "setup()"
{  
   OLED_Init_128128RGB();                           // initialize display
   
   OLED_FillScreen_128128RGB(BLACK);                // fill screen with black
   
   OLED_NHDText_128128RGB(GREEN, BLACK);            // show NEWHAVEN DISPLAY
   
   OLED_Text_128128RGB(10, 56, 40, WHITE, BLACK);   // H
   OLED_Text_128128RGB(17, 56, 69, WHITE, BLACK);   // e
   OLED_Text_128128RGB(24, 56, 76, WHITE, BLACK);   // l
   OLED_Text_128128RGB(31, 56, 76, WHITE, BLACK);   // l
   OLED_Text_128128RGB(38, 56, 79, WHITE, BLACK);   // o
   OLED_Text_128128RGB(45, 56, 0, WHITE, BLACK);    //
      
   OLED_Text_128128RGB(52, 56, 55, WHITE, BLACK);   // W
   OLED_Text_128128RGB(59, 56, 79, WHITE, BLACK);   // o
   OLED_Text_128128RGB(66, 56, 82, WHITE, BLACK);   // r
   OLED_Text_128128RGB(73, 56, 76, WHITE, BLACK);   // l
   OLED_Text_128128RGB(80, 56, 68, WHITE, BLACK);   // d
   OLED_Text_128128RGB(87, 56, 1, WHITE, BLACK);    // !
   
   OLED_Icon_128128RGB(102, 50);                    // show icon
   
   OLED_Spectrum_128128RGB();                       // show color spectrum
   
   while(1);                                        // wait here forever
}

NHD-1.69-160128UGC3

Direct Link

//---------------------------------------------------------
/*
NHD_1_69_160128UGC3_example_uno.ino
Program for writing to Newhaven Display 160x128 Graphic Color OLED with SEPS525 controller.
This code is written for the Arduino Uno R3.

(c)2014 Michael LaVine - Newhaven Display International, Inc. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTD[7..0]

#define   SDI_PIN    6    // SDI (serial mode) signal connected to pin 6
#define   SCL_PIN    7    // SCL (serial mdoe) signal connected to pin 7
#define    RS_PIN    8    // RS signal connected to pin 8
#define    RW_PIN    9    // R/W (6800 mode) signal connected to pin 9
#define    WR_PIN    9    // /WR (8080 mode) signal connected to pin 9
#define     E_PIN   10    // E (6800 mode) signal connected to pin 10
#define    RD_PIN   10    // /RD (8080 mode) signal connected to pin 10
#define   RES_PIN   11    // /RES signal connected to pin 11
#define    CS_PIN   12    // /CS signal connected to pin 12
#define    PS_PIN   A0    // PS signal connected to pin A0
#define   CPU_PIN   A1    // CPU signal connected to pin A1
#define   LVL_DIR   A2    // DIR (direction control) signal of level shifter IC connected to pin A2
#define   LVL_OEN   A3    // /OE (output enable) signal of level shifter IC connected to pin A3

#define    RED  0x0000FF
#define  GREEN  0x00FF00
#define   BLUE  0xFF0000
#define  WHITE  0xFFFFFF
#define  BLACK  0x000000


/*********************************/
/****** INTERFACE SELECTION ******/
/*********************************/

 const unsigned char interface = 1;    // 0 = 8-bit parallel (6800 mode) interface; 1 = 8-bit parallel (8080 mode) interface; 2 = 4-wire SPI interface
 
/*===============================*/
/*===============================*/
/*===============================*/


/*********************************/
/******** FONT TABLE 5x8 *********/
/************* START *************/
/*********************************/

unsigned char Ascii_1[97][5] = {     // Refer to "Times New Roman" Font Database...
                        //   Basic Characters
    {0x00,0x00,0x00,0x00,0x00},     //   (  0)    - 0x0000 Empty set
    {0x00,0x00,0x4F,0x00,0x00},     //   (  1)  ! - 0x0021 Exclamation Mark
    {0x00,0x07,0x00,0x07,0x00},     //   (  2)  " - 0x0022 Quotation Mark
    {0x14,0x7F,0x14,0x7F,0x14},     //   (  3)  # - 0x0023 Number Sign
    {0x24,0x2A,0x7F,0x2A,0x12},     //   (  4)  $ - 0x0024 Dollar Sign
    {0x23,0x13,0x08,0x64,0x62},     //   (  5)  % - 0x0025 Percent Sign
    {0x36,0x49,0x55,0x22,0x50},     //   (  6)  & - 0x0026 Ampersand
    {0x00,0x05,0x03,0x00,0x00},     //   (  7)  ' - 0x0027 Apostrophe
    {0x00,0x1C,0x22,0x41,0x00},     //   (  8)  ( - 0x0028 Left Parenthesis
    {0x00,0x41,0x22,0x1C,0x00},     //   (  9)  ) - 0x0029 Right Parenthesis
    {0x14,0x08,0x3E,0x08,0x14},     //   ( 10)  * - 0x002A Asterisk
    {0x08,0x08,0x3E,0x08,0x08},     //   ( 11)  + - 0x002B Plus Sign
    {0x00,0x50,0x30,0x00,0x00},     //   ( 12)  , - 0x002C Comma
    {0x08,0x08,0x08,0x08,0x08},     //   ( 13)  - - 0x002D Hyphen-Minus
    {0x00,0x60,0x60,0x00,0x00},     //   ( 14)  . - 0x002E Full Stop
    {0x20,0x10,0x08,0x04,0x02},     //   ( 15)  / - 0x002F Solidus
    {0x3E,0x51,0x49,0x45,0x3E},     //   ( 16)  0 - 0x0030 Digit Zero
    {0x00,0x42,0x7F,0x40,0x00},     //   ( 17)  1 - 0x0031 Digit One
    {0x42,0x61,0x51,0x49,0x46},     //   ( 18)  2 - 0x0032 Digit Two
    {0x21,0x41,0x45,0x4B,0x31},     //   ( 19)  3 - 0x0033 Digit Three
    {0x18,0x14,0x12,0x7F,0x10},     //   ( 20)  4 - 0x0034 Digit Four
    {0x27,0x45,0x45,0x45,0x39},     //   ( 21)  5 - 0x0035 Digit Five
    {0x3C,0x4A,0x49,0x49,0x30},     //   ( 22)  6 - 0x0036 Digit Six
    {0x01,0x71,0x09,0x05,0x03},     //   ( 23)  7 - 0x0037 Digit Seven
    {0x36,0x49,0x49,0x49,0x36},     //   ( 24)  8 - 0x0038 Digit Eight
    {0x06,0x49,0x49,0x29,0x1E},     //   ( 25)  9 - 0x0039 Dight Nine
    {0x00,0x36,0x36,0x00,0x00},     //   ( 26)  : - 0x003A Colon
    {0x00,0x56,0x36,0x00,0x00},     //   ( 27)  ; - 0x003B Semicolon
    {0x08,0x14,0x22,0x41,0x00},     //   ( 28)  < - 0x003C Less-Than Sign
    {0x14,0x14,0x14,0x14,0x14},     //   ( 29)  = - 0x003D Equals Sign
    {0x00,0x41,0x22,0x14,0x08},     //   ( 30)  > - 0x003E Greater-Than Sign
    {0x02,0x01,0x51,0x09,0x06},     //   ( 31)  ? - 0x003F Question Mark
    {0x32,0x49,0x79,0x41,0x3E},     //   ( 32)  @ - 0x0040 Commercial At
    {0x7E,0x11,0x11,0x11,0x7E},     //   ( 33)  A - 0x0041 Latin Capital Letter A
    {0x7F,0x49,0x49,0x49,0x36},     //   ( 34)  B - 0x0042 Latin Capital Letter B
    {0x3E,0x41,0x41,0x41,0x22},     //   ( 35)  C - 0x0043 Latin Capital Letter C
    {0x7F,0x41,0x41,0x22,0x1C},     //   ( 36)  D - 0x0044 Latin Capital Letter D
    {0x7F,0x49,0x49,0x49,0x41},     //   ( 37)  E - 0x0045 Latin Capital Letter E
    {0x7F,0x09,0x09,0x09,0x01},     //   ( 38)  F - 0x0046 Latin Capital Letter F
    {0x3E,0x41,0x49,0x49,0x7A},     //   ( 39)  G - 0x0047 Latin Capital Letter G
    {0x7F,0x08,0x08,0x08,0x7F},     //   ( 40)  H - 0x0048 Latin Capital Letter H
    {0x00,0x41,0x7F,0x41,0x00},     //   ( 41)  I - 0x0049 Latin Capital Letter I
    {0x20,0x40,0x41,0x3F,0x01},     //   ( 42)  J - 0x004A Latin Capital Letter J
    {0x7F,0x08,0x14,0x22,0x41},     //   ( 43)  K - 0x004B Latin Capital Letter K
    {0x7F,0x40,0x40,0x40,0x40},     //   ( 44)  L - 0x004C Latin Capital Letter L
    {0x7F,0x02,0x0C,0x02,0x7F},     //   ( 45)  M - 0x004D Latin Capital Letter M
    {0x7F,0x04,0x08,0x10,0x7F},     //   ( 46)  N - 0x004E Latin Capital Letter N
    {0x3E,0x41,0x41,0x41,0x3E},     //   ( 47)  O - 0x004F Latin Capital Letter O
    {0x7F,0x09,0x09,0x09,0x06},     //   ( 48)  P - 0x0050 Latin Capital Letter P
    {0x3E,0x41,0x51,0x21,0x5E},     //   ( 49)  Q - 0x0051 Latin Capital Letter Q
    {0x7F,0x09,0x19,0x29,0x46},     //   ( 50)  R - 0x0052 Latin Capital Letter R
    {0x46,0x49,0x49,0x49,0x31},     //   ( 51)  S - 0x0053 Latin Capital Letter S
    {0x01,0x01,0x7F,0x01,0x01},     //   ( 52)  T - 0x0054 Latin Capital Letter T
    {0x3F,0x40,0x40,0x40,0x3F},     //   ( 53)  U - 0x0055 Latin Capital Letter U
    {0x1F,0x20,0x40,0x20,0x1F},     //   ( 54)  V - 0x0056 Latin Capital Letter V
    {0x3F,0x40,0x38,0x40,0x3F},     //   ( 55)  W - 0x0057 Latin Capital Letter W
    {0x63,0x14,0x08,0x14,0x63},     //   ( 56)  X - 0x0058 Latin Capital Letter X
    {0x07,0x08,0x70,0x08,0x07},     //   ( 57)  Y - 0x0059 Latin Capital Letter Y
    {0x61,0x51,0x49,0x45,0x43},     //   ( 58)  Z - 0x005A Latin Capital Letter Z
    {0x00,0x7F,0x41,0x41,0x00},     //   ( 59)  [ - 0x005B Left Square Bracket
    {0x02,0x04,0x08,0x10,0x20},     //   ( 60)  \ - 0x005C Reverse Solidus
    {0x00,0x41,0x41,0x7F,0x00},     //   ( 61)  ] - 0x005D Right Square Bracket
    {0x04,0x02,0x01,0x02,0x04},     //   ( 62)  ^ - 0x005E Circumflex Accent
    {0x40,0x40,0x40,0x40,0x40},     //   ( 63)  _ - 0x005F Low Line
    {0x01,0x02,0x04,0x00,0x00},     //   ( 64)  ` - 0x0060 Grave Accent
    {0x20,0x54,0x54,0x54,0x78},     //   ( 65)  a - 0x0061 Latin Small Letter A
    {0x7F,0x48,0x44,0x44,0x38},     //   ( 66)  b - 0x0062 Latin Small Letter B
    {0x38,0x44,0x44,0x44,0x20},     //   ( 67)  c - 0x0063 Latin Small Letter C
    {0x38,0x44,0x44,0x48,0x7F},     //   ( 68)  d - 0x0064 Latin Small Letter D
    {0x38,0x54,0x54,0x54,0x18},     //   ( 69)  e - 0x0065 Latin Small Letter E
    {0x08,0x7E,0x09,0x01,0x02},     //   ( 70)  f - 0x0066 Latin Small Letter F
    {0x06,0x49,0x49,0x49,0x3F},     //   ( 71)  g - 0x0067 Latin Small Letter G
    {0x7F,0x08,0x04,0x04,0x78},     //   ( 72)  h - 0x0068 Latin Small Letter H
    {0x00,0x44,0x7D,0x40,0x00},     //   ( 73)  i - 0x0069 Latin Small Letter I
    {0x20,0x40,0x44,0x3D,0x00},     //   ( 74)  j - 0x006A Latin Small Letter J
    {0x7F,0x10,0x28,0x44,0x00},     //   ( 75)  k - 0x006B Latin Small Letter K
    {0x00,0x41,0x7F,0x40,0x00},     //   ( 76)  l - 0x006C Latin Small Letter L
    {0x7C,0x04,0x18,0x04,0x7C},     //   ( 77)  m - 0x006D Latin Small Letter M
    {0x7C,0x08,0x04,0x04,0x78},     //   ( 78)  n - 0x006E Latin Small Letter N
    {0x38,0x44,0x44,0x44,0x38},     //   ( 79)  o - 0x006F Latin Small Letter O
    {0x7C,0x14,0x14,0x14,0x08},     //   ( 80)  p - 0x0070 Latin Small Letter P
    {0x08,0x14,0x14,0x18,0x7C},     //   ( 81)  q - 0x0071 Latin Small Letter Q
    {0x7C,0x08,0x04,0x04,0x08},     //   ( 82)  r - 0x0072 Latin Small Letter R
    {0x48,0x54,0x54,0x54,0x20},     //   ( 83)  s - 0x0073 Latin Small Letter S
    {0x04,0x3F,0x44,0x40,0x20},     //   ( 84)  t - 0x0074 Latin Small Letter T
    {0x3C,0x40,0x40,0x20,0x7C},     //   ( 85)  u - 0x0075 Latin Small Letter U
    {0x1C,0x20,0x40,0x20,0x1C},     //   ( 86)  v - 0x0076 Latin Small Letter V
    {0x3C,0x40,0x30,0x40,0x3C},     //   ( 87)  w - 0x0077 Latin Small Letter W
    {0x44,0x28,0x10,0x28,0x44},     //   ( 88)  x - 0x0078 Latin Small Letter X
    {0x0C,0x50,0x50,0x50,0x3C},     //   ( 89)  y - 0x0079 Latin Small Letter Y
    {0x44,0x64,0x54,0x4C,0x44},     //   ( 90)  z - 0x007A Latin Small Letter Z
    {0x00,0x08,0x36,0x41,0x00},     //   ( 91)  { - 0x007B Left Curly Bracket
    {0x00,0x00,0x7F,0x00,0x00},     //   ( 92)  | - 0x007C Vertical Line
    {0x00,0x41,0x36,0x08,0x00},     //   ( 93)  } - 0x007D Right Curly Bracket
    {0x02,0x01,0x02,0x04,0x02},     //   ( 94)  ~ - 0x007E Tilde
    {0x08,0x0C,0x0E,0x0C,0x08},     //   ( 95)  upward facing triangle/arrow
    {0x08,0x18,0x38,0x18,0x08},     //   ( 96)  downward facing triangle/arrow
};

/*===============================*/
/*======= FONT TABLE 5x8 ========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******* CUSTOM CHARACTERS *******/
/************* START *************/
/*********************************/

const unsigned char A10pt [] = {	// 'A' (11 pixels wide)
	0x0E, 0x00, //     ###    
	0x0F, 0x00, //     ####   
	0x1B, 0x00, //    ## ##   
	0x1B, 0x00, //    ## ##   
	0x13, 0x80, //    #  ###  
	0x31, 0x80, //   ##   ##  
	0x3F, 0xC0, //   ######## 
	0x7F, 0xC0, //  ######### 
	0x60, 0xC0, //  ##     ## 
	0x60, 0xE0, //  ##     ###
	0xE0, 0xE0, // ###     ###
};
const unsigned char D10pt [] = {	// 'D' (9 pixels wide)
	0xFC, 0x00, // ######   
	0xFF, 0x00, // ######## 
	0xC7, 0x00, // ##   ### 
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC3, 0x80, // ##    ###
	0xC7, 0x00, // ##   ### 
	0xFE, 0x00, // #######  
	0xFC, 0x00, // ######
};
const unsigned char E10pt [] = {	// 'E' (7 pixels wide)
	0xFE, // #######
	0xFE, // #######
	0xC0, // ##     
	0xC0, // ##     
	0xFC, // ###### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char H10pt [] = {	// 'H' (8 pixels wide)
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xFF, // ########
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
};
const unsigned char I10pt [] = {	// 'I' (2 pixels wide)
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
};
const unsigned char L10pt [] = {	// 'L' (7 pixels wide)
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char N10pt [] = {	// 'N' (9 pixels wide)
	0xE1, 0x80, // ###    ##
	0xE1, 0x80, // ###    ##
	0xF1, 0x80, // ####   ##
	0xF9, 0x80, // #####  ##
	0xD9, 0x80, // ## ##  ##
	0xDD, 0x80, // ## ### ##
	0xCD, 0x80, // ##  ## ##
	0xC7, 0x80, // ##   ####
	0xC7, 0x80, // ##   ####
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
};
const unsigned char P10pt [] = {	// 'P' (8 pixels wide)
	0xFC, // ######  
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC7, // ##   ###
	0xFE, // ####### 
	0xF8, // #####   
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##
};
const unsigned char S10pt [] = {	// 'S' (7 pixels wide)
	0x7C, //  ##### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xF0, // ####   
	0x7C, //  ##### 
	0x1E, //    ####
	0x06, //      ##
	0x06, //      ##
	0xFE, // #######
	0xF8, // #####
};
const unsigned char V10pt [] = {	// 'V' (10 pixels wide)
	0xE0, 0xC0, // ###     ##
	0xE1, 0xC0, // ###    ###
	0x61, 0x80, //  ##    ## 
	0x71, 0x80, //  ###   ## 
	0x73, 0x00, //  ###  ##  
	0x33, 0x00, //   ##  ##  
	0x3B, 0x00, //   ### ##  
	0x1E, 0x00, //    ####   
	0x1E, 0x00, //    ####   
	0x1C, 0x00, //    ###    
	0x0C, 0x00, //     ##
};
const unsigned char W10pt [] = {	// 'W' (16 pixels wide)
	0xE1, 0x83, // ###    ##     ##
	0xE1, 0xC7, // ###    ###   ###
	0x63, 0xC6, //  ##   ####   ## 
	0x63, 0xC6, //  ##   ####   ## 
	0x72, 0xC6, //  ###  # ##   ## 
	0x32, 0x6C, //   ##  #  ## ##  
	0x36, 0x6C, //   ## ##  ## ##  
	0x3E, 0x6C, //   #####  ## ##  
	0x1C, 0x28, //    ###    # #   
	0x1C, 0x38, //    ###    ###   
	0x1C, 0x38, //    ###    ###
};
const unsigned char Y10pt [] = {	// 'Y' (8 pixels wide)
	0xE3, // ###   ##
	0x66, //  ##  ## 
	0x66, //  ##  ## 
	0x34, //   ## #  
	0x34, //   ## #  
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##
};

/*===============================*/
/*====== CUSTOM CHARACTERS ======*/
/*============= END =============*/
/*===============================*/


/*********************************/
/********** ICON BITMAP **********/
/************* START *************/
/*********************************/

const unsigned char smiley20x20[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x60, 0xa1, 0xca, 0x2e, 0x84, 0xb7, 0x0c, 0x70, 0xac, 
0x0c, 0x70, 0xae, 0x2f, 0x84, 0xb7, 0x60, 0xa1, 0xca, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0x91, 0xc1, 0x41, 0x9b, 0xc7, 0x61, 0xbf, 0xdd, 0x73, 0xdc, 0xef, 0x80, 0xef, 0xfb, 
0x7f, 0xef, 0xfb, 0x73, 0xdc, 0xef, 0x5f, 0xbf, 0xdd, 0x41, 0x9c, 0xc7, 0x41, 0x92, 0xc1, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x37, 0x95, 0xc5, 0x61, 0xc9, 0xe5, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 
0x7a, 0xf5, 0xfe, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x79, 0xf5, 0xfe, 0x5e, 0xca, 0xe5, 0x36, 0x94, 0xc5, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x3f, 0xa0, 0xcd, 0x65, 0xe0, 0xf3, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 
0x71, 0xf4, 0xfe, 0x70, 0xf3, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 0x64, 0xde, 0xf3, 0x3d, 0xa1, 0xcd, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x34, 0x98, 0xca, 0x5d, 0xde, 0xf4, 0x68, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x2c, 0x8f, 0xa2, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x2c, 0x8f, 0xa2, 0x68, 0xf2, 0xfe, 0x67, 0xf3, 0xfe, 0x67, 0xf2, 0xfe, 0x5b, 0xde, 0xf4, 0x33, 0x98, 0xca, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x22, 0x22, 0x22, 0x41, 0x9b, 0xcd, 0x4f, 0xcb, 0xe9, 0x5f, 0xf1, 0xfe, 0x5e, 0xf1, 0xfe, 0x3d, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xa6, 0xbe, 0xc6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xa6, 0xbe, 0xc6, 0x00, 0x46, 0x5d, 0x3e, 0xb5, 0xc6, 0x5f, 0xf1, 0xfe, 0x5f, 0xf1, 0xfe, 0x4c, 0xcb, 0xe9, 0x40, 0x9b, 0xcd, 0x22, 0x22, 0x22, 
0x00, 0x3e, 0x44, 0x38, 0xa5, 0xd5, 0x56, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfc, 0xf6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x37, 0xb4, 0xc6, 0x55, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xa5, 0xd4, 0x00, 0x3e, 0x44, 
0x60, 0xb0, 0xda, 0x40, 0xc4, 0xe7, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x3f, 0xc4, 0xe8, 0x60, 0xb0, 0xda, 
0x30, 0x9c, 0xd3, 0x3e, 0xdb, 0xf5, 0x44, 0xed, 0xfe, 0x44, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x44, 0xed, 0xfe, 0x43, 0xed, 0xfe, 0x3d, 0xda, 0xf5, 0x2f, 0x9c, 0xd3, 
0x0e, 0x8f, 0xd0, 0x39, 0xe8, 0xfd, 0x3b, 0xec, 0xfe, 0x3e, 0xed, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x3f, 0xed, 0xfe, 0x3a, 0xec, 0xfe, 0x38, 0xe8, 0xfd, 0x0e, 0x8f, 0xd0, 
0x0e, 0x94, 0xd5, 0x30, 0xe7, 0xfe, 0x32, 0xeb, 0xfe, 0x4a, 0xee, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 
0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x64, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 0x4a, 0xee, 0xfe, 0x32, 0xeb, 0xfe, 0x30, 0xe7, 0xfd, 0x0e, 0x94, 0xd4, 
0x30, 0xa6, 0xe0, 0x2a, 0xda, 0xf8, 0x2a, 0xe9, 0xfe, 0x60, 0xf1, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 
0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x60, 0xf1, 0xfe, 0x2a, 0xea, 0xfe, 0x29, 0xda, 0xf8, 0x30, 0xa7, 0xde, 
0x61, 0xbe, 0xea, 0x2c, 0xca, 0xf1, 0x23, 0xe9, 0xfe, 0x7b, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 
0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7b, 0xf4, 0xfe, 0x23, 0xe9, 0xfe, 0x2c, 0xc9, 0xf1, 0x61, 0xbe, 0xe9, 
0x00, 0x3e, 0x44, 0x2e, 0xb9, 0xeb, 0x1b, 0xe8, 0xfe, 0x74, 0xf4, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 
0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x74, 0xf4, 0xfe, 0x1b, 0xe7, 0xfe, 0x2d, 0xba, 0xeb, 0x00, 0x3e, 0x44, 
0x22, 0x22, 0x22, 0x40, 0xb9, 0xec, 0x21, 0xd1, 0xf6, 0x56, 0xf0, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 
0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x57, 0xf0, 0xfe, 0x21, 0xd1, 0xf6, 0x3f, 0xb9, 0xec, 0x22, 0x22, 0x22, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2a, 0xb9, 0xef, 0x24, 0xde, 0xfc, 0x79, 0xf5, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 
0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0x79, 0xf5, 0xfe, 0x24, 0xde, 0xfc, 0x2a, 0xb9, 0xef, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2b, 0xc1, 0xf3, 0x29, 0xdf, 0xfd, 0x74, 0xf4, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 
0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0x74, 0xf4, 0xfe, 0x28, 0xe0, 0xfd, 0x2a, 0xc1, 0xf3, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x28, 0xbf, 0xf3, 0x1a, 0xd4, 0xfa, 0x41, 0xec, 0xfe, 0x74, 0xf4, 0xfe, 0x9e, 0xfa, 0xfe, 0xbb, 0xfe, 0xfe, 
0xbb, 0xfe, 0xfe, 0x9e, 0xfa, 0xfe, 0x74, 0xf4, 0xfe, 0x42, 0xec, 0xfe, 0x19, 0xd3, 0xfa, 0x29, 0xbf, 0xf4, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0xc3, 0xf5, 0x2a, 0xc4, 0xf6, 0x1b, 0xd1, 0xfa, 0x0a, 0xdb, 0xfd, 0x01, 0xe2, 0xfe, 
0x01, 0xe2, 0xfe, 0x0a, 0xdb, 0xfd, 0x1b, 0xd1, 0xfa, 0x29, 0xc5, 0xf7, 0x41, 0xc3, 0xf6, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x62, 0xce, 0xf9, 0x32, 0xbe, 0xf6, 0x10, 0xb3, 0xf5, 
0x10, 0xb3, 0xf5, 0x32, 0xbe, 0xf6, 0x62, 0xce, 0xf9, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/*===============================*/
/*========= ICON BITMAP =========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/****** LOW LEVEL FUNCTIONS ******/
/************* START *************/
/*********************************/

void OLED_Command_160128RGB(unsigned char c)        // send command to OLED
{  
   unsigned char i;
   unsigned char mask = 0x80;
   
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                PORTD = c;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((c & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   c = c << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
} 

void OLED_Data_160128RGB(unsigned char d)        // send data to OLED
{ 
   unsigned char i;
   unsigned char mask = 0x80;
   
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                digitalWrite(WR_PIN, HIGH);
                PORTD = d;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((d & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   d = d << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
}

void OLED_SerialPixelData_160128RGB(unsigned char d)    // serial write for pixel data
{
   unsigned char i;
   unsigned char mask = 0x80;
   digitalWrite(CS_PIN, LOW);               
   digitalWrite(RS_PIN, HIGH);
   for(i=0;i<6;i++)
   {
     digitalWrite(SCL_PIN, LOW);
     if((d & mask) >> 7 == 1)
     {
       digitalWrite(SDI_PIN, HIGH);
     }
     else
     {
       digitalWrite(SDI_PIN, LOW);
     }
     digitalWrite(SCL_PIN, HIGH);
     d = d << 1;
   }
   digitalWrite(CS_PIN, HIGH);
}
  
void OLED_SetColumnAddress_160128RGB(unsigned char x_start, unsigned char x_end)    // set column address start + end
{
    OLED_Command_160128RGB(0x17);
    OLED_Data_160128RGB(x_start);
    OLED_Command_160128RGB(0x18);
    OLED_Data_160128RGB(x_end);
}

void OLED_SetRowAddress_160128RGB(unsigned char y_start, unsigned char y_end)    // set row address start + end
{
    OLED_Command_160128RGB(0x19);
    OLED_Data_160128RGB(y_start);
    OLED_Command_160128RGB(0x1A);
    OLED_Data_160128RGB(y_end);
}

void OLED_WriteMemoryStart_160128RGB(void)    // write to RAM command
{
    OLED_Command_160128RGB(0x22);
}

void OLED_Pixel_160128RGB(unsigned long color)    // write one pixel of a given color
{
    switch(interface)
    {
      case 0:
        OLED_Data_160128RGB((color>>16));
        OLED_Data_160128RGB((color>>8));
        OLED_Data_160128RGB(color);
        break;
      case 1: 
        OLED_Data_160128RGB((color>>16));
        OLED_Data_160128RGB((color>>8));
        OLED_Data_160128RGB(color);
        break;
      case 2:
        OLED_SerialPixelData_160128RGB((color>>16));
        OLED_SerialPixelData_160128RGB((color>>8));
        OLED_SerialPixelData_160128RGB(color);
        break;
      default:
        break;
    }
}

void OLED_SetPosition_160128RGB(unsigned char x_pos, unsigned char y_pos)    // set x,y address
{
    OLED_Command_160128RGB(0x20);
    OLED_Data_160128RGB(x_pos);
    OLED_Command_160128RGB(0x21);
    OLED_Data_160128RGB(y_pos);
}

void OLED_FillScreen_160128RGB(unsigned long color)    // fill screen with a given color
{
   unsigned int i;
   OLED_SetPosition_160128RGB(0,0);
   OLED_WriteMemoryStart_160128RGB();
   for(i=0;i<20480;i++)
   {
      OLED_Pixel_160128RGB(color);
   }
}

/*===============================*/
/*===== LOW LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/***** HIGH LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Text_160128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=0;i<8;i++)     // each character is 8 pixels tall
    {
        OLED_SetPosition_160128RGB(x_pos,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<5;count++)    // each character is 5 pixels wide
        {
            if((Ascii_1[letter][count] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
        }
        y_pos++;
        mask = mask >> 1;
   }
}

void OLED_Text2x_160128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text (2x size)
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=1;i<=16;i++)     // each character is 16 pixels tall
    {
        OLED_SetPosition_160128RGB(x_pos,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<10;count++)    // each character is 10 pixels wide
        {
            if((Ascii_1[letter][(count/2)] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
        }
        y_pos++;
        if((i%2)==0)
        {
          mask = mask >> 1;
        }
   }
}

void OLED_NHDText_160128RGB(unsigned long textColor, unsigned long backgroundColor)    // function to show NEWHAVEN DISPLAY
{
    int i;
    int count;
    unsigned char index = 0;
    unsigned char y_pos = 110;
    unsigned char mask = 0x80;
    
    for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetPosition_160128RGB(26,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 110;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetPosition_160128RGB(40,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 110;
   
   for(i=0;i<11;i++)     // display custom character W
    {
        OLED_SetPosition_160128RGB(51,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 110;
   
   for(i=0;i<11;i++)     // display custom character H
    {
        OLED_SetPosition_160128RGB(71,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((H10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 110;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetPosition_160128RGB(83,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 110;
   
   for(i=0;i<11;i++)     // display custom character V
    {
        OLED_SetPosition_160128RGB(96,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 110;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetPosition_160128RGB(110,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 110;
   
   for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetPosition_160128RGB(122,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character D
    {
        OLED_SetPosition_160128RGB(40,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;  
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character I
    {
        OLED_SetPosition_160128RGB(54,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((I10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character S
    {
        OLED_SetPosition_160128RGB(61,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((S10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character P
    {
        OLED_SetPosition_160128RGB(72,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((P10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character L
    {
        OLED_SetPosition_160128RGB(84,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((L10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetPosition_160128RGB(95,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character Y
    {
        OLED_SetPosition_160128RGB(109,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((Y10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
}

void OLED_Icon_160128RGB(unsigned char x_pos, unsigned char y_pos)    // function to show icon
{
   unsigned int i, j;
   unsigned int incr = 0;
   
   for(i=0;i<20;i++)
   {
     OLED_SetPosition_160128RGB(x_pos,y_pos+i);
     OLED_WriteMemoryStart_160128RGB();
     for(j=0;j<60;j+=3)
     {
        switch(interface)
        {
          case 0:
          case 1: 
            OLED_Data_160128RGB(smiley20x20[(j+incr)]);
            OLED_Data_160128RGB(smiley20x20[((j+incr)+1)]);
            OLED_Data_160128RGB(smiley20x20[((j+incr)+2)]);
            break;
          case 2:
            OLED_SerialPixelData_160128RGB(smiley20x20[(j+incr)]);
            OLED_SerialPixelData_160128RGB(smiley20x20[((j+incr)+1)]);
            OLED_SerialPixelData_160128RGB(smiley20x20[((j+incr)+2)]);
            break;
          default:
            break;
        }
     }
     incr += 60;
   }
}

void OLED_Spectrum_160128RGB(void)                  // function to show color spectrum
{
      unsigned char i, j;
      unsigned char blue, green, red;
      
      OLED_SetPosition_160128RGB(0,0);
      OLED_WriteMemoryStart_160128RGB();
      for(i=0;i<160;i++)
      {
        OLED_Pixel_160128RGB(WHITE);
      }
      OLED_SetPosition_160128RGB(0,1);
      OLED_WriteMemoryStart_160128RGB();
      for(i=0;i<160;i++)
      {
        OLED_Pixel_160128RGB(WHITE);
      }
      for(i=0;i<40;i++)
      {
        blue = 0x00;
        green = 0x00;
        red = 0xFF;
        OLED_SetPosition_160128RGB(0,(2+i));
        OLED_WriteMemoryStart_160128RGB();
        OLED_Pixel_160128RGB(WHITE);
        OLED_Pixel_160128RGB(WHITE);
        for(j=0;j<26;j++)
        {
          OLED_Data_160128RGB(blue);
          OLED_Data_160128RGB(green);
          OLED_Data_160128RGB(red);
          green += 9;
        }
        for(j=0;j<26;j++)
        {
          OLED_Data_160128RGB(blue);
          OLED_Data_160128RGB(green);
          OLED_Data_160128RGB(red);
          red -= 9;
        }
        for(j=0;j<26;j++)
        {
          OLED_Data_160128RGB(blue);
          OLED_Data_160128RGB(green);
          OLED_Data_160128RGB(red);
          blue += 9;
        }
        for(j=0;j<26;j++)
        {
          OLED_Data_160128RGB(blue);
          OLED_Data_160128RGB(green);
          OLED_Data_160128RGB(red);
          green -= 9;
        }
        for(j=0;j<26;j++)
        {
          OLED_Data_160128RGB(blue);
          OLED_Data_160128RGB(green);
          OLED_Data_160128RGB(red);
          red += 9;
        }
        for(j=0;j<26;j++)
        {
          OLED_Data_160128RGB(blue);
          OLED_Data_160128RGB(green);
          OLED_Data_160128RGB(red);
          blue -= 9;
        }
        OLED_Pixel_160128RGB(WHITE);
        OLED_Pixel_160128RGB(WHITE);
      }
      
      OLED_SetPosition_160128RGB(0,42);
      OLED_WriteMemoryStart_160128RGB();
      for(i=0;i<160;i++)
      {
        OLED_Pixel_160128RGB(WHITE);
      }
      OLED_SetPosition_160128RGB(0,43);
      OLED_WriteMemoryStart_160128RGB();
      for(i=0;i<160;i++)
      {
        OLED_Pixel_160128RGB(WHITE);
      }
}

/*===============================*/
/*==== HIGH LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******** INITIALIZATION *********/
/************ START **************/
/*********************************/

void OLED_Init_160128RGB(void)      //OLED initialization
{
    digitalWrite(RES_PIN, LOW);
    delay(2);
    digitalWrite(RES_PIN, HIGH);
    delay(2);
    
    // display off, analog reset
    OLED_Command_160128RGB(0x04);
    OLED_Data_160128RGB(0x01);
    delay(1);
    
     // normal mode
    OLED_Command_160128RGB(0x04); 
    OLED_Data_160128RGB(0x00); 
    delay(1);
    
    // display off
    OLED_Command_160128RGB(0x06);
    OLED_Data_160128RGB(0x00);
    delay(1);
    
    // turn on internal oscillator using external resistor
    OLED_Command_160128RGB(0x02);
    OLED_Data_160128RGB(0x01); 
    
    // 90 hz frame rate, divider 0
    OLED_Command_160128RGB(0x03);
    OLED_Data_160128RGB(0x30); 
    
    // duty cycle 127
    OLED_Command_160128RGB(0x28);
    OLED_Data_160128RGB(0x7F);
    
    // start on line 0
    OLED_Command_160128RGB(0x29);
    OLED_Data_160128RGB(0x00); 
    
    // rgb_if
    OLED_Command_160128RGB(0x14);
    OLED_Data_160128RGB(0x31); 
    
    // Set Memory Write Mode
    OLED_Command_160128RGB(0x16);
    OLED_Data_160128RGB(0x76);
    
    // driving current r g b (uA)
    OLED_Command_160128RGB(0x10);
    OLED_Data_160128RGB(0x45);
    OLED_Command_160128RGB(0x11);
    OLED_Data_160128RGB(0x34);
    OLED_Command_160128RGB(0x12);
    OLED_Data_160128RGB(0x33);
    
    // precharge time r g b
    OLED_Command_160128RGB(0x08);
    OLED_Data_160128RGB(0x04);
    OLED_Command_160128RGB(0x09);
    OLED_Data_160128RGB(0x05);
    OLED_Command_160128RGB(0x0A);
    OLED_Data_160128RGB(0x05);
    
    // precharge current r g b (uA)
    OLED_Command_160128RGB(0x0B);
    OLED_Data_160128RGB(0x9D);
    OLED_Command_160128RGB(0x0C);
    OLED_Data_160128RGB(0x8C);
    OLED_Command_160128RGB(0x0D);
    OLED_Data_160128RGB(0x57);
    
    // Set Reference Voltage Controlled by External Resister
    OLED_Command_160128RGB(0x80);
    OLED_Data_160128RGB(0x00);
    
    // mode set
    OLED_Command_160128RGB(0x13);
    OLED_Data_160128RGB(0xA0);
    
    OLED_SetColumnAddress_160128RGB(0, 159);
    OLED_SetRowAddress_160128RGB(0, 127);

    // Display On
    OLED_Command_160128RGB(0x06);
    OLED_Data_160128RGB(0x01); 
}

/*===============================*/
/*======= INITIALIZATION ========*/
/*============= END =============*/
/*===============================*/

void setup()                                       // for Arduino, runs first at power on
{
   pinMode(LVL_OEN, OUTPUT);                       // configure LVL_OEN as output
   digitalWrite(LVL_OEN, LOW);
   pinMode(LVL_DIR, OUTPUT);                       // configure LVL_DIR as output
   digitalWrite(LVL_DIR, HIGH);
   DDRD = 0xFF;                                    // configure PORTD as output
   pinMode(RS_PIN, OUTPUT);                        // configure RS_PIN as output
   pinMode(RES_PIN, OUTPUT);                       // configure RES_PIN as output
   pinMode(CS_PIN, OUTPUT);                        // configure CS_PIN as output
   pinMode(PS_PIN, OUTPUT);                        // configure PS_PIN as output
   pinMode(CPU_PIN, OUTPUT);                       // configure CPU_PIN as output
   digitalWrite(LVL_OEN, LOW);
   digitalWrite(CS_PIN, HIGH);                     // set CS_PIN
   switch(interface)
   {
     case 0:
       pinMode(RW_PIN, OUTPUT);                    // configure RW_PIN as output
       pinMode(E_PIN, OUTPUT);                     // configure E_PIN as output
       digitalWrite(PS_PIN, HIGH);                 // set PS_PIN
       digitalWrite(CPU_PIN, HIGH);                // set CPU_PIN
       digitalWrite(RW_PIN, LOW);                  // reset RW_PIN
       digitalWrite(E_PIN, HIGH);                  // set E_PIN
       break;
     case 1: 
       pinMode(WR_PIN, OUTPUT);                    // configure WR_PIN as output
       pinMode(RD_PIN, OUTPUT);                    // configure RD_PIN as output
       digitalWrite(PS_PIN, HIGH);                 // set PS_PIN
       digitalWrite(CPU_PIN, LOW);                 // reset CPU_PIN
       digitalWrite(WR_PIN, HIGH);                 // set WR_PIN
       digitalWrite(RD_PIN, HIGH);                 // set RD_PIN
       break;
     case 2:
       pinMode(SDI_PIN, OUTPUT);                   // configure SDI_PIN as output
       pinMode(SCL_PIN, OUTPUT);                   // configure SCL_PIN as output
       PORTD = 0x00;                               // reset SDI_PIN and SCL_PIN, ground DB[5..0] of the display
       digitalWrite(PS_PIN, LOW);                  // reset PS_PIN
       break;
     default:
       break;
   }
}

void loop()                                         // main loop, runs after "setup()"
{  
   OLED_Init_160128RGB();                           // initialize display
   
   OLED_FillScreen_160128RGB(BLACK);                // fill screen with black

   OLED_NHDText_160128RGB(GREEN, BLACK);            // show NEWHAVEN DISPLAY
      
   OLED_Text_160128RGB(20, 58, 40, WHITE, BLACK);   // H
   OLED_Text_160128RGB(27, 58, 69, WHITE, BLACK);   // e
   OLED_Text_160128RGB(34, 58, 76, WHITE, BLACK);   // l
   OLED_Text_160128RGB(41, 58, 76, WHITE, BLACK);   // l
   OLED_Text_160128RGB(48, 58, 79, WHITE, BLACK);   // o
   OLED_Text_160128RGB(55, 58, 0, WHITE, BLACK);    //
      
   OLED_Text_160128RGB(62, 58, 55, WHITE, BLACK);   // W
   OLED_Text_160128RGB(69, 58, 79, WHITE, BLACK);   // o
   OLED_Text_160128RGB(76, 58, 82, WHITE, BLACK);   // r
   OLED_Text_160128RGB(83, 58, 76, WHITE, BLACK);   // l
   OLED_Text_160128RGB(90, 58, 68, WHITE, BLACK);   // d
   OLED_Text_160128RGB(97, 58, 1, WHITE, BLACK);    // !
      
   OLED_Icon_160128RGB(120, 52);                    // show icon
      
   OLED_Spectrum_160128RGB();                       // show color spectrum

   while(1);                                        // wait here forever
}

NHD-1.27-AU-SHIELD

Direct Link

//---------------------------------------------------------
/*

NHD-1.27-AU-SHIELD.ino

Program for writing to Newhaven Display's 128x96 Graphic Color OLED with SSD1351 controller.

This code is written for the Arduino Uno R3.

Copyright (c) 2015 - Newhaven Display International, Inc.

Newhaven Display invests time and resources providing this open source code,
please support Newhaven Display by purchasing products from Newhaven Display!

*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTD[7..0]

#define   SDI_PIN    11    // SDI (serial mode) signal connected to pin 11
#define   SCL_PIN    13    // SCL (serial mdoe) signal connected to pin 13
#define    RS_PIN    4    // RS signal connected to pin 4
#define    RW_PIN    9    // R/W (6800 mode) signal connected to pin 9
#define    WR_PIN    9    // /WR (8080 mode) signal connected to pin 9
#define     E_PIN   10    // E (6800 mode) signal connected to pin 10
#define    RD_PIN   10    // /RD (8080 mode) signal connected to pin 10
#define   RES_PIN   6    // /RES signal connected to pin 6
#define    CS_PIN   5    // /CS signal connected to pin 5
#define   BS1_PIN   A0    // BS1 signal connected to pin A0
#define   BS0_PIN   A1    // BS0 signal connected to pin A1
#define   LVL_DIR   A2    // DIR (direction control) signal of level shifter IC connected to pin A2
#define   LVL_OEN   A3    // /OE (output enable) signal of level shifter IC connected to pin A3

#define    RED  0x0000FF
#define  GREEN  0x00FF00
#define   BLUE  0xFF0000
#define  WHITE  0xFFFFFF
#define  BLACK  0x000000


/*********************************/
/****** INTERFACE SELECTION ******/
/*********************************/

 const unsigned char interface = 2;    // 0 = 8-bit parallel (6800 mode) interface; 1 = 8-bit parallel (8080 mode) interface; 2 = 4-wire SPI interface
 
/*===============================*/
/*===============================*/
/*===============================*/


/*********************************/
/******** FONT TABLE 5x8 *********/
/************* START *************/
/*********************************/

unsigned char Ascii_1[97][5] = {     // Refer to "Times New Roman" Font Database...
                        //   Basic Characters
    {0x00,0x00,0x00,0x00,0x00},     //   (  0)    - 0x0000 Empty set
    {0x00,0x00,0x4F,0x00,0x00},     //   (  1)  ! - 0x0021 Exclamation Mark
    {0x00,0x07,0x00,0x07,0x00},     //   (  2)  " - 0x0022 Quotation Mark
    {0x14,0x7F,0x14,0x7F,0x14},     //   (  3)  # - 0x0023 Number Sign
    {0x24,0x2A,0x7F,0x2A,0x12},     //   (  4)  $ - 0x0024 Dollar Sign
    {0x23,0x13,0x08,0x64,0x62},     //   (  5)  % - 0x0025 Percent Sign
    {0x36,0x49,0x55,0x22,0x50},     //   (  6)  & - 0x0026 Ampersand
    {0x00,0x05,0x03,0x00,0x00},     //   (  7)  ' - 0x0027 Apostrophe
    {0x00,0x1C,0x22,0x41,0x00},     //   (  8)  ( - 0x0028 Left Parenthesis
    {0x00,0x41,0x22,0x1C,0x00},     //   (  9)  ) - 0x0029 Right Parenthesis
    {0x14,0x08,0x3E,0x08,0x14},     //   ( 10)  * - 0x002A Asterisk
    {0x08,0x08,0x3E,0x08,0x08},     //   ( 11)  + - 0x002B Plus Sign
    {0x00,0x50,0x30,0x00,0x00},     //   ( 12)  , - 0x002C Comma
    {0x08,0x08,0x08,0x08,0x08},     //   ( 13)  - - 0x002D Hyphen-Minus
    {0x00,0x60,0x60,0x00,0x00},     //   ( 14)  . - 0x002E Full Stop
    {0x20,0x10,0x08,0x04,0x02},     //   ( 15)  / - 0x002F Solidus
    {0x3E,0x51,0x49,0x45,0x3E},     //   ( 16)  0 - 0x0030 Digit Zero
    {0x00,0x42,0x7F,0x40,0x00},     //   ( 17)  1 - 0x0031 Digit One
    {0x42,0x61,0x51,0x49,0x46},     //   ( 18)  2 - 0x0032 Digit Two
    {0x21,0x41,0x45,0x4B,0x31},     //   ( 19)  3 - 0x0033 Digit Three
    {0x18,0x14,0x12,0x7F,0x10},     //   ( 20)  4 - 0x0034 Digit Four
    {0x27,0x45,0x45,0x45,0x39},     //   ( 21)  5 - 0x0035 Digit Five
    {0x3C,0x4A,0x49,0x49,0x30},     //   ( 22)  6 - 0x0036 Digit Six
    {0x01,0x71,0x09,0x05,0x03},     //   ( 23)  7 - 0x0037 Digit Seven
    {0x36,0x49,0x49,0x49,0x36},     //   ( 24)  8 - 0x0038 Digit Eight
    {0x06,0x49,0x49,0x29,0x1E},     //   ( 25)  9 - 0x0039 Dight Nine
    {0x00,0x36,0x36,0x00,0x00},     //   ( 26)  : - 0x003A Colon
    {0x00,0x56,0x36,0x00,0x00},     //   ( 27)  ; - 0x003B Semicolon
    {0x08,0x14,0x22,0x41,0x00},     //   ( 28)  < - 0x003C Less-Than Sign
    {0x14,0x14,0x14,0x14,0x14},     //   ( 29)  = - 0x003D Equals Sign
    {0x00,0x41,0x22,0x14,0x08},     //   ( 30)  > - 0x003E Greater-Than Sign
    {0x02,0x01,0x51,0x09,0x06},     //   ( 31)  ? - 0x003F Question Mark
    {0x32,0x49,0x79,0x41,0x3E},     //   ( 32)  @ - 0x0040 Commercial At
    {0x7E,0x11,0x11,0x11,0x7E},     //   ( 33)  A - 0x0041 Latin Capital Letter A
    {0x7F,0x49,0x49,0x49,0x36},     //   ( 34)  B - 0x0042 Latin Capital Letter B
    {0x3E,0x41,0x41,0x41,0x22},     //   ( 35)  C - 0x0043 Latin Capital Letter C
    {0x7F,0x41,0x41,0x22,0x1C},     //   ( 36)  D - 0x0044 Latin Capital Letter D
    {0x7F,0x49,0x49,0x49,0x41},     //   ( 37)  E - 0x0045 Latin Capital Letter E
    {0x7F,0x09,0x09,0x09,0x01},     //   ( 38)  F - 0x0046 Latin Capital Letter F
    {0x3E,0x41,0x49,0x49,0x7A},     //   ( 39)  G - 0x0047 Latin Capital Letter G
    {0x7F,0x08,0x08,0x08,0x7F},     //   ( 40)  H - 0x0048 Latin Capital Letter H
    {0x00,0x41,0x7F,0x41,0x00},     //   ( 41)  I - 0x0049 Latin Capital Letter I
    {0x20,0x40,0x41,0x3F,0x01},     //   ( 42)  J - 0x004A Latin Capital Letter J
    {0x7F,0x08,0x14,0x22,0x41},     //   ( 43)  K - 0x004B Latin Capital Letter K
    {0x7F,0x40,0x40,0x40,0x40},     //   ( 44)  L - 0x004C Latin Capital Letter L
    {0x7F,0x02,0x0C,0x02,0x7F},     //   ( 45)  M - 0x004D Latin Capital Letter M
    {0x7F,0x04,0x08,0x10,0x7F},     //   ( 46)  N - 0x004E Latin Capital Letter N
    {0x3E,0x41,0x41,0x41,0x3E},     //   ( 47)  O - 0x004F Latin Capital Letter O
    {0x7F,0x09,0x09,0x09,0x06},     //   ( 48)  P - 0x0050 Latin Capital Letter P
    {0x3E,0x41,0x51,0x21,0x5E},     //   ( 49)  Q - 0x0051 Latin Capital Letter Q
    {0x7F,0x09,0x19,0x29,0x46},     //   ( 50)  R - 0x0052 Latin Capital Letter R
    {0x46,0x49,0x49,0x49,0x31},     //   ( 51)  S - 0x0053 Latin Capital Letter S
    {0x01,0x01,0x7F,0x01,0x01},     //   ( 52)  T - 0x0054 Latin Capital Letter T
    {0x3F,0x40,0x40,0x40,0x3F},     //   ( 53)  U - 0x0055 Latin Capital Letter U
    {0x1F,0x20,0x40,0x20,0x1F},     //   ( 54)  V - 0x0056 Latin Capital Letter V
    {0x3F,0x40,0x38,0x40,0x3F},     //   ( 55)  W - 0x0057 Latin Capital Letter W
    {0x63,0x14,0x08,0x14,0x63},     //   ( 56)  X - 0x0058 Latin Capital Letter X
    {0x07,0x08,0x70,0x08,0x07},     //   ( 57)  Y - 0x0059 Latin Capital Letter Y
    {0x61,0x51,0x49,0x45,0x43},     //   ( 58)  Z - 0x005A Latin Capital Letter Z
    {0x00,0x7F,0x41,0x41,0x00},     //   ( 59)  [ - 0x005B Left Square Bracket
    {0x02,0x04,0x08,0x10,0x20},     //   ( 60)  \ - 0x005C Reverse Solidus
    {0x00,0x41,0x41,0x7F,0x00},     //   ( 61)  ] - 0x005D Right Square Bracket
    {0x04,0x02,0x01,0x02,0x04},     //   ( 62)  ^ - 0x005E Circumflex Accent
    {0x40,0x40,0x40,0x40,0x40},     //   ( 63)  _ - 0x005F Low Line
    {0x01,0x02,0x04,0x00,0x00},     //   ( 64)  ` - 0x0060 Grave Accent
    {0x20,0x54,0x54,0x54,0x78},     //   ( 65)  a - 0x0061 Latin Small Letter A
    {0x7F,0x48,0x44,0x44,0x38},     //   ( 66)  b - 0x0062 Latin Small Letter B
    {0x38,0x44,0x44,0x44,0x20},     //   ( 67)  c - 0x0063 Latin Small Letter C
    {0x38,0x44,0x44,0x48,0x7F},     //   ( 68)  d - 0x0064 Latin Small Letter D
    {0x38,0x54,0x54,0x54,0x18},     //   ( 69)  e - 0x0065 Latin Small Letter E
    {0x08,0x7E,0x09,0x01,0x02},     //   ( 70)  f - 0x0066 Latin Small Letter F
    {0x06,0x49,0x49,0x49,0x3F},     //   ( 71)  g - 0x0067 Latin Small Letter G
    {0x7F,0x08,0x04,0x04,0x78},     //   ( 72)  h - 0x0068 Latin Small Letter H
    {0x00,0x44,0x7D,0x40,0x00},     //   ( 73)  i - 0x0069 Latin Small Letter I
    {0x20,0x40,0x44,0x3D,0x00},     //   ( 74)  j - 0x006A Latin Small Letter J
    {0x7F,0x10,0x28,0x44,0x00},     //   ( 75)  k - 0x006B Latin Small Letter K
    {0x00,0x41,0x7F,0x40,0x00},     //   ( 76)  l - 0x006C Latin Small Letter L
    {0x7C,0x04,0x18,0x04,0x7C},     //   ( 77)  m - 0x006D Latin Small Letter M
    {0x7C,0x08,0x04,0x04,0x78},     //   ( 78)  n - 0x006E Latin Small Letter N
    {0x38,0x44,0x44,0x44,0x38},     //   ( 79)  o - 0x006F Latin Small Letter O
    {0x7C,0x14,0x14,0x14,0x08},     //   ( 80)  p - 0x0070 Latin Small Letter P
    {0x08,0x14,0x14,0x18,0x7C},     //   ( 81)  q - 0x0071 Latin Small Letter Q
    {0x7C,0x08,0x04,0x04,0x08},     //   ( 82)  r - 0x0072 Latin Small Letter R
    {0x48,0x54,0x54,0x54,0x20},     //   ( 83)  s - 0x0073 Latin Small Letter S
    {0x04,0x3F,0x44,0x40,0x20},     //   ( 84)  t - 0x0074 Latin Small Letter T
    {0x3C,0x40,0x40,0x20,0x7C},     //   ( 85)  u - 0x0075 Latin Small Letter U
    {0x1C,0x20,0x40,0x20,0x1C},     //   ( 86)  v - 0x0076 Latin Small Letter V
    {0x3C,0x40,0x30,0x40,0x3C},     //   ( 87)  w - 0x0077 Latin Small Letter W
    {0x44,0x28,0x10,0x28,0x44},     //   ( 88)  x - 0x0078 Latin Small Letter X
    {0x0C,0x50,0x50,0x50,0x3C},     //   ( 89)  y - 0x0079 Latin Small Letter Y
    {0x44,0x64,0x54,0x4C,0x44},     //   ( 90)  z - 0x007A Latin Small Letter Z
    {0x00,0x08,0x36,0x41,0x00},     //   ( 91)  { - 0x007B Left Curly Bracket
    {0x00,0x00,0x7F,0x00,0x00},     //   ( 92)  | - 0x007C Vertical Line
    {0x00,0x41,0x36,0x08,0x00},     //   ( 93)  } - 0x007D Right Curly Bracket
    {0x02,0x01,0x02,0x04,0x02},     //   ( 94)  ~ - 0x007E Tilde
    {0x08,0x0C,0x0E,0x0C,0x08},     //   ( 95)  upward facing triangle/arrow
    {0x08,0x18,0x38,0x18,0x08},     //   ( 96)  downward facing triangle/arrow
};

/*===============================*/
/*======= FONT TABLE 5x8 ========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******* CUSTOM CHARACTERS *******/
/************* START *************/
/*********************************/

const unsigned char A10pt [] = {	// 'A' (11 pixels wide)
	0x0E, 0x00, //     ###    
	0x0F, 0x00, //     ####   
	0x1B, 0x00, //    ## ##   
	0x1B, 0x00, //    ## ##   
	0x13, 0x80, //    #  ###  
	0x31, 0x80, //   ##   ##  
	0x3F, 0xC0, //   ######## 
	0x7F, 0xC0, //  ######### 
	0x60, 0xC0, //  ##     ## 
	0x60, 0xE0, //  ##     ###
	0xE0, 0xE0, // ###     ###
};
const unsigned char D10pt [] = {	// 'D' (9 pixels wide)
	0xFC, 0x00, // ######   
	0xFF, 0x00, // ######## 
	0xC7, 0x00, // ##   ### 
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC3, 0x80, // ##    ###
	0xC7, 0x00, // ##   ### 
	0xFE, 0x00, // #######  
	0xFC, 0x00, // ######
};
const unsigned char E10pt [] = {	// 'E' (7 pixels wide)
	0xFE, // #######
	0xFE, // #######
	0xC0, // ##     
	0xC0, // ##     
	0xFC, // ###### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char H10pt [] = {	// 'H' (8 pixels wide)
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xFF, // ########
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
};
const unsigned char I10pt [] = {	// 'I' (2 pixels wide)
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
};
const unsigned char L10pt [] = {	// 'L' (7 pixels wide)
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char N10pt [] = {	// 'N' (9 pixels wide)
	0xE1, 0x80, // ###    ##
	0xE1, 0x80, // ###    ##
	0xF1, 0x80, // ####   ##
	0xF9, 0x80, // #####  ##
	0xD9, 0x80, // ## ##  ##
	0xDD, 0x80, // ## ### ##
	0xCD, 0x80, // ##  ## ##
	0xC7, 0x80, // ##   ####
	0xC7, 0x80, // ##   ####
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
};
const unsigned char P10pt [] = {	// 'P' (8 pixels wide)
	0xFC, // ######  
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC7, // ##   ###
	0xFE, // ####### 
	0xF8, // #####   
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##
};
const unsigned char S10pt [] = {	// 'S' (7 pixels wide)
	0x7C, //  ##### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xF0, // ####   
	0x7C, //  ##### 
	0x1E, //    ####
	0x06, //      ##
	0x06, //      ##
	0xFE, // #######
	0xF8, // #####
};
const unsigned char V10pt [] = {	// 'V' (10 pixels wide)
	0xE0, 0xC0, // ###     ##
	0xE1, 0xC0, // ###    ###
	0x61, 0x80, //  ##    ## 
	0x71, 0x80, //  ###   ## 
	0x73, 0x00, //  ###  ##  
	0x33, 0x00, //   ##  ##  
	0x3B, 0x00, //   ### ##  
	0x1E, 0x00, //    ####   
	0x1E, 0x00, //    ####   
	0x1C, 0x00, //    ###    
	0x0C, 0x00, //     ##
};
const unsigned char W10pt [] = {	// 'W' (16 pixels wide)
	0xE1, 0x83, // ###    ##     ##
	0xE1, 0xC7, // ###    ###   ###
	0x63, 0xC6, //  ##   ####   ## 
	0x63, 0xC6, //  ##   ####   ## 
	0x72, 0xC6, //  ###  # ##   ## 
	0x32, 0x6C, //   ##  #  ## ##  
	0x36, 0x6C, //   ## ##  ## ##  
	0x3E, 0x6C, //   #####  ## ##  
	0x1C, 0x28, //    ###    # #   
	0x1C, 0x38, //    ###    ###   
	0x1C, 0x38, //    ###    ###
};
const unsigned char Y10pt [] = {	// 'Y' (8 pixels wide)
	0xE3, // ###   ##
	0x66, //  ##  ## 
	0x66, //  ##  ## 
	0x34, //   ## #  
	0x34, //   ## #  
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##
};

/*===============================*/
/*====== CUSTOM CHARACTERS ======*/
/*============= END =============*/
/*===============================*/


/*********************************/
/********** ICON BITMAP **********/
/************* START *************/
/*********************************/

const unsigned char smiley20x20[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x60, 0xa1, 0xca, 0x2e, 0x84, 0xb7, 0x0c, 0x70, 0xac, 
0x0c, 0x70, 0xae, 0x2f, 0x84, 0xb7, 0x60, 0xa1, 0xca, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0x91, 0xc1, 0x41, 0x9b, 0xc7, 0x61, 0xbf, 0xdd, 0x73, 0xdc, 0xef, 0x80, 0xef, 0xfb, 
0x7f, 0xef, 0xfb, 0x73, 0xdc, 0xef, 0x5f, 0xbf, 0xdd, 0x41, 0x9c, 0xc7, 0x41, 0x92, 0xc1, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x37, 0x95, 0xc5, 0x61, 0xc9, 0xe5, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 
0x7a, 0xf5, 0xfe, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x79, 0xf5, 0xfe, 0x5e, 0xca, 0xe5, 0x36, 0x94, 0xc5, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x3f, 0xa0, 0xcd, 0x65, 0xe0, 0xf3, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 
0x71, 0xf4, 0xfe, 0x70, 0xf3, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 0x64, 0xde, 0xf3, 0x3d, 0xa1, 0xcd, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x34, 0x98, 0xca, 0x5d, 0xde, 0xf4, 0x68, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x2c, 0x8f, 0xa2, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x2c, 0x8f, 0xa2, 0x68, 0xf2, 0xfe, 0x67, 0xf3, 0xfe, 0x67, 0xf2, 0xfe, 0x5b, 0xde, 0xf4, 0x33, 0x98, 0xca, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x22, 0x22, 0x22, 0x41, 0x9b, 0xcd, 0x4f, 0xcb, 0xe9, 0x5f, 0xf1, 0xfe, 0x5e, 0xf1, 0xfe, 0x3d, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xa6, 0xbe, 0xc6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xa6, 0xbe, 0xc6, 0x00, 0x46, 0x5d, 0x3e, 0xb5, 0xc6, 0x5f, 0xf1, 0xfe, 0x5f, 0xf1, 0xfe, 0x4c, 0xcb, 0xe9, 0x40, 0x9b, 0xcd, 0x22, 0x22, 0x22, 
0x00, 0x3e, 0x44, 0x38, 0xa5, 0xd5, 0x56, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfc, 0xf6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x37, 0xb4, 0xc6, 0x55, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xa5, 0xd4, 0x00, 0x3e, 0x44, 
0x60, 0xb0, 0xda, 0x40, 0xc4, 0xe7, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x3f, 0xc4, 0xe8, 0x60, 0xb0, 0xda, 
0x30, 0x9c, 0xd3, 0x3e, 0xdb, 0xf5, 0x44, 0xed, 0xfe, 0x44, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x44, 0xed, 0xfe, 0x43, 0xed, 0xfe, 0x3d, 0xda, 0xf5, 0x2f, 0x9c, 0xd3, 
0x0e, 0x8f, 0xd0, 0x39, 0xe8, 0xfd, 0x3b, 0xec, 0xfe, 0x3e, 0xed, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x3f, 0xed, 0xfe, 0x3a, 0xec, 0xfe, 0x38, 0xe8, 0xfd, 0x0e, 0x8f, 0xd0, 
0x0e, 0x94, 0xd5, 0x30, 0xe7, 0xfe, 0x32, 0xeb, 0xfe, 0x4a, 0xee, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 
0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x64, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 0x4a, 0xee, 0xfe, 0x32, 0xeb, 0xfe, 0x30, 0xe7, 0xfd, 0x0e, 0x94, 0xd4, 
0x30, 0xa6, 0xe0, 0x2a, 0xda, 0xf8, 0x2a, 0xe9, 0xfe, 0x60, 0xf1, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 
0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x60, 0xf1, 0xfe, 0x2a, 0xea, 0xfe, 0x29, 0xda, 0xf8, 0x30, 0xa7, 0xde, 
0x61, 0xbe, 0xea, 0x2c, 0xca, 0xf1, 0x23, 0xe9, 0xfe, 0x7b, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 
0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7b, 0xf4, 0xfe, 0x23, 0xe9, 0xfe, 0x2c, 0xc9, 0xf1, 0x61, 0xbe, 0xe9, 
0x00, 0x3e, 0x44, 0x2e, 0xb9, 0xeb, 0x1b, 0xe8, 0xfe, 0x74, 0xf4, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 
0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x74, 0xf4, 0xfe, 0x1b, 0xe7, 0xfe, 0x2d, 0xba, 0xeb, 0x00, 0x3e, 0x44, 
0x22, 0x22, 0x22, 0x40, 0xb9, 0xec, 0x21, 0xd1, 0xf6, 0x56, 0xf0, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 
0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x57, 0xf0, 0xfe, 0x21, 0xd1, 0xf6, 0x3f, 0xb9, 0xec, 0x22, 0x22, 0x22, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2a, 0xb9, 0xef, 0x24, 0xde, 0xfc, 0x79, 0xf5, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 
0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0x79, 0xf5, 0xfe, 0x24, 0xde, 0xfc, 0x2a, 0xb9, 0xef, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2b, 0xc1, 0xf3, 0x29, 0xdf, 0xfd, 0x74, 0xf4, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 
0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0x74, 0xf4, 0xfe, 0x28, 0xe0, 0xfd, 0x2a, 0xc1, 0xf3, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x28, 0xbf, 0xf3, 0x1a, 0xd4, 0xfa, 0x41, 0xec, 0xfe, 0x74, 0xf4, 0xfe, 0x9e, 0xfa, 0xfe, 0xbb, 0xfe, 0xfe, 
0xbb, 0xfe, 0xfe, 0x9e, 0xfa, 0xfe, 0x74, 0xf4, 0xfe, 0x42, 0xec, 0xfe, 0x19, 0xd3, 0xfa, 0x29, 0xbf, 0xf4, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0xc3, 0xf5, 0x2a, 0xc4, 0xf6, 0x1b, 0xd1, 0xfa, 0x0a, 0xdb, 0xfd, 0x01, 0xe2, 0xfe, 
0x01, 0xe2, 0xfe, 0x0a, 0xdb, 0xfd, 0x1b, 0xd1, 0xfa, 0x29, 0xc5, 0xf7, 0x41, 0xc3, 0xf6, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x62, 0xce, 0xf9, 0x32, 0xbe, 0xf6, 0x10, 0xb3, 0xf5, 
0x10, 0xb3, 0xf5, 0x32, 0xbe, 0xf6, 0x62, 0xce, 0xf9, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/*===============================*/
/*========= ICON BITMAP =========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/****** LOW LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Command_12896RGB(unsigned char c)        // send command to OLED
{  
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((c & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   c = c << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
} 

void OLED_Data_12896RGB(unsigned char d)        // send data to OLED
{ 
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((d & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   d = d << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
}

void OLED_SetColumnAddress_12896RGB(unsigned char x_start, unsigned char x_end)    // set column address start + end
{
   OLED_Command_12896RGB(0x15);
   OLED_Data_12896RGB(x_start);
   OLED_Data_12896RGB(x_end);
}

void OLED_SetRowAddress_12896RGB(unsigned char y_start, unsigned char y_end)    // set row address start + end
{
   OLED_Command_12896RGB(0x75);
   OLED_Data_12896RGB(y_start);
   OLED_Data_12896RGB(y_end);
}

void OLED_WriteMemoryStart_12896RGB(void)    // write to RAM command
{
    OLED_Command_12896RGB(0x5C);
}

void OLED_Pixel_12896RGB(unsigned long color)    // write one pixel of a given color
{
        OLED_Data_12896RGB((color>>16));
        OLED_Data_12896RGB((color>>8));
        OLED_Data_12896RGB(color);
}

void OLED_FillScreen_12896RGB(unsigned long color)    // fill screen with a given color
{
   unsigned int i,j;
   OLED_SetColumnAddress_12896RGB(0x00, 0x7F);
   OLED_SetRowAddress_12896RGB(0x00, 0x5F);
   OLED_WriteMemoryStart_12896RGB();
   for(i=0;i<96;i++)
   {
      for(j=0;j<128;j++)
      {
	 OLED_Pixel_12896RGB(color);
      }
   }
}

/*===============================*/
/*===== LOW LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/***** HIGH LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Text_12896RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=0;i<8;i++)     //each character is 8 px tall
    {
        OLED_SetColumnAddress_12896RGB(x_pos, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<5;count++)    //each character is 5px wide
        {
            if((Ascii_1[letter][count] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
        }
        y_pos++;
        mask = mask >> 1;
   }
}

void OLED_Text2x_12896RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text (2x size)
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=1;i<=16;i++)     // each character is 16 pixels tall
    {
        OLED_SetColumnAddress_12896RGB(x_pos, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<10;count++)    // each character is 10 pixels wide
        {
            if((Ascii_1[letter][(count/2)] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
        }
        y_pos++;
        if((i%2)==0)
        {
          mask = mask >> 1;
        }
   }
}

void OLED_NHDText_12896RGB(unsigned long textColor, unsigned long backgroundColor)    // function to show NEWHAVEN DISPLAY
{
    int i;
    int count;
    unsigned char index = 0;
    unsigned char y_pos = 88;
    unsigned char mask = 0x80;
    
    for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_12896RGB(11, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_12896RGB(25, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character W
    {
        OLED_SetColumnAddress_12896RGB(36, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character H
    {
        OLED_SetColumnAddress_12896RGB(56, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((H10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_12896RGB(68, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character V
    {
        OLED_SetColumnAddress_12896RGB(81, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_12896RGB(95, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 88;
   
   for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_12896RGB(107, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;  
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character D
    {
        OLED_SetColumnAddress_12896RGB(25, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character I
    {
        OLED_SetColumnAddress_12896RGB(39, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((I10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character S
    {
        OLED_SetColumnAddress_12896RGB(46, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((S10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character P
    {
        OLED_SetColumnAddress_12896RGB(57, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((P10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character L
    {
        OLED_SetColumnAddress_12896RGB(69, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((L10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_12896RGB(80, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 74;
   
   for(i=0;i<11;i++)     // display custom character Y
    {
        OLED_SetColumnAddress_12896RGB(94, 0x7F);
        OLED_SetRowAddress_12896RGB(y_pos, 0x5F);
        OLED_WriteMemoryStart_12896RGB();
        for (count=0;count<8;count++)
        {
            if((Y10pt[index] & mask) == mask)
                OLED_Pixel_12896RGB(textColor);
            else
                OLED_Pixel_12896RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
}

void OLED_Icon_12896RGB(unsigned char x_pos, unsigned char y_pos)    // function to show icon
{
   unsigned int i, j;
   unsigned int height = 20;
   unsigned int width  = 20;
   
   OLED_SetColumnAddress_12896RGB(x_pos, (x_pos+width-1));
   OLED_SetRowAddress_12896RGB(y_pos, (y_pos+height-1));
   OLED_WriteMemoryStart_12896RGB();
   for(j=0;j<(height*width*3);j+=3)
   {
      OLED_Data_12896RGB(smiley20x20[j]>>2);
      OLED_Data_12896RGB(smiley20x20[(j+1)]>>2);
      OLED_Data_12896RGB(smiley20x20[(j+2)]>>2);
   }
}

void OLED_Spectrum_12896RGB(void)                  // function to show color spectrum
{
      unsigned char i, j;
      unsigned char blue, green, red;
      
      OLED_SetColumnAddress_12896RGB(0, 127);
      OLED_SetRowAddress_12896RGB(0, 27);
      OLED_WriteMemoryStart_12896RGB();
      for(i=0;i<128;i++)
      {
        OLED_Pixel_12896RGB(WHITE);
      }
      for(i=0;i<26;i++)
      {
        blue = 0x00;
        green = 0x00;
        red = 0x3F;
        OLED_Pixel_12896RGB(WHITE);
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          green += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          red -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          blue += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          green -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          red += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_12896RGB(blue);
          OLED_Data_12896RGB(green);
          OLED_Data_12896RGB(red);
          blue -= 3;
        }
        OLED_Pixel_12896RGB(WHITE);
      }
      for(i=0;i<128;i++)
      {
        OLED_Pixel_12896RGB(WHITE);
      }
}

/*===============================*/
/*==== HIGH LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******** INITIALIZATION *********/
/************ START **************/
/*********************************/

void OLED_Init_12896RGB(void)      //OLED initialization
{
    digitalWrite(RES_PIN, LOW);
    delay(500);
    digitalWrite(RES_PIN, HIGH);
    delay(500);

    OLED_Command_12896RGB(0xFD);	// Command lock setting
    OLED_Data_12896RGB(0x12);		// unlock
    OLED_Command_12896RGB(0xFD);	// Command lock setting
    OLED_Data_12896RGB(0xB1);		// unlock
    OLED_Command_12896RGB(0xAE);
    OLED_Command_12896RGB(0xB3);	// clock & frequency
    OLED_Data_12896RGB(0xF1);		// clock=Diviser+1 frequency=fh 
    OLED_Command_12896RGB(0xCA);	// Duty
    OLED_Data_12896RGB(0x7F);		// OLED _END+1
    OLED_Command_12896RGB(0xA2);  	// Display offset
    OLED_Data_12896RGB(0x00);
    OLED_Command_12896RGB(0xA1);	// Set display start line
    OLED_Data_12896RGB(0x00);		// 0x00 start line
    OLED_Command_12896RGB(0xA0);	// Set Re-map, color depth
    OLED_Data_12896RGB(0xA0);		// 8-bit 262K
    OLED_Command_12896RGB(0xB5);	// set GPIO
    OLED_Data_12896RGB(0x00);		// disabled
    OLED_Command_12896RGB(0xAB);	// Function Set
    OLED_Data_12896RGB(0x01);		// 8-bit interface, internal VDD regulator
    OLED_Command_12896RGB(0xB4);	// set VSL
    OLED_Data_12896RGB(0xA0);		// external VSL
    OLED_Data_12896RGB(0xB5);
    OLED_Data_12896RGB(0x55);
    OLED_Command_12896RGB(0xC1);	// Set contrast current for A,B,C
    OLED_Data_12896RGB(0x8A);		// Color A
    OLED_Data_12896RGB(0x70);		// Color B
    OLED_Data_12896RGB(0x8A);		// Color C
    OLED_Command_12896RGB(0xC7);	// Set master contrast
    OLED_Data_12896RGB(0x0F);		//	
    OLED_Command_12896RGB(0xB9);	// use linear grayscale LUT
    OLED_Command_12896RGB(0xB1);	// Set pre & dis-charge
    OLED_Data_12896RGB(0x32);		// pre=1h, dis=1h  
    OLED_Command_12896RGB(0xBB);	// Set precharge voltage of color A,B,C
    OLED_Data_12896RGB(0x07);		//
    OLED_Command_12896RGB(0xB2);        // display enhancement
    OLED_Data_12896RGB(0xa4);		
    OLED_Data_12896RGB(0x00);
    OLED_Data_12896RGB(0x00);
    OLED_Command_12896RGB(0xB6);	// precharge period
    OLED_Data_12896RGB(0x01);		
    OLED_Command_12896RGB(0xBE);	// Set VcomH
    OLED_Data_12896RGB(0x07);
    OLED_Command_12896RGB(0xA6);	// Normal display
    OLED_Command_12896RGB(0xAF);	// Display on
}

/*===============================*/
/*======= INITIALIZATION ========*/
/*============= END =============*/
/*===============================*/

void setup()                                       // for Arduino, runs first at power on
{
   pinMode(LVL_OEN, OUTPUT);                       // configure LVL_OEN as output
   digitalWrite(LVL_OEN, LOW);
   pinMode(LVL_DIR, OUTPUT);                       // configure LVL_DIR as output
   digitalWrite(LVL_DIR, HIGH);
   DDRD = 0xFF;                                    // configure PORTD as output
   pinMode(RS_PIN, OUTPUT);                        // configure RS_PIN as output
   pinMode(RES_PIN, OUTPUT);                       // configure RES_PIN as output
   pinMode(CS_PIN, OUTPUT);                        // configure CS_PIN as output
   pinMode(BS0_PIN, OUTPUT);                       // configure BS0_PIN as output
   pinMode(BS1_PIN, OUTPUT);                       // configure BS1_PIN as output
   digitalWrite(CS_PIN, HIGH);                     // set CS_PIN
   switch(interface)
   {
     case 0:
       pinMode(RW_PIN, OUTPUT);                    // configure RW_PIN as output
       pinMode(E_PIN, OUTPUT);                     // configure E_PIN as output
       digitalWrite(BS0_PIN, HIGH);                // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // set BS1_PIN
       digitalWrite(RW_PIN, LOW);                  // reset RW_PIN
       digitalWrite(E_PIN, HIGH);                  // set E_PIN
       break;
     case 1: 
       pinMode(WR_PIN, OUTPUT);                    // configure WR_PIN as output
       pinMode(RD_PIN, OUTPUT);                    // configure RD_PIN as output
       digitalWrite(BS0_PIN, LOW);                 // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // reset BS1_PIN
       digitalWrite(WR_PIN, HIGH);                 // set WR_PIN
       digitalWrite(RD_PIN, HIGH);                 // set RD_PIN
       break;
     case 2:
       pinMode(SDI_PIN, OUTPUT);                   // configure SDI_PIN as output
       pinMode(SCL_PIN, OUTPUT);                   // configure SCL_PIN as output
       PORTD = 0x00;                               // reset SDI_PIN and SCL_PIN, ground DB[5..0] of the display
       digitalWrite(BS0_PIN, LOW);                 // reset BS0_PIN
       digitalWrite(BS1_PIN, LOW);                 // reset BS1_PIN
       digitalWrite(WR_PIN, LOW);                  // reset WR_PIN
       digitalWrite(RD_PIN, LOW);                  // reset RD_PIN
       break;
     default:
       break;
   }
}

void loop()                                        // main loop, runs after "setup()"
{  
   OLED_Init_12896RGB();                           // initialize display
   
   OLED_FillScreen_12896RGB(BLACK);                // fill screen with black
   
   OLED_NHDText_12896RGB(GREEN, BLACK);            // show NEWHAVEN DISPLAY
   
   OLED_Text_12896RGB(10, 41, 40, WHITE, BLACK);   // H
   OLED_Text_12896RGB(17, 41, 69, WHITE, BLACK);   // e
   OLED_Text_12896RGB(24, 41, 76, WHITE, BLACK);   // l
   OLED_Text_12896RGB(31, 41, 76, WHITE, BLACK);   // l
   OLED_Text_12896RGB(38, 41, 79, WHITE, BLACK);   // o
   OLED_Text_12896RGB(45, 41, 0, WHITE, BLACK);    //
      
   OLED_Text_12896RGB(52, 41, 55, WHITE, BLACK);   // W
   OLED_Text_12896RGB(59, 41, 79, WHITE, BLACK);   // o
   OLED_Text_12896RGB(66, 41, 82, WHITE, BLACK);   // r
   OLED_Text_12896RGB(73, 41, 76, WHITE, BLACK);   // l
   OLED_Text_12896RGB(80, 41, 68, WHITE, BLACK);   // d
   OLED_Text_12896RGB(87, 41, 1, WHITE, BLACK);    // !
   
   OLED_Icon_12896RGB(102, 35);                    // show icon
   
   OLED_Spectrum_12896RGB();                       // show color spectrum
   
   while(1);                                       // wait here forever
}

NHD-1.5-AU-SHIELD

Direct Link

//---------------------------------------------------------
/*

NHD-1.5-AU-SHIELD.ino

Program for writing to Newhaven Display's 128x128 Graphic Color OLED with SSD1351 controller.

This code is written for the Arduino Uno R3.

Copyright (c) 2015 - Newhaven Display International, Inc.

Newhaven Display invests time and resources providing this open source code,
please support Newhaven Display by purchasing products from Newhaven Display!

*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTD[7..0]

#define   SDI_PIN    11    // SDI (serial mode) signal connected to pin 11
#define   SCL_PIN    13    // SCL (serial mdoe) signal connected to pin 13
#define    RS_PIN    4    // RS signal connected to pin 4
#define    RW_PIN    9    // R/W (6800 mode) signal connected to pin 9
#define    WR_PIN    9    // /WR (8080 mode) signal connected to pin 9
#define     E_PIN   10    // E (6800 mode) signal connected to pin 10
#define    RD_PIN   10    // /RD (8080 mode) signal connected to pin 10
#define   RES_PIN   6    // /RES signal connected to pin 6
#define    CS_PIN   5    // /CS signal connected to pin 5
#define   BS1_PIN   A0    // BS1 signal connected to pin A0
#define   BS0_PIN   A1    // BS0 signal connected to pin A1
#define   LVL_DIR   A2    // DIR (direction control) signal of level shifter IC connected to pin A2
#define   LVL_OEN   A3    // /OE (output enable) signal of level shifter IC connected to pin A3

#define    RED  0x0000FF
#define  GREEN  0x00FF00
#define   BLUE  0xFF0000
#define  WHITE  0xFFFFFF
#define  BLACK  0x000000


/*********************************/
/****** INTERFACE SELECTION ******/
/*********************************/

 const unsigned char interface = 2;    // 0 = 8-bit parallel (6800 mode) interface; 1 = 8-bit parallel (8080 mode) interface; 2 = 4-wire SPI interface
 
/*===============================*/
/*===============================*/
/*===============================*/


/*********************************/
/******** FONT TABLE 5x8 *********/
/************* START *************/
/*********************************/

unsigned char Ascii_1[97][5] = {     // Refer to "Times New Roman" Font Database...
                        //   Basic Characters
    {0x00,0x00,0x00,0x00,0x00},     //   (  0)    - 0x0000 Empty set
    {0x00,0x00,0x4F,0x00,0x00},     //   (  1)  ! - 0x0021 Exclamation Mark
    {0x00,0x07,0x00,0x07,0x00},     //   (  2)  " - 0x0022 Quotation Mark
    {0x14,0x7F,0x14,0x7F,0x14},     //   (  3)  # - 0x0023 Number Sign
    {0x24,0x2A,0x7F,0x2A,0x12},     //   (  4)  $ - 0x0024 Dollar Sign
    {0x23,0x13,0x08,0x64,0x62},     //   (  5)  % - 0x0025 Percent Sign
    {0x36,0x49,0x55,0x22,0x50},     //   (  6)  & - 0x0026 Ampersand
    {0x00,0x05,0x03,0x00,0x00},     //   (  7)  ' - 0x0027 Apostrophe
    {0x00,0x1C,0x22,0x41,0x00},     //   (  8)  ( - 0x0028 Left Parenthesis
    {0x00,0x41,0x22,0x1C,0x00},     //   (  9)  ) - 0x0029 Right Parenthesis
    {0x14,0x08,0x3E,0x08,0x14},     //   ( 10)  * - 0x002A Asterisk
    {0x08,0x08,0x3E,0x08,0x08},     //   ( 11)  + - 0x002B Plus Sign
    {0x00,0x50,0x30,0x00,0x00},     //   ( 12)  , - 0x002C Comma
    {0x08,0x08,0x08,0x08,0x08},     //   ( 13)  - - 0x002D Hyphen-Minus
    {0x00,0x60,0x60,0x00,0x00},     //   ( 14)  . - 0x002E Full Stop
    {0x20,0x10,0x08,0x04,0x02},     //   ( 15)  / - 0x002F Solidus
    {0x3E,0x51,0x49,0x45,0x3E},     //   ( 16)  0 - 0x0030 Digit Zero
    {0x00,0x42,0x7F,0x40,0x00},     //   ( 17)  1 - 0x0031 Digit One
    {0x42,0x61,0x51,0x49,0x46},     //   ( 18)  2 - 0x0032 Digit Two
    {0x21,0x41,0x45,0x4B,0x31},     //   ( 19)  3 - 0x0033 Digit Three
    {0x18,0x14,0x12,0x7F,0x10},     //   ( 20)  4 - 0x0034 Digit Four
    {0x27,0x45,0x45,0x45,0x39},     //   ( 21)  5 - 0x0035 Digit Five
    {0x3C,0x4A,0x49,0x49,0x30},     //   ( 22)  6 - 0x0036 Digit Six
    {0x01,0x71,0x09,0x05,0x03},     //   ( 23)  7 - 0x0037 Digit Seven
    {0x36,0x49,0x49,0x49,0x36},     //   ( 24)  8 - 0x0038 Digit Eight
    {0x06,0x49,0x49,0x29,0x1E},     //   ( 25)  9 - 0x0039 Dight Nine
    {0x00,0x36,0x36,0x00,0x00},     //   ( 26)  : - 0x003A Colon
    {0x00,0x56,0x36,0x00,0x00},     //   ( 27)  ; - 0x003B Semicolon
    {0x08,0x14,0x22,0x41,0x00},     //   ( 28)  < - 0x003C Less-Than Sign
    {0x14,0x14,0x14,0x14,0x14},     //   ( 29)  = - 0x003D Equals Sign
    {0x00,0x41,0x22,0x14,0x08},     //   ( 30)  > - 0x003E Greater-Than Sign
    {0x02,0x01,0x51,0x09,0x06},     //   ( 31)  ? - 0x003F Question Mark
    {0x32,0x49,0x79,0x41,0x3E},     //   ( 32)  @ - 0x0040 Commercial At
    {0x7E,0x11,0x11,0x11,0x7E},     //   ( 33)  A - 0x0041 Latin Capital Letter A
    {0x7F,0x49,0x49,0x49,0x36},     //   ( 34)  B - 0x0042 Latin Capital Letter B
    {0x3E,0x41,0x41,0x41,0x22},     //   ( 35)  C - 0x0043 Latin Capital Letter C
    {0x7F,0x41,0x41,0x22,0x1C},     //   ( 36)  D - 0x0044 Latin Capital Letter D
    {0x7F,0x49,0x49,0x49,0x41},     //   ( 37)  E - 0x0045 Latin Capital Letter E
    {0x7F,0x09,0x09,0x09,0x01},     //   ( 38)  F - 0x0046 Latin Capital Letter F
    {0x3E,0x41,0x49,0x49,0x7A},     //   ( 39)  G - 0x0047 Latin Capital Letter G
    {0x7F,0x08,0x08,0x08,0x7F},     //   ( 40)  H - 0x0048 Latin Capital Letter H
    {0x00,0x41,0x7F,0x41,0x00},     //   ( 41)  I - 0x0049 Latin Capital Letter I
    {0x20,0x40,0x41,0x3F,0x01},     //   ( 42)  J - 0x004A Latin Capital Letter J
    {0x7F,0x08,0x14,0x22,0x41},     //   ( 43)  K - 0x004B Latin Capital Letter K
    {0x7F,0x40,0x40,0x40,0x40},     //   ( 44)  L - 0x004C Latin Capital Letter L
    {0x7F,0x02,0x0C,0x02,0x7F},     //   ( 45)  M - 0x004D Latin Capital Letter M
    {0x7F,0x04,0x08,0x10,0x7F},     //   ( 46)  N - 0x004E Latin Capital Letter N
    {0x3E,0x41,0x41,0x41,0x3E},     //   ( 47)  O - 0x004F Latin Capital Letter O
    {0x7F,0x09,0x09,0x09,0x06},     //   ( 48)  P - 0x0050 Latin Capital Letter P
    {0x3E,0x41,0x51,0x21,0x5E},     //   ( 49)  Q - 0x0051 Latin Capital Letter Q
    {0x7F,0x09,0x19,0x29,0x46},     //   ( 50)  R - 0x0052 Latin Capital Letter R
    {0x46,0x49,0x49,0x49,0x31},     //   ( 51)  S - 0x0053 Latin Capital Letter S
    {0x01,0x01,0x7F,0x01,0x01},     //   ( 52)  T - 0x0054 Latin Capital Letter T
    {0x3F,0x40,0x40,0x40,0x3F},     //   ( 53)  U - 0x0055 Latin Capital Letter U
    {0x1F,0x20,0x40,0x20,0x1F},     //   ( 54)  V - 0x0056 Latin Capital Letter V
    {0x3F,0x40,0x38,0x40,0x3F},     //   ( 55)  W - 0x0057 Latin Capital Letter W
    {0x63,0x14,0x08,0x14,0x63},     //   ( 56)  X - 0x0058 Latin Capital Letter X
    {0x07,0x08,0x70,0x08,0x07},     //   ( 57)  Y - 0x0059 Latin Capital Letter Y
    {0x61,0x51,0x49,0x45,0x43},     //   ( 58)  Z - 0x005A Latin Capital Letter Z
    {0x00,0x7F,0x41,0x41,0x00},     //   ( 59)  [ - 0x005B Left Square Bracket
    {0x02,0x04,0x08,0x10,0x20},     //   ( 60)  \ - 0x005C Reverse Solidus
    {0x00,0x41,0x41,0x7F,0x00},     //   ( 61)  ] - 0x005D Right Square Bracket
    {0x04,0x02,0x01,0x02,0x04},     //   ( 62)  ^ - 0x005E Circumflex Accent
    {0x40,0x40,0x40,0x40,0x40},     //   ( 63)  _ - 0x005F Low Line
    {0x01,0x02,0x04,0x00,0x00},     //   ( 64)  ` - 0x0060 Grave Accent
    {0x20,0x54,0x54,0x54,0x78},     //   ( 65)  a - 0x0061 Latin Small Letter A
    {0x7F,0x48,0x44,0x44,0x38},     //   ( 66)  b - 0x0062 Latin Small Letter B
    {0x38,0x44,0x44,0x44,0x20},     //   ( 67)  c - 0x0063 Latin Small Letter C
    {0x38,0x44,0x44,0x48,0x7F},     //   ( 68)  d - 0x0064 Latin Small Letter D
    {0x38,0x54,0x54,0x54,0x18},     //   ( 69)  e - 0x0065 Latin Small Letter E
    {0x08,0x7E,0x09,0x01,0x02},     //   ( 70)  f - 0x0066 Latin Small Letter F
    {0x06,0x49,0x49,0x49,0x3F},     //   ( 71)  g - 0x0067 Latin Small Letter G
    {0x7F,0x08,0x04,0x04,0x78},     //   ( 72)  h - 0x0068 Latin Small Letter H
    {0x00,0x44,0x7D,0x40,0x00},     //   ( 73)  i - 0x0069 Latin Small Letter I
    {0x20,0x40,0x44,0x3D,0x00},     //   ( 74)  j - 0x006A Latin Small Letter J
    {0x7F,0x10,0x28,0x44,0x00},     //   ( 75)  k - 0x006B Latin Small Letter K
    {0x00,0x41,0x7F,0x40,0x00},     //   ( 76)  l - 0x006C Latin Small Letter L
    {0x7C,0x04,0x18,0x04,0x7C},     //   ( 77)  m - 0x006D Latin Small Letter M
    {0x7C,0x08,0x04,0x04,0x78},     //   ( 78)  n - 0x006E Latin Small Letter N
    {0x38,0x44,0x44,0x44,0x38},     //   ( 79)  o - 0x006F Latin Small Letter O
    {0x7C,0x14,0x14,0x14,0x08},     //   ( 80)  p - 0x0070 Latin Small Letter P
    {0x08,0x14,0x14,0x18,0x7C},     //   ( 81)  q - 0x0071 Latin Small Letter Q
    {0x7C,0x08,0x04,0x04,0x08},     //   ( 82)  r - 0x0072 Latin Small Letter R
    {0x48,0x54,0x54,0x54,0x20},     //   ( 83)  s - 0x0073 Latin Small Letter S
    {0x04,0x3F,0x44,0x40,0x20},     //   ( 84)  t - 0x0074 Latin Small Letter T
    {0x3C,0x40,0x40,0x20,0x7C},     //   ( 85)  u - 0x0075 Latin Small Letter U
    {0x1C,0x20,0x40,0x20,0x1C},     //   ( 86)  v - 0x0076 Latin Small Letter V
    {0x3C,0x40,0x30,0x40,0x3C},     //   ( 87)  w - 0x0077 Latin Small Letter W
    {0x44,0x28,0x10,0x28,0x44},     //   ( 88)  x - 0x0078 Latin Small Letter X
    {0x0C,0x50,0x50,0x50,0x3C},     //   ( 89)  y - 0x0079 Latin Small Letter Y
    {0x44,0x64,0x54,0x4C,0x44},     //   ( 90)  z - 0x007A Latin Small Letter Z
    {0x00,0x08,0x36,0x41,0x00},     //   ( 91)  { - 0x007B Left Curly Bracket
    {0x00,0x00,0x7F,0x00,0x00},     //   ( 92)  | - 0x007C Vertical Line
    {0x00,0x41,0x36,0x08,0x00},     //   ( 93)  } - 0x007D Right Curly Bracket
    {0x02,0x01,0x02,0x04,0x02},     //   ( 94)  ~ - 0x007E Tilde
    {0x08,0x0C,0x0E,0x0C,0x08},     //   ( 95)  upward facing triangle/arrow
    {0x08,0x18,0x38,0x18,0x08},     //   ( 96)  downward facing triangle/arrow
};

/*===============================*/
/*======= FONT TABLE 5x8 ========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******* CUSTOM CHARACTERS *******/
/************* START *************/
/*********************************/

const unsigned char A10pt [] = {	// 'A' (11 pixels wide)
	0x0E, 0x00, //     ###    
	0x0F, 0x00, //     ####   
	0x1B, 0x00, //    ## ##   
	0x1B, 0x00, //    ## ##   
	0x13, 0x80, //    #  ###  
	0x31, 0x80, //   ##   ##  
	0x3F, 0xC0, //   ######## 
	0x7F, 0xC0, //  ######### 
	0x60, 0xC0, //  ##     ## 
	0x60, 0xE0, //  ##     ###
	0xE0, 0xE0, // ###     ###
};
const unsigned char D10pt [] = {	// 'D' (9 pixels wide)
	0xFC, 0x00, // ######   
	0xFF, 0x00, // ######## 
	0xC7, 0x00, // ##   ### 
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC1, 0x80, // ##     ##
	0xC3, 0x80, // ##    ###
	0xC7, 0x00, // ##   ### 
	0xFE, 0x00, // #######  
	0xFC, 0x00, // ######
};
const unsigned char E10pt [] = {	// 'E' (7 pixels wide)
	0xFE, // #######
	0xFE, // #######
	0xC0, // ##     
	0xC0, // ##     
	0xFC, // ###### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char H10pt [] = {	// 'H' (8 pixels wide)
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xFF, // ########
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC3, // ##    ##
};
const unsigned char I10pt [] = {	// 'I' (2 pixels wide)
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
	0xC0, // ##
};
const unsigned char L10pt [] = {	// 'L' (7 pixels wide)
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xC0, // ##     
	0xFE, // #######
	0xFE, // #######
};
const unsigned char N10pt [] = {	// 'N' (9 pixels wide)
	0xE1, 0x80, // ###    ##
	0xE1, 0x80, // ###    ##
	0xF1, 0x80, // ####   ##
	0xF9, 0x80, // #####  ##
	0xD9, 0x80, // ## ##  ##
	0xDD, 0x80, // ## ### ##
	0xCD, 0x80, // ##  ## ##
	0xC7, 0x80, // ##   ####
	0xC7, 0x80, // ##   ####
	0xC3, 0x80, // ##    ###
	0xC1, 0x80, // ##     ##
};
const unsigned char P10pt [] = {	// 'P' (8 pixels wide)
	0xFC, // ######  
	0xFF, // ########
	0xC3, // ##    ##
	0xC3, // ##    ##
	0xC7, // ##   ###
	0xFE, // ####### 
	0xF8, // #####   
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##      
	0xC0, // ##
};
const unsigned char S10pt [] = {	// 'S' (7 pixels wide)
	0x7C, //  ##### 
	0xFC, // ###### 
	0xC0, // ##     
	0xC0, // ##     
	0xF0, // ####   
	0x7C, //  ##### 
	0x1E, //    ####
	0x06, //      ##
	0x06, //      ##
	0xFE, // #######
	0xF8, // #####
};
const unsigned char V10pt [] = {	// 'V' (10 pixels wide)
	0xE0, 0xC0, // ###     ##
	0xE1, 0xC0, // ###    ###
	0x61, 0x80, //  ##    ## 
	0x71, 0x80, //  ###   ## 
	0x73, 0x00, //  ###  ##  
	0x33, 0x00, //   ##  ##  
	0x3B, 0x00, //   ### ##  
	0x1E, 0x00, //    ####   
	0x1E, 0x00, //    ####   
	0x1C, 0x00, //    ###    
	0x0C, 0x00, //     ##
};
const unsigned char W10pt [] = {	// 'W' (16 pixels wide)
	0xE1, 0x83, // ###    ##     ##
	0xE1, 0xC7, // ###    ###   ###
	0x63, 0xC6, //  ##   ####   ## 
	0x63, 0xC6, //  ##   ####   ## 
	0x72, 0xC6, //  ###  # ##   ## 
	0x32, 0x6C, //   ##  #  ## ##  
	0x36, 0x6C, //   ## ##  ## ##  
	0x3E, 0x6C, //   #####  ## ##  
	0x1C, 0x28, //    ###    # #   
	0x1C, 0x38, //    ###    ###   
	0x1C, 0x38, //    ###    ###
};
const unsigned char Y10pt [] = {	// 'Y' (8 pixels wide)
	0xE3, // ###   ##
	0x66, //  ##  ## 
	0x66, //  ##  ## 
	0x34, //   ## #  
	0x34, //   ## #  
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##   
	0x18, //    ##
};

/*===============================*/
/*====== CUSTOM CHARACTERS ======*/
/*============= END =============*/
/*===============================*/


/*********************************/
/********** ICON BITMAP **********/
/************* START *************/
/*********************************/

const unsigned char smiley20x20[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x60, 0xa1, 0xca, 0x2e, 0x84, 0xb7, 0x0c, 0x70, 0xac, 
0x0c, 0x70, 0xae, 0x2f, 0x84, 0xb7, 0x60, 0xa1, 0xca, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0x91, 0xc1, 0x41, 0x9b, 0xc7, 0x61, 0xbf, 0xdd, 0x73, 0xdc, 0xef, 0x80, 0xef, 0xfb, 
0x7f, 0xef, 0xfb, 0x73, 0xdc, 0xef, 0x5f, 0xbf, 0xdd, 0x41, 0x9c, 0xc7, 0x41, 0x92, 0xc1, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x37, 0x95, 0xc5, 0x61, 0xc9, 0xe5, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 
0x7a, 0xf5, 0xfe, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x79, 0xf5, 0xfe, 0x5e, 0xca, 0xe5, 0x36, 0x94, 0xc5, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x3f, 0xa0, 0xcd, 0x65, 0xe0, 0xf3, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 
0x71, 0xf4, 0xfe, 0x70, 0xf3, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 0x64, 0xde, 0xf3, 0x3d, 0xa1, 0xcd, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x34, 0x98, 0xca, 0x5d, 0xde, 0xf4, 0x68, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x2c, 0x8f, 0xa2, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x2c, 0x8f, 0xa2, 0x68, 0xf2, 0xfe, 0x67, 0xf3, 0xfe, 0x67, 0xf2, 0xfe, 0x5b, 0xde, 0xf4, 0x33, 0x98, 0xca, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x22, 0x22, 0x22, 0x41, 0x9b, 0xcd, 0x4f, 0xcb, 0xe9, 0x5f, 0xf1, 0xfe, 0x5e, 0xf1, 0xfe, 0x3d, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xa6, 0xbe, 0xc6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xa6, 0xbe, 0xc6, 0x00, 0x46, 0x5d, 0x3e, 0xb5, 0xc6, 0x5f, 0xf1, 0xfe, 0x5f, 0xf1, 0xfe, 0x4c, 0xcb, 0xe9, 0x40, 0x9b, 0xcd, 0x22, 0x22, 0x22, 
0x00, 0x3e, 0x44, 0x38, 0xa5, 0xd5, 0x56, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfc, 0xf6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x37, 0xb4, 0xc6, 0x55, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xa5, 0xd4, 0x00, 0x3e, 0x44, 
0x60, 0xb0, 0xda, 0x40, 0xc4, 0xe7, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x3f, 0xc4, 0xe8, 0x60, 0xb0, 0xda, 
0x30, 0x9c, 0xd3, 0x3e, 0xdb, 0xf5, 0x44, 0xed, 0xfe, 0x44, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 
0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x44, 0xed, 0xfe, 0x43, 0xed, 0xfe, 0x3d, 0xda, 0xf5, 0x2f, 0x9c, 0xd3, 
0x0e, 0x8f, 0xd0, 0x39, 0xe8, 0xfd, 0x3b, 0xec, 0xfe, 0x3e, 0xed, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 
0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x3f, 0xed, 0xfe, 0x3a, 0xec, 0xfe, 0x38, 0xe8, 0xfd, 0x0e, 0x8f, 0xd0, 
0x0e, 0x94, 0xd5, 0x30, 0xe7, 0xfe, 0x32, 0xeb, 0xfe, 0x4a, 0xee, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 
0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x64, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 0x4a, 0xee, 0xfe, 0x32, 0xeb, 0xfe, 0x30, 0xe7, 0xfd, 0x0e, 0x94, 0xd4, 
0x30, 0xa6, 0xe0, 0x2a, 0xda, 0xf8, 0x2a, 0xe9, 0xfe, 0x60, 0xf1, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 
0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x60, 0xf1, 0xfe, 0x2a, 0xea, 0xfe, 0x29, 0xda, 0xf8, 0x30, 0xa7, 0xde, 
0x61, 0xbe, 0xea, 0x2c, 0xca, 0xf1, 0x23, 0xe9, 0xfe, 0x7b, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 
0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7b, 0xf4, 0xfe, 0x23, 0xe9, 0xfe, 0x2c, 0xc9, 0xf1, 0x61, 0xbe, 0xe9, 
0x00, 0x3e, 0x44, 0x2e, 0xb9, 0xeb, 0x1b, 0xe8, 0xfe, 0x74, 0xf4, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 
0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x74, 0xf4, 0xfe, 0x1b, 0xe7, 0xfe, 0x2d, 0xba, 0xeb, 0x00, 0x3e, 0x44, 
0x22, 0x22, 0x22, 0x40, 0xb9, 0xec, 0x21, 0xd1, 0xf6, 0x56, 0xf0, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 
0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x57, 0xf0, 0xfe, 0x21, 0xd1, 0xf6, 0x3f, 0xb9, 0xec, 0x22, 0x22, 0x22, 
0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2a, 0xb9, 0xef, 0x24, 0xde, 0xfc, 0x79, 0xf5, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 
0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0x79, 0xf5, 0xfe, 0x24, 0xde, 0xfc, 0x2a, 0xb9, 0xef, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2b, 0xc1, 0xf3, 0x29, 0xdf, 0xfd, 0x74, 0xf4, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 
0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0x74, 0xf4, 0xfe, 0x28, 0xe0, 0xfd, 0x2a, 0xc1, 0xf3, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x28, 0xbf, 0xf3, 0x1a, 0xd4, 0xfa, 0x41, 0xec, 0xfe, 0x74, 0xf4, 0xfe, 0x9e, 0xfa, 0xfe, 0xbb, 0xfe, 0xfe, 
0xbb, 0xfe, 0xfe, 0x9e, 0xfa, 0xfe, 0x74, 0xf4, 0xfe, 0x42, 0xec, 0xfe, 0x19, 0xd3, 0xfa, 0x29, 0xbf, 0xf4, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0xc3, 0xf5, 0x2a, 0xc4, 0xf6, 0x1b, 0xd1, 0xfa, 0x0a, 0xdb, 0xfd, 0x01, 0xe2, 0xfe, 
0x01, 0xe2, 0xfe, 0x0a, 0xdb, 0xfd, 0x1b, 0xd1, 0xfa, 0x29, 0xc5, 0xf7, 0x41, 0xc3, 0xf6, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x62, 0xce, 0xf9, 0x32, 0xbe, 0xf6, 0x10, 0xb3, 0xf5, 
0x10, 0xb3, 0xf5, 0x32, 0xbe, 0xf6, 0x62, 0xce, 0xf9, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/*===============================*/
/*========= ICON BITMAP =========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/****** LOW LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Command_128128RGB(unsigned char c)        // send command to OLED
{  
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                PORTD = c;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, LOW);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((c & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   c = c << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
} 

void OLED_Data_128128RGB(unsigned char d)        // send data to OLED
{ 
   unsigned char i;
   unsigned char mask = 0x80;
   switch(interface)
   {
      case 0:   digitalWrite(CS_PIN, LOW);
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(RW_PIN, LOW);
                digitalWrite(E_PIN, HIGH);
                digitalWrite(E_PIN, LOW);
                digitalWrite(CS_PIN, HIGH);
                break;
      case 1:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                PORTD = d;
                digitalWrite(WR_PIN, LOW);
                digitalWrite(WR_PIN, HIGH);
                digitalWrite(CS_PIN, HIGH);
                break;
                break;
      case 2:   digitalWrite(CS_PIN, LOW);               
                digitalWrite(RS_PIN, HIGH);
                for(i=0;i<8;i++)
                {
                   digitalWrite(SCL_PIN, LOW);
                   if((d & mask) >> 7 == 1)
                   {
                      digitalWrite(SDI_PIN, HIGH);
                   }
                   else
                   {
                      digitalWrite(SDI_PIN, LOW);
                   }
                   digitalWrite(SCL_PIN, HIGH);
                   d = d << 1;
                }
                digitalWrite(CS_PIN, HIGH);
                break;
      default:  break;           
   }
}

void OLED_SetColumnAddress_128128RGB(unsigned char x_start, unsigned char x_end)    // set column address start + end
{
   OLED_Command_128128RGB(0x15);
   OLED_Data_128128RGB(x_start);
   OLED_Data_128128RGB(x_end);
}

void OLED_SetRowAddress_128128RGB(unsigned char y_start, unsigned char y_end)    // set row address start + end
{
   OLED_Command_128128RGB(0x75);
   OLED_Data_128128RGB(y_start);
   OLED_Data_128128RGB(y_end);
}

void OLED_WriteMemoryStart_128128RGB(void)    // write to RAM command
{
    OLED_Command_128128RGB(0x5C);
}

void OLED_Pixel_128128RGB(unsigned long color)    // write one pixel of a given color
{
        OLED_Data_128128RGB((color>>16));
        OLED_Data_128128RGB((color>>8));
        OLED_Data_128128RGB(color);
}

void OLED_FillScreen_128128RGB(unsigned long color)    // fill screen with a given color
{
   unsigned int i,j;
   OLED_SetColumnAddress_128128RGB(0x00, 0x7F);
   OLED_SetRowAddress_128128RGB(0x00, 0x7F);
   OLED_WriteMemoryStart_128128RGB();
   for(i=0;i<128;i++)
   {
      for(j=0;j<128;j++)
      {
	 OLED_Pixel_128128RGB(color);
      }
   }
}

/*===============================*/
/*===== LOW LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/***** HIGH LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Text_128128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=0;i<8;i++)     //each character is 8 px tall
    {
        OLED_SetColumnAddress_128128RGB(x_pos, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<5;count++)    //each character is 5px wide
        {
            if((Ascii_1[letter][count] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
        }
        y_pos++;
        mask = mask >> 1;
   }
}

void OLED_Text2x_128128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text (2x size)
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=1;i<=16;i++)     // each character is 16 pixels tall
    {
        OLED_SetColumnAddress_128128RGB(x_pos, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<10;count++)    // each character is 10 pixels wide
        {
            if((Ascii_1[letter][(count/2)] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
        }
        y_pos++;
        if((i%2)==0)
        {
          mask = mask >> 1;
        }
   }
}

void OLED_NHDText_128128RGB(unsigned long textColor, unsigned long backgroundColor)    // function to show NEWHAVEN DISPLAY
{
    int i;
    int count;
    unsigned char index = 0;
    unsigned char y_pos = 108;
    unsigned char mask = 0x80;
    
    for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_128128RGB(11, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_128128RGB(25, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character W
    {
        OLED_SetColumnAddress_128128RGB(36, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character H
    {
        OLED_SetColumnAddress_128128RGB(56, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((H10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_128128RGB(68, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character V
    {
        OLED_SetColumnAddress_128128RGB(81, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetColumnAddress_128128RGB(95, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 108;
   
   for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetColumnAddress_128128RGB(107, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;  
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character D
    {
        OLED_SetColumnAddress_128128RGB(25, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character I
    {
        OLED_SetColumnAddress_128128RGB(39, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((I10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character S
    {
        OLED_SetColumnAddress_128128RGB(46, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((S10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character P
    {
        OLED_SetColumnAddress_128128RGB(57, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((P10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character L
    {
        OLED_SetColumnAddress_128128RGB(69, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((L10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetColumnAddress_128128RGB(80, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
   index = 0;
   y_pos = 94;
   
   for(i=0;i<11;i++)     // display custom character Y
    {
        OLED_SetColumnAddress_128128RGB(94, 0x7F);
        OLED_SetRowAddress_128128RGB(y_pos, 0x7F);
        OLED_WriteMemoryStart_128128RGB();
        for (count=0;count<8;count++)
        {
            if((Y10pt[index] & mask) == mask)
                OLED_Pixel_128128RGB(textColor);
            else
                OLED_Pixel_128128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
   }
}

void OLED_Icon_128128RGB(unsigned char x_pos, unsigned char y_pos)    // function to show icon
{
   unsigned int i, j;
   unsigned int height = 20;
   unsigned int width  = 20;
   
   OLED_SetColumnAddress_128128RGB(x_pos, (x_pos+width-1));
   OLED_SetRowAddress_128128RGB(y_pos, (y_pos+height-1));
   OLED_WriteMemoryStart_128128RGB();
   for(j=0;j<(height*width*3);j+=3)
   {
      OLED_Data_128128RGB(smiley20x20[j]>>2);
      OLED_Data_128128RGB(smiley20x20[(j+1)]>>2);
      OLED_Data_128128RGB(smiley20x20[(j+2)]>>2);
   }
}

void OLED_Spectrum_128128RGB(void)                  // function to show color spectrum
{
      unsigned char i, j;
      unsigned char blue, green, red;
      
      OLED_SetColumnAddress_128128RGB(0, 127);
      OLED_SetRowAddress_128128RGB(0, 37);
      OLED_WriteMemoryStart_128128RGB();
      for(i=0;i<128;i++)
      {
        OLED_Pixel_128128RGB(WHITE);
      }
      for(i=0;i<36;i++)
      {
        blue = 0x00;
        green = 0x00;
        red = 0x3F;
        OLED_Pixel_128128RGB(WHITE);
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          green += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          red -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          blue += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          green -= 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          red += 3;
        }
        for(j=0;j<21;j++)
        {
          OLED_Data_128128RGB(blue);
          OLED_Data_128128RGB(green);
          OLED_Data_128128RGB(red);
          blue -= 3;
        }
        OLED_Pixel_128128RGB(WHITE);
      }
      for(i=0;i<128;i++)
      {
        OLED_Pixel_128128RGB(WHITE);
      }
}

/*===============================*/
/*==== HIGH LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******** INITIALIZATION *********/
/************ START **************/
/*********************************/

void OLED_Init_128128RGB(void)      //OLED initialization
{
    digitalWrite(RES_PIN, LOW);
    delay(500);
    digitalWrite(RES_PIN, HIGH);
    delay(500);

    OLED_Command_128128RGB(0xFD);	// Command lock setting
    OLED_Data_128128RGB(0x12);		// unlock
    OLED_Command_128128RGB(0xFD);	// Command lock setting
    OLED_Data_128128RGB(0xB1);		// unlock
    OLED_Command_128128RGB(0xAE);
    OLED_Command_128128RGB(0xB3);	// clock & frequency
    OLED_Data_128128RGB(0xF1);		// clock=Diviser+1 frequency=fh 
    OLED_Command_128128RGB(0xCA);	// Duty
    OLED_Data_128128RGB(0x7F);		// OLED _END+1
    OLED_Command_128128RGB(0xA2);  	// Display offset
    OLED_Data_128128RGB(0x00);
    OLED_Command_128128RGB(0xA1);	// Set display start line
    OLED_Data_128128RGB(0x00);		// 0x00 start line
    OLED_Command_128128RGB(0xA0);	// Set Re-map, color depth
    OLED_Data_128128RGB(0xA0);		// 8-bit 262K
    OLED_Command_128128RGB(0xB5);	// set GPIO
    OLED_Data_128128RGB(0x00);		// disabled
    OLED_Command_128128RGB(0xAB);	// Function Set
    OLED_Data_128128RGB(0x01);		// 8-bit interface, internal VDD regulator
    OLED_Command_128128RGB(0xB4);	// set VSL
    OLED_Data_128128RGB(0xA0);		// external VSL
    OLED_Data_128128RGB(0xB5);
    OLED_Data_128128RGB(0x55);
    OLED_Command_128128RGB(0xC1);	// Set contrast current for A,B,C
    OLED_Data_128128RGB(0x8A);		// Color A
    OLED_Data_128128RGB(0x70);		// Color B
    OLED_Data_128128RGB(0x8A);		// Color C
    OLED_Command_128128RGB(0xC7);	// Set master contrast
    OLED_Data_128128RGB(0x0F);		//	
    OLED_Command_128128RGB(0xB9);	// use linear grayscale LUT
    OLED_Command_128128RGB(0xB1);	// Set pre & dis-charge
    OLED_Data_128128RGB(0x32);		// pre=1h, dis=1h  
    OLED_Command_128128RGB(0xBB);	// Set precharge voltage of color A,B,C
    OLED_Data_128128RGB(0x07);		//
    OLED_Command_128128RGB(0xB2);       // display enhancement
    OLED_Data_128128RGB(0xa4);		
    OLED_Data_128128RGB(0x00);
    OLED_Data_128128RGB(0x00);
    OLED_Command_128128RGB(0xB6);	// precharge period
    OLED_Data_128128RGB(0x01);		
    OLED_Command_128128RGB(0xBE);	// Set VcomH
    OLED_Data_128128RGB(0x07);
    OLED_Command_128128RGB(0xA6);	// Normal display
    OLED_Command_128128RGB(0xAF);	// Display on
}

/*===============================*/
/*======= INITIALIZATION ========*/
/*============= END =============*/
/*===============================*/

void setup()                                       // for Arduino, runs first at power on
{
   pinMode(LVL_OEN, OUTPUT);                       // configure LVL_OEN as output
   digitalWrite(LVL_OEN, LOW);
   pinMode(LVL_DIR, OUTPUT);                       // configure LVL_DIR as output
   digitalWrite(LVL_DIR, HIGH);
   DDRD = 0xFF;                                    // configure PORTD as output
   pinMode(RS_PIN, OUTPUT);                        // configure RS_PIN as output
   pinMode(RES_PIN, OUTPUT);                       // configure RES_PIN as output
   pinMode(CS_PIN, OUTPUT);                        // configure CS_PIN as output
   pinMode(BS0_PIN, OUTPUT);                       // configure BS0_PIN as output
   pinMode(BS1_PIN, OUTPUT);                       // configure BS1_PIN as output
   digitalWrite(CS_PIN, HIGH);                     // set CS_PIN
   switch(interface)
   {
     case 0:
       pinMode(RW_PIN, OUTPUT);                    // configure RW_PIN as output
       pinMode(E_PIN, OUTPUT);                     // configure E_PIN as output
       digitalWrite(BS0_PIN, HIGH);                // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // set BS1_PIN
       digitalWrite(RW_PIN, LOW);                  // reset RW_PIN
       digitalWrite(E_PIN, HIGH);                  // set E_PIN
       break;
     case 1: 
       pinMode(WR_PIN, OUTPUT);                    // configure WR_PIN as output
       pinMode(RD_PIN, OUTPUT);                    // configure RD_PIN as output
       digitalWrite(BS0_PIN, LOW);                 // set BS0_PIN
       digitalWrite(BS1_PIN, HIGH);                // reset BS1_PIN
       digitalWrite(WR_PIN, HIGH);                 // set WR_PIN
       digitalWrite(RD_PIN, HIGH);                 // set RD_PIN
       break;
     case 2:
       pinMode(SDI_PIN, OUTPUT);                   // configure SDI_PIN as output
       pinMode(SCL_PIN, OUTPUT);                   // configure SCL_PIN as output
       PORTD = 0x00;                               // reset SDI_PIN and SCL_PIN, ground DB[5..0] of the display
       digitalWrite(BS0_PIN, LOW);                 // reset BS0_PIN
       digitalWrite(BS1_PIN, LOW);                 // reset BS1_PIN
       digitalWrite(WR_PIN, LOW);                  // reset WR_PIN
       digitalWrite(RD_PIN, LOW);                  // reset RD_PIN
       break;
     default:
       break;
   }
}

void loop()                                         // main loop, runs after "setup()"
{  
   OLED_Init_128128RGB();                           // initialize display
   
   OLED_FillScreen_128128RGB(BLACK);                // fill screen with black
   
   OLED_NHDText_128128RGB(GREEN, BLACK);            // show NEWHAVEN DISPLAY
   
   OLED_Text_128128RGB(10, 56, 40, WHITE, BLACK);   // H
   OLED_Text_128128RGB(17, 56, 69, WHITE, BLACK);   // e
   OLED_Text_128128RGB(24, 56, 76, WHITE, BLACK);   // l
   OLED_Text_128128RGB(31, 56, 76, WHITE, BLACK);   // l
   OLED_Text_128128RGB(38, 56, 79, WHITE, BLACK);   // o
   OLED_Text_128128RGB(45, 56, 0, WHITE, BLACK);    //
      
   OLED_Text_128128RGB(52, 56, 55, WHITE, BLACK);   // W
   OLED_Text_128128RGB(59, 56, 79, WHITE, BLACK);   // o
   OLED_Text_128128RGB(66, 56, 82, WHITE, BLACK);   // r
   OLED_Text_128128RGB(73, 56, 76, WHITE, BLACK);   // l
   OLED_Text_128128RGB(80, 56, 68, WHITE, BLACK);   // d
   OLED_Text_128128RGB(87, 56, 1, WHITE, BLACK);    // !
   
   OLED_Icon_128128RGB(102, 50);                    // show icon
   
   OLED_Spectrum_128128RGB();                       // show color spectrum
   
   while(1);                                        // wait here forever
}

NHD-1.69-AU-SHIELD

Direct Link

//---------------------------------------------------------
/*
 
NHD-1.69-AU-SHIELD.ino
 
Program for writing to Newhaven Display's 160x128 Graphic Color OLED with SEPS525 controller.
 
This code is written for the Arduino Uno.

Copyright (c) 2015 - Newhaven Display International, Inc.
 
Newhaven Display invests time and resources providing this open source code,
please support Newhaven Display by purchasing products from Newhaven Display!
 
  */
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTD[7..0]

#define   SDI_PIN   11    // SDI (serial mode) signal connected to pin 11
#define   SCL_PIN   13    // SCL (serial mdoe) signal connected to pin 13
#define    RS_PIN    4    // RS signal connected to pin 4
#define    RW_PIN    9    // R/W (6800 mode) signal connected to pin 9
#define    WR_PIN    9    // /WR (8080 mode) signal connected to pin 9
#define     E_PIN   10    // E (6800 mode) signal connected to pin 10
#define    RD_PIN   10    // /RD (8080 mode) signal connected to pin 10
#define   RES_PIN   6    // /RES signal connected to pin 6
#define    CS_PIN   5    // /CS signal connected to pin 5
#define    PS_PIN   A0    // PS signal connected to pin A0
#define   CPU_PIN   A1    // CPU signal connected to pin A1
#define   LVL_DIR   A2    // DIR (direction control) signal of level shifter IC connected to pin A2
#define   LVL_OEN   A3    // /OE (output enable) signal of level shifter IC connected to pin A3

#define    RED  0x0000FF
#define  GREEN  0x00FF00
#define   BLUE  0xFF0000
#define  WHITE  0xFFFFFF
#define  BLACK  0x000000


/*********************************/
/****** INTERFACE SELECTION ******/
/*********************************/

const unsigned char interface = 2;    // 0 = 8-bit parallel (6800 mode) interface; 1 = 8-bit parallel (8080 mode) interface; 2 = 4-wire SPI interface

/*===============================*/
/*===============================*/
/*===============================*/


/*********************************/
/******** FONT TABLE 5x8 *********/
/************* START *************/
/*********************************/

unsigned char Ascii_1[97][5] = {     // Refer to "Times New Roman" Font Database...
    //   Basic Characters
    {0x00,0x00,0x00,0x00,0x00},     //   (  0)    - 0x0000 Empty set
    {0x00,0x00,0x4F,0x00,0x00},     //   (  1)  ! - 0x0021 Exclamation Mark
    {0x00,0x07,0x00,0x07,0x00},     //   (  2)  " - 0x0022 Quotation Mark
    {0x14,0x7F,0x14,0x7F,0x14},     //   (  3)  # - 0x0023 Number Sign
    {0x24,0x2A,0x7F,0x2A,0x12},     //   (  4)  $ - 0x0024 Dollar Sign
    {0x23,0x13,0x08,0x64,0x62},     //   (  5)  % - 0x0025 Percent Sign
    {0x36,0x49,0x55,0x22,0x50},     //   (  6)  & - 0x0026 Ampersand
    {0x00,0x05,0x03,0x00,0x00},     //   (  7)  ' - 0x0027 Apostrophe
    {0x00,0x1C,0x22,0x41,0x00},     //   (  8)  ( - 0x0028 Left Parenthesis
    {0x00,0x41,0x22,0x1C,0x00},     //   (  9)  ) - 0x0029 Right Parenthesis
    {0x14,0x08,0x3E,0x08,0x14},     //   ( 10)  * - 0x002A Asterisk
    {0x08,0x08,0x3E,0x08,0x08},     //   ( 11)  + - 0x002B Plus Sign
    {0x00,0x50,0x30,0x00,0x00},     //   ( 12)  , - 0x002C Comma
    {0x08,0x08,0x08,0x08,0x08},     //   ( 13)  - - 0x002D Hyphen-Minus
    {0x00,0x60,0x60,0x00,0x00},     //   ( 14)  . - 0x002E Full Stop
    {0x20,0x10,0x08,0x04,0x02},     //   ( 15)  / - 0x002F Solidus
    {0x3E,0x51,0x49,0x45,0x3E},     //   ( 16)  0 - 0x0030 Digit Zero
    {0x00,0x42,0x7F,0x40,0x00},     //   ( 17)  1 - 0x0031 Digit One
    {0x42,0x61,0x51,0x49,0x46},     //   ( 18)  2 - 0x0032 Digit Two
    {0x21,0x41,0x45,0x4B,0x31},     //   ( 19)  3 - 0x0033 Digit Three
    {0x18,0x14,0x12,0x7F,0x10},     //   ( 20)  4 - 0x0034 Digit Four
    {0x27,0x45,0x45,0x45,0x39},     //   ( 21)  5 - 0x0035 Digit Five
    {0x3C,0x4A,0x49,0x49,0x30},     //   ( 22)  6 - 0x0036 Digit Six
    {0x01,0x71,0x09,0x05,0x03},     //   ( 23)  7 - 0x0037 Digit Seven
    {0x36,0x49,0x49,0x49,0x36},     //   ( 24)  8 - 0x0038 Digit Eight
    {0x06,0x49,0x49,0x29,0x1E},     //   ( 25)  9 - 0x0039 Dight Nine
    {0x00,0x36,0x36,0x00,0x00},     //   ( 26)  : - 0x003A Colon
    {0x00,0x56,0x36,0x00,0x00},     //   ( 27)  ; - 0x003B Semicolon
    {0x08,0x14,0x22,0x41,0x00},     //   ( 28)  < - 0x003C Less-Than Sign
    {0x14,0x14,0x14,0x14,0x14},     //   ( 29)  = - 0x003D Equals Sign
    {0x00,0x41,0x22,0x14,0x08},     //   ( 30)  > - 0x003E Greater-Than Sign
    {0x02,0x01,0x51,0x09,0x06},     //   ( 31)  ? - 0x003F Question Mark
    {0x32,0x49,0x79,0x41,0x3E},     //   ( 32)  @ - 0x0040 Commercial At
    {0x7E,0x11,0x11,0x11,0x7E},     //   ( 33)  A - 0x0041 Latin Capital Letter A
    {0x7F,0x49,0x49,0x49,0x36},     //   ( 34)  B - 0x0042 Latin Capital Letter B
    {0x3E,0x41,0x41,0x41,0x22},     //   ( 35)  C - 0x0043 Latin Capital Letter C
    {0x7F,0x41,0x41,0x22,0x1C},     //   ( 36)  D - 0x0044 Latin Capital Letter D
    {0x7F,0x49,0x49,0x49,0x41},     //   ( 37)  E - 0x0045 Latin Capital Letter E
    {0x7F,0x09,0x09,0x09,0x01},     //   ( 38)  F - 0x0046 Latin Capital Letter F
    {0x3E,0x41,0x49,0x49,0x7A},     //   ( 39)  G - 0x0047 Latin Capital Letter G
    {0x7F,0x08,0x08,0x08,0x7F},     //   ( 40)  H - 0x0048 Latin Capital Letter H
    {0x00,0x41,0x7F,0x41,0x00},     //   ( 41)  I - 0x0049 Latin Capital Letter I
    {0x20,0x40,0x41,0x3F,0x01},     //   ( 42)  J - 0x004A Latin Capital Letter J
    {0x7F,0x08,0x14,0x22,0x41},     //   ( 43)  K - 0x004B Latin Capital Letter K
    {0x7F,0x40,0x40,0x40,0x40},     //   ( 44)  L - 0x004C Latin Capital Letter L
    {0x7F,0x02,0x0C,0x02,0x7F},     //   ( 45)  M - 0x004D Latin Capital Letter M
    {0x7F,0x04,0x08,0x10,0x7F},     //   ( 46)  N - 0x004E Latin Capital Letter N
    {0x3E,0x41,0x41,0x41,0x3E},     //   ( 47)  O - 0x004F Latin Capital Letter O
    {0x7F,0x09,0x09,0x09,0x06},     //   ( 48)  P - 0x0050 Latin Capital Letter P
    {0x3E,0x41,0x51,0x21,0x5E},     //   ( 49)  Q - 0x0051 Latin Capital Letter Q
    {0x7F,0x09,0x19,0x29,0x46},     //   ( 50)  R - 0x0052 Latin Capital Letter R
    {0x46,0x49,0x49,0x49,0x31},     //   ( 51)  S - 0x0053 Latin Capital Letter S
    {0x01,0x01,0x7F,0x01,0x01},     //   ( 52)  T - 0x0054 Latin Capital Letter T
    {0x3F,0x40,0x40,0x40,0x3F},     //   ( 53)  U - 0x0055 Latin Capital Letter U
    {0x1F,0x20,0x40,0x20,0x1F},     //   ( 54)  V - 0x0056 Latin Capital Letter V
    {0x3F,0x40,0x38,0x40,0x3F},     //   ( 55)  W - 0x0057 Latin Capital Letter W
    {0x63,0x14,0x08,0x14,0x63},     //   ( 56)  X - 0x0058 Latin Capital Letter X
    {0x07,0x08,0x70,0x08,0x07},     //   ( 57)  Y - 0x0059 Latin Capital Letter Y
    {0x61,0x51,0x49,0x45,0x43},     //   ( 58)  Z - 0x005A Latin Capital Letter Z
    {0x00,0x7F,0x41,0x41,0x00},     //   ( 59)  [ - 0x005B Left Square Bracket
    {0x02,0x04,0x08,0x10,0x20},     //   ( 60)  \ - 0x005C Reverse Solidus
    {0x00,0x41,0x41,0x7F,0x00},     //   ( 61)  ] - 0x005D Right Square Bracket
    {0x04,0x02,0x01,0x02,0x04},     //   ( 62)  ^ - 0x005E Circumflex Accent
    {0x40,0x40,0x40,0x40,0x40},     //   ( 63)  _ - 0x005F Low Line
    {0x01,0x02,0x04,0x00,0x00},     //   ( 64)  ` - 0x0060 Grave Accent
    {0x20,0x54,0x54,0x54,0x78},     //   ( 65)  a - 0x0061 Latin Small Letter A
    {0x7F,0x48,0x44,0x44,0x38},     //   ( 66)  b - 0x0062 Latin Small Letter B
    {0x38,0x44,0x44,0x44,0x20},     //   ( 67)  c - 0x0063 Latin Small Letter C
    {0x38,0x44,0x44,0x48,0x7F},     //   ( 68)  d - 0x0064 Latin Small Letter D
    {0x38,0x54,0x54,0x54,0x18},     //   ( 69)  e - 0x0065 Latin Small Letter E
    {0x08,0x7E,0x09,0x01,0x02},     //   ( 70)  f - 0x0066 Latin Small Letter F
    {0x06,0x49,0x49,0x49,0x3F},     //   ( 71)  g - 0x0067 Latin Small Letter G
    {0x7F,0x08,0x04,0x04,0x78},     //   ( 72)  h - 0x0068 Latin Small Letter H
    {0x00,0x44,0x7D,0x40,0x00},     //   ( 73)  i - 0x0069 Latin Small Letter I
    {0x20,0x40,0x44,0x3D,0x00},     //   ( 74)  j - 0x006A Latin Small Letter J
    {0x7F,0x10,0x28,0x44,0x00},     //   ( 75)  k - 0x006B Latin Small Letter K
    {0x00,0x41,0x7F,0x40,0x00},     //   ( 76)  l - 0x006C Latin Small Letter L
    {0x7C,0x04,0x18,0x04,0x7C},     //   ( 77)  m - 0x006D Latin Small Letter M
    {0x7C,0x08,0x04,0x04,0x78},     //   ( 78)  n - 0x006E Latin Small Letter N
    {0x38,0x44,0x44,0x44,0x38},     //   ( 79)  o - 0x006F Latin Small Letter O
    {0x7C,0x14,0x14,0x14,0x08},     //   ( 80)  p - 0x0070 Latin Small Letter P
    {0x08,0x14,0x14,0x18,0x7C},     //   ( 81)  q - 0x0071 Latin Small Letter Q
    {0x7C,0x08,0x04,0x04,0x08},     //   ( 82)  r - 0x0072 Latin Small Letter R
    {0x48,0x54,0x54,0x54,0x20},     //   ( 83)  s - 0x0073 Latin Small Letter S
    {0x04,0x3F,0x44,0x40,0x20},     //   ( 84)  t - 0x0074 Latin Small Letter T
    {0x3C,0x40,0x40,0x20,0x7C},     //   ( 85)  u - 0x0075 Latin Small Letter U
    {0x1C,0x20,0x40,0x20,0x1C},     //   ( 86)  v - 0x0076 Latin Small Letter V
    {0x3C,0x40,0x30,0x40,0x3C},     //   ( 87)  w - 0x0077 Latin Small Letter W
    {0x44,0x28,0x10,0x28,0x44},     //   ( 88)  x - 0x0078 Latin Small Letter X
    {0x0C,0x50,0x50,0x50,0x3C},     //   ( 89)  y - 0x0079 Latin Small Letter Y
    {0x44,0x64,0x54,0x4C,0x44},     //   ( 90)  z - 0x007A Latin Small Letter Z
    {0x00,0x08,0x36,0x41,0x00},     //   ( 91)  { - 0x007B Left Curly Bracket
    {0x00,0x00,0x7F,0x00,0x00},     //   ( 92)  | - 0x007C Vertical Line
    {0x00,0x41,0x36,0x08,0x00},     //   ( 93)  } - 0x007D Right Curly Bracket
    {0x02,0x01,0x02,0x04,0x02},     //   ( 94)  ~ - 0x007E Tilde
    {0x08,0x0C,0x0E,0x0C,0x08},     //   ( 95)  upward facing triangle/arrow
    {0x08,0x18,0x38,0x18,0x08},     //   ( 96)  downward facing triangle/arrow
};

/*===============================*/
/*======= FONT TABLE 5x8 ========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******* CUSTOM CHARACTERS *******/
/************* START *************/
/*********************************/

const unsigned char A10pt [] = {	// 'A' (11 pixels wide)
    0x0E, 0x00, //     ###
    0x0F, 0x00, //     ####
    0x1B, 0x00, //    ## ##
    0x1B, 0x00, //    ## ##
    0x13, 0x80, //    #  ###
    0x31, 0x80, //   ##   ##
    0x3F, 0xC0, //   ########
    0x7F, 0xC0, //  #########
    0x60, 0xC0, //  ##     ##
    0x60, 0xE0, //  ##     ###
    0xE0, 0xE0, // ###     ###
};
const unsigned char D10pt [] = {	// 'D' (9 pixels wide)
    0xFC, 0x00, // ######
    0xFF, 0x00, // ########
    0xC7, 0x00, // ##   ###
    0xC3, 0x80, // ##    ###
    0xC1, 0x80, // ##     ##
    0xC1, 0x80, // ##     ##
    0xC1, 0x80, // ##     ##
    0xC3, 0x80, // ##    ###
    0xC7, 0x00, // ##   ###
    0xFE, 0x00, // #######
    0xFC, 0x00, // ######
};
const unsigned char E10pt [] = {	// 'E' (7 pixels wide)
    0xFE, // #######
    0xFE, // #######
    0xC0, // ##
    0xC0, // ##
    0xFC, // ######
    0xFC, // ######
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xFE, // #######
    0xFE, // #######
};
const unsigned char H10pt [] = {	// 'H' (8 pixels wide)
    0xC3, // ##    ##
    0xC3, // ##    ##
    0xC3, // ##    ##
    0xC3, // ##    ##
    0xFF, // ########
    0xFF, // ########
    0xC3, // ##    ##
    0xC3, // ##    ##
    0xC3, // ##    ##
    0xC3, // ##    ##
    0xC3, // ##    ##
};
const unsigned char I10pt [] = {	// 'I' (2 pixels wide)
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
};
const unsigned char L10pt [] = {	// 'L' (7 pixels wide)
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xFE, // #######
    0xFE, // #######
};
const unsigned char N10pt [] = {	// 'N' (9 pixels wide)
    0xE1, 0x80, // ###    ##
    0xE1, 0x80, // ###    ##
    0xF1, 0x80, // ####   ##
    0xF9, 0x80, // #####  ##
    0xD9, 0x80, // ## ##  ##
    0xDD, 0x80, // ## ### ##
    0xCD, 0x80, // ##  ## ##
    0xC7, 0x80, // ##   ####
    0xC7, 0x80, // ##   ####
    0xC3, 0x80, // ##    ###
    0xC1, 0x80, // ##     ##
};
const unsigned char P10pt [] = {	// 'P' (8 pixels wide)
    0xFC, // ######
    0xFF, // ########
    0xC3, // ##    ##
    0xC3, // ##    ##
    0xC7, // ##   ###
    0xFE, // #######
    0xF8, // #####
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
    0xC0, // ##
};
const unsigned char S10pt [] = {	// 'S' (7 pixels wide)
    0x7C, //  #####
    0xFC, // ######
    0xC0, // ##
    0xC0, // ##
    0xF0, // ####
    0x7C, //  #####
    0x1E, //    ####
    0x06, //      ##
    0x06, //      ##
    0xFE, // #######
    0xF8, // #####
};
const unsigned char V10pt [] = {	// 'V' (10 pixels wide)
    0xE0, 0xC0, // ###     ##
    0xE1, 0xC0, // ###    ###
    0x61, 0x80, //  ##    ##
    0x71, 0x80, //  ###   ##
    0x73, 0x00, //  ###  ##
    0x33, 0x00, //   ##  ##
    0x3B, 0x00, //   ### ##
    0x1E, 0x00, //    ####
    0x1E, 0x00, //    ####
    0x1C, 0x00, //    ###
    0x0C, 0x00, //     ##
};
const unsigned char W10pt [] = {	// 'W' (16 pixels wide)
    0xE1, 0x83, // ###    ##     ##
    0xE1, 0xC7, // ###    ###   ###
    0x63, 0xC6, //  ##   ####   ##
    0x63, 0xC6, //  ##   ####   ##
    0x72, 0xC6, //  ###  # ##   ##
    0x32, 0x6C, //   ##  #  ## ##
    0x36, 0x6C, //   ## ##  ## ##
    0x3E, 0x6C, //   #####  ## ##
    0x1C, 0x28, //    ###    # #
    0x1C, 0x38, //    ###    ###
    0x1C, 0x38, //    ###    ###
};
const unsigned char Y10pt [] = {	// 'Y' (8 pixels wide)
    0xE3, // ###   ##
    0x66, //  ##  ##
    0x66, //  ##  ##
    0x34, //   ## #
    0x34, //   ## #
    0x18, //    ##
    0x18, //    ##
    0x18, //    ##
    0x18, //    ##
    0x18, //    ##
    0x18, //    ##
};

/*===============================*/
/*====== CUSTOM CHARACTERS ======*/
/*============= END =============*/
/*===============================*/


/*********************************/
/********** ICON BITMAP **********/
/************* START *************/
/*********************************/

const unsigned char smiley20x20[] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x60, 0xa1, 0xca, 0x2e, 0x84, 0xb7, 0x0c, 0x70, 0xac,
    0x0c, 0x70, 0xae, 0x2f, 0x84, 0xb7, 0x60, 0xa1, 0xca, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0x91, 0xc1, 0x41, 0x9b, 0xc7, 0x61, 0xbf, 0xdd, 0x73, 0xdc, 0xef, 0x80, 0xef, 0xfb,
    0x7f, 0xef, 0xfb, 0x73, 0xdc, 0xef, 0x5f, 0xbf, 0xdd, 0x41, 0x9c, 0xc7, 0x41, 0x92, 0xc1, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x37, 0x95, 0xc5, 0x61, 0xc9, 0xe5, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe, 0x7a, 0xf5, 0xfe,
    0x7a, 0xf5, 0xfe, 0x79, 0xf4, 0xfe, 0x7a, 0xf5, 0xfe, 0x79, 0xf5, 0xfe, 0x5e, 0xca, 0xe5, 0x36, 0x94, 0xc5, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x3f, 0xa0, 0xcd, 0x65, 0xe0, 0xf3, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe,
    0x71, 0xf4, 0xfe, 0x70, 0xf3, 0xfe, 0x71, 0xf4, 0xfe, 0x71, 0xf3, 0xfe, 0x70, 0xf4, 0xfe, 0x64, 0xde, 0xf3, 0x3d, 0xa1, 0xcd, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x34, 0x98, 0xca, 0x5d, 0xde, 0xf4, 0x68, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x67, 0xf2, 0xfe, 0x2c, 0x8f, 0xa2, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d,
    0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x2c, 0x8f, 0xa2, 0x68, 0xf2, 0xfe, 0x67, 0xf3, 0xfe, 0x67, 0xf2, 0xfe, 0x5b, 0xde, 0xf4, 0x33, 0x98, 0xca, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00,
    0x22, 0x22, 0x22, 0x41, 0x9b, 0xcd, 0x4f, 0xcb, 0xe9, 0x5f, 0xf1, 0xfe, 0x5e, 0xf1, 0xfe, 0x3d, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xa6, 0xbe, 0xc6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
    0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xa6, 0xbe, 0xc6, 0x00, 0x46, 0x5d, 0x3e, 0xb5, 0xc6, 0x5f, 0xf1, 0xfe, 0x5f, 0xf1, 0xfe, 0x4c, 0xcb, 0xe9, 0x40, 0x9b, 0xcd, 0x22, 0x22, 0x22,
    0x00, 0x3e, 0x44, 0x38, 0xa5, 0xd5, 0x56, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xb5, 0xc6, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
    0xfe, 0xfe, 0xfe, 0xfe, 0xfc, 0xf6, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x37, 0xb4, 0xc6, 0x55, 0xef, 0xfe, 0x55, 0xf0, 0xfe, 0x37, 0xa5, 0xd4, 0x00, 0x3e, 0x44,
    0x60, 0xb0, 0xda, 0x40, 0xc4, 0xe7, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
    0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x4c, 0xef, 0xfe, 0x4d, 0xee, 0xfe, 0x3f, 0xc4, 0xe8, 0x60, 0xb0, 0xda,
    0x30, 0x9c, 0xd3, 0x3e, 0xdb, 0xf5, 0x44, 0xed, 0xfe, 0x44, 0xee, 0xfe, 0x00, 0x46, 0x5d, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
    0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x46, 0x5d, 0x44, 0xed, 0xfe, 0x43, 0xed, 0xfe, 0x3d, 0xda, 0xf5, 0x2f, 0x9c, 0xd3,
    0x0e, 0x8f, 0xd0, 0x39, 0xe8, 0xfd, 0x3b, 0xec, 0xfe, 0x3e, 0xed, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d,
    0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x3f, 0xed, 0xfe, 0x3a, 0xec, 0xfe, 0x38, 0xe8, 0xfd, 0x0e, 0x8f, 0xd0,
    0x0e, 0x94, 0xd5, 0x30, 0xe7, 0xfe, 0x32, 0xeb, 0xfe, 0x4a, 0xee, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x63, 0xf2, 0xfe, 0x64, 0xf2, 0xfe,
    0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf2, 0xfe, 0x63, 0xf1, 0xfe, 0x64, 0xf2, 0xfe, 0x64, 0xf2, 0xfe, 0x4a, 0xee, 0xfe, 0x32, 0xeb, 0xfe, 0x30, 0xe7, 0xfd, 0x0e, 0x94, 0xd4,
    0x30, 0xa6, 0xe0, 0x2a, 0xda, 0xf8, 0x2a, 0xe9, 0xfe, 0x60, 0xf1, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe,
    0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x6f, 0xf3, 0xfe, 0x60, 0xf1, 0xfe, 0x2a, 0xea, 0xfe, 0x29, 0xda, 0xf8, 0x30, 0xa7, 0xde,
    0x61, 0xbe, 0xea, 0x2c, 0xca, 0xf1, 0x23, 0xe9, 0xfe, 0x7b, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe,
    0x7e, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7e, 0xf5, 0xfe, 0x7e, 0xf5, 0xfe, 0x7d, 0xf5, 0xfe, 0x00, 0x46, 0x5d, 0x7b, 0xf4, 0xfe, 0x23, 0xe9, 0xfe, 0x2c, 0xc9, 0xf1, 0x61, 0xbe, 0xe9,
    0x00, 0x3e, 0x44, 0x2e, 0xb9, 0xeb, 0x1b, 0xe8, 0xfe, 0x74, 0xf4, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe,
    0x8d, 0xf7, 0xfe, 0x8d, 0xf7, 0xfe, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x00, 0x46, 0x5d, 0x8d, 0xf7, 0xfe, 0x74, 0xf4, 0xfe, 0x1b, 0xe7, 0xfe, 0x2d, 0xba, 0xeb, 0x00, 0x3e, 0x44,
    0x22, 0x22, 0x22, 0x40, 0xb9, 0xec, 0x21, 0xd1, 0xf6, 0x56, 0xf0, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe,
    0x9e, 0xfa, 0xfe, 0x9e, 0xf9, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x9e, 0xfa, 0xfe, 0x57, 0xf0, 0xfe, 0x21, 0xd1, 0xf6, 0x3f, 0xb9, 0xec, 0x22, 0x22, 0x22,
    0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2a, 0xb9, 0xef, 0x24, 0xde, 0xfc, 0x79, 0xf5, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe,
    0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xad, 0xfc, 0xfe, 0xae, 0xfc, 0xfe, 0x79, 0xf5, 0xfe, 0x24, 0xde, 0xfc, 0x2a, 0xb9, 0xef, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x2b, 0xc1, 0xf3, 0x29, 0xdf, 0xfd, 0x74, 0xf4, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe,
    0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0xbb, 0xfd, 0xfe, 0x74, 0xf4, 0xfe, 0x28, 0xe0, 0xfd, 0x2a, 0xc1, 0xf3, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x1b, 0x1b, 0x00, 0x3e, 0x44, 0x28, 0xbf, 0xf3, 0x1a, 0xd4, 0xfa, 0x41, 0xec, 0xfe, 0x74, 0xf4, 0xfe, 0x9e, 0xfa, 0xfe, 0xbb, 0xfe, 0xfe,
    0xbb, 0xfe, 0xfe, 0x9e, 0xfa, 0xfe, 0x74, 0xf4, 0xfe, 0x42, 0xec, 0xfe, 0x19, 0xd3, 0xfa, 0x29, 0xbf, 0xf4, 0x00, 0x3e, 0x44, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x44, 0x41, 0xc3, 0xf5, 0x2a, 0xc4, 0xf6, 0x1b, 0xd1, 0xfa, 0x0a, 0xdb, 0xfd, 0x01, 0xe2, 0xfe,
    0x01, 0xe2, 0xfe, 0x0a, 0xdb, 0xfd, 0x1b, 0xd1, 0xfa, 0x29, 0xc5, 0xf7, 0x41, 0xc3, 0xf6, 0x00, 0x3e, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x00, 0x3e, 0x44, 0x62, 0xce, 0xf9, 0x32, 0xbe, 0xf6, 0x10, 0xb3, 0xf5,
    0x10, 0xb3, 0xf5, 0x32, 0xbe, 0xf6, 0x62, 0xce, 0xf9, 0x00, 0x3e, 0x44, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/*===============================*/
/*========= ICON BITMAP =========*/
/*============= END =============*/
/*===============================*/


/*********************************/
/****** LOW LEVEL FUNCTIONS ******/
/************* START *************/
/*********************************/

void OLED_Command_160128RGB(unsigned char c)        // send command to OLED
{
    unsigned char i;
    unsigned char mask = 0x80;
    
    switch(interface)
    {
        case 0:   digitalWrite(CS_PIN, LOW);
            digitalWrite(RS_PIN, LOW);
            PORTD = c;
            digitalWrite(RW_PIN, LOW);
            digitalWrite(E_PIN, HIGH);
            digitalWrite(E_PIN, LOW);
            digitalWrite(CS_PIN, HIGH);
            break;
        case 1:   digitalWrite(CS_PIN, LOW);
            digitalWrite(RS_PIN, LOW);
            digitalWrite(WR_PIN, HIGH);
            PORTD = c;
            digitalWrite(WR_PIN, LOW);
            digitalWrite(WR_PIN, HIGH);
            digitalWrite(CS_PIN, HIGH);
            break;
        case 2:   digitalWrite(CS_PIN, LOW);
            digitalWrite(RS_PIN, LOW);
            for(i=0;i<8;i++)
            {
                digitalWrite(SCL_PIN, LOW);
                if((c & mask) >> 7 == 1)
                {
                    digitalWrite(SDI_PIN, HIGH);
                }
                else
                {
                    digitalWrite(SDI_PIN, LOW);
                }
                digitalWrite(SCL_PIN, HIGH);
                c = c << 1;
            }
            digitalWrite(CS_PIN, HIGH);
            break;
        default:  break;
    }
}

void OLED_Data_160128RGB(unsigned char d)        // send data to OLED
{
    unsigned char i;
    unsigned char mask = 0x80;
    
    switch(interface)
    {
        case 0:   digitalWrite(CS_PIN, LOW);
            digitalWrite(RS_PIN, HIGH);
            PORTD = d;
            digitalWrite(RW_PIN, LOW);
            digitalWrite(E_PIN, HIGH);
            digitalWrite(E_PIN, LOW);
            digitalWrite(CS_PIN, HIGH);
            break;
        case 1:   digitalWrite(CS_PIN, LOW);
            digitalWrite(RS_PIN, HIGH);
            digitalWrite(WR_PIN, HIGH);
            PORTD = d;
            digitalWrite(WR_PIN, LOW);
            digitalWrite(WR_PIN, HIGH);
            digitalWrite(CS_PIN, HIGH);
            break;
            break;
        case 2:   digitalWrite(CS_PIN, LOW);
            digitalWrite(RS_PIN, HIGH);
            for(i=0;i<8;i++)
            {
                digitalWrite(SCL_PIN, LOW);
                if((d & mask) >> 7 == 1)
                {
                    digitalWrite(SDI_PIN, HIGH);
                }
                else
                {
                    digitalWrite(SDI_PIN, LOW);
                }
                digitalWrite(SCL_PIN, HIGH);
                d = d << 1;
            }
            digitalWrite(CS_PIN, HIGH);
            break;
        default:  break;
    }
}

void OLED_SerialPixelData_160128RGB(unsigned char d)    // serial write for pixel data
{
    unsigned char i;
    unsigned char mask = 0x80;
    digitalWrite(CS_PIN, LOW);
    digitalWrite(RS_PIN, HIGH);
    for(i=0;i<6;i++)
    {
        digitalWrite(SCL_PIN, LOW);
        if((d & mask) >> 7 == 1)
        {
            digitalWrite(SDI_PIN, HIGH);
        }
        else
        {
            digitalWrite(SDI_PIN, LOW);
        }
        digitalWrite(SCL_PIN, HIGH);
        d = d << 1;
    }
    digitalWrite(CS_PIN, HIGH);
}

void OLED_SetColumnAddress_160128RGB(unsigned char x_start, unsigned char x_end)    // set column address start + end
{
    OLED_Command_160128RGB(0x17);
    OLED_Data_160128RGB(x_start);
    OLED_Command_160128RGB(0x18);
    OLED_Data_160128RGB(x_end);
}

void OLED_SetRowAddress_160128RGB(unsigned char y_start, unsigned char y_end)    // set row address start + end
{
    OLED_Command_160128RGB(0x19);
    OLED_Data_160128RGB(y_start);
    OLED_Command_160128RGB(0x1A);
    OLED_Data_160128RGB(y_end);
}

void OLED_WriteMemoryStart_160128RGB(void)    // write to RAM command
{
    OLED_Command_160128RGB(0x22);
}

void OLED_Pixel_160128RGB(unsigned long color)    // write one pixel of a given color
{
    switch(interface)
    {
        case 0:
            OLED_Data_160128RGB((color>>16));
            OLED_Data_160128RGB((color>>8));
            OLED_Data_160128RGB(color);
            break;
        case 1:
            OLED_Data_160128RGB((color>>16));
            OLED_Data_160128RGB((color>>8));
            OLED_Data_160128RGB(color);
            break;
        case 2:
            OLED_SerialPixelData_160128RGB((color>>16));
            OLED_SerialPixelData_160128RGB((color>>8));
            OLED_SerialPixelData_160128RGB(color);
            break;
        default:
            break;
    }
}

void OLED_SetPosition_160128RGB(unsigned char x_pos, unsigned char y_pos)    // set x,y address
{
    OLED_Command_160128RGB(0x20);
    OLED_Data_160128RGB(x_pos);
    OLED_Command_160128RGB(0x21);
    OLED_Data_160128RGB(y_pos);
}

void OLED_FillScreen_160128RGB(unsigned long color)    // fill screen with a given color
{
    unsigned int i;
    OLED_SetPosition_160128RGB(0,0);
    OLED_WriteMemoryStart_160128RGB();
    for(i=0;i<20480;i++)
    {
        OLED_Pixel_160128RGB(color);
    }
}

/*===============================*/
/*===== LOW LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/***** HIGH LEVEL FUNCTIONS ******/
/************ START **************/
/*********************************/

void OLED_Text_160128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=0;i<8;i++)     // each character is 8 pixels tall
    {
        OLED_SetPosition_160128RGB(x_pos,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<5;count++)    // each character is 5 pixels wide
        {
            if((Ascii_1[letter][count] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
        }
        y_pos++;
        mask = mask >> 1;
    }
}

void OLED_Text2x_160128RGB(unsigned char x_pos, unsigned char y_pos, unsigned char letter, unsigned long textColor, unsigned long backgroundColor)  // function to show text (2x size)
{
    int i;
    int count;
    unsigned char mask = 0x80;
    
    for(i=1;i<=16;i++)     // each character is 16 pixels tall
    {
        OLED_SetPosition_160128RGB(x_pos,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<10;count++)    // each character is 10 pixels wide
        {
            if((Ascii_1[letter][(count/2)] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
        }
        y_pos++;
        if((i%2)==0)
        {
            mask = mask >> 1;
        }
    }
}

void OLED_NHDText_160128RGB(unsigned long textColor, unsigned long backgroundColor)    // function to show NEWHAVEN DISPLAY
{
    int i;
    int count;
    unsigned char index = 0;
    unsigned char y_pos = 110;
    unsigned char mask = 0x80;
    
    for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetPosition_160128RGB(26,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 110;
    
    for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetPosition_160128RGB(40,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 110;
    
    for(i=0;i<11;i++)     // display custom character W
    {
        OLED_SetPosition_160128RGB(51,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((W10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 110;
    
    for(i=0;i<11;i++)     // display custom character H
    {
        OLED_SetPosition_160128RGB(71,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((H10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 110;
    
    for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetPosition_160128RGB(83,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 110;
    
    for(i=0;i<11;i++)     // display custom character V
    {
        OLED_SetPosition_160128RGB(96,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((V10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 110;
    
    for(i=0;i<11;i++)     // display custom character E
    {
        OLED_SetPosition_160128RGB(110,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((E10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 110;
    
    for(i=0;i<11;i++)     // display custom character N
    {
        OLED_SetPosition_160128RGB(122,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((N10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 94;
    
    for(i=0;i<11;i++)     // display custom character D
    {
        OLED_SetPosition_160128RGB(40,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((D10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 94;
    
    for(i=0;i<11;i++)     // display custom character I
    {
        OLED_SetPosition_160128RGB(54,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((I10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 94;
    
    for(i=0;i<11;i++)     // display custom character S
    {
        OLED_SetPosition_160128RGB(61,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((S10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 94;
    
    for(i=0;i<11;i++)     // display custom character P
    {
        OLED_SetPosition_160128RGB(72,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((P10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 94;
    
    for(i=0;i<11;i++)     // display custom character L
    {
        OLED_SetPosition_160128RGB(84,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((L10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 94;
    
    for(i=0;i<11;i++)     // display custom character A
    {
        OLED_SetPosition_160128RGB(95,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        for (count=0;count<8;count++)
        {
            if((A10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
    index = 0;
    y_pos = 94;
    
    for(i=0;i<11;i++)     // display custom character Y
    {
        OLED_SetPosition_160128RGB(109,y_pos);
        OLED_WriteMemoryStart_160128RGB();
        for (count=0;count<8;count++)
        {
            if((Y10pt[index] & mask) == mask)
                OLED_Pixel_160128RGB(textColor);
            else
                OLED_Pixel_160128RGB(backgroundColor);
            mask = mask >> 1;
        }
        index++;
        mask = 0x80;
        y_pos--;
    }
}

void OLED_Icon_160128RGB(unsigned char x_pos, unsigned char y_pos)    // function to show icon
{
    unsigned int i, j;
    unsigned int incr = 0;
    
    for(i=0;i<20;i++)
    {
        OLED_SetPosition_160128RGB(x_pos,y_pos+i);
        OLED_WriteMemoryStart_160128RGB();
        for(j=0;j<60;j+=3)
        {
            switch(interface)
            {
                case 0:
                case 1:
                    OLED_Data_160128RGB(smiley20x20[(j+incr)]);
                    OLED_Data_160128RGB(smiley20x20[((j+incr)+1)]);
                    OLED_Data_160128RGB(smiley20x20[((j+incr)+2)]);
                    break;
                case 2:
                    OLED_SerialPixelData_160128RGB(smiley20x20[(j+incr)]);
                    OLED_SerialPixelData_160128RGB(smiley20x20[((j+incr)+1)]);
                    OLED_SerialPixelData_160128RGB(smiley20x20[((j+incr)+2)]);
                    break;
                default:
                    break;
            }
        }
        incr += 60;
    }
}

void OLED_Spectrum_160128RGB(void)                  // function to show color spectrum
{
    unsigned char i, j;
    unsigned char blue, green, red;
    
    OLED_SetPosition_160128RGB(0,0);
    OLED_WriteMemoryStart_160128RGB();
    for(i=0;i<160;i++)
    {
        OLED_Pixel_160128RGB(WHITE);
    }
    OLED_SetPosition_160128RGB(0,1);
    OLED_WriteMemoryStart_160128RGB();
    for(i=0;i<160;i++)
    {
        OLED_Pixel_160128RGB(WHITE);
    }
    for(i=0;i<40;i++)
    {
        blue = 0x00;
        green = 0x00;
        red = 0xFF;
        OLED_SetPosition_160128RGB(0,(2+i));
        OLED_WriteMemoryStart_160128RGB();
        OLED_Pixel_160128RGB(WHITE);
        OLED_Pixel_160128RGB(WHITE);
        for(j=0;j<26;j++)
        {
            OLED_Data_160128RGB(blue);
            OLED_Data_160128RGB(green);
            OLED_Data_160128RGB(red);
            green += 9;
        }
        for(j=0;j<26;j++)
        {
            OLED_Data_160128RGB(blue);
            OLED_Data_160128RGB(green);
            OLED_Data_160128RGB(red);
            red -= 9;
        }
        for(j=0;j<26;j++)
        {
            OLED_Data_160128RGB(blue);
            OLED_Data_160128RGB(green);
            OLED_Data_160128RGB(red);
            blue += 9;
        }
        for(j=0;j<26;j++)
        {
            OLED_Data_160128RGB(blue);
            OLED_Data_160128RGB(green);
            OLED_Data_160128RGB(red);
            green -= 9;
        }
        for(j=0;j<26;j++)
        {
            OLED_Data_160128RGB(blue);
            OLED_Data_160128RGB(green);
            OLED_Data_160128RGB(red);
            red += 9;
        }
        for(j=0;j<26;j++)
        {
            OLED_Data_160128RGB(blue);
            OLED_Data_160128RGB(green);
            OLED_Data_160128RGB(red);
            blue -= 9;
        }
        OLED_Pixel_160128RGB(WHITE);
        OLED_Pixel_160128RGB(WHITE);
    }
    
    OLED_SetPosition_160128RGB(0,42);
    OLED_WriteMemoryStart_160128RGB();
    for(i=0;i<160;i++)
    {
        OLED_Pixel_160128RGB(WHITE);
    }
    OLED_SetPosition_160128RGB(0,43);
    OLED_WriteMemoryStart_160128RGB();
    for(i=0;i<160;i++)
    {
        OLED_Pixel_160128RGB(WHITE);
    }
}

/*===============================*/
/*==== HIGH LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/


/*********************************/
/******** INITIALIZATION *********/
/************ START **************/
/*********************************/

void OLED_Init_160128RGB(void)      //OLED initialization
{
    digitalWrite(RES_PIN, LOW);
    delay(2);
    digitalWrite(RES_PIN, HIGH);
    delay(2);
    
    // display off, analog reset
    OLED_Command_160128RGB(0x04);
    OLED_Data_160128RGB(0x01);
    delay(1);
    
     // normal mode
    OLED_Command_160128RGB(0x04); 
    OLED_Data_160128RGB(0x00); 
    delay(1);
    
    // display off
    OLED_Command_160128RGB(0x06);
    OLED_Data_160128RGB(0x00);
    delay(1);
    
    // turn on internal oscillator using external resistor
    OLED_Command_160128RGB(0x02);
    OLED_Data_160128RGB(0x01); 
    
    // 90 hz frame rate, divider 0
    OLED_Command_160128RGB(0x03);
    OLED_Data_160128RGB(0x30); 
    
    // duty cycle 127
    OLED_Command_160128RGB(0x28);
    OLED_Data_160128RGB(0x7F);
    
    // start on line 0
    OLED_Command_160128RGB(0x29);
    OLED_Data_160128RGB(0x00); 
    
    // rgb_if
    OLED_Command_160128RGB(0x14);
    OLED_Data_160128RGB(0x31); 
    
    // Set Memory Write Mode
    OLED_Command_160128RGB(0x16);
    OLED_Data_160128RGB(0x76);
    
    // driving current r g b (uA)
    OLED_Command_160128RGB(0x10);
    OLED_Data_160128RGB(0x45);
    OLED_Command_160128RGB(0x11);
    OLED_Data_160128RGB(0x34);
    OLED_Command_160128RGB(0x12);
    OLED_Data_160128RGB(0x33);
    
    // precharge time r g b
    OLED_Command_160128RGB(0x08);
    OLED_Data_160128RGB(0x04);
    OLED_Command_160128RGB(0x09);
    OLED_Data_160128RGB(0x05);
    OLED_Command_160128RGB(0x0A);
    OLED_Data_160128RGB(0x05);
    
    // precharge current r g b (uA)
    OLED_Command_160128RGB(0x0B);
    OLED_Data_160128RGB(0x9D);
    OLED_Command_160128RGB(0x0C);
    OLED_Data_160128RGB(0x8C);
    OLED_Command_160128RGB(0x0D);
    OLED_Data_160128RGB(0x57);
    
    // Set Reference Voltage Controlled by External Resister
    OLED_Command_160128RGB(0x80);
    OLED_Data_160128RGB(0x00);
    
    // mode set
    OLED_Command_160128RGB(0x13);
    OLED_Data_160128RGB(0xA0);
    
    OLED_SetColumnAddress_160128RGB(0, 159);
    OLED_SetRowAddress_160128RGB(0, 127);

    // Display On
    OLED_Command_160128RGB(0x06);
    OLED_Data_160128RGB(0x01); 
}

/*===============================*/
/*======= INITIALIZATION ========*/
/*============= END =============*/
/*===============================*/

void setup()                                       // for Arduino, runs first at power on
{
    pinMode(LVL_OEN, OUTPUT);                       // configure LVL_OEN as output
    digitalWrite(LVL_OEN, LOW);
    pinMode(LVL_DIR, OUTPUT);                       // configure LVL_DIR as output
    digitalWrite(LVL_DIR, HIGH);
    DDRD = 0xFF;                                    // configure PORTD as output
    pinMode(RS_PIN, OUTPUT);                        // configure RS_PIN as output
    pinMode(RES_PIN, OUTPUT);                       // configure RES_PIN as output
    pinMode(CS_PIN, OUTPUT);                        // configure CS_PIN as output
    pinMode(PS_PIN, OUTPUT);                        // configure PS_PIN as output
    pinMode(CPU_PIN, OUTPUT);                       // configure CPU_PIN as output
    digitalWrite(LVL_OEN, LOW);
    digitalWrite(CS_PIN, HIGH);                     // set CS_PIN
    switch(interface)
    {
        case 0:
            pinMode(RW_PIN, OUTPUT);                    // configure RW_PIN as output
            pinMode(E_PIN, OUTPUT);                     // configure E_PIN as output
            digitalWrite(PS_PIN, HIGH);                 // set PS_PIN
            digitalWrite(CPU_PIN, HIGH);                // set CPU_PIN
            digitalWrite(RW_PIN, LOW);                  // reset RW_PIN
            digitalWrite(E_PIN, HIGH);                  // set E_PIN
            break;
        case 1:
            pinMode(WR_PIN, OUTPUT);                    // configure WR_PIN as output
            pinMode(RD_PIN, OUTPUT);                    // configure RD_PIN as output
            digitalWrite(PS_PIN, HIGH);                 // set PS_PIN
            digitalWrite(CPU_PIN, LOW);                 // reset CPU_PIN
            digitalWrite(WR_PIN, HIGH);                 // set WR_PIN
            digitalWrite(RD_PIN, HIGH);                 // set RD_PIN
            break;
        case 2:
            pinMode(SDI_PIN, OUTPUT);                   // configure SDI_PIN as output
            pinMode(SCL_PIN, OUTPUT);                   // configure SCL_PIN as output
            PORTD = 0x00;                               // reset SDI_PIN and SCL_PIN, ground DB[5..0] of the display
            digitalWrite(PS_PIN, LOW);                  // reset PS_PIN
            break;
        default:
            break;
    }
}

void loop()                                         // main loop, runs after "setup()"
{
    OLED_Init_160128RGB();                           // initialize display
    
    OLED_FillScreen_160128RGB(BLACK);                // fill screen with black
    
    OLED_NHDText_160128RGB(GREEN, BLACK);            // show NEWHAVEN DISPLAY
    
    OLED_Text_160128RGB(20, 58, 40, WHITE, BLACK);   // H
    OLED_Text_160128RGB(27, 58, 69, WHITE, BLACK);   // e
    OLED_Text_160128RGB(34, 58, 76, WHITE, BLACK);   // l
    OLED_Text_160128RGB(41, 58, 76, WHITE, BLACK);   // l
    OLED_Text_160128RGB(48, 58, 79, WHITE, BLACK);   // o
    OLED_Text_160128RGB(55, 58, 0, WHITE, BLACK);    //
    
    OLED_Text_160128RGB(62, 58, 55, WHITE, BLACK);   // W
    OLED_Text_160128RGB(69, 58, 79, WHITE, BLACK);   // o
    OLED_Text_160128RGB(76, 58, 82, WHITE, BLACK);   // r
    OLED_Text_160128RGB(83, 58, 76, WHITE, BLACK);   // l
    OLED_Text_160128RGB(90, 58, 68, WHITE, BLACK);   // d
    OLED_Text_160128RGB(97, 58, 1, WHITE, BLACK);    // !
    
    OLED_Icon_160128RGB(120, 52);                    // show icon
    
    OLED_Spectrum_160128RGB();                       // show color spectrum
    
    while(1);                                        // wait here forever
}

NHD-4.3CTP-SHIELD

FT801 Arduino Library

To write "Hello World" text

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           HelloWorld.ino
* @brief                          Sketch to display hello world on FT801.
								  Tested platform version: Arduino 1.0.4 and later
* @version                        0.1.0
* @date                           2014/17/05
*
*/


/* This application demonstrates the usage of FT801 library on NHD_43CTP_SHIELD platform */

/* Arduino standard includes */
#include "SPI.h"
#include "Wire.h"

/* Platform specific includes */
#include "FT_NHD_43CTP_SHIELD.h"

/* Global object for FT801 Implementation */
FT801IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

/* Api to bootup FT801, verify FT801 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure()
{
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);
	
	/* Identify the chip */
	if(FT801_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}
	
	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
    FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 	
	FTImpl.AudioOn();  		
	return 0;
}

/* API to display Hello World string on the screen */
void HelloWorld()
{
	/* Change the below string for experimentation */
	const char Display_string[12] = "Hello World";
	
	/* Display list to display "Hello World" at the centre of display area */
	FTImpl.DLStart();//start the display list. Note DLStart and DLEnd are helper apis, Cmd_DLStart() and Display() can also be utilized.
	FTImpl.ColorRGB(0xFF,0xFF,0xFF);//set the color of the string to while color
	FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2, FT_DISPLAYHEIGHT/2, 29, FT_OPT_CENTER, Display_string);//display "Hello World at the center of the screen using inbuilt font handle 29 "
	FTImpl.DLEnd();//end the display list
	FTImpl.Finish();//render the display list and wait for the completion of the DL
}

/* bootup the module and display "Hello World" on screen */
void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{
		HelloWorld();
	}
	Serial.println("--End Application--");
}

/* Nothing in loop api */
void loop()
{
}

To display and transform a bitmap

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           Bitmaps.ino
* @brief                          Sketch to display bitmaps on FT801.
								  Tested platform version: Arduino 1.0.4 and later
* @version                        0.1.0
* @date                           2014/17/05
*
*/


/* This application demonstrates the usage of FT801 library on NHD_43CTP_SHIELD platform */

/* Arduino standard includes */
#include "SPI.h"
#include "Wire.h"

/* Platform specific includes */
#include "FT_NHD_43CTP_SHIELD.h"

/* Application specific includes */
#include "Lena_RawData.h"

/* Global object for FT801 Implementation */
FT801IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

/* Lena face bitmap raw data and respective structure */
typedef struct Bitmap_header
{
	uint8_t Format;
	int16_t Width;
	int16_t Height;
	int16_t Stride;
	int32_t Arrayoffset;
}Bitmap_header_t;

Bitmap_header_t Lena40_Header[] = 
{
	/* format,width,height,stride,arrayoffset */
	{FT_RGB565,	40,	40,	40*2,	0	},
};
/* Macro for size of raw data */
#define Lena40_SIZE (2769)


/* Api to bootup FT801, verify FT801 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure()
{
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);
	
	/* Identify the chip */
	if(FT801_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}
	
	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
    FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 	
	FTImpl.AudioOn();  		
	return 0;
}

/* Display lena face at different locations with various colors, -ve offsets, alpha blend etc */
void Bitmaps()
{
	Bitmap_header_t *p_bmhdr;
	int16_t BMoffsetx,BMoffsety;

	p_bmhdr = (Bitmap_header_t *)&Lena40_Header[0];
	/* Copy raw data into address 0 followed by generation of bitmap */
	FTImpl.Writefromflash(FT_RAM_G,&Lena40_RawData[p_bmhdr->Arrayoffset], p_bmhdr->Stride*p_bmhdr->Height);

	/* Display list to demonstrate the display of lena bitmap at various co ordinates and various colors */
	FTImpl.DLStart();//start the display list	
	FTImpl.BitmapSource(FT_RAM_G);//set the source address of bitmap to starting address of graphis ram
	FTImpl.BitmapLayout(p_bmhdr->Format, p_bmhdr->Stride, p_bmhdr->Height);//set the layout of the bitmap
	FTImpl.BitmapSize(FT_NEAREST,FT_BORDER,FT_BORDER, p_bmhdr->Width, p_bmhdr->Height);//set the bitmap size
	FTImpl.Begin(FT_BITMAPS); // start drawing bitmaps
	
	FTImpl.ColorRGB(255,255,255);//set the color of the bitmap to white
	BMoffsetx = ((FT_DISPLAYWIDTH/4) - (p_bmhdr->Width/2));
	BMoffsety = ((FT_DISPLAYHEIGHT/2) - (p_bmhdr->Height/2));
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorRGB(255, 64, 64); // set the color of the bitmap
	BMoffsetx = ((FT_DISPLAYWIDTH*2/4) - (p_bmhdr->Width/2));
	BMoffsety = ((FT_DISPLAYHEIGHT/2) - (p_bmhdr->Height/2));
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorRGB(64, 180, 64); // set the color of the bitmap
	BMoffsetx += (p_bmhdr->Width/2);
	BMoffsety += (p_bmhdr->Height/2);
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorRGB(255, 255, 64); // transparent yellow at (232, 152)
	FTImpl.ColorA(150);
	BMoffsetx += (p_bmhdr->Width/2);
	BMoffsety += (p_bmhdr->Height/2);
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorA(255);//reset the alpha to 255
	FTImpl.ColorRGB(255,255,255);
	FTImpl.Vertex2f(-10*16, -10*16);//for -ve coordinates use vertex2f instruction
	FTImpl.End();
	
	FTImpl.DLEnd();//end the display list
	FTImpl.Finish();//render the display list and wait for the completion of the DL
}

/* bootup the module and display bitmaps on screen */
void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{
		Bitmaps();
	}
	Serial.println("--End Application--");
}

/* Nothing in loop api */
void loop()
{
}

To decode and display a JPG

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           LoadImage.ino
* @brief                          Sketch to demonstrate useage of jpg decode functionality and display decoded bitmaps.
								  Tested platform version: Arduino 1.0.4 and later
* @version                        0.1.0
* @date                           2014/17/05
*
*/

/* This application demonstrates the usage of FT801 library on NHD_43CTP_SHIELD platform */

/* Arduino standard includes */
#include "SPI.h"
#include "Wire.h"

/* Platform specific includes */
#include "FT_NHD_43CTP_SHIELD.h"

/* Macro for size of raw data */
#define GOLF_JPEGDATA_SIZE 	(4187)
#define FT_NUM_BITMAPCELLS 		(4)
/* Application specific includes */
#include "Golf_JpegData.h"

/* Global object for FT801 Implementation */
FT801IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

/* Lena face bitmap raw data and respective structure */
typedef struct Bitmap_header
{
	uint8_t Format;
	int16_t Width;
	int16_t Height;
	int16_t Stride;
	int32_t Arrayoffset;
}Bitmap_header_t;

Bitmap_header_t Golf_Header[] = 
{
	/* format,width,height,stride,arrayoffset */
	{FT_RGB565,	68,	86,	68*2,	0	},
};


/* Api to bootup FT801, verify FT801 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure()
{
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);

	/* Identify the chip */
	if(FT801_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}

	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
	FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 	
	FTImpl.AudioOn();  		
	return 0;
}

/* API to demonstrate the usage of Loadimage command - compression done via jpeg baseline profile */
void LoadImage()
{
	const Bitmap_header_t *pBitmapHdr = NULL;
	int16_t xoffset,yoffset;
	
	/*************************************************************************/
	/* Below code demonstrates the usage of LoadImage functionality          */
	/* Download the jpeg encoded data into command buffer and in turn 		 */
	/* coprocessor decodes the jpeg data and output at 0 location			 */
	/*************************************************************************/

	pBitmapHdr = &Golf_Header[0];
	
	/* Calculate the screen centre offset based on image dimension */
	xoffset = ((FT_DISPLAYWIDTH - pBitmapHdr->Width*FT_NUM_BITMAPCELLS)/2);
	yoffset = ((FT_DISPLAYHEIGHT - pBitmapHdr->Height)/2);

	/* Clear the memory at location 0 - any previous junk or bitmap data */	
	FTImpl.Cmd_Memset(0L,255L,1L*pBitmapHdr->Stride*pBitmapHdr->Height*FT_NUM_BITMAPCELLS);

	/* Construction of display list to display background and set of golf bitmaps on the foreground */
	FTImpl.DLStart();//start the display list. Note DLStart and DLEnd are helper apis, Cmd_DLStart() and Display() can also be utilized.
	FTImpl.ClearColorRGB(0,255,255);//clear the background color
	FTImpl.Clear(1,0,0);//clear the color component
	FTImpl.ColorRGB(255,255,255);//set the bitmap color to White
	
	/* Assign the bitmap parameters and display the bitmap at (xoffset,yoffset) coordinates */
	FTImpl.Begin(FT_BITMAPS);
	FTImpl.BitmapSource(0);
	FTImpl.BitmapLayout(pBitmapHdr->Format,pBitmapHdr->Stride,pBitmapHdr->Height);
	FTImpl.BitmapSize(FT_BILINEAR,FT_BORDER,FT_BORDER,pBitmapHdr->Width,pBitmapHdr->Height);
	FTImpl.Vertex2ii(xoffset,yoffset,0,0);//display Lena at (xoffset,yoffset) pixel coordinates
	xoffset += pBitmapHdr->Width;
	yoffset += 10;
	FTImpl.Vertex2ii(xoffset,yoffset,0,1);//display other cells
	xoffset += pBitmapHdr->Width;
	yoffset += 10;
	FTImpl.Vertex2ii(xoffset,yoffset,0,2);
	xoffset += pBitmapHdr->Width;
	yoffset += 10;
	FTImpl.Vertex2ii(xoffset,yoffset,0,3);
	FTImpl.End();

	/* Display of information string at (xoffset,yoffset) pixel coordinates */
	xoffset = (FT_DISPLAYWIDTH/2);
	yoffset = ((FT_DISPLAYHEIGHT - pBitmapHdr->Height - 20)/2);
	FTImpl.ColorRGB(0x000000);//set the color of the informative text to black
	FTImpl.Cmd_Text(xoffset, yoffset, 26, FT_OPT_CENTER, "Display bitmap by LoadImage");
	FTImpl.DLEnd();
	
	/* Wait till coprocessor completes the operation */
	FTImpl.Finish();//after this White color rectangle will be visible on the screen

	/* decode jpeg data into location 0 */
	FTImpl.Cmd_LoadImage(0,FT_OPT_NODL);//using option not to generate DL for jpeg image
	/* Copy the jpeg data into coprocessor fifo */
	FTImpl.WriteCmdfromflash(Golf_JpegData,1L*GOLF_JPEGDATA_SIZE);	
}
/* bootup the module and display golf bitmaps on screen using jpeg decode command */
void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{
		LoadImage();
	}
	Serial.println("--End Application--");
}

/* Nothing in loop api */
void loop()
{
}

To play sound on a virtual piano

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           FT_App_Music.ino
* @brief                          Sample application to demonstrat FT801 primitives, widgets and customized screen shots. 
* @version                        0.1.0
* @date                           2014/03/21
*
*/


#include "SPI.h"
#include "Wire.h"
#include "FT_NHD_43CTP_SHIELD.h"



FT801IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

uint32_t coprostatus = 0;
PROGMEM prog_uchar home_star_icon[] = {0x78,0x9C,0xE5,0x94,0xBF,0x4E,0xC2,0x40,0x1C,0xC7,0x7F,0x2D,0x04,0x8B,0x20,0x45,0x76,0x14,0x67,0xA3,0xF1,0x0D,0x64,0x75,0xD2,0xD5,0x09,0x27,0x17,0x13,0xE1,0x0D,0xE4,0x0D,0x78,0x04,0x98,0x5D,0x30,0x26,0x0E,0x4A,0xA2,0x3E,0x82,0x0E,0x8E,0x82,0xC1,0x38,0x62,0x51,0x0C,0x0A,0x42,0x7F,0xDE,0xB5,0x77,0xB4,0x77,0x17,0x28,0x21,0x26,0x46,0xFD,0x26,0xCD,0xE5,0xD3,0x7C,0xFB,0xBB,0xFB,0xFD,0xB9,0x02,0xCC,0xA4,0xE8,0x99,0x80,0x61,0xC4,0x8A,0x9F,0xCB,0x6F,0x31,0x3B,0xE3,0x61,0x7A,0x98,0x84,0x7C,0x37,0xF6,0xFC,0xC8,0xDD,0x45,0x00,0xDD,0xBA,0xC4,0x77,0xE6,0xEE,0x40,0xEC,0x0E,0xE6,0x91,0xF1,0xD2,0x00,0x42,0x34,0x5E,0xCE,0xE5,0x08,0x16,0xA0,0x84,0x68,0x67,0xB4,0x86,0xC3,0xD5,0x26,0x2C,0x20,0x51,0x17,0xA2,0xB8,0x03,0xB0,0xFE,0x49,0xDD,0x54,0x15,0xD8,0xEE,0x73,0x37,0x95,0x9D,0xD4,0x1A,0xB7,0xA5,0x26,0xC4,0x91,0xA9,0x0B,0x06,0xEE,0x72,0xB7,0xFB,0xC5,0x16,0x80,0xE9,0xF1,0x07,0x8D,0x3F,0x15,0x5F,0x1C,0x0B,0xFC,0x0A,0x90,0xF0,0xF3,0x09,0xA9,0x90,0xC4,0xC6,0x37,0xB0,0x93,0xBF,0xE1,0x71,0xDB,0xA9,0xD7,0x41,0xAD,0x46,0xEA,0x19,0xA9,0xD5,0xCE,0x93,0xB3,0x35,0x73,0x0A,0x69,0x59,0x91,0xC3,0x0F,0x22,0x1B,0x1D,0x91,0x13,0x3D,0x91,0x73,0x43,0xF1,0x6C,0x55,0xDA,0x3A,0x4F,0xBA,0x25,0xCE,0x4F,0x04,0xF1,0xC5,0xCF,0x71,0xDA,0x3C,0xD7,0xB9,0xB2,0x48,0xB4,0x89,0x38,0x20,0x4B,0x2A,0x95,0x0C,0xD5,0xEF,0x5B,0xAD,0x96,0x45,0x8A,0x41,0x96,0x7A,0x1F,0x60,0x0D,0x7D,0x22,0x75,0x82,0x2B,0x0F,0xFB,0xCE,0x51,0x3D,0x2E,0x3A,0x21,0xF3,0x1C,0xD9,0x38,0x86,0x2C,0xC6,0x05,0xB6,0x7B,0x9A,0x8F,0x0F,0x97,0x1B,0x72,0x6F,0x1C,0xEB,0xAE,0xFF,0xDA,0x97,0x0D,0xBA,0x43,0x32,0xCA,0x66,0x34,0x3D,0x54,0xCB,0x24,0x9B,0x43,0xF2,0x70,0x3E,0x42,0xBB,0xA0,0x95,0x11,0x37,0x46,0xE1,0x4F,0x49,0xC5,0x1B,0xFC,0x3C,0x3A,0x3E,0xD1,0x65,0x0E,0x6F,0x58,0xF8,0x9E,0x5B,0xDB,0x55,0xB6,0x41,0x34,0xCB,0xBE,0xDB,0x87,0x5F,0xA9,0xD1,0x85,0x6B,0xB3,0x17,0x9C,0x61,0x0C,0x9B,0xA2,0x5D,0x61,0x10,0xED,0x2A,0x9B,0xA2,0x5D,0x61,0x10,0xED,0x2A,0x9B,0xA2,0x5D,0x61,0x10,0xED,0x2A,0x9B,0xED,0xC9,0xFC,0xDF,0x14,0x54,0x8F,0x80,0x7A,0x06,0xF5,0x23,0xA0,0x9F,0x41,0xF3,0x10,0x30,0x4F,0x41,0xF3,0x18,0x30,0xCF,0xCA,0xFC,0xFF,0x35,0xC9,0x79,0xC9,0x89,0xFA,0x33,0xD7,0x1D,0xF6,0x5E,0x84,0x5C,0x56,0x6E,0xA7,0xDA,0x1E,0xF9,0xFA,0xAB,0xF5,0x97,0xFF,0x2F,0xED,0x89,0x7E,0x29,0x9E,0xB4,0x9F,0x74,0x1E,0x69,0xDA,0xA4,0x9F,0x81,0x94,0xEF,0x4F,0xF6,0xF9,0x0B,0xF4,0x65,0x51,0x08};

char *info[] =  {  "FT801 Music Application",
                   "APP to demonstrate interactive Piano,",
                   "using Rectangles, Buttons,Slider ",
                   "&synthesized Sound"
                }; 

/***********************API used to SET the ICON******************************************/
/*Refer the code flow in the flowchart availble in the Application Note */


void home_setup()
{

	
  /*Icon  file is deflated use J1 Command to inflate the file and write into the GRAM*/
  FTImpl.WriteCmd(CMD_INFLATE);
  FTImpl.WriteCmd(250*1024L);
  FTImpl.WriteCmdfromflash(home_star_icon,sizeof(home_star_icon));
  /*Set the Bitmap properties for the ICONS*/ 	
  FTImpl.DLStart( );        // start
  FTImpl.Clear(1,1,1);
  FTImpl.ColorRGB(255, 255, 255);
  FTImpl.BitmapHandle(13);    // handle for background stars
  FTImpl.BitmapSource(250*1024L);      // Starting address in gram
  FTImpl.BitmapLayout(FT_L4, 16, 32);  // format 
  FTImpl.BitmapSize(FT_NEAREST, FT_REPEAT, FT_REPEAT, 512, 512);
  FTImpl.BitmapHandle(14);    // handle for background stars
  FTImpl.BitmapSource(250*1024L);      // Starting address in gram
  FTImpl.BitmapLayout(FT_L4, 16, 32);  // format 
  FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 32, 32  );
  FTImpl.Display();
  FTImpl.Cmd_Swap();
  FTImpl.Finish();
}
/********API to return the assigned TAG value when penup,for the primitives/widgets******/

static uint8_t keypressed=0;
uint8_t Read_Keys()
{
  static uint8_t Read_tag=0,temp_tag=0,ret_tag=0;	
  Read_tag = FTImpl.Read(REG_TOUCH_TAG);
  ret_tag = NULL;
  if(Read_tag!=NULL)								// Allow if the Key is released
  {
    if(temp_tag!=Read_tag)
    {
      temp_tag = Read_tag;	
      keypressed = Read_tag;										// Load the Read tag to temp variable	
    }  
  }
  else
  {
    if(temp_tag!=0)
    {
      ret_tag = temp_tag;
	  temp_tag = 0;
    }  
    keypressed = 0;
  }
  return ret_tag;
}

// Info Screen//
void Info()
{
  uint16_t dloffset = 0,z;

  FTImpl.DLStart( ); 
  FTImpl.Clear(1,1,1);
  FTImpl.ColorRGB(255,255,255);
  FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,FT_DISPLAYHEIGHT/2,26,FT_OPT_CENTERX|FT_OPT_CENTERY,"Please tap on a dot");
  FTImpl.Cmd_Calibrate(0);
  FTImpl.Display();
  FTImpl.Cmd_Swap();
  FTImpl.Finish();
// Ftdi Logo animation 
  FTImpl.Cmd_Logo();
	while(FTImpl.CheckLogo() != FT_GE_FINISHED);
  dloffset = FTImpl.Read16(REG_CMD_DL);
  dloffset -=4;
  //Copy the Displaylist from DL RAM to GRAM
  FTImpl.WriteCmd(CMD_MEMCPY);
  FTImpl.WriteCmd(100000L);
  FTImpl.WriteCmd(FT_RAM_DL);
  FTImpl.WriteCmd(dloffset);
  //Enter into Info Screen
  do
  {
    FTImpl.DLStart( );   
    FTImpl.Cmd_Append(100000L,dloffset);
    //Reset the BITMAP properties used during Logo animation
    FTImpl.BitmapTransformA(256);
    FTImpl.BitmapTransformA(256);
    FTImpl.BitmapTransformB(0);
    FTImpl.BitmapTransformC(0);
    FTImpl.BitmapTransformD(0);
    FTImpl.BitmapTransformE(256);
    FTImpl.BitmapTransformF(0);  
    FTImpl.SaveContext();	
    //Display the information with transparent Logo using Edge Strip  
    FTImpl.ColorRGB(219,180,150);
    FTImpl.ColorA(220);
    FTImpl.Begin(FT_EDGE_STRIP_A);
    FTImpl.Vertex2f(0,FT_DISPLAYHEIGHT*16);
    FTImpl.Vertex2f(FT_DISPLAYWIDTH*16,FT_DISPLAYHEIGHT*16);
    FTImpl.ColorA(255);
    FTImpl.RestoreContext();	
    FTImpl.ColorRGB(0,0,0);
   // INFORMATION 
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,20,28,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[0]);
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,60,26,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[1]);
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,90,26,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[2]);  
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,120,26,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[3]);  
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,FT_DISPLAYHEIGHT-30,26,FT_OPT_CENTERX|FT_OPT_CENTERY,"Click to play");
    //Check if the Play key enter then change the color
    if(keypressed!='P')
    FTImpl.ColorRGB(255,255,255);
    else
    FTImpl.ColorRGB(100,100,100);
    FTImpl.Begin(FT_POINTS);   
    FTImpl.PointSize(20*16);
    FTImpl.Tag('P');
    FTImpl.Vertex2f((FT_DISPLAYWIDTH/2)*16,(FT_DISPLAYHEIGHT-60)*16);
    FTImpl.ColorRGB(180,35,35);
    FTImpl.Begin(FT_BITMAPS);
    FTImpl.Vertex2ii((FT_DISPLAYWIDTH/2)-14,(FT_DISPLAYHEIGHT-75),14,4);
    FTImpl.Display();
    FTImpl.Cmd_Swap();
	FTImpl.Finish();
  }while(Read_Keys()!='P');
  
  /* wait until Play key is not pressed*/ 
} 


struct 
{
    uint8_t sound : 1;
}Flag;



void Music_Keys(uint8_t no,uint16_t xx,uint16_t y,uint8_t btspace,uint8_t btw,uint8_t bth,uint8_t tag_no,uint32_t fgc1,uint32_t fgc2,uint8_t rtag)
{
  uint16_t x,z;	
  for(z=0;z<no;z++)
  {
    x = z*(btw+btspace)+xx;								
    rtag==(z+tag_no) ? FTImpl.Cmd_FGColor(fgc1) : FTImpl.Cmd_FGColor(fgc2);
    FTImpl.Tag(z+tag_no);	
    FTImpl.Cmd_Button(x,y,btw,bth,16,FT_OPT_FLAT,"");		
  }
}


void Music(void)
{
  uint8_t  instr,Mkeys,Skeys,temp_keys,
           z,button_space,
	       button_w,button_h,
	       Volume,b1w,b1h,b1s,pk;

  uint32_t Read_Tag_val;
  uint16_t x,y,n,temp;
sTrackTag sTracktag;
	

  const char *ins[] = {"Harp","Xylophone","Tuba","Glockenspiel","Organ","Trumpet","Piano","Chimes","Musicbox","Ding" };
// Intial stage
  instr = 0x40;
  Volume = 100;
  button_space = 2;						// space between buttons					
  button_w = (FT_DISPLAYWIDTH / 10)-button_space;			// Button width	
  button_h = (FT_DISPLAYHEIGHT - (FT_DISPLAYHEIGHT/3));		// Button Height		
  b1w = button_w/2;                                             // button width one
  b1h = button_h/2;
  b1s = b1w+button_space;
 // Set the tracker for the Volume adjuster 
  FTImpl.Cmd_DLStart();      
  FTImpl.Cmd_Track(200,20,100,10,'V');   
  FTImpl.Finish();
  FTImpl.Write(REG_VOL_SOUND,100);
  do
  {
    FTImpl.Cmd_DLStart();                                    // start		
    FTImpl.Clear(1,1,1);
    FTImpl.TagMask(1);
    FTImpl.Tag(0);
    FTImpl.Cmd_Gradient(0,0,0x0,480,0,0x505050);
// for music keys
    Music_Keys(10,0,100,2,button_w,button_h,1,0xA0A080,0xFFFFFF,Mkeys);    // noofbuttons,xaxis,yaxis,bs,bw,bh,starting tagno,fgcolor1,fgcolor2,current tag
    Music_Keys(2,button_w*0.782,98,b1s,b1w,b1h,11,0xA0A080,0,Mkeys);
    Music_Keys(3,(3*(button_w+2))+(button_w*0.782),98,b1s,b1w,b1h,13,0xA0A080,0,Mkeys);
    Music_Keys(2,(7*(button_w+2))+(button_w*0.782),98,b1s,b1w,b1h,16,0xA0A080,0,Mkeys);
// Set the Background colors		
    FTImpl.Cmd_BGColor(0x402000);
    FTImpl.Cmd_FGColor(0x703800);
    FTImpl.Tag('I');
    FTImpl.Cmd_Button(50,10,100,30,26,(keypressed=='I')?FT_OPT_FLAT:0,ins[instr-0x40]);      // view button
    
    FTImpl.Tag('V');	
    FTImpl.Cmd_Slider(200,20,100,10,0,Volume,255);
    
    FTImpl.Cmd_Text(155,20,26,FT_OPT_CENTERY,"Vol -");
    FTImpl.Cmd_Text(305,15,26,FT_OPT_CENTERY,"+");
    FTImpl.Cmd_Keys(0,50,FT_DISPLAYWIDTH,40,28,Mkeys|FT_OPT_CENTER,"123456789");
// Sound Selection screen
    if(Flag.sound)	
    {
      FTImpl.Clear(0,0,1);	
      FTImpl.SaveContext();
      FTImpl.ColorRGB(0,0,0);
      FTImpl.ColorA(175);
      FTImpl.Begin(FT_RECTS);
      FTImpl.Vertex2ii(0,0,0,0);
      FTImpl.Vertex2ii(FT_DISPLAYWIDTH,FT_DISPLAYHEIGHT,0,0);
      FTImpl.End();
      FTImpl.RestoreContext();
      x = (uint16_t)(FT_DISPLAYWIDTH*0.270);
      uint16_t dt = 130; 
	  #if (FT_DISPLAY_RESOLUTION == FT_DISPLAY_QVGA_320x240)
      dt = 50;
      #endif
	  
// Draw the sound selection menu bar        
      for(z=0;z<10;z++)
      {
        y = 10+(40*(z%5));						// space bw keys in col 
        x = dt+(120*(z/5));
		FTImpl.Tag(z+100);	//Tagval from 100
		FTImpl.Cmd_Button(x,y,100,30,26,(keypressed==z+100)?FT_OPT_FLAT:0,ins[z]);
      }
    }			
    FTImpl.TagMask(0);				// Disable the tag updation
    FTImpl.Display();
    FTImpl.Cmd_Swap();
    FTImpl.Finish();
		
//Sound change  
    Skeys = Read_Keys();
    Mkeys = FTImpl.Read(REG_TOUCH_TAG);
    if((sTracktag.tag)=='V'){Mkeys = 0;Skeys =0;}
    if(Skeys=='I'){Flag.sound  = 1;
    Mkeys = 0;}
    if(Skeys>=100 && Flag.sound==1)          //Tagval from 100
    {	
      Flag.sound  = 0;
      pk = (Skeys-100);		// assign the selection
      instr = pk|0x40;
    }	
 // Play the sound   
    if(!Flag.sound && Mkeys!='I')
    {
      if(Mkeys > '0' && temp_keys!=Mkeys)
      {
		  FTImpl.Write16(REG_SOUND, 0x50 + (Mkeys-'0'));
		  FTImpl.Write(REG_PLAY,1);
      }
      if(Mkeys !=0 &&  Mkeys < 18 && temp_keys!=Mkeys && Flag.sound==0)
      {	
	  FTImpl.Write16(REG_SOUND,((Mkeys |60) << 8) | instr);
	  FTImpl.Write(REG_PLAY,1);
      }
      FTImpl.GetTrackTag(sTracktag);

      if((sTracktag.tag)=='V' && Flag.sound==0)
      {		
          Volume = (sTracktag.track>>8);
          FTImpl.Write(REG_VOL_SOUND,Volume);
      }
    }
    temp_keys=Mkeys;
  }while(1);
}

/* Api to bootup FT801, verify FT801 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure(){
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);
	
	/* Identify the chip */
	if(FT801_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}
	

	
	
	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
    FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 
	FTImpl.AudioOn(); 	
	return 0;
}

void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{  
		home_setup();
		Info();
		Music();   
		FTImpl.Exit();
	}
	Serial.println("--End Application--");
}

void loop()
{
}
/* Nothing beyond this */

To create a simple UI

Direct Link

//---------------------------------------------------------
/*

FT_App_CarbonationMachine.ino

Program for writing to Newhaven Displays NHD-4.3CTP-SHIELD based on the FT801 controller.

This code is written for the Arduino Mega.

Copyright (c) 2016 - Newhaven Display International, Inc.

Newhaven Display invests time and resources providing this open source code,
please support Newhaven Display by purchasing products from Newhaven Display!

*/
//---------------------------------------------------------

#include <EEPROM.h>
#include <SPI.h>
#include <Wire.h>
#include <FT_NHD_43RTP_SHIELD.h>

#define RAM_IMAGES_SODA1 26700
static PROGMEM prog_uchar IMAGES_SODA1[] = {
	#include "IMAGES_SODA1.h"
};

#define RAM_IMAGES_SODA2 89252
static PROGMEM prog_uchar IMAGES_SODA2[] = {
	#include "IMAGES_SODA3.h"
};

#define RAM_IMAGES_SODA3 150904
static PROGMEM prog_uchar IMAGES_SODA3[] = {
	#include "IMAGES_SODA2.h"
};

FT801IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

int counter=6;
int previous;
int image_count;
unsigned long currentTime;
unsigned long loopTime;
const int pin_A = 7;  // pin 7
const int pin_B = 6;  // pin 6
const int pin_C = 5;  // pin 5
unsigned char encoder_A;
unsigned char encoder_B;
unsigned char encoder_button;
unsigned char encoder_A_prev=0;
int transformA;
int transformE;
int i;
int n;
int wait_time;
int spark_y;
int box_location;
int box_start = 120;
int box_end = 120;

void read_encoder()  {  
  currentTime = millis();                     // get the current elapsed time
  if(currentTime >= (loopTime + 5)){          // 5ms since last check of encoder = 200Hz      
    encoder_A = digitalRead(pin_A);           // Read encoder pins
    encoder_B = digitalRead(pin_B);   
    if((!encoder_A) && (encoder_A_prev)){     // A has gone from high to low      
      if(encoder_B) {                         // B is high so clockwise      
        counter--;
        if(counter==0){counter=13;}        
      }   
      else {                                  // B is low so counter-clockwise 
        counter++;
        if(counter==14){counter=1;}        
      }   

    }   
    encoder_A_prev = encoder_A;               // Store value of A for next time      
    loopTime = currentTime;  // Updates loopTime
  }                         
}

void encoder_click(){
  if(counter<13){
    FTImpl.DLStart();
    FTImpl.ClearColorRGB(255, 255, 255);
    FTImpl.Clear(1, 1, 1);
    FTImpl.End();
    FTImpl.Begin(FT_BITMAPS);
    FTImpl.Vertex2ii(293, 7, image_count, 0);
    FTImpl.End();
    FTImpl.ColorRGB(0, 0, 0);
    FTImpl.Cmd_Text(5, 73, 31, 0, "CARBONATING");
    FTImpl.ColorRGB(201, 132, 63);
    FTImpl.Cmd_Spinner(158, 156, 3, 1);
    FTImpl.DLEnd();
    FTImpl.Finish();
    delay(wait_time);
  }
  else{
        FTImpl.DLStart();
        FTImpl.ClearColorRGB(255, 255, 255);
        FTImpl.Clear(1, 1, 1);
        FTImpl.End();
        FTImpl.ColorRGB(0, 0, 0);
        FTImpl.Cmd_Text(178, 61, 29, 0, "CLEANING");
        FTImpl.ColorRGB(255, 255, 255);
        FTImpl.End();
        FTImpl.Begin(FT_BITMAPS);
        FTImpl.Vertex2ii(183, 95, 0, 0);
        FTImpl.End();
        FTImpl.ColorRGB(201, 132, 63);
        FTImpl.Cmd_Spinner(240, 210, 1, 1);	
        FTImpl.DLEnd();
        FTImpl.Finish();
        delay(5000);
      }          
}

void setup()
{
        pinMode(pin_A, INPUT);
        pinMode(pin_B, INPUT);
        pinMode(pin_C, INPUT);
        currentTime = millis();
        loopTime = currentTime; 
  
  
	FTImpl.Init(FT_DISPLAY_RESOLUTION);FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN);
	FTImpl.DisplayOn();FTImpl.AudioOn();

	FTImpl.DLStart();
	FTImpl.Cmd_Inflate(RAM_IMAGES_SODA1);FTImpl.WriteCmdfromflash(IMAGES_SODA1, sizeof(IMAGES_SODA1));	
        FTImpl.Cmd_Inflate(RAM_IMAGES_SODA2);FTImpl.WriteCmdfromflash(IMAGES_SODA2, sizeof(IMAGES_SODA2));
        FTImpl.Finish();
	FTImpl.DLStart();
	FTImpl.BitmapHandle(1);FTImpl.BitmapSource(26700);FTImpl.BitmapLayout(FT_ARGB1555, 278, 225);FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 139, 225);
        FTImpl.BitmapHandle(2);FTImpl.BitmapSource(89252);FTImpl.BitmapLayout(FT_ARGB1555, 268, 225);FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 134, 225);
        FTImpl.BitmapHandle(0);FTImpl.BitmapSource(211204);FTImpl.BitmapLayout(FT_ARGB1555, 196, 97);FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 98, 97);
        FTImpl.DLEnd();FTImpl.Finish();
        FTImpl.DLStart();
	FTImpl.ClearColorRGB(201, 132, 63);FTImpl.Clear(1, 1, 1);
	FTImpl.ClearColorRGB(0, 0, 0);FTImpl.Cmd_Text(80, 113, 30, 0, "Carbonation Machine");FTImpl.Cmd_Spinner(227, 205, 0, 0);	
	FTImpl.DLEnd();FTImpl.Finish();
        delay(1000);
}

void loop()
{       
       switch (counter){
          case 1:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 2;wait_time = 1000;break; 
          case 2:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 122;wait_time = 1500;break; 
          case 3:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 243;wait_time = 2000;break; 
          case 4:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 360;wait_time = 2500;break;  
          case 5:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 2;wait_time = 1000;break;  
          case 6:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 122;wait_time = 1500;break; 
          case 7:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 243;wait_time = 2000;break; 
          case 8:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 360;wait_time = 2500;break; 
          case 9:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 2;wait_time = 1000;break; 
          case 10:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 122;wait_time = 1500;break;  
          case 11:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 243;wait_time = 2000;break;
          case 12:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 360;wait_time = 2500;break;
       }              
       if(counter<13){
           for(i=20;i<98;i++){
                FTImpl.DLStart();
                FTImpl.ClearColorRGB(255, 255, 255);
                FTImpl.Clear(1, 1, 1);
                FTImpl.End();
        	FTImpl.Cmd_FGColor(0x1DAAEB); 
                box_location = box_end;
        	FTImpl.Cmd_Button(box_location, 40, 100, 155, 27, FT_OPT_FLAT, "");
        	FTImpl.ColorRGB(0, 0, 0);
                FTImpl.Cmd_Text(16, 195, 28, 0, "Small");
        	FTImpl.Cmd_Text(16, spark_y, 27, 0, "Sparkling");
             	FTImpl.Cmd_Text(138, 195, 28, 0, "Medium");
        	FTImpl.Cmd_Text(138, spark_y, 27, 0, "Sparkling");       	
        	FTImpl.Cmd_Text(260, 195, 28, 0, "Large");
        	FTImpl.Cmd_Text(260, spark_y, 27, 0, "Sparkling");
        	FTImpl.Cmd_Text(377, 195, 28, 0, "XL");
        	FTImpl.Cmd_Text(377, spark_y, 27, 0, "Sparkling");
        
                switch (counter){
                    case 1:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light");           
                    break; 
                    case 2:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light");             
                    break; 
                    case 3:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light");             
                    break; 
                    case 4:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light"); 
                    break; 
                    case 5:            
                    break; 
                    case 6:
                    break; 
                    case 7:            
                    break; 
                    case 8:
                    break; 
                    case 9:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");
                    break; 
                    case 10:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");          
                    break; 
                    case 11:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");          
                    break;
                    case 12:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");          
                    break; 
                    }
                                   	
        	FTImpl.ColorRGB(255, 255, 255);
        	FTImpl.Cmd_Progress(144, 10, 180, 12, 0, i, 100);
        	FTImpl.ColorRGB(255, 255, 255);	
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(440);
        	FTImpl.BitmapTransformE(420);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(10, 50, image_count, 0);
        	FTImpl.End();
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(410);
        	FTImpl.BitmapTransformE(390);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(130, 40, image_count, 0);
        	FTImpl.End();
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(380);
        	FTImpl.BitmapTransformE(360);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(247, 30, image_count, 0);
        	FTImpl.End();
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(350);
        	FTImpl.BitmapTransformE(320);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(360, 15, image_count, 0);
                if(i>90){FTImpl.ColorRGB(0, 0, 0);FTImpl.Cmd_Text(337, 7, 29, 0, "READY");FTImpl.ColorRGB(255, 255, 255);}
        	FTImpl.End();
        	FTImpl.DLEnd();
        	FTImpl.Finish();
                i++;i++;i++;i++;i++;
                }
         }      
       else{
        FTImpl.DLStart();
	FTImpl.ClearColorRGB(255, 255, 255);
	FTImpl.Clear(1, 1, 1);
	FTImpl.End();
	FTImpl.ColorRGB(0, 0, 0);
	FTImpl.ColorRGB(255, 255, 255);
	FTImpl.Cmd_Progress(144, 10, 180, 12, 0, 97, 100);
	FTImpl.ColorRGB(0, 0, 0);
	FTImpl.Cmd_Text(337, 7, 29, 0, "READY");
	FTImpl.Cmd_Text(337, 32, 29, 0, "TO CLEAN");
	FTImpl.ColorRGB(255, 255, 255);
	FTImpl.End();
	FTImpl.Begin(FT_BITMAPS);
	FTImpl.Vertex2ii(183, 95, 0, 0);
	FTImpl.End();	
	FTImpl.DLEnd();
	FTImpl.Finish();
  }         
        previous = counter;
        //delay(1000);
        //encoder_click();               
        while (counter == previous){         
          read_encoder();
          encoder_button = digitalRead(pin_C);
          if(!encoder_button){encoder_click();return;}
        }    
        if(counter==14){counter=1;}          
}
/* end of file */

NHD-4.3RTP-SHIELD

FT800 Arduino Library

To write "Hello World" text

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           HelloWorld.ino
* @brief                          Sketch to display hello world on FT800.
								  Tested platform version: Arduino 1.0.4 and later
* @version                        0.1.0
* @date                           2014/17/05
*
*/


/* This application demonstrates the usage of FT800 library on NHD_43RTP_SHIELD platform */

/* Arduino standard includes */
#include "SPI.h"
#include "Wire.h"

/* Platform specific includes */
#include "FT_NHD_43RTP_SHIELD.h"

/* Global object for FT800 Implementation */
FT800IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

/* Api to bootup ft800, verify FT800 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure()
{
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);
	
	/* Identify the chip */
	if(FT800_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}
	
	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
    FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 	
	FTImpl.AudioOn();  		
	return 0;
}

/* API to display Hello World string on the screen */
void HelloWorld()
{
	/* Change the below string for experimentation */
	const char Display_string[12] = "Hello World";
	
	/* Display list to display "Hello World" at the centre of display area */
	FTImpl.DLStart();//start the display list. Note DLStart and DLEnd are helper apis, Cmd_DLStart() and Display() can also be utilized.
	FTImpl.ColorRGB(0xFF,0xFF,0xFF);//set the color of the string to while color
	FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2, FT_DISPLAYHEIGHT/2, 29, FT_OPT_CENTER, Display_string);//display "Hello World at the center of the screen using inbuilt font handle 29 "
	FTImpl.DLEnd();//end the display list
	FTImpl.Finish();//render the display list and wait for the completion of the DL
}

/* bootup the module and display "Hello World" on screen */
void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{
		HelloWorld();
	}
	Serial.println("--End Application--");
}

/* Nothing in loop api */
void loop()
{
}

To display and transform a bitmap

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           Bitmaps.ino
* @brief                          Sketch to display bitmaps on FT800.
								  Tested platform version: Arduino 1.0.4 and later
* @version                        0.1.0
* @date                           2014/17/05
*
*/


/* This application demonstrates the usage of FT800 library on NHD_43RTP_SHIELD platform */

/* Arduino standard includes */
#include "SPI.h"
#include "Wire.h"

/* Platform specific includes */
#include "FT_NHD_43RTP_SHIELD.h"

/* Application specific includes */
#include "Lena_RawData.h"

/* Global object for FT800 Implementation */
FT800IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

/* Lena face bitmap raw data and respective structure */
typedef struct Bitmap_header
{
	uint8_t Format;
	int16_t Width;
	int16_t Height;
	int16_t Stride;
	int32_t Arrayoffset;
}Bitmap_header_t;

Bitmap_header_t Lena40_Header[] = 
{
	/* format,width,height,stride,arrayoffset */
	{FT_RGB565,	40,	40,	40*2,	0	},
};
/* Macro for size of raw data */
#define Lena40_SIZE (2769)


/* Api to bootup ft800, verify FT800 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure()
{
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);
	
	/* Identify the chip */
	if(FT800_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}
	
	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
    FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 	
	FTImpl.AudioOn();  		
	return 0;
}

/* Display lena face at different locations with various colors, -ve offsets, alpha blend etc */
void Bitmaps()
{
	Bitmap_header_t *p_bmhdr;
	int16_t BMoffsetx,BMoffsety;

	p_bmhdr = (Bitmap_header_t *)&Lena40_Header[0];
	/* Copy raw data into address 0 followed by generation of bitmap */
	FTImpl.Writefromflash(FT_RAM_G,&Lena40_RawData[p_bmhdr->Arrayoffset], p_bmhdr->Stride*p_bmhdr->Height);

	/* Display list to demonstrate the display of lena bitmap at various co ordinates and various colors */
	FTImpl.DLStart();//start the display list	
	FTImpl.BitmapSource(FT_RAM_G);//set the source address of bitmap to starting address of graphis ram
	FTImpl.BitmapLayout(p_bmhdr->Format, p_bmhdr->Stride, p_bmhdr->Height);//set the layout of the bitmap
	FTImpl.BitmapSize(FT_NEAREST,FT_BORDER,FT_BORDER, p_bmhdr->Width, p_bmhdr->Height);//set the bitmap size
	FTImpl.Begin(FT_BITMAPS); // start drawing bitmaps
	
	FTImpl.ColorRGB(255,255,255);//set the color of the bitmap to white
	BMoffsetx = ((FT_DISPLAYWIDTH/4) - (p_bmhdr->Width/2));
	BMoffsety = ((FT_DISPLAYHEIGHT/2) - (p_bmhdr->Height/2));
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorRGB(255, 64, 64); // set the color of the bitmap
	BMoffsetx = ((FT_DISPLAYWIDTH*2/4) - (p_bmhdr->Width/2));
	BMoffsety = ((FT_DISPLAYHEIGHT/2) - (p_bmhdr->Height/2));
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorRGB(64, 180, 64); // set the color of the bitmap
	BMoffsetx += (p_bmhdr->Width/2);
	BMoffsety += (p_bmhdr->Height/2);
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorRGB(255, 255, 64); // transparent yellow at (232, 152)
	FTImpl.ColorA(150);
	BMoffsetx += (p_bmhdr->Width/2);
	BMoffsety += (p_bmhdr->Height/2);
	FTImpl.Vertex2ii(BMoffsetx, BMoffsety, 0, 0);
	
	FTImpl.ColorA(255);//reset the alpha to 255
	FTImpl.ColorRGB(255,255,255);
	FTImpl.Vertex2f(-10*16, -10*16);//for -ve coordinates use vertex2f instruction
	FTImpl.End();
	
	FTImpl.DLEnd();//end the display list
	FTImpl.Finish();//render the display list and wait for the completion of the DL
}

/* bootup the module and display bitmaps on screen */
void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{
		Bitmaps();
	}
	Serial.println("--End Application--");
}

/* Nothing in loop api */
void loop()
{
}

To decode and display a JPG

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           LoadImage.ino
* @brief                          Sketch to demonstrate useage of jpg decode functionality and display decoded bitmaps.
								  Tested platform version: Arduino 1.0.4 and later
* @version                        0.1.0
* @date                           2014/17/05
*
*/

/* This application demonstrates the usage of FT800 library on NHD_43RTP_SHIELD platform */

/* Arduino standard includes */
#include "SPI.h"
#include "Wire.h"

/* Platform specific includes */
#include "FT_NHD_43RTP_SHIELD.h"

/* Macro for size of raw data */
#define GOLF_JPEGDATA_SIZE 	(4187)
#define FT_NUM_BITMAPCELLS 		(4)
/* Application specific includes */
#include "Golf_JpegData.h"

/* Global object for FT800 Implementation */
FT800IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

/* Lena face bitmap raw data and respective structure */
typedef struct Bitmap_header
{
	uint8_t Format;
	int16_t Width;
	int16_t Height;
	int16_t Stride;
	int32_t Arrayoffset;
}Bitmap_header_t;

Bitmap_header_t Golf_Header[] = 
{
	/* format,width,height,stride,arrayoffset */
	{FT_RGB565,	68,	86,	68*2,	0	},
};


/* Api to bootup ft800, verify FT800 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure()
{
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);

	/* Identify the chip */
	if(FT800_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}

	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
	FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 	
	FTImpl.AudioOn();  		
	return 0;
}

/* API to demonstrate the usage of Loadimage command - compression done via jpeg baseline profile */
void LoadImage()
{
	const Bitmap_header_t *pBitmapHdr = NULL;
	int16_t xoffset,yoffset;
	
	/*************************************************************************/
	/* Below code demonstrates the usage of LoadImage functionality          */
	/* Download the jpeg encoded data into command buffer and in turn 		 */
	/* coprocessor decodes the jpeg data and output at 0 location			 */
	/*************************************************************************/

	pBitmapHdr = &Golf_Header[0];
	
	/* Calculate the screen centre offset based on image dimension */
	xoffset = ((FT_DISPLAYWIDTH - pBitmapHdr->Width*FT_NUM_BITMAPCELLS)/2);
	yoffset = ((FT_DISPLAYHEIGHT - pBitmapHdr->Height)/2);

	/* Clear the memory at location 0 - any previous junk or bitmap data */	
	FTImpl.Cmd_Memset(0L,255L,1L*pBitmapHdr->Stride*pBitmapHdr->Height*FT_NUM_BITMAPCELLS);

	/* Construction of display list to display background and set of golf bitmaps on the foreground */
	FTImpl.DLStart();//start the display list. Note DLStart and DLEnd are helper apis, Cmd_DLStart() and Display() can also be utilized.
	FTImpl.ClearColorRGB(0,255,255);//clear the background color
	FTImpl.Clear(1,0,0);//clear the color component
	FTImpl.ColorRGB(255,255,255);//set the bitmap color to White
	
	/* Assign the bitmap parameters and display the bitmap at (xoffset,yoffset) coordinates */
	FTImpl.Begin(FT_BITMAPS);
	FTImpl.BitmapSource(0);
	FTImpl.BitmapLayout(pBitmapHdr->Format,pBitmapHdr->Stride,pBitmapHdr->Height);
	FTImpl.BitmapSize(FT_BILINEAR,FT_BORDER,FT_BORDER,pBitmapHdr->Width,pBitmapHdr->Height);
	FTImpl.Vertex2ii(xoffset,yoffset,0,0);//display Lena at (xoffset,yoffset) pixel coordinates
	xoffset += pBitmapHdr->Width;
	yoffset += 10;
	FTImpl.Vertex2ii(xoffset,yoffset,0,1);//display other cells
	xoffset += pBitmapHdr->Width;
	yoffset += 10;
	FTImpl.Vertex2ii(xoffset,yoffset,0,2);
	xoffset += pBitmapHdr->Width;
	yoffset += 10;
	FTImpl.Vertex2ii(xoffset,yoffset,0,3);
	FTImpl.End();

	/* Display of information string at (xoffset,yoffset) pixel coordinates */
	xoffset = (FT_DISPLAYWIDTH/2);
	yoffset = ((FT_DISPLAYHEIGHT - pBitmapHdr->Height - 20)/2);
	FTImpl.ColorRGB(0x000000);//set the color of the informative text to black
	FTImpl.Cmd_Text(xoffset, yoffset, 26, FT_OPT_CENTER, "Display bitmap by LoadImage");
	FTImpl.DLEnd();
	
	/* Wait till coprocessor completes the operation */
	FTImpl.Finish();//after this White color rectangle will be visible on the screen

	/* decode jpeg data into location 0 */
	FTImpl.Cmd_LoadImage(0,FT_OPT_NODL);//using option not to generate DL for jpeg image
	/* Copy the jpeg data into coprocessor fifo */
	FTImpl.WriteCmdfromflash(Golf_JpegData,1L*GOLF_JPEGDATA_SIZE);	
}
/* bootup the module and display golf bitmaps on screen using jpeg decode command */
void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{
		LoadImage();
	}
	Serial.println("--End Application--");
}

/* Nothing in loop api */
void loop()
{
}

To play sound on a virtual piano

Direct Link

/*****************************************************************************
* Copyright (c) Future Technology Devices International 2014
* propriety of Future Technology devices International.
*
* Software License Agreement
*
* This code is provided as an example only and is not guaranteed by FTDI. 
* FTDI accept no responsibility for any issues resulting from its use. 
* The developer of the final application incorporating any parts of this 
* sample project is responsible for ensuring its safe and correct operation 
* and for any consequences resulting from its use.
*****************************************************************************/
/**
* @file                           FT_App_Music.ino
* @brief                          Sample application to demonstrat FT800 primitives, widgets and customized screen shots. 
* @version                        0.1.0
* @date                           2014/03/21
*
*/


#include "SPI.h"
#include "Wire.h"
#include "FT_NHD_43RTP_SHIELD.h"



FT800IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

uint32_t coprostatus = 0;
PROGMEM prog_uchar home_star_icon[] = {0x78,0x9C,0xE5,0x94,0xBF,0x4E,0xC2,0x40,0x1C,0xC7,0x7F,0x2D,0x04,0x8B,0x20,0x45,0x76,0x14,0x67,0xA3,0xF1,0x0D,0x64,0x75,0xD2,0xD5,0x09,0x27,0x17,0x13,0xE1,0x0D,0xE4,0x0D,0x78,0x04,0x98,0x5D,0x30,0x26,0x0E,0x4A,0xA2,0x3E,0x82,0x0E,0x8E,0x82,0xC1,0x38,0x62,0x51,0x0C,0x0A,0x42,0x7F,0xDE,0xB5,0x77,0xB4,0x77,0x17,0x28,0x21,0x26,0x46,0xFD,0x26,0xCD,0xE5,0xD3,0x7C,0xFB,0xBB,0xFB,0xFD,0xB9,0x02,0xCC,0xA4,0xE8,0x99,0x80,0x61,0xC4,0x8A,0x9F,0xCB,0x6F,0x31,0x3B,0xE3,0x61,0x7A,0x98,0x84,0x7C,0x37,0xF6,0xFC,0xC8,0xDD,0x45,0x00,0xDD,0xBA,0xC4,0x77,0xE6,0xEE,0x40,0xEC,0x0E,0xE6,0x91,0xF1,0xD2,0x00,0x42,0x34,0x5E,0xCE,0xE5,0x08,0x16,0xA0,0x84,0x68,0x67,0xB4,0x86,0xC3,0xD5,0x26,0x2C,0x20,0x51,0x17,0xA2,0xB8,0x03,0xB0,0xFE,0x49,0xDD,0x54,0x15,0xD8,0xEE,0x73,0x37,0x95,0x9D,0xD4,0x1A,0xB7,0xA5,0x26,0xC4,0x91,0xA9,0x0B,0x06,0xEE,0x72,0xB7,0xFB,0xC5,0x16,0x80,0xE9,0xF1,0x07,0x8D,0x3F,0x15,0x5F,0x1C,0x0B,0xFC,0x0A,0x90,0xF0,0xF3,0x09,0xA9,0x90,0xC4,0xC6,0x37,0xB0,0x93,0xBF,0xE1,0x71,0xDB,0xA9,0xD7,0x41,0xAD,0x46,0xEA,0x19,0xA9,0xD5,0xCE,0x93,0xB3,0x35,0x73,0x0A,0x69,0x59,0x91,0xC3,0x0F,0x22,0x1B,0x1D,0x91,0x13,0x3D,0x91,0x73,0x43,0xF1,0x6C,0x55,0xDA,0x3A,0x4F,0xBA,0x25,0xCE,0x4F,0x04,0xF1,0xC5,0xCF,0x71,0xDA,0x3C,0xD7,0xB9,0xB2,0x48,0xB4,0x89,0x38,0x20,0x4B,0x2A,0x95,0x0C,0xD5,0xEF,0x5B,0xAD,0x96,0x45,0x8A,0x41,0x96,0x7A,0x1F,0x60,0x0D,0x7D,0x22,0x75,0x82,0x2B,0x0F,0xFB,0xCE,0x51,0x3D,0x2E,0x3A,0x21,0xF3,0x1C,0xD9,0x38,0x86,0x2C,0xC6,0x05,0xB6,0x7B,0x9A,0x8F,0x0F,0x97,0x1B,0x72,0x6F,0x1C,0xEB,0xAE,0xFF,0xDA,0x97,0x0D,0xBA,0x43,0x32,0xCA,0x66,0x34,0x3D,0x54,0xCB,0x24,0x9B,0x43,0xF2,0x70,0x3E,0x42,0xBB,0xA0,0x95,0x11,0x37,0x46,0xE1,0x4F,0x49,0xC5,0x1B,0xFC,0x3C,0x3A,0x3E,0xD1,0x65,0x0E,0x6F,0x58,0xF8,0x9E,0x5B,0xDB,0x55,0xB6,0x41,0x34,0xCB,0xBE,0xDB,0x87,0x5F,0xA9,0xD1,0x85,0x6B,0xB3,0x17,0x9C,0x61,0x0C,0x9B,0xA2,0x5D,0x61,0x10,0xED,0x2A,0x9B,0xA2,0x5D,0x61,0x10,0xED,0x2A,0x9B,0xA2,0x5D,0x61,0x10,0xED,0x2A,0x9B,0xED,0xC9,0xFC,0xDF,0x14,0x54,0x8F,0x80,0x7A,0x06,0xF5,0x23,0xA0,0x9F,0x41,0xF3,0x10,0x30,0x4F,0x41,0xF3,0x18,0x30,0xCF,0xCA,0xFC,0xFF,0x35,0xC9,0x79,0xC9,0x89,0xFA,0x33,0xD7,0x1D,0xF6,0x5E,0x84,0x5C,0x56,0x6E,0xA7,0xDA,0x1E,0xF9,0xFA,0xAB,0xF5,0x97,0xFF,0x2F,0xED,0x89,0x7E,0x29,0x9E,0xB4,0x9F,0x74,0x1E,0x69,0xDA,0xA4,0x9F,0x81,0x94,0xEF,0x4F,0xF6,0xF9,0x0B,0xF4,0x65,0x51,0x08};

char *info[] =  {  "FT800 Music Application",
                   "APP to demonstrate interactive Piano,",
                   "using Rectangles, Buttons,Slider ",
                   "&synthesized Sound"
                }; 

/***********************API used to SET the ICON******************************************/
/*Refer the code flow in the flowchart availble in the Application Note */


void home_setup()
{

	
  /*Icon  file is deflated use J1 Command to inflate the file and write into the GRAM*/
  FTImpl.WriteCmd(CMD_INFLATE);
  FTImpl.WriteCmd(250*1024L);
  FTImpl.WriteCmdfromflash(home_star_icon,sizeof(home_star_icon));
  /*Set the Bitmap properties for the ICONS*/ 	
  FTImpl.DLStart( );        // start
  FTImpl.Clear(1,1,1);
  FTImpl.ColorRGB(255, 255, 255);
  FTImpl.BitmapHandle(13);    // handle for background stars
  FTImpl.BitmapSource(250*1024L);      // Starting address in gram
  FTImpl.BitmapLayout(FT_L4, 16, 32);  // format 
  FTImpl.BitmapSize(FT_NEAREST, FT_REPEAT, FT_REPEAT, 512, 512);
  FTImpl.BitmapHandle(14);    // handle for background stars
  FTImpl.BitmapSource(250*1024L);      // Starting address in gram
  FTImpl.BitmapLayout(FT_L4, 16, 32);  // format 
  FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 32, 32  );
  FTImpl.Display();
  FTImpl.Cmd_Swap();
  FTImpl.Finish();
}
/********API to return the assigned TAG value when penup,for the primitives/widgets******/

static uint8_t keypressed=0;
uint8_t Read_Keys()
{
  static uint8_t Read_tag=0,temp_tag=0,ret_tag=0;	
  Read_tag = FTImpl.Read(REG_TOUCH_TAG);
  ret_tag = NULL;
  if(Read_tag!=NULL)								// Allow if the Key is released
  {
    if(temp_tag!=Read_tag)
    {
      temp_tag = Read_tag;	
      keypressed = Read_tag;										// Load the Read tag to temp variable	
    }  
  }
  else
  {
    if(temp_tag!=0)
    {
      ret_tag = temp_tag;
	  temp_tag = 0;
    }  
    keypressed = 0;
  }
  return ret_tag;
}

// Info Screen//
void Info()
{
  uint16_t dloffset = 0,z;

  FTImpl.DLStart( ); 
  FTImpl.Clear(1,1,1);
  FTImpl.ColorRGB(255,255,255);
  FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,FT_DISPLAYHEIGHT/2,26,FT_OPT_CENTERX|FT_OPT_CENTERY,"Please tap on a dot");
  FTImpl.Cmd_Calibrate(0);
  FTImpl.Display();
  FTImpl.Cmd_Swap();
  FTImpl.Finish();
// Ftdi Logo animation 
  FTImpl.Cmd_Logo();
	while(FTImpl.CheckLogo() != FT_GE_FINISHED);
  dloffset = FTImpl.Read16(REG_CMD_DL);
  dloffset -=4;
  //Copy the Displaylist from DL RAM to GRAM
  FTImpl.WriteCmd(CMD_MEMCPY);
  FTImpl.WriteCmd(100000L);
  FTImpl.WriteCmd(FT_RAM_DL);
  FTImpl.WriteCmd(dloffset);
  //Enter into Info Screen
  do
  {
    FTImpl.DLStart( );   
    FTImpl.Cmd_Append(100000L,dloffset);
    //Reset the BITMAP properties used during Logo animation
    FTImpl.BitmapTransformA(256);
    FTImpl.BitmapTransformA(256);
    FTImpl.BitmapTransformB(0);
    FTImpl.BitmapTransformC(0);
    FTImpl.BitmapTransformD(0);
    FTImpl.BitmapTransformE(256);
    FTImpl.BitmapTransformF(0);  
    FTImpl.SaveContext();	
    //Display the information with transparent Logo using Edge Strip  
    FTImpl.ColorRGB(219,180,150);
    FTImpl.ColorA(220);
    FTImpl.Begin(FT_EDGE_STRIP_A);
    FTImpl.Vertex2f(0,FT_DISPLAYHEIGHT*16);
    FTImpl.Vertex2f(FT_DISPLAYWIDTH*16,FT_DISPLAYHEIGHT*16);
    FTImpl.ColorA(255);
    FTImpl.RestoreContext();	
    FTImpl.ColorRGB(0,0,0);
   // INFORMATION 
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,20,28,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[0]);
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,60,26,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[1]);
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,90,26,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[2]);  
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,120,26,FT_OPT_CENTERX|FT_OPT_CENTERY,(char*)info[3]);  
    FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2,FT_DISPLAYHEIGHT-30,26,FT_OPT_CENTERX|FT_OPT_CENTERY,"Click to play");
    //Check if the Play key enter then change the color
    if(keypressed!='P')
    FTImpl.ColorRGB(255,255,255);
    else
    FTImpl.ColorRGB(100,100,100);
    FTImpl.Begin(FT_POINTS);   
    FTImpl.PointSize(20*16);
    FTImpl.Tag('P');
    FTImpl.Vertex2f((FT_DISPLAYWIDTH/2)*16,(FT_DISPLAYHEIGHT-60)*16);
    FTImpl.ColorRGB(180,35,35);
    FTImpl.Begin(FT_BITMAPS);
    FTImpl.Vertex2ii((FT_DISPLAYWIDTH/2)-14,(FT_DISPLAYHEIGHT-75),14,4);
    FTImpl.Display();
    FTImpl.Cmd_Swap();
	FTImpl.Finish();
  }while(Read_Keys()!='P');
  
  /* wait until Play key is not pressed*/ 
} 


struct 
{
    uint8_t sound : 1;
}Flag;



void Music_Keys(uint8_t no,uint16_t xx,uint16_t y,uint8_t btspace,uint8_t btw,uint8_t bth,uint8_t tag_no,uint32_t fgc1,uint32_t fgc2,uint8_t rtag)
{
  uint16_t x,z;	
  for(z=0;z<no;z++)
  {
    x = z*(btw+btspace)+xx;								
    rtag==(z+tag_no) ? FTImpl.Cmd_FGColor(fgc1) : FTImpl.Cmd_FGColor(fgc2);
    FTImpl.Tag(z+tag_no);	
    FTImpl.Cmd_Button(x,y,btw,bth,16,FT_OPT_FLAT,"");		
  }
}


void Music(void)
{
  uint8_t  instr,Mkeys,Skeys,temp_keys,
           z,button_space,
	       button_w,button_h,
	       Volume,b1w,b1h,b1s,pk;

  uint32_t Read_Tag_val;
  uint16_t x,y,n,temp;
sTrackTag sTracktag;
	

  const char *ins[] = {"Harp","Xylophone","Tuba","Glockenspiel","Organ","Trumpet","Piano","Chimes","Musicbox","Ding" };
// Intial stage
  instr = 0x40;
  Volume = 100;
  button_space = 2;						// space between buttons					
  button_w = (FT_DISPLAYWIDTH / 10)-button_space;			// Button width	
  button_h = (FT_DISPLAYHEIGHT - (FT_DISPLAYHEIGHT/3));		// Button Height		
  b1w = button_w/2;                                             // button width one
  b1h = button_h/2;
  b1s = b1w+button_space;
 // Set the tracker for the Volume adjuster 
  FTImpl.Cmd_DLStart();      
  FTImpl.Cmd_Track(200,20,100,10,'V');   
  FTImpl.Finish();
  FTImpl.Write(REG_VOL_SOUND,100);
  do
  {
    FTImpl.Cmd_DLStart();                                    // start		
    FTImpl.Clear(1,1,1);
    FTImpl.TagMask(1);
    FTImpl.Tag(0);
    FTImpl.Cmd_Gradient(0,0,0x0,480,0,0x505050);
// for music keys
    Music_Keys(10,0,100,2,button_w,button_h,1,0xA0A080,0xFFFFFF,Mkeys);    // noofbuttons,xaxis,yaxis,bs,bw,bh,starting tagno,fgcolor1,fgcolor2,current tag
    Music_Keys(2,button_w*0.782,98,b1s,b1w,b1h,11,0xA0A080,0,Mkeys);
    Music_Keys(3,(3*(button_w+2))+(button_w*0.782),98,b1s,b1w,b1h,13,0xA0A080,0,Mkeys);
    Music_Keys(2,(7*(button_w+2))+(button_w*0.782),98,b1s,b1w,b1h,16,0xA0A080,0,Mkeys);
// Set the Background colors		
    FTImpl.Cmd_BGColor(0x402000);
    FTImpl.Cmd_FGColor(0x703800);
    FTImpl.Tag('I');
    FTImpl.Cmd_Button(50,10,100,30,26,(keypressed=='I')?FT_OPT_FLAT:0,ins[instr-0x40]);      // view button
    
    FTImpl.Tag('V');	
    FTImpl.Cmd_Slider(200,20,100,10,0,Volume,255);
    
    FTImpl.Cmd_Text(155,20,26,FT_OPT_CENTERY,"Vol -");
    FTImpl.Cmd_Text(305,15,26,FT_OPT_CENTERY,"+");
    FTImpl.Cmd_Keys(0,50,FT_DISPLAYWIDTH,40,28,Mkeys|FT_OPT_CENTER,"123456789");
// Sound Selection screen
    if(Flag.sound)	
    {
      FTImpl.Clear(0,0,1);	
      FTImpl.SaveContext();
      FTImpl.ColorRGB(0,0,0);
      FTImpl.ColorA(175);
      FTImpl.Begin(FT_RECTS);
      FTImpl.Vertex2ii(0,0,0,0);
      FTImpl.Vertex2ii(FT_DISPLAYWIDTH,FT_DISPLAYHEIGHT,0,0);
      FTImpl.End();
      FTImpl.RestoreContext();
      x = (uint16_t)(FT_DISPLAYWIDTH*0.270);
      uint16_t dt = 130; 
	  #if (FT_DISPLAY_RESOLUTION == FT_DISPLAY_QVGA_320x240)
      dt = 50;
      #endif
	  
// Draw the sound selection menu bar        
      for(z=0;z<10;z++)
      {
        y = 10+(40*(z%5));						// space bw keys in col 
        x = dt+(120*(z/5));
		FTImpl.Tag(z+100);	//Tagval from 100
		FTImpl.Cmd_Button(x,y,100,30,26,(keypressed==z+100)?FT_OPT_FLAT:0,ins[z]);
      }
    }			
    FTImpl.TagMask(0);				// Disable the tag updation
    FTImpl.Display();
    FTImpl.Cmd_Swap();
    FTImpl.Finish();
		
//Sound change  
    Skeys = Read_Keys();
    Mkeys = FTImpl.Read(REG_TOUCH_TAG);
    if((sTracktag.tag)=='V'){Mkeys = 0;Skeys =0;}
    if(Skeys=='I'){Flag.sound  = 1;
    Mkeys = 0;}
    if(Skeys>=100 && Flag.sound==1)          //Tagval from 100
    {	
      Flag.sound  = 0;
      pk = (Skeys-100);		// assign the selection
      instr = pk|0x40;
    }	
 // Play the sound   
    if(!Flag.sound && Mkeys!='I')
    {
      if(Mkeys > '0' && temp_keys!=Mkeys)
      {
		  FTImpl.Write16(REG_SOUND, 0x50 + (Mkeys-'0'));
		  FTImpl.Write(REG_PLAY,1);
      }
      if(Mkeys !=0 &&  Mkeys < 18 && temp_keys!=Mkeys && Flag.sound==0)
      {	
	  FTImpl.Write16(REG_SOUND,((Mkeys |60) << 8) | instr);
	  FTImpl.Write(REG_PLAY,1);
      }
      FTImpl.GetTrackTag(sTracktag);

      if((sTracktag.tag)=='V' && Flag.sound==0)
      {		
          Volume = (sTracktag.track>>8);
          FTImpl.Write(REG_VOL_SOUND,Volume);
      }
    }
    temp_keys=Mkeys;
  }while(1);
}

/* Api to bootup ft800, verify FT800 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure(){
	uint32_t chipid = 0;
	FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

	delay(20);//for safer side
	chipid = FTImpl.Read32(FT_ROM_CHIPID);
	
	/* Identify the chip */
	if(FT800_CHIPID != chipid)
	{
		Serial.print("Error in chip id read ");
		Serial.println(chipid,HEX);
		return 1;
	}
	
	/*Platform pressure sensitivity adjustment*/
	FTImpl.Write16(REG_TOUCH_RZTHRESH,1200); 
	
	/* Set the Display & audio pins */
	FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
    FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN); 
	FTImpl.DisplayOn(); 
	FTImpl.AudioOn(); 	
	return 0;
}

void setup()
{
	/* Initialize serial print related functionality */
	Serial.begin(9600);
	
	/* Set the Display Enable pin*/   
	Serial.println("--Start Application--");
	if(BootupConfigure())
	{
		//error case - do not do any thing
	}
  	else
	{  
		home_setup();
		Info();
		Music();   
		FTImpl.Exit();
	}
	Serial.println("--End Application--");
}

void loop()
{
}
/* Nothing beyond this */

To create a simple UI

Direct Link

//---------------------------------------------------------
/*

FT_App_CarbonationMachine.ino

Program for writing to Newhaven Displays NHD-4.3RTP-SHIELD based on the FT800 controller.

This code is written for the Arduino Mega.

Copyright (c) 2016 - Newhaven Display International, Inc.

Newhaven Display invests time and resources providing this open source code,
please support Newhaven Display by purchasing products from Newhaven Display!

*/
//---------------------------------------------------------

#include <EEPROM.h>
#include <SPI.h>
#include <Wire.h>
#include <FT_NHD_43RTP_SHIELD.h>

#define RAM_IMAGES_SODA1 26700
static PROGMEM prog_uchar IMAGES_SODA1[] = {
	#include "IMAGES_SODA1.h"
};

#define RAM_IMAGES_SODA2 89252
static PROGMEM prog_uchar IMAGES_SODA2[] = {
	#include "IMAGES_SODA3.h"
};

#define RAM_IMAGES_SODA3 150904
static PROGMEM prog_uchar IMAGES_SODA3[] = {
	#include "IMAGES_SODA2.h"
};

FT800IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

int counter=6;
int previous;
int image_count;
unsigned long currentTime;
unsigned long loopTime;
const int pin_A = 7;  // pin 7
const int pin_B = 6;  // pin 6
const int pin_C = 5;  // pin 5
unsigned char encoder_A;
unsigned char encoder_B;
unsigned char encoder_button;
unsigned char encoder_A_prev=0;
int transformA;
int transformE;
int i;
int n;
int wait_time;
int spark_y;
int box_location;
int box_start = 120;
int box_end = 120;

void read_encoder()  {  
  currentTime = millis();                     // get the current elapsed time
  if(currentTime >= (loopTime + 5)){          // 5ms since last check of encoder = 200Hz      
    encoder_A = digitalRead(pin_A);           // Read encoder pins
    encoder_B = digitalRead(pin_B);   
    if((!encoder_A) && (encoder_A_prev)){     // A has gone from high to low      
      if(encoder_B) {                         // B is high so clockwise      
        counter--;
        if(counter==0){counter=13;}        
      }   
      else {                                  // B is low so counter-clockwise 
        counter++;
        if(counter==14){counter=1;}        
      }   

    }   
    encoder_A_prev = encoder_A;               // Store value of A for next time      
    loopTime = currentTime;  // Updates loopTime
  }                         
}

void encoder_click(){
  if(counter<13){
    FTImpl.DLStart();
    FTImpl.ClearColorRGB(255, 255, 255);
    FTImpl.Clear(1, 1, 1);
    FTImpl.End();
    FTImpl.Begin(FT_BITMAPS);
    FTImpl.Vertex2ii(293, 7, image_count, 0);
    FTImpl.End();
    FTImpl.ColorRGB(0, 0, 0);
    FTImpl.Cmd_Text(5, 73, 31, 0, "CARBONATING");
    FTImpl.ColorRGB(201, 132, 63);
    FTImpl.Cmd_Spinner(158, 156, 3, 1);
    FTImpl.DLEnd();
    FTImpl.Finish();
    delay(wait_time);
  }
  else{
        FTImpl.DLStart();
        FTImpl.ClearColorRGB(255, 255, 255);
        FTImpl.Clear(1, 1, 1);
        FTImpl.End();
        FTImpl.ColorRGB(0, 0, 0);
        FTImpl.Cmd_Text(178, 61, 29, 0, "CLEANING");
        FTImpl.ColorRGB(255, 255, 255);
        FTImpl.End();
        FTImpl.Begin(FT_BITMAPS);
        FTImpl.Vertex2ii(183, 95, 0, 0);
        FTImpl.End();
        FTImpl.ColorRGB(201, 132, 63);
        FTImpl.Cmd_Spinner(240, 210, 1, 1);	
        FTImpl.DLEnd();
        FTImpl.Finish();
        delay(5000);
      }          
}

void setup()
{
        pinMode(pin_A, INPUT);
        pinMode(pin_B, INPUT);
        pinMode(pin_C, INPUT);
        currentTime = millis();
        loopTime = currentTime; 
  
  
	FTImpl.Init(FT_DISPLAY_RESOLUTION);FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN);
	FTImpl.DisplayOn();FTImpl.AudioOn();

	FTImpl.DLStart();
	FTImpl.Cmd_Inflate(RAM_IMAGES_SODA1);FTImpl.WriteCmdfromflash(IMAGES_SODA1, sizeof(IMAGES_SODA1));	
        FTImpl.Cmd_Inflate(RAM_IMAGES_SODA2);FTImpl.WriteCmdfromflash(IMAGES_SODA2, sizeof(IMAGES_SODA2));
        FTImpl.Finish();
	FTImpl.DLStart();
	FTImpl.BitmapHandle(1);FTImpl.BitmapSource(26700);FTImpl.BitmapLayout(FT_ARGB1555, 278, 225);FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 139, 225);
        FTImpl.BitmapHandle(2);FTImpl.BitmapSource(89252);FTImpl.BitmapLayout(FT_ARGB1555, 268, 225);FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 134, 225);
        FTImpl.BitmapHandle(0);FTImpl.BitmapSource(211204);FTImpl.BitmapLayout(FT_ARGB1555, 196, 97);FTImpl.BitmapSize(FT_NEAREST, FT_BORDER, FT_BORDER, 98, 97);
        FTImpl.DLEnd();FTImpl.Finish();
        FTImpl.DLStart();
	FTImpl.ClearColorRGB(201, 132, 63);FTImpl.Clear(1, 1, 1);
	FTImpl.ClearColorRGB(0, 0, 0);FTImpl.Cmd_Text(80, 113, 30, 0, "Carbonation Machine");FTImpl.Cmd_Spinner(227, 205, 0, 0);	
	FTImpl.DLEnd();FTImpl.Finish();
        delay(1000);
}

void loop()
{       
       switch (counter){
          case 1:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 2;wait_time = 1000;break; 
          case 2:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 122;wait_time = 1500;break; 
          case 3:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 243;wait_time = 2000;break; 
          case 4:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 360;wait_time = 2500;break;  
          case 5:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 2;wait_time = 1000;break;  
          case 6:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 122;wait_time = 1500;break; 
          case 7:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 243;wait_time = 2000;break; 
          case 8:
            image_count=1;spark_y = 222;box_start = box_end;box_end = 360;wait_time = 2500;break; 
          case 9:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 2;wait_time = 1000;break; 
          case 10:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 122;wait_time = 1500;break;  
          case 11:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 243;wait_time = 2000;break;
          case 12:
            image_count=2;spark_y = 242;box_start = box_end;box_end = 360;wait_time = 2500;break;
       }              
       if(counter<13){
           for(i=20;i<98;i++){
                FTImpl.DLStart();
                FTImpl.ClearColorRGB(255, 255, 255);
                FTImpl.Clear(1, 1, 1);
                FTImpl.End();
        	FTImpl.Cmd_FGColor(0x1DAAEB); 
                box_location = box_end;
        	FTImpl.Cmd_Button(box_location, 40, 100, 155, 27, FT_OPT_FLAT, "");
        	FTImpl.ColorRGB(0, 0, 0);
                FTImpl.Cmd_Text(16, 195, 28, 0, "Small");
        	FTImpl.Cmd_Text(16, spark_y, 27, 0, "Sparkling");
             	FTImpl.Cmd_Text(138, 195, 28, 0, "Medium");
        	FTImpl.Cmd_Text(138, spark_y, 27, 0, "Sparkling");       	
        	FTImpl.Cmd_Text(260, 195, 28, 0, "Large");
        	FTImpl.Cmd_Text(260, spark_y, 27, 0, "Sparkling");
        	FTImpl.Cmd_Text(377, 195, 28, 0, "XL");
        	FTImpl.Cmd_Text(377, spark_y, 27, 0, "Sparkling");
        
                switch (counter){
                    case 1:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light");           
                    break; 
                    case 2:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light");             
                    break; 
                    case 3:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light");             
                    break; 
                    case 4:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Light");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Light"); 
                    break; 
                    case 5:            
                    break; 
                    case 6:
                    break; 
                    case 7:            
                    break; 
                    case 8:
                    break; 
                    case 9:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");
                    break; 
                    case 10:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");          
                    break; 
                    case 11:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");          
                    break;
                    case 12:
                      FTImpl.Cmd_Text(16, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(138, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(260, 220, 27, 0, "Extra");
        	      FTImpl.Cmd_Text(377, 220, 27, 0, "Extra");          
                    break; 
                    }
                                   	
        	FTImpl.ColorRGB(255, 255, 255);
        	FTImpl.Cmd_Progress(144, 10, 180, 12, 0, i, 100);
        	FTImpl.ColorRGB(255, 255, 255);	
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(440);
        	FTImpl.BitmapTransformE(420);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(10, 50, image_count, 0);
        	FTImpl.End();
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(410);
        	FTImpl.BitmapTransformE(390);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(130, 40, image_count, 0);
        	FTImpl.End();
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(380);
        	FTImpl.BitmapTransformE(360);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(247, 30, image_count, 0);
        	FTImpl.End();
        	FTImpl.Begin(FT_BITMAPS);
        	FTImpl.BitmapTransformA(350);
        	FTImpl.BitmapTransformE(320);
        	FTImpl.BitmapTransformB(0);
        	FTImpl.BitmapTransformC(0);
        	FTImpl.BitmapTransformD(0);
        	FTImpl.BitmapTransformF(0);
        	FTImpl.Vertex2ii(360, 15, image_count, 0);
                if(i>90){FTImpl.ColorRGB(0, 0, 0);FTImpl.Cmd_Text(337, 7, 29, 0, "READY");FTImpl.ColorRGB(255, 255, 255);}
        	FTImpl.End();
        	FTImpl.DLEnd();
        	FTImpl.Finish();
                i++;i++;i++;i++;i++;
                }
         }      
       else{
        FTImpl.DLStart();
	FTImpl.ClearColorRGB(255, 255, 255);
	FTImpl.Clear(1, 1, 1);
	FTImpl.End();
	FTImpl.ColorRGB(0, 0, 0);
	FTImpl.ColorRGB(255, 255, 255);
	FTImpl.Cmd_Progress(144, 10, 180, 12, 0, 97, 100);
	FTImpl.ColorRGB(0, 0, 0);
	FTImpl.Cmd_Text(337, 7, 29, 0, "READY");
	FTImpl.Cmd_Text(337, 32, 29, 0, "TO CLEAN");
	FTImpl.ColorRGB(255, 255, 255);
	FTImpl.End();
	FTImpl.Begin(FT_BITMAPS);
	FTImpl.Vertex2ii(183, 95, 0, 0);
	FTImpl.End();	
	FTImpl.DLEnd();
	FTImpl.Finish();
  }         
        previous = counter;
        //delay(1000);
        //encoder_click();               
        while (counter == previous){         
          read_encoder();
          encoder_button = digitalRead(pin_C);
          if(!encoder_button){encoder_click();return;}
        }    
        if(counter==14){counter=1;}          
}
/* end of file */

Character LCD code example

Direct Link

/*
 Demonstrates the use a 2x16 OLED display.
 The LiquidCrystal library works with all LCD displays that are compatible with the Hitachi HD44780 driver. 
 
 This sketch prints to the OLED and shows the time since last reset
 
  The circuit:
 * OLED RS pin to digital pin 12
 * OLED Enable pin to digital pin 11
 * OLED D4 pin to digital pin 5
 * OLED D5 pin to digital pin 4
 * OLED D6 pin to digital pin 3
 * OLED D7 pin to digital pin 2
 * OLED R/W pin to ground

 */

// include the library code:
#include <LiquidCrystal.h>
#include <Time.h>  
#include <Wire.h>  

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  setTime(15,36,30,14,5,2013);
  lcd.begin(16, 2);
  delay(100);               // wait for 1/10 second
}

void loop() {
  digitalClockDisplay();  
  delay(1000);
}

void digitalClockDisplay(){
  // digital clock display of the time
  lcd.setCursor(2, 0);
  delay(10);               // wait for 1/10 second
  lcd.print(hourFormat12());
  printDigits(minute());
  printDigits(second());
  lcd.print(" ");
  if(isAM()){lcd.print("am");}
  else{lcd.print("pm");}
  
  lcd.setCursor(0, 1);
  printDay();
  printMonth();
  lcd.print(day());
  lcd.print(" ");
  lcd.print(year()); 
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  lcd.print(":");
  if(digits < 10)
    lcd.print('0');
  lcd.print(digits);
}

void printDay(){
  int day;
  day = weekday();
  if(day == 1){lcd.print("Sun, ");}
  if(day == 2){lcd.print("Mon, ");}
  if(day == 3){lcd.print("Tue, ");}
  if(day == 4){lcd.print("Wed, ");}
  if(day == 5){lcd.print("Thu, ");}
  if(day == 6){lcd.print("Fri, ");}
  if(day == 7){lcd.print("Sat, ");}
}

void printMonth(){
  int mon;
  mon = month();
  if(mon == 1){lcd.print("Jan ");}
  if(mon == 2){lcd.print("Feb ");}
  if(mon == 3){lcd.print("Mar ");}
  if(mon == 4){lcd.print("Apr ");}
  if(mon == 5){lcd.print("May ");}
  if(mon == 6){lcd.print("Jun ");}
  if(mon == 7){lcd.print("Jul ");}
  if(mon == 8){lcd.print("Aug ");}
  if(mon == 9){lcd.print("Sep ");}
  if(mon == 10){lcd.print("Oct ");}
  if(mon == 11){lcd.print("Nov ");}
  if(mon == 12){lcd.print("Dec ");}
}

NHD-1.8-128160EF-CTXI

Direct Link

//---------------------------------------------------------
/*
NHD_1_8_128160EF_CTXI_mega.ino
Program for writing to Newhaven Display 1.8" TFT with ILI9163 controller

(c)2013 Mike LaVine - Newhaven Display International, LLC. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int DC = 30;      // D/C signal connected to Arduino digital pin 30
int WR = 31;      // /WR signal connected to Arduino digital pin 31
int RD = 32;      // /RD signal connected to Arduino digital pin 32
int RST = 33;     // /RST signal connected to Arduino digital pin 33

// /CS signal tied to ground

void comm_out(unsigned char c)
{
  digitalWrite(DC, LOW);
  PORTA = c;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}

void data_out(unsigned char d)
{
  digitalWrite(DC, HIGH);
  PORTA = d;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
void disp()
{
	unsigned int i; 
	comm_out(0x2C);              //command to begin writing to frame memory
	for(i=0;i<20480;i++)         //fill screen with red pixels
	{
	    data_out(0xFF);
            data_out(0x00);
            data_out(0x00);
	}
        for(i=0;i<20480;i++)         //fill screen with green pixels
	{
	    data_out(0x00);
            data_out(0xFF);
            data_out(0x00);
        }
        for(i=0;i<20480;i++)         //fill screen with blue pixels
	{
	    data_out(0x00);
            data_out(0x00);
            data_out(0xFF);
        }
}

void setup()
{
  DDRC = 0xFF;   
  PORTC = 0x00;
  DDRA = 0xFF;
  PORTA = 0x00;
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RST, LOW);
  delay(150);
  digitalWrite(RST, HIGH);
  delay(150);
  
  comm_out(0x11);              //exit SLEEP mode
  
  delay(100);
  
  comm_out(0x28);              //display off
  
  comm_out(0x26);              //select gamma curve
  data_out(0x04);
  
  comm_out(0xB1);              //frame rate control
  data_out(0x0A);
  data_out(0x14);
  
  comm_out(0xC0);              //power control 1
  data_out(0x0A); 
  data_out(0x00);
  
  comm_out(0xC1);              //power control 2
  data_out(0x02);
  
  comm_out(0xC5);              //VCOM control 1
  data_out(0x2F); 
  data_out(0x3E);
  
  comm_out(0xC7);              //VCOM control 2
  data_out(0x40);
  
  comm_out(0x2A);              //column address set
  data_out(0x00);                  
  data_out(0x00);                  //start 0x0000
  data_out(0x00);
  data_out(0x7F);                  //end 0x007F
  
  comm_out(0x2B);              //page address set
  data_out(0x00);                  
  data_out(0x00);                  //start 0x0000
  data_out(0x00);
  data_out(0x9F);                  //end 0x009F
  
  comm_out(0x36);              //memory access control
  data_out(0xC8);
  
  comm_out(0x3A);              //pixel format = 18 bit per pixel
  data_out(0x06);                  
  
  comm_out(0x29);              //display ON

  delay(10);
}

void loop()
{ 
  disp();
  delay(1000);
}

NHD-2.4-240320SF-CTXI

Direct Link

//---------------------------------------------------------
/*
NHD_2_4_240320SF_CTXI_mega.ino
Program for writing to Newhaven Display 2.4" TFT with ILI9341 controller

(c)2013 Mike LaVine - Newhaven Display International, LLC. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS = 30;      // RS signal connected to Arduino digital pin 30
int WR = 31;      // /WR signal connected to Arduino digital pin 31
int RD = 32;      // /RD signal connected to Arduino digital pin 32
int RES = 33;     // /RES signal connected to Arduino digital pin 33

// /CS signal tied to GND
// IM0 signal tied to VDD

void comm_out(unsigned char c)
{
  digitalWrite(RS, LOW);
  PORTA = c;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}

void data_out(unsigned char d)
{
  digitalWrite(RS, HIGH);
  PORTA = d;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
void disp()
{
	unsigned int i; 
	comm_out(0x2C);              //command to begin writing to frame memory
	for(i=0;i<38400;i++)         //fill screen with blue pixels
	{
	    data_out(0x00);
            data_out(0x1F);
            data_out(0x00);
            data_out(0x1F);
	}
        for(i=0;i<38400;i++)         //fill screen with green pixels
	{
	    data_out(0x07);
            data_out(0xE0);
            data_out(0x07);
            data_out(0xE0);
        }
}

void setup()
{
  DDRC = 0xFF;   
  PORTC = 0x00;
  DDRA = 0xFF;
  PORTA = 0x00;
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(250);
  digitalWrite(RES, HIGH);
  delay(250);
  
  comm_out(0x28);                                  //display off
  comm_out(0x11);  //exit SLEEP mode
  
  comm_out(0xCB);  //power control A
  data_out(0x39);
  data_out(0x2C);
  data_out(0x00);
  data_out(0x34);
  data_out(0x02);
  
  comm_out(0xCF);  //power control B
  data_out(0x00);
  data_out(0x81);
  data_out(0x30);
  
  comm_out(0xC0); 
  data_out(0x26);  //power control 1
  data_out(0x04);  //second parameter for ILI9340 (ignored by ILI9341)
  
  comm_out(0xC1); 
  data_out(0x11);                  //power control 2
  
  comm_out(0xC5); 
  data_out(0x35); 
  data_out(0x3E);  //VCOM control 1
  
  comm_out(0x36); 
  data_out(0x88);                  //memory access control = BGR
  
  comm_out(0xB1); 
  data_out(0x00); 
  data_out(0x18);  //frame rate control
  
  comm_out(0xB6); 
  data_out(0x0A); 
  data_out(0xA2);  //display function control
  
  comm_out(0xC7); 
  data_out(0xBE);                  //VCOM control 2
  
  comm_out(0x3A); 
  data_out(0x55);                  //pixel format = 16 bit per pixel
  
  /*comm_out(0xE0); 
  data_out(0x1F);                  //positive gamma correction
  data_out(0x1B);
  data_out(0x18);
  data_out(0x0B);
  data_out(0x0F);
  data_out(0x09);
  data_out(0x46);
  data_out(0xB5);
  data_out(0x37);
  data_out(0x0A);
  data_out(0x0C);
  data_out(0x07);
  data_out(0x07);
  data_out(0x05);
  data_out(0x00);
  
  comm_out(0xE1); 
  data_out(0x00);                  //negative gamma correction
  data_out(0x24);
  data_out(0x27);
  data_out(0x04);
  data_out(0x10);
  data_out(0x06);
  data_out(0x39);
  data_out(0x74);
  data_out(0x48);
  data_out(0x05);
  data_out(0x13);
  data_out(0x38);
  data_out(0x38);
  data_out(0x3A);
  data_out(0x1F);*/
  
  comm_out(0xF2);                  //3g damma control
  data_out(0x02);                  //off
  
  comm_out(0x26);                  //gamma curve 3
  data_out(0x01);
  
  comm_out(0x2A); 
  data_out(0x00);                  //column address set
  data_out(0x00);                  //start 0x0000
  data_out(0x00);
  data_out(0xEF);                  //end 0x00EF
  
  comm_out(0x2B); 
  data_out(0x00);                  //page address set
  data_out(0x00);                  //start 0x0000
  data_out(0x01);
  data_out(0x3F);                  //end 0x003F
  
  comm_out(0x29);                  //display ON

  delay(10);
}

void loop()
{ 
  disp();
  delay(1000);
}

NHD-2.4-240320CF-CTXI

Direct Link

//---------------------------------------------------------
/*
NHD_2_4_240320CF_CTXI_mega.ino
Program for writing to Newhaven Display 2.4" TFT with ST7789S controller

(c)2016 Paul Bartek - Newhaven Display International, Inc. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS = 30;      // RS signal connected to Arduino digital pin 30
int WR = 31;      // /WR signal connected to Arduino digital pin 31
int RD = 32;      // /RD signal connected to Arduino digital pin 32
int RES = 33;     // /RES signal connected to Arduino digital pin 33

// /CS signal tied to GND
// IM0 signal tied to VDD

void comm_out(unsigned char c)
{
  digitalWrite(RS, LOW);
  PORTA = c;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}

void data_out(unsigned char d)
{
  digitalWrite(RS, HIGH);
  PORTA = d;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
void disp()
{
	unsigned int i; 
	comm_out(0x2C);              //command to begin writing to frame memory
	for(i=0;i<38400;i++)         //fill screen with blue pixels
	{
	    data_out(0x00);
            data_out(0x1F);
            data_out(0x00);
            data_out(0x1F);
	}
        for(i=0;i<38400;i++)         //fill screen with green pixels
	{
	    data_out(0x07);
            data_out(0xE0);
            data_out(0x07);
            data_out(0xE0);
        }
        
        for(i=0;i<38400;i++)         //fill screen with red pixels
	{
	    data_out(0xF8);
            data_out(0x00);
            data_out(0xF8);
            data_out(0x00);
        }
        
         for(i=0;i<38400;i++)         //fill screen with black pixels
	{
	    data_out(0x00);
            data_out(0x00);
            data_out(0x00);
            data_out(0x00);
        }
        
         for(i=0;i<38400;i++)         //fill screen with white pixels
	{
	    data_out(0xFF);
            data_out(0xFF);
            data_out(0xFF);
            data_out(0xFF);
        }
}

void setup()
{
  DDRC = 0xFF;   
  PORTC = 0x00;
  DDRA = 0xFF;
  PORTA = 0x00;
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(250);
  digitalWrite(RES, HIGH);
  delay(250);
  
  comm_out(0x28);   //display off
  comm_out(0x11);  //exit SLEEP mode
  delay(100);
  
  comm_out(0x36);  //MADCTL: memory data access control
  data_out(0x80);
  
  //comm_out(0x3A);  //COLMOD: Interface Pixel format *** 262K-colors in 18bit/pixel format when using 8-bit interface to allow 3-bytes per pixel
  //data_out(0x66);
  
  comm_out(0x3A);    //COLMOD: Interface Pixel format  *** 65K-colors in 16bit/pixel (5-6-5) format when using 16-bit interface to allow 1-byte per pixel
  data_out(0x55);
  
  comm_out(0xB2);  //PORCTRK: Porch setting
  data_out(0x0C);
  data_out(0x0C);
  data_out(0x00);
  data_out(0x33);
  data_out(0x33);
  
  comm_out(0xB7);  //GCTRL: Gate Control
  data_out(0x35);
  
  comm_out(0xBB);  //VCOMS: VCOM setting
  data_out(0x2B);
 
  comm_out(0xC0);  //LCMCTRL: LCM Control
  data_out(0x2C);
  
  comm_out(0xC2);  //VDVVRHEN: VDV and VRH Command Enable
  data_out(0x01);
  data_out(0xFF);
  
  comm_out(0xC3);  //VRHS: VRH Set
  data_out(0x11);
  
  comm_out(0xC4);  //VDVS: VDV Set
  data_out(0x20);
  
  comm_out(0xC6);  //FRCTRL2: Frame Rate control in normal mode
  data_out(0x0F);
  
  comm_out(0xD0);  //PWCTRL1: Power Control 1
  data_out(0xA4);
  data_out(0xA1);
  
  comm_out(0xE0);  //PVGAMCTRL: Positive Voltage Gamma control	
  data_out(0xD0);
  data_out(0x00);
  data_out(0x05);
  data_out(0x0E);
  data_out(0x15);
  data_out(0x0D);
  data_out(0x37);
  data_out(0x43);
  data_out(0x47);
  data_out(0x09);
  data_out(0x15);
  data_out(0x12);
  data_out(0x16);
  data_out(0x19);
  
  comm_out(0xE1);  //NVGAMCTRL: Negative Voltage Gamma control	
  data_out(0xD0);
  data_out(0x00);
  data_out(0x05);
  data_out(0x0D);
  data_out(0x0C);
  data_out(0x06);
  data_out(0x2D);
  data_out(0x44);
  data_out(0x40);
  data_out(0x0E);
  data_out(0x1C);
  data_out(0x18);
  data_out(0x16);
  data_out(0x19);
  
  comm_out(0x2A);  //X address set
  data_out(0x00);
  data_out(0x00);
  data_out(0x00);
  data_out(0xEF);

  comm_out(0x2B);  //Y address set
  data_out(0x00);
  data_out(0x00);
  data_out(0x01);
  data_out(0x3F);
  delay(10);
  
  comm_out(0x29);  //display ON
  delay(10);
}

void loop()
{ 
  disp();
  delay(1000);
}

NHD-3.5-320240MF with SSD1963 controller

Direct Link

//---------------------------------------------------------
/*
NHD_3_5_320240MF_mega.ino
Program for writing to Newhaven Display 3.5" TFT with NHD-3.5-320240MF-20 Controller Board (SSD1963, 8-bit)

(c)2013 Mike LaVine - Newhaven Display International, LLC.

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS  = 30;    // RS signal connected to Arduino digital pin 30
int WR  = 31;    // /WR signal connected to Arduino digital pin 31
int RD  = 32;    // /RD signal connected to Arduino digital pin 32
int RES = 33;    // /RES signal connected to Arduino digital pin 33

// /CS signal tied to GND 
												 
//;******************************************************************************
void TFT_Write_Command(unsigned char command)
{
  digitalWrite(RS, LOW);
  PORTA = command;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//;******************************************************************************
void TFT_Write_Data(unsigned char data)
{
  //digitalWrite(RS, HIGH);
  PORTA = data;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//====================================================
void TFT_Command_Write(unsigned char REG,unsigned char VALUE)
{
        TFT_Write_Command(REG);
        digitalWrite(RS, HIGH);
        TFT_Write_Data(VALUE);
}
//======================================================
void WindowSet(unsigned int s_x,unsigned int e_x,unsigned int s_y,unsigned int e_y)
{
	TFT_Write_Command(0x2a);		//SET column address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_x)>>8);			//SET start column address
	TFT_Write_Data(s_x);
	TFT_Write_Data((e_x)>>8);			//SET end column address
	TFT_Write_Data(e_x);
	
	TFT_Write_Command(0x2b);		//SET page address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_y)>>8);			//SET start page address
	TFT_Write_Data(s_y);
	TFT_Write_Data((e_y)>>8);			//SET end page address
	TFT_Write_Data(e_y);
}
void disp()
{
	unsigned int i, j;
        WindowSet(0,319,0,239);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
	for(i=0;i<240;i++)         //fill screen with blue pixels
	{
	    for(j=0;j<320;j++)
            {
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,319,0,239);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<240;i++)         //fill screen with green pixels
	{
	    for(j=0;j<320;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,319,0,239);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<240;i++)         //fill screen with red pixels
	{
	    for(j=0;j<320;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
            }
	}
}
//======================================================
void setup() 
{
  DDRA = 0xFF;
  PORTA = 0x00;
  DDRC = 0xFF;
  PORTC = 0x00;
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(120);
  digitalWrite(RES, HIGH);
  delay(120);
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xe2);         //set multiplier and divider of PLL
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x1d);
  TFT_Write_Data(0x02);
  TFT_Write_Data(0x04);
  TFT_Command_Write(0xe0,0x01);    //Enable PLL
  delay(1);
  TFT_Command_Write(0xe0,0x03);    //Lock PLL
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xb0);		//SET LCD MODE  SET TFT 18Bits MODE
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0c);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x80);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x01);			//SET horizontal size=320-1 HightByte
  TFT_Write_Data(0x3f);		        //SET horizontal size=320-1 LowByte
  TFT_Write_Data(0x00);			//SET vertical size=240-1 HightByte
  TFT_Write_Data(0xef);			//SET vertical size=240-1 LowByte
  TFT_Write_Data(0x00);			//SET even/odd line RGB seq.=RGB
  TFT_Command_Write(0xf0,0x00);	        //SET pixel data I/F format=8bit
  TFT_Command_Write(0x36,0x09);	        //SET address mode=flip vertical  
  TFT_Write_Command(0xe6);   		//SET PCLK freq
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0a);
  TFT_Write_Data(0x3d);
  TFT_Write_Data(0x70);
  TFT_Write_Command(0xb4);		//SET HBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x01);			//SET HSYNC Total=440
  TFT_Write_Data(0xb8);
  TFT_Write_Data(0x00);			//SET HBP 68
  TFT_Write_Data(0x46);
  TFT_Write_Data(0x0f);  		//SET HSYNC Pulse Width=128=127pixels+1
  TFT_Write_Data(0x00);			//SET Hsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Data(0x00);			//SET Hsync pulse subpixel start position
  TFT_Write_Command(0xb6); 		//SET VBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x01);			//SET Vsync total
  TFT_Write_Data(0x48);
  TFT_Write_Data(0x00);			//SET VBP=19
  TFT_Write_Data(0x0b);
  TFT_Write_Data(0x07);  		//SET VSYNC Pulse Width= 8=7lines+1
  TFT_Write_Data(0x00);			//SET Vsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Command(0x13);		//SET display on
  //TFT_Write_Command(0x38);		//SET display on
  TFT_Write_Command(0x29);		//SET display on
  delay(10);
}

void loop() 
{
  disp();
  delay(1000);  
}

NHD-4.3-480272EF with SSD1963 controller

Direct Link

//---------------------------------------------------------
/*
NHD_4_3_480272EF_mega.ino
Program for writing to Newhaven Display 4.3" TFT with NHD-4.3-480272MF-20 Controller Board (SSD1963, 8-bit)

(c)2013 Mike LaVine - Newhaven Display International, LLC.

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS  = 30;    // RS signal connected to Arduino digital pin 30
int WR  = 31;    // /WR signal connected to Arduino digital pin 31
int RD  = 32;    // /RD signal connected to Arduino digital pin 32
int RES = 33;    // /RES signal connected to Arduino digital pin 33

// /CS signal tied to GND 
												 
//;******************************************************************************
void TFT_Write_Command(unsigned char command)
{
  digitalWrite(RS, LOW);
  PORTA = command;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//;******************************************************************************
void TFT_Write_Data(unsigned char data)
{
  //digitalWrite(RS, HIGH);
  PORTA = data;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//====================================================
void TFT_Command_Write(unsigned char REG,unsigned char VALUE)
{
        TFT_Write_Command(REG);
        digitalWrite(RS, HIGH);
        TFT_Write_Data(VALUE);
}
//======================================================
void WindowSet(unsigned int s_x,unsigned int e_x,unsigned int s_y,unsigned int e_y)
{
	TFT_Write_Command(0x2a);		//SET column address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_x)>>8);			//SET start column address
	TFT_Write_Data(s_x);
	TFT_Write_Data((e_x)>>8);			//SET end column address
	TFT_Write_Data(e_x);
	
	TFT_Write_Command(0x2b);		//SET page address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_y)>>8);			//SET start page address
	TFT_Write_Data(s_y);
	TFT_Write_Data((e_y)>>8);			//SET end page address
	TFT_Write_Data(e_y);
}
void disp()
{
	unsigned int i, j;
        WindowSet(0,479,0,271);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
	for(i=0;i<272;i++)         //fill screen with blue pixels
	{
	    for(j=0;j<480;j++)
            {
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,479,0,271);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<272;i++)         //fill screen with green pixels
	{
	    for(j=0;j<480;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,479,0,271);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<272;i++)         //fill screen with red pixels
	{
	    for(j=0;j<480;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
            }
	}
}
//======================================================
void setup() 
{
  DDRA = 0xFF;
  PORTA = 0x00;
  DDRC = 0xFF;
  PORTC = 0x00;
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(120);
  digitalWrite(RES, HIGH);
  delay(120);
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xe2);         //set multiplier and divider of PLL
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x1d);
  TFT_Write_Data(0x02);
  TFT_Write_Data(0x04);
  TFT_Command_Write(0xe0,0x01);    //Enable PLL
  delay(1);
  TFT_Command_Write(0xe0,0x03);    //Lock PLL
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xb0);		//SET LCD MODE  SET TFT 18Bits MODE
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0c);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x80);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x01);			//SET horizontal size=480-1 HightByte
  TFT_Write_Data(0xdf);		        //SET horizontal size=480-1 LowByte
  TFT_Write_Data(0x01);			//SET vertical size=272-1 HightByte
  TFT_Write_Data(0x0f);			//SET vertical size=272-1 LowByte
  TFT_Write_Data(0x00);			//SET even/odd line RGB seq.=RGB
  TFT_Command_Write(0xf0,0x00);	        //SET pixel data I/F format=8bit
  TFT_Command_Write(0x36,0x09);	        //SET address mode=flip vertical  
  TFT_Write_Command(0xe6);   		//SET PCLK freq
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0a);
  TFT_Write_Data(0x3d);
  TFT_Write_Data(0x70);
  TFT_Write_Command(0xb4);		//SET HBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x01);			//SET HSYNC Total=440
  TFT_Write_Data(0xb8);
  TFT_Write_Data(0x00);			//SET HBP 68
  TFT_Write_Data(0x46);
  TFT_Write_Data(0x0f);  		//SET HSYNC Pulse Width=128=127pixels+1
  TFT_Write_Data(0x00);			//SET Hsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Data(0x00);			//SET Hsync pulse subpixel start position
  TFT_Write_Command(0xb6); 		//SET VBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x01);			//SET Vsync total
  TFT_Write_Data(0x48);
  TFT_Write_Data(0x00);			//SET VBP=19
  TFT_Write_Data(0x0b);
  TFT_Write_Data(0x07);  		//SET VSYNC Pulse Width= 8=7lines+1
  TFT_Write_Data(0x00);			//SET Vsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Command(0x13);		//SET display on
  TFT_Write_Command(0x38);		//SET display on
  TFT_Write_Command(0x29);		//SET display on
  delay(10);
}

void loop() 
{
  disp();
  delay(1000);  
}

NHD-4.3-480800EF-CTXP

Direct Link

//---------------------------------------------------------
/*
NHD_4_3_480800EF_CTXP_mega.ino
Program for writing to Newhaven Display 4.3" TFT with HX8369 controller

(c)2013 Mike LaVine - Newhaven Display International, LLC. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The lower 8 bits of the 16 bit data bus are connected to PORTA of the Arduino Mega2560
// The upper 8 bits of the 16 bit data bus are connected to PORTC of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic


int DC  = 38;          // D/C signal connected to Arduino digital pin 38
int WR  = 39;          // /WR signal connected to Arduino digital pin 39
int RD  = 40;          // /RD signal connected to Arduino digital pin 40
int RES = 41;          // /RES signal connected to Arduino digital pin 41

// /CS signal tied to ground
// BLPWM signal is a No Connect

//****************************************//
void comm_out(unsigned char command)
{
    digitalWrite(DC, LOW);
    PORTA = command;
    digitalWrite(WR, LOW);
    digitalWrite(WR, HIGH);
}

void data_out(unsigned char data)
{
    digitalWrite(DC, HIGH);
    PORTA = data;
    digitalWrite(WR, LOW);
    digitalWrite(WR, HIGH);
}

void data_out_16bit(unsigned int data)
{
     //digitalWrite(DC, HIGH);
     PORTA = data;
     PORTC = (data>>8);
     digitalWrite(WR, LOW);
     digitalWrite(WR, HIGH);
}
//========================================//
// Initialize controller
//========================================//
void Init_HX8369A()
{
        digitalWrite(RD, HIGH);
        digitalWrite(RES, HIGH);	
	delay(120);
	digitalWrite(RES, LOW);     //HW reset
	delay(120);
	digitalWrite(RES, HIGH);
	delay(120);

	comm_out(0xB9);		    //Enter Extension Command
	data_out(0xFF);		    //Followed by 3 extension parameters
	data_out(0x83);
	data_out(0x69);

        comm_out(0xB1);		    //Set Power
	data_out(0x01);    
        data_out(0x00);    
        data_out(0x34);      
        data_out(0x06);    
        data_out(0x00);    
        data_out(0x0F);    
        data_out(0x0F);    
        data_out(0x2A);    
        data_out(0x32);    
        data_out(0x3F);    
        data_out(0x3F);    
        data_out(0x07);    
        data_out(0x23);   
        data_out(0x01);    
        data_out(0xE6);   
        data_out(0xE6);    
        data_out(0xE6);    
        data_out(0xE6);    
        data_out(0xE6); 

        comm_out(0xB2);		    //Set Display 480x800
	data_out(0x00);   
        data_out(0x20);   
        data_out(0x0A);   
        data_out(0x0A);   
        data_out(0x70);   
        data_out(0x00);  
        data_out(0xFF);  
        data_out(0x00);   
        data_out(0x00);   
        data_out(0x00);  
        data_out(0x00);   
        data_out(0x03);   
        data_out(0x03);  
        data_out(0x00);  
        data_out(0x01);
        
        comm_out(0xB4);             //Set display column inversion
        data_out(0x00);   
        data_out(0x18);   
        data_out(0x80);   
        data_out(0x10);   
        data_out(0x01);   

        comm_out(0xB6);		    //Set VCOM
	data_out(0x2C);    
	data_out(0x2C);    

        comm_out(0xD5);             //set GIP
        data_out(0x00);   
        data_out(0x05);   
        data_out(0x03);   
        data_out(0x00);   
        data_out(0x01);   
        data_out(0x09);   
        data_out(0x10);   
        data_out(0x80);   
        data_out(0x37);   
        data_out(0x37);   
        data_out(0x20);   
        data_out(0x31);   
        data_out(0x46);  
        data_out(0x8A);   
        data_out(0x57);   
        data_out(0x9B);   
        data_out(0x20);   
        data_out(0x31);   
        data_out(0x46);   
        data_out(0x8A);   
        data_out(0x57);   
        data_out(0x9B);   
        data_out(0x07);   
        data_out(0x0F);   
        data_out(0x02);   
        data_out(0x00);   
     
        comm_out(0x3A);		   //Interface pixel format
	data_out(0x77);		   //3bytes per pixel

        comm_out(0x36);            //MADCTL
        data_out(0x80);

        comm_out(0x11);            //exit sleep mode
        delay(120);
        
	comm_out(0x29);		   //Display ON
        delay(10);     
}
//=====================================================//
void WindowSet(unsigned int s_x,unsigned int e_x,unsigned int s_y,unsigned int e_y)
{
	comm_out(0x2a);		//SET column address
	digitalWrite(DC, HIGH);
	data_out((s_x)>>8);			//SET start column address=0
	data_out(s_x);
	data_out((e_x)>>8);			//SET end column address=479
	data_out(e_x);
	
	comm_out(0x2b);		//SET page address
	digitalWrite(DC, HIGH);
	data_out((s_y)>>8);			//SET start page address=0
	data_out(s_y);
	data_out((e_y)>>8);			//SET end page address=779
	data_out(e_y);
}
//*****************************************************//
//*****************************************************//
void setup()                                    
{
        pinMode(DC, OUTPUT);          //set digital pin 38 as output
        pinMode(WR, OUTPUT);          //set digital pin 39 as output
        pinMode(RD, OUTPUT);          //set digital pin 40 as output
        pinMode(RES, OUTPUT);          //set digital pin 41 as output
        digitalWrite(DC, LOW);
        digitalWrite(WR, LOW);
        digitalWrite(RD, LOW);
        digitalWrite(RES, LOW);
        DDRA = 0xFF;                  //set PORTA as output
        DDRC = 0xFF;                  //set PORTC as output
	PORTA = 0;
        PORTC = 0;
        Init_HX8369A();               //initialize the HX8369 controller
}
void loop()
{
         for(int c=0;c<3;c++)
         {
           switch(c)
           {
             case 0 : WindowSet(0x0000,0x01df,0x0000,0x031f);    //set start/end column and page addresses
                      comm_out(0x2C);                            //command to write to frame memory
                      digitalWrite(DC, HIGH);
                      for(int j=0;j<800;j++)                     //fill display with red pixels
                      {
                        for(int k=0;k<240;k++)
                        {
                          data_out_16bit(0xFF00);
                          data_out_16bit(0x00FF);
                          data_out_16bit(0x0000);
                        }
                      }
                      break;
              case 1 : WindowSet(0x0000,0x01df,0x0000,0x031f);    //set start/end column and page addresses
                       comm_out(0x2C);                            //command to write to frame memory
                       digitalWrite(DC, HIGH);
                       for(int j=0;j<800;j++)                     //fill display with green pixels
                       {
                         for(int k=0;k<240;k++)
                         {
                           data_out_16bit(0x00FF);
                           data_out_16bit(0x0000);
                           data_out_16bit(0xFF00);
                         }
                       }
                       break;
              case 2 : WindowSet(0x0000,0x01df,0x0000,0x031f);    //set start/end column and page addresses
                       comm_out(0x2C);                            //command to write to frame memory
                       digitalWrite(DC, HIGH);
                       for(int j=0;j<800;j++)                     //fill display with blue pixels
                       {
                         for(int k=0;k<240;k++)
                         {
                           data_out_16bit(0x0000);
                           data_out_16bit(0xFF00);
                           data_out_16bit(0x00FF);
                         }
                       }
                       break;
              default: break;
           }
         }
}

NHD-5.0-800480TF with SSD1963 controller

Direct Link

//---------------------------------------------------------
/*
NHD_5_0_800480TF_mega.ino
Program for writing to Newhaven Display 5.0" TFT with NHD-5.0-800480TF-20 Controller Board (SSD1963, 8-bit)

(c)2013 Mike LaVine - Newhaven Display International, LLC.

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS  = 30;    // RS signal connected to Arduino digital pin 30
int WR  = 31;    // /WR signal connected to Arduino digital pin 31
int RD  = 32;    // /RD signal connected to Arduino digital pin 32
int RES = 33;    // /RES signal connected to Arduino digital pin 33
int DIS = 34;    // DISP signal connected to Arduino digital pin 34

// /CS signal tied to GND 
												 
//;******************************************************************************
void TFT_Write_Command(unsigned char command)
{
  digitalWrite(RS, LOW);
  PORTA = command;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//;******************************************************************************
void TFT_Write_Data(unsigned char data)
{
  //digitalWrite(RS, HIGH);
  PORTA = data;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//====================================================
void TFT_Command_Write(unsigned char REG,unsigned char VALUE)
{
        TFT_Write_Command(REG);
        digitalWrite(RS, HIGH);
        TFT_Write_Data(VALUE);
}
//======================================================
void WindowSet(unsigned int s_x,unsigned int e_x,unsigned int s_y,unsigned int e_y)
{
	TFT_Write_Command(0x2a);		//SET column address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_x)>>8);			//SET start column address
	TFT_Write_Data(s_x);
	TFT_Write_Data((e_x)>>8);			//SET end column address
	TFT_Write_Data(e_x);
	
	TFT_Write_Command(0x2b);		//SET page address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_y)>>8);			//SET start page address
	TFT_Write_Data(s_y);
	TFT_Write_Data((e_y)>>8);			//SET end page address
	TFT_Write_Data(e_y);
}
void disp()
{
	unsigned int i, j;
        WindowSet(0,799,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
	for(i=0;i<480;i++)         //fill screen with blue pixels
	{
	    for(j=0;j<800;j++)
            {
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,799,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<480;i++)         //fill screen with green pixels
	{
	    for(j=0;j<800;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,799,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<480;i++)         //fill screen with red pixels
	{
	    for(j=0;j<800;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
            }
	}
}
//======================================================
void setup() 
{
  DDRA = 0xFF;
  PORTA = 0x00;
  DDRC = 0xFF;
  PORTC = 0x00;
  digitalWrite(DIS, HIGH);
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(120);
  digitalWrite(RES, HIGH);
  delay(120);
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xe2);         //set multiplier and divider of PLL
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x1d);
  TFT_Write_Data(0x02);
  TFT_Write_Data(0x04);
  TFT_Command_Write(0xe0,0x01);    //Enable PLL
  delay(1);
  TFT_Command_Write(0xe0,0x03);    //Lock PLL
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xb0);		//SET LCD MODE  SET TFT 18Bits MODE
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x08);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x80);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x03);			//SET horizontal size=800-1 HightByte
  TFT_Write_Data(0x1f);		        //SET horizontal size=800-1 LowByte
  TFT_Write_Data(0x01);			//SET vertical size=480-1 HightByte
  TFT_Write_Data(0xdf);			//SET vertical size=480-1 LowByte
  TFT_Write_Data(0x00);			//SET even/odd line RGB seq.=RGB
  TFT_Command_Write(0xf0,0x00);	        //SET pixel data I/F format=8bit
  TFT_Command_Write(0x36,0x09);	        //SET address mode=flip vertical  
  TFT_Write_Command(0xe6);   		//SET PCLK freq
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0f);
  TFT_Write_Data(0xff);
  TFT_Write_Data(0xff);
  TFT_Write_Command(0xb4);		//SET HBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x04);			//SET HSYNC Total=1056
  TFT_Write_Data(0x20);
  TFT_Write_Data(0x00);			//SET HBP 88
  TFT_Write_Data(0x58);
  TFT_Write_Data(0x80);  		//SET HSYNC Pulse Width=128=127pixels+1
  TFT_Write_Data(0x00);			//SET Hsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Data(0x00);			//SET Hsync pulse subpixel start position
  TFT_Write_Command(0xb6); 		//SET VBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x02);			//SET Vsync total 525
  TFT_Write_Data(0x0d);
  TFT_Write_Data(0x00);			//SET VBP=32
  TFT_Write_Data(0x20);
  TFT_Write_Data(0x01);  		//SET VSYNC Pulse Width= 0=0lines+1
  TFT_Write_Data(0x00);			//SET Vsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Command(0x13);		//SET display on
  TFT_Write_Command(0x38);		//SET display on
  TFT_Write_Command(0x29);		//SET display on
  delay(10);
}

void loop() 
{
  disp();
  delay(1000);  
}

NHD-5.7-320240WFB-CTXI

Direct Link

//---------------------------------------------------------
/*
NHD_5_7_320240WFB_mega.ino
Program for writing to Newhaven Display 5.7" TFT with NHD-5.7-320240WFB-20 Controller Board (SSD1963, 8-bit)

(c)2013 Mike LaVine - Newhaven Display International, LLC.

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS  = 30;    // RS signal connected to Arduino digital pin 30
int WR  = 31;    // /WR signal connected to Arduino digital pin 31
int RD  = 32;    // /RD signal connected to Arduino digital pin 32
int RES = 33;    // /RES signal connected to Arduino digital pin 33

// /CS signal tied to GND 
												 
//;******************************************************************************
void TFT_Write_Command(unsigned char command)
{
  digitalWrite(RS, LOW);
  PORTA = command;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//;******************************************************************************
void TFT_Write_Data(unsigned char data)
{
  //digitalWrite(RS, HIGH);
  PORTA = data;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//====================================================
void TFT_Command_Write(unsigned char REG,unsigned char VALUE)
{
        TFT_Write_Command(REG);
        digitalWrite(RS, HIGH);
        TFT_Write_Data(VALUE);
}
//======================================================
void WindowSet(unsigned int s_x,unsigned int e_x,unsigned int s_y,unsigned int e_y)
{
	TFT_Write_Command(0x2a);		//SET column address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_x)>>8);			//SET start column address
	TFT_Write_Data(s_x);
	TFT_Write_Data((e_x)>>8);			//SET end column address
	TFT_Write_Data(e_x);
	
	TFT_Write_Command(0x2b);		//SET page address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_y)>>8);			//SET start page address
	TFT_Write_Data(s_y);
	TFT_Write_Data((e_y)>>8);			//SET end page address
	TFT_Write_Data(e_y);
}
void disp()
{
	unsigned int i, j;
        WindowSet(0,319,0,239);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
	for(i=0;i<240;i++)         //fill screen with blue pixels
	{
	    for(j=0;j<320;j++)
            {
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,319,0,239);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<240;i++)         //fill screen with green pixels
	{
	    for(j=0;j<320;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,319,0,239);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<240;i++)         //fill screen with red pixels
	{
	    for(j=0;j<320;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
            }
	}
}
//======================================================
void setup() 
{
  DDRA = 0xFF;
  PORTA = 0x00;
  DDRC = 0xFF;
  PORTC = 0x00;
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(120);
  digitalWrite(RES, HIGH);
  delay(120);
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xe2);         //set multiplier and divider of PLL
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x1d);
  TFT_Write_Data(0x02);
  TFT_Write_Data(0x04);
  TFT_Command_Write(0xe0,0x01);    //Enable PLL
  delay(1);
  TFT_Command_Write(0xe0,0x03);    //Lock PLL
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xb0);		//SET LCD MODE  SET TFT 18Bits MODE
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0c);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x80);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x01);			//SET horizontal size=320-1 HightByte
  TFT_Write_Data(0x3f);		        //SET horizontal size=320-1 LowByte
  TFT_Write_Data(0x00);			//SET vertical size=240-1 HightByte
  TFT_Write_Data(0xef);			//SET vertical size=240-1 LowByte
  TFT_Write_Data(0x00);			//SET even/odd line RGB seq.=RGB
  TFT_Command_Write(0xf0,0x00);	        //SET pixel data I/F format=8bit
  TFT_Command_Write(0x36,0x09);	        //SET address mode=flip vertical  
  TFT_Write_Command(0xe6);   		//SET PCLK freq
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x00);
  TFT_Write_Data(0xe7);
  TFT_Write_Data(0x4f);
  TFT_Write_Command(0xb4);		//SET HBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x01);			//SET HSYNC Total=440
  TFT_Write_Data(0xb8);
  TFT_Write_Data(0x00);			//SET HBP 68
  TFT_Write_Data(0x44);
  TFT_Write_Data(0x0f);  		//SET HSYNC Pulse Width=128=127pixels+1
  TFT_Write_Data(0x00);			//SET Hsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Data(0x00);			//SET Hsync pulse subpixel start position
  TFT_Write_Command(0xb6); 		//SET VBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x01);			//SET Vsync total
  TFT_Write_Data(0x08);
  TFT_Write_Data(0x00);			//SET VBP=19
  TFT_Write_Data(0x13);
  TFT_Write_Data(0x07);  		//SET VSYNC Pulse Width= 8=7lines+1
  TFT_Write_Data(0x00);			//SET Vsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Command(0x13);		//SET display on
  //TFT_Write_Command(0x38);		//SET display on
  TFT_Write_Command(0x29);		//SET display on
  delay(10);
}

void loop() 
{
  disp();
  delay(1000);  
}

NHD-5.7-640480WF-CTXI

Direct Link

//---------------------------------------------------------
/*
NHD_5_7_640480WF_mega.ino
Program for writing to Newhaven Display 5.7" TFT with NHD-5.7-640480WF-20 Controller Board (SSD1963, 8-bit)

(c)2013 Mike LaVine - Newhaven Display International, LLC.

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS  = 30;    // RS signal connected to Arduino digital pin 30
int WR  = 31;    // /WR signal connected to Arduino digital pin 31
int RD  = 32;    // /RD signal connected to Arduino digital pin 32
int RES = 33;    // /RES signal connected to Arduino digital pin 33

// /CS signal tied to GND 
// U/D and R/L signals can be either high or low, depending on scan direction preference
												 
//;******************************************************************************
void TFT_Write_Command(unsigned char command)
{
  digitalWrite(RS, LOW);
  PORTA = command;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//;******************************************************************************
void TFT_Write_Data(unsigned char data)
{
  //digitalWrite(RS, HIGH);
  PORTA = data;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//====================================================
void TFT_Command_Write(unsigned char REG,unsigned char VALUE)
{
        TFT_Write_Command(REG);
        digitalWrite(RS, HIGH);
        TFT_Write_Data(VALUE);
}
//======================================================
void WindowSet(unsigned int s_x,unsigned int e_x,unsigned int s_y,unsigned int e_y)
{
	TFT_Write_Command(0x2a);		//SET column address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_x)>>8);			//SET start column address
	TFT_Write_Data(s_x);
	TFT_Write_Data((e_x)>>8);			//SET end column address
	TFT_Write_Data(e_x);
	
	TFT_Write_Command(0x2b);		//SET page address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_y)>>8);			//SET start page address
	TFT_Write_Data(s_y);
	TFT_Write_Data((e_y)>>8);			//SET end page address
	TFT_Write_Data(e_y);
}
void disp()
{
	unsigned int i, j;
        WindowSet(0,639,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
	for(i=0;i<480;i++)         //fill screen with blue pixels
	{
	    for(j=0;j<640;j++)
            {
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,639,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<480;i++)         //fill screen with green pixels
	{
	    for(j=0;j<640;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,639,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<480;i++)         //fill screen with red pixels
	{
	    for(j=0;j<640;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
            }
	}
}
//======================================================
void setup() 
{
  DDRA = 0xFF;
  PORTA = 0x00;
  DDRC = 0xFF;
  PORTC = 0x00;
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(120);
  digitalWrite(RES, HIGH);
  delay(120);
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xe2);         //set multiplier and divider of PLL
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x1d);
  TFT_Write_Data(0x02);
  TFT_Write_Data(0x04);
  TFT_Command_Write(0xe0,0x01);    //Enable PLL
  delay(1);
  TFT_Command_Write(0xe0,0x03);    //Lock PLL
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xb0);		//SET LCD MODE  SET TFT 18Bits MODE
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0c);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x80);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x02);			//SET horizontal size=320-1 HightByte
  TFT_Write_Data(0x7f);		        //SET horizontal size=320-1 LowByte
  TFT_Write_Data(0x01);			//SET vertical size=240-1 HightByte
  TFT_Write_Data(0xdf);			//SET vertical size=240-1 LowByte
  TFT_Write_Data(0x00);			//SET even/odd line RGB seq.=RGB
  TFT_Command_Write(0xf0,0x00);	        //SET pixel data I/F format=8bit
  TFT_Command_Write(0x36,0x09);	        //SET address mode=flip vertical  
  TFT_Write_Command(0xe6);   		//SET PCLK freq
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x02);
  TFT_Write_Data(0xff);
  TFT_Write_Data(0xff);
  TFT_Write_Command(0xb4);		//SET HBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x02);			//SET HSYNC Total=760
  TFT_Write_Data(0xf8);
  TFT_Write_Data(0x00);			//SET HBP 68
  TFT_Write_Data(0x44);
  TFT_Write_Data(0x0f);  		//SET HSYNC Pulse Width=128=127pixels+1
  TFT_Write_Data(0x00);			//SET Hsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Data(0x00);			//SET Hsync pulse subpixel start position
  TFT_Write_Command(0xb6); 		//SET VBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x01);			//SET Vsync total
  TFT_Write_Data(0xf8);
  TFT_Write_Data(0x00);			//SET VBP=19
  TFT_Write_Data(0x13);
  TFT_Write_Data(0x07);  		//SET VSYNC Pulse Width= 8=7lines+1
  TFT_Write_Data(0x00);			//SET Vsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Command(0x13);		//SET display on
  //TFT_Write_Command(0x38);		//SET display on
  TFT_Write_Command(0x29);		//SET display on
  delay(10);
}

void loop() 
{
  disp();
  delay(1000);  
}

NHD-7.0-800480EF with SSD1963 controller

Direct Link

//---------------------------------------------------------
/*
NHD_7_0_800480EF_mega.ino
Program for writing to Newhaven Display 7.0" TFT with NHD-5.0-800480TF-20 Controller Board (SSD1963, 8-bit)

(c)2013 Mike LaVine - Newhaven Display International, LLC. 

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
*/
//---------------------------------------------------------

// The 8 bit data bus is connected to PORTA of the Arduino Mega2560
// 5V voltage regulator on Arduino Mega has been replaced with a 3.3V regulator to provide 3.3V logic

int RS  = 30;    // RS signal connected to Arduino digital pin 30
int WR  = 31;    // /WR signal connected to Arduino digital pin 31
int RD  = 32;    // /RD signal connected to Arduino digital pin 32
int RES = 33;    // /RES signal connected to Arduino digital pin 33
int DIS = 34;    // DISP signal connected to Arduino digital pin 34

// /CS signal tied to GND 
												 
//;******************************************************************************
void TFT_Write_Command(unsigned char command)
{
  digitalWrite(RS, LOW);
  PORTA = command;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//;******************************************************************************
void TFT_Write_Data(unsigned char data)
{
  //digitalWrite(RS, HIGH);
  PORTA = data;
  digitalWrite(WR, LOW);
  digitalWrite(WR, HIGH);
}
//====================================================
void TFT_Command_Write(unsigned char REG,unsigned char VALUE)
{
        TFT_Write_Command(REG);
        digitalWrite(RS, HIGH);
        TFT_Write_Data(VALUE);
}
//======================================================
void WindowSet(unsigned int s_x,unsigned int e_x,unsigned int s_y,unsigned int e_y)
{
	TFT_Write_Command(0x2a);		//SET column address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_x)>>8);			//SET start column address
	TFT_Write_Data(s_x);
	TFT_Write_Data((e_x)>>8);			//SET end column address
	TFT_Write_Data(e_x);
	
	TFT_Write_Command(0x2b);		//SET page address
	digitalWrite(RS, HIGH);
	TFT_Write_Data((s_y)>>8);			//SET start page address
	TFT_Write_Data(s_y);
	TFT_Write_Data((e_y)>>8);			//SET end page address
	TFT_Write_Data(e_y);
}
void disp()
{
	unsigned int i, j;
        WindowSet(0,799,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
	for(i=0;i<480;i++)         //fill screen with blue pixels
	{
	    for(j=0;j<800;j++)
            {
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,799,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<480;i++)         //fill screen with green pixels
	{
	    for(j=0;j<800;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
              TFT_Write_Data(0x00);
            }
	}
        WindowSet(0,799,0,479);               //set start/end column/page address (full screen)
	TFT_Write_Command(0x2C);              //command to begin writing to frame memory
        digitalWrite(RS, HIGH);
        for(i=0;i<480;i++)         //fill screen with red pixels
	{
	    for(j=0;j<800;j++)
            {
              TFT_Write_Data(0x00);
              TFT_Write_Data(0x00);
              TFT_Write_Data(0xFF);
            }
	}
}
//======================================================
void setup() 
{
  DDRA = 0xFF;
  PORTA = 0x00;
  DDRC = 0xFF;
  PORTC = 0x00;
  digitalWrite(DIS, HIGH);
  digitalWrite(RD, HIGH);
  digitalWrite(WR, LOW);
  digitalWrite(RES, LOW);
  delay(120);
  digitalWrite(RES, HIGH);
  delay(120);
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xe2);         //set multiplier and divider of PLL
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x1d);
  TFT_Write_Data(0x02);
  TFT_Write_Data(0x04);
  TFT_Command_Write(0xe0,0x01);    //Enable PLL
  delay(1);
  TFT_Command_Write(0xe0,0x03);    //Lock PLL
  TFT_Write_Command(0x01);         //Software reset
  delay(120);
  TFT_Write_Command(0xb0);		//SET LCD MODE  SET TFT 18Bits MODE
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x08);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x80);			//SET TFT MODE & hsync+Vsync+DEN MODE
  TFT_Write_Data(0x03);			//SET horizontal size=800-1 HightByte
  TFT_Write_Data(0x1f);		        //SET horizontal size=800-1 LowByte
  TFT_Write_Data(0x01);			//SET vertical size=480-1 HightByte
  TFT_Write_Data(0xdf);			//SET vertical size=480-1 LowByte
  TFT_Write_Data(0x00);			//SET even/odd line RGB seq.=RGB
  TFT_Command_Write(0xf0,0x00);	        //SET pixel data I/F format=8bit
  TFT_Command_Write(0x36,0x09);	        //SET address mode=flip vertical  
  TFT_Write_Command(0xe6);   		//SET PCLK freq
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x0f);
  TFT_Write_Data(0xff);
  TFT_Write_Data(0xff);
  TFT_Write_Command(0xb4);		//SET HBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x04);			//SET HSYNC Total=1056
  TFT_Write_Data(0x20);
  TFT_Write_Data(0x00);			//SET HBP 88
  TFT_Write_Data(0x58);
  TFT_Write_Data(0x80);  		//SET HSYNC Pulse Width=128=127pixels+1
  TFT_Write_Data(0x00);			//SET Hsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Data(0x00);			//SET Hsync pulse subpixel start position
  TFT_Write_Command(0xb6); 		//SET VBP
  digitalWrite(RS, HIGH);
  TFT_Write_Data(0x02);			//SET Vsync total 525
  TFT_Write_Data(0x0d);
  TFT_Write_Data(0x00);			//SET VBP=32
  TFT_Write_Data(0x20);
  TFT_Write_Data(0x01);  		//SET VSYNC Pulse Width= 0=0lines+1
  TFT_Write_Data(0x00);			//SET Vsync pulse start position
  TFT_Write_Data(0x00);
  TFT_Write_Command(0x13);		//SET display on
  TFT_Write_Command(0x38);		//SET display on
  TFT_Write_Command(0x29);		//SET display on
  delay(10);
}

void loop() 
{
  disp();
  delay(1000);  
}

NHD-0216MW, NHD-0216CW, NHD-0220CW, NHD-0420CW

Direct Link

#include <Wire.h>
//#include <SPI.h>

int RS = 30;
int  E = 31;
int RES = 32;
int CS = 33;

int ASDA = 20;
int ASCL = 21;

int SCLK = 52;
int SDIN = 51;
int SDOUT = 50;

// R/W signal tied LOW (always write)

unsigned char tx_packet[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

const char slave2w = 0x3C;  //3C or 78

unsigned char mode = 0; // 0 = 8-bit parallel 6800 mode; 1 = i2c mode; 2 = SPI mode;

unsigned char text1[] = {"Newhaven Display----"};
unsigned char text2[] = {"Slim OLED Display---"};
unsigned char text3[] = {"16/20 Characters----"};
unsigned char text4[] = {"!@#$%^&*()_+{}[]<>?~"};

void command(unsigned char c)
{
  unsigned char i, temp;
  switch(mode)
  {
    case 0:   digitalWrite(CS, LOW);
              PORTA = c;
              digitalWrite(RS, LOW);
              digitalWrite(E, HIGH);
              delay(1);
              digitalWrite(E, LOW);
              digitalWrite(CS, HIGH);
              break;
   case 1:    tx_packet[0] = 0x00;
              tx_packet[1] = c;
              send_packet(2);
              break;
   case 2:    
              temp = 0xF8;
              for(i=0;i<8;i++)
              {
                digitalWrite(SCLK, LOW);
                if((temp&0x80)>>7==1)
                {
                  digitalWrite(SDIN, HIGH);
                }
                else
                {
                  digitalWrite(SDIN, LOW);
                }
                temp = temp << 1;
                digitalWrite(SCLK, HIGH);
              }
  
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                if((c&0x01)==1)
                {
                  digitalWrite(SDIN, HIGH);
                }
                else
                {
                  digitalWrite(SDIN, LOW);
                }
                c = c >> 1;
                digitalWrite(SCLK, HIGH);
              }
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                digitalWrite(SDIN, LOW);
                digitalWrite(SCLK, HIGH);
              }
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                if((c&0x10)==0x10)
                {
                  digitalWrite(SDIN, HIGH);
                }
                else
                {
                  digitalWrite(SDIN, LOW);
                }
                c = c >> 1;
                digitalWrite(SCLK, HIGH);
              }
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                digitalWrite(SDIN, LOW);
                digitalWrite(SCLK, HIGH);
              }
              break;
  }
  
}
void data(unsigned char d)
{
  unsigned char i, temp;
  switch(mode)
  {
    case 0:   digitalWrite(CS, LOW);
              PORTA = d;
              digitalWrite(RS, HIGH);
              digitalWrite(E, HIGH);
              delay(1);
              digitalWrite(E, LOW);
              digitalWrite(CS, HIGH);
              break;
   case 1:    tx_packet[0] = 0x40;
              tx_packet[1] = d;
              send_packet(2);
              break;
   case 2:    
              temp = 0xFA;
              for(i=0;i<8;i++)
              {
                digitalWrite(SCLK, LOW);
                if((temp&0x80)>>7==1)
                {
                  digitalWrite(SDIN, HIGH);
                }
                else
                {
                  digitalWrite(SDIN, LOW);
                }
                temp = temp << 1;
                digitalWrite(SCLK, HIGH);
              }
  
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                if((d&0x01)==1)
                {
                  digitalWrite(SDIN, HIGH);
                }
                else
                {
                  digitalWrite(SDIN, LOW);
                }
                d = d >> 1;
                digitalWrite(SCLK, HIGH);
              }
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                digitalWrite(SDIN, LOW);
                digitalWrite(SCLK, HIGH);
              }
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                if((d&0x10)==0x10)
                {
                  digitalWrite(SDIN, HIGH);
                }
                else
                {
                  digitalWrite(SDIN, LOW);
                }
                d = d >> 1;
                digitalWrite(SCLK, HIGH);
              }
              for(i=0;i<4;i++)
              {
                digitalWrite(SCLK, LOW);
                digitalWrite(SDIN, LOW);
                digitalWrite(SCLK, HIGH);
              }
              break;
  }
  
}

void send_packet(unsigned char x)
{
  unsigned char ix;
  
  Wire.beginTransmission(slave2w);
  for(ix=0;ix<x;ix++)
  {
    Wire.write(tx_packet[ix]);
  }
  Wire.endTransmission();
}


void output()
{
	int i;

        command(0x01);
        delay(2);
        for(i=0;i<20;i++){
          data(text1[i]);
        }
        
        command(0xA0);
        for(i=0;i<20;i++){
          data(text2[i]);
        }
        
        command(0xC0);
        for(i=0;i<20;i++){
          data(text3[i]);
        }
        command(0xE0);
        for(i=0;i<20;i++){
          data(text4[i]);
        }
        delay(2000);

	command(0x01);
        delay(2);
	for (i=0;i<20;i++){
		data(text3[i]);
	}
	
	command(0xA0);
	for (i=0;i<20;i++){
		data(text4[i]);
	}

	command(0xC0);
	for (i=0;i<20;i++){
		data(text1[i]);
	}
	
	command(0xE0);
	for (i=0;i<20;i++){
		data(text2[i]);
	}
}

void outputTest()
{
	int i;

        command(0x01);
        delay(2);
        data('N');
        while(1);
        
        for(i=0;i<20;i++){
          data(text1[i]);
        }
        
        command(0xA0);
        for(i=0;i<20;i++){
          data(text2[i]);
        }
        
        command(0xC0);
        for(i=0;i<20;i++){
          data(text3[i]);
        }
        command(0xE0);
        for(i=0;i<20;i++){
          data(text4[i]);
        }
        delay(2000);

	command(0x01);
        delay(2);
	for (i=0;i<20;i++){
		data(text3[i]);
	}
	
	command(0xA0);
	for (i=0;i<20;i++){
		data(text4[i]);
	}

	command(0xC0);
	for (i=0;i<20;i++){
		data(text1[i]);
	}
	
	command(0xE0);
	for (i=0;i<20;i++){
		data(text2[i]);
	}
}

void blocks()
{
	int i;

        command(0x01);
        delay(2);

        for(i=0;i<20;i++){
          data(0x1F);
        }

        command(0xA0);
        for(i=0;i<20;i++){
          data(0x1F);
        }
}

void setup() 
{
  pinMode(ASCL, OUTPUT);      //set Arduino I2C lines as outputs
  pinMode(ASDA, OUTPUT);      //
  digitalWrite(ASCL, LOW);    //
  digitalWrite(ASDA, LOW);    //
  pinMode(SCLK, OUTPUT);
  pinMode(SDIN, OUTPUT);
  pinMode(SDOUT, INPUT);
  digitalWrite(SCLK, HIGH);
  digitalWrite(SDIN, HIGH);
  DDRA = 0xFF;
  PORTA = 0x00;
  DDRC = 0xFF;
  PORTC = 0x00;
  digitalWrite(RES, HIGH);
  delay(10);
  Wire.begin();
  delay(10);
  //SPI.begin();
  command(0x2A);  //function set (extended command set)
	    command(0x71);  //function selection A, disable internal Vdd regualtor
	    data(0x00);
	command(0x28);  //function set (fundamental command set)
	command(0x08);  //display off, cursor off, blink off
	command(0x2A);  //function set (extended command set)
	command(0x79);  //OLED command set enabled
	command(0xD5);  //set display clock divide ratio/oscillator frequency
	command(0x70);  //set display clock divide ratio/oscillator frequency
	command(0x78);  //OLED command set disabled
	command(0x09);  //extended function set (4-lines)
        command(0x06);  //COM SEG direction
	command(0x72);  //function selection B, disable internal Vdd regualtor
	data(0x00);     //ROM CGRAM selection
	command(0x2A);  //function set (extended command set)
	command(0x79);  //OLED command set enabled
	command(0xDA);  //set SEG pins hardware configuration
	command(0x00);  //set SEG pins hardware configuration   ////////////////////////////////////0x10 on other slim char OLEDs
	command(0xDC);  //function selection C
	command(0x00);  //function selection C
	command(0x81);  //set contrast control
	command(0x7F);  //set contrast control
	command(0xD9);  //set phase length
	command(0xF1);  //set phase length
	command(0xDB);  //set VCOMH deselect level
	command(0x40);  //set VCOMH deselect level
	command(0x78);  //OLED command set disabled
	command(0x28);  //function set (fundamental command set)
	command(0x01);  //clear display
	command(0x80);  //set DDRAM address to 0x00
	command(0x0C);  //display ON
  delay(100);
  //Wire.begin();
  //delay(10);
}

void loop() 
{  
  while(1)
  {
    //output();
    blocks();
    while(1);
    //outputTest();
    delay(2000);
  }
}

US2066