Driving more than 1 LCD via Shift Registers

Hey guys,

I’ve been trying to find the most efficient, pin wise, to drive more than one 16x2 “standard” lcd. I found the ShiftLCD library from chrisparish, which works great, i’ve been able to get one LCD successfully working with a shift register. In the name of trying to keep it simple and expand the number of LCD’s. I figured it would be simple since i’d just cascade the shift registers. Sadly, its not working, i get jibberish on the second LCD. The second LCD is hooked up correctly because if i just connect the Data,Clock,latch pins to the second it outputs the display correctly, but when daisy chained it doesnt.

I’ve looked at the core functions of the library, but am not sure how I’d even modify it so that I can pass text to different LCD’s. I’ve used shift registers before and have a basic idea of how they work and how you send data to the cascaded registers. Toggle the latch, then send the bytes over starting from the last to the first then toggle the latch again.

The shift register LCD library can be found here

The basic utilization of it is like so:

#include <ShiftLCD.h>

//initialize the libary
ShiftLCD lcd(2,4,3);

void setup() {
lcd.begin (16,2)
lcd.print(“hello world”);

}

I figured i could just initialize another instance of it like
ShiftLCD lcd1(2,4,3); //since they’re using the same D,C,L pins

the just repeat the printing assignment, but this time with:

lcd1.begin(16,2);
lcd1.print(“Hello world”);

but it doesnt work…

WHen looking at the way the library sends the data its only mean to send it to one shift register otherwise you’d see more than one call to the ShiftOut function in order to send the data to the other registers. I figured i could try to another ShiftOut() into it, but i have no idea of how i’d pass the second piece of data to it…

Has anyone tried this approach?

I know that with the LCD you can tie all the lines except for the E and have them working with the liquid crystal library, but that would still cost me too many pins. Hence trying to use 3 pins and the shift regs…

Try looking here: Arduino Forum
or here: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1265969050/0

I don't think you gain a lot by using the shift register(s) when you consider the extra code and latency.

Don

Hey Don,

I did run across those posts and saw your advice. This doesn't have to be very snappy, so a little latency is not an issue for me doing it in software. I liked the idea of utilizing the shift reg because it only need 3 pins. If i were to connect all the commons together (4 data + rw) and then just have unique E lines for each of the LCD, i'd be consuming 9 pins total (I want to use 5 LCD's).

So it seems like the approach you've mentioned before is what people usually implement... I just wish i could tweak that library just a bit so that i could actually utilize the cascading feature of the shift registers..

If i were to connect all the commons together (4 data + rw) and then just have unique E lines for each of the LCD, i'd be consuming 9 pins total (I want to use 5 LCD's).

If you try this make sure you parallel 4 data + rs not 4 data + rw. It would also use 10 pins total for 5 LCD's. It may pay to use a second Arduino just for the LCDs rather than dealing with a bunch of shift registers, or maybe a Mega instead of two UNOs.

Another approach would be to use the Microchip MCP23017 I/O expander. Each one will give you two 8-bit ports, enough for two LCDs running in 4-bit mode. I think you would have to write your own software. With two 8-bit ports you could hang 8 LCDs in parallel off of one port and run the 8 Enable lines off of the other port. I know you would have to write your own software.

Don

floresta:

If i were to connect all the commons together (4 data + rw) and then just have unique E lines for each of the LCD, i'd be consuming 9 pins total (I want to use 5 LCD's).

If you try this make sure you parallel 4 data + rs not 4 data + rw. It would also use 10 pins total for 5 LCD's. It may pay to use a second Arduino just for the LCDs rather than dealing with a bunch of shift registers, or maybe a Mega instead of two UNOs.

Another approach would be to use the Microchip MCP23017 I/O expander. Each one will give you two 8-bit ports, enough for two LCDs running in 4-bit mode. I think you would have to write your own software. With two 8-bit ports you could hang 8 LCDs in parallel off of one port and run the 8 Enable lines off of the other port. I know you would have to write your own software.

Don

In my rush to post that I made two mistakes. 1.) I meant 4 LCDs and 2.) I mean the RS line. My apologies and yes it would be 9pins total for it. I was thinking of possibly just going with a 644P to give me the extra room rather than making a dual 328.. I dont even know how i'd have them talking to each other correctly (standard serial? rx/tx flip?)

So Don, seeing that you've actually weighed in on this all across the forums on multiple sites. Is it just not feasible to use the shift registers? Whats the disadvantage? Code bloat?

Is it just not feasible to use the shift registers?

Yes, you can use shift registers to drive multiple displays with shift register, although you will have to adapt the library a little. On the Aduino, you still just need your 3 lines, dataout, clock and latch.

What's necessary? The usual 44780 display in 4 bit mode is driven with 6 lines: 4 data lines DB0-DB3, the RS line to select command or data mode and E line to latch the data. If now you want to drive more displays, you can share DB0-DB3 and RS between all displays and have one individual E line for each display. So on your 74hc595 with 8 lines, you can use up to 3 pins for individual E lines thus driving 3 displays with one 74hc595. The remaining 5 are used for the common DB0-3 and RS.

You now just need to adapt the Serial LCD library - which I don't have at hand at the moment, to set the correct E line on the 74hc595 to high (and toggle to back to low) and make sure the E lines for the other displays are set to low. If you need even more display, cascade another 74hc595 to get up to 11 displays and tell your library to shift out one more byte for the additional E lines. If you want to write in parallel (for example to clear all displays at the same time), just toggle all respective E lines to high and back t the same time. Just make sure, you always send the whole command to all of them - the command word plus all pieces of the data.

Korman

Korman:

Is it just not feasible to use the shift registers?

Yes, you can use shift registers to drive multiple displays with shift register, although you will have to adapt the library a little. On the Aduino, you still just need your 3 lines, dataout, clock and latch.

What's necessary? The usual 44780 display in 4 bit mode is driven with 6 lines: 4 data lines DB0-DB3, the RS line to select command or data mode and E line to latch the data. If now you want to drive more displays, you can share DB0-DB3 and RS between all displays and have one individual E line for each display. So on your 74hc595 with 8 lines, you can use up to 3 pins for individual E lines thus driving 3 displays with one 74hc595. The remaining 5 are used for the common DB0-3 and RS.

You now just need to adapt the Serial LCD library - which I don't have at hand at the moment, to set the correct E line on the 74hc595 to high (and toggle to back to low) and make sure the E lines for the other displays are set to low. If you need even more display, cascade another 74hc595 to get up to 11 displays and tell your library to shift out one more byte for the additional E lines. If you want to write in parallel (for example to clear all displays at the same time), just toggle all respective E lines to high and back t the same time. Just make sure, you always send the whole command to all of them - the command word plus all pieces of the data.

Korman

Korman, thanks for the higher level overview of the process involved. The problem for me is that i'm not that strong of a coder, especially when dealing with OOP which the library is written with. So i dont understand exactly how one function/class will pass certain parameters to the helper (objects?). I looked at the code for the ShiftLCD library and it seems well documented and straight forward, but for example i cant even figure out where the print command is utilized.

So even if i were to use your approached and tie everything together except for the E line to toggle. I dont know how i'd pass the unique display data for an individual lcd. The typical usage is like this:

ShiftLCD lcd(2, 4, 3);

void setup() {
  // set up the LCD's number of rows and columns: 
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("First LCD");
}

Ideally, it would haev to work like this:

ShiftLCD lcd1(2, 4, 3);
ShiftLCD lcd2(2, 4, 3);

void setup() {
  // set up the LCD's number of rows and columns: 
  lcd1.begin(16, 2);
  // Print a message to the LCD.
  lcd1.print("First LCD");

  lcd2.begin(16, 2);
  // Print a message to the LCD.
  lcd2.print("Second LCD");
}

Anyhow, i dont think I have the requisite skills to pull it off.. :~

The parts you care about that need to be adapted are just the lines containing EN_SWITCH in ShiftLCD.cpp. All EN lines should always be set to high, except when you strobe one to pass data. Extending the library to work in 4 bit mode with two displays connected to pins 2 and 3 on the shift registers should be fairly easy. If you need help on this, post your hardware setup and where you connect what. I hope I can look into it later or tomorrow. Be warned, I’m on the road without an Arduino, so you’ll have to do all the testing.

Korman

