cannot make Grove I2C LCD with Pico to work

[bartvdg]

I have spent quit some time getting a Grove 16x2 I2C LCD to work with Pico.
I tried multiple source found on the internet but I only get a first row with white blocks and second row blanks...

example 1.txt
example 1 scans for the I2C address and uses this to print on the thonny shell, this works, but the LCD won't show the text from lcd.putstr command?
example 1.txt

[scruss]

What display are you using? Does it have a manual contrast adjustment trimpot on the back? Sometimes they're shipped so that all you see is blocks until you set the contrast.

What I2C address is printed? Not all 16x2 LCDs use the same hardware.

[bartvdg]

I'm using the Grove-16x2 LCD (White on Blue V2.0) <https://www.seeedstudio.com/Grove-16x2-LCD-White-on-Blue.html> I added the datasheet as attachment. There is no trimpot available. It has address 0x3E (62 DEC) [https://media-cdn.seeedstudio.com/media/catalog/product/cache/7f7f32ef807b8c2c2215b49801c56084/h/t/httpsstatics3.seeedstudio.comseeedfile2018-10bazaar969249_front.jpg]<https://www.seeedstudio.com/Grove-16x2-LCD-White-on-Blue.html> Grove - 16x2 LCD (White on Blue)<https://www.seeedstudio.com/Grove-16x2-LCD-White-on-Blue.html> Grove - 16 x 2 LCD is a perfect I2C LCD display for Arduino and Raspberry Pi with high contrast and easy deployment. www.seeedstudio.com

…

