pro mini LCD 5110 / PCD8544 + ADC

[3roomlab]

just another 1 of the millions of video about LCD and ADC
but this 1 is shorter

https://youtu.be/RwI-rozF_iI

for those who want to have some fun with the code
the base code involved

Code: [Select]

#define RST 6
#define CE 7
#define DC 5
#define DIN 11
#define CLK 13
float T1 = 0.0;
float T2 = 0.0;
float BAA = 0.0;
float AAA = 0.0;
char AA[10];
int os = 800;
static const byte ASCII[][5] =
{
   {0x00, 0x00, 0x00, 0x00, 0x00} // 0x20
  ,{0x00, 0x00, 0x5f, 0x00, 0x00} // 0x21 !
  ,{0x00, 0x07, 0x00, 0x07, 0x00} // 0x22 "
  ,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 0x23 #
  ,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 0x24 $
  ,{0x23, 0x13, 0x08, 0x64, 0x62} // 0x25 %
  ,{0x36, 0x49, 0x55, 0x22, 0x50} // 0x26 &
  ,{0x00, 0x05, 0x03, 0x00, 0x00} // 0x27 '
  ,{0x00, 0x1c, 0x22, 0x41, 0x00} // 0x28 (
  ,{0x00, 0x41, 0x22, 0x1c, 0x00} // 0x29 )
  ,{0x14, 0x08, 0x3e, 0x08, 0x14} // 0x2a *
  ,{0x08, 0x08, 0x3e, 0x08, 0x08} // 0x2b +
  ,{0x00, 0x50, 0x30, 0x00, 0x00} // 0x2c ,
  ,{0x08, 0x08, 0x08, 0x08, 0x08} // 0x2d -
  ,{0x00, 0x60, 0x60, 0x00, 0x00} // 0x2e .
  ,{0x20, 0x10, 0x08, 0x04, 0x02} // 0x2f /
  ,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 0x30 0
  ,{0x00, 0x42, 0x7f, 0x40, 0x00} // 0x31 1
  ,{0x42, 0x61, 0x51, 0x49, 0x46} // 0x32 2
  ,{0x21, 0x41, 0x45, 0x4b, 0x31} // 0x33 3
  ,{0x18, 0x14, 0x12, 0x7f, 0x10} // 0x34 4
  ,{0x27, 0x45, 0x45, 0x45, 0x39} // 0x35 5
  ,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 0x36 6
  ,{0x01, 0x71, 0x09, 0x05, 0x03} // 0x37 7
  ,{0x36, 0x49, 0x49, 0x49, 0x36} // 0x38 8
  ,{0x06, 0x49, 0x49, 0x29, 0x1e} // 0x39 9
  ,{0x00, 0x36, 0x36, 0x00, 0x00} // 0x3a :
  ,{0x00, 0x56, 0x36, 0x00, 0x00} // 0x3b ;
  ,{0x08, 0x14, 0x22, 0x41, 0x00} // 0x3c <
  ,{0x14, 0x14, 0x14, 0x14, 0x14} // 0x3d =
  ,{0x00, 0x41, 0x22, 0x14, 0x08} // 0x3e >
  ,{0x02, 0x01, 0x51, 0x09, 0x06} // 0x3f ?
  ,{0x32, 0x49, 0x79, 0x41, 0x3e} // 0x40 @
  ,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 0x41 A
  ,{0x44, 0x64, 0x54, 0x4c, 0x44} // 0x42 B
}
;
void LcdWD(byte cmd)  // write data
{
  digitalWrite(DC, HIGH);
  digitalWrite(CE, LOW);
  shiftOut(DIN, CLK, MSBFIRST, cmd);
  digitalWrite(CE, HIGH);
}
void LcdCH(char CH)  //write character
{
  for (int i=0; i<5; i++)
  LcdWD(ASCII[CH -0x20][i]);
  LcdWD(0x00);
 
}
void LcdST(char *chrs) // write STRING
{
  while (*chrs) LcdCH(*chrs++);
}
void LcdXY(int x, int y) // position at X,Y
{
  LcdWC(0x80 | x); // to continue from video, why is it a |
  LcdWC(0x40 | y);
}
float readADC()
{ 
   AAA = 0.0;
   for (int k = 0; k< os; k++)    {    AAA = AAA +analogRead(A0);    } // ADC oversampled os=16 =4x,
   BAA = AAA / os /7; // divide 888 just to make decimals
   return BAA;
}
void LcdWC(byte cmd)  //write cmd
{
  digitalWrite(DC, LOW);
  digitalWrite(CE, LOW);
  shiftOut(DIN, CLK, MSBFIRST, cmd);
  digitalWrite(CE, HIGH);
}
void setup()
{
  analogReference(INTERNAL);    // use int 1.1vref
  Serial.begin(9600, SERIAL_8N1);
  pinMode(6, OUTPUT); // rst
  pinMode(7, OUTPUT); // ce
  pinMode(5, OUTPUT); // dc
  pinMode(11, OUTPUT); // din
  pinMode(13, OUTPUT); // clk
  digitalWrite(RST, LOW);
  digitalWrite(RST, HIGH);
  LcdWC(0x21); // LCD extended commands
  LcdWC(0xb8); // set LCD Vop (contrast)
  LcdWC(0x04); // set temp coefficent
  LcdWC(0x13); // LCD bias mode
  LcdWC(0x20); // LCD basic commands
  //LcdWC(0x09); // LCD all segments on
  //LcdWC(0x08); // LCD all segments off
  LcdWC(0x0C); // LCD video
  //r =random(-9.0,9.0);
  randomSeed(9);
  }


