LCD Smartie Cuts off 4th line on Adafruit 20x4 RGB HD44780

[Belial88]

So using the simple tutorial code:

Code: Select all

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

#define REDLITE 12
#define GREENLITE 11
#define BLUELITE 10

int brightness = 50;

// these constants won't change.  But you can change the size of
// your LCD using them:
const int numRows = 4;
const int numCols = 20;

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(8,3,4,5,6,7);
// RS, RW, Enable, 4,5,6,7 (Refer to the back of your LCD for details)

void setup() { 
  Serial.begin(9600);
  // set up the LCD's number of rows and columns: 
  lcd.begin(numRows, numCols);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("**LCD  SMARTIE**");
  lcd.setCursor(0,1);
  lcd.print("on Arduino");
   lcd.setCursor(0,2);
  lcd.print("*<3*");
  lcd.setCursor(0,3);
  lcd.print("123456789012345");
  
  pinMode(REDLITE, OUTPUT);
  pinMode(GREENLITE, OUTPUT);
  pinMode(BLUELITE, OUTPUT);
 
  brightness = 50;
}

byte serial_getch(){
  
  int incoming;  
  while (Serial.available()==0){}
   // read the incoming byte:
  incoming = Serial.read();

  return (byte) (incoming &0xff);
}

void loop(){
  byte rxbyte;
  byte temp;

  rxbyte = serial_getch();

  if (rxbyte == 254) //Matrix Orbital uses 254 prefix for commands
  {
    switch (serial_getch())
    {
    case 66: //backlight on (at previously set brightness)
      // not implemented            

      break;
    case 70: //backlight off
      // not implemented            
      break;
    case 71:  //set cursor position
      temp = (serial_getch() - 1);  //get column byte
      switch (serial_getch())  //get row byte
      {
        //line 1 is already set up
      case 2:
        temp += 0x40;
        break;
      case 3:
        temp += 0x14;
        break;
      case 4:
        temp += 0x54;
        break;
      default:
        break;
      }
      lcd.command(0b10000000 + temp);
      break;
    case 72:  //cursor home (reset display position)
      lcd.command(2);
      break;
    case 74:  //show underline cursor
      lcd.command(0b00001110);
      break;
    case 75:  //underline cursor off
    case 84:  //block cursor off
      lcd.command(0b00001100);
      break;
    case 76:  //move cursor left
      lcd.command(16);
      break;
    case 77:  //move cursor right
      lcd.command(20);
      break;
    case 78:  //define custom char
      lcd.command(64 + (serial_getch() * 8));  //get+set char address
      for (temp = 7; temp != 0; temp--)
      {
        lcd.print(serial_getch()); //get each pattern byte
      }
      break;
    case 83:  //show blinking block cursor
      lcd.command(0b00001111);
      break;
    case 86:  //GPO OFF
      //implement later
      break;
    case 87:  //GPO ON
      /*temp = serial_getch();
                   if (temp == 1)
                   {
                      GPO1 = GPO_ON;
                   }*/
      break;
    case 88:  //clear display, cursor home
      lcd.command(1);
      break;
    case 152: //set and remember (doesn't save value, though)
    case 153: //set backlight brightness
      //not implemented
      break;

      //these commands ignored (no parameters)
    case 35: //read serial number
    case 36: //read version number
    case 55: //read module type
    case 59: //exit flow-control mode
    case 65: //auto transmit keypresses
    case 96: //auto-repeat mode off (keypad)
    case 67: //auto line-wrap on
    case 68: //auto line-wrap off
    case 81: //auto scroll on
    case 82: //auto scroll off
    case 104: //init horiz bar graph
    case 109: //init med size digits
    case 115: //init narrow vert bar graph
    case 118: //init wide vert bar graph
      break;
    default:
      //all other commands ignored and parameter byte discarded
      temp = serial_getch();  //dump the command code
      break;
    }
    return;
  } //END OF COMMAND HANDLER

  //change accented char to plain, detect and change descenders
  //NB descenders only work on 5x10 displays. This lookup table works
  //  with my DEM-20845 (Display Elektronik GmbH) LCD using KS0066 chip.
  switch (rxbyte)
  {
    //chars that have direct equivalent in LCD charmap
    /*      case 0x67: //g
              rxbyte = 0xE7;
              break;
           case 0x6A: //j
              rxbyte = 0xEA;
              break;
           case 0x70: //p
              rxbyte = 0xF0;
              break;
           case 0x71: //q
              rxbyte = 0xF1;
              break;
           case 0x79: //y
              rxbyte = 0xF9;
              break;
     */  case 0xE4: //ASCII "a" umlaut
    rxbyte = 0xE1;
    break;
  case 0xF1: //ASCII "n" tilde
    rxbyte = 0xEE;
    break;
  case 0xF6: //ASCII "o" umlaut
    rxbyte = 0xEF; //was wrong in v0.86
    break;
  case 0xFC: //ASCII "u" umlaut
    rxbyte = 0xF5;
    break;

    //accented -> plain equivalent
    //and misc symbol translation
  case 0xA3: //sterling (pounds)
    rxbyte = 0xED;
    break;
    /*      case 0xB0: //degrees symbol
              rxbyte = 0xDF;
              break;
     */  case 0xB5: //mu
    rxbyte = 0xE4;
    break;
  case 0xC0: //"A" variants
  case 0xC1:
  case 0xC2:
  case 0xC3:
  case 0xC4:
  case 0xC5:
    rxbyte = 0x41;
    break;
  case 0xC8: //"E" variants
  case 0xC9:
  case 0xCA:
  case 0xCB:
    rxbyte = 0x45;
    break;
  case 0xCC: //"I" variants
  case 0xCD:
  case 0xCE:
  case 0xCF:
    rxbyte = 0x49;
    break;
  case 0xD1: //"N" tilde -> plain "N"
    rxbyte = 0x43;
    break;
  case 0xD2: //"O" variants
  case 0xD3:
  case 0xD4:
  case 0xD5:
  case 0xD6:
  case 0xD8:
    rxbyte = 0x4F;
    break;
  case 0xD9: //"U" variants
  case 0xDA:
  case 0xDB:
  case 0xDC:
    rxbyte = 0x55;
    break;
  case 0xDD: //"Y" acute -> "Y"
    rxbyte = 0x59;
    break;
    /*      case 0xDF: //beta  //mucks up LCDSmartie's degree symbol??
              rxbyte = 0xE2;
              break;
     */  case 0xE0: //"a" variants except umlaut
  case 0xE1:
  case 0xE2:
  case 0xE3:
  case 0xE5:
    rxbyte = 0x61;
    break;
  case 0xE7: //"c" cedilla -> "c"
    rxbyte = 0x63;
    break;
  case 0xE8: //"e" variants
  case 0xE9:
  case 0xEA:
  case 0xEB:
    rxbyte = 0x65;
    break;
  case 0xEC: //"i" variants
  case 0xED:
  case 0xEE:
  case 0xEF:
    rxbyte = 0x69;
    break;
  case 0xF2: //"o" variants except umlaut
  case 0xF3:
  case 0xF4:
  case 0xF5:
  case 0xF8:
    rxbyte = 0x6F;
    break;
  case 0xF7: //division symbol
    rxbyte = 0xFD;
    break;
  case 0xF9: //"u" variants except umlaut
  case 0xFA:
  case 0xFB:
    rxbyte = 0x75;
    break;
  default:
    break;
  }

  lcd.write(rxbyte);  //otherwise a plain char so we print it to lcd

  }

