alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-03-24 01:10:22 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

i2clcd: use the mraa C++ API instead of the C API

Browse Source 
Rewrite the i2c module to be based around the MRAA C++ API,
since this makes resource management easier inside of the UPM
C++ classes.

i2clcd.{h,cxx}: remove the close() function. This now automatically gets
called when the object goes out of scope, inside the destructor.

examples/i2clcd: fix C++/Python/Javascript examples that explicitly called the close function.
The I2c context now gets called by the destructor of the sensor class. This
happens when the object goes out of scope or when it gets deleted, if the
object was created using the new keyword, as is the case here.

Signed-off-by: Wouter van Verre <wouter.van.verre@intel.com>
Signed-off-by: Mihai Tudor Panu <mihai.tudor.panu@intel.com>
This commit is contained in:
Wouter van Verre 2015-04-20 14:15:41 +01:00 committed by Mihai Tudor Panu
parent 53b58225a4
commit 31c4f470fe
17 changed files with 130 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/c++/jhd1313m1-lcd.cxx
View File

@ -34,6 +34,6 @@ main(int argc, char **argv)
lcd->write("Hello World"); lcd->write("Hello World");
lcd->setCursor(1,2); lcd->setCursor(1,2);
lcd->write("Hello World"); lcd->write("Hello World");
lcd->close(); delete lcd;
//! [Interesting] //! [Interesting]
} }

2
examples/c++/lcm1602-lcd.cxx
View File

@ -38,5 +38,5 @@ main(int argc, char **argv)
lcd->write("Hello World"); lcd->write("Hello World");
lcd->setCursor(3,6); lcd->setCursor(3,6);
lcd->write("Hello World"); lcd->write("Hello World");
lcd->close(); delete lcd;
} }

2
examples/c++/ssd1308-oled.cxx
View File

@ -93,6 +93,6 @@ main(int argc, char **argv)
lcd->clear(); lcd->clear();
lcd->draw(intel_logo, 1024); lcd->draw(intel_logo, 1024);
lcd->close(); delete lcd;
//! [Interesting] //! [Interesting]
} }

2
examples/c++/ssd1327-oled.cxx
View File

@ -121,6 +121,6 @@ main(int argc, char **argv)
lcd->write("Hello World"); lcd->write("Hello World");
} }
lcd->close(); delete lcd;
//! [Interesting] //! [Interesting]
} }

1
examples/javascript/oled_ssd1308.js
View File

@ -93,7 +93,6 @@ for (var x = 0; x < logoArr.length; x++)
myLcd.clear(); myLcd.clear();
myLcd.draw(intelLogo, 1024); myLcd.draw(intelLogo, 1024);
myLcd.close();
intelLogo = null; intelLogo = null;
myLcd = null; myLcd = null;
LCD.cleanUp(); LCD.cleanUp();

1
examples/javascript/oled_ssd1327.js
View File

@ -191,5 +191,4 @@ for (var i = 0; i < 12; i++)
myLcd.write('Hello World'); myLcd.write('Hello World');
} }
myLcd.close();

1
examples/javascript/rgb-lcd.js
View File

@ -39,4 +39,3 @@ myLcd.setColor(255, 0, 0);
myLcd.write('Hello World'); myLcd.write('Hello World');
myLcd.setCursor(1,2); myLcd.setCursor(1,2);
myLcd.write('Hello World'); myLcd.write('Hello World');
myLcd.close();

1
examples/python/oled_ssd1308.py
View File

@ -89,7 +89,6 @@ for x in range(len(logoArr)):
intelLogo.__setitem__(x, logoArr[x]) intelLogo.__setitem__(x, logoArr[x])
myLCD.clear() myLCD.clear()
myLCD.draw(intelLogo, 1024) myLCD.draw(intelLogo, 1024)
myLCD.close()
del intelLogo del intelLogo
del myLCD del myLCD

2
examples/python/oled_ssd1327.py
View File

@ -186,6 +186,4 @@ for i in range(12):
myLCD.setGrayLevel(i) myLCD.setGrayLevel(i)
myLCD.write('Hello World') myLCD.write('Hello World')
myLCD.close()
print "Exiting" print "Exiting"

1
examples/python/rgb-lcd.py
View File

@ -36,4 +36,3 @@ myLcd.setColor(255, 0, 0)
myLcd.write('Hello World') myLcd.write('Hello World')
myLcd.setCursor(1,2) myLcd.setCursor(1,2)
myLcd.write('Hello World') myLcd.write('Hello World')
myLcd.close()

16
src/lcd/i2clcd.cxx
View File

@ -30,14 +30,12 @@
using namespace upm; using namespace upm;
I2CLcd::I2CLcd(int bus, int lcdAddress) I2CLcd::I2CLcd(int bus, int lcdAddress) : m_i2c_lcd_control(bus)
{ {
m_lcd_control_address = lcdAddress; m_lcd_control_address = lcdAddress;
m_bus = bus; m_bus = bus;
m_i2c_lcd_control = mraa_i2c_init(m_bus); mraa_result_t ret = m_i2c_lcd_control.address(m_lcd_control_address);
mraa_result_t ret = mraa_i2c_address(m_i2c_lcd_control, m_lcd_control_address);
if (ret != MRAA_SUCCESS) { if (ret != MRAA_SUCCESS) {
fprintf(stderr, "Messed up i2c bus\n"); fprintf(stderr, "Messed up i2c bus\n");
} }
@ -55,22 +53,16 @@ I2CLcd::createChar(uint8_t charSlot, uint8_t charData[])
{ {
mraa_result_t error = MRAA_SUCCESS; mraa_result_t error = MRAA_SUCCESS;
charSlot &= 0x07; // only have 8 positions we can set charSlot &= 0x07; // only have 8 positions we can set
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, LCD_SETCGRAMADDR | (charSlot << 3), LCD_CMD); error = m_i2c_lcd_control.writeReg(LCD_CMD, LCD_SETCGRAMADDR | (charSlot << 3));
if (error == MRAA_SUCCESS) { if (error == MRAA_SUCCESS) {
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, charData[i], LCD_DATA); error = m_i2c_lcd_control.writeReg(LCD_DATA, charData[i]);
} }
} }
return error; return error;
} }
mraa_result_t
I2CLcd::close()
{
return mraa_i2c_stop(m_i2c_lcd_control);
}
std::string std::string
I2CLcd::name() I2CLcd::name()
{ {

6
src/lcd/i2clcd.h
View File

@ -24,7 +24,7 @@
#pragma once #pragma once
#include <string> #include <string>
#include <mraa/i2c.h> #include <mraa/i2c.hpp>
namespace upm namespace upm
{ {
@ -92,13 +92,13 @@ class I2CLcd
virtual mraa_result_t home() = 0; virtual mraa_result_t home() = 0;
virtual mraa_result_t createChar(uint8_t charSlot, uint8_t charData[]); virtual mraa_result_t createChar(uint8_t charSlot, uint8_t charData[]);
mraa_result_t close();
std::string name(); std::string name();
protected: protected:
std::string m_name; std::string m_name;
int m_lcd_control_address; int m_lcd_control_address;
int m_bus; int m_bus;
mraa_i2c_context m_i2c_lcd_control;
mraa::I2c m_i2c_lcd_control;
}; };
} }

62
src/lcd/jhd1313m1.cxx
View File

