Usage of LCD displays via LiquidCrystal_I2C

[esanya]

Hi,

I would like to add a LCD display to the arduino controlled by telemetrix.

Just like this but via telemetrix:
https://create.arduino.cc/projecthub/Arnov_Sharma_makes/lcd-i2c-tutorial-664e5a

I have seen that I2C is supported. But I'm not sure what to do to drive a LCD via I2C
Should the library https://github.com/johnrickman/LiquidCrystal_I2C reimplemented based on telemetrix?

If some suggestions / guidance is available I would also like to integrate myself the lib
https://github.com/johnrickman/LiquidCrystal_I2C into telemetrix...

Thanks,
BR,
Sandor

[MrYsLab]

@esanya
Hi Sandor,
Although I have not used Telemetrix to drive an i2c LCD, there is no reason why it should not work.

Looking at the article you provided, the Adafruit LCD display used does not seem to be manufactured anymore.

Also, I looked at John Rickman's library, and it seems it is no longer supported. He states it is now being hosted on GitLab, but the link he provides does not work.

However, If you have tried running John Ricman's examples using your LCD display and it works, porting to Telemetrix should be obtainable.

From the i2c perspective, the Rickman library only places three calls to i2c functions. The first, is during initialization where Wire.begin is called. The telemetrix equivalent occurs when set_pin_mode_i2c is called.

The two other calls are contained in the library's expanderWrite method.

The telemtrix i2c_write() method incorporates both beginTransmiision and endTransmiision. You would need to provide the data to be written across the i2c interface, and telemetrix will take care of the rest.

All the other C++ code in Rickman's library would need to be ported to Python. That would be the bulk of the work.

I hope I have answered your question. If you have any additional comments or questions, please post them here, and I will do my best to provide an answer.

[esanya]

Hi Alan,

Thanks for you answer!

I have seen also that the lib what I have posted is no more maintained. Because of this I would take this one (this is maintained):

https://github.com/blackhack/LCD_I2C

One question:

you wrote: "All the other C++ code in Rickman's library would need to be ported to Python. That would be the bulk of the work."

could you give me a hint where this should be done? Can it go to telemetrix somewhere? Like the support for "DHT Temperature/Humidity Sensor" or "Stepper Motor Control (AccelStepper)"?

Then I will fork your 2 repos:

• https://github.com/MrYsLab/Telemetrix4Arduino
• https://github.com/MrYsLab/telemetrix

And try to do what you proposed... :)

Regards,
Sandor

[MrYsLab]

@esanya
Hi Sandor,
I may have been unclear on what would need to be done to support the i2c LCD.
I2C is a serial protocol used to communicate with i2c devices. It allows many devices to be connected on the same Arduino pins, but each device can be controlled individually using the protocol. For Arduino, the protocol is supported using the Wire library. Telemtrix implements i2c using the Wire library.

You do not need to modify either the telemetrix client or server. You would build your LCD application using telemetrix as is.
An example is an application I wrote for the ADXL345 accelerometer.

Other examples I provide for other devices, such as the HC-SR04 distance sensor or stepper motor control, required modification of the client and server to support them. That is because their protocols are specific to those devices and cannot be used with other devices. With i2c, all i2c devices use the same communication protocol, which is why one sees so many i2c devices available for a large array of different uses. Essentially with i2c devices, you communicate with the device using the device's address and then read and write to a register on that device.

To create an application to support an LCD using the LCD_I2C library, find all the calls that start with Wire. The LCD library uses Wire.begin, which telemetrix calls in set_pin_mode_i2c,
and calls to Wire.write, which is implemented by telemtrix as i2c_write.

You would want to port the code in the .cpp file to your Python application using the telemtrix i2c API to control the LCD.

I hope that I did not make things more confusing. If you have any questions, please let me know.

[esanya]

Hi Alan,

Thank you for your hints! Now I think I know how to proceed.

Regards,
Sandor

[esanya]

Hi Alan,

I have my first version of telemetrix + I2C_LCD port to python.

https://github.com/esanya/telemetrix/tree/add-an-example-to-support-i2c-LCD
master...esanya:telemetrix:add-an-example-to-support-i2c-LCD

It is actually the pythonization of the https://github.com/blackhack/LCD_I2C

https://github.com/blackhack/LCD_I2C/blob/master/src/LCD_I2C.{h, cpp}
and
https://github.com/blackhack/LCD_I2C/blob/master/examples/Hello_World/Hello_World.ino

It runs without error. But does not change / show anything on the LCD display... I'm not sure what could be wrong...

I have tried it to debug, but only on python level (-mpdb), and I'm not sure what is happening within the arduino...

Could you give me an idea?

Thanks,
Regards,
Sandor

[MrYsLab]

Hi Sandor,
Have you tried the blackhack library by loading the Hello_World.ino onto an Arduino, and did it work? This may seem silly, but I have found that some Arduino libraries do not work, and I wanted to ensure that you start with a working library.
I will look at your code to see if I can find anything that may be causing problems and will get back to you.