So Don, seeing that you've actually weighed in on this all across the forums on multiple sites. Is it just not feasible to use the shift registers? Whats the disadvantage? Code bloat?

I've been using LCD modules for decades and have them pretty well figured out so I respond to lots of LCD threads. I don't think I have answered too many shift-register questions since I have no actual experience with the general purpose ones and only limited and very recent experience with the Microchip IO Expander.

There's really no reason not to use the shift registers with the LCDs. The main disadvantage of any serial data transfer technique (compared to parallel) is the loss of speed. Since the typical LCD implementation requires many time delays this loss of speed is immaterial. Another disadvantage with most shift register LCD implementations is the loss of the ability to read the busy-flag to determine when the LCD is ready for another operation. The majority of LCD applications do not require this capability and consequently this is really not a serious deficiency.

Korman's clear and concise explanation (middle paragraph) would apply to the use of the IO expander chip as well. I think that the big difference would occur when you wanted to drive more than 3 LCDs. Using the 74HC595 it looks like you max out at three LCDs. Using the MCP23017 you can drive 8 LCDs using the straightforward technique I mentioned previously and you could get 3 more if you implemented their enable lines on the unused pins of the port that drives the data and rs lines. You might even be able to do all this by using (or modifying) the library described here: IO expander Library | koenwar .

So aside from the less than trivial problem of the software, using the IO expander gives you the ability to drive more LCDs with one chip, an easier (I think) route to adding more chips, and all this with one less Arduino pin. If you want to use three pins then you can use the MCP23S17 chip which uses SPI rather than I2C and take advantage of the higher speed of this interface.

Don

All EN lines should always be set to high, except when you strobe one to pass data.

Shouldn't that be low, or is there some inversion going on with the shift register?

Don

Korman:
The parts you care about that need to be adapted are just the lines containing EN_SWITCH in ShiftLCD.cpp. All EN lines should always be set to high, except when you strobe one to pass data. Extending the library to work in 4 bit mode with two displays connected to pins 2 and 3 on the shift registers should be fairly easy. If you need help on this, post your hardware setup and where you connect what. I hope I can look into it later or tomorrow. Be warned, I’m on the road without an Arduino, so you’ll have to do all the testing.

Korman

Thanks for offering to lend a hand or in this case the mind and i’ll be the hands. I pretty much have it connected like so: LCD+V2.png (image)

With the exception that I did not connect LED K on the LCD to the shift register QF pin (have have the respective LED pins going to 5v and G). Here’s the simple layout of it

Aruduino Pins => '595 Shift Reg

2 (Data) = > '595 pin 14
3 (Clock) = > '595 pin 11
4 (Latch) = > '595 pin 12

LCD Pins => '595 Shift Reg

DB7 => pin 15 (QA)
DB6 => pin 1 (QB)
DB5 => pin 2 (QC)
DB4 => pin 3 (QD)
E => pin 6 (QG)
RS => pin 7 (QH)

Needless to say, the next shift register and LCD are setup the same. Except the data input for the second 595 is coming from the serial out (Pin 9 Q7) of the first. thats the basic setup.

In the ShiftLCD.h there are the following definitions:
// pins for functional output
#define LCD_RS_PIN 0x01, im assuming in binary its 00000001 (would this mean it would keep RS at 5v)
#define LCD_EN_PIN 0x02 and this is 00000010 (and this would mean it keeps EN at 5v as well)
#define LCD_BL_PIN 0x04 (i’m not connecting the backlight to the shift reg so this is probably useless to me)

Which seems like it would coincide with the pin location on the shift register, am i correct?

Looking over his modified library it seems that he explicitly defines it to run in 4 bit mode. I’m basing this off of the ShiftLCD.h

/*
ShiftLCD Class
*/
class ShiftLCD: public Print {
public:

ShiftLCD(uint8_t dp, uint8_t cp, uint8_t lp, uint8_t mode = 4);

Based on what you said before, this is the meat and potatoes function for the 4 bit writing

void ShiftLCD::write4bits(uint8_t value, uint8_t mode) {
int EN_SWITCH = B00000010;
int RS_SWITCH = B00000001;
int cmd = 0;
int data = 0;
if (!mode) {
cmd = 0 | _backlight;
} else {
cmd = LCD_RS_PIN | _backlight;
}
data = value<<4 & B11110000;
cmd |= EN_SWITCH;
digitalWrite(_latch_pin, HIGH);
shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd);
digitalWrite(_latch_pin, LOW);
delayMicroseconds(1);

cmd &= ~EN_SWITCH;
digitalWrite(_latch_pin, HIGH);
shiftOut (_data_pin, _clock_pin, LSBFIRST, data | cmd);
digitalWrite(_latch_pin, LOW);
delayMicroseconds(1);

cmd |= EN_SWITCH;
digitalWrite(_latch_pin, HIGH);
shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd);
digitalWrite(_latch_pin, LOW);

delayMicroseconds(100);
}

Not sure how i’d rework that

floresta:

So Don, seeing that you've actually weighed in on this all across the forums on multiple sites. Is it just not feasible to use the shift registers? Whats the disadvantage? Code bloat?

I've been using LCD modules for decades and have them pretty well figured out so I respond to lots of LCD threads. I don't think I have answered too many shift-register questions since I have no actual experience with the general purpose ones and only limited and very recent experience with the Microchip IO Expander.

There's really no reason not to use the shift registers with the LCDs. The main disadvantage of any serial data transfer technique (compared to parallel) is the loss of speed. Since the typical LCD implementation requires many time delays this loss of speed is immaterial. Another disadvantage with most shift register LCD implementations is the loss of the ability to read the busy-flag to determine when the LCD is ready for another operation. The majority of LCD applications do not require this capability and consequently this is really not a serious deficiency.

Korman's clear and concise explanation (middle paragraph) would apply to the use of the IO expander chip as well. I think that the big difference would occur when you wanted to drive more than 3 LCDs. Using the 74HC595 it looks like you max out at three LCDs. Using the MCP23017 you can drive 8 LCDs using the straightforward technique I mentioned previously and you could get 3 more if you implemented their enable lines on the unused pins of the port that drives the data and rs lines. You might even be able to do all this by using (or modifying) the library described here: IO expander Library | koenwar .

So aside from the less than trivial problem of the software, using the IO expander gives you the ability to drive more LCDs with one chip, an easier (I think) route to adding more chips, and all this with one less Arduino pin. If you want to use three pins then you can use the MCP23S17 chip which uses SPI rather than I2C and take advantage of the higher speed of this interface.

Don

At this point i'm going to stick with the shift registers because I have a bunch that were surplus from another project..

So if it makes it easier, I care more about the pin savings on the arduino rather than the shift reg, they're cheap and i have plenty.

When you speak of loss of speed, what exactly does that entail? Slower write speeds to the LCD, aka it will take a few milliseconds longer doing it serially to update the display? If so, that isnt an issue for me, i'm not displaying time sensitive info. So a delay of up to a couple seconds is even acceptable.

I'll have to get my hands on a couple SPI IO expanders to get my hands dirty with them. I've been using shift register, 595's for output expansing and CD4021B for input expansion. They've worked well for me thus far, but then again I've never had the pleasure of working with some of the cooler IC's.

These Microchip devices work for both input and output. I haven’t tried the input yet though.

Don

So i’m “trying” to mess with the library to see if i can start making any headway. I’ve succesfully now manipulated it so that it can mirror the print output on multiple LCD’s. Which is a step in the right direction. Its a very basic modification:

ShiftLCD.cpp

void ShiftLCD::write4bits(uint8_t value, uint8_t mode) {
	int EN_SWITCH = B00000010;
	int RS_SWITCH = B00000001;
	int cmd = 0;
	int data = 0;
	if (!mode) {
		cmd = 0 | _backlight;
	} else {
		cmd = LCD_RS_PIN | _backlight;
	}
    data = value<<4 & B11110000;
	cmd |= EN_SWITCH;
	digitalWrite(_latch_pin, HIGH);
	shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd);
	shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd);
	digitalWrite(_latch_pin, LOW);
	delayMicroseconds(1);
	
	cmd &= ~EN_SWITCH;
	digitalWrite(_latch_pin, HIGH);
	shiftOut (_data_pin, _clock_pin, LSBFIRST, data | cmd);
	shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd);
	digitalWrite(_latch_pin, LOW);
	delayMicroseconds(1);
	
	cmd |= EN_SWITCH;
	digitalWrite(_latch_pin, HIGH);
	shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd);
	[b]shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd);[/b]
	digitalWrite(_latch_pin, LOW);
	
	delayMicroseconds(100);
}

