STM32 Blue Pill board Trying to use i2C2 with the i2C LCD library

Hi guys, Beginner here.
I can display messages on a 16 x 2 i2C display using the default i2C ports.
But I would also like to do the same using the i2C2 ports, PB10 SCL and PB11 SDA.
There is nearly no information online about this, and the info I have found just doesn’t work. :frowning:

I am using the “genericSTM32F103C” board to compile the code. And this is my test code using the default i2C ports, PB6 and PB7.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);


void setup() {

    lcd.init();


  lcd.backlight();
  lcd.print("Hello, world!");
}

void loop() {
  // put your main code here, to run repeatedly:

}

I found online that i should use something like the following to use the i2C2 ports, but it doesn’t work.

TwoWire WIRE2 (2, I2C_FAST_MODE);
#define Wire WIRE2

Perhaps I am not putting this in the right place in the code, or perhaps it is just useless?

Thanks for your help

João

If you look at the examples that come with the Wire library for the STM32, you will see the HardWire example where you can specify either i2c 1 or 2 as part of the setup.

Or...
If you stick with the more traditional Wire library, it is all done in software but you could

TwoWire Wire(SCL, SDA, SOFT_STANDARD);
//TwoWire Wire(PB6, PB7, SOFT_STANDARD);
TwoWire Wire2(PB10, PB11, SOFT_STANDARD);

putting in the '#define Wire Wire2' will not help since the lcd library is compiled outside your sketch and that define will not influence what it thinks is the 'Wire' interface (i2c #1)

You could probably make a copy of the lcd library and then search and replace Wire with Wire2 to make a version that uses the 2nd i2c and then rename it

Thank very much you for your answer. Will have a look at all that and let you know how it goes.

João

Ok, got it working on PB10 and PB11. Thank you very much for your help.

Here is the modified “LiquidCrystal_I2C.cpp” file.
I then placed the modified library inside the sktetch folder and used “#include LiquidCrystal_I2C.h” in the main code, instead of #include <LiquidCrystal_I2C.h>.

Perhaps this saves others hours of googling stress :slight_smile:

There is only one problem I can see. The sketch doesn’t work if one of the i2C connections is broken. Not the test code above, the real code with footswitches relays etc. The real project is a Guitar effects foot controller, and by adding a i2C LCD we gain a couple pins. But as i said, the whole thuing stops working if the i2c connection is broken. Is there a way of fixing this? Thanks

By the way the project is open for anyone to build and it is at:

You need to ask to join the group.

EDIT: Message too long it seems. so the code is on the next post. Sorry

#include "LiquidCrystal_I2C.h"
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100

#include "Arduino.h"
//use IIC2
TwoWire Wire2 (2,I2C_FAST_MODE);
#define Wire Wire2

#define printIIC(args) Wire2.write(args)
inline size_t LiquidCrystal_I2C::write(uint8_t value) {
 send(value, Rs);
 return 1;
}

#else
#include "WProgram.h"

#define printIIC(args) Wire2.send(args)
inline void LiquidCrystal_I2C::write(uint8_t value) {
 send(value, Rs);
}

#endif
#include "Wire.h"



// 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).

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()
{
 Wire2.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);
}


/************ 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){                                        
 Wire2.beginTransmission(_Addr);
 printIIC((int)(_data) | _backlightval);
 Wire2.endTransmission();   
}

void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
 expanderWrite(_data | En); // En high
 delayMicroseconds(1); // enable pulse must be >450ns
 
 expanderWrite(_data & ~En); // 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){}

Are you sure you are using your modified version? It typically does not work to place other files (.h and .cpp) files in your sketch directory. I think the IDE will look in the libraries directory to find #include files

You might want to check. Typically, the IDE will tell you which libraries are being used from which directory

Yes, I am sure I am using the libraries I placed inside the sketch folder, otherwise it wouldn’t work. if it was looking for the default IDE libraries it wouldn’t work as those aren’t modified.
As you for sure know, if we include a library like this:

#include <LiquidCrystal_I2C.h>

The IDE will use the default libraries installed in the IDE itself. But like this:

#include "LiquidCrystal_I2C.h"

The IDE will use the libraries placed inside the sketch folder. And in my case, I modified these, and it is working as i wanted, thanks to your advice, thank you.

I also solved the other problem I’ve mentioned above where the board would stop working if one or both of the i2c wires were disconnected. I solved this problem by placing pullup resistors (100K) on the i2c pins at the STM32 board’s side. The i2c display module already has them, but disconnecting a wire would leave the processor pins without any, and it wouldn’t start.

Thank you again for your help, and i hope this can help someone else as there isn’t much information out there about using the second i2c ports…

João

100K pullup resistors is pretty high, Typical values are 10k or even 4.7k

As for the behavior of the IDE with respect to including libraries, it has evolved over the years so I am still leary, but you do make a good point - it wouldn't work if it included the wrong version

blh64:
100K pullup resistors is pretty high, Typical values are 10k or even 4.7k

You are right, 100K is very high. But the i2c LCD module already has 4K7 resistors on the SCL and SDA lines. If i parallel other 10K or less resistor, the total resistance will decrease putting more load on the processor pins by increasing the current when the pin goes low. Therefore I decided to use a higher value, higher enough not to decrease the total resistance, and lower enough that it keeps the pins high if the i2c wires for some reason disconnect :slight_smile:

João