[esanya]

So I have now modified the I2C_LCD lib, and changed all

• delay(*) and
• delayMiliseconds(*)

to delay(500) calls.

It is now super slow, but still works stable (as before)...

One question from me: are you sure that the I2C addres used in arduino example the "0x27" is applied in the python/telemetrix stack too?

LCD_I2C lcd(0x27, 16, 2); // Default address of most PCF8574 modules, change according

This should be the number 39 in your logs...

As next I'm going to check your suggestion at the begin function...

[esanya]

I have also removed the extra clear (this is not the clear LCD but clear I2C adapter (I don't know what that means)!), but no change...

I have also reproduces your debug outputs.

I have pushed the actutal python port to my gitlab fork...

Somehow I have the feeling that the data is not arriving to the LCD. Is the I2C always enabled?

[esanya]

OK, so all the commands from the python side are, this seems to be ok for me:

tlmtr python:  [6]
tlmtr python:  [5]
tlmtr python:  [17]
tlmtr python:  [54]
tlmtr python:  [18]
tlmtr python:  [10, 0]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 52]
tlmtr python:  [12, 1, 39, 0, 48]
tlmtr python:  [12, 1, 39, 0, 52]
tlmtr python:  [12, 1, 39, 0, 48]
tlmtr python:  [12, 1, 39, 0, 52]
tlmtr python:  [12, 1, 39, 0, 48]
tlmtr python:  [12, 1, 39, 0, 36]
tlmtr python:  [12, 1, 39, 0, 32]
tlmtr python:  [12, 1, 39, 0, 36]
tlmtr python:  [12, 1, 39, 0, 32]
tlmtr python:  [12, 1, 39, 0, 132]
tlmtr python:  [12, 1, 39, 0, 128]
tlmtr python:  [12, 1, 39, 0, 4]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 196]
tlmtr python:  [12, 1, 39, 0, 192]
tlmtr python:  [12, 1, 39, 0, 4]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 20]
tlmtr python:  [12, 1, 39, 0, 16]
tlmtr python:  [12, 1, 39, 0, 4]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 100]
tlmtr python:  [12, 1, 39, 0, 96]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 8]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 8]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 8]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 8]
tlmtr python:  [12, 1, 39, 0, 0]
tlmtr python:  [12, 1, 39, 0, 8]
tlmtr python:  [12, 1, 39, 0, 0]

[MrYsLab]

@esanya The 39 is the address. It is set in:

    def I2C_Write(self, output):
        self.board.i2c_write(self._address, [output])

The fact that the scripts work with the delay changes means that it is not the value of the delays.

Perhaps I should explain the format of the Telemetrix i2c_write messages.
The first byte is the message ID. Message IDs are defined here:

The second byte is the number of data bytes to write.

The third byte is the i2c address of the device.

The fourth byte is the i2c port. The Arduino Uno only has one, but a device like the STM32 has two i2c ports.

The fifth and subsequent bytes are the bytes to be written to the i2c device.

Once set_pin_mode_i2c is called, the i2c interface is enabled.

Have you tried running my blink-the-backlight scripts in both the .ino and Python versions? Does either of them work?

I am going to look at the pcf8574 data sheet to see if see anything that might provide an answer.

[MrYsLab]

@esanya
I did not find anything useful in the datasheet. However, I purchased this discontinued LCD Display several years back. It incorporates an Arduino Leonardo and supports i2c. It uses a different chipset than you are using, so I cannot use the blackhack examples, but I just ran the i2c demo sketch for this board, and it works.

I will attempt a "quick" (but I am not sure how quick this may be) port of a simple i2c demo for telemetrix. It will prove that I can use telemetrix with an i2c LCD if successful. This is not very meaningful for you, but if it fails, it may provide a clue as to what may be going on with your setup.

This may take a couple of days.

[MrYsLab]

I took a quick look at the code, and I did not see anything obvious. Unfortunately, I do not have hardware here and, therefore, cannot test. The code has some semicolons (;) probably from cut and paste. You should remove them, but I don't think that is causing issues.

There is a way to print out values in the Telemetrix4Arduino sketch on the Python console. The function is called send_debug_info. The first parameter is a byte, usually used as an identifier and the second byte is an integer to report a value. You can also uncomment out this line to see the data being sent across the link.

However, before trying to debug on the Arduino side, perhaps we can do things on the Python side first.

When you first power up the display, are there any characters on the screen?
Is the backlight on or off?

One thing you can try is to toggle the backlight on and off to see if commands are being processed. Perhaps something like this:

import sys
import time
from telemetrix import telemetrix
from i2c_lcd_pcf8574 import LCD_I2C

"""
This example sets up and control an pcf8574 i2c LCD display.
"""


def pcf8574(board):
    lcd = LCD_I2C(board)
    lcd.begn()
    for i in range(3):
        lcd.backlight()
        time.sleep(1)
        lcd.nobacklight()
        time.sleep(1)


