I2C LCD display getting corrupted [SOLVED]

From : http://en.m.wikipedia.org/wiki/I²C

High is defined at (at least 0.7*VDD) (only described in the German version of wiki)

Data Transfer is initiated with a START bit (S) signaled by SDA being pulled low while SCL stays high.
SDA sets the 1st data bit level while keeping SCL low (during blue bar time.)
The data is sampled (received) when SCL rises (green) for the first bit (B1).
This process repeats, SDA transitioning while SCL is low, and the data being read while SCL is high (B2, Bn).
A STOP bit (P) is signaled when SDA is pulled high while SCL is high.
In order to avoid false marker detection, SDA is changed on the SCL falling edge and is sampled and captured on the rising edge of SCL.

yes it seems so…

the library, if anyone can see an issue. I’m out of my wheelhouse here.

it may be a problem with the Spark…

(@harrisonhjones … are there any other reported compatibility issues with the I2C bus?)

@clyde, did you get corrupted display with your Sainsmart LCD display?

// LiquidCrystal_I2C V2.0

// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set:
//    DL = 1; 8-bit interface data
//    N = 0; 1-line display
//    F = 0; 5x8 dot character font
// 3. Display on/off control:
//    D = 0; Display off
//    C = 0; Cursor off
//    B = 0; Blinking off
// 4. Entry mode set:
//    I/D = 1; Increment by 1
//    S = 0; No shift
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).

#include "application.h"
#include "LiquidCrystal_I2C.h"


LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows)
{
  _Addr = lcd_Addr;
  _cols = lcd_cols;
  _rows = lcd_rows;
  _backlightval = LCD_NOBACKLIGHT;
}

void LiquidCrystal_I2C::init(){
        init_priv();
}

void LiquidCrystal_I2C::init_priv()
{
        Wire.begin();
        _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
        begin(_cols, _rows);  
}

void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
        if (lines > 1) {
                _displayfunction |= LCD_2LINE;
        }
        _numlines = lines;

        // for some 1 line displays you can select a 10 pixel high font
        if ((dotsize != 0) && (lines == 1)) {
                _displayfunction |= LCD_5x10DOTS;
        }

        // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
        // according to datasheet, we need at least 40ms after power rises above 2.7V
        // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
        delay(50);

        // Now we pull both RS and R/W low to begin commands
        expanderWrite(_backlightval);   // reset expanderand turn backlight off (Bit 8 =1)
        delay(1000);

        //put the LCD into 4 bit mode
        // this is according to the hitachi HD44780 datasheet
        // figure 24, pg 46

          // we start in 8bit mode, try to set 4 bit mode
   write4bits(0x03 << 4);
   delayMicroseconds(4500); // wait min 4.1ms

   // second try
   write4bits(0x03 << 4);
   delayMicroseconds(4500); // wait min 4.1ms

   // third go!
   write4bits(0x03 << 4);
   delayMicroseconds(150);

   // finally, set to 4-bit interface
   write4bits(0x02 << 4);



        // set # lines, font size, etc.
        command(LCD_FUNCTIONSET | _displayfunction);  

        // turn the display on with no cursor or blinking default
        _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
        display();

        // clear it off
        clear();

        // Initialize to default text direction (for roman languages)
        _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;

        // set the entry mode
        command(LCD_ENTRYMODESET | _displaymode);

        home();

}



/********** high level commands, for the user! */
void LiquidCrystal_I2C::clear(){
        command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
        delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal_I2C::home(){
        command(LCD_RETURNHOME);  // set cursor position to zero
        delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
        int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
        if ( row > _numlines ) {
                row = _numlines-1;    // we count rows starting w/0
        }
        command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
        _displaycontrol &= ~LCD_DISPLAYON;
        command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
        _displaycontrol |= LCD_DISPLAYON;
        command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
        _displaycontrol &= ~LCD_CURSORON;
        command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
        _displaycontrol |= LCD_CURSORON;
        command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
        _displaycontrol &= ~LCD_BLINKON;
        command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
        _displaycontrol |= LCD_BLINKON;
        command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
        command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
        command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
        _displaymode |= LCD_ENTRYLEFT;
        command(LCD_ENTRYMODESET | _displaymode);
}

// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
        _displaymode &= ~LCD_ENTRYLEFT;
        command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
        _displaymode |= LCD_ENTRYSHIFTINCREMENT;
        command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
        _displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
        command(LCD_ENTRYMODESET | _displaymode);
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
        location &= 0x7; // we only have 8 locations 0-7
        command(LCD_SETCGRAMADDR | (location << 3));
        for (int i=0; i<8; i++) {
                write(charmap[i]);
        }
}

// Turn the (optional) backlight off/on
void LiquidCrystal_I2C::noBacklight(void) {
        _backlightval=LCD_NOBACKLIGHT;
        expanderWrite(0);
}

void LiquidCrystal_I2C::backlight(void) {
        _backlightval=LCD_BACKLIGHT;
        expanderWrite(0);
}



/*********** mid level commands, for sending data/cmds */

inline void LiquidCrystal_I2C::command(uint8_t value) {
        send(value, 0);
}

inline size_t LiquidCrystal_I2C::write(uint8_t value) {
        send(value, 1);
        return 0;
}





/************ low level data pushing commands **********/

// write either command or data
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
        uint8_t highnib=value&0xf0;
        uint8_t lownib=(value<<4)&0xf0;
       write4bits((highnib)|mode);
        write4bits((lownib)|mode);
}

void LiquidCrystal_I2C::write4bits(uint8_t value) {
        expanderWrite(value);
        pulseEnable(value);
}

void LiquidCrystal_I2C::expanderWrite(uint8_t _data){                                        
        Wire.beginTransmission(_Addr);
        Wire.write((int)(_data) | _backlightval);
        Wire.endTransmission();  
        }

void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
        expanderWrite(_data | (1<<2));  // En high
        delayMicroseconds(1);           // enable pulse must be >450ns

        expanderWrite(_data & ~(1<<2)); // En low
        delayMicroseconds(50);          // commands need > 37us to settle
}


// Alias functions

void LiquidCrystal_I2C::cursor_on(){
        cursor();
}

void LiquidCrystal_I2C::cursor_off(){
        noCursor();
}

void LiquidCrystal_I2C::blink_on(){
        blink();
}

void LiquidCrystal_I2C::blink_off(){
        noBlink();
}

void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
                createChar(char_num, rows);
}

void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
        if(new_val){
                backlight();            // turn backlight on
        }else{
                noBacklight();          // turn backlight off
        }
}

void LiquidCrystal_I2C::printstr(const char c[]){
        //This function is not identical to the function used for "real" I2C displays
        //it's here so the user sketch doesn't have to be changed
        print(c);
}


// unsupported API functions
void LiquidCrystal_I2C::off(){}
void LiquidCrystal_I2C::on(){}
void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {}
uint8_t LiquidCrystal_I2C::status(){return 0;}
uint8_t LiquidCrystal_I2C::keypad (){return 0;}
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype){return 0;}
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end){}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end){}
void LiquidCrystal_I2C::setContrast(uint8_t new_val){}

and the .h file

#define ARDUINO_H

#ifndef LiquidCrystal_I2C_h
#define LiquidCrystal_I2C_h

#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80

#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00

// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00

// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00

// flags for backlight control
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00

//#define En B00000100  // Enable bit
//#define Rw B00000010  // Read/Write bit
//#define Rs B00000001  // Register select bit

class LiquidCrystal_I2C : public Print {
public:
  LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows);
  void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS );
  void clear();
  void home();
  void noDisplay();
  void display();
  void noBlink();
  void blink();
  void noCursor();
  void cursor();
  void scrollDisplayLeft();
  void scrollDisplayRight();
  void printLeft();
  void printRight();
  void leftToRight();
  void rightToLeft();
  void shiftIncrement();
  void shiftDecrement();
  void noBacklight();
  void backlight();
  void autoscroll();
  void noAutoscroll();
  void createChar(uint8_t, uint8_t[]);
  void setCursor(uint8_t, uint8_t);
  virtual size_t write(uint8_t); //changed to size_t
  void command(uint8_t);
  void init();