what happens is the 4th line will cut off, will show only about 4-6 characters, it changes from time to time,, when I launch smartie, and only the first 5 will change dynamically. If I edit the line after launching smartie, it'll show, but it's buggy - like if I have switching screens or a value that changes, it'll just sort of be frozen, as in only the first 5 characters will change. In general it's pretty buggy, like if i have a scrolling line often the end of the line will freeze on stuff, etc. The LCD itself is fine, it'll display on the 4th line fine.

I just have default settings, 500/500 (but 300/300 doesnt work either).
what's going on :X

[Belial88]

First and 2nd line are glitchy, they aren't appearing sometimes... most of the time. Sometimes it'l just be line 1, or line 2.... hard to understand exactly what's going on. Voltage is updating fine though.

That would seem to confirm Smartie is too smart, only updating the LCD when the display has data that's changed.

If you repeat the same experiment w/only lines 1 and 2 having 'data' to be displayed, leaving lines 3 and 4 empty ... are they (lines 1 and 2) still glitchy ?

It might be time to post some questions on the Smartie forum ?

No. It appears with just using first 2 lines, it's okay... Even with CPU Vcore and vrin, using the swapping 2 screens method, works fine. I could live with a 1 second refresh. I'd prefer a quicker one, but this is doable.

I have a guess as to what's happening w/line4 and it relates to the speed of the USB and your 32U4 based Micro.

