I2C: Removing multiple address calls

~20 UPM modules have multiple I2C calls in them. As per MRAA API
the I2C address is set in the MRAA I2C context and used from there
for all I2C transactions. Setting the I2C address alone does not
actually result in an I2C transaction. This makes multiple set
address calls pointless. This commit removes these superflous set
address calls from the UPM modules. Setting the address once per
context per device should be enough, unless there are multiple
addresses or multiple devices with different addresses.

Signed-off-by: Abhishek Malik <abhishek.malik@intel.com>

src/adafruitss/adafruitss.cxx

@@ -76,20 +76,17 @@ void adafruitss::setPWMFreq(float freq) {
 
 
 
-    mraa_i2c_address(m_i2c, pca9685_addr);
     mraa_i2c_read_byte_data(m_i2c,PCA9685_MODE1);
 
 
     m_rx_tx_buf[0]=PCA9685_MODE1;
     m_rx_tx_buf[1]=0x10; // sleep
-    mraa_i2c_address(m_i2c, pca9685_addr);
     mraa_i2c_write(m_i2c,m_rx_tx_buf,2);
 
 
 
     m_rx_tx_buf[0]=PCA9685_PRESCALE;
     m_rx_tx_buf[1]=prescale;
-    mraa_i2c_address(m_i2c, pca9685_addr);
     mraa_i2c_write(m_i2c,m_rx_tx_buf,2);
 
 
@@ -97,7 +94,6 @@ void adafruitss::setPWMFreq(float freq) {
 
     m_rx_tx_buf[0]=PCA9685_MODE1;
     m_rx_tx_buf[1]=0x00;
-    mraa_i2c_address(m_i2c, pca9685_addr);
     mraa_i2c_write(m_i2c,m_rx_tx_buf,2);
 
     // mraa_i2c_write_byte_data(m_i2c,0x00,PCA9685_MODE1);
@@ -107,7 +103,6 @@ void adafruitss::setPWMFreq(float freq) {
 
     m_rx_tx_buf[0]=PCA9685_MODE1;
     m_rx_tx_buf[1]=0xa1;
-    mraa_i2c_address(m_i2c, pca9685_addr);
     mraa_i2c_write(m_i2c,m_rx_tx_buf,2);
 }
 
@@ -149,7 +144,6 @@ void adafruitss::servo(uint8_t port, uint8_t servo_type, float degrees) {
    }
 
     uint16_t d= roundf(duration);
-    mraa_i2c_address(m_i2c, pca9685_addr);
     m_rx_tx_buf[0]=LED0_REG+4*port;
     m_rx_tx_buf[1]=0;
     m_rx_tx_buf[2]=0;

src/adxl345/adxl345.cxx

@@ -104,12 +104,6 @@ Adxl345::Adxl345(int bus) : m_i2c(bus)
         return;
     }
 
-    if ( m_i2c.address(ADXL345_I2C_ADDR) != mraa::SUCCESS ){
-        throw std::invalid_argument(std::string(__FUNCTION__) +
-                                    ": i2c.address() failed");
-        return;
-    }
-
     m_buffer[0] = ADXL345_DATA_FORMAT;
     m_buffer[1] = ADXL345_16G | ADXL345_FULL_RES;
     if( m_i2c.write(m_buffer, 2) != mraa::SUCCESS){
@@ -148,10 +142,8 @@ Adxl345::getScale(){
 
     uint8_t result;
 
-    m_i2c.address(ADXL345_I2C_ADDR);
     m_i2c.writeByte(ADXL345_DATA_FORMAT);
 
-    m_i2c.address(ADXL345_I2C_ADDR);
     result = m_i2c.readByte();
 
     return pow(2, (result & 0x03) + 1);
@@ -160,10 +152,8 @@ Adxl345::getScale(){
 mraa::Result
 Adxl345::update(void)
 {
-    m_i2c.address(ADXL345_I2C_ADDR);
     m_i2c.writeByte(ADXL345_XOUT_L);
 
-    m_i2c.address(ADXL345_I2C_ADDR);
     m_i2c.read(m_buffer, DATA_REG_SIZE);
 
     // x

src/am2315/am2315.cpp

@@ -199,12 +199,6 @@ AM2315::i2cWriteReg(uint8_t reg, uint8_t* data, uint8_t ilen)
     tdata[ilen+3] = crc;
     tdata[ilen+4] = (crc >> 8);
 
-    if (mraa_i2c_address(m_i2ControlCtx, m_controlAddr) != MRAA_SUCCESS)
-    {
-        fprintf(stdout, "Error, setting i2c address.\n");
-        return -1;
-    }
-
     int iLoops = 5;
     mraa_set_priority(HIGH_PRIORITY);
     do {
@@ -241,7 +235,7 @@ AM2315::i2cReadReg(int reg, uint8_t* data, int ilen)
   uint8_t tdata[16] = { AM2315_READ, static_cast<uint8_t>(reg),
                         static_cast<uint8_t>(ilen) };
 
-    mraa_result_t ret = mraa_i2c_address(m_i2ControlCtx, m_controlAddr);
+    mraa_result_t ret;
     int iLoops = 5;
     mraa_set_priority(HIGH_PRIORITY);
     do {

src/ds1307/ds1307.cxx

@@ -61,13 +61,6 @@ mraa::Result DS1307::writeBytes(uint8_t reg, uint8_t *buffer, int len)
   for (int i=1; i<(len + 1); i++)
     buf2[i] = buffer[i-1];
 
-  mraa::Result ret = m_i2c.address(DS1307_I2C_ADDR);
-  if (ret != mraa::SUCCESS){
-      throw std::invalid_argument(std::string(__FUNCTION__) +
-                                  ": i2c.address() failed");
-      return ret;
-  }
-
   return m_i2c.write(buf2, len + 1);
 }
 
@@ -76,12 +69,6 @@ int DS1307::readBytes(uint8_t reg, uint8_t *buffer, int len)
   if (!len || !buffer)
     return 0;
 
-  mraa::Result ret = m_i2c.address(DS1307_I2C_ADDR);
-  if (ret != mraa::SUCCESS){
-      throw std::invalid_argument(std::string(__FUNCTION__) +
-                                  ": i2c.address() failed");
-      return 0;
-  }
   m_i2c.writeByte(reg);
 
   return m_i2c.read(buffer, len);

src/hdc1000/hdc1000.cpp

@@ -85,13 +85,7 @@ HDC1000::checkID(void)
 void
 HDC1000::resetSensor(void)
 {
-    mraa::Result ret = m_i2ControlCtx.address(m_controlAddr);
+    mraa::Result ret = m_i2ControlCtx.writeByte(0);
-    if (ret != mraa::SUCCESS) {
-        throw std::invalid_argument(std::string(__FUNCTION__) +
-                                    ": mraa_i2c_address() failed");
-    }
-
-    ret = m_i2ControlCtx.writeByte(0);
     if (ret != mraa::SUCCESS) {
         throw std::invalid_argument(std::string(__FUNCTION__) +
                                     ": mraa_i2c_write_byte() failed");
@@ -108,12 +102,6 @@ HDC1000::sampleData(void)
 
     resetSensor();
 
-    mraa::Result ret = m_i2ControlCtx.address(m_controlAddr);
-    if (ret != mraa::SUCCESS) {
-        throw std::invalid_argument(std::string(__FUNCTION__) +
-                                    ": mraa_i2c_address() failed");
-    }
-
     re = m_i2ControlCtx.read(itemp, 4);
     if (re != 4) {
         /* not enough bytes were read! */

src/htu21d/htu21d.cpp

@@ -54,7 +54,6 @@ void
 HTU21D::resetSensor(void)
 {
     uint8_t data = HTU21D_SOFT_RESET;
-    m_i2ControlCtx.address (m_controlAddr);
     m_i2ControlCtx.write (&data, 1);
     usleep(20000);
 }
@@ -259,7 +258,6 @@ HTU21D::i2cWriteReg (uint8_t reg, uint8_t value) {
     mraa::Result error = mraa::SUCCESS;
 
     uint8_t data[2] = { reg, value };
-    m_i2ControlCtx.address (m_controlAddr);
     error = m_i2ControlCtx.write (data, 2);
     if ( error != mraa::SUCCESS)
       throw std::invalid_argument(std::string(__FUNCTION__) +
@@ -270,13 +268,11 @@ HTU21D::i2cWriteReg (uint8_t reg, uint8_t value) {
 
 uint16_t
 HTU21D::i2cReadReg_16 (int reg) {
-    m_i2ControlCtx.address(m_controlAddr);
     return m_i2ControlCtx.readWordReg(reg);
 }
 
 uint8_t
 HTU21D::i2cReadReg_8 (int reg) {
-    m_i2ControlCtx.address(m_controlAddr);
     return m_i2ControlCtx.readReg(reg);
 }
 

src/itg3200/itg3200.cxx

@@ -129,10 +129,8 @@ Itg3200::getRawTemp()
 mraa::Result
 Itg3200::update(void)
 {
-    m_i2c.address(ITG3200_I2C_ADDR);
     m_i2c.writeByte(ITG3200_TEMP_H);
 
-    m_i2c.address(ITG3200_I2C_ADDR);
     m_i2c.read(m_buffer, DATA_REG_SIZE);
 
     //temp

src/lidarlitev3/lidarlitev3.cxx

@@ -98,10 +98,8 @@ uint16_t
 LIDARLITEV3::i2cReadReg_16 (int reg) {
     uint16_t data;
 
-    m_i2ControlCtx.address(m_controlAddr);
     m_i2ControlCtx.writeByte(reg);
 
-    m_i2ControlCtx.address(m_controlAddr);
     m_i2ControlCtx.read((uint8_t *)&data, 0x2);
 
     uint8_t high = (data & 0xFF00) >> 8;
@@ -115,10 +113,8 @@ uint8_t
 LIDARLITEV3::i2cReadReg_8 (int reg) {
     uint8_t data;
 
-    m_i2ControlCtx.address(m_controlAddr);
     m_i2ControlCtx.writeByte(reg);
 
-    m_i2ControlCtx.address(m_controlAddr);
     m_i2ControlCtx.read(&data, 0x1);
 
     return data;
@@ -129,7 +125,6 @@ LIDARLITEV3::i2cWriteReg (uint8_t reg, uint8_t value) {
     mraa::Result error = mraa::SUCCESS;
 
     uint8_t data[2] = { reg, value };
-    error = m_i2ControlCtx.address (m_controlAddr);
     error = m_i2ControlCtx.write (data, 2);
     if ( error != mraa::SUCCESS)
       throw std::invalid_argument(std::string(__FUNCTION__) +

src/lp8860/lp8860.cxx

@@ -240,7 +240,6 @@ void LP8860::allowMaxCurrent()
 
 void LP8860::i2cWriteByte(int reg, int value)
 {
-    i2c->address(LP8860_I2C_ADDR);
     status = i2c->writeReg(static_cast<uint8_t>(reg), static_cast<uint8_t>(value));
     if (status != mraa::SUCCESS)
         UPM_THROW("i2cWriteByte failed");
@@ -250,7 +249,6 @@ void LP8860::i2cWriteByte(int reg, int value)
 uint8_t LP8860::i2cReadByte(uint8_t reg)
 {
     uint8_t value;
-    i2c->address(LP8860_I2C_ADDR);
     if (i2c->readBytesReg(reg, &value, 1) != 1)
         UPM_THROW("i2cReadByte failed");
     return value;
@@ -264,7 +262,6 @@ void LP8860::i2cWriteBuffer(int reg, uint8_t* buf, int length)
         uint8_t* writeBuf = new unsigned char[length + 1];
         writeBuf[0] = reg;
         memcpy(&writeBuf[1], buf, length);
-        i2c->address(LP8860_I2C_ADDR);
         status = i2c->write(writeBuf, length + 1);
         delete[] writeBuf;
     }
@@ -277,7 +274,6 @@ void LP8860::i2cWriteBuffer(int reg, uint8_t* buf, int length)
 
 void LP8860::i2cReadBuffer(int reg, uint8_t* buf, int length)
 {
-    i2c->address(LP8860_I2C_ADDR);
     if (i2c->readBytesReg(reg, buf, length) != length)
         UPM_THROW("i2cReadBuffer failed");
 }

src/max44000/max44000.cxx

@@ -77,10 +77,8 @@ uint8_t
 MAX44000::i2cReadReg_8 (int reg) {
     uint8_t data;
 
-    m_i2cMaxControlCtx.address(m_maxControlAddr);
     m_i2cMaxControlCtx.writeByte(reg);
 
-    m_i2cMaxControlCtx.address(m_maxControlAddr);
     m_i2cMaxControlCtx.read(&data, 0x1);
 
     return data;
@@ -90,10 +88,8 @@ uint16_t
 MAX44000::i2cReadReg_16 (int reg) {
     uint16_t data;
 
-    m_i2cMaxControlCtx.address(m_maxControlAddr);
     m_i2cMaxControlCtx.writeByte(reg);
 
-    m_i2cMaxControlCtx.address(m_maxControlAddr);
     m_i2cMaxControlCtx.read((uint8_t *)&data, 0x2);
 
     return data;
@@ -104,7 +100,6 @@ MAX44000::i2cWriteReg (uint8_t reg, uint8_t value) {
     mraa::Result error = mraa::SUCCESS;
 
     uint8_t data[2] = { reg, value };
-    error = m_i2cMaxControlCtx.address (m_maxControlAddr);
     error = m_i2cMaxControlCtx.write (data, 2);
 
     return error;

src/maxds3231m/maxds3231m.cxx

@@ -98,10 +98,8 @@ uint16_t
 MAXDS3231M::i2cReadReg_N (int reg, unsigned int len, uint8_t * buffer) {
     int readByte = 0;
 
-    m_i2Ctx.address(m_i2cAddr);
     m_i2Ctx.writeByte(reg);
 
-    m_i2Ctx.address(m_i2cAddr);
     readByte = m_i2Ctx.read(buffer, len);
     return readByte;
 }
@@ -110,7 +108,6 @@ mraa::Result
 MAXDS3231M::i2cWriteReg_N (uint8_t reg, unsigned int len, uint8_t * buffer) {
     mraa::Result error = mraa::SUCCESS;
 
-    error = m_i2Ctx.address (m_i2cAddr);
     error = m_i2Ctx.write (buffer, len);
 
     return error;

src/mma7455/mma7455.cxx

@@ -144,12 +144,6 @@ short *MMA7455::readData() {
 
 int
 MMA7455::i2cReadReg (unsigned char reg, uint8_t *buffer, int len) {
-    if (mraa::SUCCESS != m_i2ControlCtx.address(m_controlAddr)) {
-        throw std::runtime_error(std::string(__FUNCTION__) +
-                                 ": mraa_i2c_address() failed");
-        return 0;
-    }
-
     if (mraa::SUCCESS != m_i2ControlCtx.writeByte(reg)) {
         throw std::runtime_error(std::string(__FUNCTION__) +
                                  ": mraa_i2c_write_byte() failed");
@@ -167,12 +161,6 @@ MMA7455::i2cWriteReg (unsigned char reg, uint8_t *buffer, int len) {
     data[0] = reg;
     memcpy(&data[1], buffer, len);
 
-    error = m_i2ControlCtx.address (m_controlAddr);
-    if (error != mraa::SUCCESS) {
-        throw std::runtime_error(std::string(__FUNCTION__) +
-                                 ": mraa_i2c_address() failed");
-        return error;
-    }
     error = m_i2ControlCtx.write (data, len + 1);
     if (error != mraa::SUCCESS) {
         throw std::runtime_error(std::string(__FUNCTION__) +

src/mpl3115a2/mpl3115a2.cpp

@@ -298,7 +298,6 @@ MPL3115A2::i2cWriteReg (uint8_t reg, uint8_t value) {
     mraa::Result error = mraa::SUCCESS;
 
     uint8_t data[2] = { reg, value };
-    m_i2ControlCtx.address (m_controlAddr);
     error = m_i2ControlCtx.write (data, 2);
 
     if (error != mraa::SUCCESS)
@@ -311,7 +310,6 @@ uint16_t
 MPL3115A2::i2cReadReg_16 (int reg) {
     uint16_t data;
 
-    m_i2ControlCtx.address(m_controlAddr);
     data  = (uint16_t)m_i2ControlCtx.readReg(reg) << 8;
     data |= (uint16_t)m_i2ControlCtx.readReg(reg+1);
 
@@ -320,7 +318,6 @@ MPL3115A2::i2cReadReg_16 (int reg) {
 
 uint8_t
 MPL3115A2::i2cReadReg_8 (int reg) {
-    m_i2ControlCtx.address(m_controlAddr);
     return m_i2ControlCtx.readReg(reg);
 }
 

src/mpr121/mpr121.c

@@ -79,11 +79,6 @@ upm_result_t mpr121_write_bytes(mpr121_context dev, uint8_t reg,
     for(i=1; i<(len + 1); i++)
         buf2[i] = buffer[i-1];
 
-    if(mraa_i2c_address(dev->i2c, dev->address) != MRAA_SUCCESS){
-        printf("write byte error address\n");
-        return UPM_ERROR_OPERATION_FAILED;
-    }
-
     if(mraa_i2c_write(dev->i2c, buf2, len+1) != MRAA_SUCCESS){
         printf("write byte error while writing\n");
         return UPM_ERROR_OPERATION_FAILED;

src/mpr121/mpr121.cxx

@@ -63,8 +63,6 @@ mraa::Result MPR121::writeBytes(uint8_t reg, uint8_t *buffer, int len)
   for (int i=1; i<(len + 1); i++)
     buf2[i] = buffer[i-1];
 
-  m_i2c.address(m_addr);
-
   return m_i2c.write(buf2, len + 1);
 }
 

src/ms5611/ms5611.cxx

@@ -154,7 +154,6 @@ uint32_t MS5611::readADC(int adcReg)
 {
     uint32_t value;
     uint8_t buf[3];
-    i2c->address(address);
     status = i2c->writeByte(adcReg + osr);
     if (status != mraa::SUCCESS)
        UPM_THROW("Convert D2 failed");

src/pn532/pn532.cxx

@@ -1466,12 +1466,6 @@ void PN532::readData(uint8_t* buff, uint8_t n)
 
   memset(buf, 0, n+2);
   usleep(2000); 
-  if (m_i2c.address(m_addr) != mraa::SUCCESS)
-    {
-      throw std::runtime_error(std::string(__FUNCTION__) +
-                               ": mraa_i2c_address() failed");
-      return;
-    }
 
   rv = m_i2c.read(buf, n + 2);
 
@@ -1540,13 +1534,6 @@ void PN532::writeCommand(uint8_t* cmd, uint8_t cmdlen)
   buf[offset++] = ~checksum;
   buf[offset] = PN532_POSTAMBLE;
 
-  if (m_i2c.address(m_addr) != mraa::SUCCESS)
-    {
-      throw std::runtime_error(std::string(__FUNCTION__) +
-                               ": mraa_i2c_address() failed");
-      return;
-    }
-
   if (m_i2c.write(buf, cmdlen + 8 - 1) != mraa::SUCCESS)
     {
       throw std::runtime_error(std::string(__FUNCTION__) +

src/si1132/si1132.cxx

@@ -89,8 +89,6 @@ SI1132::~SI1132() {
 }
 
 mraa::Result SI1132::reset() {
-    i2c->address(SI1132_ADDRESS);
-
     // Check version
     uint8_t regValue = i2c->readReg(SI1132_REG_PART_ID);
     if (regValue != SI1132_PART_ID)  {
@@ -175,7 +173,6 @@ mraa::Result SI1132::runCommand(uint8_t command)
     int sleepTimeMs = 5;
     int timeoutMs = 50;
     int waitTimeMs = 0;
-    i2c->address(SI1132_ADDRESS);
     status = clearResponseRegister();
     if (status != mraa::SUCCESS)
         return status;
@@ -196,7 +193,6 @@ mraa::Result SI1132::runCommand(uint8_t command)
 
 mraa::Result SI1132::writeParam(uint8_t param, uint8_t value)
 {
-    i2c->address(SI1132_ADDRESS);
     status = i2c->writeReg(SI1132_REG_PARAM_WR, value);
     if (status != mraa::SUCCESS)
         return status;

src/si7005/si7005.cxx

@@ -131,7 +131,6 @@ uint16_t SI7005::getMeasurement(uint8_t configValue) {
     usleep(SI7005_WAKE_UP_TIME);
 
     // Setup config register
-    m_i2c->address(m_controlAddr);
     status = m_i2c->writeReg(SI7005_REG_CONFIG, SI7005_CONFIG_START | configValue | config_reg);
 
     // FIXME: readReg() returns 0 on failure which is same as "reading ready" status
@@ -169,7 +168,6 @@ SI7005::isAvailable( )
     usleep(SI7005_WAKE_UP_TIME);
 
     // Read id register
-    m_i2c->address(m_controlAddr);
     uint8_t  deviceID = m_i2c->readReg(SI7005_REG_ID);
 
     // Disable the sensor

src/t6713/t6713.cxx

@@ -98,12 +98,6 @@ uint16_t T6713::getSensorData (MODBUS_COMMANDS cmd)
                 //printf("\nI2C mode set\n");
                 data = 0;
                 runCommand(cmd);
-                mraa::Result ret = i2c.address(T6713_ADDR);
-                if (ret != mraa::SUCCESS)
-                {
-                    UPM_THROW ("I2C error setting slave address");
-                    // TODO: need to handle this
-                }
                 RESPONSE response;
                 if((readBytes = i2c.read((uint8_t*)(&response), sizeof(RESPONSE) ) != sizeof(RESPONSE)))
                 {
@@ -152,11 +146,6 @@ mraa::Result T6713::runCommand(MODBUS_COMMANDS cmd)
             cmdPacket.register_address_lsb = (T6713_REG_STATUS & 0xff);
             cmdPacket.input_registers_to_read_msb = 0;
             cmdPacket.input_registers_to_read_lsb = 1;
-            ret = i2c.address(T6713_ADDR);
-            if (ret != mraa::SUCCESS)
-            {
-                UPM_THROW ("I2C error setting slave address");
-            }
 
             if((ret = i2c.write((const uint8_t*) (&cmdPacket), sizeof(COMMAND))) != mraa::SUCCESS)
             {
@@ -180,13 +169,6 @@ mraa::Result T6713::runCommand(MODBUS_COMMANDS cmd)
 
             cmdPacket.input_registers_to_read_msb = 0;
             cmdPacket.input_registers_to_read_lsb = 1;
-            ret = i2c.address(T6713_ADDR);
-            if (ret != mraa::SUCCESS)
-            {
-                UPM_THROW ("I2C error setting slave address");
-                //need to handle this
-            }
-
 
             if((ret = i2c.write((const uint8_t*) (&cmdPacket), sizeof(COMMAND))) != mraa::SUCCESS)
             {
@@ -205,12 +187,6 @@ STATUS T6713::getStatus()
     uint16_t responseStatus = 0, readBytes = 0;
     RESPONSE response;
     runCommand(T6713_COMMAND_STATUS);
-    mraa::Result ret = i2c.address(T6713_ADDR);
-    if (ret != mraa::SUCCESS)
-    {
-        UPM_THROW ("I2C error setting slave address");
-        //need to handle tnis
-    }
     if((readBytes = i2c.read((uint8_t*) (&response), sizeof(RESPONSE)) != sizeof(RESPONSE)))
     {
         UPM_THROW("I2C read failed");

src/tsl2561/tsl2561.c

@@ -115,11 +115,6 @@ upm_result_t tsl2561_get_lux(const tsl2561_context dev, float* lux){
 
 upm_result_t tsl2561_i2c_write_reg(tsl2561_context dev, uint8_t reg,
                                    uint8_t value){
-    // Start transmission to device
-    if(mraa_i2c_address(dev->i2c, dev->address) != MRAA_SUCCESS){
-        return UPM_ERROR_OPERATION_FAILED;
-    }
-
     // Write register to I2C
     if(mraa_i2c_write_byte(dev->i2c, reg) != MRAA_SUCCESS){
         return UPM_ERROR_OPERATION_FAILED;
@@ -136,11 +131,6 @@ upm_result_t tsl2561_i2c_write_reg(tsl2561_context dev, uint8_t reg,
 
 upm_result_t tsl2561_i2c_read_reg(tsl2561_context dev, uint8_t reg,
                                   uint8_t* data){
-   // Start transmission to dev
-    if(mraa_i2c_address(dev->i2c, dev->address) != MRAA_SUCCESS){
-        return UPM_ERROR_OPERATION_FAILED;
-    }
-
     // Send address of register to be read.
     if(mraa_i2c_write_byte(dev->i2c, reg) != MRAA_SUCCESS){
         return UPM_ERROR_OPERATION_FAILED;

src/tsl2561/tsl2561.cxx

@@ -195,12 +195,6 @@ TSL2561::i2cWriteReg (uint8_t reg, uint8_t value)
 {
     mraa::Result error = mraa::SUCCESS;
 
-    // Start transmission to device
-    error = m_i2ControlCtx.address (m_controlAddr);
-    if (error != mraa::SUCCESS) {
-        fprintf(stderr, "Error: on i2c bus address setup in i2cWriteReg()\n");
-        return error;
-    }
     // Write register to I2C
     error = m_i2ControlCtx.writeByte (reg);
     if (error != mraa::SUCCESS) {
@@ -225,13 +219,6 @@ TSL2561::i2cReadReg(uint8_t reg, uint8_t &data)
 {
     mraa::Result error = mraa::SUCCESS;
 
-    // Start transmission to device
-    error = m_i2ControlCtx.address(m_controlAddr);
-    if (error != mraa::SUCCESS) {
-        fprintf(stderr, "Error: on i2c bus address setup in i2cReadReg()\n");
-        return error;
-    }
-
     // Send address of register to be read.
     error = m_i2ControlCtx.writeByte(reg);
     if (error != mraa::SUCCESS) {