void loop() // the play room
{
  T1 = micros();

  //LcdXY(random(0,84),random(0,6)); // position xy random
  //LcdWC(0x09); // LCD all segments on
  //for (int i=0; i<12; i++) {
  // delayMicroseconds (d);
  //LcdWD(random(0,128));} // this one line spaced random @xy
  // LcdWD(random(0,256));} // this one full height random @xy
  //LcdCH(random(32,128)); // display gibberish letters @xy
  //LcdXY(0,0);
  //if (BAA > 2) { LcdST("                                                                                    ") ;} // clear 14 spaces line at random
  //LcdST("xxx345678901234567890123456789012345678901234567890123456789012345678901234567890...") ; // fill 84 chars full screen
  //exit(0);

  for ( int c = 0; c <5; c++)
  {
 int d = random(0,5);
//int d = c;
    if (micros() <3300000) {
   LcdST("             ") ;}
  LcdXY(6,d); // prep to display readADC
  readADC(); // pretend arduino is a HP3458a
  LcdST(dtostrf(BAA,4,1, AA)); // right align ?
  LcdST(" ");
 
  LcdXY(48,d);
  readADC(); // pretend arduino is a HP3458a
  LcdST(dtostrf(BAA,4,1, AA)); // right align ?
  LcdST(" ");
 
  }
// LcdXY(0,4);
//  LcdST(dtostrf(AAA,11,1, AA)); // right align ?
//  LcdXY(8,5);
//  LcdST(dtostrf((micros()/1000),11,0, AA)); // right align ?
//Serial.println(dtostrf((AAA),11,1, AA)); // send to serial monitor to looky look
 

     if (micros() <3300000) {
   LcdST("             ") ;}
if (BAA > 1.2) {   LcdST("  ");}
  LcdXY(26,5);
   T2 = micros();
    LcdST(dtostrf((1000000/(T2-T1)),4,3, AA)); // right align ?
    LcdST("AB");
}



the wait for python trigger code

Code: [Select]

#include "FONT.h"
#define RST 6
#define CE 7
#define DC 5
#define DIN 11
#define CLK 13
float T1 = 0.0;
float T2 = 0.0;
float T3 = 0.0;
float T4 = 0.0;
float T5 = 0.0;
float BAA = 0.0;
float AAA = 0.0;
char AA[10];
int os = 800;
int clr = 1;
int si =0;
int se =0;
int r =1000000;
void LcdWC(byte cmd)  //write cmd
{
  digitalWrite(DC, LOW);
  digitalWrite(CE, LOW);
  shiftOut(DIN, CLK, MSBFIRST, cmd);
  digitalWrite(CE, HIGH);
}
void LcdWD(byte cmd)  // write data
{
  digitalWrite(DC, HIGH);
  digitalWrite(CE, LOW);
  shiftOut(DIN, CLK, MSBFIRST, cmd);
  digitalWrite(CE, HIGH);
}
void LcdCH(char CH)  //write character
{
  for (int i=0; i<5; i++)
  LcdWD(ASCII[CH -0x20][i]);
  LcdWD(0x00);
 
}
void LcdST(char *chrs) // write STRING
{
  while (*chrs) LcdCH(*chrs++);
}
void LcdXY(int x, int y) // position at X,Y
{
  LcdWC(0x80 | x); // to continue from video, why is it a |
  LcdWC(0x40 | y);
}
float readADC()
{ 
   AAA = 0.0;
   for (int k = 0; k< os; k++)    {    AAA = AAA +analogRead(A0);    } // ADC oversampled os=16 =4x,
   BAA = AAA / os /7; // divide 888 just to make decimals
   return BAA;
}
void out()
{
for ( int c = 1; c <4; c++)  {
int d = c;   
  LcdXY(6,d); // prep to display readADC
  readADC(); // pretend arduino is a HP3458a
  LcdST(dtostrf(BAA,5,4, AA)); // right align ?
    LcdXY(48,d);
  readADC(); // pretend arduino is a HP3458a
  LcdST(dtostrf(BAA,5,4, AA)); // right align ?
    Serial.println(BAA);
 
  }}