All i’ve done is added another call the the shiftOut fuction, which now properly sends the print value twice, which succesfully writes it to the second shift register. So thats a baby step in the right direction.

here’s the problem as I seem to see it. When i call the lcd.print(“helloooo…?”) it sends the “hellooo…?” out twice because thats what it receives. Now the crucial next step is to be able to send each LCD its unique. I dont know how i’d be able to do that given the way this library is coded because the write4bits function is what is responsible for sending the data out, but i dont know how i’d specifcally assign the data to the 2nd, 3rd, and 4th registers

i’d need something along the lines of
shiftOut (_data_pin, _clock_pin, LSBFIRST, data1 | cmd);
shiftOut(_data_pin, _clock_pin, LSBFIRST, data2 | cmd);
shiftOut (_data_pin, _clock_pin, LSBFIRST, data3 | cmd);
shiftOut(_data_pin, _clock_pin, LSBFIRST, data4 | cmd);

but i think i’ve hit a wall, let me know if you can help me out.

Hello Rizla,

sorry for the delay, I was a little busy. I attached to this message a zip with a modified ShiftLCD library, which should be able to handle 2 displays where the EN line of one is attached to pin2 of the shift register and the other to pin3. All changed have been marked with a comment //Touched here.

To use it, you need add one additional parameter (after the default default parameter with the mode, 4 for 4 bit mode in this case) to the constructor to tell it which pins to use. This is still a little rough, so you have to give it a bitmask, but for testing it should be good enough.

Your initialisation should look something like this:

ShiftLCD lcd1(2, 4, 3, 4, 0b00000010); // EN Attached to pin 2
ShiftLCD lcd2(2, 4, 3, 4, 0b00000100); // EN Attached to pin 3

Then you can do either lcd1.print() or lcd2.print. At least in theory.

If you feel lucky, you could also try:

ShiftLCD lcdboth(2, 4, 3, 4, 0b00000110); // EN attached to pins 2 and 3, both should display the same stuff

As warned before, the code is completely untested, I changed the stuff while waiting at the airport again and have no Arduino with me. Let me know what happens and we take it from there.

In the unlikely case that this really works, the next step is to expand the whole thing to work with as many displays as you need.

Korman

shiftlcdtest.zip (4.77 KB)

I'll weigh in for the approach for driving lots of LCDs by using the MCP23017 16-port IO expander, which costs around $US 1.20 each.

Using I2C you can potentially have many LCDs, and just have to address each one by jumpering the address pins. You can choose 8 address combinations (3 jumpers). I did an example of using that for a graphical LCD here:

For a text LCD you don't need as many pins, so you could run two LCDs from one expander. Thus without a lot of mucking around, 8 expanders would support 16 LCDs. In fact there is a "Centipede" board for the Arduino that has four of them in place, so with two of those you would have the 8 expanders.

This may or may not work better for you than the shift register approach that Korman is helping you with. For only $1.20 per chip I wouldn't let price stand in the way.

The code on that link was for the graphical LCDs, it would need modification for a text LCD. Of course text is simpler than graphics. There is probably a library around already that does it, I just can't recall where that might be.

Pin-wise the expanders are pretty economical. You only need 2 wires (SDA/SCL) plus your ground and power wires, which you would need anyway.

You could use the SPI chip for faster access but be warned that each chip then needs a separate SS line, so for 8 chips you need CLK, MISO, MOSI plus SS x n where n is the number of chips. So to keep the pin count low, I2C is the way to go.

Come to think of it Adafruit have the I2C/SPI backpacks for LCDs here:

(Out of stock right now). But if you got those and soldered them into place, you can just daisy chain them. I think they only support one LCD per address, and since you can only jumper 8 addresses, that solution would limit you to 8 LCDs.

The custom-wired approach with the MCP23017 would give you 16 as I said. If you really want more, well a second Atmega processor as a "LCD driver" would not be inconceivable.

Korman:
Hello Rizla,

