Thanks so much, I really appreciate the help. I ordered a Sainsmart LCD over the weekend and it should arrive today, so perhaps tonight we can isolate this to the PCF85741 (if it works with their on-board chip).
I'll still have a slog at getting the PCF8574T working though... should be fun.
@BulldogLowell, I also recommend using Digole displays and backpacks. They have PIC processors on-board with simple and fast commands. Iāve used a cheap 128x64 LCD and their backpack, giving me a āsmartā display with built-in fonts and graphics. I prefer it to a fixed text LCD because I can place text and graphics where I want. For the Spark, I use Serial1 at 115Kbaud and on my power meter, I can draw in different fonts and with graphics without any problems. The backpack supports I2C and SPI also but with a single Tx line, I prefer using serial. 
BTW, the chip is a PCF8574T (the last char is a T, not a 1)
ha!
I edited so folks may find it! Thanks I had to use my magnifying glass and angle just right to see it!
I'll play with those displays when I can, I actually came across your posts on these in searches to find a solution here...
I like this 4X20 mainy because you can see it across a room, and the blue/white doesn't look too old fashioned compared to the other run-of-the-mill LCD displays.
These would be good replacements displays that @peekay123 lready has working libraries for.
http://digole.com/index.php?productID=844
So the Sainsmart had the same problem.
IC2 traces of the Spark Core, yellow trace is SDA, Blue is SCL:
This is an Arduino print I2C, prints perfectly for months.
sitting waiting for the corrupt signal is impossibleā¦ two kids.
@BulldogLowell, do the two samples have the exact same scope settings? Do you have pull-ups or are they on the backpack? Can you show the p-p voltage for the SDA and SCL on the Spark trace?
In The First picture the Signal is corrupt (Look at the yellow line. You have two problematik States!).
I2C is primary a clock Signal (Blue) which triggers a Bit Information on the edges of the clock Signal. If the clock has a long High, this is start of a new sequence.
So your yellow signal is corrupt (afaik)
We have seen this problems in our own installation if the WLAN is sending (especially during login).
Try to short your wires or try different pins
I'm measuring on the Spark Pins, pulled up with 4.7kOhm resistors.
Data Line (Yellow): peak to peak (flat part of the wave) is 4.72V
Clock (Blue): Nominally is 5.28
sorry, this triggered trace shows the first and start of a 2nd I2C transmission, It looks more like what you may expect:
Yep, this looks better, but the 5th yellow Signal is too Short! If the Signal is too Short the other Party has a very small timeframe to get it.
By the way : 4.2mV peak too peak is very low !
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.
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 
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.
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.
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.