void setup()
{
  analogReference(INTERNAL);    // use int 1.1vref
  Serial.begin(9600, SERIAL_8N1);
  Serial.flush();
//Serial.read();
  pinMode(6, OUTPUT); // rst
  pinMode(7, OUTPUT); // ce
  pinMode(5, OUTPUT); // dc
  pinMode(11, OUTPUT); // din
  pinMode(13, OUTPUT); // clk
  digitalWrite(RST, LOW);
  digitalWrite(RST, HIGH);
  LcdWC(0x21); // LCD extended commands
  LcdWC(0xb8); // set LCD Vop (contrast)
  LcdWC(0x04); // set temp coefficent
  LcdWC(0x13); // LCD bias mode
  LcdWC(0x20); // LCD basic commands
  LcdWC(0x0C); // LCD video
  randomSeed(9); 
if ((T5<5000000)&&(clr = 1)) {
LcdXY(0,0);
   LcdST("              ") ;
   LcdST("              ") ;
   LcdST("              ") ;
   LcdST("              ") ;
   LcdST("              ") ;
   LcdST("              ") ;
   T4 = micros();
   } 
 
}

void loop() // the play room
{
se = 0;
T1 = micros();
delayMicroseconds (r);
 
if (Serial.available() > 0)   {
si = Serial.read();
LcdXY(0,0);
LcdST("Python trigger");
delay (1000);
LcdXY(0,0);
//se = (dtostrf(si,3,0, AA));
//LcdST(se);
LcdST("              ");
delay (200);
//out();
//clr = 0;
//T4=micros()-T1;
T4 = micros();

BAA = readADC();
Serial.println(BAA);
delay (200);
LcdXY(0,2);
LcdST("ADC=") ;
LcdST(dtostrf(BAA,6,3, AA));
LcdXY(0,0);
}


//LcdXY(72,5);
//LcdST("  ") ;
LcdXY(0,5);

LcdST("LCD ") ;
T2 = micros();
LcdST(dtostrf(1000000/(T2-T1),7,2, AA));
LcdST(" Hz") ;
//LcdST("/") ;
//LcdST(dtostrf(1000000/(T1-T3),5,2, AA));
LcdXY(0,4);
//LcdST(dtostrf(CLR,1,0, AA));

T3 = micros();
delayMicroseconds (r);
// LcdXY(0,0);
T5 = micros()-T4;
LcdST("idle ") ;
LcdST(dtostrf(T5/1000000,6,2, AA));
LcdST(" s") ;
//clr = 0;
}



font