Here's the test;
Screen 1
line1 = anything
line2 = anything
line3 =
line4 =
and;
Screen 2
line1 =
line2 =
line3 = anything
line4 = anything

That is put any characters you want on the anything lines but leave the other 2 lines blank.
If line4 shows up OK, I'll explain my guess.

Another informative test is;
Screen 1
line1 = 1
line2 = 2
line3 = 3
line4 = 12345678901234567890
no Screen 2

Use any version of Smartie code.

It goofs up. After a few seconds, line 1 will like freeze, and then the 4th line, it'll do something like characters 6-onwards will freeze, and only character 2-3 OR 1-3 OR 1-2 will show (or basically, 2 of the first 5 characters will not be there when it's time to display on that line).

So like it'll turn into:
VCORE 1.718v // VCORE 1.718v
VRIN 0.000v // XXXXXXXXXXXXXXXXX
XXXXXXXXXXXXX // VCORE 1.777v
0.000v // IN 0.000v

Seems like voltage is reading fine though.

Using only line 4 with a static or dynamic value, 1 screen or switching screens, seems to work perfectly fine.

OK one last test, this one to see how many characters Smartie @PC end sends. For example if you setup the following;
Screen 1
line1 = a
line2 = b
line3 = c
line4 = d
Screen 2
line1 = A
line2 = B
line3 = C
line4 = D

I would hope Smartie sends 2 - 4 bytes to move the cursor from line to line plus 1 for the single character. Resulting in LCD displays of (w/new test code below);
Screen 1
line1 = 5a
line2 = 3b
line3 = 5c
line4 = 5d
Screen 2
line1 = 5A
line2 = 3B
line3 = 5C
line4 = 5D

OTOH if the GUI fills in spaces after the character you place on each line, the it's 20 characters per line all the time, giving a display of;

Screen 1
line1 = 25a
line2 = 23b
line3 = 25c
line4 = 25d
Screen 2
line1 = 25A
line2 = 23B
line3 = 25C
line4 = 25D

So here's the test code to do that test.

Code: Select all

#include <VarSpeedServo.h>  //variable speed servo library
#include <LiquidCrystal.h>

//declare the constants to be used
#define LEDPIN 13             //pin attached to LED
#define servoPIN 9            //Servo control line
#define SWitchPIN 2           //input from N.O. momentary switch
#define redPIN 11             //PWM pin for red LED backlight
#define greenPIN 10           //PWM pin for green LED backlight
#define bluePIN 12            //PWM pin for blue LED backlight
#define rsPIN 8               //reset pin for LCD
#define enablePIN 7           //enable pin for LCD
#define d4PIN 4               //data pin4 for LCD
#define d5PIN 5               //data pin5 for LCD
#define d6PIN 6               //data pin6 for LCD
#define d7PIN 3               //data pin7 for LCD
// these constants won't change.  But you can change the size of
// your LCD using them:
const int numRows = 4;
const int numCols = 20;

#define posOpenCMD 1900       //Define Clockwise Servo position in usec
#define posCloseCMD 600       //Define CounterClockwise Servo position in usec
#define DBdelay 2000          //Min time needed btw any 2 button presses, in msec
#define fastSPD 100           //speed setting; 1 = slowest, 255 is fastest (???)
#define slowSPD 15            //Speed Servo/Door opens and closes (15 is good average)
#define DIV_1    1.0          //gain correction for A0 channel
#define DIV_2    1.0          //note it's 1.0, not 1, to get full floating point accuracy

