commit 018e981cc1ffeb724a453e4c8cc8b96586a47e22 Author: Patrick Valk Date: Mon Nov 7 11:38:51 2016 +0100 init diff --git a/README.md b/README.md new file mode 100644 index 0000000..9836a98 --- /dev/null +++ b/README.md @@ -0,0 +1,15 @@ +# Arduino-USB + +This is a personal driver/controller i wrote for lcdproc to controll a 4x40 hd44780 display through usb. + +I will post the driver module to lcdproc soon. + +It works by sending serial commands to the arduino, and is based on the works of the original `hd44780` driver in lcdproc by Benjamin Tse . + +## Tested on +* Arduino nano. + + +## Dependency +I moddified the original `LiquidCrystal` from Arduino LLC to work with 4x40 hd44780 displays, this means adding a second enable line. +This library is included in this repository. diff --git a/arduino/LiquidCrystal/README.adoc b/arduino/LiquidCrystal/README.adoc new file mode 100644 index 0000000..d51cee7 --- /dev/null +++ b/arduino/LiquidCrystal/README.adoc @@ -0,0 +1,24 @@ += Liquid Crystal Library for Arduino = + +This library allows an Arduino board to control LiquidCrystal displays (LCDs) based on the Hitachi HD44780 (or a compatible) chipset, which is found on most text-based LCDs. + +For more information about this library please visit us at +http://www.arduino.cc/en/Reference/LiquidCrystal + +== License == + +Copyright (c) Arduino LLC. All right reserved. + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA diff --git a/arduino/LiquidCrystal/examples/Autoscroll/Autoscroll.ino b/arduino/LiquidCrystal/examples/Autoscroll/Autoscroll.ino new file mode 100644 index 0000000..f70a1a7 --- /dev/null +++ b/arduino/LiquidCrystal/examples/Autoscroll/Autoscroll.ino @@ -0,0 +1,74 @@ +/* + LiquidCrystal Library - Autoscroll + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch demonstrates the use of the autoscroll() + and noAutoscroll() functions to make new text scroll or not. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystalAutoscroll + + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); +} + +void loop() { + // set the cursor to (0,0): + lcd.setCursor(0, 0); + // print from 0 to 9: + for (int thisChar = 0; thisChar < 10; thisChar++) { + lcd.print(thisChar); + delay(500); + } + + // set the cursor to (16,1): + lcd.setCursor(16, 1); + // set the display to automatically scroll: + lcd.autoscroll(); + // print from 0 to 9: + for (int thisChar = 0; thisChar < 10; thisChar++) { + lcd.print(thisChar); + delay(500); + } + // turn off automatic scrolling + lcd.noAutoscroll(); + + // clear screen for the next loop: + lcd.clear(); +} + diff --git a/arduino/LiquidCrystal/examples/Blink/Blink.ino b/arduino/LiquidCrystal/examples/Blink/Blink.ino new file mode 100644 index 0000000..fea13a3 --- /dev/null +++ b/arduino/LiquidCrystal/examples/Blink/Blink.ino @@ -0,0 +1,61 @@ +/* + LiquidCrystal Library - Blink + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch prints "Hello World!" to the LCD and makes the + cursor block blink. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystalBlink + + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // Print a message to the LCD. + lcd.print("hello, world!"); +} + +void loop() { + // Turn off the blinking cursor: + lcd.noBlink(); + delay(3000); + // Turn on the blinking cursor: + lcd.blink(); + delay(3000); +} + + diff --git a/arduino/LiquidCrystal/examples/Cursor/Cursor.ino b/arduino/LiquidCrystal/examples/Cursor/Cursor.ino new file mode 100644 index 0000000..8699d27 --- /dev/null +++ b/arduino/LiquidCrystal/examples/Cursor/Cursor.ino @@ -0,0 +1,61 @@ +/* + LiquidCrystal Library - Cursor + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch prints "Hello World!" to the LCD and + uses the cursor() and noCursor() methods to turn + on and off the cursor. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystalCursor + + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // Print a message to the LCD. + lcd.print("hello, world!"); +} + +void loop() { + // Turn off the cursor: + lcd.noCursor(); + delay(500); + // Turn on the cursor: + lcd.cursor(); + delay(500); +} + diff --git a/arduino/LiquidCrystal/examples/CustomCharacter/CustomCharacter.ino b/arduino/LiquidCrystal/examples/CustomCharacter/CustomCharacter.ino new file mode 100644 index 0000000..e70a949 --- /dev/null +++ b/arduino/LiquidCrystal/examples/CustomCharacter/CustomCharacter.ino @@ -0,0 +1,140 @@ +/* + LiquidCrystal Library - Custom Characters + + Demonstrates how to add custom characters on an LCD display. + The LiquidCrystal library works with all LCD displays that are + compatible with the Hitachi HD44780 driver. There are many of + them out there, and you can usually tell them by the 16-pin interface. + + This sketch prints "I Arduino!" and a little dancing man + to the LCD. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K potentiometer: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + * 10K poterntiometer on pin A0 + + created 21 Mar 2011 + by Tom Igoe + modified 11 Nov 2013 + by Scott Fitzgerald + + Based on Adafruit's example at + https://github.com/adafruit/SPI_VFD/blob/master/examples/createChar/createChar.pde + + This example code is in the public domain. + http://www.arduino.cc/en/Tutorial/LiquidCrystal + + Also useful: + http://icontexto.com/charactercreator/ + + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +// make some custom characters: +byte heart[8] = { + 0b00000, + 0b01010, + 0b11111, + 0b11111, + 0b11111, + 0b01110, + 0b00100, + 0b00000 +}; + +byte smiley[8] = { + 0b00000, + 0b00000, + 0b01010, + 0b00000, + 0b00000, + 0b10001, + 0b01110, + 0b00000 +}; + +byte frownie[8] = { + 0b00000, + 0b00000, + 0b01010, + 0b00000, + 0b00000, + 0b00000, + 0b01110, + 0b10001 +}; + +byte armsDown[8] = { + 0b00100, + 0b01010, + 0b00100, + 0b00100, + 0b01110, + 0b10101, + 0b00100, + 0b01010 +}; + +byte armsUp[8] = { + 0b00100, + 0b01010, + 0b00100, + 0b10101, + 0b01110, + 0b00100, + 0b00100, + 0b01010 +}; + +void setup() { + // initialize LCD and set up the number of columns and rows: + lcd.begin(16, 2); + + // create a new character + lcd.createChar(0, heart); + // create a new character + lcd.createChar(1, smiley); + // create a new character + lcd.createChar(2, frownie); + // create a new character + lcd.createChar(3, armsDown); + // create a new character + lcd.createChar(4, armsUp); + + // Print a message to the lcd. + lcd.print("I "); + lcd.write(byte(0)); // when calling lcd.write() '0' must be cast as a byte + lcd.print(" Arduino! "); + lcd.write((byte) 1); + +} + +void loop() { + // read the potentiometer on A0: + int sensorReading = analogRead(A0); + // map the result to 200 - 1000: + int delayTime = map(sensorReading, 0, 1023, 200, 1000); + // set the cursor to the bottom row, 5th position: + lcd.setCursor(4, 1); + // draw the little man, arms down: + lcd.write(3); + delay(delayTime); + lcd.setCursor(4, 1); + // draw him arms up: + lcd.write(4); + delay(delayTime); +} diff --git a/arduino/LiquidCrystal/examples/Display/Display.ino b/arduino/LiquidCrystal/examples/Display/Display.ino new file mode 100644 index 0000000..90b14f0 --- /dev/null +++ b/arduino/LiquidCrystal/examples/Display/Display.ino @@ -0,0 +1,61 @@ +/* + LiquidCrystal Library - display() and noDisplay() + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch prints "Hello World!" to the LCD and uses the + display() and noDisplay() functions to turn on and off + the display. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystalDisplay + + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // Print a message to the LCD. + lcd.print("hello, world!"); +} + +void loop() { + // Turn off the display: + lcd.noDisplay(); + delay(500); + // Turn on the display: + lcd.display(); + delay(500); +} + diff --git a/arduino/LiquidCrystal/examples/HelloWorld/HelloWorld.ino b/arduino/LiquidCrystal/examples/HelloWorld/HelloWorld.ino new file mode 100644 index 0000000..bf122d9 --- /dev/null +++ b/arduino/LiquidCrystal/examples/HelloWorld/HelloWorld.ino @@ -0,0 +1,60 @@ +/* + LiquidCrystal Library - Hello World + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch prints "Hello World!" to the LCD + and shows the time. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * LCD VSS pin to ground + * LCD VCC pin to 5V + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystal + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // Print a message to the LCD. + lcd.print("hello, world!"); +} + +void loop() { + // set the cursor to column 0, line 1 + // (note: line 1 is the second row, since counting begins with 0): + lcd.setCursor(0, 1); + // print the number of seconds since reset: + lcd.print(millis() / 1000); +} + diff --git a/arduino/LiquidCrystal/examples/Scroll/Scroll.ino b/arduino/LiquidCrystal/examples/Scroll/Scroll.ino new file mode 100644 index 0000000..0a4a95f --- /dev/null +++ b/arduino/LiquidCrystal/examples/Scroll/Scroll.ino @@ -0,0 +1,86 @@ +/* + LiquidCrystal Library - scrollDisplayLeft() and scrollDisplayRight() + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch prints "Hello World!" to the LCD and uses the + scrollDisplayLeft() and scrollDisplayRight() methods to scroll + the text. + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystalScroll + + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // Print a message to the LCD. + lcd.print("hello, world!"); + delay(1000); +} + +void loop() { + // scroll 13 positions (string length) to the left + // to move it offscreen left: + for (int positionCounter = 0; positionCounter < 13; positionCounter++) { + // scroll one position left: + lcd.scrollDisplayLeft(); + // wait a bit: + delay(150); + } + + // scroll 29 positions (string length + display length) to the right + // to move it offscreen right: + for (int positionCounter = 0; positionCounter < 29; positionCounter++) { + // scroll one position right: + lcd.scrollDisplayRight(); + // wait a bit: + delay(150); + } + + // scroll 16 positions (display length + string length) to the left + // to move it back to center: + for (int positionCounter = 0; positionCounter < 16; positionCounter++) { + // scroll one position left: + lcd.scrollDisplayLeft(); + // wait a bit: + delay(150); + } + + // delay at the end of the full loop: + delay(1000); + +} + diff --git a/arduino/LiquidCrystal/examples/SerialDisplay/SerialDisplay.ino b/arduino/LiquidCrystal/examples/SerialDisplay/SerialDisplay.ino new file mode 100644 index 0000000..ec46ff0 --- /dev/null +++ b/arduino/LiquidCrystal/examples/SerialDisplay/SerialDisplay.ino @@ -0,0 +1,65 @@ +/* + LiquidCrystal Library - Serial Input + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + 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 Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystalSerial + */ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // 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()); + } + } +} diff --git a/arduino/LiquidCrystal/examples/TextDirection/TextDirection.ino b/arduino/LiquidCrystal/examples/TextDirection/TextDirection.ino new file mode 100644 index 0000000..c838d81 --- /dev/null +++ b/arduino/LiquidCrystal/examples/TextDirection/TextDirection.ino @@ -0,0 +1,86 @@ +/* +LiquidCrystal Library - TextDirection + +Demonstrates the use a 16x2 LCD display. The LiquidCrystal +library works with all LCD displays that are compatible with the +Hitachi HD44780 driver. There are many of them out there, and you +can usually tell them by the 16-pin interface. + +This sketch demonstrates how to use leftToRight() and rightToLeft() +to move the cursor. + +The circuit: +* LCD RS pin to digital pin 12 +* LCD Enable pin to digital pin 11 +* 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 +* LCD R/W pin to ground +* 10K resistor: +* ends to +5V and ground +* wiper to LCD VO pin (pin 3) + +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 22 Nov 2010 +by Tom Igoe + +This example code is in the public domain. + +http://www.arduino.cc/en/Tutorial/LiquidCrystalTextDirection + +*/ + +// include the library code: +#include + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +int thisChar = 'a'; + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(16, 2); + // turn on the cursor: + lcd.cursor(); +} + +void loop() { + // 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.write(thisChar); + // wait a second: + delay(1000); + // increment the letter: + thisChar++; +} + + + + + + + + diff --git a/arduino/LiquidCrystal/examples/setCursor/setCursor.ino b/arduino/LiquidCrystal/examples/setCursor/setCursor.ino new file mode 100644 index 0000000..d2dae93 --- /dev/null +++ b/arduino/LiquidCrystal/examples/setCursor/setCursor.ino @@ -0,0 +1,72 @@ +/* + LiquidCrystal Library - setCursor + + Demonstrates the use a 16x2 LCD display. The LiquidCrystal + library works with all LCD displays that are compatible with the + Hitachi HD44780 driver. There are many of them out there, and you + can usually tell them by the 16-pin interface. + + This sketch prints to all the positions of the LCD using the + setCursor() method: + + The circuit: + * LCD RS pin to digital pin 12 + * LCD Enable pin to digital pin 11 + * 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 + * LCD R/W pin to ground + * 10K resistor: + * ends to +5V and ground + * wiper to LCD VO pin (pin 3) + + 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 22 Nov 2010 + by Tom Igoe + + This example code is in the public domain. + + http://www.arduino.cc/en/Tutorial/LiquidCrystalSetCursor + + */ + +// include the library code: +#include + +// these constants won't change. But you can change the size of +// your LCD using them: +const int numRows = 2; +const int numCols = 16; + +// initialize the library with the numbers of the interface pins +LiquidCrystal lcd(12, 11, 5, 4, 3, 2); + +void setup() { + // set up the LCD's number of columns and rows: + lcd.begin(numCols, numRows); +} + +void loop() { + // loop from ASCII 'a' to ASCII 'z': + for (int thisLetter = 'a'; thisLetter <= 'z'; thisLetter++) { + // loop over the columns: + for (int thisRow = 0; thisRow < numRows; thisRow++) { + // loop over the rows: + for (int thisCol = 0; thisCol < numCols; thisCol++) { + // set the cursor position: + lcd.setCursor(thisCol, thisRow); + // print the letter: + lcd.write(thisLetter); + delay(200); + } + } + } +} + + diff --git a/arduino/LiquidCrystal/keywords.txt b/arduino/LiquidCrystal/keywords.txt new file mode 100644 index 0000000..b6aa7fd --- /dev/null +++ b/arduino/LiquidCrystal/keywords.txt @@ -0,0 +1,38 @@ +####################################### +# Syntax Coloring Map For LiquidCrystal +####################################### + +####################################### +# Datatypes (KEYWORD1) +####################################### + +LiquidCrystal KEYWORD1 LiquidCrystal + +####################################### +# Methods and Functions (KEYWORD2) +####################################### + +begin KEYWORD2 +clear KEYWORD2 +home KEYWORD2 +print KEYWORD2 +setCursor KEYWORD2 +cursor KEYWORD2 +noCursor KEYWORD2 +blink KEYWORD2 +noBlink KEYWORD2 +display KEYWORD2 +noDisplay KEYWORD2 +autoscroll KEYWORD2 +noAutoscroll KEYWORD2 +leftToRight KEYWORD2 +rightToLeft KEYWORD2 +scrollDisplayLeft KEYWORD2 +scrollDisplayRight KEYWORD2 +createChar KEYWORD2 +setRowOffsets KEYWORD2 + +####################################### +# Constants (LITERAL1) +####################################### + diff --git a/arduino/LiquidCrystal/library.properties b/arduino/LiquidCrystal/library.properties new file mode 100644 index 0000000..7aa5b52 --- /dev/null +++ b/arduino/LiquidCrystal/library.properties @@ -0,0 +1,9 @@ +name=LiquidCrystal +version=1.0.2 +author=Arduino, Adafruit +maintainer=Arduino +sentence=Allows communication with alphanumerical liquid crystal displays (LCDs). For all Arduino boards. +paragraph=This library allows an Arduino board to control LiquidCrystal displays (LCDs) based on the Hitachi HD44780 (or a compatible) chipset, which is found on most text-based LCDs. The library works with in either 4 or 8 bit mode (i.e. using 4 or 8 data lines in addition to the rs, enable, and, optionally, the rw control lines). +category=Display +url=http://www.arduino.cc/en/Reference/LiquidCrystal +architectures=* diff --git a/arduino/LiquidCrystal/src/LiquidCrystal.cpp b/arduino/LiquidCrystal/src/LiquidCrystal.cpp new file mode 100644 index 0000000..0f9a383 --- /dev/null +++ b/arduino/LiquidCrystal/src/LiquidCrystal.cpp @@ -0,0 +1,551 @@ +#include "LiquidCrystal.h" + +#include +#include +#include +#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); +} + +// Custom initializer +LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable1, uint8_t enable2, + uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3) +{ + _enable_pin1 = enable1; + _enable_pin2 = enable2; + _d = 0; + init(1, rs, rw, enable1, 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::setController(int i) +{ + if (i >= 1) + _enable_pin = _enable_pin2; + else + _enable_pin = _enable_pin1; +} + +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; + + begin(16, 1); +} + +void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { + _numlines = lines; + + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + begin(cols, lines, dotsize); + setController(1); + begin(cols, lines, dotsize); + _d = 0; + return; + } + + if (lines > 1) { + _displayfunction |= LCD_2LINE; + } + + setRowOffsets(0x00, 0x40, 0x00 + cols, 0x40 + cols); + + // for some 1 line displays you can select a 10 pixel high font + if ((dotsize != LCD_5x8DOTS) && (lines == 1)) { + _displayfunction |= LCD_5x10DOTS; + } + + 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<((_displayfunction & LCD_8BITMODE) ? 8 : 4); ++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 before 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); + +} + +void LiquidCrystal::setRowOffsets(int row0, int row1, int row2, int row3) +{ + _row_offsets[0] = row0; + _row_offsets[1] = row1; + _row_offsets[2] = row2; + _row_offsets[3] = row3; +} + +/********** high level commands, for the user! */ +void LiquidCrystal::clear() +{ + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + clear(); + setController(1); + clear(); + _d = 0; + return; + } + + command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero + delayMicroseconds(2000); // this command takes a long time! +} + +void LiquidCrystal::home() +{ + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + home(); + setController(1); + home(); + _d = 0; + return; + } + + 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) +{ + if (row >= 2) + { + _enable_pin = _enable_pin1; + row -= 2; + } + else + _enable_pin = _enable_pin2; + + const size_t max_lines = sizeof(_row_offsets) / sizeof(*_row_offsets); + if ( row >= max_lines ) { + row = max_lines - 1; // we count rows starting w/0 + } + 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() { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + noDisplay(); + setController(1); + noDisplay(); + _d = 0; + return; + } + + _displaycontrol &= ~LCD_DISPLAYON; + command(LCD_DISPLAYCONTROL | _displaycontrol); +} +void LiquidCrystal::display() { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + display(); + setController(1); + display(); + _d = 0; + return; + } + + _displaycontrol |= LCD_DISPLAYON; + command(LCD_DISPLAYCONTROL | _displaycontrol); +} + +// Turns the underline cursor on/off +void LiquidCrystal::noCursor() { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + noCursor(); + setController(1); + noCursor(); + _d = 0; + return; + } + + _displaycontrol &= ~LCD_CURSORON; + command(LCD_DISPLAYCONTROL | _displaycontrol); +} +void LiquidCrystal::cursor() { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + cursor(); + setController(1); + cursor(); + _d = 0; + return; + } + + _displaycontrol |= LCD_CURSORON; + command(LCD_DISPLAYCONTROL | _displaycontrol); +} + +// Turn on and off the blinking cursor +void LiquidCrystal::noBlink() { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + noBlink(); + setController(1); + noBlink(); + _d = 0; + return; + } + + _displaycontrol &= ~LCD_BLINKON; + command(LCD_DISPLAYCONTROL | _displaycontrol); +} +void LiquidCrystal::blink() { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + blink(); + setController(1); + blink(); + _d = 0; + return; + } + + _displaycontrol |= LCD_BLINKON; + command(LCD_DISPLAYCONTROL | _displaycontrol); +} + +// These commands scroll the display without changing the RAM +void LiquidCrystal::scrollDisplayLeft(void) { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + scrollDisplayLeft(); + setController(1); + scrollDisplayLeft(); + _d = 0; + return; + } + + command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT); +} +void LiquidCrystal::scrollDisplayRight(void) { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + scrollDisplayRight(); + setController(1); + scrollDisplayRight(); + _d = 0; + return; + } + + command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT); +} + +// This is for text that flows Left to Right +void LiquidCrystal::leftToRight(void) { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + leftToRight(); + setController(1); + leftToRight(); + _d = 0; + return; + } + + _displaymode |= LCD_ENTRYLEFT; + command(LCD_ENTRYMODESET | _displaymode); +} + +// This is for text that flows Right to Left +void LiquidCrystal::rightToLeft(void) { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + rightToLeft(); + setController(1); + rightToLeft(); + _d = 0; + return; + } + + _displaymode &= ~LCD_ENTRYLEFT; + command(LCD_ENTRYMODESET | _displaymode); +} + +// This will 'right justify' text from the cursor +void LiquidCrystal::autoscroll(void) { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + autoscroll(); + setController(1); + autoscroll(); + _d = 0; + return; + } + + _displaymode |= LCD_ENTRYSHIFTINCREMENT; + command(LCD_ENTRYMODESET | _displaymode); +} + +// This will 'left justify' text from the cursor +void LiquidCrystal::noAutoscroll(void) { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + noAutoscroll(); + setController(1); + noAutoscroll(); + _d = 0; + return; + } + + _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[]) { + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + createChar(location, charmap); + setController(1); + createChar(location, charmap); + _d = 0; + return; + } + + 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) +{ + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + command(value); + setController(1); + command(value); + _d = 0; + return; + } + send(value, LOW); +} + +inline size_t LiquidCrystal::write(uint8_t value) +{ + if (_numlines == 4 && _d == 0) + { + _d = 1; + setController(0); + write(value); + setController(1); + write(value); + _d = 0; + return; + } + 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); + delayMicroseconds(1); + digitalWrite(_enable_pin, HIGH); + delayMicroseconds(1); // enable pulse must be >450ns + 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(); +} diff --git a/arduino/LiquidCrystal/src/LiquidCrystal.h b/arduino/LiquidCrystal/src/LiquidCrystal.h new file mode 100644 index 0000000..dbab221 --- /dev/null +++ b/arduino/LiquidCrystal/src/LiquidCrystal.h @@ -0,0 +1,116 @@ +#ifndef LiquidCrystal_h +#define LiquidCrystal_h + +#include +#include "Print.h" + +// 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 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 + +class LiquidCrystal : public Print { +public: + 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); + 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); + LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable, + uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3); + LiquidCrystal(uint8_t rs, uint8_t enable, + uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3); + LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable1, uint8_t enable2, + uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3); + + void 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); + + void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS); + + void clear(); + void home(); + + void noDisplay(); + void display(); + void noBlink(); + void blink(); + void noCursor(); + void cursor(); + void scrollDisplayLeft(); + void scrollDisplayRight(); + void leftToRight(); + void rightToLeft(); + void autoscroll(); + void noAutoscroll(); + + void setRowOffsets(int row1, int row2, int row3, int row4); + void createChar(uint8_t, uint8_t[]); + void setCursor(uint8_t, uint8_t); + virtual size_t write(uint8_t); + void command(uint8_t); + void setController(int i); + + using Print::write; +private: + + void send(uint8_t, uint8_t); + void write4bits(uint8_t); + void write8bits(uint8_t); + void pulseEnable(); + + uint8_t _rs_pin; // LOW: command. HIGH: character. + uint8_t _rw_pin; // LOW: write to LCD. HIGH: read from LCD. + uint8_t _enable_pin; // activated by a HIGH pulse. + uint8_t _enable_pin1; // activated by a HIGH pulse. + uint8_t _enable_pin2; // activated by a HIGH pulse. + uint8_t _data_pins[8]; + + uint8_t _displayfunction; + uint8_t _displaycontrol; + uint8_t _displaymode; + + uint8_t _initialized; + + uint8_t _numlines; + uint8_t _row_offsets[4]; + + uint8_t _d; +}; + +#endif diff --git a/arduino/hd44780_40X4-LCDPROC.ino b/arduino/hd44780_40X4-LCDPROC.ino new file mode 100644 index 0000000..eb44a24 --- /dev/null +++ b/arduino/hd44780_40X4-LCDPROC.ino @@ -0,0 +1,163 @@ +#include + +LiquidCrystal lcd(9, 8, 7, 6, 5, 4, 3, 2); + +int row = 0; +int line = 0; +bool controller = false; + +void setup() { + Serial.begin(115200); + // set up the LCD's number of columns and rows: + lcd.begin(40, 4); + lcd.clear(); + lcd.home(); +} + +#define LCDSERIALIZER_LCDI 0xFE + +byte serial_getch() { + int incoming; + while (Serial.available() == 0) { + } + // read the incoming byte: + incoming = Serial.read(); + //Serial.write(incoming); + + return (incoming & 0xff); +} + +void loop() { + byte rxbyte = serial_getch(); // Fetch byte + + if (rxbyte == LCDSERIALIZER_LCDI) // If LCD instruction + { + //Serial.write("[CMD]"); + + rxbyte = serial_getch(); // Fetch byte + + if (rxbyte == 0x01) + { + Serial.println("Clear screen"); + } + else if (rxbyte == 0x0c) + { + Serial.println("Restore the display (with cursor hidden)"); + } + else if (rxbyte == 0x08) + { + Serial.println("Blank the display (without clearing)"); + } + else if (rxbyte == 0x0c) + { + Serial.println("Make cursor invisible"); + } + else if (rxbyte == 0x0f) + { + Serial.println("Turn on visible blinking-block cursor"); + } + else if (rxbyte == 0x0e) + { + Serial.println("Turn on visible underline cursor"); + } + else if (rxbyte == 0x10) + { + Serial.println("Move cursor one character left"); + } + else if (rxbyte == 0x14) + { + Serial.println("Move cursor one character right"); + } + else if (rxbyte == 0x15) + { + Serial.println("(15)Move cursor one character right"); + } + else if (rxbyte == 0x02) + { + Serial.println("Home (move cursor to top/left character position)"); + } + else if (rxbyte == 0x18) + { + Serial.println("Scroll display one character left (all lines)"); + } + else if (rxbyte == 0x1e) + { + Serial.println("Scroll display one character right (all lines)"); + } + else if (rxbyte == 0x20) + { + Serial.println("Function set (4-bit interface, 1 line, 5*7 Pixels)"); + } + else if (rxbyte == 0x28) + { + Serial.println("Function set (4-bit interface, 2 lines, 5*7 Pixels)"); + } + else if (rxbyte == 0x30) + { + Serial.println("Function set (8-bit interface, 1 line, 5*7 Pixels)"); + } + else if (rxbyte == 0x38) + { + Serial.println("Function set (8-bit interface, 2 lines, 5*7 Pixels)"); + } + else if (rxbyte == 0x80) // set ddram address command. + { + serial_getch(); // instruction + row = serial_getch(); + serial_getch(); // instruction + line = serial_getch(); + + lcd.setCursor(line, row); + + Serial.println("Set Cursor to " + String(row) + "," + String(line)); + + return; + } + else if (rxbyte & 0x40) // set cgram address, cgram is custom character ram. + { + Serial.println("Set pointer in character-generator RAM (CG RAM address)"); + Serial.println("["); + + lcd.setController(0); + lcd.command(rxbyte); + lcd.setController(1); + lcd.command(rxbyte); + + // get custom char + for (int i = 0; i < 8; i++) + { + rxbyte = serial_getch(); // Fetch byte + + String thisString = String(rxbyte, HEX); + Serial.println(thisString); + + lcd.setController(0); + lcd.write(rxbyte); + lcd.setController(1); + lcd.write(rxbyte); + } + + Serial.println("]"); + + return; + } + else + { + // print byte. + String thisString = String(rxbyte, HEX); + Serial.println("UNKNOWN " + thisString); + } + + lcd.command(rxbyte); + } + else + { + // print byte. + //String thisString = String(rxbyte, HEX); + //Serial.println(thisString); + //Serial.println("position " + String(row) + " " + String(line)); + + lcd.write(rxbyte); + // line++; + } +} diff --git a/build lcdproc/driver/raspberry pi/hd44780.so b/build lcdproc/driver/raspberry pi/hd44780.so new file mode 100644 index 0000000..aa70064 Binary files /dev/null and b/build lcdproc/driver/raspberry pi/hd44780.so differ diff --git a/build lcdproc/driver/ubuntu 32/hd44780.so b/build lcdproc/driver/ubuntu 32/hd44780.so new file mode 100644 index 0000000..85e4beb Binary files /dev/null and b/build lcdproc/driver/ubuntu 32/hd44780.so differ diff --git a/instructions/LCDd.conf b/instructions/LCDd.conf new file mode 100644 index 0000000..fb8ec8c --- /dev/null +++ b/instructions/LCDd.conf @@ -0,0 +1,153 @@ +# LCDd.conf +# +# This file contains the configuration for the LCDd server. +# +# The format is ini-file-like. It is divided into sections that start at +# markers that look like [section]. Comments are all line-based comments, +# and are lines that start with '#' or ';'. +# +# The server has a 'central' section named [server]. For the menu there is +# a section called [menu]. Further each driver has a section which +# defines how the driver acts. +# +# The drivers are activated by specifiying them in a driver= line in the +# server section, like: +# +# Driver=curses +# +# This tells LCDd to use the curses driver. +# The first driver that is loaded and is capable of output defines the +# size of the display. The default driver to use is curses. +# If -d is specified on the command line, the Driver= options in the +# config file are ignored. +# +# The drivers read their own options from the respective sections. + + +## Server section with all kinds of settings for the LCDd server ## +[server] + +# Tells the server to load the given drivers. Multiple lines can be given. +# The name of the driver is exactly the same as the name of the driver +# module that is to be loaded, including the case of the letters ! +# (That is: unless a file= option is given in the driver section) +Driver=hd44780 + +# Tells the driver to bind to the given interface +Bind=127.0.0.1 + +# Listen on this specified port; defaults to 13666. +Port=13666 + +# Sets the reporting level; defaults to 2 (warnings and errors only). +#ReportLevel=3 + +# Should we report to syslog instead of stderr ? Default: no +#ReportToSyslog=yes + +# Sets the default time in seconds to displays a screen. +WaitTime=8 + +# User to run as. LCDd will drop its root priviledges, +# if any, and run as this user instead. +User=nobody + +# If yes, the the serverscreen will be rotated as a usual info screen. If no, +# it will be a background screen, only visible when no other screens are +# active. +ServerScreen=no + +# The server will stay in the foreground if set to true. +#Foreground=no + +# Where can we find the driver modules ? +# IMPORTANT: Make sure to change this setting to reflect your +# specific setup! Otherwise LCDd won't be able to find +# the driver modules and will thus not be able to +# function properly. +# NOTE: Always place a slash as last character ! +DriverPath=/usr/local/lib/lcdproc/ + +# The "...Key=" lines define what the server does with keypresses that +# don't go to any client. +# These are the defaults: +ToggleRotateKey=Enter +PrevScreenKey=Left +NextScreenKey=Right +#ScrollUpKey=Up +#ScrollDownKey=Down + +# If you have only 4 keys, you can choose to use this: +#ToggleRotateKey=Enter +#PrevScreenKey=Up +#NextScreenKey=Down + +# If you have only 3 keys, you can choose to use this: +#ToggleRotateKey=Enter +#PrevScreenKey=Up + + + +## The menu section. The menu is an internal LCDproc client. ## +[menu] +# You can configure what keys the menu should use. Note that the MenuKey +# will be reserved exclusively, the others work in shared mode. + +# The following works excellent with 4 keys or more. +MenuKey=Escape +EnterKey=Enter +UpKey=Up +DownKey=Down +# If you have 6 keys you may define these as well +#LeftKey=Left +#RightKey=Right + +# If you have only 3 keys, you could use something like this: +#MenuKey=Escape +#EnterKey=Enter +#DownKey=Down + + + +### Driver sections are below this line, in alphabetical order ### +## Hitachi HD44780 driver ## +[hd44780] + +# Port where the LPT is. Usual values are 0x278, 0x378 and 0x3BC +#Port=0x378 + +Device=/dev/serial/by-id/usb-1a86_USB2.0-Serial-if00-port0 + +# Select what type of connection. See documentation for types. +connectionType=lcdserializer +#connectionType=picanlcd + + +Speed=115200 + +RefreshDisplay=1 + +# Specifies the size of the LCD. +# In case of multiple combined displays, this should be the total size. +Size=40x4 + +# For multiple combined displays: how many lines does each display have. +# Vspan=2,2 means both displays have 2 lines. +#vspan=2,2 + +# If you have a KS0073 or an other 'almost HD44780-compatible', set this +# flag to get into extended mode (4-line linear). +# This flag is NOT the old obsolete Extended option. +#ExtendedMode=yes + +# If your display is slow and cannot keep up with the flow of data from +# LCDd, garbage can appear on the LCDd. Set this delay factor to 2 or 4 +# to increase the delays. Default: 1. +DelayMult=12 + +# You can reduce the inserted delays by setting this to false. +# On fast PCs it is possible your LCD does not respond correctly. +# Default: true. +DelayBus=false + +# EOF diff --git a/instructions/README.md b/instructions/README.md new file mode 100644 index 0000000..b1fc154 --- /dev/null +++ b/instructions/README.md @@ -0,0 +1,14 @@ +# copy/git lcdproc to server + +cd ./lcdproc +sudo apt-get install autoconf automake make build-essential pkg-config +sudo sh autogen.sh +./configure --prefix=/usr/local --enable-drivers=all +sudo make +sudo make install + + +# LCDd.conf driverpath= whereis lcdproc +copy /LCDd.conf to /usr/local/etc/ # whereis LCDd.conf +sudo LCDd +sudo lcdproc K \ No newline at end of file diff --git a/instructions/lcdproc.conf b/instructions/lcdproc.conf new file mode 100644 index 0000000..6c7c33d --- /dev/null +++ b/instructions/lcdproc.conf @@ -0,0 +1,148 @@ +# LCDproc client configuration file + +## general options ## +[lcdproc] +# address of the LCDd server to connect to +Server=localhost + +# Port of the server to connect to +Port=13666 + +# set reporting level +ReportLevel=2 + +# report to to syslog ? +ReportToSyslog=false + +# run in foreground [default: false; legal: true, false] +#Foreground=true + +# PidFile location when running as daemon [default: /var/run/lcdproc.pid] +#PidFile=/var/run/lcdproc.pid + +# slow down initial announcement of modes (in 1/100s) +#delay=2 + +# display name for the main menu [default: LCDproc HOST] +#DisplayName=lcdproc + + +## screen specific configuration options ## + +[CPU] +# Show screen +Active=True +OnTime=1 +OffTime=2 +ShowInvisible=false + + +[Iface] +# Show screen +Active=True + +# Show stats for Interface0 +Interface0=eth0 +# Interface alias name to display [default: ] +Alias0=ETH0 + +# Show stats for Interface1 +#Interface1=eth1 +#Alias1=WAN + +# Show stats for Interface2 +#Interface2=eth2 +#Alias2=MGMT + +# for more than 3 interfaces change MAX_INTERFACES in iface.h and rebuild + +# Units to display [default: byte; legal: byte, bit, packet] +unit=byte + +# add screen with transferred traffic +#transfer=TRUE + + +[Memory] +# Show screen +Active=True + + +[Load] +# Show screen +Active=True +# Min Load Avg at which the backlight will be turned off [default: 0.05] +LowLoad=0.05 +# Max Load Avg at which the backlight will start blinking [default: 1.3] +HighLoad=1.3 + + +[TimeDate] +# Show screen +Active=True +# time format [default: %H:%M:%S; legal: see strftime(3)] +TimeFormat="%H:%M:%S" +# date format [default: %x; legal: see strftime(3)] +DateFormat="%x" + + +[About] +# Show screen +Active=true + + +[SMP-CPU] +# Show screen +Active=true + + +[OldTime] +# Show screen +Active=false +# time format [default: %H:%M:%S; legal: see strftime(3)] +TimeFormat="%H:%M:%S" +# date format [default: %x; legal: see strftime(3)] +DateFormat="%x" +# Display the title bar in two-line mode. Note that with four lines or more +# the title is always shown. [default: true; legal: true, false] +#ShowTitle=false + + +[BigClock] +# Show screen +Active=true + + +[Uptime] +# Show screen +Active=true + + +[Battery] +# Show screen +Active=false + + +[CPUGraph] +# Show screen +Active=true + + +[ProcSize] +# Show screen +Active=true + + +[Disk] +# Show screen +Active=true + + +[MiniClock] +# Show screen +Active=false +# time format [default: %H:%M; legal: see strftime(3)] +TimeFormat="%H:%M" + + +# EOF