board = telemetrix.Telemetrix()
try:
    pcf8574(board)
except KeyboardInterrupt:
    board.shutdown()
    sys.exit(0)
    

If that works, I would continue by adding functionality slowly, such as clearing the screen if the screen is not clear on power up. If the backlight toggle does not work, you may need to observe the data being sent when LCD_I2C(board) is called and when lcd.begin() is called.

Please let me know if any of this helps.

[esanya]

Thanks, I will proceed as you have just suggested!

[MrYsLab]

@esanya
Porting the libraries for the LCD I own will be very labor intensive, so I think it may be better for me to try and get the same LCD hardware you are using. It may take weeks to code and debug the port. Could you provide a link to the board you are using or a manufacturer and model number?

I found this board on Amazon. Is it the equivalent of the board you are using?

[MrYsLab]

@esanya
I just ordered the display, and I should receive it this week. Out of curiosity:

1. Are you powering the display with 5 V?
2. Are you taking power from the Arduino or a separate power supply?
3. Which model of Arduino are you using?
4. Do you have devices other than the i2c connections connected to the Arduino?

[esanya]

Hi Alan,

Thank you for your support!

1; yes, with 5V
2; from Arduino
3; I have something like this: https://www.ebay.de/itm/273757062282
4; no I don't have any other device on the i2c

[esanya]

Sorry!!!!!

I guess I have found the "issue" .... :) I have missed to comment out the //define I2C_ENABLED 1 line....

Oh... I feel me so stupid...

[esanya]

And, yes, now the noBacklight(), backlight(), clear() methods work. The lcd.print("xyz") still not, but at least some interaction... :)

[esanya]

The current problem is, the LCD displays instead "Hello" some strange characters... :) So it has to be some conversion I guess...

[MrYsLab]

Don't feel stupid - mistakes are how we learn. I can't tell how often I have "learned" things ;-). Since you can run the blink script, then it can't be a power supply issue. It sounds like the character data is either being built incorrectly from the Python side or corrupted on the Arduino side. My guess is that it is on the Python side.

[MrYsLab]

I received two LCDs from Amazon. I ordered this unit.

I tried running the blackhack Hello_World.ino script and saw the backlight flash, but no characters print. Is there anything I need to change in the blackhack software?

When you run this script, do you see the characters printed to the LCD?

[MrYsLab]

I found out why I could not see any characters. I needed to adjust the contrast potentiometer on the i2c interface. I don't know why they had it set to a level where the characters were not visible.

So, now I am seeing what you are seeing. The characters being printed are not correct. I am unsure of what approach I will take with this. Since the data being sent to the i2c interface is the same between the Arduino sketch and the Python script, The only place that I think that things could be going wrong is the time between the two nibbles being written to the LCD. I will play and see if that is the case. If not, I will probably do a more direct port of the Arduino libraries. I will let you know what I find out.

[MrYsLab]

It is not the timing as you said before. I am going to investigate the initialization code to see if anything is going on there that might explain this.

[MrYsLab]

@esanya
Problem solved!
I have modified your original files, and you may view them here.

You will find both a modified library and an example on that page.

The problem was that some of the time delays on the Python side in your library were too short. I modified many of the delays but did not test all library methods.

Please let me know if things know work for you.

[MrYsLab]

@nildude The contributed example code uses a PCF8574 i2c controller chip, and the DFRobot board uses a HD44780U i2c controller. These are very different devices.

The term i2c refers only to the data transport that sends and receives data from the device. To control an i2c device, data is written to specific registers that the chip designer specifies. The registers and control values are different between these two chips.

To "port" the C++ code provided in the DFRobot library to Telemetrix Python scripts, you must use the same register and data values that the DFRobot C++ library uses.

I would happily answer any questions about how you might do the port.

[nildude]

Hi @MrYsLab,

Yes, I am getting there. I am starting to understand the addresses. I am now able to control the back lighting of the display. I will move on to the actual placement of curser and other features. I used an Arduino I2C address scanner and found the two addresses needed for addressing the backlit and colour of the display as well as the dot matrix addresses.

Thank you for the heads-up. I will be happy to merge my library once it is ready.

[MrYsLab]

@nildude That is good news.

[nildude]

Hi again,

I have gotten my display working by porting over the python code from the DF Robot library that is using a raspberry pi specific python extension as far as I can tell. It is not ideal for what I want to do.

Kindly see my attachments. My "Hello World" example is a bit messy and I have not yet unit tested all the functions but I could think this would be rather useful for others that are interested in a bit more modern display. It also gives a likely broader framework to support other displays.

Happy to try to continue to work with you to get this to a stage where we can integrate it in the main example fork.

Thanks.

DFRobot_RGBLCD1602_hello_world_telemetrix.zip

[MrYsLab]

This looks very good. Using the DFRobot RPi code was a great idea.