#define V_REF    2.54         //use the measured Aref voltage

//declare the variables used

volatile boolean doorOPEN = false;   //desired door state set to closed
byte rxbyte = 0;                     //rxbyte is the received byte from Smartie
byte temp = 0;
volatile unsigned long SWtime = 0;   //holds the time of the last valid switch push
float voltage1 = 0.0;                // calculated voltage for A0
float voltage2 = 0.0;                // calculated voltage for A1
int bctr = 0;

LiquidCrystal lcd(rsPIN, enablePIN, d4PIN, d5PIN, d6PIN, d7PIN);
VarSpeedServo myServo; //create a servo object

void setup() {
  //set the pins to be ins or outs
  pinMode(LEDPIN, OUTPUT);
  digitalWrite(LEDPIN, LOW);            //turn LED off
  pinMode(servoPIN, OUTPUT);
  pinMode(SWitchPIN, INPUT_PULLUP);
  pinMode(redPIN, OUTPUT);
  pinMode(greenPIN, OUTPUT);
  pinMode(bluePIN, OUTPUT);

  attachInterrupt(1, SW_ISR, FALLING);

  Serial.begin(9600);

  lcd.begin(numCols, numRows);
  lcd.clear();

  analogWrite(bluePIN,0);                //Blue brightness 255-0
  analogWrite(redPIN,255);               //Red brightness 255-0
  analogWrite(greenPIN,255);             //Green brightness 255-0

  analogReference(INTERNAL);              //use the internal 2.56v ADC reference

  //CMD the servo to close the door
  myServo.attach(servoPIN);               // Attach the servo
  myServo.slowmove(posCloseCMD, fastSPD); // Tell servo to go to closed position
    
  //put a hello world on the LCD
  lcd.home();
  lcd.print("Line 1");
  lcd.setCursor(10, 1);
  lcd.print("Line 2");
  lcd.setCursor(20, 2);
  lcd.print("Line 3");
  lcd.setCursor(30, 3);
  lcd.print("Line 4");
}


//the following function is the ISR that responds to the push button switch
//it commands the door to open or close at slow speed
void SW_ISR(){
  //debounce the switch by ignoring any interrupt that occurs too soon after the prior one
  unsigned long Time = millis();
  if(Time - SWtime > DBdelay){            //enough time has elapsed, not a switch bounce
    SWtime = Time;                        //save new time of switch push
    doorOPEN = !doorOPEN;                 //reverse desired door state
    if(doorOPEN == true){
      digitalWrite(LEDPIN, HIGH);         //turn LED on
      myServo.slowmove(posOpenCMD, slowSPD);    //tell servo to go to open position
    }
    else {
      digitalWrite(LEDPIN, LOW);          //turn LED off
      myServo.slowmove(posCloseCMD, slowSPD);   //tell servo to go to closed position
    }
  }
}


//this function is used by the smartie code to get data from the PC
byte serial_getch(){
  int incoming; 
  while (Serial.available()==0){
  }
  // read the incoming byte:
  incoming = Serial.read();
  bctr++ ;
  return (byte) (incoming &0xff);
}


