//////////////////////////////////////////////////////////////////////////////// // // // Programname: HSA_LCD_Shield - Code // // Date: 16.11.2018 // // Description: Code-File of the LCD-Shield, which was designed and built in // // the Modul "Elektronikdesign". In this file you can find the // // code of all functions mentioned in the Header-File of the // // class. // // // // Author: Tobias Müller, M. Eng. // // // //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// //////////////////// Include Header-File //////////////////// //////////////////////////////////////////////////////////////////////////////// #include "HSA_LCD_Shield.h" //////////////////////////////////////////////////////////////////////////////// //////////////////// Protected Functions //////////////////// //////////////////////////////////////////////////////////////////////////////// //////////////////// GPIO Configuration //////////////////// bool HSA_LCD_Shield::__gpioConfig(void) { // Save Pin configuration, depending of LCD-Shield version if(this->__version == LCD_VERSION_5) { // Save Pin configuration for buttons this->__buttonUp = BUTTON_UP_V5; this->__buttonRight = BUTTON_RIGHT_V5; this->__buttonDown = BUTTON_DOWN_V5; this->__buttonLeft = BUTTON_LEFT_V5; // Save Pin configuration for LEDs this->__ledGreen = LED_GREEN_V5; this->__ledRed = LED_RED_V5; // Save Pin configuration for LCD-Backlight this->__lcdBacklight = LCD_BACKLIGHT_V5; } else if(this->__version == LCD_VERSION_6) { // Save Pin configuration for buttons this->__buttonUp = BUTTON_UP_V6; this->__buttonRight = BUTTON_RIGHT_V6; this->__buttonDown = BUTTON_DOWN_V6; this->__buttonLeft = BUTTON_LEFT_V6; // Save Pin configuration for LEDs this->__ledGreen = LED_GREEN_V6; this->__ledRed = LED_RED_V6; // Save Pin configuration for LCD-Backlight this->__lcdBacklight = LCD_BACKLIGHT_V6; } // If LCD-Shield version is unknown, exit function with error else return false; // Check config-value and setup the LEDs, depending of config-value if(strcmp(this->__config,CONFIG_L1B0) == false || strcmp(this->__config,CONFIG_L1B1) == false) { // Setup LEDs pinMode(this->__ledGreen,OUTPUT); pinMode(this->__ledRed,OUTPUT); digitalWrite(this->__ledGreen,HIGH); digitalWrite(this->__ledRed,HIGH); // Store the value "true", if LEDs are configured this->__leds = true; } else { // Store the value "false", if LEDs are not configured this->__leds = false; } // Check config-value and setup the Buttons depending of config-value if(strcmp(this->__config,CONFIG_L0B1) == false || strcmp(this->__config,CONFIG_L1B1) == false) { // Setup Buttons pinMode(this->__buttonUp,INPUT); pinMode(this->__buttonRight,INPUT); pinMode(this->__buttonDown,INPUT); pinMode(this->__buttonLeft,INPUT); // Store the value "true", if buttons are configured this->__buttons = true; } else { // Store the value "false", if buttons are not configured this->__buttons = false; } // If config-value is unknown, quit configuration, otherwise configure Display if(strcmp(this->__config,CONFIG_L1B1) != false && strcmp(this->__config,CONFIG_L0B1) != false && strcmp(this->__config,CONFIG_L1B0) != false && strcmp(this->__config,CONFIG_L0B0) != false) return false; else { // Setup LCD-Backlight pinMode(this->__lcdBacklight,OUTPUT); // Initialize I²C as Master Wire.begin(); // Define an array of Bytes for configure the Display byte buffer[] = {CONTROL_BYTE_CB, LCD_PARA_FUNC1, LCD_PARA_EXT_FUNC, LCD_PARA_ENTRY_MODE, LCD_PARA_BIAS_SET, LCD_PARA_FUNC2, LCD_PARA_INT_OSC, LCD_PARA_FOL_CON, LCD_PARA_POW_CON, LCD_PARA_CONTRAST, LCD_PARA_FUNC3, LCD_PARA_DIS_CON, LCD_PARA_CLR_DIS}; // Send array of bytes _sendMessage(buffer, sizeof(buffer)); // Exit function with positive feedback return true; } } //////////////////////////////////////////////////////////////////////////////// //////////////////// Privat Functions //////////////////// //////////////////////////////////////////////////////////////////////////////// //////////////////// Send Message //////////////////// void HSA_LCD_Shield::_sendMessage(byte* bytes, byte sizeBytes) { // Small timeout before access the I²C-Bus delayMicroseconds(DELAY_TRANS_US); // Start I²C transmission Wire.beginTransmission(this->__i2cAddress); // Send an array of Bytes over I²C, depending of its size for(byte i = 0x00; i < sizeBytes; i++) Wire.write(bytes[i]); // Stop I²C transmission Wire.endTransmission(); // Small timeout after access the I²C-Bus delayMicroseconds(DELAY_TRANS_US); // Exit function return; } //////////////////////////////////////////////////////////////////////////////// //////////////////// Public Functions //////////////////// //////////////////////////////////////////////////////////////////////////////// //////////////////// Constructor //////////////////// HSA_LCD_Shield::HSA_LCD_Shield(byte version, const char config[CONFIG_SIZE]) { // Save LCD-Shield version this->__version = version; // Save standard I²C-Address for LC-Display this->__i2cAddress = I2C_ADDRESS; // Save the configuration of Buttons/LEDs strcpy(this->__config,config); // Exit Constructor return; } HSA_LCD_Shield::HSA_LCD_Shield(byte version) { // Save LCD-Shield version this->__version = version; // Save standard I²C-Address for LC-Display this->__i2cAddress = I2C_ADDRESS; // Save the configuration of Buttons/LEDs strcpy(this->__config,CONFIG_L1B1); // Exit Constructor return; } HSA_LCD_Shield::HSA_LCD_Shield(const char config[CONFIG_SIZE]){ // Save LCD-Shield version this->__version = LCD_VERSION_6; // Save standard I²C-Address for LC-Display this->__i2cAddress = I2C_ADDRESS; // Save the configuration of Buttons/LEDs strcpy(this->__config,config); // Exit Constructor return; } HSA_LCD_Shield::HSA_LCD_Shield(void){ // Save LCD-Shield version this->__version = LCD_VERSION_6; // Save standard I²C-Address for LC-Display this->__i2cAddress = I2C_ADDRESS; // Save the configuration of Buttons/LEDs strcpy(this->__config,CONFIG_L1B1); // Exit Constructor return; } //////////////////// Deconstructor //////////////////// HSA_LCD_Shield::~HSA_LCD_Shield(void) { // Exit function return; } //////////////////// Start Configuration //////////////////// bool HSA_LCD_Shield::begin(void) { // Configure GPIOs this->__lcd = __gpioConfig(); // Exit function return this->__lcd; } bool HSA_LCD_Shield::begin(byte address) { // Save I²C-Address of LC-Display this->__i2cAddress = address; // Configure GPIOs this->__lcd = __gpioConfig(); // Exit function return this->__lcd; } //////////////////// LCD-Backlight //////////////////// bool HSA_LCD_Shield::lcdBacklight(bool value) { // check, whether LCD is configured if(this->__lcd == false) return false; // Turning on/off LCD-Backlight digitalWrite(this->__lcdBacklight,value); // Exit function return true; } //////////////////// Clear Display //////////////////// bool HSA_LCD_Shield::clearDisplay(void) { // check, whether LCD is configured if(this->__lcd == false) return false; // Define an array of Bytes for clearing the Display byte buffer[] = {CONTROL_BYTE_CB, LCD_PARA_CLR_DIS}; // Send array of bytes _sendMessage(buffer, sizeof(buffer)); // Exit function return true; } /////////////////// Return Version //////////////////// byte HSA_LCD_Shield::returnVersion(void) { // Exit function and return the configured Version for the LCD-Shield return this->__version; } //////////////////// Return Config //////////////////// char* HSA_LCD_Shield::returnConfig(void) { // Exit function and return the configuration value return this->__config; } //////////////////// Return I²C-Address //////////////////// byte HSA_LCD_Shield::returnAddress(void){ // Exit function and return the value of the I²C-Address return this->__i2cAddress; } //////////////////// Control LEDs //////////////////// bool HSA_LCD_Shield::controlLED(byte ledPin, bool state) { // Checks, whether LED-Pins are configured if(this->__leds) { // Checks, whether LED-Color is known and control LED if(ledPin == LED_GREEN) { digitalWrite(this->__ledGreen,!state); return true; } if(ledPin == LED_RED) { digitalWrite(this->__ledRed,!state); return true; } } // Exit function with error, if LED-Pins are not configured or LED-Color is // unknown return false; } //////////////////// Get LED state //////////////////// bool HSA_LCD_Shield::getLED(byte ledPin) { // Exit function and return the value of chosen LED if(ledPin == LED_GREEN && this->__leds) return !digitalRead(this->__ledGreen); else if(ledPin == LED_RED && this->__leds) return !digitalRead(this->__ledRed); else return false; } //////////////////// Get the pressed Button //////////////////// byte HSA_LCD_Shield::getButton() { // return 1, if only button "Up" is pressed and configured if(digitalRead(this->__buttonUp) && !digitalRead(this->__buttonRight) && !digitalRead(this->__buttonDown) && !digitalRead(this->__buttonLeft) && this->__buttons) return BUTTON_UP; // return 2, if only button "Right" is pressed and configured if(!digitalRead(this->__buttonUp) && digitalRead(this->__buttonRight) && !digitalRead(this->__buttonDown) && !digitalRead(this->__buttonLeft) && this->__buttons) return BUTTON_RIGHT; // return 3, if only button "Down" is pressed and configured if(!digitalRead(this->__buttonUp) && !digitalRead(this->__buttonRight) && digitalRead(this->__buttonDown) && !digitalRead(this->__buttonLeft) && this->__buttons) return BUTTON_DOWN; // return 4, if only button "Left" is pressed and configured if(!digitalRead(this->__buttonUp) && !digitalRead(this->__buttonRight) && !digitalRead(this->__buttonDown) && digitalRead(this->__buttonLeft) && this->__buttons) return BUTTON_LEFT; // return false, if no button or more than one button is pressed or // buttons are not configured return false; } //////////////////// Write Row //////////////////// bool HSA_LCD_Shield::writeRow(byte row, const char* text) { // check, whether LCD is configured if(this->__lcd == false) return false; // If chosen Row does not exist, exit function with error if(!(row >= 0x01 && row <= 0x04)) return false; // Define buffer for test Message byte buffer[ARRAY_SIZE_ROW] = ""; // Define variable to store a boolean value, if a control-byte was found bool controlByte = false; // Create data-array with message and send the message at the end for(byte i = 0x00; i < ARRAY_SIZE_ROW; i++) { // Set control-byte for changing parameter in the first iteration if(i == 0x00) buffer[i] = CONTROL_BYTE_CB; // Change the cursor position to row in the second iteration. if(i == 0x01 && row == 0x01) buffer[i] = LCD_PARA_DIS_ROW1; if(i == 0x01 && row == 0x02) buffer[i] = LCD_PARA_DIS_ROW2; if(i == 0x01 && row == 0x03) buffer[i] = LCD_PARA_DIS_ROW3; if(i == 0x01 && row == 0x04) buffer[i] = LCD_PARA_DIS_ROW4; // Set control-byte for writing to the display in the third iteration if(i == 0x02) buffer[i] = CONTROL_BYTE_DCB; // Copy text into the buffer between iteration 2 to 13 if(i > 0x02 && i < ARRAY_SIZE_ROW) { // If no control-byte was found, copy byte into buffer if(!controlByte) { // Check byte for control-byte if(isControl(text[i - 0x03])) controlByte = true; // if not, copy byte into buffer else buffer[i] = text[i - 0x03]; } // If control-byte was found, fill message with free space if(controlByte) { // Fill Buffer with free space buffer[i] = FREE_SPACE; } } } // Send message _sendMessage(buffer,sizeof(buffer)); // Exit function with success return true; } bool HSA_LCD_Shield::writeRow(const char* text) { // check, whether LCD is configured if(this->__lcd == false) return false; // Define buffer for test Message char buffer[ARRAY_SIZE_ROW] = ""; // Define variable to store the actual row position byte rowPosition = LCD_PARA_DIS_ROW1; // Define variable, which count the copied bytes byte countBytes = 0x00; // Create data-array with messages for 4 rows and send the messages for(byte i = 0x00; i < 0x28; i++){ // If the position of the row is not selected, skip following code if(rowPosition == false) continue; // If first row is selected if(rowPosition == LCD_PARA_DIS_ROW1) { // If counted bytes has not reach max value, copy byte into buffer if(countBytes < 0x0A) buffer[countBytes] = text[i]; // Check, if copied byte was control-byte if(isControl(text[i])) { // Check if control-byte was \n or \r or end of string, // set counted bytes to max value if(text[i] == BACKSLASH_N || text[i] == BACKSLASH_R || text[i] == STRING_END) countBytes = 0x0A; // Check if control-byte was end of the string, deactivate row position if(text[i] == STRING_END) rowPosition = false; } // Otherwise increase counted bytes else countBytes++; // If count bytes is max value if(countBytes == 0x0A) { // Reset count bytes countBytes = 0x00; // write first row writeRow(0x01, buffer); // If row position is deactivated if(rowPosition == false) { // clear following rows writeRow(0x02, &text[i]); writeRow(0x03, &text[i]); writeRow(0x04, &text[i]); } // Otherwise set row position the row 2 else rowPosition = LCD_PARA_DIS_ROW2; // skip the rest of the code in this iteration continue; } } // If second row is selected if(rowPosition == LCD_PARA_DIS_ROW2) { // If counted bytes has not reach max value, copy byte into buffer if(countBytes < 0x0A) buffer[countBytes] = text[i]; // Check, if copied byte was control-byte if(isControl(text[i])) { // Check if control-byte was \n or \r or end of string, // set counted bytes to max value if(text[i] == BACKSLASH_N || text[i] == BACKSLASH_R || text[i] == STRING_END) countBytes = 0x0A; // Check if control-byte was end of the string, deactivate row position if(text[i] == STRING_END) rowPosition = false; } // Otherwise increase counted bytes else countBytes++; // If count bytes is max value if(countBytes == 0x0A) { // Reset count bytes countBytes = 0x00; // write second row writeRow(0x02, buffer); // If row position is deactivated if(rowPosition == false) { // clear following rows writeRow(0x03, &text[i]); writeRow(0x04, &text[i]); } // Otherwise set row position the row 3 else rowPosition = LCD_PARA_DIS_ROW3; // skip the rest of the code in this iteration continue; } } // If third row is selected if(rowPosition == LCD_PARA_DIS_ROW3) { // If counted bytes has not reach max value, copy byte into buffer if(countBytes < 0x0A) buffer[countBytes] = text[i]; // Check, if copied byte was control-byte if(isControl(text[i])) { // Check if control-byte was \n or \r or end of string, // set counted bytes to max value if(text[i] == BACKSLASH_N || text[i] == BACKSLASH_R || text[i] == STRING_END) countBytes = 0x0A; // Check if control-byte was end of the string, deactivate row position if(text[i] == STRING_END) rowPosition = false; } // Otherwise increase counted bytes else countBytes++; // If count bytes is max value if(countBytes == 0x0A) { // Reset count bytes countBytes = 0x00; // write third row writeRow(0x03, buffer); // If row position is deactivated, clear following row if(rowPosition == false) writeRow(0x04, &text[i]); // Otherwise set row position the row 4 else rowPosition = LCD_PARA_DIS_ROW4; // skip the rest of the code in this iteration continue; } } // If fourth row is selected if(rowPosition == LCD_PARA_DIS_ROW4) { // If counted bytes has not reach max value, copy byte into buffer if(countBytes < 0x0A) buffer[countBytes] = text[i]; // Check, if copied byte was control-byte if(isControl(text[i])) { // Check if control-byte was \n or \r or end of string, // set counted bytes to max value if(text[i] == BACKSLASH_N || text[i] == BACKSLASH_R || text[i] == STRING_END) countBytes = 0x0A; // Check if control-byte was end of the string, deactivate row position if(text[i] == STRING_END) rowPosition = false; } // Otherwise increase counted bytes else countBytes++; // If count bytes is max value if(countBytes == 0x0A) { // Reset count bytes countBytes = 0x00; // write fourth row writeRow(0x04, buffer); // If row position is not deactivated, deaktivate row position if(rowPosition != false) rowPosition = false; // skip the rest of the code in this iteration continue; } } } // Exit function return true; } //////////////////// Write Position XY //////////////////// bool HSA_LCD_Shield::writeXY(byte row, byte column, const char* text) { // check, whether LCD is configured if(this->__lcd == false) return false; // If chosen Row does not exist, exit function with error if(!(row >= 0x01 && row <= 0x04)) return false; // If chosen Column does not exist, exit function with error if(!(column >= 0x01 && column <= 0x0A)) return false; // create variable to store count of chars byte count = 0x00; // Count chars inside of text for(byte i = 0x00; i < 0x0A && !isControl(text[i]); i++) count++; // Define buffer for text Message byte buffer[ARRAY_SIZE_ROW - (0x0A - count)] = ""; // Create data-array with message and send the message at the end for(byte i = 0x00; i < sizeof(buffer); i++) { // Set control-byte for changing parameter in the first iteration if(i == 0x00) buffer[i] = CONTROL_BYTE_CB; // Change the cursor position to row/column in the second iteration. if(i == 0x01 && row == 0x01) buffer[i] = LCD_PARA_DIS_ROW1 | (column - 0x01); if(i == 0x01 && row == 0x02) buffer[i] = LCD_PARA_DIS_ROW2 | (column - 0x01); if(i == 0x01 && row == 0x03) buffer[i] = LCD_PARA_DIS_ROW3 | (column - 0x01); if(i == 0x01 && row == 0x04) buffer[i] = LCD_PARA_DIS_ROW4 | (column - 0x01); // Set control-byte for writing to the display if(i == 0x02) buffer[i] = CONTROL_BYTE_DCB; // Copy text into the buffer between iteration 2 to 13 if(i >= 0x03 && i < sizeof(buffer)) buffer[i] = text[i - 0x03]; } // Send message _sendMessage(buffer,sizeof(buffer)); // Exit function with success return true; }