@ -31,22 +31,26 @@
using namespace upm; using namespace upm;
Jhd1313m1::Jhd1313m1(int bus, int lcdAddress, int rgbAddress) : I2CLcd(bus, lcdAddress) Jhd1313m1::Jhd1313m1(int bus, int lcdAddress, int rgbAddress)
: I2CLcd(bus, lcdAddress), m_i2c_lcd_rgb(bus)
{ {
m_rgb_address = rgbAddress; m_rgb_address = rgbAddress;
m_i2c_lcd_rgb = mraa_i2c_init(m_bus);
mraa_result_t ret = mraa_i2c_address(m_i2c_lcd_rgb, m_rgb_address); mraa_result_t ret = m_i2c_lcd_rgb.address(m_rgb_address);
if (ret != MRAA_SUCCESS) { if (ret != MRAA_SUCCESS) {
fprintf(stderr, "Messed up i2c bus\n"); fprintf(stderr, "Messed up i2c bus\n");
} }
usleep(50000); usleep(50000);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_control, LCD_FUNCTIONSET | LCD_2LINE, LCD_CMD); ret = m_i2c_lcd_control.writeReg(LCD_CMD, LCD_FUNCTIONSET | LCD_2LINE);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller");
if (!ret) {
ret = m_i2c_lcd_control.writeReg(LCD_CMD, LCD_FUNCTIONSET | LCD_2LINE);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller");
}
usleep(100); usleep(100);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_control, LCD_DISPLAYCONTROL | LCD_DISPLAYON, LCD_CMD); ret = m_i2c_lcd_control.writeReg(LCD_CMD, LCD_DISPLAYCONTROL | LCD_DISPLAYON);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller");
usleep(100); usleep(100);
@ -54,23 +58,22 @@ Jhd1313m1::Jhd1313m1(int bus, int lcdAddress, int rgbAddress) : I2CLcd(bus, lcdA
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller");
usleep(2000); usleep(2000);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_control, ret =
LCD_ENTRYMODESET | LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT, m_i2c_lcd_control.writeReg(LCD_CMD, LCD_ENTRYMODESET | LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT);
LCD_CMD);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller");
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0, 0); ret = m_i2c_lcd_rgb.writeReg(0, 0);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller");
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0, 1); ret = m_i2c_lcd_rgb.writeReg(1, 0);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller");
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0xAA, 0x08); ret = m_i2c_lcd_rgb.writeReg(0x08, 0xAA);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller");
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0xFF, 0x04); ret = m_i2c_lcd_rgb.writeReg(0x04, 0xFF);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller");
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0xFF, 0x03); ret = m_i2c_lcd_rgb.writeReg(0x03, 0xFF);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller");
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0xFF, 0x02); ret = m_i2c_lcd_rgb.writeReg(0x02, 0xFF);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller"); UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the RGB controller");
} }
@ -83,18 +86,18 @@ Jhd1313m1::setColor(uint8_t r, uint8_t g, uint8_t b)
{ {
mraa_result_t ret; mraa_result_t ret;
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0, 0); ret = m_i2c_lcd_rgb.writeReg(0, 0);
UPM_GOTO_ON_MRAA_FAIL(ret, beach); UPM_GOTO_ON_MRAA_FAIL(ret, beach);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0, 1); ret = m_i2c_lcd_rgb.writeReg(1, 0);
UPM_GOTO_ON_MRAA_FAIL(ret, beach); UPM_GOTO_ON_MRAA_FAIL(ret, beach);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, 0xAA, 0x08); ret = m_i2c_lcd_rgb.writeReg(0x08, 0xAA);
UPM_GOTO_ON_MRAA_FAIL(ret, beach); UPM_GOTO_ON_MRAA_FAIL(ret, beach);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, r, 0x04); ret = m_i2c_lcd_rgb.writeReg(0x04, r);
UPM_GOTO_ON_MRAA_FAIL(ret, beach); UPM_GOTO_ON_MRAA_FAIL(ret, beach);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, g, 0x03); ret = m_i2c_lcd_rgb.writeReg(0x03, g);
UPM_GOTO_ON_MRAA_FAIL(ret, beach); UPM_GOTO_ON_MRAA_FAIL(ret, beach);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, b, 0x02); ret = m_i2c_lcd_rgb.writeReg(0x02, b);
beach: beach:
return ret; return ret;
@ -104,13 +107,10 @@ mraa_result_t
Jhd1313m1::scroll(bool direction) Jhd1313m1::scroll(bool direction)
{ {
if (direction) { if (direction) {
return mraa_i2c_write_byte_data(m_i2c_lcd_control, return m_i2c_lcd_control.writeReg(LCD_CMD, LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT,
LCD_CMD);
} else { } else {
return mraa_i2c_write_byte_data(m_i2c_lcd_control, return m_i2c_lcd_control.writeReg(LCD_CMD,
LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT, LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
LCD_CMD);
} }
} }
@ -128,7 +128,7 @@ Jhd1313m1::write(std::string msg)
usleep(1000); usleep(1000);
for (std::string::size_type i = 0; i < msg.size(); ++i) { for (std::string::size_type i = 0; i < msg.size(); ++i) {
ret = mraa_i2c_write_byte_data(m_i2c_lcd_control, msg[i], LCD_DATA); ret = m_i2c_lcd_control.writeReg(LCD_DATA, msg[i]);
UPM_GOTO_ON_MRAA_FAIL(ret, beach); UPM_GOTO_ON_MRAA_FAIL(ret, beach);
} }
@ -144,7 +144,7 @@ Jhd1313m1::setCursor(int row, int column)
int row_addr[] = { 0x80, 0xc0, 0x14, 0x54 }; int row_addr[] = { 0x80, 0xc0, 0x14, 0x54 };
uint8_t offset = ((column % 16) + row_addr[row]); uint8_t offset = ((column % 16) + row_addr[row]);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_control, offset, LCD_CMD); ret = m_i2c_lcd_control.writeReg(LCD_CMD, offset);
return ret; return ret;
} }
@ -152,11 +152,11 @@ Jhd1313m1::setCursor(int row, int column)
mraa_result_t mraa_result_t
Jhd1313m1::clear() Jhd1313m1::clear()
{ {
return mraa_i2c_write_byte_data(m_i2c_lcd_control, LCD_CLEARDISPLAY, LCD_CMD); return m_i2c_lcd_control.writeReg(LCD_CMD, LCD_CLEARDISPLAY);
} }
mraa_result_t mraa_result_t
Jhd1313m1::home() Jhd1313m1::home()
{ {
return mraa_i2c_write_byte_data(m_i2c_lcd_control, LCD_RETURNHOME, LCD_CMD); return m_i2c_lcd_control.writeReg(LCD_CMD, LCD_RETURNHOME);
} }

