9 Replies Latest reply on Nov 2, 2014 9:34 AM by pulled_pork

    OSEPP LCD KEYPAD SHIELD

    eagamezg

      Hi guys, Do you know if just connecting power and ground signals to this shield is enough to see is my LCD has life? because at the moment, it seem like don't.

      Thank you.

        • 1. Re: OSEPP LCD KEYPAD SHIELD
          Clayton Hofrock

          In order for an LCD to light up, you usually need to connect power ground, and a signal for the LED backlight.

           

          Note, there is a known issue with Galileo and LCDs. Galileo LiquidCrystal Library Fixes

          • 2. Re: OSEPP LCD KEYPAD SHIELD
            eagamezg

            Thank you Clay, I'm not using any library. I figure it out a few days ago, this shield is a mess mapping its signals to physical pins.

            • 3. Re: OSEPP LCD KEYPAD SHIELD
              KenColey

              How did you correct this, because my LCD board causes my Galileo not to power up also?

               

              -Ken

              • 4. Re: OSEPP LCD KEYPAD SHIELD
                eagamezg

                First of all, the LCD signals arrangement are NOT mapped in the same physical order that we expect (one to one). Very funny by OSEPP vendor.

                So I took a multimeter and start finding the signals. Here are my findings, hope this help. Regardspin_arragement.png

                • 5. Re: OSEPP LCD KEYPAD SHIELD
                  JonM

                  If you have a previously loaded Sketch on the Galileo, that might cause an issue.  I initially had a Sketch loaded on mine for a Motor Control Shield and with the OSEPP installed it caused some funkiness.  I removed the LCD shield and using the docs and sample Sketch from the OSEPP web site, I created a Hello World sample and loaded that to the Galileo before installing the LCD Shield. 

                   

                  Basically I just modified the following line to accommodate the OSEPP shield pinout:

                  // select the pins used on the LCD panel

                  LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

                   

                  You could just remove the LCD Shield from the Galileo and then connect the 5v and GND to the Shield to ensure it powers on before connecting to the Galileo.  I bread boarded the shield before connecting myself.

                   

                  Cheers.

                  • 6. Re: OSEPP LCD KEYPAD SHIELD
                    KenColey

                    I have unloaded the sketch, taken the shield off and back on.  Nothing works on the galileo.  I have since purchased a stanard Arduino board using the ATmega chip and the LCD board powers up just fine.  Anyone know of pin incompatibilities on the Galileo boards that don't truely match the Arduino Uno specification?

                    • 7. Re: OSEPP LCD KEYPAD SHIELD
                      KenColey

                      Now, after installing on regular UNO board, it powers up on the Intel board.  Very strange.  More updates on Monday, after I fix the library code.

                      • 8. Re: OSEPP LCD KEYPAD SHIELD
                        manoelramon

                        Please

                         

                          On your installation dir, locate the file LiquidCrystal.cpp  in the path arduino/libraries/LiquidCrystal/src/ and replace for the code below. This is going to be integrated soon in the official IDE release but use this file as workaround.

                         

                         

                        #include "LiquidCrystal.h"

                         

                         

                        #include <stdio.h>

                        #include <string.h>

                        #include <inttypes.h>

                        #include "Arduino.h"

                         

                         

                        // When the display powers up, it is configured as follows:

                        //

                        // 1. Display clear

                        // 2. Function set:

                        //    DL = 1; 8-bit interface data

                        //    N = 0; 1-line display

                        //    F = 0; 5x8 dot character font

                        // 3. Display on/off control:

                        //    D = 0; Display off

                        //    C = 0; Cursor off

                        //    B = 0; Blinking off

                        // 4. Entry mode set:

                        //    I/D = 1; Increment by 1

                        //    S = 0; No shift

                        //

                        // Note, however, that resetting the Arduino doesn't reset the LCD, so we

                        // can't assume that its in that state when a sketch starts (and the

                        // LiquidCrystal constructor is called).

                         

                         

                        LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,

                              uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,

                              uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)

                        {

                          init(0, rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7);

                        }

                         

                         

                        LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,

                              uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,

                              uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)

                        {

                          init(0, rs, 255, enable, d0, d1, d2, d3, d4, d5, d6, d7);

                        }

                         

                         

                        LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,

                              uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)

                        {

                          init(1, rs, rw, enable, d0, d1, d2, d3, 0, 0, 0, 0);

                        }

                         

                         

                        LiquidCrystal::LiquidCrystal(uint8_t rs,  uint8_t enable,

                              uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)

                        {

                          init(1, rs, 255, enable, d0, d1, d2, d3, 0, 0, 0, 0);

                        }

                         

                         

                        void LiquidCrystal::init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,

                          uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,

                          uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)

                        {

                          _rs_pin = rs;

                          _rw_pin = rw;

                          _enable_pin = enable;

                         

                          _data_pins[0] = d0;

                          _data_pins[1] = d1;

                          _data_pins[2] = d2;

                          _data_pins[3] = d3;

                          _data_pins[4] = d4;

                          _data_pins[5] = d5;

                          _data_pins[6] = d6;

                          _data_pins[7] = d7;

                         

                         

                          if (fourbitmode)

                            _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;

                          else

                            _displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;

                         

                         

                        #ifndef __ARDUINO_X86__

                          begin(16, 1);

                        #endif 

                         

                         

                        }

                         

                         

                        void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {

                          if (lines > 1) {

                            _displayfunction |= LCD_2LINE;

                          }

                          _numlines = lines;

                          _currline = 0;

                         

                         

                          // for some 1 line displays you can select a 10 pixel high font

                          if ((dotsize != 0) && (lines == 1)) {

                            _displayfunction |= LCD_5x10DOTS;

                          }

                         

                         

                          // Deferred initialized from init()

                          pinMode(_rs_pin, OUTPUT);

                          // we can save 1 pin by not using RW. Indicate by passing 255 instead of pin#

                          if (_rw_pin != 255) {

                            pinMode(_rw_pin, OUTPUT);

                          }

                          pinMode(_enable_pin, OUTPUT);

                         

                          // Do these once, instead of every time a character is drawn for speed reasons.

                          for (int i=0; i<8; ++i)

                            pinMode(_data_pins[i], OUTPUT);

                         

                         

                          // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!

                          // according to datasheet, we need at least 40ms after power rises above 2.7V

                          // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50

                          delayMicroseconds(50000);

                          // Now we pull both RS and R/W low to begin commands

                          digitalWrite(_rs_pin, LOW);

                          digitalWrite(_enable_pin, LOW);

                          if (_rw_pin != 255) {

                            digitalWrite(_rw_pin, LOW);

                          }

                         

                          //put the LCD into 4 bit or 8 bit mode

                          if (! (_displayfunction & LCD_8BITMODE)) {

                            // this is according to the hitachi HD44780 datasheet

                            // figure 24, pg 46

                         

                         

                            // we start in 8bit mode, try to set 4 bit mode

                            write4bits(0x03);

                            delayMicroseconds(4500); // wait min 4.1ms

                         

                         

                            // second try

                            write4bits(0x03);

                            delayMicroseconds(4500); // wait min 4.1ms

                           

                            // third go!

                            write4bits(0x03);

                            delayMicroseconds(150);

                         

                         

                            // finally, set to 4-bit interface

                            write4bits(0x02);

                          } else {

                            // this is according to the hitachi HD44780 datasheet

                            // page 45 figure 23

                         

                         

                            // Send function set command sequence

                            command(LCD_FUNCTIONSET | _displayfunction);

                            delayMicroseconds(4500);  // wait more than 4.1ms

                         

                         

                            // second try

                            command(LCD_FUNCTIONSET | _displayfunction);

                            delayMicroseconds(150);

                         

                         

                            // third go

                            command(LCD_FUNCTIONSET | _displayfunction);

                          }

                         

                         

                          // finally, set # lines, font size, etc.

                          command(LCD_FUNCTIONSET | _displayfunction); 

                         

                         

                          // turn the display on with no cursor or blinking default

                          _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF; 

                          display();

                         

                         

                          // clear it off

                          clear();

                         

                         

                          // Initialize to default text direction (for romance languages)

                          _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;

                          // set the entry mode

                          command(LCD_ENTRYMODESET | _displaymode);

                         

                         

                        }

                         

                         

                        /********** high level commands, for the user! */

                        void LiquidCrystal::clear()

                        {

                          command(LCD_CLEARDISPLAY);  // clear display, set cursor position to zero

                          delayMicroseconds(2000);  // this command takes a long time!

                        }

                         

                         

                        void LiquidCrystal::home()

                        {

                          command(LCD_RETURNHOME);  // set cursor position to zero

                          delayMicroseconds(2000);  // this command takes a long time!

                        }

                         

                         

                        void LiquidCrystal::setCursor(uint8_t col, uint8_t row)

                        {

                          int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };

                          if ( row >= _numlines ) {

                            row = _numlines-1;    // we count rows starting w/0

                          }

                         

                          command(LCD_SETDDRAMADDR | (col + row_offsets[row]));

                        }

                         

                         

                        // Turn the display on/off (quickly)

                        void LiquidCrystal::noDisplay() {

                          _displaycontrol &= ~LCD_DISPLAYON;

                          command(LCD_DISPLAYCONTROL | _displaycontrol);

                        }

                        void LiquidCrystal::display() {

                          _displaycontrol |= LCD_DISPLAYON;

                          command(LCD_DISPLAYCONTROL | _displaycontrol);

                        }

                         

                         

                        // Turns the underline cursor on/off

                        void LiquidCrystal::noCursor() {

                          _displaycontrol &= ~LCD_CURSORON;

                          command(LCD_DISPLAYCONTROL | _displaycontrol);

                        }

                        void LiquidCrystal::cursor() {

                          _displaycontrol |= LCD_CURSORON;

                          command(LCD_DISPLAYCONTROL | _displaycontrol);

                        }

                         

                         

                        // Turn on and off the blinking cursor

                        void LiquidCrystal::noBlink() {

                          _displaycontrol &= ~LCD_BLINKON;

                          command(LCD_DISPLAYCONTROL | _displaycontrol);

                        }

                        void LiquidCrystal::blink() {

                          _displaycontrol |= LCD_BLINKON;

                          command(LCD_DISPLAYCONTROL | _displaycontrol);

                        }

                         

                         

                        // These commands scroll the display without changing the RAM

                        void LiquidCrystal::scrollDisplayLeft(void) {

                          command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);

                        }

                        void LiquidCrystal::scrollDisplayRight(void) {

                          command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);

                        }

                         

                         

                        // This is for text that flows Left to Right

                        void LiquidCrystal::leftToRight(void) {

                          _displaymode |= LCD_ENTRYLEFT;

                          command(LCD_ENTRYMODESET | _displaymode);

                        }

                         

                         

                        // This is for text that flows Right to Left

                        void LiquidCrystal::rightToLeft(void) {

                          _displaymode &= ~LCD_ENTRYLEFT;

                          command(LCD_ENTRYMODESET | _displaymode);

                        }

                         

                         

                        // This will 'right justify' text from the cursor

                        void LiquidCrystal::autoscroll(void) {

                          _displaymode |= LCD_ENTRYSHIFTINCREMENT;

                          command(LCD_ENTRYMODESET | _displaymode);

                        }

                         

                         

                        // This will 'left justify' text from the cursor

                        void LiquidCrystal::noAutoscroll(void) {

                          _displaymode &= ~LCD_ENTRYSHIFTINCREMENT;

                          command(LCD_ENTRYMODESET | _displaymode);

                        }

                         

                         

                        // Allows us to fill the first 8 CGRAM locations

                        // with custom characters

                        void LiquidCrystal::createChar(uint8_t location, uint8_t charmap[]) {

                          location &= 0x7; // we only have 8 locations 0-7

                          command(LCD_SETCGRAMADDR | (location << 3));

                          for (int i=0; i<8; i++) {

                            write(charmap[i]);

                          }

                        }

                         

                         

                        /*********** mid level commands, for sending data/cmds */

                         

                         

                        inline void LiquidCrystal::command(uint8_t value) {

                          send(value, LOW);

                        }

                         

                         

                        inline size_t LiquidCrystal::write(uint8_t value) {

                          send(value, HIGH);

                          return 1; // assume sucess

                        }

                         

                         

                        /************ low level data pushing commands **********/

                         

                         

                        // write either command or data, with automatic 4/8-bit selection

                        void LiquidCrystal::send(uint8_t value, uint8_t mode) {

                          digitalWrite(_rs_pin, mode);

                         

                         

                          // if there is a RW pin indicated, set it low to Write

                          if (_rw_pin != 255) {

                            digitalWrite(_rw_pin, LOW);

                          }

                         

                          if (_displayfunction & LCD_8BITMODE) {

                            write8bits(value);

                          } else {

                            write4bits(value>>4);

                            write4bits(value);

                          }

                        }

                         

                         

                        void LiquidCrystal::pulseEnable(void) {

                          digitalWrite(_enable_pin, LOW);

                        #ifndef __ARDUINO_X86__

                          delayMicroseconds(1);   

                        #endif 

                          digitalWrite(_enable_pin, HIGH);

                        #ifndef __ARDUINO_X86__ 

                          delayMicroseconds(1);    // enable pulse must be >450ns

                        #endif 

                          digitalWrite(_enable_pin, LOW);

                          delayMicroseconds(100);   // commands need > 37us to settle

                        }

                         

                         

                        void LiquidCrystal::write4bits(uint8_t value) {

                          for (int i = 0; i < 4; i++) {

                            digitalWrite(_data_pins[i], (value >> i) & 0x01);

                          }

                         

                         

                          pulseEnable();

                        }

                         

                         

                        void LiquidCrystal::write8bits(uint8_t value) {

                          for (int i = 0; i < 8; i++) {

                          digitalWrite(_data_pins[i], (value >> i) & 0x01);

                          }

                         

                          pulseEnable();

                        }

                        Many thanks

                        • 9. Re: OSEPP LCD KEYPAD SHIELD
                          pulled_pork

                          Hi,

                           

                          I saw the LCD fix for Galileo you posted on April 24th, 2014. Judging from the date, it should have been for Gen 1 Galileo since the Gen 2 was not yet released back then. Here is my question about this fix: I have a few DFRobot LCD shields and they work well on Gen 2 boards but cause "non-boot" problem on Gen 1 like KenColey reported on this thread. Is the replacement LiquidCrystal.cpp code you posted for Gen 1 only? or it should work for both Gen 1 and Gen 2? My Gen 2 boards work well with the as-is LiquidCrystal library files, I wonder if this fix for Gen 1 will still keep the Gen 2 working. I do not want to maintain two IDE for the two board models.... Thanks.

                           

                          Regards,

                          Pulled_Pork