Code: [Select]

       
static const byte ASCII[][5] =   //, hex/char 
{       
  {0x00, 0x00, 0x00, 0x00, 0x00}  //, 20 
 ,{0x00, 0x00, 0x5f, 0x00, 0x00}  //, 21 !
 ,{0x00, 0x07, 0x00, 0x07, 0x00}  //, 22 “
 ,{0x14, 0x7f, 0x14, 0x7f, 0x14}  //, 23 #
 ,{0x24, 0x2a, 0x7f, 0x2a, 0x12}  //, 24 $
 ,{0x23, 0x13, 0x08, 0x64, 0x62}  //, 25 %
 ,{0x36, 0x49, 0x55, 0x22, 0x50}  //, 26 &
 ,{0x00, 0x05, 0x03, 0x00, 0x00}  //, 27 '
 ,{0x00, 0x1c, 0x22, 0x41, 0x00}  //, 28 (
 ,{0x00, 0x41, 0x22, 0x1c, 0x00}  //, 29 )
 ,{0x14, 0x08, 0x3e, 0x08, 0x14}  //, 2a *
 ,{0x08, 0x08, 0x3e, 0x08, 0x08}  //, 2b +
 ,{0x00, 0x50, 0x30, 0x00, 0x00}  //, 2c ,
 ,{0x08, 0x08, 0x08, 0x08, 0x08}  //, 2d -
 ,{0x00, 0x60, 0x60, 0x00, 0x00}  //, 2e .
 ,{0x20, 0x10, 0x08, 0x04, 0x02}  //, 2f  /
 ,{0x3e, 0x51, 0x49, 0x45, 0x3e}  //, 30 0
 ,{0x00, 0x42, 0x7f, 0x40, 0x00}  //, 31 1
 ,{0x42, 0x61, 0x51, 0x49, 0x46}  //, 32 2
 ,{0x21, 0x41, 0x45, 0x4b, 0x31}  //, 33 3
 ,{0x18, 0x14, 0x12, 0x7f, 0x10}  //, 34 4
 ,{0x27, 0x45, 0x45, 0x45, 0x39}  //, 35 5
 ,{0x3c, 0x4a, 0x49, 0x49, 0x30}  //, 36 6
 ,{0x01, 0x71, 0x09, 0x05, 0x03}  //, 37 7
 ,{0x36, 0x49, 0x49, 0x49, 0x36}  //, 38 8
 ,{0x06, 0x49, 0x49, 0x29, 0x1e}  //, 39 9
 ,{0x00, 0x36, 0x36, 0x00, 0x00}  //, 3a :
 ,{0x00, 0x56, 0x36, 0x00, 0x00}  //, 3b ;
 ,{0x08, 0x14, 0x22, 0x41, 0x00}  //, 3c <
 ,{0x14, 0x14, 0x14, 0x14, 0x14}  //, 3d =
 ,{0x00, 0x41, 0x22, 0x14, 0x08}  //, 3e >
 ,{0x02, 0x01, 0x51, 0x09, 0x06}  //, 3f ?
 ,{0x32, 0x49, 0x79, 0x41, 0x3e}  //, 40 @
 ,{0x7e, 0x11, 0x11, 0x11, 0x7e}  //, 41 A
 ,{0x7f, 0x49, 0x49, 0x49, 0x36}  //, 42 B
 ,{0x3e, 0x41, 0x41, 0x41, 0x22}  //, 43 C
 ,{0x7f, 0x41, 0x41, 0x22, 0x1c}  //, 44 D
 ,{0x7f, 0x49, 0x49, 0x49, 0x41}  //, 45 E
 ,{0x7f, 0x09, 0x09, 0x09, 0x01}  //, 46 F
 ,{0x3e, 0x41, 0x49, 0x49, 0x7a}  //, 47 G
 ,{0x7f, 0x08, 0x08, 0x08, 0x7f}  //, 48 H
 ,{0x00, 0x41, 0x7f, 0x41, 0x00}  //, 49 I
 ,{0x20, 0x40, 0x41, 0x3f, 0x01}  //, 4a J
 ,{0x7f, 0x08, 0x14, 0x22, 0x41}  //, 4b K
 ,{0x7f, 0x40, 0x40, 0x40, 0x40}  //, 4c L
 ,{0x7f, 0x02, 0x0c, 0x02, 0x7f}  //, 4d M
 ,{0x7f, 0x04, 0x08, 0x10, 0x7f}  //, 4e N
 ,{0x3e, 0x41, 0x41, 0x41, 0x3e}  //, 4f O
 ,{0x7f, 0x09, 0x09, 0x09, 0x06}  //, 50 P
 ,{0x3e, 0x41, 0x51, 0x21, 0x5e}  //, 51 Q
 ,{0x7f, 0x09, 0x19, 0x29, 0x46}  //, 52 R
 ,{0x46, 0x49, 0x49, 0x49, 0x31}  //, 53 S
 ,{0x01, 0x01, 0x7f, 0x01, 0x01}  //, 54 T
 ,{0x3f, 0x40, 0x40, 0x40, 0x3f}  //, 55 U
 ,{0x1f, 0x20, 0x40, 0x20, 0x1f}  //, 56 V
 ,{0x3f, 0x40, 0x38, 0x40, 0x3f}  //, 57 W
 ,{0x63, 0x14, 0x08, 0x14, 0x63}  //, 58 X
 ,{0x07, 0x08, 0x70, 0x08, 0x07}  //, 59 Y
 ,{0x61, 0x51, 0x49, 0x45, 0x43}  //, 5a Z
 ,{0x00, 0x7f, 0x41, 0x41, 0x00}  //, 5b [
 ,{0x02, 0x04, 0x08, 0x10, 0x20}  //, 5c \   //
 ,{0x00, 0x41, 0x41, 0x7f, 0x00}  //, 5d ]
 ,{0x04, 0x02, 0x01, 0x02, 0x04}  //, 5e ^
 ,{0x40, 0x40, 0x40, 0x40, 0x40}  //, 5f _
 ,{0x00, 0x01, 0x02, 0x04, 0x00}  //, 60 `
 ,{0x20, 0x54, 0x54, 0x54, 0x78}  //, 61 a
 ,{0x7f, 0x48, 0x44, 0x44, 0x38}  //, 62 b
 ,{0x38, 0x44, 0x44, 0x44, 0x20}  //, 63 c
 ,{0x38, 0x44, 0x44, 0x48, 0x7f}  //, 64 d
 ,{0x38, 0x54, 0x54, 0x54, 0x18}  //, 65 e
 ,{0x08, 0x7e, 0x09, 0x01, 0x02}  //, 66 f
 ,{0x0c, 0x52, 0x52, 0x52, 0x3e}  //, 67 g
 ,{0x7f, 0x08, 0x04, 0x04, 0x78}  //, 68 h
 ,{0x00, 0x44, 0x7d, 0x40, 0x00}  //, 69 i
 ,{0x20, 0x40, 0x44, 0x3d, 0x00}  //, 6a j
 ,{0x7f, 0x10, 0x28, 0x44, 0x00}  //, 6b k
 ,{0x00, 0x41, 0x7f, 0x40, 0x00}  //, 6c l
 ,{0x7c, 0x04, 0x18, 0x04, 0x78}  //, 6d m
 ,{0x7c, 0x08, 0x04, 0x04, 0x78}  //, 6e n
 ,{0x38, 0x44, 0x44, 0x44, 0x38}  //, 6f o
 ,{0x7c, 0x14, 0x14, 0x14, 0x08}  //, 70 p
 ,{0x08, 0x14, 0x14, 0x18, 0x7c}  //, 71 q
 ,{0x7c, 0x08, 0x04, 0x04, 0x08}  //, 72 r
 ,{0x48, 0x54, 0x54, 0x54, 0x20}  //, 73 s
 ,{0x04, 0x3f, 0x44, 0x40, 0x20}  //, 74 t
 ,{0x3c, 0x40, 0x40, 0x20, 0x7c}  //, 75 u
 ,{0x1c, 0x20, 0x40, 0x20, 0x1c}  //, 76 v
 ,{0x3c, 0x40, 0x30, 0x40, 0x3c}  //, 77 w
 ,{0x44, 0x28, 0x10, 0x28, 0x44}  //, 78 x
 ,{0x0c, 0x50, 0x50, 0x50, 0x3c}  //, 79 y
 ,{0x44, 0x64, 0x54, 0x4c, 0x44}  //, 7a z
 ,{0x00, 0x08, 0x36, 0x41, 0x00}  //, 7b ,{
 ,{0x00, 0x00, 0x7f, 0x00, 0x00}  //, 7c |
 ,{0x00, 0x41, 0x36, 0x08, 0x00}  //, 7d }
 ,{0x10, 0x08, 0x08, 0x10, 0x08}  //, 7e ~
 ,{0x78, 0x46, 0x41, 0x46, 0x78}  //, 7f DEL
}
;

