Welcome Guest! To enable all features please Login or Register.
Options
Go to last post Go to first unread
KouraMan  
#21 Posted : Tuesday, December 13, 2022 11:49:13 AM(UTC)
KouraMan

Rank: Newbie

Groups: Registered
Joined: 4/19/2017(UTC)
Posts: 2
Finland

Was thanked: 1 time(s) in 1 post(s)
#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
thanks 1 user thanked KouraMan for this useful post.
sample@email.tst on 4/7/2024(UTC)
sample@email.tst  
#22 Posted : Sunday, April 07, 2024 11:22:46 AM(UTC)
sample@email.tst

Rank: Newbie

Groups: Registered
Joined: 4/7/2024(UTC)
Posts: 8

Thanks: 171 times
555
sample@email.tst  
#23 Posted : Sunday, April 07, 2024 11:23:17 AM(UTC)
sample@email.tst

Rank: Newbie

Groups: Registered
Joined: 4/7/2024(UTC)
Posts: 8

Thanks: 171 times
555
sample@email.tst  
#24 Posted : Sunday, April 07, 2024 11:23:49 AM(UTC)
sample@email.tst

Rank: Newbie

Groups: Registered
Joined: 4/7/2024(UTC)
Posts: 8

Thanks: 171 times
555
sample@email.tst  
#25 Posted : Sunday, April 07, 2024 11:24:20 AM(UTC)
sample@email.tst

Rank: Newbie

Groups: Registered
Joined: 4/7/2024(UTC)
Posts: 8

Thanks: 171 times
555
Forum Jump  
You cannot post new topics in this forum.
You cannot reply to topics in this forum.
You cannot delete your posts in this forum.
You cannot edit your posts in this forum.
You cannot create polls in this forum.
You cannot vote in polls in this forum.

Notification

Icon
Error