________________________________ Van: Stewart Russell ***@***.***> Verzonden: donderdag 13 juli 2023 18:53 Aan: micropython/micropython ***@***.***> CC: bartvdg ***@***.***>; Author ***@***.***> Onderwerp: Re: [micropython/micropython] cannot make Grove I2C LCD with Pico to work (Discussion #12003) What display are you using? Does it have a manual contrast adjustment trimpot on the back? Sometimes they're shipped so that all you see is blocks until you set the contrast. What I2C address is printed? Not all 16x2 LCDs use the same hardware. — Reply to this email directly, view it on GitHub<#12003 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AKSREBHANQRXI52GK43GGKDXQARXTANCNFSM6AAAAAA2JCWWVU>. You are receiving this because you authored the thread.Message ID: ***@***.***>

[mcauser]

Pasting the contents of example1.txt above

from machine import I2C, Pin
from pico_i2c_lcd import I2cLcd
i2c = I2C(0, sda=Pin(8), scl=Pin(9), freq=400000)
 
I2C_ADDR = i2c.scan()[0]
lcd = I2cLcd(i2c, I2C_ADDR, 2, 16)
while True:
  print(I2C_ADDR, "| Hex:",hex(I2C_ADDR))
  print()
  lcd.move_to(0,0)
  lcd.putstr("I2CAddress:"+hex(I2C_ADDR)+"\n")
  lcd.move_to(0,1)
  lcd.putstr("CircuitSchools.")

Is this the repo/file you're referring to?
https://github.com/T-622/RPI-PICO-I2C-LCD/blob/main/pico_i2c_lcd.py

[mcauser]

HD44780 compatible displays have an 80 character memory.

If you have a 20x4 display, it displays all characters on screen:

  1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
1 # # # # # # # # # # # # # # # # # # # #
2 # # # # # # # # # # # # # # # # # # # #
3 # # # # # # # # # # # # # # # # # # # #
4 # # # # # # # # # # # # # # # # # # # #

If you have a 16x2 display, you're only seeing a subset of characters (32 of 80).

  1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
1 # # # # # # # # # # # # # # # # . . . .
2 # # # # # # # # # # # # # # # # . . . .
3 . . . . . . . . . . . . . . . . . . . .
4 . . . . . . . . . . . . . . . . . . . .

You could try moving to top left with lcd.move_to(0,0) then lcd.putchar('a') and repeat for other coordinates until you find where your screen's visible portion of the 80 character memory.
putchar() calls move_to() after it's finished putting to try to start you on the second visible line once you exceeded the first, and wrap back to the top again. If there's something wrong with these calculations, it'll not put the cursor at the right spot.

You could try initing with lcd = I2cLcd(i2c, I2C_ADDR, 4, 20) which should disable the put-wrapping-magic.

• Then move to 0,0, put an 'a' 20 times. 4x 'a's should be offscreen.
• Then put 'b' 20x times and it should fill the 2nd line (4x offscreen).
• Then put 'c' 20x times and it should fill the 3rd line (all offscreen).
• Then put 'd' 20x times and it should fill the 4th line (all offscreen).
• Then finally put an 'x' and it should be back in the first 0,0 character.

Ideally, you should see this:

  1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
1 x a a a a a a a a a a a a a a a . . . .
2 b b b b b b b b b b b b b b b b . . . .
3 . . . . . . . . . . . . . . . . . . . .
4 . . . . . . . . . . . . . . . . . . . .

If you 2nd display line shows a line of 'c's or 'd's, the display maps to a different location in the 80 char memory.

[mcauser]

Have you tried this one? https://github.com/dhylands/python_lcd

[bartvdg]

Many thanks Mike to give me so much detailed feedback. I'm rather new in this and boxed together below code based on your inputs, result is still same. first row only white boxes, second row blank. My big toe is saying it is contrast setting, but no clue on how to adjust this? code used to test: from machine import I2C, Pin from pico_i2c_lcd import I2cLcd from time import sleep i2c = I2C(0, sda=Pin(8), scl=Pin(9), freq=400000) I2C_ADDR = i2c.scan()[0] lcd = I2cLcd(i2c, I2C_ADDR, 4, 20) count = 0 # print a 20 times on LCD row 1 while count < 20: count += 1 lcd.move_to(0,0) lcd.putstr("a") print("a" + str(count)) # print on shell sleep(0.25) count = 0 # print b 20 times on LCD row 2 while count < 20: count += 1 lcd.move_to(0,1) lcd.putstr("b") print("b" + str(count)) # print on shell sleep(0.25) count = 0 # print c 20 times on LCD row 3 while count < 20: count += 1 lcd.move_to(0,0) lcd.putstr("c") print("c" + str(count)) # print on shell sleep(0.25) count = 0 # print d 20 times on LCD row 4 while count < 20: count += 1 lcd.move_to(0,1) lcd.putstr("d") print("d" + str(count)) # print on shell sleep(0.25) count = 0 lcd.putstr("x") print("x" + str(count)) # print on shell

…

________________________________ Van: Mike Causer ***@***.***> Verzonden: vrijdag 14 juli 2023 02:52 Aan: micropython/micropython ***@***.***> CC: bartvdg ***@***.***>; Author ***@***.***> Onderwerp: Re: [micropython/micropython] cannot make Grove I2C LCD with Pico to work (Discussion #12003) HD44780 compatible displays have an 80 character memory. If you have a 20x4 display, it displays all characters on screen: 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 # # # # # # # # # # # # # # # # # # # # 2 # # # # # # # # # # # # # # # # # # # # 3 # # # # # # # # # # # # # # # # # # # # 4 # # # # # # # # # # # # # # # # # # # # If you have a 16x2 display, you're only seeing a subset of characters (32 of 80). 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 # # # # # # # # # # # # # # # # . . . . 2 # # # # # # # # # # # # # # # # . . . . 3 . . . . . . . . . . . . . . . . . . . . 4 . . . . . . . . . . . . . . . . . . . . You could try moving to top left with lcd.move_to(0,0) then lcd.putchar('a') and repeat for other coordinates until you find where your screen's visible portion of the 80 character memory. putchar() calls move_to() after it's finished putting to try to start you on the second visible line once you exceeded the first, and wrap back to the top again. If there's something wrong with these calculations, it'll not put the cursor at the right spot. You could try initing with lcd = I2cLcd(i2c, I2C_ADDR, 4, 20) which should disable the put-wrapping-magic. * Then move to 0,0, put an 'a' 20 times. 4x 'a's should be offscreen. * Then put 'b' 20x times and it should fill the 2nd line (4x offscreen). * Then put 'c' 20x times and it should fill the 3rd line (all offscreen). * Then put 'd' 20x times and it should fill the 4th line (all offscreen). * Then finally put an 'x' and it should be back in the first 0,0 character. Ideally, you should see this: 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 x a a a a a a a a a a a a a a a . . . . 2 b b b b b b b b b b b b b b b b . . . . 3 . . . . . . . . . . . . . . . . . . . . 4 . . . . . . . . . . . . . . . . . . . . If you 2nd display line shows a line of 'c's or 'd's, the display maps to a different location in the 80 char memory. — Reply to this email directly, view it on GitHub<#12003 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AKSREBGF7WBU6T7AY3CA2ULXQCJ4TANCNFSM6AAAAAA2JCWWVU>. You are receiving this because you authored the thread.Message ID: ***@***.***>

[mcauser]

I have one of the Grove RGB 1602 LCDs. It presents 2x I2C addresses. One for driving the (HD44780 compatible) display, and one for driving the RGB backlight.
I don't have one of your display modules, but I wonder if Seeed used the same chips, but with a single colour backlight.
Can you do an i2c.scan() and let us know what addresses appear.

Also, according to the wiki page, early versions were missing I2C pull-ups. What version is your display?

Without a trimpot for controlling contrast, they must be "hard coding" it with resistors on the back of the display.

Bonus:

count = 0
while count < 20:
    count += 1
    print(i)

Can be rewritten as simply:

for i in range(20):
    print(i)

range(5) gives you steps 0,1,2,3,4.

[bartvdg]

Yes I have tried it but no luck...

…

________________________________ Van: Mike Causer ***@***.***> Verzonden: vrijdag 14 juli 2023 02:54 Aan: micropython/micropython ***@***.***> CC: bartvdg ***@***.***>; Author ***@***.***> Onderwerp: Re: [micropython/micropython] cannot make Grove I2C LCD with Pico to work (Discussion #12003) Have you tried this one? https://github.com/dhylands/python_lcd — Reply to this email directly, view it on GitHub<#12003 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AKSREBBEBY23HOUV2C3CD73XQCKFDANCNFSM6AAAAAA2JCWWVU>. You are receiving this because you authored the thread.Message ID: ***@***.***>

[bidrohini]

You can cross-check your setup and coding with this tutorial: https://www.tomshardware.com/how-to/lcd-display-raspberry-pi-pico
It will help you find if you're missing something.

[bartvdg]

I tried this one before. It gave me same result. I start to think if it is not contrast that LCD could be broke altough it is brand new.

[bartvdg]

Decimal address: 62 | Hexa address: 0x3e I have the resistors R9 & R12 mounted on PCB (see pic) the LCD has version V2.0  thanks for the bonus 😉

…

________________________________ Van: Mike Causer ***@***.***> Verzonden: zaterdag 15 juli 2023 05:19 Aan: micropython/micropython ***@***.***> CC: bartvdg ***@***.***>; Author ***@***.***> Onderwerp: Re: [micropython/micropython] cannot make Grove I2C LCD with Pico to work (Discussion #12003) I have one of the Grove RGB 1602 LCDs<https://wiki.seeedstudio.com/Grove-LCD_RGB_Backlight/>. It presents 2x I2C addresses. One for driving the (HD44780 compatible) display, and one for driving the RGB backlight. I don't have one of your display modules, but I wonder if Seeed used the same chips, but with a single colour backlight. Can you do an i2c.scan() and let us know what addresses appear. Also, according to the wiki page<https://wiki.seeedstudio.com/Grove-16x2_LCD_Series/>, early versions were missing I2C pull-ups. What version is your display? Without a trimpot for controlling contrast, they must be "hard coding" it with resistors on the back of the display. Bonus: count = 0 while count < 20: count += 1 print(i) Can be rewritten as simply: for i in range(20): print(i) range(5) gives you steps 0,1,2,3,4. — Reply to this email directly, view it on GitHub<#12003 (reply in thread)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AKSREBFDD2QUBIP5BVY4S7DXQID4VANCNFSM6AAAAAA2JCWWVU>. You are receiving this because you authored the thread.Message ID: ***@***.***>

[rkompass]

You may try my rework of the LCD driver, if you like.
There are quite extensive instructions how to wire and set it up.
The setup should be simpler - just one file to be copied to the device.

[rkompass]

See now that you have different hardware. ..

[robert-hh]

Do you run the display at 3.3V or 5V? The data sheet of the controller allows both voltages, but all of the LCD displays I worked with required 5V supply.

[bartvdg]

I have tried both 3.3V & 5V

[robert-hh]

Often when a LCD is powered, one row is solid black and the other is white. Did you notice a similar behavior? It may be hard to see without a backlight.

[bartvdg]

Yes, top row shows solid blocks, second blanked.

[robert-hh]

So the LCD is powered and connected to the controller. I see that the backlight is on. But for that, the contrast is too weak. Did you drive with 3v3 or 5V for this picture? Nevertheless, we should focus now on the communication.

So you tried that i2c.scan() returns the address 62 in the list of Addresses on the bus. I would prefer using this a hardcoded value instead of relying on i2c.scan() returning this as first value in the list. I have used the drivers from dhylands with these LCD devices and they worked well. They were designed for a HD44780 controller, but according to the data sheet of your device the command set is the same. The machine_i2c_lcd.py should be the right one. It uses the 4bit mode of the interface. But the Seeed example code does the same. Two difference I see between the Seeed example and machine_i2c_lcd.py:

• The Seeed example waits 50ms after power on, the dhylands code waits 20ms. Better wait longer.
• The Seeed example does not perform a devices reset, the dhylands code does it three times.
• The Seeed example sets the function mode three times in a row, the dhylands code only once. This three-time-in-a-row method is recommended, it if is not known in which state the display is. But that's only for reset. After power on the display is definitely in 8bit mode.

Edit: The device reset code of the dhylands code is actually teh code for setting 4 bit mode. So both examples work similar. Anyhow it may be that the DL setting is ignored. The data sheet of the JHD1804 device is not consistent.

[robert-hh]

Looking at the examples, it seems that from the dhylands code the one for grove displays may match better, which uses the device in 8 bit mode,

[bartvdg]

I run attached test I got from Dhylands code after chaning to my address DEC 62.
I get the ouput on the Shell but the LCD doesn't show anything besides the blocks on top row and a blank second row.
machine_i2c_lcd_test.txt

would you be able to give me some example to test? I understand the basic code to show characters but the attached is too complex for me as a beginner.

[robert-hh]

After reading the data sheets, I came to the conclusion that the machine_i2c_lcd.py code will not work. The Grove display requires a completely different way of controlling. Since the data to be transferred are 9 bit items, they are to be split into 2 bytes.

The machine_i2c_lcd.py code and all others using a I2C backpack for the parallel interface split the data into two four bit parts and add the RS bit and other control bits into the remaining bits. The Grove display requires a control byte with the RS bit and 8 bit data/command byte.

So none of the variants offered by dhylands fit. The closest one at least for the low level I/O is pyb_i2c_grove_rgb_lcd.py, but that one uses the PyBoard pyb.i2c module, and not machine.I2C.

[rkompass]

If you have an extra I2C address (0x62, which should show up in a I2C scan)
for the control of the backlight then something like this may help:

# Grove LCD device has two I2C addresses
_GROVE_LCD_RGB  = const(0x62)
_GROVE_LCD_TEXT = const(0x3e)

# set backlight to (r,g,b)  (0..255  each)
#
def set_backl(i2c, r, g, b):
    i2c.writeto(_GROVE_LCD_RGB, b'\x00\x00')
    i2c.writeto(_GROVE_LCD_RGB, b'\x01\x00')
    i2c.writeto(_GROVE_LCD_RGB, b'\x08\xaa')
    i2c.writeto(_GROVE_LCD_RGB, bytes((0x04, r)))
    i2c.writeto(_GROVE_LCD_RGB, bytes((0x03, g)))
    i2c.writeto(_GROVE_LCD_RGB, bytes((0x02, b)))

set_backl(i2c, 128, 128, 128)

[bartvdg]

running above code removes the white blocks on first row but don't see the text appear?

[rkompass]

That might be due to the device reset in __init__ working. But after seeing Roberts arguments and code I'm now convinced that the writing to the LCD is different, as he found out.

Do you manage to combine Roberts last

simplified version of the machine_i2c_lcd.py driver

with the rest of the lcd api by Dave Hylands?

If not I can try to work the different style of writing to the device into a new variant of my _wr() function and present a new version of the above code.

[bartvdg]

If you could help me with this would be nice. I didn't had the chance to test with Roberts code. Like said before I'm rather new and could need all the help. Although this is a great learning process for me. Thanks all!

[rkompass]

I edited the above code to use the 8 bit interface as Robert described it (with the option grove=True). You may try it out again.

[bartvdg]

This is working now as I see the texts 'First Line' on row 1 and 'Second Line' on row2.

I never tought it would be so complex to get this working. I learned a lot from everone in this thread!
Next step is to read my modbus device and get the data on the LCD :-)

[robert-hh]

I never tought it would be so complex to get this working.

I wouldn't say it' complex. It's just an unusual interface for a LCD device, and some lack of documentation.

[amtor82]

I edited the above code to use the 8 bit interface as Robert described it (with the option grove=True). You may try it out again.

After 10-15 hours troubleshooting the same issue as @bartvdg I now also have a working LCD. Thank you @rkompass and @robert-hh for great help!

[robert-hh]

A data sheet describing the interface would be e.g. https://www.orientdisplay.com/wp-content/uploads/2022/08/AIP31068L.pdf. This part is mentioned in the display data sheet mentioned by Seeed.

For sending a command byte, one has to transmit [0x80, command]. For sending a data byte, one has to transmit [0x40, data]. That's done for instance by the Seeed C++ sample code.

[robert-hh]

You could try the following simplified version of the machine_i2c_lcd.py driver with the changed way of writing to the controller.

from lcd_api import LcdApi
from time import sleep_ms

DEFAULT_I2C_ADDR = 0x3e

# Defines shifts or masks for the various LCD line attached to the PCF8574

MASK_RS = 0x01
MASK_RW = 0x02
MASK_E = 0x04
SHIFT_BACKLIGHT = 3
SHIFT_DATA = 4


class I2cLcd(LcdApi):

    def __init__(self, i2c, i2c_addr, num_lines, num_columns):
        self.i2c = i2c
        self.i2c_addr = i2c_addr
        self.i2c.hal_write_command(self.i2c_addr, 0)
        sleep_ms(50)   # Allow LCD time to powerup
        LcdApi.__init__(self, num_lines, num_columns)
        cmd = self.LCD_FUNCTION
        if num_lines > 1:
            cmd |= self.LCD_FUNCTION_2LINES
        self.hal_write_command(cmd)

    def hal_write_command(self, cmd):
        """Writes a command to the LCD."""
        self.i2c.writeto(self.i2c_addr, bytearray([0x80, byte]))
        if cmd <= 3:
            # The home and clear commands require a worst case delay of 4.1 msec
            sleep_ms(5)

    def hal_write_data(self, data):
        """Write data to the LCD."""
        self.i2c.writeto(self.i2c_addr, bytearray([0x40, data]))

[robert-hh]

Some progress. At least the commands seem to be accepted.

[robert-hh]

Which test code do you run? Any error messages?

[robert-hh]

It is hard to help without the same LCD at hand. You should be able to run dhylands machine_i2c_lcd_test.py code, but without the calls to backlight_on() and backlight_off(). You need the lcd_api.py file on the board as well.

[bartvdg]

I will give it a go and for sure let you know. Thanks for the help so far. 👍🏼🙏🏼

[bartvdg]

This code from rKompass did the job as it showing the lcd.write commands on the LCD.

[bartvdg]

from time import sleep_us

Driver class.

class I2cLcd:

def __init__(self, i2c, i2c_addr=0x27, dim=(16, 2), grove=False):  # default address of PCF8574 is 0x27
    self.i2c = i2c
    self.i2c_addr = i2c_addr
    if not isinstance(dim, (tuple, list)) or len(dim) != 2:
        raise ValueError('dim: tuple/list e.g. (16, 2) expected')
    self.nx = min(dim[0], 40)
    self.ny = min(dim[1], 4)
    self.grove = grove
    self.backl = 0x08
    self.i2c.writeto(self.i2c_addr, b'\x00')         # Init I2C
    sleep_us(20000)                                  # Allow LCD time to powerup
    for _ in range(3):                               # Send reset 3 times
        self.i2c.writeto(self.i2c_addr, b'\x34\x30') # LCD_FUNCTION_RESET
        sleep_us(5000)                               # Need to delay at least 4.1 msec
    if not grove:
        self.i2c.writeto(self.i2c_addr, b'\x24\x20') # LCD_FUNCTION, put LCD into 4 bit mode
    sleep_us(1000)
    self.set_display(False)
    self.clear()        # Sets class variables: self.x = 0; self.y = 0; self.nl = False; self.impl_nl = False
    self._wr(0x06)                         # LCD_ENTRY_MODE | LCD_ENTRY_INC
    self.set_cursor(False)
    self.set_display(True)                 # We might include a backlight option here
    self._wr(0x28 if self.ny > 1 else 0x20)  # LCD_FUNCTION_2LINES if n_lin > 1 else LCD_FUNCTION

# Clears the LCD display and moves the cursor to the top left.
def clear(self):
    self._wr(0x01)      # LCD_CLR
    self._wr(0x02)      # LCD_HOME
    self.x = 0
    self.y = 0
    self.nl = False       # newline
    self.impl_nl = False  # implicit newline, to suppress an extra nl when a character in rightmost position is followed by \n

# Causes the cursor to be made visible if show or even blink.
def set_cursor(self, show=False, blink=False):
    self._wr(0x0f if blink else (0x0e if show else 0x0c))  # LCD_ON_CTRL | LCD_ON_DISPLAY | (LCD_ON_CURSOR) 

# Turns the LCD on (unblanks) or off, optionally sets backlight.
def set_display(self, on=True, backl=None):
    self._wr(0x0c if on else 0x08)  # LCD_ON_CTRL | LCD_ON_DISPLAY
    if backl is not None:
        self.backl = 0x08 if backl else 0x00
        self.i2c.writeto(self.i2c_addr, bytes((self.backl,)))

# Moves the cursor to the indicated position.
def move_to(self, x, y):  # Moves the cursor position to the indicated position
    self.x = x            # The cursor position is zero based (x == 0 -> first column)
    self.y = y
    self.nl = False       # No active newline anymore
    self.impl_nl = False  # If we just moved then also an implicit newline is no longer valid
    pos_c = 0x80 | x & 0x3f | (y & 1) << 6         # HD44780 position code.  y & 1 << 6   <-- Lines 1 & 3 add 0x40
    if y & 2:                                      # Lines 2 & 3 add number of columns
        pos_c += self.nx
    self._wr(pos_c)           # LCD_DDRAM | ..

# Writes the string at the current cursor pos and advances cursor.
# Trailing newlines (also implicit) happen at writes of following character to better use the limited number of lines.
# May be used to write a single character with .write(c).
def write(self, string='', end='\n'): 
    for c in ''.join((string, end)): #                                                                            --- #
        if c == '\n' and self.impl_nl:
            self.impl_nl = False          # Consume nl if a character written in rightmost position already elicited an implicit nl
            continue
        if self.nl:
            self.move_to(0, self.y+1 % self.ny)
            for _ in range(self.nx):
                self._wr(32, 1)   # 32 <-- ord(' ')    # Clear the line that we now start writing at
            self.move_to(0, self.y)
        if c == '\n':
            self.nl = True                # nl will be executed when next character arrives
            continue
        if self.x < self.nx:
            self.impl_nl = False          # Other character than \n after implicit newline makes it invalid
            self._wr(ord(c), 1)    #                                                                                    ------- #
            self.x += 1
        if self.x >= self.nx:
            self.nl = True                # We signal the newline, but it is implicit
            self.impl_nl = True

def _wr(self, data, dbit=0):  # Write to the LCD; dbit: 0..command, 1..data
    if self.grove:
        self.i2c.writeto(self.i2c_addr, bytes((0x40 if dbit else 0x80, data)))
    else:
        b0 = dbit | self.backl | data & 0xf0
        b1 = dbit | self.backl | ((data & 0x0f) << 4)
        self.i2c.writeto(self.i2c_addr, bytes((b0 | 0x04, b0, b1 | 0x04, b1)))
    if not dbit and data <= 3: # The home and clear commands require a worst case delay of 4.1 msec
        sleep_us(5000)

from machine import I2C, Pin

i2c = I2C(0, sda=Pin(8), scl=Pin(9), freq=100000)
lcd = I2cLcd(i2c, 0x3e, (16, 2), grove=True)

lcd.write('First Line')
lcd.write('Second Line')

[rkompass]

Nice you got it working.
@bartvdg: What is displayed if you do lcd.write('~ \\')?
You may discard set_display(), as its no 8-bit code and has no functionality with the grove LCD (you may not switch the backlight off, can you?).
Have a look at the other driver variants - this was the maximally reduced version.
Of course the drivers essence is Dave Hylands code. I didn't like the idea of selecting and combining two files in the beginning as this was very complicated for me then. Now you somewhat proved that a single file is also simpler for others.

[bartvdg]

It works fine now.

[bartvdg]

@rkompass I have asked also support from the supplier of the 'Grove Starter kit for Pico', he just sent me a new LCD, they thought it was faulty.
So I have 2 LCDs now, would you be interestted to have one? If you send me your address I can ship it to you.

[rkompass]

Got mine today. Many thanks for the offer.
Perhaps Robert?
The Grove plugs are quite convenient. Now way to mismatch the connections. I will update my repo soon to have the Grove LCD automatically selected, if the I2C address is in the respective range (only minimal changes needed, as we learnt already).
Btw you may solder such a female connector to the 2004 LCD version and have more lines and characters available with the same luxury and safety of plugging.

[bartvdg]

@robert-hh do you want a free Grove - 16x2 LCD (White on Blue), if so please give me your address and I will send it over...

[robert-hh]

Thank you for the offer. But better keep it for yourself as spare one or second device. You will surely need another one soon.