public class NativeI2CDeviceSysFs extends Object implements I2CSMBusInterface
Native Java implementation of the I2C SMBus commands using sysfs and a single native method to select the slave address.
Reference Kernel I2C dev interface and SMBus Protocol.
Warning Not all methods have been tested!
MAX_I2C_BLOCK_SIZE| Constructor and Description |
|---|
NativeI2CDeviceSysFs(int controller,
int deviceAddress,
boolean force) |
| Modifier and Type | Method and Description |
|---|---|
byte[] |
blockProcessCall(int register,
byte[] data,
int length)
SMBus Block Write - Block Read Process Call
|
void |
close() |
boolean |
probe(I2CDevice.ProbeMode mode)
Probe this I2C device
|
short |
processCall(int register,
short data)
SMBus Process Call
|
byte[] |
readBlockData(int register)
SMBus Block Read: i2c_smbus_read_block_data()
|
byte |
readByte()
SMBus Receive Byte: i2c_smbus_read_byte()
|
byte |
readByteData(int register)
SMBus Read Byte: i2c_smbus_read_byte_data()
|
byte[] |
readBytes(int length) |
byte[] |
readI2CBlockData(int register,
int length)
I2C Block Read: i2c_smbus_read_i2c_block_data()
|
short |
readWordData(int register)
SMBus Read Word: i2c_smbus_read_word_data()
|
void |
writeBlockData(int register,
byte[] data)
SMBus Block Write: i2c_smbus_write_block_data()
|
void |
writeByte(byte data)
SMBus Send Byte: i2c_smbus_write_byte()
|
void |
writeByteData(int register,
byte data)
SMBus Write Byte: i2c_smbus_write_byte_data()
|
void |
writeBytes(byte[] data) |
void |
writeI2CBlockData(int register,
byte[] data)
I2C Block Write: i2c_smbus_write_i2c_block_data()
|
void |
writeQuick(byte bit)
SMBus Quick Command
|
void |
writeWordData(int register,
short data)
SMBus Write Word: i2c_smbus_write_word_data()
|
public NativeI2CDeviceSysFs(int controller,
int deviceAddress,
boolean force)
public void close()
close in interface I2CSMBusInterfaceclose in interface Closeableclose in interface AutoCloseablepublic boolean probe(I2CDevice.ProbeMode mode)
I2CSMBusInterfaceprobe in interface I2CSMBusInterfacemode - Probe modepublic void writeQuick(byte bit)
I2CSMBusInterfaceSMBus Quick Command
This sends a single bit to the device, at the place of the Rd/Wr bit.
A Addr Rd/Wr [A] P
writeQuick in interface I2CSMBusInterfacebit - The bit to writepublic byte readByte()
I2CSMBusInterfaceSMBus Receive Byte: i2c_smbus_read_byte()
This reads a single byte from a device, without specifying a device register. Some devices are so simple that this interface is enough; for others, it is a shorthand if you want to read the same register as in the previous SMBus command.
S Addr Rd [A] [Data] NA P
readByte in interface I2CSMBusInterfacepublic void writeByte(byte data)
I2CSMBusInterfaceSMBus Send Byte: i2c_smbus_write_byte()
This operation is the reverse of Receive Byte: it sends a single byte to a device. See Receive Byte for more information.
S Addr Wr [A] Data [A] P
writeByte in interface I2CSMBusInterfacedata - value to writepublic byte[] readBytes(int length)
readBytes in interface I2CSMBusInterfacepublic void writeBytes(byte[] data)
writeBytes in interface I2CSMBusInterfacepublic byte readByteData(int register)
I2CSMBusInterfaceSMBus Read Byte: i2c_smbus_read_byte_data()
This reads a single byte from a device, from a designated register. The register is specified through the Comm byte.
S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P
readByteData in interface I2CSMBusInterfaceregister - the register to read frompublic void writeByteData(int register,
byte data)
I2CSMBusInterfaceSMBus Write Byte: i2c_smbus_write_byte_data()
This writes a single byte to a device, to a designated register. The register is specified through the Comm byte. This is the opposite of the Read Byte operation.
S Addr Wr [A] Comm [A] Data [A] P
writeByteData in interface I2CSMBusInterfaceregister - the register to write todata - value to writepublic short readWordData(int register)
I2CSMBusInterfaceSMBus Read Word: i2c_smbus_read_word_data()
This operation is very like Read Byte; again, data is read from a device, from a designated register that is specified through the Comm byte. But this time, the data is a complete word (16 bits).
S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
readWordData in interface I2CSMBusInterfaceregister - the register to read frompublic void writeWordData(int register,
short data)
I2CSMBusInterfaceSMBus Write Word: i2c_smbus_write_word_data()
This is the opposite of the Read Word operation. 16 bits of data is written to a device, to the designated register that is specified through the Comm byte.
S Addr Wr [A] Comm [A] DataLow [A] DataHigh [A] P
writeWordData in interface I2CSMBusInterfaceregister - the register to write todata - value to writepublic short processCall(int register,
short data)
I2CSMBusInterfaceSMBus Process Call
This command selects a device register (through the Comm byte), sends 16 bits of data to it, and reads 16 bits of data in return.
S Addr Wr [A] Comm [A] DataLow [A] DataHigh [A]
S Addr Rd [A] [DataLow] A [DataHigh] NA PprocessCall in interface I2CSMBusInterfaceregister - the register to write to / read fromdata - value to writepublic byte[] readBlockData(int register)
I2CSMBusInterfaceSMBus Block Read: i2c_smbus_read_block_data()
This command reads a block of up to 32 bytes from a device, from a designated register that is specified through the Comm byte. The amount of data is specified by the device in the Count byte.
S Addr Wr [A] Comm [A]
S Addr Rd [A] [Count] A [Data] A [Data] A ... A [Data] NA PreadBlockData in interface I2CSMBusInterfaceregister - the register to read frompublic void writeBlockData(int register,
byte[] data)
I2CSMBusInterfaceSMBus Block Write: i2c_smbus_write_block_data()
The opposite of the Block Read command, this writes up to 32 bytes to a device, to a designated register that is specified through the Comm byte. The amount of data is specified in the Count byte.
S Addr Wr [A] Comm [A] Count [A] Data [A] Data [A] ... [A] Data [A] P
writeBlockData in interface I2CSMBusInterfaceregister - the register to write todata - values to writepublic byte[] blockProcessCall(int register,
byte[] data,
int length)
I2CSMBusInterfaceSMBus Block Write - Block Read Process Call
SMBus Block Write - Block Read Process Call was introduced in
Revision 2.0 of the specification.
This command selects a device register (through the Comm byte), sends
1 to 31 bytes of data to it, and reads 1 to 31 bytes of data in return.
S Addr Wr [A] Comm [A] Count [A] Data [A] ...
S Addr Rd [A] [Count] A [Data] ... A PblockProcessCall in interface I2CSMBusInterfaceregister - the register to write todata - data to writelength - Lengthpublic byte[] readI2CBlockData(int register,
int length)
I2CSMBusInterfaceI2C Block Read: i2c_smbus_read_i2c_block_data()
This command reads a block of bytes from a device, from a designated register that is specified through the Comm byte.
S Addr Wr [A] Comm [A]
S Addr Rd [A] [Data] A [Data] A ... A [Data] NA PreadI2CBlockData in interface I2CSMBusInterfaceregister - the register to read fromlength - amount of data to readpublic void writeI2CBlockData(int register,
byte[] data)
I2CSMBusInterfaceI2C Block Write: i2c_smbus_write_i2c_block_data()
The opposite of the Block Read command, this writes bytes to a device, to a designated register that is specified through the Comm byte. Note that command lengths of 0, 2, or more bytes are supported as they are indistinguishable from data.
S Addr Wr [A] Comm [A] Data [A] Data [A] ... [A] Data [A] P
writeI2CBlockData in interface I2CSMBusInterfaceregister - the register to write todata - values to writeCopyright © 2016–2018 mattjlewis. All rights reserved.