I'm trying to find a way to convert data from an LCD screen (I don't have access to the driver that drives the LCD) to a data format that I can use for calculations.
The LCD seems to be this one:
It will always display 3 digits on the same place in the LCD, that updates roughly 1 time per second.
Would it be possible to 'hack' into this LCD screen with an arduino to read the data that's being sent to it, and so convert the number to something that's usuable?
The datasheet lists a table for all the characters on page 2 and since the data I'm interested in can only consist of numbers, I'm expecting to read out values between 0011 0000 (0x30) and 0011 1001 (0x39)..somewhere.
I would then need to figure out how to trigger a read from these pins whenever that specific location (low and column) is being written to.
Is this doable? I am not very experienced in electronics but have played around a lot in the past.
It looks like a regular HD44780-style LCD with regular 8x2 header pins.
You can capture all the traffic with a Logic Analyser. e.g. Saleae Logic can decode HD44780 data.
It is hard work connecting all the logic pins to the Logic Analyser. But at least it will show you when and how the LCD receives data. With luck, it is using 4-bit interface. Which means that you don't need so many wires to LA (or your sniffer)
Seriously. Why don't you just ask the manufacturer of the product ?
This has come up a few times in the past.
Not only can the host choose 4 bit vs 8 bit mode, but how the host handles the E signal, control signals, and data signals can vary substantially.
Also, the host could be doing reads from the display as well as writes.
The hd44780 spec allows for some pretty tight/short timing between the control signals (E, R/W, CS) and data signals.
Depending on how the host controls the signals and how fast it changes them,
it could be fairly easy to snoop the lines with another processor, or impossible to do without some h/w assist.
For example, the E signal is only required to be high or low for 450ns and when writing bytes to the display, the data signals/pins are only required to remain valid for 10ns after E is dropped low.
In the worst case scenario, the snooper must be able to process an operation every 1us.
For writes, processed on falling edge of E, be able to immediately process the data signals and the RS signal in 10ns after E drops to low.
For reads, be able to process process the data signals and the RS signal within the time period of 160ns after E goes high and before 10ns after E goes low.
This is not possible to do with another processor looking at and reading the signals and requires some kind of h/w assist circuitry.
However, most hosts don't push things that hard and if they don't, it might be feasible to simply read the signals with another processor.
First thing to do is to use a logic analyzer see how the device is being used.
only writes vs writes and reads.
(monitor the R/W signal, if always low then only writes)
See if 4 bit or 8 bit mode is being used.
(monitor D0, D1, D2, D3 to see if they are changing, if they are changing then 8 bit mode is being used)
See how fast the E signals is changing.
(monitor the E signal and see how fast it changes, this determines how fast you have to process operations)
See timing of control and data signals with respect to E.
This requires hooking up E, RS, R/W, and at least some if not all of the data lines.
For writes, you will need to look to see how long the data lines typically remain stable after E is dropped.
Reads are different, they are normally processed while E is still high - no sooner than 160ns after E rises to high.
But often the host leaves the data signals a while after E goes low.
You will want to look at an analyzer trace to see if you are lucky and have some time after E goes low.
If so, you might be able to process read data on E falling.
The timing information will determine how to proceed, and if it is possible to read the signals with another processor, of if you will have to build some sort of h/w assist to latch the data to be read by another processor slightly later in time.