tylen/ESP-Ventilation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lcd: add internal columns, rows

Browse Source
This commit is contained in:
Vasily Davydov 2022-10-16 11:26:59 +03:00
parent eec05297a3
commit 243766044c
2 changed files with 235 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
LiquidCrystal/inc/LiquidCrystal.h
View File

@ -1,11 +1,11 @@
#ifndef LiquidCrystal_h #ifndef LiquidCrystal_h
#define LiquidCrystal_h #define LiquidCrystal_h
#include "DigitalIoPin.h"
#include "chip.h"
#include <cstddef> #include <cstddef>
#include <string> #include <string>
#include "chip.h"
#include "DigitalIoPin.h"
// commands // commands
#define LCD_CLEARDISPLAY 0x01 #define LCD_CLEARDISPLAY 0x01
@ -45,43 +45,43 @@
#define LCD_5x10DOTS 0x04 #define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00 #define LCD_5x8DOTS 0x00
class LiquidCrystal { class LiquidCrystal
{
public: public:
LiquidCrystal (DigitalIoPin *rs, DigitalIoPin *enable, DigitalIoPin *d0,
DigitalIoPin *d1, DigitalIoPin *d2, DigitalIoPin *d3);
LiquidCrystal(DigitalIoPin *rs, DigitalIoPin *enable, void begin (uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS);
DigitalIoPin *d0, DigitalIoPin *d1, DigitalIoPin *d2, DigitalIoPin *d3);
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS); void clear ();
void home ();
void clear(); void noDisplay ();
void home(); void display ();
void noBlink ();
void blink ();
void noCursor ();
void cursor ();
void scrollDisplayLeft ();
void scrollDisplayRight ();
void leftToRight ();
void rightToLeft ();
void autoscroll ();
void noAutoscroll ();
void noDisplay(); void createChar (uint8_t, uint8_t[]);
void display(); void setCursor (uint8_t, uint8_t);
void noBlink(); virtual size_t write (uint8_t);
void blink(); void command (uint8_t);
void noCursor(); void print (std::string const &s);
void cursor(); void print (const char *s);
void scrollDisplayLeft();
void scrollDisplayRight();
void leftToRight();
void rightToLeft();
void autoscroll();
void noAutoscroll();
void createChar(uint8_t, uint8_t[]);
void setCursor(uint8_t, uint8_t);
virtual size_t write(uint8_t);
void command(uint8_t);
void print(std::string const &s);
void print(const char *s);
private: private:
void send(uint8_t, uint8_t); void send (uint8_t, uint8_t);
void write4bits(uint8_t); void write4bits (uint8_t);
void pulseEnable(); void pulseEnable ();
DigitalIoPin *rs_pin; // LOW(false): command. HIGH(true): character. DigitalIoPin *rs_pin; // LOW(false): command. HIGH(true): character.
DigitalIoPin *enable_pin; // activated by a HIGH pulse. DigitalIoPin *enable_pin; // activated by a HIGH pulse.
DigitalIoPin *data_pins[4]; DigitalIoPin *data_pins[4];
@ -91,7 +91,8 @@ private:
uint8_t _initialized; uint8_t _initialized;
uint8_t _numlines,_currline; uint8_t _numlines, _currline;
uint8_t rows, col;
}; };
#endif #endif

320
LiquidCrystal/src/LiquidCrystal.cpp
View File

