-
        

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 12

Thema: Arduino Mega mit LCD I2C

  1. #1

    Arduino Mega mit LCD I2C

    Anzeige

    Moin, nachdem ich jetzt 3Tage lang das ganze Internet durchforstet habe und sämtliche Bibiliotheken ausprobiert habe, brauche ich doch euren Rat.

    Also Ich habe ein Arduino Mega 2560 und ein Liquid Crystal I2C Display beide von SainSmart

    Das Display habe ich an die 5V Power und der Masse des Boards, sowie die Pinne SDA mit Port 20 und SCL mit Port 21 verbunden.

    Ich komm mal zum Punkt:

    Ich kann mir mit unterschiedlichen Beispielprogrammen tolle Chinesische Zeichen und ähnliches über das ganze Display anzeigen lassen, aber sobald ich den Befehl Print benutzte und etwas in Klammern dahinter schreibe, schreibt das Display nur den ersten Buchstaben aus dem Befehl. Also wenn ich schreibe:

    lcd.print("Hello, World!"); Dann schreibt das Display nur ein H in die Zeile und lässt den rest unbeschrieben.

    Erst dachte ich, dass die Libery nicht ganz Kosch ist, aber nach Zahlosen tests mit unterschiedlichen Liberys bin ich mir auch nicht mehr ganz sicher.
    Lötstellen sehen soweit ganz gut aus, habe aber aktuell keinen Durchgangsprüfer hier um sie mal durch zu pieksen.


    Was habt ihr noch für Ideen, was es sein könnte?
    Rettet mir mein Weihnachten

    Lg Andreas
    Geändert von Ezekiel (27.12.2015 um 03:21 Uhr)

  2. #2
    Erfahrener Benutzer Roboter Genie Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    70
    Beiträge
    1.344
    schade, dass du keinen code postest, da könnte man evtl. was rauslesen ob es z.b. an der initialisierung liegt, oder sowas. Ich habe ein 20x4 I2C LCD display mit diesem code gut verwenden können, vergleiche mal mit deinem...

    Code:
    // Includes für das Display
    #include <Wire.h>
    #include <LCD.h>
    #include <LiquidCrystal_I2C.h>
    
    
    // Die Pin-Belegung des Displays
    #define BACKLIGHT_PIN  7
    #define En_pin  6
    #define Rw_pin  5
    #define Rs_pin  4
    #define D4_pin  0
    #define D5_pin  1
    #define D6_pin  2
    #define D7_pin  3
    
    
    #define  LED_OFF  1
    #define  LED_ON  0
    
    
    LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // Set the LCD I2C address
    
    
    
    
    // http://forum.arduino.cc/index.php?topic=156140.0
    
    
    byte val;
    
    
    void setup()
    {
       lcd.begin (16,2);  // Display initialisieren
    
    
      // Hintergrundbeleuchtung einschalten
      lcd.setBacklightPin(BACKLIGHT_PIN,NEGATIVE);
      lcd.setBacklight(LED_ON);  
    
    
      // Display bereit machen
      lcd.clear();
      lcd.home();  
      lcd.backlight();    // Beleuchtung einschalten
      lcd.setCursor(0,0); // Zeichen 1, Zeile 1
      lcd.print("serial-Empfang");   
      lcd.setCursor(0,1); // Zeichen 1, Zeile 2
     
     
     Serial.begin(9600);
     Serial1.begin(9600);
    }
    
    
    void loop()
    {
    if (Serial1.available())
    {
      val = Serial1.read();
      Serial.println(val,BIN);
           lcd.print(val);
      
      
      
    }
    }
    gruß inka

  3. #3
    Oh ja, sorry da hätte ich auch dran denken können^^

    hier mein Code:
    #include <LiquidCrystal_I2C.h>
    #include <Wire.h>


    LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x27 for a 16 chars and 2 line display

    void setup()
    {
    lcd.init();
    //lcd.begin(16,2);
    lcd.backlight();
    lcd.print("Hello");
    lcd.setCursor(2,1);
    lcd.print("World!");
    }

    Welche libary hast du unter #include <LCD.h> verwendet?

    Ich konnte den Code nicht testen, weil mir diese fehlte.

    Andere Beispiel Codes bei denen die Zeile LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); verwendet wurden, schlugen allerdings auch schon bei der Initialisierung fehl. Deswegen bin ich wieder zu der kürzereren Variante zurück gekehrt.
    Bei dem Fehlschlag war das Wort POSITIVE nicht erkannt worden.

    Danke schon mal

  4. #4
    Erfahrener Benutzer Roboter Genie Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    70
    Beiträge
    1.344
    ich muss mich in einem punkt korrigieren, das LCD ist 16x2 und nicht 20x4...

    LCD.h und LiquidCrystal_I2C.h sind m.e. nach die normalen libraries, vielleicht muss du beide includieren?

    und bitte code immer in die "code-tags" reinpacken..
    gruß inka

  5. #5
    Erfahrener Benutzer Roboter Genie Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    70
    Beiträge
    1.344
    hier die lcd.h:

    Code:
    // ---------------------------------------------------------------------------
    // Created by Francisco Malpartida on 20/08/11.
    // Copyright 2011 - Under creative commons license 3.0:
    //        Attribution-ShareAlike CC BY-SA
    //
    // This software is furnished "as is", without technical support, and with no 
    // warranty, express or implied, as to its usefulness for any purpose.
    //
    // Thread Safe: No
    // Extendable: Yes
    //
    // @file LCD.h
    // This file implements a basic liquid crystal library that comes as standard
    // in the Arduino SDK.
    // 
    // @brief 
    // This is a basic implementation of the LiquidCrystal library of the
    // Arduino SDK. This library is a refactored version of the one supplied
    // in the Arduino SDK in such a way that it simplifies its extension
    // to support other mechanism to communicate to LCDs such as I2C, Serial, SR, 
    // The original library has been reworked in such a way that this will be
    // the base class implementing all generic methods to command an LCD based
    // on the Hitachi HD44780 and compatible chipsets.
    //
    // This base class is a pure abstract class and needs to be extended. As reference,
    // it has been extended to drive 4 and 8 bit mode control, LCDs and I2C extension
    // backpacks such as the I2CLCDextraIO using the PCF8574* I2C IO Expander ASIC.
    //
    // The functionality provided by this class and its base class is identical
    // to the original functionality of the Arduino LiquidCrystal library.
    //
    // @version API 1.1.0
    //
    //
    // @author F. Malpartida - fmalpartida@gmail.com
    // ---------------------------------------------------------------------------
    #ifndef _LCD_H_
    #define _LCD_H_
    
    
    #if (ARDUINO <  100)
    #include <WProgram.h>
    #else
    #include <Arduino.h>
    #endif
    
    
    #include <inttypes.h>
    #include <Print.h>
    
    
    
    
    /*!
     @defined 
     @abstract   Enables disables fast waits for write operations for LCD
     @discussion If defined, the library will avoid doing un-necessary waits.
     this can be done, because the time taken by Arduino's slow digitalWrite
     operations. If fast digitalIO operations, comment this line out or undefine
     the mode.
     */
    #ifdef __AVR__
    #define FAST_MODE
    #endif
    
    
    /*!
     @function
     @abstract   waits for a given time in microseconds (compilation dependent).
     @discussion Waits for a given time defined in microseconds depending on
     the FAST_MODE define. If the FAST_MODE is defined the call will return
     inmediatelly.
     @param      uSec[in] time in microseconds.
     @result     None
     */
    inline static void waitUsec ( uint16_t uSec )
    {
    #ifndef FAST_MODE
       delayMicroseconds ( uSec );
    #endif // FAST_MODE
    }
    
    
    
    
    /*!
     @defined 
     @abstract   All these definitions shouldn't be used unless you are writing 
     a driver.
     @discussion All these definitions are for driver implementation only and
     shouldn't be used by applications.
     */
    // LCD Commands
    // ---------------------------------------------------------------------------
    #define LCD_CLEARDISPLAY        0x01
    #define LCD_RETURNHOME          0x02
    #define LCD_ENTRYMODESET        0x04
    #define LCD_DISPLAYCONTROL      0x08
    #define LCD_CURSORSHIFT         0x10
    #define LCD_FUNCTIONSET         0x20
    #define LCD_SETCGRAMADDR        0x40
    #define LCD_SETDDRAMADDR        0x80
    
    
    // flags for display entry mode
    // ---------------------------------------------------------------------------
    #define LCD_ENTRYRIGHT          0x00
    #define LCD_ENTRYLEFT           0x02
    #define LCD_ENTRYSHIFTINCREMENT 0x01
    #define LCD_ENTRYSHIFTDECREMENT 0x00
    
    
    // flags for display on/off and cursor control
    // ---------------------------------------------------------------------------
    #define LCD_DISPLAYON           0x04
    #define LCD_DISPLAYOFF          0x00
    #define LCD_CURSORON            0x02
    #define LCD_CURSOROFF           0x00
    #define LCD_BLINKON             0x01
    #define LCD_BLINKOFF            0x00
    
    
    // flags for display/cursor shift
    // ---------------------------------------------------------------------------
    #define LCD_DISPLAYMOVE         0x08
    #define LCD_CURSORMOVE          0x00
    #define LCD_MOVERIGHT           0x04
    #define LCD_MOVELEFT            0x00
    
    
    // flags for function set
    // ---------------------------------------------------------------------------
    #define LCD_8BITMODE            0x10
    #define LCD_4BITMODE            0x00
    #define LCD_2LINE               0x08
    #define LCD_1LINE               0x00
    #define LCD_5x10DOTS            0x04
    #define LCD_5x8DOTS             0x00
    
    
    
    
    // Define COMMAND and DATA LCD Rs (used by send method).
    // ---------------------------------------------------------------------------
    #define COMMAND                 0
    #define DATA                    1
    #define FOUR_BITS               2
    
    
    
    
    /*!
     @defined 
     @abstract   Defines the duration of the home and clear commands
     @discussion This constant defines the time it takes for the home and clear
     commands in the LCD - Time in microseconds.
     */
    #define HOME_CLEAR_EXEC      2000
    
    
    /*!
        @defined 
        @abstract   Backlight off constant declaration
        @discussion Used in combination with the setBacklight to swith off the
     LCD backlight. @set setBacklight
    */
    #define BACKLIGHT_OFF           0
    
    
    /*!
     @defined 
     @abstract   Backlight on constant declaration
     @discussion Used in combination with the setBacklight to swith on the
     LCD backlight. @set setBacklight
     */
    #define BACKLIGHT_ON          255
    
    
    
    
    /*!
     @typedef 
     @abstract   Define backlight control polarity
     @discussion Backlight control polarity. @see setBacklightPin.
     */
    typedef enum { POSITIVE, NEGATIVE } t_backlighPol;
    
    
    class LCD : public Print 
    {
    public:
       
       /*!
        @method
        @abstract   LiquidCrystal abstract constructor.
        @discussion LiquidCrystal class abstract constructor needed to create
        the base abstract class.
        */
       LCD ( );
       
       /*!
        @function
        @abstract   LCD initialization.
        @discussion Initializes the LCD to a given size (col, row). This methods
        initializes the LCD, therefore, it MUST be called prior to using any other
        method from this class.
        
        This method is abstract, a base implementation is available common to all LCD
        drivers. Should it not be compatible with some other LCD driver, a derived
        implementation should be done on the driver specif class.
        
        @param      cols[in] the number of columns that the display has
        @param      rows[in] the number of rows that the display has
        @param      charsize[in] character size, default==LCD_5x8DOTS
        */
       virtual void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS);
       
       /*!
        @function
        @abstract   Clears the LCD.
        @discussion Clears the LCD screen and positions the cursor in the upper-left 
        corner. 
        
        This operation is time consuming for the LCD.
        
        @param      none
        */
       void clear();
       
       /*!
        @function
        @abstract   Sets the cursor to the upper-left corner.
        @discussion Positions the cursor in the upper-left of the LCD. 
        That is, use that location in outputting subsequent text to the display. 
        To also clear the display, use the clear() function instead.
        
        This operation is time consuming for the LCD.
        
        @param      none
        */
       void home();
       
       /*!
        @function
        @abstract   Turns off the LCD display.
        @discussion Turns off the LCD display, without losing the text currently 
        being displayed on it.
        
        @param      none
        */
       void noDisplay();
       
       /*!
        @function
        @abstract   Turns on the LCD display.
        @discussion Turns on the LCD display, after it's been turned off with 
        noDisplay(). This will restore the text (and cursor location) that was on 
        the display prior to calling noDisplay().
        
        @param      none
        */
       void display();
       
       /*!
        @function
        @abstract   Turns off the blinking of the LCD cursor.
        
        @param      none
        */
       void noBlink();
       
       /*!
        @function
        @abstract   Display the cursor of the LCD.
        @discussion Display the blinking LCD cursor. If used in combination with 
        the cursor() function, the result will depend on the particular display.
        
        @param      none
        */
       void blink();
       
       /*!
        @function
        @abstract   Hides the LCD cursor.
        
        @param      none
        */
       void noCursor();
       
       /*!
        @function
        @abstract   Display the LCD cursor.
        @discussion Display the LCD cursor: an underscore (line) at the location 
        where the next character will be written.
        
        @param      none
        */
       void cursor();
       
       /*!
        @function
        @abstract   Scrolls the contents of the display (text and cursor) one space 
        to the left.
        
        @param      none
        */
       void scrollDisplayLeft();
       
       /*!
        @function
        @abstract   Scrolls the contents of the display (text and cursor) one space 
        to the right.
        
        @param      none
        */
       void scrollDisplayRight();
       
       /*!
        @function
        @abstract   Set the direction for text written to the LCD to left-to-right.
        @discussion Set the direction for text written to the LCD to left-to-right. 
        All subsequent characters written to the display will go from left to right, 
        but does not affect previously-output text.
        
        This is the default configuration.
        
        @param      none
        */
       void leftToRight();
       
       /*!
        @function
        @abstract   Set the direction for text written to the LCD to right-to-left.
        @discussion Set the direction for text written to the LCD to right-to-left. 
        All subsequent characters written to the display will go from right to left, 
        but does not affect previously-output text.
        
        left-to-right is the default configuration.
        
        @param      none
        */
       void rightToLeft();
       
       /*!
        @function
        @abstract   Moves the cursor one space to the left.
        @discussion 
        @param      none
        */   
       void moveCursorLeft();
       
       
       /*!
        @function
        @abstract   Moves the cursor one space to the right.
        
        @param      none
        */
       void moveCursorRight();
       
       /*!
        @function
        @abstract   Turns on automatic scrolling of the LCD.
        @discussion Turns on automatic scrolling of the LCD. This causes each 
        character output to the display to push previous characters over by one 
        space. If the current text direction is left-to-right (the default), 
        the display scrolls to the left; if the current direction is right-to-left, 
        the display scrolls to the right. 
        This has the effect of outputting each new character to the same location on 
        the LCD.
        
        @param      none
        */
       void autoscroll();
       
       /*!
        @function
        @abstract   Turns off automatic scrolling of the LCD.
        @discussion Turns off automatic scrolling of the LCD, this is the default
        configuration of the LCD.
        
        @param      none
        */
       void noAutoscroll();
       
       /*!
        @function
        @abstract   Creates a custom character for use on the LCD.
        @discussion Create a custom character (glyph) for use on the LCD. 
        Most chipsets only support up to eight characters of 5x8 pixels. Therefore,
        this methods has been limited to locations (numbered 0 to 7). 
        
        The appearance of each custom character is specified by an array of eight 
        bytes, one for each row. The five least significant bits of each byte 
        determine the pixels in that row. To display a custom character on screen, 
        write()/print() its number, i.e. lcd.print (char(x)); // Where x is 0..7.
        
        @param      location[in] LCD memory location of the character to create
        (0 to 7)
        @param      charmap[in] the bitmap array representing each row of the character.
        */
       void createChar(uint8_t location, uint8_t charmap[]);
       
       /*!
        @function
        @abstract   Position the LCD cursor.
        @discussion Sets the position of the LCD cursor. Set the location at which 
        subsequent text written to the LCD will be displayed.
        
        @param      col[in] LCD column
        @param      row[in] LCD row - line.
        */
       void setCursor(uint8_t col, uint8_t row);
       
       /*!
        @function
        @abstract   Switch-on the LCD backlight.
        @discussion Switch-on the LCD backlight.
        The setBacklightPin has to be called before setting the backlight for
        this method to work. @see setBacklightPin. 
        */
       void backlight ( void );
       
       /*!
        @function
        @abstract   Switch-off the LCD backlight.
        @discussion Switch-off the LCD backlight.
        The setBacklightPin has to be called before setting the backlight for
        this method to work. @see setBacklightPin. 
        */   
       void noBacklight ( void );
       
       /*!
        @function
        @abstract   Switch on the LCD module.
        @discussion Switch on the LCD module, it will switch on the LCD controller
        and the backlight. This method has the same effect of calling display and
        backlight. @see display, @see backlight
        */
       void on ( void );
    
    
       /*!
        @function
        @abstract   Switch off the LCD module.
        @discussion Switch off the LCD module, it will switch off the LCD controller
        and the backlight. This method has the same effect of calling noDisplay and
        noBacklight. @see display, @see backlight
        */   
       void off ( void );
       
       //
       // virtual class methods
       // --------------------------------------------------------------------------
       /*!
        @function
        @abstract   Sets the pin to control the backlight.
        @discussion Sets the pin in the device to control the backlight.
        This method is device dependent and can be programmed on each subclass. An 
        empty function call is provided that does nothing.
        
        @param      value: pin associated to backlight control.
        @param      pol: backlight polarity control (POSITIVE, NEGATIVE)
        */
       virtual void setBacklightPin ( uint8_t value, t_backlighPol pol ) { };
       
       /*!
        @function
        @abstract   Sets the pin to control the backlight.
        @discussion Sets the pin in the device to control the backlight. The behaviour
        of this method is very dependent on the device. Some controllers support
        dimming some don't. Please read the actual header file for each individual
        device. The setBacklightPin method has to be called before setting the backlight
        or the adequate backlight control constructor.
        @see setBacklightPin.
        
        NOTE: The prefered methods to control the backlight are "backlight" and
        "noBacklight".
        
        @param      0..255 - the value is very dependent on the LCD. However, 
        BACKLIGHT_OFF will be interpreted as off and BACKLIGHT_ON will drive the
        backlight on.
        */
       virtual void setBacklight ( uint8_t value ) { };
       
       /*!
        @function
        @abstract   Writes to the LCD.
        @discussion This method writes character to the LCD in the current cursor
        position.
        
        This is the virtual write method, implemented in the Print class, therefore
        all Print class methods will end up calling this method.
        
        @param      value[in] Value to write to the LCD.
        */
    #if (ARDUINO <  100)
       virtual void write(uint8_t value);
    #else
       virtual size_t write(uint8_t value);
    #endif
       
    #if (ARDUINO <  100)
       using Print::write;
    #else
       using Print::write;
    #endif   
       
    protected:
       // Internal LCD variables to control the LCD shared between all derived
       // classes.
       uint8_t _displayfunction;  // LCD_5x10DOTS or LCD_5x8DOTS, LCD_4BITMODE or 
                                  // LCD_8BITMODE, LCD_1LINE or LCD_2LINE
       uint8_t _displaycontrol;   // LCD base control command LCD on/off, blink, cursor
                                  // all commands are "ored" to its contents.
       uint8_t _displaymode;      // Text entry mode to the LCD
       uint8_t _numlines;         // Number of lines of the LCD, initialized with begin()
       uint8_t _cols;             // Number of columns in the LCD
       t_backlighPol _polarity;   // Backlight polarity
       
    private:
       /*!
        @function
        @abstract   Send a command to the LCD.
        @discussion This method sends a command to the LCD by setting the Register
        select line of the LCD.
        
        This command shouldn't be used to drive the LCD, only to implement any other
        feature that is not available on this library.
        
        @param      value[in] Command value to send to the LCD (COMMAND, DATA or
        FOUR_BITS).
        */
       void command(uint8_t value);
    
    
       /*!
        @function
        @abstract   Send a particular value to the LCD.
        @discussion Sends a particular value to the LCD. This is a pure abstract
        method, therefore, it is implementation dependent of each derived class how
        to physically write to the LCD.
        
        Users should never call this method.
        
        @param      value[in] Value to send to the LCD.
        @result     mode LOW - write to the LCD CGRAM, HIGH - write a command to
        the LCD.
        */
    #if (ARDUINO <  100)
       virtual void send(uint8_t value, uint8_t mode) { };
    #else
       virtual void send(uint8_t value, uint8_t mode) = 0;
    #endif
       
    };
    
    
    #endif
    gruß inka

  6. #6
    Also ich habe jetzt die LCD.h datei mit dem Texteditor und dem Code von dir, erstellt und in einem Ordner der LCD hieß in Verzeichnis libaries unter den Dokumenten abgespeichert.

    Dann habe ich deine Implementierung und deklaration der Pinne übernommen. Das ganze sah dann so aus:

    Code:
    // Includes für das Display
    #include <Wire.h>
    #include <LCD.h>
    #include <LiquidCrystal_I2C.h>
    
    
    // Die Pin-Belegung des Displays
    #define BACKLIGHT_PIN  7
    #define En_pin  6
    #define Rw_pin  5
    #define Rs_pin  4
    #define D4_pin  0
    #define D5_pin  1
    #define D6_pin  2
    #define D7_pin  3
    
    
    #define  LED_OFF  1
    #define  LED_ON  0
    
    
    LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // Set the LCD I2C address
    void setup()
    {
     lcd.init();
    //lcd.begin(16,2);
     lcd.backlight();
      lcd.print("Hello");
      lcd.setCursor(2,1);
      lcd.print("World!");
    }
    danach wurde mir die Fehlermeldung:

    "cc1plus.exe: out of memory allocating 1677721600 bytes

    exit status 1
    Fehler beim Kompilieren."

    ausgegeben.

    Nach einer kurzen Suche mit diesem Ergebnis: http://stackoverflow.com/questions/1...ed-header-file

    verstehe ich das so, dass mit den eingebundenen Libaries nun das Maximum an möglichen zu Kompilierenden Bytes überschritten wurde.

    Sorry, dass ich kein Codetag benutzt habe, bin noch ganz neu in der Szene und muss nun mein uraltes Wissen ausgraben.

  7. #7
    Erfahrener Benutzer Roboter Genie Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    49
    Beiträge
    1.242
    Irgendwas wild zusammenkopieren klappt seltener, als man denkt....

    Code:
    #include <Wire.h>
    #include <LCD.h>
    #include <LiquidCrystal_I2C.h>
    
    LiquidCrystal_I2C    lcd(0x27,2,1,0,4,5,6,7);
    
    void setup()
    {
     lcd.begin (16,2); //  beim 20x4 natürlich entsprechend ändern
     
    lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
    lcd.setBacklight(HIGH);//ohne Beleuchtung sieht man nich viel
    lcd.setCursor(0,0);
    lcd.print("Funktioniert?");  
    }
    void loop()
    {
    
    //nichts weiter zu tun hier
    }
    Damit laufen meine 16x2er und 20x4er problemlos.
    Allerdings ist der Backlight-Jumper gesetzt, sonst klappt das so nicht!
    Wenn man die Beleuchtung dimmen will, muss der Jumper raus, dann kann man da ne PWM dran geben (ich bin grad nicht sicher, ob da noch nen Vorwiderstand nötig war, das hab ich gaaanz früher mal gemacht gehabt).
    Gerüchte besagen, dass die Adresse des Displays (bzw. des I2C-Rucksackes) auch mal ne andere sein kann, dazu gibts den I2C-Scanner.
    Geändert von Rabenauge (26.12.2015 um 22:27 Uhr)
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

  8. #8
    Erfahrener Benutzer Roboter Genie Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    70
    Beiträge
    1.344
    ich habe auch ein wenig experimentiert, habe vor kurzem nämlich die IDE 1.0.5 durch die 1.6.6 ersetzt und die hat ein wenig anderes library-management. Die LCD.h ist bestandteil der library von Francisco Malpartida vom 20/08/11.

    hier kannst du die auch runterladen...
    gruß inka

  9. #9
    Okay, ich habs nun endlich....https://arduino-info.wikispaces.com/LCD-Blue-I2C

    hat eine gute Beschreibung. Mit euren Codes hat es leider auch nicht ganz geklappt. Habe wohl einen anderen Typ gehabt.

    Vielen dank für die Mühe! Es war übrigens Version 1

  10. #10
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    17.02.2009
    Ort
    Aachen
    Beiträge
    1.055
    Die "Liquid Crystal I2C" ist in der neusten Version für die neue Arduino-IDE angepasst.
    In der alten Version wurde ein Rückgabewert in der Library nicht kompatibel zur neuen Lib gesetzt.
    Einfach mal die Lib neu herunterladen und (Wichtig) Duplikate der alten Library löschen. Dann geht wieder alles.

    Solltet ihr die Auto-Update-Version der neuen Arduino-IDE genutzt haben, bestenen etwaige Kopien der Lib nicht nut im Lib-Folder, sondern auch in dem Verzeichnis, das unter File => Preferences unter "Sketchbook location" angegeben ist. Das rauszufinden hat mich einige Nerven gekostet

    Das passende Issue findet man hier: https://github.com/fdebrabander/Ardu...brary/issues/2

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Phoenix_PS2_SSC32 Arduino Mega
    Von Ownnemesis im Forum Arduino -Plattform
    Antworten: 6
    Letzter Beitrag: 15.10.2015, 18:54
  2. Arduino Mega und Due am Lego NXT
    Von HaWe im Forum Eigene fertige Schaltungen und Bauanleitungen
    Antworten: 0
    Letzter Beitrag: 02.01.2015, 12:37
  3. Arduino Mega Matrix
    Von oel im Forum Arduino -Plattform
    Antworten: 16
    Letzter Beitrag: 04.10.2014, 17:11
  4. Arduino UNO, MEGA und Bascom
    Von Ripper121 im Forum Arduino -Plattform
    Antworten: 1
    Letzter Beitrag: 27.03.2013, 17:57
  5. 2 x HDMM01 auf Arduino Mega
    Von arnoa im Forum Sensoren / Sensorik
    Antworten: 2
    Letzter Beitrag: 08.02.2012, 17:19

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •