Witam, mam wyświetlacz 40x4 LCD , w rzeczywistości to zintegrowane 2 wyświetlacze na sterowniku HD44780 wykorzystując bibliotekę dla Arduino LiquidCrystal440,
oto przykładowy kod:
Problem tkwi przy próbie kompilacji, wyskakuje oto taki komunikat:
nie bardzo wiem o co tu chodzi.
Podobno to działa, jest jeszcze wewnątrz biblioteki plik testLCD i też nie mogę go skompilować.
TestLCD:
wyświetlacz firmy Optrex Dmc40457
Z biblioteką dla standardowych wyśw. działa jako 40x2 pierwsze 2 linie podając sygnał enable na E1 i pozostałe 2 linie na E2.
oto przykładowy kod:
Code:
#include <LiquidCrystal440.h>
// LiquidCrystal lcd(rs,rw,enable1,enable2,d4,d5,d6,d7);
// Note: some Forum examples using LiquidCrystal440.h have wrong DB pins,
// eg DB0-DB3, or in wrong order. The top 4 work, in this order.
LiquidCrystal lcd(2, 3, 4, 5, 9, 10, 11, 12);
void setup()
{ lcd.begin (40, 4);
lcd.clear();
for (int j=18; j<129; j++)
{ lcd.write(j);
} // print English chars in rom lower 4 bits, upper 4 bits Japanese
}
void loop()
{
}
Problem tkwi przy próbie kompilacji, wyskakuje oto taki komunikat:
Code:
Opcje projektu zmienione, przeładuj całość
In file included from lcd40x4v2.ino:1:0:
C:\Users\Dell\Documents\Arduino\libraries\Liquidcrystal440/LiquidCrystal440.h:95:16: error: conflicting return type specified for 'virtual void LiquidCrystal::write(uint8_t)'
virtual void write(uint8_t);
^
In file included from C:\Users\Dell\Documents\Arduino\libraries\Liquidcrystal440/LiquidCrystal440.h:5:0,
from lcd40x4v2.ino:1:
C:\arduino-1.6.1\hardware\arduino\avr\cores\arduino/Print.h:48:20: error: overriding 'virtual size_t Print::write(uint8_t)'
virtual size_t write(uint8_t) = 0;
^
Błąd kompilacji.
nie bardzo wiem o co tu chodzi.
Podobno to działa, jest jeszcze wewnątrz biblioteki plik testLCD i też nie mogę go skompilować.
TestLCD:
Code:
#include <LiquidCrystal440.h>
// Try to exercise everything in LiquidCrystal for test purposes--: You should be able to modify the first 4 lines
// of code to test different options and swap LCD boards (with contrast potentiometers attached directly) by plugging them directly
// into the row of digital sockets on the Mega opposite the USB socket. Be careful about current draw on the backlight pins!!
//Arduino can only power these if current draw is <= 40 mAmps
uint8_t nRows = 4; //number of rows on LCD
uint8_t nColumns =20; //number of columns
uint8_t rw = 47; //255 if rw is connected vs 47 (or 49 for the 24x2) in the examples below; it should be pulled to GND if not controlled by the interface.
LiquidCrystal lcd(49,45, 35,33,31,29); //there are multiple versions of this commented below; paste 'em in
//this is kind of interesting: the LIquidCrystal object is created and init/begin is run
//out here before setup(); before the board has power on the Mega!!! We need another begin to really
//start the board later.
//======for an LCD with a single HD44780 type chip and 16 pin interface (eg 16x2 20x2 16x4 20x4) 4 data pinshttp://healthriskappraisal.org/LiquidCrystal440.zip
//Alternate interfaces to test for 2x16,4x20,4x16:
//LiquidCrystal lcd(49,47,45, 35,33,31,29); // rs,rw,en, 4 data pins remember to set rw = 255 above
//LiquidCrystal lcd(49,47,45, 43,41,39,37, 35,33,31,29); // rs,rw,en 8 data pins remember to set rw = 255 above
//LiquidCrystal lcd(49,45, 35,33,31,29); // rs,en, 4 data pins remember to set rw = 47 above
//LiquidCrystal lcd(49,45, 43,41,39,37, 35,33,31,29); // rs,en 8 data pins remember to set rw = 47 above
//alternate interfaces to test for 4x40:
//LiquidCrystal lcd(48,47,46,52, 41,40,39,38); rs,rw,en1,en2, 4 data lines set rw to 255 I don't see any way to eliminate rw and include en2 with fcn overloading.
//LiquidCrystal lcd(48,255,46,52, 41,40,39,38); rs,rw,en1,en2, 4 data lines set rw to 47 but this trick should let me use a grounded RW and skip the checkLcdBusyFlag if I want.
// Connections this assumes we attached a potentiometer across LCD pins 1,2 and 3 with a standard 16 pin straight interface
// and then plugged the LCD into the distal row of digital pins on a Mega
// with the LCD extending away from the mega board:
// this frees up the PWM pins for other uses.
// rs (LCD pin 4) to Arduino pin 49
// rw (LCD pin 5) to Arduino pin 47
// enable (LCD pin 6) to Arduino pin 45
// LCD pin 15 to Arduino pin 27
// LCD pins d4, d5, d6, d7 to Arduino pins 35,33,31,29
//Arduino pins 51,43,41,39,37,23 are unused and hard to get at--you could interpose something like a stackable header between
// the used pins and the LCD; then you could access the unused pins
//=====for a 4x40 LCD with 2 HD44780 type chips and 17 pin interface in 2 rows of 9; the pins are not arranged for
// use with a breadboard, although you could solder a female socket onto the LCD board and use wires inserted
// female sockets or (as I did) to solder in stackable headers so that you can use the breadboard but
// also can plug it into the 2 rows of digital sockets on the Mega.
// LCD Mega Signal
// 18 Gnd Backlight draws 480 mAmps!
// 17 +5V
// 16 (53) not used
// 15 52 En2 -- enable the 2nd HD44780 chip which controls the bottom 2 rows of the display
// 14 51* +5V
// 13 50* Gnd
// 12 -- Contrast resistor to Gnd
// 11 48 RS
// 10 47* RW -- could be strapped to Gnd
// 9 46 En1 -- enable the 1st HD44780 which controls the top 2 rows
// 5-8 42-45* Data 0-3 not used in 4 bit modes
// 1-4 38-41 Data 4-7
//This mode for the 4x40 is not working now://LiquidCrystal lcd(48,47,46,52, 45,44,43,42, 41,40,39,38); // rs,rw,en1,en2, 8 data lines remember to set rw =255
//=========================================
//alternate versions to test for 2x24: I have not seen this one actually work.
//LiquidCrystal lcd(50,49,48, 47,46,45,44, 43,42,41,40); // rs,rw,en 8 data pins remember to set rw = 255 above
//LiquidCrystal lcd(50,49,48, 43,42,41,40); // rs,rw,en 4 data pins remember to set rw = 255 above
//LiquidCrystal lcd(50,48, 47,46,45,44, 43,42,41,40); // rs,en 8 data pins remember to set rw = 49 above -- these interfaces generally have unreliable initialization
//LiquidCrystal lcd(50,48, 43,42,41,40); // rs,en 4 data pins remember to set rw = 49 above -- these interfaces generally have unreliable initialization
//====2x24 LCD also has a non standard pinout and pins are numbered in the opposite direction:
// 1 53 Gnd
// 2 52 +5V
// 3 -- Contrast
// 4 50 RS
// 5 49 RW
// 6 48 EN
// 7-10 44-47 Data 0-3 not used in 4 bit mode
// 11-14 40-43 Data 4-7
// 15 -- Backlight +5v 147 mAmps!
// 16 -- Backlight Gnd
byte BACKLIGHT, BACKLTGND, POWER5V, GNDMain;
void setup(void) {
// set some digital pins to high and low to provide LCD with power and gnd:
// most of them: 2x16,4x20 4x16
BACKLIGHT = 27; // pin 27 will control the backlight //before I solder pins in, I check current on the backlight
BACKLTGND = 25; // PIN 25 will be set LOW to provide a Gnd for the backlight
POWER5V = 53; // we will set this HIGH to provide power on pin 2 of the LCD
GNDMain = 255; // next to pin 53 (in the pin "55" position) is a GND--pin 1 of the LCD goes there
if ((nColumns == 40) && (nRows ==4)) { //4x40
BACKLIGHT = 255; // Digital IO pins cannot control the backlight for the 4x40 double HD44780 LCD draws 480 mAmps !!
BACKLTGND = 255; //Arduino is limited to 40 mAmps
POWER5V = 51; // we will set this HIGH to provide power on pin 2 of the LCD
GNDMain = 50;
}
if ((nRows ==2) && (nColumns ==24) ) { //2x24
BACKLIGHT = 255; // the 2x24 draws 147 mAmps !!
BACKLTGND = 255; //
POWER5V = 53; // we will set this HIGH to provide power on pin 2 of the LCD
GNDMain = 52;
}
pinMode(POWER5V, OUTPUT); //We're using a digital out as a 5V power source for the LCD
digitalWrite(POWER5V, HIGH);
if (BACKLIGHT != 255) {
pinMode(BACKLIGHT, OUTPUT); //set 255 if you need to wire backlight to gnd bo high current draw
digitalWrite(BACKLIGHT, HIGH); // turn backlight on. Replace 'HIGH' with 'LOW' to turn it off.
pinMode(BACKLTGND, OUTPUT); //We're using a digital out as a GND for the backlight
digitalWrite(BACKLTGND,LOW);
}
if (GNDMain != 255) {
pinMode (GNDMain, OUTPUT);
digitalWrite(GNDMain, LOW);
}
if (rw != 255) {
pinMode(rw,OUTPUT);
digitalWrite(rw,LOW);
}
pinMode(13,OUTPUT);
randomSeed(analogRead(0)); //read unconnected pin to seed random number generator
lcd.begin(nColumns,nRows); //this is absolutely needed with this arrangement on the Mega--power was not
// applied to the LCD when it was initialized as lcd was instantiated above!!
}
void loop(void) { //this runs the LCD with the interface selected above through a fairly comprehensive series of tests
lcd.clear();
lcd.setCursor((nColumns>>1)-2,0);
lcd.print( (int)nColumns);
lcd.print(",");
lcd.print( (int)nRows);
delay(1000);
//mark the corners
lcd.setCursor(0,0);
lcd.print('1');
lcd.setCursor(nColumns-1,nRows-1);
lcd.print('4');
lcd.setCursor(nColumns-1,0);
lcd.print('2');
lcd.setCursor(0,nRows-1);
lcd.print('3');
lcd.setCursor((nColumns>>1)-3,0);
// lcd.print("corners ");
delay(1000);
lcd.setCursor((nColumns>>1)-3,0);
lcd.print(" scroll ");
uint8_t rand=random(150);
lcd.setCursor((nColumns>>1)-3,1);
lcd.print((int)rand);
int i = 0;
while (i < rand) {
lcd.scrollDisplayLeft();
i++;
delay(100);
}
// now we repeat the corner code to be sure we fixed the behavior of setCursor after scroll
delay(1000);
//mark the corners
lcd.setCursor(0,0);
lcd.print('a');
lcd.setCursor(nColumns-1,nRows-1);
lcd.print('d');
lcd.setCursor(nColumns-1,0);
lcd.print('b');
lcd.setCursor(0,nRows-1);
lcd.print('c');
lcd.setCursor((nColumns>>1)-3,0);
lcd.print("corners ");
delay(1000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print('1');
lcd.setCursor(nColumns-1,nRows-1);
lcd.print('4');
lcd.setCursor(nColumns-1,0);
lcd.print('3');
lcd.setCursor(0,nRows-1);
lcd.print('2');
lcd.setCursor((nColumns>>1)-3,0);
lcd.print("corners");
delay(1000);
lcd.setCursor((nColumns>>1)-3,1);
lcd.print(" scroll ");
rand = random(150);
lcd.setCursor((nColumns>>1)-3,2);
lcd.print((int) rand);
i = 0;
while (i < rand) {
lcd.scrollDisplayRight();
i++;
delay(100);
}
// now we repeat the corner code to be sure we fixed the behavior of setCursor after scroll
delay(1000);
//mark the corners -- all of these corner tests are good ways to find off by one errors!
lcd.setCursor(nColumns-1,nRows-1);
lcd.print('d');
lcd.setCursor(nColumns-1,0);
lcd.print('b');
lcd.setCursor(0,nRows-1);
lcd.print('c');
lcd.setCursor(0,0);
lcd.print('a');
lcd.setCursor((nColumns>>1)-3,0);
lcd.print("corners ");
delay(1000);
//Cursor on/off
lcd.clear();
lcd.setCursor (0,0);
lcd.print("Cursor off");
lcd.noCursor();
delay(1000);
// Turn on the cursor:
lcd.setCursor (0,0);
lcd.print("Cursor on ");
lcd.cursor();
delay(1000);
lcd.setCursor (0,nRows-1);
lcd.print("Cursor off");
lcd.noCursor();
delay(1000);
// Turn on the cursor:
lcd.setCursor (0,nRows-1);
lcd.print("Cursor on ");
lcd.cursor();
delay(1000);
//==enumerate lines on the display
lcd.clear();
i = 0;
while (i < nRows) {
lcd.setCursor(nColumns-8,i);
lcd.print("ROW ");
lcd.print(i+1);
i++;
}
delay(1000);
//=====try println
lcd.clear();
lcd.setCursor(0,0);
i = 0;
while (i < nRows) {
lcd.print("Println:# ");
lcd.println(i+1);
i++;
}
delay(1000);
//=====Line wrap demo:
lcd.clear();
lcd.setCursor(nColumns-4,0);
lcd.print("LINEWRAP01234567890");
delay(200);
if (nRows>=2) {
lcd.setCursor(nColumns-4,1);
lcd.print("linewrap01234567890");
delay(1000);
if (nRows >=4) {
lcd.setCursor(nColumns-4,3);
lcd.print("linewrap01234567890");
delay(200);
}
}
delay(1000);
i = 0;
while (i < 11) {
lcd.scrollDisplayLeft();
i++;
delay(100);
}
delay(1000);
lcd.home();
int length = nRows * nColumns;
lcd.setCursor(0,0);
char text[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
text[length] = '\0';
lcd.print(text); //here we are printing the entire screen with one long string lets you be sure that linewrap happens exactly as it should
delay(2000);
uint8_t a =0;
if ((nColumns == 8) && (nRows == 2) ) a=1; //This is a trick to make a 'crazy 8' 16x1 LCD work reasonably in a right to left language; I suppose it could be added to the library routine
// as a conditional but that seems like too much support. what happens is that we write the 2nd line first; when that fills with (8) characters
// it wraps onto the first line. This means that lcd.print("abcdefghijklmno"); will print from right to left as you desire.
lcd.clear();
lcd.rightToLeft();
lcd.setCursor(nColumns-1,a); //now we print it in right to left mode to test the same thing
lcd.print (text);
delay(3000);
lcd.leftToRight();
long startTime=millis(); //let's try to benchmark how fast we can go; this will give us an idea about speed of the various interfaces 4/8 bit and checking busy flag or not:
uint8_t repetitions = 20;
char blanks[]=" ";
blanks[length] = '\0';
while (repetitions--) { //fill every screen pixel with text, then fill every pixel with blanks and repeat.
lcd.setCursor(0,0);
lcd.print(text);
lcd.setCursor(0,0);
lcd.print(blanks);
}
long endTime = millis();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Benchmark took ");
lcd.setCursor(0,1);
lcd.print(endTime - startTime);
lcd.print(" millisecs.");
delay(5000);
//======setCursor===
// loop from ASCII 'a' to ASCII 'z':
lcd.home();
int thisLetter = 'a';
// loop over the rows:
for (int thisRow = 0; thisRow < nRows; thisRow++) {
// loop over the columns:
for (int thisCol = 0; thisCol < nColumns; thisCol++) {
// set the cursor position:
lcd.setCursor(thisCol,thisRow);
// print the letter:
lcd.print(thisLetter, BYTE);
thisLetter++;
if (thisLetter > 'z') thisLetter = 'a';
delay(100);
}
}
//========Autoscroll: -- my arch nemesis !
lcd.clear();
// set the cursor to (0,0):
lcd.setCursor(0, 0);
// print from 0 to 9:
lcd.print("Autoscroll");
for (char thisChar = '1'; thisChar < '9'; thisChar++) {
lcd.print(thisChar);
delay(100);
}
// set the cursor to (nColumns,1):
lcd.setCursor(0,1);
lcd.print("Autoscroll");
// set the display to automatically scroll:
lcd.autoscroll();
// print from 0 to 9:
for (int thisChar = 0; thisChar < 10; thisChar++) {
lcd.print(thisChar);
delay(100);
}
// turn off automatic scrolling
lcd.noAutoscroll();
if (nRows>2) {
//========Autoscroll: -- my arch nemesis !
// set the cursor to (0,0):
lcd.setCursor(0, nRows-2);
// print from 0 to 9:
lcd.print("Autoscroll");
for (char thisChar = '1'; thisChar < '9'; thisChar++) {
lcd.print(thisChar);
delay(100);
}
// set the cursor to (nColumns,1):
lcd.setCursor(0,nRows-1);
lcd.print("Autoscroll");
// set the display to automatically scroll:
lcd.autoscroll();
// print from 0 to 9:
for (int thisChar = 0; thisChar < 10; thisChar++) {
lcd.print(thisChar);
delay(200);
}
// turn off automatic scrolling
lcd.noAutoscroll();
}
//====== Turn on the blinking cursor:
lcd.clear();
lcd.setCursor(0,nRows-1);
lcd.print("Blinking Cursor");
lcd.blink();
delay(1000);
// Turn off the blinking cursor:
lcd.noBlink();
delay(1000);
lcd.setCursor(0,0);
lcd.print("Blinking Cursor");
lcd.blink();
delay(1000);
// Turn off the blinking cursor:
lcd.noBlink();
delay(1000);
//=====Turn display on and off:
lcd.clear();
lcd.setCursor(0,0);
lcd.print("turn display off");
delay(1000);
// Turn off the display:
lcd.noDisplay();
delay(2000);
lcd.setCursor(0,0);
lcd.print("Turn Display ON "); //sent to the LCD while the display is turned off.
// Turn on the display:
lcd.display();
delay(1000);
lcd.clear();
lcd.home();
lcd.setCursor(0,0);
lcd.print(" Shift under program control ");
// scroll 27 positions (display length + string length) to the left:
for (int positionCounter = 0; positionCounter < 27; positionCounter++) {
// scroll one position left:
lcd.scrollDisplayLeft();
// wait a bit:
delay(100);
}
// scroll 27 positions (display length + string length) to the right:
for (int positionCounter = 0; positionCounter < 27; positionCounter++) {
// scroll one position right:
lcd.scrollDisplayRight();
// wait a bit:
delay(100);
}
delay(1500);
//======Text direction
lcd.clear();
lcd.setCursor(0,0);
int thisChar ='a';
for (int i = 0;i!=30; i++) {
// reverse directions at 'm':
if (thisChar == 'm') {
// go right for the next letter
lcd.rightToLeft();
}
// reverse again at 's':
if (thisChar == 's') {
// go left for the next letter
lcd.leftToRight();
}
// reset at 'z':
if (thisChar > 'z') {
// go to (0,0):
lcd.home();
// start again at 0
thisChar = 'a';
}
// print the character
lcd.print(thisChar, BYTE);
delay(200);
//increment the letter:
thisChar++;
}
lcd.clear();
//======define charset
uint8_t bell[8] = {0x4,0xe,0xe,0xe,0x1f,0x0,0x4};
uint8_t note[8] = {0x2,0x3,0x2,0xe,0x1e,0xc,0x0};
uint8_t clock[8] = {0x0,0xe,0x15,0x17,0x11,0xe,0x0};
uint8_t heart[8] = {0x0,0xa,0x1f,0x1f,0xe,0x4,0x0};
uint8_t duck[8] = {0x0,0xc,0x1d,0xf,0xf,0x6,0x0};
uint8_t check[8] = {0x0,0x1,0x3,0x16,0x1c,0x8,0x0};
uint8_t cross[8] = {0x0,0x1b,0xe,0x4,0xe,0x1b,0x0};
uint8_t retarrow[8] = { 0x1,0x1,0x5,0x9,0x1f,0x8,0x4};
lcd.createChar(0, bell);
lcd.createChar(1, note);
lcd.createChar(2, clock);
lcd.createChar(3, heart);
lcd.createChar(4, duck);
lcd.createChar(5, check);
lcd.createChar(6, cross);
lcd.createChar(7, retarrow);
lcd.home();
i = 0;
lcd.clear();
while (i<nRows) {
lcd.setCursor(0,i);
lcd.print("user:");
for (int j=0; j<7; j++) {
lcd.print(j, BYTE);
}
i++;
}
delay(2000);
}
wyświetlacz firmy Optrex Dmc40457
Z biblioteką dla standardowych wyśw. działa jako 40x2 pierwsze 2 linie podając sygnał enable na E1 i pozostałe 2 linie na E2.