#define SERIAL_BUFFER_SIZE 256
#include <Arduino.h>
#include "EmbrioMath.h"
#include "EmbrioArduino.h"
bool emptyBool;
int emptyInt;
long emptyLong;
float emptyFloat;
String emptyString;
bool *emptyBoolArray[1] = { &emptyBool };
bool **emptyBoolArrayArray[0];
float *emptyFloatArray[1] = { &emptyFloat };
// Global variables
bool InputPinNumber092e4 = true;
float OutputActivationc4ee7;
bool InputActivationfa8db = true;
bool InputInputMin6e3dd = true;
bool InputInputMaxc306b = true;
bool InputOutputMindf8e9 = true;
bool InputOutputMax75b49 = true;
float OutputHorizontalActivation65bdc;
bool InputActivation7a611 = true;
float OutputLeftActivationd73e2;
bool InputPinNumberbfce1 = true;
bool InputActivationd10e5 = true;
bool InputActivation9f39f = true;
float OutputRightActivationb58ff;
bool InputPinNumber77a0b = true;
bool InputActivationb5826 = true;
// Global functions
// Update code definitions
void AnalogInputEveryUpdate526fe9(long Input_PinNumber, float *Output_Activation, bool *Output_ActivationInputs[], int Output_ActivationInpCnt)
{
#line 1 "526fe9d1-8046-499e-b9ef-75b17067b1b1"
long value = analogRead(Input_PinNumber);
*Output_Activation = transform(value, 0, 1023, 0.0, 1.0);MarkChange(Output_ActivationInputs, Output_ActivationInpCnt);
}
void TransformNumberInputChange988374(float Input_Activation, float Input_InputMin, float Input_InputMax, float Input_OutputMin, float Input_OutputMax, float *Output_Activation, bool *Output_ActivationInputs[], int Output_ActivationInpCnt)
{
#line 1 "98837426-fe93-4064-afea-f0cba39223b5"
if (Input_OutputMin < Input_OutputMax)
{
*Output_Activation = map(Input_Activation, Input_InputMin, Input_InputMax, Input_OutputMin, Input_OutputMax);MarkChange(Output_ActivationInputs, Output_ActivationInpCnt);
}
else
{
*Output_Activation = map(1 - Input_Activation, Input_InputMin, Input_InputMax, Input_OutputMax, Input_OutputMin);MarkChange(Output_ActivationInputs, Output_ActivationInpCnt);
}
}
void InvertValueInputChangee740d6(float Input_Activation, float *Output_Activation, bool *Output_ActivationInputs[], int Output_ActivationInpCnt)
{
#line 1 "e740d6a3-1ad0-4693-b4b0-fb06eb6896f8"
*Output_Activation = Input_Activation * -1;MarkChange(Output_ActivationInputs, Output_ActivationInpCnt);
}
void DigitalOutputInputChange5ab2af(long Input_PinNumber, float Input_Activation)
{
#line 1 "5ab2afb8-f560-4835-8d18-0d8c4556966c"
if (Input_Activation > 0.5)
{
digitalWrite(Input_PinNumber, HIGH);
}
else
{
digitalWrite(Input_PinNumber, LOW);
}
}
void DigitalOutputInputChange5cd2fc(long Input_PinNumber)
{
#line 1 "5cd2fc0c-f594-4e4a-9527-31ca92d23f63"
pinMode(Input_PinNumber, OUTPUT);
}
void BlendInputsInputChange231c40(float Input_Activation, float *Output_Activation, bool *Output_ActivationInputs[], int Output_ActivationInpCnt)
{
#line 1 "231c4040-8027-4aa3-bbfe-eb164f8746e2"
*Output_Activation = Input_Activation;MarkChange(Output_ActivationInputs, Output_ActivationInpCnt);
}
// Update code instance functions
void HorizontalAnalogInPin18517f()
{
#line 1 "18517f47-be0e-43c7-b5b9-2c87f4f8d3bc"
bool *arr0[1] = {&InputActivationfa8db};AnalogInputEveryUpdate526fe9(0, &OutputActivationc4ee7, arr0, 1);
}
void TransformNumber047192()
{
#line 1 "047192b5-78f9-4d63-ac19-35435e7cc9e1"
if(InputInputMin6e3dd||InputInputMaxc306b||InputOutputMindf8e9||InputOutputMax75b49||InputActivationfa8db) { bool *arr0[2] = {&InputActivation7a611, &InputActivation9f39f};TransformNumberInputChange988374(OutputActivationc4ee7, 0, 1, -1, 1, &OutputHorizontalActivation65bdc, arr0, 2);InputInputMin6e3dd=InputInputMaxc306b=InputOutputMindf8e9=InputOutputMax75b49=InputActivationfa8db=false; }
}
void InvertValued97b7b()
{
#line 1 "d97b7b7d-013d-4086-8077-7c6a65e42ab1"
if(InputActivation7a611) { bool *arr0[1] = {&InputActivationd10e5};InvertValueInputChangee740d6(OutputHorizontalActivation65bdc, &OutputLeftActivationd73e2, arr0, 1);InputActivation7a611=false; }
}
void DigitalOutputRightae962b()
{
#line 1 "ae962b52-357d-49bc-8e48-a13d3b28416a"
if(InputActivationd10e5) { DigitalOutputInputChange5ab2af(32, OutputLeftActivationd73e2);InputActivationd10e5=false; }
if(InputPinNumberbfce1) { DigitalOutputInputChange5cd2fc(32);InputPinNumberbfce1=false; }
}
void BlendInputs737a44()
{
#line 1 "737a4479-c906-4414-bb4d-fe5b061c5531"
if(InputActivation9f39f) { bool *arr0[1] = {&InputActivationb5826};BlendInputsInputChange231c40(OutputHorizontalActivation65bdc, &OutputRightActivationb58ff, arr0, 1);InputActivation9f39f=false; }
}
void DigitalOutputLeft5550ac()
{
#line 1 "5550aca8-6d1c-46d8-8b8d-2aa8bb3c38b0"
if(InputActivationb5826) { DigitalOutputInputChange5ab2af(33, OutputRightActivationb58ff);InputActivationb5826=false; }
if(InputPinNumber77a0b) { DigitalOutputInputChange5cd2fc(33);InputPinNumber77a0b=false; }
}
// Node group functions
void _ee92e0821a36453f885b6804fa90f5f1()
{
ProcessTimedFunction(HorizontalAnalogInPin18517f, 168);
ProcessTimedFunction(TransformNumber047192, 6);
ProcessTimedFunction(InvertValued97b7b, 5);
ProcessTimedFunction(DigitalOutputRightae962b, 191);
ProcessTimedFunction(BlendInputs737a44, 4);
ProcessTimedFunction(DigitalOutputLeft5550ac, 191);
}
void setup()
{
}
void loop()
{
_ee92e0821a36453f885b6804fa90f5f1();
EmbrioWait(30685);
#include "EmbrioArduino.h"
// These variables are used when timing the execution of a time slice
int timingOverhead = 9; // How long it takes to do the subtracting and timing for a slice
// Wait for a number of microseconds. First wait for milliseconds then microseconds < 1000
void EmbrioWait(long microseconds)
{
if (microseconds > 0)
{
long waitMilis = microseconds / 1000;
long waitMicros = microseconds % 1000;
delay(waitMilis);
if (waitMicros > 3)
delayMicroseconds(waitMicros);
}
}
long ProcessTimedFunction(void (*fun)(), long maxMicros)
{
// Start timing
long startMicros = micros();
// Execute the node function
(*fun)();
//Calculate how long it took to run the update
long endMicros = micros();
long remainingMicros = 0;
if (endMicros < startMicros)
remainingMicros = maxMicros - ((4294967295 - startMicros) + endMicros) - timingOverhead;
else
remainingMicros = maxMicros - (endMicros - startMicros) - timingOverhead;
//Wait for the milli and micro second portions of the remaining time
EmbrioWait(remainingMicros);
return remainingMicros;
}
void MarkChange(bool *bools[], int cnt)
{
for (int i = 0; i < cnt; i++)
{
*bools[i] = true;
}
}
void MarkNoChange(bool *bools, int cnt)
{
for (int i = 0; i < cnt; i++)
{
bools[i] = false;
}
}
int GetTriggerIndex(bool *bools, int cnt)
{
int triggerIndex = -1;
for (int i = 0; i < cnt; i++)
{
if (bools[i])
{
triggerIndex = i;
}
}
return triggerIndex;
}
void EmbrioDebug(String text)
{
Serial.print("deb:");Serial.print(text);Serial.print("\n");
}
void Debug(String text)
{
Serial.print("deb:");Serial.print(text);Serial.print("\n");
}
void Debug(float text)
{
Serial.print("deb:"); Serial.print(text); Serial.print("\n");
}
void Debug(int text)
{
Serial.print("deb:"); Serial.print((String)text); Serial.print("\n");
}
void Debug(long text)
{
Serial.print("deb:"); Serial.print((String)text); Serial.print("\n");
}
void Error(String text)
{
Serial.print("err:");Serial.print(text);Serial.print("\n");
}
void Error(float text)
{
Serial.print("err:"); Serial.print((String)text); Serial.print("\n");
}
void Error(int text)
{
Serial.print("err:"); Serial.print((String)text); Serial.print("\n");
}
void Error(long text)
{
Serial.print("err:"); Serial.print((String)text); Serial.print("\n");
}
}
#ifndef _EMBRIOARDUINO_h
#define _EMBRIOARDUINO_h
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
extern long sliceMicros;
extern long startMicros;
void EmbrioWait(long);
// Process a function and wait for the unused micros so that the total execution time takes maxMicros.
// The number of microseconds waited is returned.
long ProcessTimedFunction(void (*fun)(), long maxMicros);
void MarkChange(bool *bools[], int cnt);
void MarkNoChange(bool *bools, int cnt);
int GetTriggerIndex(bool *bools, int cnt);
void EmbrioDebug(String text);
void Debug(String text);
void Debug(float text);
void Debug(int text);
void Debug(long text);
void Error(String text);
void Error(float text);
void Error(int text);
void Error(long text);
#endif
#ifndef _EMBRIOARDUINO_h
#define _EMBRIOARDUINO_h
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
extern long sliceMicros;
extern long startMicros;
void EmbrioWait(long);
// Process a function and wait for the unused micros so that the total execution time takes maxMicros.
// The number of microseconds waited is returned.
long ProcessTimedFunction(void (*fun)(), long maxMicros);
void MarkChange(bool *bools[], int cnt);
void MarkNoChange(bool *bools, int cnt);
int GetTriggerIndex(bool *bools, int cnt);
void EmbrioDebug(String text);
void Debug(String text);
void Debug(float text);
void Debug(int text);
void Debug(long text);
void Error(String text);
void Error(float text);
void Error(int text);
void Error(long text);
#endif
#include "EmbrioMath.h"
#include <stdarg.h>
// Transform the input value from the input range to the output range
float transform(float input, float inputMin, float inputMax, float outputMin, float outputMax)
{
float inputRange = inputMax - inputMin;
float outputRange = outputMax - outputMin;
if (inputRange == 0 || outputRange == 0) {
return 0.0;
} else {
float scale = inputRange / outputRange;
return outputMin + ((input - inputMin) / scale);
}
}
int transformInt(int input, int inputMin, int inputMax, int outputMin, int outputMax)
{
int inputRange = inputMax - inputMin;
int outputRange = outputMax - outputMin;
if (inputRange == 0 || outputRange == 0) {
return 0.0;
} else {
int scale = inputRange / outputRange;
return outputMin + ((input - inputMin) / scale);
}
}
long transformLong(long input, long inputMin, long inputMax, long outputMin, long outputMax)
{
long inputRange = inputMax - inputMin;
long outputRange = outputMax - outputMin;
if (inputRange == 0 || outputRange == 0) {
return 0.0;
} else {
long scale = inputRange / outputRange;
return outputMin + ((input - inputMin) / scale);
}
}
float clamp(float value, float rangeMin, float rangeMax)
{
if (value < rangeMin)
return rangeMin;
else if (value > rangeMax)
return rangeMax;
return value;
}
long clamp(long value, long rangeMin, long rangeMax)
{
if (value < rangeMin)
return rangeMin;
else if (value > rangeMax)
return rangeMax;
return value;
}
// EmbrioMath.h
#ifndef _EMBRIOMATH_h
#define _EMBRIOMATH_h
// Transform the input value from the input range to the output range
extern float transform(float input, float inputMin, float inputMax, float outputMin, float outputMax);
extern int transformInt(int input, int inputMin, int inputMax, int outputMin, int outputMax);
extern long transformLong(long input, long inputMin, long inputMax, long outputMin, long outputMax);
float clamp(float value, float rangeMin, float rangeMax);
long clamp(long value, long rangeMin, long rangeMax);
#endif
#include "LiquidCrystal_I2C.h"
#include <inttypes.h>
#include <Arduino.h>
#include <Wire.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_I2C::LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize)
{
_addr = lcd_addr;
_cols = lcd_cols;
_rows = lcd_rows;
_charsize = charsize;
_backlightval = LCD_BACKLIGHT;
}
void LiquidCrystal_I2C::begin() {
Wire.begin();
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
if (_rows > 1) {
_displayfunction |= LCD_2LINE;
}
// for some 1 line displays you can select a 10 pixel high font
if ((_charsize != 0) && (_rows == 1)) {
_displayfunction |= LCD_5x10DOTS;
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
delay(50);
// Now we pull both RS and R/W low to begin commands
expanderWrite(_backlightval); // reset expanderand turn backlight off (Bit 8 =1)
delay(1000);
//put the LCD into 4 bit mode
// 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 << 4);
delayMicroseconds(4500); // wait min 4.1ms
// second try
write4bits(0x03 << 4);
delayMicroseconds(4500); // wait min 4.1ms
// third go!
write4bits(0x03 << 4);
delayMicroseconds(150);
// finally, set to 4-bit interface
write4bits(0x02 << 4);
// 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 roman languages)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
// set the entry mode
command(LCD_ENTRYMODESET | _displaymode);
home();
}
/********** high level commands, for the user! */
void LiquidCrystal_I2C::clear(){
command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal_I2C::home(){
command(LCD_RETURNHOME); // set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
if (row > _rows) {
row = _rows-1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}
// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
_displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
_displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
_displaycontrol &= ~LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
_displaycontrol |= LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
_displaycontrol &= ~LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
_displaycontrol |= LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}
// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
_displaymode |= LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
_displaymode &= ~LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
_displaymode |= LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
location &= 0x7; // we only have 8 locations 0-7
command(LCD_SETCGRAMADDR | (location << 3));
for (int i=0; i<8; i++) {
write(charmap[i]);
}
}
// Turn the (optional) backlight off/on
void LiquidCrystal_I2C::noBacklight(void) {
_backlightval=LCD_NOBACKLIGHT;
expanderWrite(0);
}
void LiquidCrystal_I2C::backlight(void) {
_backlightval=LCD_BACKLIGHT;
expanderWrite(0);
}
bool LiquidCrystal_I2C::getBacklight() {
return _backlightval == LCD_BACKLIGHT;
}
/*********** mid level commands, for sending data/cmds */
inline void LiquidCrystal_I2C::command(uint8_t value) {
send(value, 0);
}
inline size_t LiquidCrystal_I2C::write(uint8_t value) {
send(value, Rs);
return 1;
}
/************ low level data pushing commands **********/
// write either command or data
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
uint8_t highnib=value&0xf0;
uint8_t lownib=(value<<4)&0xf0;
write4bits((highnib)|mode);
write4bits((lownib)|mode);
}
void LiquidCrystal_I2C::write4bits(uint8_t value) {
expanderWrite(value);
pulseEnable(value);
}
void LiquidCrystal_I2C::expanderWrite(uint8_t _data){
Wire.beginTransmission(_addr);
Wire.write((int)(_data) | _backlightval);
Wire.endTransmission();
}
void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
expanderWrite(_data | En); // En high
delayMicroseconds(1); // enable pulse must be >450ns
expanderWrite(_data & ~En); // En low
delayMicroseconds(50); // commands need > 37us to settle
}
void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
createChar(char_num, rows);
}
void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
if (new_val) {
backlight(); // turn backlight on
} else {
noBacklight(); // turn backlight off
}
}
void LiquidCrystal_I2C::printstr(const char c[]){
//This function is not identical to the function used for "real" I2C displays
//it's here so the user sketch doesn't have to be changed
print(c);
}
#ifndef FDB_LIQUID_CRYSTAL_I2C_H
#define FDB_LIQUID_CRYSTAL_I2C_H
#include <inttypes.h>
#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
// flags for backlight control
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00
#define En B00000100 // Enable bit
#define Rw B00000010 // Read/Write bit
#define Rs B00000001 // Register select bit
/**
* This is the driver for the Liquid Crystal LCD displays that use the I2C bus.
*
* After creating an instance of this class, first call begin() before anything else.
* The backlight is on by default, since that is the most likely operating mode in
* most cases.
*/
class LiquidCrystal_I2C : public Print {
public:
/**
* Constructor
*
* @param lcd_addr I2C slave address of the LCD display. Most likely printed on the
* LCD circuit board, or look in the supplied LCD documentation.
* @param lcd_cols Number of columns your LCD display has.
* @param lcd_rows Number of rows your LCD display has.
* @param charsize The size in dots that the display has, use LCD_5x10DOTS or LCD_5x8DOTS.
*/
LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize = LCD_5x8DOTS);
/**
* Set the LCD display in the correct begin state, must be called before anything else is done.
*/
void begin();
/**
* Remove all the characters currently shown. Next print/write operation will start
* from the first position on LCD display.
*/
void clear();
/**
* Next print/write operation will will start from the first position on the LCD display.
*/
void home();
/**
* Do not show any characters on the LCD display. Backlight state will remain unchanged.
* Also all characters written on the display will return, when the display in enabled again.
*/
void noDisplay();
/**
* Show the characters on the LCD display, this is the normal behaviour. This method should
* only be used after noDisplay() has been used.
*/
void display();
/**
* Do not blink the cursor indicator.
*/
void noBlink();
/**
* Start blinking the cursor indicator.
*/
void blink();
/**
* Do not show a cursor indicator.
*/
void noCursor();
/**
* Show a cursor indicator, cursor can blink on not blink. Use the
* methods blink() and noBlink() for changing cursor blink.
*/
void cursor();
void scrollDisplayLeft();
void scrollDisplayRight();
void printLeft();
void printRight();
void leftToRight();
void rightToLeft();
void shiftIncrement();
void shiftDecrement();
void noBacklight();
void backlight();
bool getBacklight();
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);
inline void blink_on() { blink(); }
inline void blink_off() { noBlink(); }
inline void cursor_on() { cursor(); }
inline void cursor_off() { noCursor(); }
// Compatibility API function aliases
void setBacklight(uint8_t new_val); // alias for backlight() and nobacklight()
void load_custom_character(uint8_t char_num, uint8_t *rows); // alias for createChar()
void printstr(const char[]);
private:
void send(uint8_t, uint8_t);
void write4bits(uint8_t);
void expanderWrite(uint8_t);
void pulseEnable(uint8_t);
uint8_t _addr;
uint8_t _displayfunction;
uint8_t _displaycontrol;
uint8_t _displaymode;
uint8_t _cols;
uint8_t _rows;
uint8_t _charsize;
uint8_t _backlightval;
};
#endif // FDB_LIQUID_CRYSTAL_I2C_H