Elektroda.pl
Elektroda.pl
X
Elektroda.pl
Please add exception to AdBlock for elektroda.pl.
If you watch the ads, you support portal and users.

Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2

21 Sep 2015 10:28 3996 9
  • Level 12  
    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:
    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.
  • Level 12  
    wynik przy kompilacji bez żadnych modyfikacji dla TestLCD:

    Code:











    In file included from LCDtest.ino:1:
    C:\Users\Dell\Documents\Arduino\libraries\Liquidcrystal440/LiquidCrystal440.h:95: error: conflicting return type specified for 'virtual void LiquidCrystal::write(uint8_t)'
    C:\Program Files\Arduino106\hardware\arduino\cores\arduino/Print.h:48: error:   overriding 'virtual size_t Print::write(uint8_t)'
    LCDtest.ino: In function 'void loop()':
    LCDtest:323: error: 'BYTE' was not declared in this scope
    Od wersji Arduino 1.0, słowo 'BYTE' nie jest wspierane.
    Użyj proszę funkcji Serial.write()
    LCDtest:457: error: 'BYTE' was not declared in this scope
    Od wersji Arduino 1.0, słowo 'BYTE' nie jest wspierane.
    Użyj proszę funkcji Serial.write()
    LCDtest:492: error: 'BYTE' was not declared in this scope
    Od wersji Arduino 1.0, słowo 'BYTE' nie jest wspierane.
    Użyj proszę funkcji Serial.write()


    już nie rozchodzi się o nr wyprowadzeń jak zapewne ktoś zauważy że podane są dla Mega prawdopodobnie, tylko o komunikaty "virtual .. void size.. itp" mam nadzieję że znajdzie się ktoś kto wyjaśni w czym problem i jak rozwiązać go.
  • Level 12  
    mam zainstalowaną wersję 1.6.1 i 1.0.6. obydwie wyrzucają ten sam błąd, to są jeszcze starsze dostępne wersje?
  • Moderator of Microcontroller designs
    Kompilator dokładnie ci pisze co jest nie tak. Na zachętę - nie pasuje mu, że klasa LiquidCrystal pokrywa czystą metodę wirtualną klasy Print, lecz zadeklarowaną z innym typem wyniku. Masz:
    virtual void LiquidCrystal::write(uint8_t);
    podczas, gdy w klasie bazowej jest:
    virtual size_t Print::write(uint8_t) = 0;
    O ile C++ wspiera przeciążanie funkcji, to nie można przeciążać robiąc te same argumenty, ale inny typ wyniku.
  • Level 12  
    faktyczni w wersji Arduino 0017 nie wyskakuje błąd. dzięki

    Rozumie ze poprawiona biblioteka umożliwi kompilację na nowszej wersji

    Dodano po 1 [godziny] 28 [minuty]:

    Ok wszystko działa na IDE Arduino 1.6.5 z Biblioteką LiquidCrystalFast. Problem tkwił w wyrwanym z pinu kablu który nie zauważyłem a był od E2
  • Level 12  
    Dziękuję uzi18, ta biblioteka L..C..fast działa dobrze więc pozostanę przy niej. Chyba że spróbuję pobawić się z I2C.

    wstawiam przykładowy kod (wpisywanie dowolnej treści z Serial Monitor na wyświetlacz 40x4)

    Code:

    /*
      LiquidCrystalFast Library - Serial Input
     
     Demonstrates the use a 40x4 LCD display.  The LiquidCrystalFast
     library works with all LCD displays that are compatible with the TwO
     Hitachi HD44780 driver. There are many of them out there, and you
     can usually tell them by the 16-pin interface.
     
     This sketch displays text sent over the serial port
     (e.g. from the Serial Monitor) on an attached LCD.
     
     The circuit:
     * LCD RS pin to digital pin 12
     * LCD WR pin to digital pin 11
     * LCD Enable1 pin to digital pin 10
     * LCD Enable2 pin to digital pin  9
     * LCD D4 pin to digital pin 5
     * LCD D5 pin to digital pin 4
     * LCD D6 pin to digital pin 3
     * LCD D7 pin to digital pin 2
     * 10K resistor:
     * ends to +5V and ground

     
     Library originally added 18 Apr 2008
     by David A. Mellis
     library modified 5 Jul 2009
     by Limor Fried (http://www.ladyada.net)
     example added 9 Jul 2009
     by Tom Igoe
     modified 25 July 2009
     by David A. Mellis

     http://www.pjrc.com/teensy/td_libs_LiquidCrystal.html
     http://www.arduino.cc/en/Tutorial/LiquidCrystal
     */

    // include the library code:
    #include <LiquidCrystalFast.h>

    // initialize the library with the numbers of the interface pins
    LiquidCrystalFast lcd(12, 11, 10, 9, 5, 4, 3, 2);
             // LCD pins: RS  RW  E1 E2  D4 D5 D6 D7

    void setup(){
        // set up the LCD's number of rows and columns:
      lcd.begin(40, 4);
      // initialize the serial communications:
      Serial.begin(9600);
    }

    void loop()
    {
      // when characters arrive over the serial port...
      if (Serial.available()) {
        // wait a bit for the entire message to arrive
        delay(100);
        // clear the screen
        lcd.clear();
        // read all the available characters
        while (Serial.available() > 0) {
          // display each character to the LCD
          lcd.write(Serial.read());
        }
      }
    }


    Przykładowe grafiki ASCII Art wysłane z Serial Monitor, nie wyświetla poprawnie tylko "\" ale to pewnie wina samej konsoli.

    Wykonano generatorem OnLine

    Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2
    Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2 Leonardo - LCD 40x4,biblioteka LiquidCrystal440 - nie kompiluje kodu, hd44780 x2