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

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>

examples/c++/jhd1313m1-lcd.cxx

@@ -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]
 }

examples/c++/lcm1602-lcd.cxx

@@ -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;
 }

examples/c++/ssd1308-oled.cxx

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

examples/c++/ssd1327-oled.cxx

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

examples/javascript/oled_ssd1308.js

@@ -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();

examples/javascript/oled_ssd1327.js

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

examples/javascript/rgb-lcd.js

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

examples/python/oled_ssd1308.py

@@ -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

examples/python/oled_ssd1327.py

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

examples/python/rgb-lcd.py

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

src/lcd/i2clcd.cxx

@@ -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()
 {

src/lcd/i2clcd.h

@@ -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;
 };
 }

src/lcd/jhd1313m1.cxx

@@ -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);
 }

src/lcd/jhd1313m1.h

@@ -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;
 };
 }

src/lcd/lcm1602.cxx

@@ -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

src/lcd/ssd1308.cxx

@@ -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
 }

src/lcd/ssd1327.cxx

@@ -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);
 }