/// <summary>
/// Read lenght data from register
/// </summary>
/// <param name="register">The register to read</param>
/// <param name="length">Number of bytes to read</param>
/// <param name="useRepeatedStart">Use or not I2C Repeated start condition</param>
/// <returns></returns>
internal byte[] ReadRegisterByte(TKey register, int length, bool useRepeatedStart = false)
{
try
{
if (_deviceConnection != null)
{
if (useRepeatedStart)
{
byte[] res = _deviceConnection.Read(GetConstantAsByte(register), length);
if (length == 2)
{
CommonHelper.Logger.Info(string.Format("ReadRegisterByte: {0}-{1}", res[0], res[1]));
}
return(res);
}
else
{
_deviceConnection.WriteByte(GetConstantAsByte(register));
return(_deviceConnection.Read(length));
}
}
else
{
return(null);
}
}
catch (Exception e)
{
CommonHelper.Logger.Error(e, string.Format("Error ReadRegisterByte(TKey register, int length) {0} - {1}", register, e.Message));
return(null);
}
}
public string ReadDateAndTime()
{
byte[] rd = connection.Read(4);
// returndata = self._bus.read_byte_data(self._addr, data)
//#print "addr = 0x%x data = 0x%x %i returndata = 0x%x %i " % (self._addr, data, data, returndata, _bcd_to_int(returndata))
// return returndata
return("2014-11-04 22:24:51");
}
private static float ReadTemperature()
{
//byte[] result = i2cConnection.Read(0x14, 2);
//foreach (var b in result)
// Console.WriteLine("result: {0}", b);
byte[] result = new byte[2];
result[0] = i2cConnection.Read(0x14, 1)[0];
result[1] = i2cConnection.Read(0x15, 1)[0];
var tempCode = result[0] * 256 + result[1];
return(tempCode * ((float)(510f) / 65535) - 273.15f);
}
/// <summary>
/// Reads sleep date from board.
/// </summary>
/// <param name="conn"></param>
/// <returns></returns>
public static SleepDateTime ReadSleepDate(I2cDeviceConnection conn)
{
conn.WriteByte(0x0B);
var bytes = conn.Read(3);
var piDate = new SleepDateTime
(
min: GetByte(bytes[0]).Value,
hour: GetByte(bytes[1]).Value,
day: GetByte(bytes[2]).Value
);
return(piDate);
}
/// <summary>
/// Reads wake up date from board.
/// </summary>
/// <param name="conn"></param>
/// <returns></returns>
public static WakeUpDateTime ReadWakeUpDate(I2cDeviceConnection conn)
{
conn.WriteByte(0x07);
var bytes = conn.Read(4);
var piDate = new WakeUpDateTime
(
GetByte(bytes[3]),
GetByte(bytes[2]),
GetByte(bytes[1]),
GetByte(bytes[0]).Value
);
return(piDate);
}
/// <summary>
/// Reads the temperature value from the sensor.
/// </summary>
/// <returns>Temperature in degrees Centigrade.</returns>
public double ReadTemperature()
{
if (ReadMode == I2cReadMode.NoHoldMaster)
{
throw new NotSupportedException("No-Hold-Master read mode not supported.");
}
connection.WriteByte((byte)I2cDefs.HTU21DF_READTEMP);
// Add delay between request and actual read
Thread.Sleep(50);
// Read 3 bytes; 2 bytes temp data and one byte checksum.
var readBytes = connection.Read(3);
CheckCrc(readBytes);
// Get data value from bytes 0 and 1.
var tVal = (readBytes[0] << 8) + readBytes[1];
// Compute temp using formula from datasheet.
return(((tVal * 175.72) / 65536) - 46.85);
}
/**************************************************************************/
/*!
* @brief Reads the raw data from the sensor
*/
/**************************************************************************/
private void read()
{
byte[] addr = new byte[] { (byte)((byte)lsm303AccelRegisters_t.LSM303_REGISTER_ACCEL_OUT_X_L_A | 0x80) };
byte[] data = new byte[6];
I2CDev.Write((byte)lsm303AccelRegisters_t.LSM303_REGISTER_ACCEL_OUT_X_L_A);
data = I2CDev.Read(6);
byte xlo = data[0];
byte xhi = data[1];
byte ylo = data[2];
byte yhi = data[3];
byte zlo = data[4];
byte zhi = data[5];
// Shift values to create properly formed integer (low byte first)
_accelData.x = (short)(xlo | (xhi << 8)) >> 4;
_accelData.y = (short)(ylo | (yhi << 8)) >> 4;
_accelData.z = (short)(zlo | (zhi << 8)) >> 4;
}
/**************************************************************************/
/*!
* @brief Reads the raw data from the sensor
*/
/**************************************************************************/
private void read()
{
byte[] addr = new byte[] { (byte)((byte)lsm303MagRegisters_t.LSM303_REGISTER_MAG_OUT_X_H_M) };
byte[] data = new byte[6];
I2CDev.Write((byte)lsm303MagRegisters_t.LSM303_REGISTER_MAG_OUT_X_H_M);
data = I2CDev.Read(6);
byte xlo = data[0];
byte xhi = data[1];
byte ylo = data[2];
byte yhi = data[3];
byte zlo = data[4];
byte zhi = data[5];
// Shift values to create properly formed integer (low byte first)
_magData.x = (short)(xlo | ((short)xhi << 8));
_magData.y = (short)(ylo | ((short)yhi << 8));
_magData.z = (short)(zlo | ((short)zhi << 8));
_magData.orientation = 0.0f;
}
private void Run(string[] args)
{
//
// see the end of this file more information on reading the TMP102
//
Console.WriteLine("Press any key to exit...\n");
int seconds = 3;
Console.WriteLine("TMP102 (Model: SEN-11931): Measure temperature");
Console.WriteLine($"Measure: I2C every {seconds} second(s)");
int i2cAddress = 0x48;
using (var driver = new I2cDriver(ProcessorPin.Pin2, ProcessorPin.Pin3))
{
I2cDeviceConnection connection = driver.Connect(i2cAddress);
while (!Console.KeyAvailable)
{
byte[] data = connection.Read(2);
// the msb is the first byte on linux
byte msb = data[0];
// the lsb is the second byte on linux
byte lsb = data[1];
// now combine then back together with msb first
int temperature = ((msb << 8) | lsb) >> 4;
Console.WriteLine(
"Temperature is {0}°C, {1}°F",
temperature * .0625,
(temperature * .0625 * 1.8) + 32);
System.Threading.Thread.Sleep(seconds * 1000);
}
}
}
private object ReadTemperature(I2cDeviceConnection connection)
{
byte[] data = connection.Read(2);
// the msb is the first byte on linux
byte msb = data[0];
// the lsb is the second byte on linux
byte lsb = data[1];
// now combine then back together with msb first
int temperature = ((msb << 8) | lsb) >> 4;
object temps = new
{
date = DateTime.UtcNow.ToString("o"),
temperatureF = (temperature * .0625 * 1.8) + 32,
temperatureC = temperature * .0625,
};
return(temps);
}
private void UpdateEZO()
{
try
{
i2cConnection.Write(Encoding.ASCII.GetBytes("R"));
//ezo needs 900 milliseconds to get a value ready
Observable
.Timer(TimeSpan.FromMilliseconds(900))
.Subscribe(
x =>
{
try
{
byte[] result = i2cConnection.Read(20);
if (result[0] == 1)
{
String strPH = Encoding.ASCII.GetString(result).Substring(1);
Double phResult = 0;
Double.TryParse(strPH, out phResult);
UpdatePH(phResult);
}
else
{
phTile.Set("ERR");
}
}
catch (Exception)
{
}
});
}
catch (Exception err)
{
}
}
private byte[] ReadBytes(byte address, int byteCount)
{
connection.WriteByte(address);
return(connection.Read(byteCount));
}
/**************************************************************************/
/*!
* @brief Gets the most recent sensor event
*/
/**************************************************************************/
public void getEvent(ref sensors_event_t Event)
{
bool readingValid = false;
Event.sensor_id = _sensorID;
Event.type = 4; // SENSOR_TYPE_GYROSCOPE;
while (!readingValid)
{
Event.timestamp = 0;
byte[] addr = new byte[] { (byte)((byte)gyroRegisters_t.GYRO_REGISTER_OUT_X_L | 0x80) };
byte[] data = new byte[6];
I2CDev.Write((byte)gyroRegisters_t.GYRO_REGISTER_OUT_X_L);
data = I2CDev.Read(6);
byte xlo = data[0];
byte xhi = data[1];
byte ylo = data[2];
byte yhi = data[3];
byte zlo = data[4];
byte zhi = data[5];
/* Shift values to create properly formed integer (low byte first) */
Event.gyro.x = (short)(xlo | (xhi << 8));
Event.gyro.y = (short)(ylo | (yhi << 8));
Event.gyro.z = (short)(zlo | (zhi << 8));
/* Make sure the sensor isn't saturating if auto-ranging is enabled */
if (!_autoRangeEnabled)
{
readingValid = true;
}
else
{
/* Check if the sensor is saturating or not */
if ((Event.gyro.x >= 32760) | (Event.gyro.x <= -32760) |
(Event.gyro.y >= 32760) | (Event.gyro.y <= -32760) |
(Event.gyro.z >= 32760) | (Event.gyro.z <= -32760))
{
/* Saturating .... increase the range if we can */
switch (_range)
{
case gyroRange_t.GYRO_RANGE_500DPS:
/* Push the range up to 2000dps */
_range = gyroRange_t.GYRO_RANGE_2000DPS;
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG1, 0x00);
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG1, 0x0F);
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG4, 0x20);
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG5, 0x80);
readingValid = false;
// Serial.println("Changing range to 2000DPS");
break;
case gyroRange_t.GYRO_RANGE_250DPS:
/* Push the range up to 500dps */
_range = gyroRange_t.GYRO_RANGE_500DPS;
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG1, 0x00);
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG1, 0x0F);
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG4, 0x10);
write8((byte)gyroRegisters_t.GYRO_REGISTER_CTRL_REG5, 0x80);
readingValid = false;
// Serial.println("Changing range to 500DPS");
break;
default:
readingValid = true;
break;
}
}
else
{
/* All values are withing range */
readingValid = true;
}
}
}
/* Compensate values depending on the resolution */
switch (_range)
{
case gyroRange_t.GYRO_RANGE_250DPS:
Event.gyro.x *= GYRO_SENSITIVITY_250DPS;
Event.gyro.y *= GYRO_SENSITIVITY_250DPS;
Event.gyro.z *= GYRO_SENSITIVITY_250DPS;
break;
case gyroRange_t.GYRO_RANGE_500DPS:
Event.gyro.x *= GYRO_SENSITIVITY_500DPS;
Event.gyro.y *= GYRO_SENSITIVITY_500DPS;
Event.gyro.z *= GYRO_SENSITIVITY_500DPS;
break;
case gyroRange_t.GYRO_RANGE_2000DPS:
Event.gyro.x *= GYRO_SENSITIVITY_2000DPS;
Event.gyro.y *= GYRO_SENSITIVITY_2000DPS;
Event.gyro.z *= GYRO_SENSITIVITY_2000DPS;
break;
}
/* Convert values to rad/s */
Event.gyro.x *= SENSORS_DPS_TO_RADS;
Event.gyro.y *= SENSORS_DPS_TO_RADS;
Event.gyro.z *= SENSORS_DPS_TO_RADS;
}
public byte GetPort(Port port) => connection.Read(GetRegisterAddress(Register.GPIOA, port));