alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-03-15 04:57:30 +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->setCursor(1,2);
lcd->write("Hello World");
lcd->close();
delete lcd;
//! [Interesting]
}

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

@ -38,5 +38,5 @@ main(int argc, char **argv)
lcd->write("Hello World");
lcd->setCursor(3,6);
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->draw(intel_logo, 1024);
lcd->close();
delete lcd;
//! [Interesting]
}

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

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

1
examples/javascript/oled_ssd1308.js
View File

@ -93,7 +93,6 @@ for (var x = 0; x < logoArr.length; x++)
myLcd.clear();
myLcd.draw(intelLogo, 1024);
myLcd.close();
intelLogo = null;
myLcd = null;
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.close();

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

@ -39,4 +39,3 @@ myLcd.setColor(255, 0, 0);
myLcd.write('Hello World');
myLcd.setCursor(1,2);
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])
myLCD.clear()
myLCD.draw(intelLogo, 1024)
myLCD.close()
del intelLogo
del myLCD

2
examples/python/oled_ssd1327.py
View File

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

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

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

16
src/lcd/i2clcd.cxx
View File

@ -30,14 +30,12 @@
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_bus = bus;
m_i2c_lcd_control = mraa_i2c_init(m_bus);
mraa_result_t ret = mraa_i2c_address(m_i2c_lcd_control, m_lcd_control_address);
mraa_result_t ret = m_i2c_lcd_control.address(m_lcd_control_address);
if (ret != MRAA_SUCCESS) {
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;
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) {
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;
}
mraa_result_t
I2CLcd::close()
{
return mraa_i2c_stop(m_i2c_lcd_control);
}
std::string
I2CLcd::name()
{

6
src/lcd/i2clcd.h
View File

@ -24,7 +24,7 @@
#pragma once
#include <string>
#include <mraa/i2c.h>
#include <mraa/i2c.hpp>
namespace upm
{
@ -92,13 +92,13 @@ class I2CLcd
virtual mraa_result_t home() = 0;
virtual mraa_result_t createChar(uint8_t charSlot, uint8_t charData[]);
mraa_result_t close();
std::string name();
protected:
std::string m_name;
int m_lcd_control_address;
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;
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_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) {
fprintf(stderr, "Messed up i2c bus\n");
}
usleep(50000);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_control, LCD_FUNCTIONSET | LCD_2LINE, LCD_CMD);
UPM_CHECK_MRAA_SUCCESS(ret, "Unable to initialise the LCD controller");
ret = m_i2c_lcd_control.writeReg(LCD_CMD, LCD_FUNCTIONSET | LCD_2LINE);
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);
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");
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");
usleep(2000);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_control,
LCD_ENTRYMODESET | LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT,
LCD_CMD);
ret =
m_i2c_lcd_control.writeReg(LCD_CMD, LCD_ENTRYMODESET | LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT);
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");
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");
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");
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");
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");
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");
}
@ -83,18 +86,18 @@ Jhd1313m1::setColor(uint8_t r, uint8_t g, uint8_t b)
{
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);
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);
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);
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);
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);
ret = mraa_i2c_write_byte_data(m_i2c_lcd_rgb, b, 0x02);
ret = m_i2c_lcd_rgb.writeReg(0x02, b);
beach:
return ret;
@ -104,13 +107,10 @@ mraa_result_t
Jhd1313m1::scroll(bool direction)
{
if (direction) {
return mraa_i2c_write_byte_data(m_i2c_lcd_control,
LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT,
LCD_CMD);
return m_i2c_lcd_control.writeReg(LCD_CMD, LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
} else {
return mraa_i2c_write_byte_data(m_i2c_lcd_control,
LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT,
LCD_CMD);
return m_i2c_lcd_control.writeReg(LCD_CMD,
LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}
}
@ -128,7 +128,7 @@ Jhd1313m1::write(std::string msg)
usleep(1000);
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);
}
@ -144,7 +144,7 @@ Jhd1313m1::setCursor(int row, int column)
int row_addr[] = { 0x80, 0xc0, 0x14, 0x54 };
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;
}
@ -152,11 +152,11 @@ Jhd1313m1::setCursor(int row, int column)
mraa_result_t
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
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:
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)
{
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

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)
{
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);
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);
setNormalDisplay(); // set to normal display '1' is ON
@ -52,7 +52,7 @@ SSD1308::draw(uint8_t* data, int bytes)
setAddressingMode(HORIZONTAL);
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;
@ -82,15 +82,13 @@ SSD1308::setCursor(int row, int column)
{
mraa_result_t error = MRAA_SUCCESS;
error = mraa_i2c_write_byte_data(m_i2c_lcd_control,
BASE_PAGE_START_ADDR + row,
LCD_CMD); // set page address
error = mraa_i2c_write_byte_data(m_i2c_lcd_control,
BASE_LOW_COLUMN_ADDR + (8 * column & 0x0F),
LCD_CMD); // set column lower address
error = mraa_i2c_write_byte_data(m_i2c_lcd_control,
BASE_HIGH_COLUMN_ADDR + ((8 * column >> 4) & 0x0F),
LCD_CMD); // set column higher address
error = m_i2c_lcd_control.writeReg(LCD_CMD, BASE_PAGE_START_ADDR + row); // set page address
error = m_i2c_lcd_control.writeReg(LCD_CMD,
BASE_LOW_COLUMN_ADDR + (8 * column & 0x0F)); // set column
// lower address
error = m_i2c_lcd_control.writeReg(LCD_CMD,
BASE_HIGH_COLUMN_ADDR +
((8 * column >> 4) & 0x0F)); // set column higher address
return error;
}
@ -101,7 +99,7 @@ SSD1308::clear()
mraa_result_t error = MRAA_SUCCESS;
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++) {
setCursor(rowIdx, 0);
@ -110,7 +108,7 @@ SSD1308::clear()
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();
return MRAA_SUCCESS;
@ -135,23 +133,21 @@ SSD1308::writeChar(uint8_t value)
}
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
SSD1308::setNormalDisplay()
{
return mraa_i2c_write_byte_data(m_i2c_lcd_control,
DISPLAY_CMD_SET_NORMAL_1308,
LCD_CMD); // set to normal display '1' is ON
return m_i2c_lcd_control.writeReg(LCD_CMD,
DISPLAY_CMD_SET_NORMAL_1308); // set to normal display '1' is
// ON
}
mraa_result_t
SSD1308::setAddressingMode(displayAddressingMode mode)
{
mraa_i2c_write_byte_data(m_i2c_lcd_control,
DISPLAY_CMD_MEM_ADDR_MODE,
LCD_CMD); // set addressing mode
mraa_i2c_write_byte_data(m_i2c_lcd_control, mode, LCD_CMD); // set page addressing mode
m_i2c_lcd_control.writeReg(LCD_CMD, DISPLAY_CMD_MEM_ADDR_MODE); // set addressing mode
m_i2c_lcd_control.writeReg(LCD_CMD, mode); // 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;
usleep(INIT_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xFD, LCD_CMD); // Unlock OLED driver IC MCU
// interface from entering command.
// i.e: Accept commands
m_i2c_lcd_control.writeReg(LCD_CMD, 0xFD); // Unlock OLED driver IC MCU
// interface from entering command.
// i.e: Accept commands
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control,
0xB3,
LCD_CMD); // Set Display Clock Divide Ratio/Oscillator
// Frequency
error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xB3); // Set Display Clock Divide Ratio/Oscillator
// Frequency
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);
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);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xBC, LCD_CMD); // set pre_charge
// voltage/VCOMH
error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xBC); // set pre_charge
// voltage/VCOMH
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);
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);
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);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0xB6, LCD_CMD); // Set second pre-charge
// period
error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xB6); // Set second pre-charge
// period
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);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control,
0xD5,
LCD_CMD); // enable second precharge and enternal vsl
error = m_i2c_lcd_control.writeReg(LCD_CMD, 0xD5); // enable second precharge and enternal vsl
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);
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);
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);
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);
// 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);
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);
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);
// 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);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x08, LCD_CMD); // Start from 8th Column of
// driver IC. This is 0th
// Column for OLED
error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x08); // Start from 8th Column of
// driver IC. This is 0th
// Column for OLED
usleep(INIT_SLEEP);
error = mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x37, LCD_CMD); // End at (8 + 47)th
// column. Each Column has 2
// pixels(segments)
error = m_i2c_lcd_control.writeReg(LCD_CMD, 0x37); // End at (8 + 47)th
// column. Each Column has 2
// pixels(segments)
usleep(INIT_SLEEP);
clear();
@ -153,7 +149,7 @@ SSD1327::draw(uint8_t* data, int bytes)
value |= (bitOne) ? grayHigh : 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);
}
}
@ -185,19 +181,19 @@ SSD1327::setCursor(int row, int column)
mraa_result_t error = MRAA_SUCCESS;
// 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);
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 */
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);
// 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);
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);
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);
return error;
@ -254,7 +250,7 @@ SSD1327::writeChar(uint8_t value)
data |= (bitOne) ? grayHigh : 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);
}
}
@ -263,43 +259,42 @@ SSD1327::writeChar(uint8_t value)
mraa_result_t
SSD1327::setNormalDisplay()
{
return mraa_i2c_write_byte_data(m_i2c_lcd_control,
DISPLAY_CMD_SET_NORMAL,
LCD_CMD); // set to normal display '1' is ON
return m_i2c_lcd_control.writeReg(LCD_CMD,
DISPLAY_CMD_SET_NORMAL); // set to normal display '1' is ON
}
mraa_result_t
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);
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);
// 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);
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);
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);
// 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);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x08, LCD_CMD); // Start from 8th Column of driver
// IC. This is 0th Column for OLED
m_i2c_lcd_control.writeReg(LCD_CMD, 0x08); // Start from 8th Column of driver
// IC. This is 0th Column for OLED
usleep(CMD_SLEEP);
mraa_i2c_write_byte_data(m_i2c_lcd_control, 0x37, LCD_CMD); // End at (8 + 47)th column. Each
// Column has 2 pixels(or segments)
m_i2c_lcd_control.writeReg(LCD_CMD, 0x37); // End at (8 + 47)th column. Each
// Column has 2 pixels(or segments)
usleep(CMD_SLEEP);
}
mraa_result_t
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);
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);
}