sorry for the delay, I was a little busy. I attached to this message a zip with a modified ShiftLCD library, which should be able to handle 2 displays where the EN line of one is attached to pin2 of the shift register and the other to pin3. All changed have been marked with a comment //Touched here.

To use it, you need add one additional parameter (after the default default parameter with the mode, 4 for 4 bit mode in this case) to the constructor to tell it which pins to use. This is still a little rough, so you have to give it a bitmask, but for testing it should be good enough.

Your initialisation should look something like this:

ShiftLCD lcd1(2, 4, 3, 4, 0b00000010); // EN Attached to pin 2

ShiftLCD lcd2(2, 4, 3, 4, 0b00000100); // EN Attached to pin 3




Then you can do either lcd1.print() or lcd2.print. At least in theory.

If you feel lucky, you could also try:


ShiftLCD lcdboth(2, 4, 3, 4, 0b00000110); // EN attached to pins 2 and 3, both should display the same stuff




As warned before, the code is completely untested, I changed the stuff while waiting at the airport again and have no Arduino with me. Let me know what happens and we take it from there.

In the unlikely case that this really works, the next step is to expand the whole thing to work with as many displays as you need.

Korman

Haha, coding at the airport. Good way to pass the time.

Based on the mods you’ve made it seems like you are trying to drive both LCD’s off of the same shift register and just toggle different EN bits for the particular LCD. I was looking more so at using one shift reg per LCD. A little more waste in terms of shift registers, but i think the advantage would be that I wouldnt have to alter the library if i were to add more because i’d be limited to 3 per shift register. I guess doing it my way is not really feasible. I think i twould require tweawking the print library as well… ug. too bad this wasnt a little more straight forward.

I’ll give your code a try a little later. Thanks and have a great trip.

rizla420:
Based on the mods you've made it seems like you are trying to drive both LCD's off of the same shift register and just toggle different EN bits for the particular LCD. I was looking more so at using one shift reg per LCD. A little more waste in terms of shift registers, but i think the advantage would be that I wouldnt have to alter the library if i were to add more because i'd be limited to 3 per shift register. I guess doing it my way is not really feasible. I think i twould require tweawking the print library as well.. ug. too bad this wasnt a little more straight forward.

If you want to one shift register per LCD, you either have to drive the shift registers seperately, which is done cheapest by sharing data and clock between all registers and the each register has its private latch pin on the Arduino. So you'll be using one additional pin on the Arduino per additional lcd display. In this case you can use the library without modifications, once instance like this:

ShiftLCD lcd1(2, 4, 3); // latch attached to Arduino pin 3
ShiftLCD lcd1(2, 4, 5); // latch attached to Arduino pin 5

If you want to daisy chain the shift registers, you need to change the library, no matter how you do it, because when you talk to one, the data for all needs to be managed and you need to make sure, that the EN pin of only the desired displays change. So in this case, why no share the other pins between the displays?

The solution I sent you was just a minimal test to check if the idea works in general and I because one pin was free it made only minimal changes necessary. If it works, I would modify the library a little further so it can handle also an additional shift registers or three for EN-pins exclusively. You then should be able to drive up to 26 displays with it - if the fan-out of the data pins bear it.

Korman

This was the board I ultimately came up with for mine. Still waiting for the second LCD to arrive in the mail to give it a full testing though. But, it works with one LCD hooked up to either sockets, and it’s recognising which socket the LCD’s hooked up to and sending the appropriate output.

The 4N25’s are just to hook up to a camera for AF+Ground and Shutter+Ground connections. The light coloured lines are just wires to bridge gaps (working on single sided board).

Using Raron’s library - http://code.google.com/p/arduinoshiftreglcd/

No modifications needed, hopefully. We’ll see when my other LCDs show up, but for now this is how they’re declared…

#include <ShiftRegLCD.h>
ShiftRegLCD lcd(3, 2, 4, 2, 0);
ShiftRegLCD lcd2(3, 2, 5, 2, 0);

Then lcd.print sends to one output, and lcd2.print sends to the other. Like I said, it’s sneding the output to the right set of pins when I switch the LCD over from one to the other, but still need to test running two at the same time.

My other 4x20 LCDs showed up in the mail this morning. Running both with no problems :slight_smile: