I2C_device.cpp

Go to the documentation of this file.

#include "I2C_device.h"
 
I2C_device::I2C_device( uint8_t i2c_address, bool repeated_start_enable ) : i2c_addr( i2c_address ), i2c( Wire ), rs_dis( !repeated_start_enable )
{
}
 
I2C_device::I2C_device( TwoWire& wire, uint8_t i2c_address, bool repeated_start_enable ) : i2c_addr( i2c_address ), i2c( wire ), rs_dis( !repeated_start_enable )
{
}
 
I2C_device::~I2C_device()
{
}
 
void I2C_device::repeated_start_enable( bool en )
{
    rs_dis  = !en;
}
 
bool I2C_device::ping( void )
{
    i2c.beginTransmission( i2c_addr );
    return !i2c.endTransmission();
}
 
void I2C_device::scan( TwoWire& target_i2c, uint8_t stop )
{
    bool  result[ 128 ];
 
    for ( uint8_t i = 0; i < stop; i++ ) {
        target_i2c.beginTransmission( i );
        result[i] = !target_i2c.endTransmission();
    }
 
    for ( uint8_t i = stop; i < 128; i++ ) {
        result[i] = false;
    }
 
    Serial.print( "\nI2C scan result\n   " );
    for ( uint8_t x = 0; x < 16; x++ ) {
        Serial.print( " x" );
        Serial.print( x, HEX );
    }
    
    for ( uint8_t i = 0; i < 128; i++ ) {
        if ( !( i % 16) ) {
            Serial.print( "\n" );
            Serial.print( i / 16, HEX );
            Serial.print( "x:" );
        }
        
        if ( result[ i ] ) {
            Serial.print( " " );
            Serial.print( i, HEX );
        }
        else {
            Serial.print( " --" );
        }
    }
    Serial.print( "\n" );           
}
 
int I2C_device::tx( const uint8_t *data, uint16_t size, bool stop )
{
    i2c.beginTransmission( i2c_addr );
    size        = i2c.write( data, size );
    uint8_t rtn = i2c.endTransmission( stop || rs_dis );
 
    if (rtn)
        return -rtn;
 
    return size;
}
 
int I2C_device::rx( uint8_t *data, uint16_t size, bool stop )
{
    uint16_t r_size = i2c.requestFrom( static_cast<int>( i2c_addr ), static_cast<int>( size ), static_cast<int>( stop || rs_dis ) );
 
    if ( size && !r_size )
        return  -1;
    
    for ( uint16_t i = 0; i < size; i++ ) {
        while ( !i2c.available() )
            ;
        data[ i ] = i2c.read();
    }
    return r_size;
}
 
int I2C_device::reg_w( uint8_t reg_adr, const uint8_t *data, uint16_t size, bool stop )
{
    uint8_t buffer[ size + 1 ];
    
    buffer[ 0 ] = reg_adr;
    for ( uint16_t i = 0; i < size; i++)
        buffer[ i + 1 ] = data[ i ];
    
    return tx( buffer, sizeof( buffer ), stop );
}
 
int I2C_device::reg_w( uint8_t reg_adr, uint8_t data, bool stop )
{
    uint8_t buffer[ 2 ];
    
    buffer[ 0 ] = reg_adr;
    buffer[ 1 ] = data;
    
    return tx( buffer, sizeof( buffer ), stop );
}
 
int I2C_device::reg_r( uint8_t reg_adr, uint8_t *data, uint16_t size, bool stop )
{
    tx( &reg_adr, 1, false );
    return rx( data, size, stop );
}
 
uint8_t I2C_device::reg_r( uint8_t reg_adr, bool stop )
{
    uint8_t buffer  = 0;    //  assigning zero to suppress warning "-Wmaybe-uninitialized"
    
    tx( &reg_adr, 1, false );
    rx( &buffer, 1, stop );
    return buffer;
} 
 
void I2C_device::write_r8( uint8_t reg, uint8_t val, bool stop )
{
    reg_w( reg, val, stop );
}
 
void I2C_device::write_r16( uint8_t reg, uint16_t val, bool stop )
{
    uint8_t buff[ 2 ];
    
    buff[ 0 ]   = val >> 8;
    buff[ 1 ]   = val & 0xFF;
    
    reg_w( reg, buff, sizeof( buff ), stop );
}
 
uint8_t I2C_device::read_r8( uint8_t reg, bool stop )
{
    return reg_r( reg, stop );  
}
 
uint16_t I2C_device::read_r16( uint8_t reg, bool stop )
{
    uint8_t buff[ 2 ];
 
    reg_r( reg, buff, sizeof( buff ), stop );
    
    return (buff[ 0 ] << 8) | buff[ 1 ];
}
 
void I2C_device::bit_op8( uint8_t reg, uint8_t mask, uint8_t value )
{
    uint8_t v   = read_r8( reg, false );
 
    v   &= mask;
    v   |= value;
    
    write_r8( reg, v );
}
 
void I2C_device::bit_op16( uint8_t reg, uint16_t mask, uint16_t value )
{
    uint16_t v  = read_r16( reg, false );
 
    v   &= mask;
    v   |= value;
 
    write_r16( reg, v );
}
 
void I2C_device::txrx( const uint8_t *w_data, uint8_t *r_data, uint16_t size )
{
    memcpy( r_data, w_data, size );
    
    SPI.beginTransaction( spi_setting );
    
    digitalWrite( SS, LOW );
    SPI.transfer( r_data, size );
    digitalWrite( SS, HIGH );
    
    SPI.endTransaction();
}