2
src/lcd/jhd1313m1.h
View File

@ -112,6 +112,6 @@ class Jhd1313m1 : public I2CLcd
private: private:
int m_rgb_address; int m_rgb_address;
mraa_i2c_context m_i2c_lcd_rgb; mraa::I2c m_i2c_lcd_rgb;
}; };
} }

2
src/lcd/lcm1602.cxx
View File

@ -132,7 +132,7 @@ mraa_result_t
Lcm1602::expandWrite(uint8_t value) Lcm1602::expandWrite(uint8_t value)
{ {
uint8_t buffer = value | LCD_BACKLIGHT; uint8_t buffer = value | LCD_BACKLIGHT;
return mraa_i2c_write_byte(m_i2c_lcd_control, buffer); return m_i2c_lcd_control.writeByte(buffer);
} }
mraa_result_t mraa_result_t

40
src/lcd/ssd1308.cxx
View File

@ -31,9 +31,9 @@ using namespace upm;
SSD1308::SSD1308(int bus_in, int addr_in) : I2CLcd(bus_in, addr_in) SSD1308::SSD1308(int bus_in, int addr_in) : I2CLcd(bus_in, addr_in)
{ {
mraa_i2c_write_byte_data(m_i2c_lcd_control, DISPLAY_CMD_OFF, LCD_CMD); // display off m_i2c_lcd_control.writeReg(LCD_CMD, DISPLAY_CMD_OFF); // display off
usleep(4500); usleep(4500);
mraa_i2c_write_byte_data(m_i2c_lcd_control, DISPLAY_CMD_ON, LCD_CMD); // display on m_i2c_lcd_control.writeReg(LCD_CMD, DISPLAY_CMD_ON); // display on
usleep(4500); usleep(4500);
setNormalDisplay(); // set to normal display '1' is ON setNormalDisplay(); // set to normal display '1' is ON
@ -52,7 +52,7 @@ SSD1308::draw(uint8_t* data, int bytes)
setAddressingMode(HORIZONTAL); setAddressingMode(HORIZONTAL);
for (int idx = 0; idx < bytes; idx++) { for (int idx = 0; idx < bytes; idx++) {
mraa_i2c_write_byte_data(m_i2c_lcd_control, data[idx], LCD_DATA); m_i2c_lcd_control.writeReg(LCD_DATA, data[idx]);
} }
return error; return error;
@ -82,15 +82,13 @@ SSD1308::setCursor(int row, int column)
{ {
mraa_result_t error = MRAA_SUCCESS; mraa_result_t error = MRAA_SUCCESS;
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, error = m_i2c_lcd_control.writeReg(LCD_CMD, BASE_PAGE_START_ADDR + row); // set page address
BASE_PAGE_START_ADDR + row, error = m_i2c_lcd_control.writeReg(LCD_CMD,
LCD_CMD); // set page address BASE_LOW_COLUMN_ADDR + (8 * column & 0x0F)); // set column
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, // lower address
BASE_LOW_COLUMN_ADDR + (8 * column & 0x0F), error = m_i2c_lcd_control.writeReg(LCD_CMD,
LCD_CMD); // set column lower address BASE_HIGH_COLUMN_ADDR +
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, ((8 * column >> 4) & 0x0F)); // set column higher address
BASE_HIGH_COLUMN_ADDR + ((8 * column >> 4) & 0x0F),
LCD_CMD); // set column higher address
return error; return error;
} }
@ -101,7 +99,7 @@ SSD1308::clear()
mraa_result_t error = MRAA_SUCCESS; mraa_result_t error = MRAA_SUCCESS;
uint8_t columnIdx, rowIdx; uint8_t columnIdx, rowIdx;
mraa_i2c_write_byte_data(m_i2c_lcd_control, DISPLAY_CMD_OFF, LCD_CMD); // display off m_i2c_lcd_control.writeReg(LCD_CMD, DISPLAY_CMD_OFF); // display off
for (rowIdx = 0; rowIdx < 8; rowIdx++) { for (rowIdx = 0; rowIdx < 8; rowIdx++) {
setCursor(rowIdx, 0); setCursor(rowIdx, 0);
@ -110,7 +108,7 @@ SSD1308::clear()
writeChar(' '); writeChar(' ');
} }
} }
mraa_i2c_write_byte_data(m_i2c_lcd_control, DISPLAY_CMD_ON, LCD_CMD); // display on m_i2c_lcd_control.writeReg(LCD_CMD, DISPLAY_CMD_ON); // display on
home(); home();
return MRAA_SUCCESS; return MRAA_SUCCESS;
@ -135,23 +133,21 @@ SSD1308::writeChar(uint8_t value)
} }
for (uint8_t idx = 0; idx < 8; idx++) { for (uint8_t idx = 0; idx < 8; idx++) {
mraa_i2c_write_byte_data(m_i2c_lcd_control, BasicFont[value - 32][idx], LCD_DATA); m_i2c_lcd_control.writeReg(LCD_DATA, BasicFont[value - 32][idx]);
} }
} }
mraa_result_t mraa_result_t
SSD1308::setNormalDisplay() SSD1308::setNormalDisplay()
{ {
return mraa_i2c_write_byte_data(m_i2c_lcd_control, return m_i2c_lcd_control.writeReg(LCD_CMD,
DISPLAY_CMD_SET_NORMAL_1308, DISPLAY_CMD_SET_NORMAL_1308); // set to normal display '1' is
LCD_CMD); // set to normal display '1' is ON // ON
} }
mraa_result_t mraa_result_t
SSD1308::setAddressingMode(displayAddressingMode mode) SSD1308::setAddressingMode(displayAddressingMode mode)
{ {
mraa_i2c_write_byte_data(m_i2c_lcd_control, m_i2c_lcd_control.writeReg(LCD_CMD, DISPLAY_CMD_MEM_ADDR_MODE); // set addressing mode
DISPLAY_CMD_MEM_ADDR_MODE, m_i2c_lcd_control.writeReg(LCD_CMD, mode); // set page addressing mode
LCD_CMD); // set addressing mode
mraa_i2c_write_byte_data(m_i2c_lcd_control, mode, LCD_CMD); // set page addressing mode
} }

