rekahsoft/avr-lcd-lib
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity
87070fb281
avr-lcd-lib/lcdLib.c
Collin J. Doering d8068b8f7a Completed scrollUp and scrollDown functions 
This completes the functions for ANSI escapes. It required the LCD read
functionality from last commit to be efficient (memory wise).

Signed-off-by: Collin J. Doering <collin.doering@rekahsoft.ca>
2015-10-28 04:53:46 -04:00

970 lines
30 KiB
C
Raw Blame History

/**
* (C) Copyright Collin J. Doering 2015
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* File: lcdLib.c
* Author: Collin J. Doering <collin.doering@rekahsoft.ca>
* Date: Sep 29, 2015
*/
// Includes -----------------------------------------------------------------------------------
#include <math.h>
#include <avr/io.h>
#include <util/delay.h>
#include "lcdLib.h"
//---------------------------------------------------------------------------------------------
// Static global variables
static volatile uint8_t currentLineNum;
static volatile uint8_t currentLineChars;
static volatile uint8_t saveCursorLineNum;
static volatile uint8_t saveCursorLineChars;
static volatile uint8_t lcdState;
static const uint8_t lineBeginnings[LCD_NUMBER_OF_LINES] = { LCD_LINE_BEGINNINGS };
//---------------------------------------------------------------------------------------------
// Static functions
/*
Bring LCD_ENABLE line high, wait for LCD_ENABLE_HIGH_DELAY; then bring LCD_ENABLE line low
and wait for LCD_ENABLE_LOW_DELAY.
Note: LCD_ENABLE, LCD_ENABLE_HIGH_DELAY, and LCD_ENABLE_LOW_DELAY must be defined in lcdLibConfig.h
*/
static void clkLCD(void) {
LCD_ENABLE_PORT |= (1 << LCD_ENABLE);
_delay_us(LCD_ENABLE_HIGH_DELAY);
LCD_ENABLE_PORT &= ~(1 << LCD_ENABLE);
_delay_us(LCD_ENABLE_LOW_DELAY);
}
/*
Wait until LCD_BF (busy flag) is cleared (low).
*/
static void loop_until_LCD_BF_clear(void) {
uint8_t bf;
LCD_RS_PORT &= ~(1 << LCD_RS); // RS=0
LCD_RW_PORT |= (1 << LCD_RW); // RW=1
// Set LCD_BF as input
LCD_DBUS7_DDR &= ~(1 << LCD_BF);
do {
bf = 0;
LCD_ENABLE_PORT |= (1 << LCD_ENABLE);
_delay_us(1); // 'delay data time' and 'enable pulse width'
bf |= (LCD_DBUS7_PIN & (1 << LCD_BF));
LCD_ENABLE_PORT &= ~(1 << LCD_ENABLE);
_delay_us(1); // 'address hold time', 'data hold time' and 'enable cycle width'
#ifdef FOUR_BIT_MODE
LCD_ENABLE_PORT |= (1 << LCD_ENABLE);
_delay_us(1); // 'delay data time' and 'enable pulse width'
LCD_ENABLE_PORT &= ~(1 << LCD_ENABLE);
_delay_us(1); // 'address hold time', 'data hold time' and 'enable cycle width'
#endif
} while (bf);
#if defined (FOUR_BIT_MODE) || defined (EIGHT_BIT_ARBITRARY_PIN_MODE)
LCD_DBUS7_DDR |= (1 << LCD_DBUS7);
LCD_DBUS6_DDR |= (1 << LCD_DBUS6);
LCD_DBUS5_DDR |= (1 << LCD_DBUS5);
LCD_DBUS4_DDR |= (1 << LCD_DBUS4);
#ifdef EIGHT_BIT_ARBITRARY_PIN_MODE
LCD_DBUS3_DDR |= (1 << LCD_DBUS3);
LCD_DBUS2_DDR |= (1 << LCD_DBUS2);
LCD_DBUS1_DDR |= (1 << LCD_DBUS1);
LCD_DBUS0_DDR |= (1 << LCD_DBUS0);
#endif
#else
LCD_DBUS_DDR = 0xff; // Reset all LCD_DBUS_PORT pins as outputs
#endif
}
/*
Given a 8 bit integer, writes the four MSB's (one nibble) to the LCD data bus.
Note: this is only defined in FOUR_BIT_MODE
*/
#ifdef FOUR_BIT_MODE
static void writeLCDDBusNibble_(uint8_t b) {
// Reset data lines to zeros
LCD_DBUS7_PORT &= ~(1 << LCD_DBUS7);
LCD_DBUS6_PORT &= ~(1 << LCD_DBUS6);
LCD_DBUS5_PORT &= ~(1 << LCD_DBUS5);
LCD_DBUS4_PORT &= ~(1 << LCD_DBUS4);
// Write 1's where appropriate on data lines
if (b & (1 << 7)) LCD_DBUS7_PORT |= (1 << LCD_DBUS7);
if (b & (1 << 6)) LCD_DBUS6_PORT |= (1 << LCD_DBUS6);
if (b & (1 << 5)) LCD_DBUS5_PORT |= (1 << LCD_DBUS5);
if (b & (1 << 4)) LCD_DBUS4_PORT |= (1 << LCD_DBUS4);
// Pulse the enable line
clkLCD();
}
#endif
/*
Given an 8 bit integer, writes it to the LCD data bus, regardless of its
configuration (default 8-bit mode, 8-bit arbitrary pin mode and 4-bit mode). In the default
8-bit mode and EIGHT_BIT_ARBITRARY_PIN_MODE, the given data is written in one cycle using the
writeLCDDBusByte_ function. In FOUR_BIT_MODE however, the given data is written in two cycles
using two successive calls to the writeLCDDBusNibble_ function.
This function does not ensure the LCD is ready to accept new data and thus needs to
be handled by the caller.
*/
static void writeLCDDBusByte_(uint8_t b) {
#ifdef FOUR_BIT_MODE
writeLCDDBusNibble_(b);
writeLCDDBusNibble_(b << 4);
#elif defined (EIGHT_BIT_ARBITRARY_PIN_MODE)
// Reset data lines to zeros
LCD_DBUS7_PORT &= ~(1 << LCD_DBUS7);
LCD_DBUS6_PORT &= ~(1 << LCD_DBUS6);
LCD_DBUS5_PORT &= ~(1 << LCD_DBUS5);
LCD_DBUS4_PORT &= ~(1 << LCD_DBUS4);
LCD_DBUS3_PORT &= ~(1 << LCD_DBUS3);
LCD_DBUS2_PORT &= ~(1 << LCD_DBUS2);
LCD_DBUS1_PORT &= ~(1 << LCD_DBUS1);
LCD_DBUS0_PORT &= ~(1 << LCD_DBUS0);
// Write 1's where appropriate on data lines
if (b & (1 << 7)) LCD_DBUS7_PORT |= (1 << LCD_DBUS7);
if (b & (1 << 6)) LCD_DBUS6_PORT |= (1 << LCD_DBUS6);
if (b & (1 << 5)) LCD_DBUS5_PORT |= (1 << LCD_DBUS5);
if (b & (1 << 4)) LCD_DBUS4_PORT |= (1 << LCD_DBUS4);
if (b & (1 << 3)) LCD_DBUS3_PORT |= (1 << LCD_DBUS3);
if (b & (1 << 2)) LCD_DBUS2_PORT |= (1 << LCD_DBUS2);
if (b & (1 << 1)) LCD_DBUS1_PORT |= (1 << LCD_DBUS1);
if (b & (1 << 0)) LCD_DBUS0_PORT |= (1 << LCD_DBUS0);
clkLCD();
#else
LCD_DBUS_PORT = b;
clkLCD();
#endif
}
/*
Given a 8 bit integer representing a LCD instruction, sends it to the LCD display.
Sets RS=RW=0 and writes the given 8 bit integer to the LCD databus.
Note that this function does not ensure the LCD is ready to accept a new instruction and thus
needs to be handled by the caller.
*/
static void writeLCDInstr_(uint8_t instr) {
LCD_RS_PORT &= ~(1 << LCD_RS); // RS=0
LCD_RW_PORT &= ~(1 << LCD_RW); // RW=0
writeLCDDBusByte_(instr);
}
/*
Given a 8 bit integer representing a LCD instruction, waits until the LCD is ready and sends
the instruction.
*/
static inline void writeLCDInstr(uint8_t instr) {
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
writeLCDInstr_(instr);
}
/*
Sets RS=1, RW=0 and accepts a char (8 bit) and outputs it to the current cursor position of
the LCD. In the default 8-bit mode and EIGHT_BIT_ARBITRARY_PIN_MODE, the given data is
written in one cycle using the writeLCDDBusByte_ function. In FOUR_BIT_MODE however, the given
data is written in two cycles using two successive calls to the writeLCDDBusNibble_ function.
*/
static void writeCharToLCD_(char c) {
LCD_RS_PORT |= (1 << LCD_RS); // RS=1
LCD_RW_PORT &= ~(1 << LCD_RW); // RW=0
writeLCDDBusByte_(c);
}
static uint8_t readLCDDBusByte_(void) {
LCD_RS_PORT |= (1 << LCD_RS); // RS=1
LCD_RW_PORT |= (1 << LCD_RW); // RW=1
LCD_ENABLE_PORT |= (1 << LCD_ENABLE);
_delay_us(1); // 'delay data time' and 'enable pulse width'
// Read data
char c = 0;
#if defined(FOUR_BIT_MODE)
if (LCD_DBUS7_PIN & (1 << LCD_DBUS7)) c |= (1 << 7);
if (LCD_DBUS6_PIN & (1 << LCD_DBUS6)) c |= (1 << 6);
if (LCD_DBUS5_PIN & (1 << LCD_DBUS5)) c |= (1 << 5);
if (LCD_DBUS4_PIN & (1 << LCD_DBUS4)) c |= (1 << 4);
LCD_ENABLE_PORT &= ~(1 << LCD_ENABLE);
_delay_us(1); // 'address hold time', 'data hold time' and 'enable cycle width'
LCD_ENABLE_PORT |= (1 << LCD_ENABLE);
_delay_us(1); // 'delay data time' and 'enable pulse width'
if (LCD_DBUS7_PIN & (1 << LCD_DBUS7)) c |= (1 << 3);
if (LCD_DBUS6_PIN & (1 << LCD_DBUS6)) c |= (1 << 2);
if (LCD_DBUS5_PIN & (1 << LCD_DBUS5)) c |= (1 << 1);
if (LCD_DBUS4_PIN & (1 << LCD_DBUS4)) c |= (1 << 0);
#elif defined(EIGHT_BIT_ARBITRARY_PIN_MODE)
if (LCD_DBUS7_PIN & (1 << LCD_DBUS7)) c |= (1 << 7);
if (LCD_DBUS6_PIN & (1 << LCD_DBUS6)) c |= (1 << 6);
if (LCD_DBUS5_PIN & (1 << LCD_DBUS5)) c |= (1 << 5);
if (LCD_DBUS4_PIN & (1 << LCD_DBUS4)) c |= (1 << 4);
if (LCD_DBUS3_PIN & (1 << LCD_DBUS3)) c |= (1 << 3);
if (LCD_DBUS2_PIN & (1 << LCD_DBUS2)) c |= (1 << 2);
if (LCD_DBUS1_PIN & (1 << LCD_DBUS1)) c |= (1 << 1);
if (LCD_DBUS0_PIN & (1 << LCD_DBUS0)) c |= (1 << 0);
#else
c = LCD_DBUS_PIN;
#endif
LCD_ENABLE_PORT &= ~(1 << LCD_ENABLE);
_delay_us(1); // 'address hold time', 'data hold time' and 'enable cycle width'
return c;
}
/*
Given a character string, and a uint8_t pointer, reads the character string until a
non-numerical ASCII character, returning the integer representation of the number read. At
the end of the functions execution, the found_num uint8_t* will be updated to indicate how
many digits were read. The new_loc char** will be updated with the new parsing position in
the string.
*/
static uint8_t readASCIINumber(char* str, uint8_t* found_num, char** new_loc) {
uint8_t nums[3];
*found_num = 0;
while (*str != '\0' && *found_num < 3) {
if (*str >= 0x30 && *str <= 0x39) {
// Use *str as a number (specified in ASCII)
nums[(*found_num)++] = *str - 0x30;
} else {
break;
}
str++;
}
*new_loc = str;
uint8_t ret = 0;
uint8_t i = *found_num - 1;
for (uint8_t fnd = 0; fnd < *found_num; fnd++)
ret += nums[fnd] * pow(10, i--);
return ret;
}
/*
Set all pins of LCD_DBUS as outputs
*/
static inline void setLCDDBusAsOutputs(void) {
#if defined (FOUR_BIT_MODE) || defined (EIGHT_BIT_ARBITRARY_PIN_MODE)
LCD_DBUS7_DDR |= (1 << LCD_DBUS7);
LCD_DBUS6_DDR |= (1 << LCD_DBUS6);
LCD_DBUS5_DDR |= (1 << LCD_DBUS5);
LCD_DBUS4_DDR |= (1 << LCD_DBUS4);
#ifdef EIGHT_BIT_ARBITRARY_PIN_MODE
LCD_DBUS3_DDR |= (1 << LCD_DBUS3);
LCD_DBUS2_DDR |= (1 << LCD_DBUS2);
LCD_DBUS1_DDR |= (1 << LCD_DBUS1);
LCD_DBUS0_DDR |= (1 << LCD_DBUS0);
#endif
#else
LCD_DBUS_DDR = 0xff;
#endif
}
/*
Set all pins of LCD_DBUS as inputs (disabling their output)
*/
static inline void setLCDDBusAsInputs(void) {
#if defined (FOUR_BIT_MODE) || defined (EIGHT_BIT_ARBITRARY_PIN_MODE)
LCD_DBUS7_DDR &= ~(1 << LCD_DBUS7);
LCD_DBUS6_DDR &= ~(1 << LCD_DBUS6);
LCD_DBUS5_DDR &= ~(1 << LCD_DBUS5);
LCD_DBUS4_DDR &= ~(1 << LCD_DBUS4);
#ifdef EIGHT_BIT_ARBITRARY_PIN_MODE
LCD_DBUS3_DDR &= ~(1 << LCD_DBUS3);
LCD_DBUS2_DDR &= ~(1 << LCD_DBUS2);
LCD_DBUS1_DDR &= ~(1 << LCD_DBUS1);
LCD_DBUS0_DDR &= ~(1 << LCD_DBUS0);
#endif
#else
LCD_DBUS_DDR = 0;
#endif
}
/*
Set RS=RW=0 and write the CMD_INIT command to the LCD data bus. Note that an appropriate
pause must follow before sending new commands to the LCD using writeLCD*_ functions.
*/
static inline void softwareLCDInitPulse(void) {
LCD_RS_PORT &= ~(1 << LCD_RS); // RS=0
LCD_RW_PORT &= ~(1 << LCD_RW); // RW=0
#ifdef FOUR_BIT_MODE
writeLCDDBusNibble_(CMD_INIT);
#else
writeLCDDBusByte_(CMD_INIT);
#endif
}
//---------------------------------------------------------------------------------------------
// Library function definitions
/*
Do software initialization as specified by the datasheet
*/
void initLCD(void) {
// Set LCD_RS, LCD_RW and LCD_ENABLE as outputs
LCD_RS_DDR |= (1 << LCD_RS);
LCD_RW_DDR |= (1 << LCD_RW);
LCD_ENABLE_DDR |= (1 << LCD_ENABLE);
setLCDDBusAsOutputs();
_delay_us(LCD_INIT_DELAY0); // Wait minimum 15ms as per datasheet
softwareLCDInitPulse();
_delay_us(LCD_INIT_DELAY1); // Wait minimum 4.1ms as per datasheet
softwareLCDInitPulse();
_delay_us(LCD_INIT_DELAY2); // Wait minimum 100us as per datasheet
softwareLCDInitPulse();
#if defined (FOUR_BIT_MODE)
// Function Set (4-bit interface)
writeLCDDBusNibble_(CMD_INIT_FOUR_BIT);
writeLCDInstr_(CMD_INIT_FOUR_BIT | LCD_LINES | LCD_FONT);
#else
// Function set (8-bit interface)
writeLCDInstr_(INSTR_FUNC_SET | (1 << INSTR_FUNC_SET_DL) | LCD_LINES | LCD_FONT);
#endif
/* BF now can be checked */
// Set functions of LCD
writeLCDInstr(INSTR_DISPLAY); // Display off
// Clear display
writeLCDInstr(CMD_CLEAR_DISPLAY);
// Increment mode, no shift
writeLCDInstr(INSTR_ENTRY_SET | (1 << INSTR_ENTRY_SET_ID));
// Display on, cursor on, blink off
lcdState = (1 << INSTR_DISPLAY_D) | (1 << INSTR_DISPLAY_C);
writeLCDInstr(INSTR_DISPLAY | lcdState);
}
/*
Given a single character, checks whether its a ASCII escape and does the following:
- Newline '\n': moves the cursor to the next physical line of the LCD display; if the cursor is on
the last line of the display, clears the display and positions the cursor at the top left
of the LCD
- Carriage return '\r': moves the cursor to the beginning of the current line
- Backspace '\b': moves the cursor one position backwards, wrapping to the end of the
previous line when at the beginning of a line (other then the first one). A space is then
inserted to replace the character at point, without moving the cursor. When the cursor is
at the beginning of the first line, does nothing.
- Form feed '\f': clears the LCD display and places the cursor at the beginning of the first line.
- Alarm '\a': ignored
Any other character is sent to the LCD display using writeCharToLCD_.
*/
void writeCharToLCD(char c) {
switch (c) {
case '\n': // Line feed
if (currentLineNum == LCD_NUMBER_OF_LINES - 1) {
scrollUp(1);
currentLineChars = 0;
writeLCDInstr(INSTR_DDRAM_ADDR | lineBeginnings[currentLineNum]);
} else {
currentLineChars = 0;
writeLCDInstr(INSTR_DDRAM_ADDR | lineBeginnings[++currentLineNum]);
}
break;
case '\a': // Alarm
break;
case '\b': // Backspace (non-destructive)
if (currentLineChars == 0 && currentLineNum == 0) {
// At first line, first column; there is no where to move; do nothing
break;
} else if (currentLineChars == 0) {
// At beginning of line, need to move the end of previous line
currentLineChars = LCD_CHARACTERS_PER_LINE - 1;
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[--currentLineNum] + currentLineChars));
} else {
// OK, simply go back one character
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + --currentLineChars));
}
break;
case '\r': // Carriage return
writeLCDInstr(INSTR_DDRAM_ADDR | lineBeginnings[currentLineNum]);
currentLineChars = 0;
break;
case '\f': // Form feed
clearDisplay();
break;
default: // Printable character
if (currentLineChars == LCD_CHARACTERS_PER_LINE - 1 && currentLineNum == LCD_NUMBER_OF_LINES - 1) {
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
writeCharToLCD_(c);
scrollUp(1);
currentLineChars = 0;
writeLCDInstr(INSTR_DDRAM_ADDR | lineBeginnings[currentLineNum]);
} else if (currentLineChars == LCD_CHARACTERS_PER_LINE - 1) {
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
writeCharToLCD_(c);
currentLineChars = 0;
writeLCDInstr(INSTR_DDRAM_ADDR | lineBeginnings[++currentLineNum]);
} else {
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
writeCharToLCD_(c);
currentLineChars++;
}
}
}
void writeStringToLCD(char* str) {
while (*str != '\0') {
#ifdef LCD_ANSI_ESCAPE_ENABLE
// Check for ANSI CSI (Control Sequence Introducer)
if (*str == '\e') {
if (*(++str) != '\0' && *str == '[') {
char* str_ref = ++str;
switch (*str) {
case 's': // SCP - Save cursor position
saveCursorPosition();
return;
case 'u': // RCP - Restore cursor position
restoreCursorPosition();
return;
case '?': // DECTCEM
if (*(++str_ref) != '\0' && *str_ref == '2') {
if (*(++str_ref) != '\0' && *str_ref == '5') {
if (*(++str_ref) != '\0') {
if (*str_ref == 'l') {
hideCursor();
} else if (*str_ref == 'h') {
showCursor();
} else {
// Invalid escape
}
} // Invalid escape (early termination)
} // Invalid escape
} // Invalid escape
return;
default:
break;
}
// Read optional variable length number in ASCII (0x30 - 0x3f) where 0x3a - 0x3f are
// ignored (they are used as flags by some terminals)
uint8_t fnd0;
uint8_t num0 = readASCIINumber(str, &fnd0, &str);
// Read optional (semicolon followed by optional variable length number)
uint8_t fnd1;
uint8_t num1;
if (*str != '\0' && *str == ';') {
num1 = readASCIINumber(++str, &fnd1, &str);
// Read control character (between 0x40 - 0x7e) for two argument sequences
switch (*str) {
case 'f': // HVP - Horizontal and vertical position
case 'H': // CUP - Cursor position
num0 = fnd0 ? num0 : 1;
num1 = fnd1 ? num1 : 1;
setCursorPosition(num0, num1);
break;
default: // Invalid control character
break;
}
} else if (*str != '\0') {
// Read control character (between 0x40 - 0x7e) for single argument sequences
switch (*str) {
case 'A': // CUU - Cursor up
num0 = fnd0 ? num0 : 1;
moveCursorUp(num0);
break;
case 'B': // CUD - Cursor down
num0 = fnd0 ? num0 : 1;
moveCursorDown(num0);
break;
case 'C': // CUF - Cursor forward
num0 = fnd0 ? num0 : 1;
moveCursorForward(num0);
break;
case 'D': // CUB - Cursor back
num0 = fnd0 ? num0 : 1;
moveCursorBackward(num0);
break;
case 'E': // CNL - Cursor next line
num0 = fnd0 ? num0 : 1;
moveCursorNextLine(num0);
break;
case 'F': // CPL - Cursor previous line
num0 = fnd0 ? num0 : 1;
moveCursorPreviousLine(num0);
break;
case 'G': // CHA - Cursor horizontal absolute
num0 = fnd0 ? num0 : 1;
moveCursorToColumn(num0);
break;
case 'J': // ED - Erase display
num0 = fnd0 ? num0 : 1;
eraseDisplay(num0);
break;
case 'K': // EL - Erase in line
num0 = fnd0 ? num0 : 1;
eraseInline(num0);
break;
case 'S': // SU - Scroll up
num0 = fnd0 ? num0 : 1;
scrollUp(num0);
break;
case 'T': // SD Scroll down
num0 = fnd0 ? num0 : 1;
scrollDown(num0);
break;
case 'm': // SGR - Select graphic rendition (single optional argument)
break;
case ';': // SGR - Select graphic rendition (multiple arguments)
if (fnd0) {
while (fnd0) {
readASCIINumber(++str, &fnd0, &str);
if (fnd0) {
if (*str == 'm') {
break; // Valid SGR
} else if (*str == ';') {
continue; // More SGR parameters yet
} else {
break; // Invalid escape
}
} else {
// Invalid escape; expected SGR parameter
}
}
} else {
// Invalid escape; expected first SGR parameter but none given
}
break;
case 'n': // DSR - Device status report
if (fnd0 && num0 == 6) {
// Valid DSR
} else {
// Invalid DSR
}
break;
default: // Invalid control character
writeCharToLCD(*str);
break;
}
} else {
return; // Invalid escape sequence (terminated early)
}
}
} else {
writeCharToLCD(*str);
}
str++;
#else
writeCharToLCD(*(str++));
#endif
}
}
//---------------------------------------------------------------------------------------------
// LCD command functions (all have associated ANSI escape)
/*
Writes the CMD_CLEAR_DISPLAY command to the LCD using writeLCDINSTR, and clears the local
char and line counters.
*/
void clearDisplay(void) {
writeLCDInstr(CMD_CLEAR_DISPLAY);
// Reset line and char number tracking
currentLineNum = 0;
currentLineChars = 0;
}
/*
Writes the CMD_RETURN_HOME command to the LCD using writeLCDInstr, and clears the local char
and line counters.
*/
void returnHome(void) {
writeLCDInstr(CMD_RETURN_HOME);
// Reset line and char number tracking
currentLineNum = 0;
currentLineChars = 0;
}
void getCursorPosition(uint8_t* row, uint8_t* column) {
*row = currentLineNum + 1;
*column = currentLineChars + 1;
}
void setCursorPosition(uint8_t row, uint8_t column) {
// Set currentLineNum and currentLineChars
currentLineNum = row ? row - 1 : 0;
currentLineChars = column ? column - 1 : 0;
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void moveCursorUp(uint8_t n) {
if (n < currentLineNum + 1) {
currentLineNum -= n;
} else {
currentLineNum = 0;
}
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void moveCursorDown(uint8_t n) {
if (n + currentLineNum < LCD_NUMBER_OF_LINES) {
currentLineNum += n;
} else {
currentLineNum = LCD_NUMBER_OF_LINES - 1;
}
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void moveCursorForward(uint8_t n) {
if (n + currentLineChars < LCD_CHARACTERS_PER_LINE) {
currentLineChars += n;
} else {
currentLineChars = LCD_CHARACTERS_PER_LINE - 1;
}
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void moveCursorBackward(uint8_t n) {
if (n < currentLineChars + 1) {
currentLineChars -= n;
} else {
currentLineChars = 0;
}
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void moveCursorNextLine(uint8_t n) {
currentLineChars = 0;
if (n + currentLineNum < LCD_NUMBER_OF_LINES) {
currentLineNum += n;
} else {
currentLineNum = LCD_NUMBER_OF_LINES - 1;
}
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void moveCursorPreviousLine(uint8_t n) {
currentLineChars = 0;
if (n < currentLineNum + 1) {
currentLineNum -= n;
} else {
currentLineNum = 0;
}
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void moveCursorToColumn(uint8_t n) {
if (n <= LCD_CHARACTERS_PER_LINE) {
currentLineChars = n ? n - 1 : 0;
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
} // else index out of range (off screen column)
}
void eraseDisplay(uint8_t n) {
uint8_t old_row, old_column;
getCursorPosition(&old_row, &old_column);
switch (n) {
case 0: // Clear from cursor to end of screen
{
uint8_t len = (LCD_NUMBER_OF_LINES - old_row)*LCD_CHARACTERS_PER_LINE + (LCD_CHARACTERS_PER_LINE - old_column);
for (uint8_t i = 0; i < len; i++)
writeCharToLCD(' ');
// Write last char without scrolling
loop_until_LCD_BF_clear();
writeCharToLCD_(' ');
break;
}
case 1: // Clear from cursor to beginning of screen
{
uint8_t len = (old_row - 1)*LCD_CHARACTERS_PER_LINE + old_column;
returnHome();
for (uint8_t i = 0; i < len; i++)
writeCharToLCD(' ');
// Write last char without scrolling
loop_until_LCD_BF_clear();
writeCharToLCD_(' ');
break;
}
case 2: // Clear entire screen
clearDisplay();
break;
default: // Invalid argument; do nothing
break;
}
setCursorPosition(old_row, old_column);
}
void eraseInline(uint8_t n) {
uint8_t old_row, old_column;
getCursorPosition(&old_row, &old_column);
switch (n) {
case 0: // Clear from cursor to end of line
for (uint8_t i = old_column; i <= LCD_CHARACTERS_PER_LINE; i++)
writeCharToLCD(' ');
break;
case 1: // Clear from cursor to beginning of line
setCursorPosition(old_row, 1);
for (uint8_t i = 1; i <= old_column; i++)
writeCharToLCD(' ');
break;
case 2: // Clear entire line
setCursorPosition(old_row, 1);
for (uint8_t i = 1; i <= LCD_CHARACTERS_PER_LINE; i++) {
loop_until_LCD_BF_clear();
writeCharToLCD_(' ');
}
break;
default: // Invalid argument; do nothing
return;
}
setCursorPosition(old_row, old_column);
}
void scrollUp(uint8_t n) {
#if LCD_NUMBER_OF_LINES == 1
clearDisplay();
#else
if (n >= LCD_NUMBER_OF_LINES) {
clearDisplay();
} else {
uint8_t old_row, old_column;
getCursorPosition(&old_row, &old_column);
uint8_t len = (LCD_NUMBER_OF_LINES - n)*LCD_CHARACTERS_PER_LINE + 1;
char str[len];
readCharsFromLCD(n + 1, 1, LCD_NUMBER_OF_LINES, LCD_CHARACTERS_PER_LINE, str, len);
setCursorPosition(1, 1); // returnHome();
writeStringToLCD(str);
// Add n newlines to bottom of screen
for (uint8_t i = 0; i < n; i++) {
setCursorPosition(LCD_NUMBER_OF_LINES - i, 1);
eraseInline(2);
}
setCursorPosition(old_row, old_column);
}
#endif
}
void scrollDown(uint8_t n) {
#if LCD_NUMBER_OF_LINES == 1
clearDisplay();
#else
if (n >= LCD_NUMBER_OF_LINES) {
clearDisplay();
} else {
uint8_t old_row, old_column;
getCursorPosition(&old_row, &old_column);
uint8_t len = (LCD_NUMBER_OF_LINES - n)*LCD_CHARACTERS_PER_LINE + 1;
char str[len];
readCharsFromLCD(1, 1, LCD_NUMBER_OF_LINES - n, LCD_CHARACTERS_PER_LINE, str, len);
for (uint8_t column = n + 1, i = 0; column <= LCD_NUMBER_OF_LINES; column++) {
setCursorPosition(column , 1);
for (uint8_t row = 1; row <= LCD_CHARACTERS_PER_LINE; row++) {
loop_until_LCD_BF_clear();
writeCharToLCD_(str[i++]);
}
}
// Add n newlines to top of screen
for (uint8_t i = 1; i <= n; i++) {
setCursorPosition(i, 1);
eraseInline(2);
}
setCursorPosition(old_row, old_column);
}
#endif
}
void saveCursorPosition() {
saveCursorLineNum = currentLineNum;
saveCursorLineChars = currentLineChars;
}
void restoreCursorPosition() {
currentLineNum = saveCursorLineNum;
currentLineChars = saveCursorLineChars;
writeLCDInstr(INSTR_DDRAM_ADDR | (lineBeginnings[currentLineNum] + currentLineChars));
}
void hideCursor(void) {
lcdState &= ~(1 << INSTR_DISPLAY_C);
writeLCDInstr(INSTR_DISPLAY | lcdState);
}
void showCursor(void) {
lcdState |= (1 << INSTR_DISPLAY_C);
writeLCDInstr(INSTR_DISPLAY | lcdState);
}
//-----------------------------------------------------------------------------------------------
// Utility functions (with no associated ASCII or ANSI escape)
void blinkCursorOff(void) {
lcdState &= ~(1 << INSTR_DISPLAY_B);
writeLCDInstr(INSTR_DISPLAY | lcdState);
}
void blinkCursorOn(void) {
lcdState |= (1 << INSTR_DISPLAY_B);
writeLCDInstr(INSTR_DISPLAY | lcdState);
}
void displayOff(void) {
lcdState &= ~(1 << INSTR_DISPLAY_D);
writeLCDInstr(INSTR_DISPLAY | lcdState);
}
void displayOn(void) {
lcdState |= (1 << INSTR_DISPLAY_D);
writeLCDInstr(INSTR_DISPLAY | lcdState);
}
//-----------------------------------------------------------------------------------------------
char readCharFromLCD(uint8_t row, uint8_t column) {
uint8_t old_row, old_column;
getCursorPosition(&old_row, &old_column);
setCursorPosition(row, column);
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
setLCDDBusAsInputs();
char c = readLCDDBusByte_();
setLCDDBusAsOutputs();
setCursorPosition(old_row, old_column);
return c;
}
void readLCDLine(uint8_t i, char* str) {
readCharsFromLCD(i, 1, i, LCD_CHARACTERS_PER_LINE, str, LCD_CHARACTERS_PER_LINE + 1);
}
//---------------------------------------------------------------------------------------------
// Advanced functions for special cases
void readCharsFromLCD(uint8_t from_row, uint8_t from_column, uint8_t to_row, uint8_t to_column, char* str, uint8_t len) {
uint8_t old_row, old_column;
getCursorPosition(&old_row, &old_column);
setCursorPosition(from_row, from_column);
for (uint8_t i = 0; i < len - 1 && from_row <= to_row; i++) {
if (from_row == LCD_NUMBER_OF_LINES && from_column == LCD_CHARACTERS_PER_LINE) {
// Last character on screen
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
setLCDDBusAsInputs();
*(str++) = readLCDDBusByte_();
setLCDDBusAsOutputs();
} else if (from_column == LCD_CHARACTERS_PER_LINE) { // End of line (but not last one)
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
setLCDDBusAsInputs();
*(str++) = readLCDDBusByte_();
setLCDDBusAsOutputs();
from_row += 1;
from_column = 1;
setCursorPosition(from_row, from_column);
} else {
loop_until_LCD_BF_clear(); // Wait until LCD is ready for new instructions
setLCDDBusAsInputs();
*(str++) = readLCDDBusByte_();
setLCDDBusAsOutputs();
from_column++;
}
}
// Ensure array is terminated with null character
*str = '\0';
setCursorPosition(old_row, old_column);
setLCDDBusAsOutputs();
}
/*
Initialize LCD using the internal reset circuitry.
Note: This currently only works with 8 bit modes, but is not recommended. Instead use the
initLCD function which uses the software initialization method and works for 8-bit
modes as well the 4-bit mode.
*/
void initLCDByInternalReset(void) {
setLCDDBusAsOutputs();
// Function set (8-bit interface; 2 lines with 5x7 dot character font)
writeLCDInstr_(INSTR_FUNC_SET | (1 << INSTR_FUNC_SET_DL) | (1 << INSTR_FUNC_SET_N));
writeLCDInstr_(0x0F);
writeLCDInstr_(0x06);
writeLCDInstr_(CMD_CLEAR_DISPLAY);
_delay_ms(LCD_CLEAR_DISPLAY_DELAY);
}
Reference in New Issue View Git Blame Copy Permalink