////compatibility API function aliases
void blink_on();            // alias for blink()
void blink_off();                 // alias for noBlink()
void cursor_on();                 // alias for cursor()
void cursor_off();                // alias for noCursor()
void setBacklight(uint8_t new_val);       // alias for backlight() and nobacklight()
void load_custom_character(uint8_t char_num, uint8_t *rows);  // alias for createChar()
void printstr(const char[]);

////Unsupported API functions (not implemented in this library)
uint8_t status();
void setContrast(uint8_t new_val);
uint8_t keypad();
void setDelay(int,int);
void on();
void off();
uint8_t init_bargraph(uint8_t graphtype);
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);


private:
  void init_priv();
  void send(uint8_t, uint8_t);
  void write4bits(uint8_t);
  void expanderWrite(uint8_t);
  void pulseEnable(uint8_t);
  uint8_t _Addr;
  uint8_t _displayfunction;
  uint8_t _displaycontrol;
  uint8_t _displaymode;
  uint8_t _numlines;
  uint8_t _cols;
  uint8_t _rows;
  uint8_t _backlightval;
};

#endif

Can you also please check if the problem also persists with Wifi.off(). (Chip should be much cooler with wifi.off()).
We have seen such spikes during wifi communications on the pins near the antenna.

Will do, good idea. I did try to affect close GPIO’s but actually I have no idea if their pin numbers are even closely related to their actual topography on the IC!

Question… would interference affect the timing of the signal, or just affect its ‘quality’? That short signal is typical of what I see here.

It dawns on me also to try combining chars I print in lcdPaintBackground( ), or adding a little delay( ) between the prints…Maybe I can improve the transmissions by spacing them out a bit?

Don’t use pin numbers, but use the names printed on the PCB.

As a side info D0..D7 numbers 0..7, A0..A7 numbers 10..17.


Since the scope revieled spikes on the data line with each falling and some of the rising edges of the clock line, you might also like to try use shorter wires (for signals and power - also breadboard distances) as @softmeter suggested - some of your jumper wires seem extremely long.
If at all possible try moving the whole thing off the breadboard, since this might also add extra capacitance and/or inductance to your setup.

1 Like

Hi *,

I do remember that I have the same problem with my i2c lcd display, but it´s been a while and I switched to a Digole OLED display right after writing the tutorial. I thought that I messed up things in my code and thus I getting these errors, so @BulldogLowell you proof me wrong, it´s seems that it is not my fault.

As far as I remember, with my 16x2, I have the problem after several hours, not after minutes. Can´t test it right now because my Core is in use and I´m waiting for my Photon :frowning:

I2C is very robust against different frequencys and/or timings, if high is appropriate and the signal has a defined minimum timing.

I2C is not robust against “Ghost signals” or Noise because almost every HIGH has a meaningful state in the.

If your highsignal is only 300mv, the so called Signal to Noise Ratio is very low.

1 Like

So did the Arduino…

Look at the timing on the Arduino trace above, seems cleaner to me.

I’ll try all of your ideas. Its fun learning about this.

Also please keep in mind: I2C is a very cheap Protocoll (no buffers etc.) which, in some cases without any complicated processor at al, can be implemented at extrem low cost.
Especially in low cost display implementations there are no checksum or other tests to check for correct communication. -> so every Noisy-bit will result in a Wrong character.
More complex interfaces uses Retry Algorithms to solve these Noise- problems, but these display chips are too cheap.

But so far, to me (before this Spark Core issue) very dependable!!! This is the first time I have ever had a problem and I have used an assortment of MCU’s

That being said, I’m interested to see if it can be made to work, but I’m ordering some of the Serial displays just in case.

Your suggestion of turning WiFi.off( ) has not glitched out the display yet (nearly two hours). It is not a solution, but it could narrow the isssues down quite a bit (a) the library insofar as it affects communication and (b) the Spark itself.