141
src/lcd/ssd1327.cxx
View File

@ -36,96 +36,92 @@ SSD1327::SSD1327(int bus_in, int addr_in) : I2CLcd(bus_in, addr_in)
{ {
mraa_result_t error = MRAA_SUCCESS; mraa_result_t error = MRAA_SUCCESS;
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xFD, LCD_CMD); // Unlock OLED driver IC MCU m_i2c_lcd_control.writeReg(LCD_CMD, 0xFD); // Unlock OLED driver IC MCU
// interface from entering command. // interface from entering command.
// i.e: Accept commands // i.e: Accept commands
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x12, LCD_CMD); m_i2c_lcd_control.writeReg(LCD_CMD, 0x12);
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xAE, LCD_CMD); // Set display off error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xAE); // Set display off
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xA8, LCD_CMD); // set multiplex ratio m_i2c_lcd_control.writeReg(LCD_CMD, 0xA8); // set multiplex ratio
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x5F, LCD_CMD); // 96 error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x5F); // 96
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xA1, LCD_CMD); // set display start line error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xA1); // set display start line
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x00, LCD_CMD); // error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x00); //
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xA2, LCD_CMD); // set display offset error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xA2); // set display offset
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x60, LCD_CMD); error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x60);
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xA0, LCD_CMD); // set remap error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xA0); // set remap
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x46, LCD_CMD); error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x46);
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xAB, LCD_CMD); // set vdd internal error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xAB); // set vdd internal
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x01, LCD_CMD); // error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x01); //
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x81, LCD_CMD); // set contrasr error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x81); // set contrasr
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x53, LCD_CMD); // 100 nit error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x53); // 100 nit
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xB1, LCD_CMD); // Set Phase Length error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xB1); // Set Phase Length
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0X51, LCD_CMD); // error = m_i2c_lcd_control.writeReg(LCD_CMD, 0X51); //
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xB3); // Set Display Clock Divide Ratio/Oscillator
0xB3, // Frequency
LCD_CMD); // Set Display Clock Divide Ratio/Oscillator
// Frequency
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x01, LCD_CMD); // error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x01); //
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xB9, LCD_CMD); // error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xB9); //
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xBC, LCD_CMD); // set pre_charge error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xBC); // set pre_charge
// voltage/VCOMH // voltage/VCOMH
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x08, LCD_CMD); // (0x08); error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x08); // (0x08);
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xBE, LCD_CMD); // set VCOMH error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xBE); // set VCOMH
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0X07, LCD_CMD); // (0x07); error = m_i2c_lcd_control.writeReg(LCD_CMD, 0X07); // (0x07);
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xB6, LCD_CMD); // Set second pre-charge error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xB6); // Set second pre-charge
// period // period
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x01, LCD_CMD); // error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x01); //
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xD5); // enable second precharge and enternal vsl
0xD5,
LCD_CMD); // enable second precharge and enternal vsl
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0X62, LCD_CMD); // (0x62); error = m_i2c_lcd_control.writeReg(LCD_CMD, 0X62); // (0x62);
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xA4, LCD_CMD); // Set Normal Display Mode error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xA4); // Set Normal Display Mode
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x2E, LCD_CMD); // Deactivate Scroll error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x2E); // Deactivate Scroll
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xAF, LCD_CMD); // Switch on display error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xAF); // Switch on display
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
// Row Address // Row Address
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x75, LCD_CMD); // Set Row Address error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x75); // Set Row Address
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x00, LCD_CMD); // Start 0 error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x00); // Start 0
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x5f, LCD_CMD); // End 95 error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x5f); // End 95
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
// Column Address // Column Address
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x15, LCD_CMD); // Set Column Address error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x15); // Set Column Address
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x08, LCD_CMD); // Start from 8th Column of error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x08); // Start from 8th Column of
// driver IC. This is 0th // driver IC. This is 0th
// Column for OLED // Column for OLED
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x37, LCD_CMD); // End at (8 + 47)th error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x37); // End at (8 + 47)th
// column. Each Column has 2 // column. Each Column has 2
// pixels(segments) // pixels(segments)
usleep(INIT_SLEEP); usleep(INIT_SLEEP);
clear(); clear();
@ -153,7 +149,7 @@ SSD1327::draw(uint8_t* data, int bytes)
value |= (bitOne) ? grayHigh : 0x00; value |= (bitOne) ? grayHigh : 0x00;
value |= (bitTwo) ? grayLow : 0x00; value |= (bitTwo) ? grayLow : 0x00;
mraa_i2c_write_byte_data(m_i2c_lcd_control, value, LCD_DATA); m_i2c_lcd_control.writeReg(LCD_DATA, value);
usleep(CMD_SLEEP - 2000); usleep(CMD_SLEEP - 2000);
} }
} }
@ -185,19 +181,19 @@ SSD1327::setCursor(int row, int column)
mraa_result_t error = MRAA_SUCCESS; mraa_result_t error = MRAA_SUCCESS;
// Column Address // Column Address
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x15, LCD_CMD); /* Set Column Address */ m_i2c_lcd_control.writeReg(LCD_CMD, 0x15); /* Set Column Address */
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x08 + (column * 4), LCD_CMD); /* Start Column: m_i2c_lcd_control.writeReg(LCD_CMD, 0x08 + (column * 4)); /* Start Column:
Start from 8 */ Start from 8 */
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x37, LCD_CMD); /* End Column */ m_i2c_lcd_control.writeReg(LCD_CMD, 0x37); /* End Column */
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
// Row Address // Row Address
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x75, LCD_CMD); /* Set Row Address */ m_i2c_lcd_control.writeReg(LCD_CMD, 0x75); /* Set Row Address */
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x00 + (row * 8), LCD_CMD); /* Start Row*/ m_i2c_lcd_control.writeReg(LCD_CMD, 0x00 + (row * 8)); /* Start Row*/
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x07 + (row * 8), LCD_CMD); /* End Row*/ m_i2c_lcd_control.writeReg(LCD_CMD, 0x07 + (row * 8)); /* End Row*/
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
return error; return error;
@ -254,7 +250,7 @@ SSD1327::writeChar(uint8_t value)
data |= (bitOne) ? grayHigh : 0x00; data |= (bitOne) ? grayHigh : 0x00;
data |= (bitTwo) ? grayLow : 0x00; data |= (bitTwo) ? grayLow : 0x00;
mraa_i2c_write_byte_data(m_i2c_lcd_control, data, LCD_DATA); m_i2c_lcd_control.writeReg(LCD_DATA, data);
usleep(CMD_SLEEP - 2000); usleep(CMD_SLEEP - 2000);
} }
} }
@ -263,43 +259,42 @@ SSD1327::writeChar(uint8_t value)
mraa_result_t mraa_result_t
SSD1327::setNormalDisplay() SSD1327::setNormalDisplay()
{ {
return mraa_i2c_write_byte_data(m_i2c_lcd_control, return m_i2c_lcd_control.writeReg(LCD_CMD,
DISPLAY_CMD_SET_NORMAL, DISPLAY_CMD_SET_NORMAL); // set to normal display '1' is ON
LCD_CMD); // set to normal display '1' is ON
} }
mraa_result_t mraa_result_t
SSD1327::setHorizontalMode() SSD1327::setHorizontalMode()
{ {
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xA0, LCD_CMD); // remap to m_i2c_lcd_control.writeReg(LCD_CMD, 0xA0); // remap to
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x42, LCD_CMD); // horizontal mode m_i2c_lcd_control.writeReg(LCD_CMD, 0x42); // horizontal mode
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
// Row Address // Row Address
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x75, LCD_CMD); // Set Row Address m_i2c_lcd_control.writeReg(LCD_CMD, 0x75); // Set Row Address
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x00, LCD_CMD); // Start 0 m_i2c_lcd_control.writeReg(LCD_CMD, 0x00); // Start 0
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x5f, LCD_CMD); // End 95 m_i2c_lcd_control.writeReg(LCD_CMD, 0x5f); // End 95
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
// Column Address // Column Address
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x15, LCD_CMD); // Set Column Address m_i2c_lcd_control.writeReg(LCD_CMD, 0x15); // Set Column Address
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x08, LCD_CMD); // Start from 8th Column of driver m_i2c_lcd_control.writeReg(LCD_CMD, 0x08); // Start from 8th Column of driver
// IC. This is 0th Column for OLED // IC. This is 0th Column for OLED
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x37, LCD_CMD); // End at (8 + 47)th column. Each m_i2c_lcd_control.writeReg(LCD_CMD, 0x37); // End at (8 + 47)th column. Each
// Column has 2 pixels(or segments) // Column has 2 pixels(or segments)
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
} }
mraa_result_t mraa_result_t
SSD1327::setVerticalMode() SSD1327::setVerticalMode()
{ {
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xA0, LCD_CMD); // remap to m_i2c_lcd_control.writeReg(LCD_CMD, 0xA0); // remap to
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x46, LCD_CMD); // Vertical mode m_i2c_lcd_control.writeReg(LCD_CMD, 0x46); // Vertical mode
usleep(CMD_SLEEP); usleep(CMD_SLEEP);
} }