@ -1,16 +1,39 @@
#include "LiquidCrystal.h" #include "LiquidCrystal.h"
#include <cstring>
#include "chip.h" #include "chip.h"
#include <cstring>
#define LOW 0 #define LOW 0
#define HIGH 1 #define HIGH 1
void
delayMicroseconds (unsigned int us)
void delayMicroseconds(unsigned int us)
{ {
// implement with RIT uint32_t reg;
// calculate compare value
uint64_t cmp = (Chip_Clock_GetSystemClockRate () / 1000000)
* us; // One cycle equals ~72 us, thus cycle * us
// disable RIT – compare value may only be changed when RIT is disabled
reg = LPC_RITIMER->CTRL & 0xF;
LPC_RITIMER->CTRL = reg & ~RIT_CTRL_TEN;
// set compare value to RIT
LPC_RITIMER->COMPVAL = (uint32_t)cmp;
LPC_RITIMER->COMPVAL_H = (uint32_t) (cmp >> 32);
// clear RIT counter (so that counting starts from zero)
LPC_RITIMER->COUNTER = (uint32_t)0;
LPC_RITIMER->COUNTER_H = (uint32_t) (0 >> 32);
// enable RIT
reg = LPC_RITIMER->CTRL & 0xF;
LPC_RITIMER->CTRL = reg | RIT_CTRL_TEN;
// wait until RIT Int flag is set
while (!(LPC_RITIMER->CTRL & RIT_CTRL_INT))
;
// disable RIT
reg = LPC_RITIMER->CTRL & 0xF;
LPC_RITIMER->CTRL = reg & ~RIT_CTRL_TEN;
// clear RIT Int flag
reg = LPC_RITIMER->CTRL & 0xF;
LPC_RITIMER->CTRL = reg | RIT_CTRL_INT;
} }
// When the display powers up, it is configured as follows: // When the display powers up, it is configured as follows:
@ -32,11 +55,9 @@ void delayMicroseconds(unsigned int us)
// can't assume that its in that state when a sketch starts (and the // can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called). // LiquidCrystal constructor is called).
LiquidCrystal::LiquidCrystal (DigitalIoPin *rs, DigitalIoPin *enable,
DigitalIoPin *d0, DigitalIoPin *d1,
DigitalIoPin *d2, DigitalIoPin *d3)
LiquidCrystal::LiquidCrystal(DigitalIoPin *rs, DigitalIoPin *enable,
DigitalIoPin *d0, DigitalIoPin *d1, DigitalIoPin *d2, DigitalIoPin *d3)
{ {
rs_pin = rs; rs_pin = rs;
enable_pin = enable; enable_pin = enable;
@ -48,221 +69,282 @@ LiquidCrystal::LiquidCrystal(DigitalIoPin *rs, DigitalIoPin *enable,
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS; _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
begin(16, 2); // default to 16x2 display begin (16, 2); // default to 16x2 display
} }
void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { void
if (lines > 1) { LiquidCrystal::begin (uint8_t cols, uint8_t lines, uint8_t dotsize)
_displayfunction |= LCD_2LINE; {
} this->rows = lines;
this->col = cols;
if (lines > 1)
{
_displayfunction |= LCD_2LINE;
}
_numlines = lines; _numlines = lines;
_currline = 0; _currline = 0;
// for some 1 line displays you can select a 10 pixel high font // for some 1 line displays you can select a 10 pixel high font
if ((dotsize != 0) && (lines == 1)) { if ((dotsize != 0) && (lines == 1))
_displayfunction |= LCD_5x10DOTS; {
} _displayfunction |= LCD_5x10DOTS;
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION! // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V // 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 // before sending commands. Arduino can turn on way befer 4.5V so we'll wait
delayMicroseconds(50000); // 50
delayMicroseconds (50000);
// Now we pull both RS and R/W low to begin commands // Now we pull both RS and R/W low to begin commands
rs_pin->write(false); //digitalWrite(_rs_pin, LOW); rs_pin->write (false); // digitalWrite(_rs_pin, LOW);
enable_pin->write(false); //digitalWrite(_enable_pin, LOW); enable_pin->write (false); // digitalWrite(_enable_pin, LOW);
// note: this port supports only 4 bit mode // note: this port supports only 4 bit mode
//put the LCD into 4 bit or 8 bit mode // put the LCD into 4 bit or 8 bit mode
if (! (_displayfunction & LCD_8BITMODE)) { if (!(_displayfunction & LCD_8BITMODE))
// this is according to the hitachi HD44780 datasheet {
// figure 24, pg 46 // this is according to the hitachi HD44780 datasheet
// figure 24, pg 46
// we start in 8bit mode, try to set 4 bit mode // we start in 8bit mode, try to set 4 bit mode
write4bits(0x03); write4bits (0x03);
delayMicroseconds(4500); // wait min 4.1ms delayMicroseconds (4500); // wait min 4.1ms
// second try // second try
write4bits(0x03); write4bits (0x03);
delayMicroseconds(4500); // wait min 4.1ms delayMicroseconds (4500); // wait min 4.1ms
// third go! // third go!
write4bits(0x03); write4bits (0x03);
delayMicroseconds(150); delayMicroseconds (150);
// finally, set to 4-bit interface // finally, set to 4-bit interface
write4bits(0x02); write4bits (0x02);
} else { }
// this is according to the hitachi HD44780 datasheet else
// page 45 figure 23 {
// this is according to the hitachi HD44780 datasheet
// page 45 figure 23
// Send function set command sequence // Send function set command sequence
command(LCD_FUNCTIONSET | _displayfunction); command (LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(4500); // wait more than 4.1ms delayMicroseconds (4500); // wait more than 4.1ms
// second try // second try
command(LCD_FUNCTIONSET | _displayfunction); command (LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(150); delayMicroseconds (150);
// third go // third go
command(LCD_FUNCTIONSET | _displayfunction); command (LCD_FUNCTIONSET | _displayfunction);
} }
// finally, set # lines, font size, etc. // finally, set # lines, font size, etc.
command(LCD_FUNCTIONSET | _displayfunction); command (LCD_FUNCTIONSET | _displayfunction);
// turn the display on with no cursor or blinking default // turn the display on with no cursor or blinking default
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF; _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
display(); display ();
// clear it off // clear it off
clear(); clear ();
// Initialize to default text direction (for romance languages) // Initialize to default text direction (for romance languages)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT; _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
// set the entry mode // set the entry mode
command(LCD_ENTRYMODESET | _displaymode); command (LCD_ENTRYMODESET | _displaymode);
} }
/********** high level commands, for the user! */ /********** high level commands, for the user! */
void LiquidCrystal::clear() void
LiquidCrystal::clear ()
{ {
command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero command (LCD_CLEARDISPLAY); // clear display, set cursor position to zero
delayMicroseconds(2000); // this command takes a long time! delayMicroseconds (2000); // this command takes a long time!
} }
void LiquidCrystal::home() void
LiquidCrystal::home ()
{ {
command(LCD_RETURNHOME); // set cursor position to zero command (LCD_RETURNHOME); // set cursor position to zero
delayMicroseconds(2000); // this command takes a long time! delayMicroseconds (2000); // this command takes a long time!
} }
void
void LiquidCrystal::print(std::string const &s) LiquidCrystal::print (std::string const &s)
{ {
this->print (s.c_str ());
} }
void LiquidCrystal::print(const char *s) void
LiquidCrystal::print (const char *s)
{ {
int char_counter = 0;
while (*s && char_counter < this->col)
{
send (*s, HIGH);
char_counter++;
s++;
}
} }
void LiquidCrystal::setCursor(uint8_t col, uint8_t row) void
LiquidCrystal::setCursor (uint8_t col, uint8_t row)
{ {
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 }; int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
if ( row >= _numlines ) { if (row >= _numlines)
row = _numlines-1; // we count rows starting w/0 {
} row = _numlines - 1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + row_offsets[row])); command (LCD_SETDDRAMADDR | (col + row_offsets[row]));
} }
// Turn the display on/off (quickly) // Turn the display on/off (quickly)
void LiquidCrystal::noDisplay() { void
LiquidCrystal::noDisplay ()
{
_displaycontrol &= ~LCD_DISPLAYON; _displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol); command (LCD_DISPLAYCONTROL | _displaycontrol);
} }
void LiquidCrystal::display() { void
LiquidCrystal::display ()
{
_displaycontrol |= LCD_DISPLAYON; _displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol); command (LCD_DISPLAYCONTROL | _displaycontrol);
} }
// Turns the underline cursor on/off // Turns the underline cursor on/off
void LiquidCrystal::noCursor() { void
LiquidCrystal::noCursor ()
{
_displaycontrol &= ~LCD_CURSORON; _displaycontrol &= ~LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol); command (LCD_DISPLAYCONTROL | _displaycontrol);
} }
void LiquidCrystal::cursor() { void
LiquidCrystal::cursor ()
{
_displaycontrol |= LCD_CURSORON; _displaycontrol |= LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol); command (LCD_DISPLAYCONTROL | _displaycontrol);
} }
// Turn on and off the blinking cursor // Turn on and off the blinking cursor
void LiquidCrystal::noBlink() { void
LiquidCrystal::noBlink ()
{
_displaycontrol &= ~LCD_BLINKON; _displaycontrol &= ~LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol); command (LCD_DISPLAYCONTROL | _displaycontrol);
} }
void LiquidCrystal::blink() { void
LiquidCrystal::blink ()
{
_displaycontrol |= LCD_BLINKON; _displaycontrol |= LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol); command (LCD_DISPLAYCONTROL | _displaycontrol);
} }
// These commands scroll the display without changing the RAM // These commands scroll the display without changing the RAM
void LiquidCrystal::scrollDisplayLeft(void) { void
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT); LiquidCrystal::scrollDisplayLeft (void)
{
command (LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
} }
void LiquidCrystal::scrollDisplayRight(void) { void
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT); LiquidCrystal::scrollDisplayRight (void)
{
command (LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
} }
// This is for text that flows Left to Right // This is for text that flows Left to Right
void LiquidCrystal::leftToRight(void) { void
LiquidCrystal::leftToRight (void)
{
_displaymode |= LCD_ENTRYLEFT; _displaymode |= LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode); command (LCD_ENTRYMODESET | _displaymode);
} }
// This is for text that flows Right to Left // This is for text that flows Right to Left
void LiquidCrystal::rightToLeft(void) { void
LiquidCrystal::rightToLeft (void)
{
_displaymode &= ~LCD_ENTRYLEFT; _displaymode &= ~LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode); command (LCD_ENTRYMODESET | _displaymode);
} }
// This will 'right justify' text from the cursor // This will 'right justify' text from the cursor
void LiquidCrystal::autoscroll(void) { void
LiquidCrystal::autoscroll (void)
{
_displaymode |= LCD_ENTRYSHIFTINCREMENT; _displaymode |= LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode); command (LCD_ENTRYMODESET | _displaymode);
} }
// This will 'left justify' text from the cursor // This will 'left justify' text from the cursor
void LiquidCrystal::noAutoscroll(void) { void
LiquidCrystal::noAutoscroll (void)
{
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT; _displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode); command (LCD_ENTRYMODESET | _displaymode);
} }
// Allows us to fill the first 8 CGRAM locations // Allows us to fill the first 8 CGRAM locations
// with custom characters // with custom characters
void LiquidCrystal::createChar(uint8_t location, uint8_t charmap[]) { void
LiquidCrystal::createChar (uint8_t location, uint8_t charmap[])
{
location &= 0x7; // we only have 8 locations 0-7 location &= 0x7; // we only have 8 locations 0-7
command(LCD_SETCGRAMADDR | (location << 3)); command (LCD_SETCGRAMADDR | (location << 3));
for (int i=0; i<8; i++) { for (int i = 0; i < 8; i++)
write(charmap[i]); {
} write (charmap[i]);
}
} }
/*********** mid level commands, for sending data/cmds */ /*********** mid level commands, for sending data/cmds */
inline void LiquidCrystal::command(uint8_t value) { inline void
send(value, LOW); LiquidCrystal::command (uint8_t value)
{
send (value, LOW);
} }
inline size_t LiquidCrystal::write(uint8_t value) { inline size_t
send(value, HIGH); LiquidCrystal::write (uint8_t value)
{
send (value, HIGH);
return 1; // assume sucess return 1; // assume sucess
} }
/************ low level data pushing commands **********/ /************ low level data pushing commands **********/
// write either command or data // write either command or data
void LiquidCrystal::send(uint8_t value, uint8_t mode) { void
rs_pin->write(mode); //digitalWrite(_rs_pin, mode); LiquidCrystal::send (uint8_t value, uint8_t mode)
{
rs_pin->write (mode); // digitalWrite(_rs_pin, mode);
write4bits(value>>4); write4bits (value >> 4);
write4bits(value); write4bits (value);
} }
void LiquidCrystal::pulseEnable(void) { void
enable_pin->write(false); //digitalWrite(_enable_pin, LOW); LiquidCrystal::pulseEnable (void)
delayMicroseconds(1); {
enable_pin->write(true); //digitalWrite(_enable_pin, HIGH); enable_pin->write (false); // digitalWrite(_enable_pin, LOW);
delayMicroseconds(1); // enable pulse must be >450ns delayMicroseconds (1);
enable_pin->write(false); //digitalWrite(_enable_pin, LOW); enable_pin->write (true); // digitalWrite(_enable_pin, HIGH);
delayMicroseconds(100); // commands need > 37us to settle delayMicroseconds (1); // enable pulse must be >450ns
enable_pin->write (false); // digitalWrite(_enable_pin, LOW);
delayMicroseconds (100); // commands need > 37us to settle
} }
void LiquidCrystal::write4bits(uint8_t value) { void
for (int i = 0; i < 4; i++) { LiquidCrystal::write4bits (uint8_t value)
data_pins[i]->write((value >> i) & 0x01); //digitalWrite(_data_pins[i], (value >> i) & 0x01); {
} for (int i = 0; i < 4; i++)
{
pulseEnable(); data_pins[i]->write (
} (value >> i)
& 0x01); // digitalWrite(_data_pins[i], (value >> i) & 0x01);
}
pulseEnable ();
}