void printFunction( )
  {
    WiFi.off( );
    delay(10);
    doLCDprints( );
    WiFi.on( );
    delay(10);
  {

My jetlag from returning from China is paying off this morning, but I must get to work. More on this later.

Hi @BulldogLowell

While I think i2c works for most people (me included), there are some devices that can difficult to interface to.

If you turn the WiFi radio off and things improve, then you likely have a power supply or noise problem of some sort. Maybe the display is just sensitive to conducted (through the wiring) or radiated (through the air) radio signals.

With a 5V display and a 5V Arduino, there is a lot of margin for noise or power problems, but with a 5V display and a 3.3V Spark core, there is less margin.

Things to try:

  • Try a different power supply. Those breadboard supplies are not so good in my experience.

  • Add some 0.01uF and 100uF capacitors across the power supply leads to the display as close to the display as possible. Make every wire as short as possible. I know you said you tried this but put them close to the display.

  • Make sure the display is physically far from the WiFi antenna at the end of the Spark core.

  • Add 100ohm series resistors from D0 and D1 to the i2c pins on the display. Place these close to the Spark. These will limit the rise and fall time of i2c signals and can improve signal to noise problems.

1 Like

Thanks @bko, some more things to try. I’m not spiking the ball on the WiFi ‘solution’ I sort of need WiFi, hence buying the Spark Cores!

I have tried most of what you suggested, including:

Caps on Power Supply
Other power supplies
Moving display around… though I kind of need to fit this all into a box eventually!
with and without the DHT sensor

I am still going at the rest of the recommendations from the forum tonight.

@BulldogLowell, this issue is chewing at me! I believe I have a 16x2 display with the same backpack so I will be doing some tests. @bko’s recommendations are spot on. I also want to look at the I2C code for any interrupt issues. So many folks have used I2C without problems, it makes finding the issue that much more difficult. Stay tuned. :smile:

not to make you feel worse, but I own three Spark Cores and can get none of them to consistently update either I2C display without eventual errors.

one is early, with a round (really groovy) shaped RGB led. Two are newer and each sporting a square led.

‘square’… get it?

Please keep in mind: I2C is primarily an Chip to Chip interface. It was not defined to “put it on the wire”. (No checksums, no retry).
If you want components connected by wires, I2C is not the correct Protocoll.

Not simply to contradict you, but the tens (perhaps hundreds) of thousands of Arduino (et al) implementations of I2C displays tends to a “preponderance of the evidence to the contrary”

at the end of the day, if it doesn’t work on a Spark, well it just doesn’t work on a Spark and that won’t make me :’-(

I’m just curious to find out why. Maybe its a simple thing to fix and it opens up a universe of low-cost displays being used by hackers everywhere.

Yes. I’m sure, that’s a small problem within the wiring or power (High Level/ LowLevel / Noise Ratio).

The Noise from the wireless modul is definitely a source for problems which simply doesn’t exist on the Arduino ( spark and arduino are not comparable from my point of view!)

In our own project we have used AnalogInput form the spark and the signal is (during wifi und especially during login) unusable.

So we decided to switch off wifi during this operations (signal frequency detection). But this is much more problematic to noise compared to I2C.

I fly multirotors and some controllers use i2c for compass/gps (for example http://copter.ardupilot.com/wiki/common-installing-3dr-ublox-gps-compass-module/ ) . 15cm wires, noise from motors/ESC’s, 2,4Ghz transmitter noise + 5,8Ghz (or some other freq) FPV signal from 600mW transmitter and it works like a charm.

Folks, the argument on the merits of I2C are somewhat moot as the OP is looking for help with his display corruption. As such, it would seem more constructive to analyze what is known to try and identify where the problem originates. I am Looking at the odd pulse on the data and its proximity to the START pulse. It is too short to be properly clocked as data but is aligned to the last clock pulse prior to the START. So is it a product of a STOP or data that was cut-off somehow? One odd thing in the first traces shown (Spark vs Arduino) is the frequency reading of the scope. For the Arduino, it shows 555.772HZ but on the Core, it shows 17.7358KHz!

Just an update, turning off the WiFi radio, same old problem.

I am sure that is just a result of the wave sampling at the moment, I was not measuring that. I’ll try to get more/better numbers tonight.