python 2.7 trigger

Code: [Select]

import serial
#import syslog
import time
import random





ser = serial.Serial(
port='COM9',
baudrate=9600,
parity='N',
stopbits=1,
bytesize=8,
xonxoff=0,
timeout=3,
rtscts=0,
dsrdtr=0,
writeTimeout=3
)
time.sleep(2) # wait for DUT bootup
ser.flush()

while (True):
    ser.write('1')
    line = ser.readline()
    print (line)
    r = random.randint(2, 5)
    time.sleep(r)
#    ser.close()


basically the final playthang turns the pro mini, waiting for a "1" instruction from python. which triggers the ADC, and send data back.
after this, a XLWT can be written/added in python to collect all the adc data and save all the collected data into a xls file with rows and columns.

[3roomlab]

the poor mans DMM logger? I think I have posted this somewhere, but I actually forgotten where I saved those python files

example of python 2.7 + xlwt 1.3
used as a logger
(python 2.7 is used because I am going to use all ASCII only, no unicode)

Code: [Select]

import serial
#import syslog
import time
import random
import xlwt
from datetime import datetime
style0 = xlwt.easyxf('font: name Times New Roman, color-index red, bold on',
    num_format_str='#,##0.00')
style1 = xlwt.easyxf(num_format_str='D-MMM-YY')
# style is here for show, it is not used