//the main loop is now just the hacked version of the Arduino Smartie code
void loop(){
  rxbyte = serial_getch();   //this calls the 'function' serial_getch(), stores result in rxbyte
  if (rxbyte == 254)     //Matrix uses 254 for commands, if rxbyte = 254 the the code below runs
  {
    switch (serial_getch())  //calls serial_getch() to get the next byte from the PC
    {
    case 66: //former backlight on command
      break;
    case 70: //former backlight off command
      break;
    case 71:  //set cursor position
      temp = (serial_getch() - 1);  //get column byte
      switch (serial_getch())  //get row byte
      {
        //line 1 is already set up
      case 2:
        temp += 0x40;
        break;
      case 3:
        temp += 0x14;
        break;
      case 4:
        temp += 0x54;
        break;
      default:
        break;
      }
      lcd.command(0b10000000 + temp);
      lcd.print(bctr);  //display byte count for prior line
      bctr = 0;
      break;
    case 72:  //cursor home (reset display position)
      lcd.command(2);
      lcd.print(bctr);  //display byte count for prior line
      bctr = 0;
      break;
    case 74:  //show underline cursor
      lcd.command(0b00001110);
      break;
    case 75:  //underline cursor off
    case 84:  //block cursor off
      lcd.command(0b00001100);
      break;
    case 76:  //move cursor left
      lcd.command(16);
      break;
    case 77:  //move cursor right
      lcd.command(20);
      break;
    case 78:  //define custom char
      lcd.command(64 + (serial_getch() * 8));  //get+set char address
      for (temp = 7; temp != 0; temp--)
      {
        lcd.print(serial_getch()); //get each pattern byte
      }
      break;
    case 83:  //show blinking block cursor
      lcd.command(0b00001111);
      break;
    case 86:  //GPO OFF
      //implement later
      break;
    case 87:  //GPO ON
      /*temp = serial_getch();
       if (temp == 1)
       {
       GPO1 = GPO_ON;
       }*/
      break;
    case 88:  //clear display, cursor home
      lcd.command(1);
      break;
    case 152: //set and remember (doesn't save value, though)
    case 153: //set backlight brightness
      //not implemented
      break;

      //these commands ignored (no parameters)
    case 35: //read serial number
    case 36: //read version number
    case 55: //read module type
    case 59: //exit flow-control mode
    case 65: //auto transmit keypresses
    case 96: //auto-repeat mode off (keypad)
    case 67: //auto line-wrap on
    case 68: //auto line-wrap off
    case 81: //auto scroll on
    case 82: //auto scroll off
    case 104: //init horiz bar graph
    case 109: //init med size digits
    case 115: //init narrow vert bar graph
    case 118: //init wide vert bar graph
      break;
    default:
      //all other commands ignored and parameter byte discarded
      temp = serial_getch();  //dump the command code
      break;
    }
    return;
  } //END OF COMMAND HANDLER

  //change accented char to plain, detect and change descenders
  //NB descenders only work on 5x10 displays. This lookup table works
  //  with my DEM-20845 (Display Elektronik GmbH) LCD using KS0066 chip.
  switch (rxbyte)
  {
    //chars that have direct equivalent in LCD charmap
    /* case 0x67: //g
     rxbyte = 0xE7;
     break;
     case 0x6A: //j
     rxbyte = 0xEA;
     break;
     case 0x70: //p
     rxbyte = 0xF0;
     break;
     case 0x71: //q
     rxbyte = 0xF1;
     break;
     case 0x79: //y
     rxbyte = 0xF9;
     break;
     */  
  case 0x5B: //Formerly [, now does A0 ADC
    voltage1 = DIV_1 * float(analogRead(A0)) * V_REF/1023.0;            
    lcd.print(voltage1, 3);
    rxbyte = 0x76;           //will cause v to be displayed
    break;
  case 0x5D: //Formerly ], now does A1 ADC
    voltage2 = DIV_2 * float(analogRead(A1)) * V_REF/1023.0;
    lcd.print(voltage2, 3);
    rxbyte = 0x76;           //will cause v to be displayed
    break;
  case 0x7B: //Formerly left brace, now does A0 ADC
    voltage1 = DIV_1 * float(analogRead(A0)) * V_REF/1023.0;            
    lcd.print(voltage1, 3);
    rxbyte = 0x76;           //will cause v to be displayed
    break;
  case 0x7D: //Formerly right brace, now does A1 ADC
    voltage2 = DIV_2 * float(analogRead(A1)) * V_REF/1023.0;
    lcd.print(voltage2, 3);
    rxbyte = 0x76;           //will cause v to be displayed
    break;
  case 0xE4: //ASCII "a" umlaut
    rxbyte = 0xE1;
    break;
  case 0xF1: //ASCII "n" tilde
    rxbyte = 0xEE;
    break;
  case 0xF6: //ASCII "o" umlaut
    rxbyte = 0xEF; //was wrong in v0.86
    break;
  case 0xFC: //ASCII "u" umlaut
    rxbyte = 0xF5;
    break;

    //accented -> plain equivalent
    //and misc symbol translation
  case 0xA3: //sterling (pounds)
    rxbyte = 0xED;
    break;
    /*      case 0xB0: //degrees symbol
     rxbyte = 0xDF;
     break;
     */  
  case 0xB5: //mu
    rxbyte = 0xE4;
    break;
  case 0xC0: //"A" variants
  case 0xC1:
  case 0xC2:
  case 0xC3:
  case 0xC4:
  case 0xC5:
    rxbyte = 0x41;
    break;
  case 0xC8: //"E" variants
  case 0xC9:
  case 0xCA:
  case 0xCB:
    rxbyte = 0x45;
    break;
  case 0xCC: //"I" variants
  case 0xCD:
  case 0xCE:
  case 0xCF:
    rxbyte = 0x49;
    break;
  case 0xD1: //"N" tilde -> plain "N"
    rxbyte = 0x43;
    break;
  case 0xD2: //"O" variants
  case 0xD3:
  case 0xD4:
  case 0xD5:
  case 0xD6:
  case 0xD8:
    rxbyte = 0x4F;
    break;
  case 0xD9: //"U" variants
  case 0xDA:
  case 0xDB:
  case 0xDC:
    rxbyte = 0x55;
    break;
  case 0xDD: //"Y" acute -> "Y"
    rxbyte = 0x59;
    break;
    /*      case 0xDF: //beta  //mucks up LCDSmartie's degree symbol??
     rxbyte = 0xE2;
     break;
     */  
  case 0xE0: //"a" variants except umlaut
  case 0xE1:
  case 0xE2:
  case 0xE3:
  case 0xE5:
    rxbyte = 0x61;
    break;
  case 0xE7: //"c" cedilla -> "c"
    rxbyte = 0x63;
    break;
  case 0xE8: //"e" variants
  case 0xE9:
  case 0xEA:
  case 0xEB:
    rxbyte = 0x65;
    break;
  case 0xEC: //"i" variants
  case 0xED:
  case 0xEE:
  case 0xEF:
    rxbyte = 0x69;
    break;
  case 0xF2: //"o" variants except umlaut
  case 0xF3:
  case 0xF4:
  case 0xF5:
  case 0xF8:
    rxbyte = 0x6F;
    break;
  case 0xF7: //division symbol
    rxbyte = 0xFD;
    break;
  case 0xF9: //"u" variants except umlaut
  case 0xFA:
  case 0xFB:
    rxbyte = 0x75;
    break;
  default:
    break;
  }
  lcd.write(rxbyte);  //otherwise a plain char so we print it to lcd
}