wb = xlwt.Workbook()
ws = wb.add_sheet('ADC01') # sheet name is .... ADC01

ser = serial.Serial(
port='COM9',
baudrate=9600,
parity='N',
stopbits=1,
bytesize=8,
xonxoff=0,
timeout=3,
rtscts=0,
dsrdtr=0,
writeTimeout=3
)
time.sleep(2) # wait for DUT bootup
ser.flush()
x = 0
t0 =0.0
t1 = 0.0

for x in range (0,5):
    t0 = time.clock()
    ser.write('1')
    line = ser.readline()
    f = float(line);
    print (line)
    ws.write(x, 0, t0)
    ws.write(x, 1, f)
    t1 = time.clock()
    print (t1-t0)
    print (x+1)
    ser.flush()
#    r = random.randint(2, 5)
#    time.sleep(r)

ser.close()
wb.save('ADC01' + str(t0) + '.xls') #raw time as part of file name

picture of the sheet (see below pic)
the raw time is imprinted as a ref as xlwt col 0 = in sheet as col A, xlwt col 1 = in sheet as col B
loop can be applied to file names as well to create very long multi file spanning data collection routines.
this is actually what I used many years ago to read keithley K2015 data off RS232 (instead of GPIB)

with the pro-mini doing minimum printing of LCD writes
the to and fro data triggering is under 0.25s per fetch for a pro mini with 512 averages done on pro-mini itself

*edit changed string ADC read into float number to store into xls.

happy triggering !
(keep logging those DMM noise!)

[3roomlab]

yesterday, i managed to decipher the startup sequence for a quirky panel (about 79mm wide pixels width, 62dpi). JLX 19264-329 3.3v (about USD7 shipped from taobao).
i almost wanted to throw it away as it does not respond to anything, i thought it was broken (or wrong combination of code)
but it was when i put the engine to sleep (B10101001), that it started to worked !

edit the power sequence was retested with a powersave reset (B11100001 0xe1), it has similar effect as sleep to turn on the LCD engine.

the LED backlight is very bright, the picture shown is using additional 2x 220R+ onboard 200R. @3.3v = 5-6mA (not the usual 20mA) + typ operating LCD engine of 0.15mA (sleep is under 5uA).
the support pcb is able to accommodate a font eeprom which is not installed in my version.
my successful test drive is using 4wire mode. there is no multiple CS, only 1 engine.

in the process of trying to get the engine to work, i try to "steal" many pdf and look at potential libraries which already have got it to work. including u8g2. u8g2 by trying the hello world, it didnt work off the bat. did not compile.

after stumbling on the sleep mode, i draw up a chart showing how the engine starters compare. of interest to this IST3020, is that it has a power sequence 0x2c+2e+2f. ERC LCd company list theirs as after a bias instruction, JLX is after. u8g2 is using ERC. i tried both before and after, no difference. ERC is based on IST sequence.
of interest is the 0xa9 instruction, goto sleep and it start to understand 0xaf = turn on LCD.
this LCD also has a interesting power down sequence, it also has an elaborate sequence to discharge LCD charge pump... if you use it.
so using the original IST pdf sequence, 9 instructions + 1 sleep = 10 instructions to do a complete startup. bare startup + 5x8 ASCII font = about 7kb. no other library required for std text.

so if you are a LCD expert, here is a question : do you really need to power down LCD in sequence? what if you dont?

attached are some test codes and a pic
and this is the pin config
big pixels ! yea !

Code: [Select]

// LCD --------> MCU

// 05 LED BL --> 4 LED
// 06 GND
// 07 V+
//
// 08 A0/RS ---> 5 RS
// 09 RESET ---> 6 RT
// 10 CS ------> 7 CS
// 11/D7 SDA --> 8 Data
// 12/D6 SCK --> 13 Clock
// 13 D5 ------> GND
// 14 D4 ------> GND
// 15 D3 ------> GND
// 16 D2 ------> GND
// 17 D1 ------> GND
// 18 D0 ------> GND
// 19 E  ------> GND
// 20 RW ------> GND
(i also spotted a 130mm wide version using ST7525. thats 48dpi. even bigger letters on 5x8 font!)

code to change contrast are 2 instructions.
simply set instruction (B10000001) + (B00000xxx) in succession.