FYI I think your Micro implements a 64 byte incoming buffer on the USB. If the data comes in too fast from the PC, the buffer will be overrun and data to the Arduino will be lost ... like parts of line4 ??? This can't happen if the baud rate is really 9600 but I've learned that isn't true at the Arduino end, despite the code saying

Code: Select all

Serial.begin(9600);        //this has no meaning on Leonardo/Micro/Yun

and so I suspect the setup at the PC end is equally ficticious. Real data rates of 10x to 40x that 9600 have been posted. So depending on how many characters are really sent, I can see the buffer getting overrun.

No. What I got was.. not consistent. I guess:
1st line - it'd be 8a/8A/8a/8A/8a/8A then a 24/24/8a/8A/8a/8A... i dont know if it's a cycle, I think a 7a (or 7A?) and 10a (10A maybe?) sometimes showed up too. It mostly goes 8a/8A for a couple times then 24. Usually the other random character would precede this 24.
2nd line - 24B/24b, but the 24 flashes super fast so it basically looks like it's just xxB/xxb. Like right when screen changes, the 24 flashes for a split second, just barely.
3rd line - 24C/24c, normal operation I presume.
4th line - 24D/24d, but sometimes the 24 wouldn't be there, and eventually a 24 got all the way at the end (spaces 15-16, so 24xxx|End of screen).