// Explorations into I2C usage
public static void Sketch()
{
// Create the config object with device address and clock speed
I2CDevice.Configuration c = new I2CDevice.Configuration(0x68, 100);
I2CDevice d = new I2CDevice(c);
byte[] read_byte = new byte[1];
byte test_value = 0x00;
while (test_value < 0xff)
{
// Read the register
I2CDevice.I2CWriteTransaction w = I2CDevice.CreateWriteTransaction(new byte[] { 0x14 });
I2CDevice.I2CReadTransaction r = I2CDevice.CreateReadTransaction(read_byte);
int bytes_exchanged = d.Execute(new I2CDevice.I2CTransaction[] { w, r }, 100);
// Write to the register
w = I2CDevice.CreateWriteTransaction(new byte[] { 0x14, test_value });
bytes_exchanged = d.Execute(new I2CDevice.I2CTransaction[] { w }, 100);
foreach (byte b in read_byte)
{
Debug.Print(b.ToString());
}
test_value++;
Thread.Sleep(3000);
}
}
/// <summary>
/// Example sensor constructor
/// </summary>
/// <param name="address">I2C device address of the example sensor</param>
public DS1621(byte address)
{
Address = address;
_slaveConfig = new I2CDevice.Configuration(address, ClockRateKHz);
I2CBus.GetInstance().Write(_slaveConfig, new byte[] { CONFIG_CMD, 0x01 }, TransactionTimeout);
}
public TSL2561(byte I2CAddress, int ClockinKHz)
{
I2CConfig = new I2CDevice.Configuration(I2CAddress, ClockinKHz);
I2C = new I2CDevice(I2CConfig);
// read the ID register.
var Actions = new I2CDevice.I2CTransaction[2];
byte[] rx = new byte[1];
Actions[0] = I2CDevice.CreateWriteTransaction(new byte[] { 0x0a });
Actions[1] = I2CDevice.CreateReadTransaction(rx);
if (I2C.Execute(Actions, 1000) == 0)
{
Debug.Print("Read ID Register failed");
// exit or something
}
else
{
Debug.Print("ID value: " + rx[0].ToString());
}
// 4 msb must be 0001 for a TSL2561
if ((rx[0] & 0xf0) != 0xa0)
{
// exit or something
}
setGain(0x10);
Thread.Sleep(5); // Mandatory after each Write transaction !!!
}
void run()
{
values[0] = values[1] = values[2] = -1;
oldValues[0] = oldValues[1] = oldValues[2] = -1;
I2CDevice.Configuration configuration = new I2CDevice.Configuration(deviceAddress, 400);
I2CDevice adxl345 = new I2CDevice(configuration);
writeCommand(adxl345, 0x2d, 0);
writeCommand(adxl345, 0x2d, 16);
writeCommand(adxl345, 0x2d, 8);
// Set the g range to 2g - typical output: 17, -32, 257 (scale = 3.9 => 66 mg, -124 mg, 1002 mg)
writeCommand(adxl345, 0x31, 0);
// Set the g range to 16g - typical output: 2, -4, 31 (scale = 31.2 => 62.4 mg, -124.8 mg, 967 mg)
// writeCommand(adxl345, 0x31, 3);
while (true)
{
readValues(adxl345, values);
if ((changed(values[0], oldValues[0])) || (changed(values[1], oldValues[1])) || (changed(values[2], oldValues[2])))
{
//Debug.Print("Values: " + values[0] + ", " + values[1] + ", " + values[2]+"\n");
reporter.report(values[0] + "," + values[1] + "," + values[2]+"\n\r");
}
oldValues[0] = values[0];
oldValues[1] = values[1];
oldValues[2] = values[2];
}
}
/// <summary>
/// Create a new abstract I2C device.
/// </summary>
/// <param name="Address">I2C address.</param>
/// <param name="ClockRateKhz">I2C clockrate.</param>
public I2CPlug(Byte Address,
UInt32 ClockRateKhz = DefaultClockRate)
{
this._Address = Address;
this.I2C_Config = new I2CDevice.Configuration(this.Address, (Int32) ClockRateKhz);
this.I2C_Device = new I2CDevice(this.I2C_Config);
}
public Accelerometer(I2CDevice bus, ushort deviceAddress = 0x53, int clockRate = 400)
{
this.bus = bus;
configuration = new I2CDevice.Configuration(deviceAddress, clockRate);
ConfigureDevice();
}
public static void Main()
{
//our 10 bit address
const ushort address10Bit = 0x1001; //binary 1000000001 = 129
const byte addressMask = 0x78; //reserved address mask 011110XX for 10 bit addressing
//first MSB part of address
ushort address1 = addressMask | (address10Bit >> 8); //is 7A and contains the two MSB of the 10 bit address
I2CDevice.Configuration config = new I2CDevice.Configuration(address1, 100);
I2CDevice device = new I2CDevice(config);
//second LSB part of address
byte address2 = (byte)(address10Bit & 0xFF); //the other 8 bits (LSB)
byte[] address2OutBuffer = new byte[] { address2 };
I2CDevice.I2CWriteTransaction addressWriteTransaction = device.CreateWriteTransaction(address2OutBuffer);
//prepare buffer to write data
byte[] outBuffer = new byte[] { 0xAA };
I2CDevice.I2CWriteTransaction writeTransaction = device.CreateWriteTransaction(outBuffer);
//prepare buffer to read data
byte[] inBuffer = new byte[4];
I2CDevice.I2CReadTransaction readTransaction = device.CreateReadTransaction(inBuffer);
//execute transactions
I2CDevice.I2CTransaction[] transactions =
new I2CDevice.I2CTransaction[] { addressWriteTransaction, writeTransaction, readTransaction };
device.Execute(transactions, 100);
}
private static void test1602()
{
//I2CScanner.ScanAddresses(0, 120);
//address 39
I2CDevice.Configuration conf = new I2CDevice.Configuration(39, 100);
LcdCharacter_I2C lcd = new LcdCharacter_I2C(new I2CDevice(conf),4,20);
lcd.Init();
lcd.WriteText("TEST ZAPISU delsi".ToCharArray());
lcd.SetCursorDirection(false);
lcd.SetCursorPosition(1, 3);
Thread.Sleep(5000);
//lcd.MoveText(true);
Thread.Sleep(5000);
lcd.SetupDisplay(true, true, false);
lcd.SetCursorPosition(0, 19);
lcd.WriteChar('E');
lcd.SetCursorPosition(1, 19);
lcd.WriteChar('E');
lcd.SetCursorPosition(2, 19);
lcd.WriteChar('E');
lcd.SetCursorPosition(3, 19);
lcd.WriteChar('E');
//lcd.ResetDisplay();
//lcd.WriteChar('A');
}
public static void Sketch01()
{
//create I2C object
//note that the netmf i2cdevice configuration requires a 7-bit address! It set the 8th R/W bit automatically.
I2CDevice.Configuration con =
new I2CDevice.Configuration(0x68, 100);
I2CDevice MyI2C = new I2CDevice(con);
// Create transactions
// We need 2 in this example, we are reading from the device
// First transaction is writing the "read command"
// Second transaction is reading the data
I2CDevice.I2CTransaction[] xActions =
new I2CDevice.I2CTransaction[2];
// create write buffer (we need one byte)
byte[] RegisterNum = new byte[1] { 0x14 };
xActions[0] = I2CDevice.CreateWriteTransaction(RegisterNum);
// create read buffer to read the register
byte[] RegisterValue = new byte[1];
xActions[1] = I2CDevice.CreateReadTransaction(RegisterValue);
// Now we access the I2C bus using a timeout of one second
// if the execute command returns zero, the transaction failed (this
// is a good check to make sure that you are communicating with the device correctly
// and don’t have a wiring issue or other problem with the I2C device)
if (MyI2C.Execute(xActions, 1000) == 0)
{
Debug.Print("Failed to perform I2C transaction");
}
else
{
Debug.Print("Register value: " + RegisterValue[0].ToString());
}
}
/// <summary>
/// Turns on the Oscillator. Turns on the Display. Turns off Blinking. Sets Brightness to full.
/// </summary>
public void Init()
{
Config = new I2CDevice.Configuration(HT16K33_ADRESS, HT16K33_CLKRATE);
Matrix = new I2CDevice(Config);
byte[] write = new byte[1];
write[0] = HT16K33_OSC_ON; // IC Oscillator ON
byte[] write2 = new byte[1];
write2[0] = HT16K33_DISPLAY_ON; // Display ON
I2CDevice.I2CTransaction[] i2cTx = new I2CDevice.I2CTransaction[1];
i2cTx[0] = I2CDevice.CreateWriteTransaction(write);
I2CDevice.I2CTransaction[] i2cTx2 = new I2CDevice.I2CTransaction[1];
i2cTx2[0] = I2CDevice.CreateWriteTransaction(write2);
Matrix.Execute(i2cTx, Timeout);
Matrix.Execute(i2cTx2, Timeout);
// initialize DisplayBuffer
for (int i = 0; i < 8; i++)
{
DisplayBuffer[i] = 0x00;
}
}
void Connect ()
{
if (i2cDevice != null)
return;
this.i2cConfig = new I2CDevice.Configuration (this.Address, clockRateKhz);
this.i2cDevice = new I2CDevice (this.i2cConfig);
}
public BaseI2CDevice(byte address = 0, int transactionTimeout = 1000, int clockRate = 100)
{
this.Address = address;
this.TransactionTimeout = transactionTimeout;
this.ClockRate = clockRate;
config = new I2CDevice.Configuration(Address, ClockRate);
}
public BMP085_BaroSensor(byte address)
{
// initialize i2c device.
Address = address;
_slaveConfig = new I2CDevice.Configuration(address, ClockRateKHz);
// Pull calbration data from sensor and store in variables.
GetInitialCalibration();
}
/// <summary>
/// Constructor - Sets up configuration and starts thread
/// </summary>
/// <param name="address">I2C Address</param>
/// <param name="clockRateKhz">Clockrate</param>
public LM75Driver(ushort address, int clockRateKhz)
{
//Setup configuration
config = new I2CDevice.Configuration(address, clockRateKhz);
// Initial, not being used, but then thread wont be null used throughout to check status.
thread = new Thread(Pull);
//Start driver
Start();
}
public I2CDevice2(I2CDevice.Configuration config)
{
// In the constructor a
if (config == null)
throw new ArgumentNullException();
this.Config = config;
if (singletonDevice == null)
singletonDevice = new I2CDevice(config);
instanceCount++;
}
public TWIDisplay(ushort address)
{
I2CDevice.Configuration config = new I2CDevice.Configuration(address, 100);
m_display = new I2CDevice(config);
m_data = new byte[4];
m_dots = 0;
setRotateMode();
}
public BlinkMArray()
{
_i2cDevice = new I2CDevice(null);
_blinkM_D = new I2CDevice.Configuration(0x0D, BlinkMCommand.DefaultClockRateKhz);
_blinkM_E = new I2CDevice.Configuration(0x0E, BlinkMCommand.DefaultClockRateKhz);
_blinkM_F = new I2CDevice.Configuration(0x0F, BlinkMCommand.DefaultClockRateKhz);
InitBlinkM(_i2cDevice, _blinkM_D);
InitBlinkM(_i2cDevice, _blinkM_E);
InitBlinkM(_i2cDevice, _blinkM_F);
}
public NativeI2CBus(Socket socket, ushort address, int clockRateKhz, Module module)
{
if (_device == null)
{
socket.ReservePin(Socket.Pin.Eight, module);
socket.ReservePin(Socket.Pin.Nine, module);
_device = new I2CDevice(new I2CDevice.Configuration(0, 50));
}
_configuration = new I2CDevice.Configuration(address, clockRateKhz);
}
public BMP085(byte address, DeviceMode deviceMode)
{
Address = address;
_slaveConfig = new I2CDevice.Configuration(address, ClockRateKHz);
_oversamplingSetting = (byte)deviceMode;
// Get calibration data that will be used for future measurement taking.
GetCalibrationData();
// Take initial measurements.
TakeMeasurements();
}
public I2CDevice2(I2CDevice.Configuration config)
{
// In the constructor a
if (config == null)
{
throw new ArgumentNullException();
}
this.Config = config;
if (singletonDevice == null)
{
singletonDevice = new I2CDevice(config);
}
instanceCount++;
}
public ECO2Result ReadCO2(ref int co2Data)
{
co2Data = 0;
ECO2Result result = ECO2Result.UnknownResult;
I2CDevice.Configuration slaveConfig = new I2CDevice.Configuration(0x7F, 10);
byte[] dataWrite = new byte[4] { 0x22, 0x00, 0x08, 0x2A };
int transferred = Write(slaveConfig, dataWrite, 5000);
if (transferred > 0)
{
Thread.Sleep(50);
byte[] dataRead = new byte[4] { 0x00, 0x00, 0x00, 0x00 };
transferred = Read(slaveConfig, dataRead, 5000);
if (transferred > 0)
{
if ((dataRead[0] & 0x01) == 1)
{
co2Data |= dataRead[1] & 0xFF;
co2Data = co2Data << 8;
co2Data |= dataRead[2] & 0xFF;
if (dataRead[3] == CheckSum(dataRead, 3))
{
result = ECO2Result.ValidResult;
}
else
{
result = ECO2Result.ChecksumError;
}
}
else
{
result = ECO2Result.ReadIncomplete;
}
}
else
{
result = ECO2Result.NoReadDataTransfered;
}
}
else
{
result = ECO2Result.NoWriteDataTransfered;
}
return result;
}
protected override ArrayList GetOnlineModules()
{
ArrayList result = new ArrayList();
for (byte address = 1; address <= 127; address++)
{
byte type = (byte)BusModuleType.Unknown;
var config = new I2CDevice.Configuration(address, BusConfigurationI2C.ClockRate); // config for I2C-module with "address"
if (busConfig.Bus.TryGetRegister(config, BusConfigurationI2C.Timeout, BusModuleAPI.CmdGetType, out type)) // query module
result.Add(new BusModule(this, new byte[] { address }, (BusModuleType)type));
}
return result;
}
/// <summary>
/// Initializes a new I²C device
/// </summary>
/// <param name="Address">The address of the I²C device</param>
/// <param name="ClockRateKhz">The speed in Khz of the I²C device</param>
public MultiI2C(ushort Address, int ClockRateKhz = 100)
{
// Sets the configuration in a local value
this._Configuration = new I2CDevice.Configuration(Address, ClockRateKhz);
// Sets the default timeout
this.Timeout = 100;
// If no I2C Device exists yet, we create it's first instance
if (_I2CDevice == null)
{
// Creates the SPI Device
_I2CDevice = new I2CDevice(this._Configuration);
}
}
protected override void ScanModules(out ArrayList modulesAdded, out ArrayList modulesRemoved)
{
modulesAdded = new ArrayList();
modulesRemoved = new ArrayList();
for (byte address = 1; address <= 127; address++)
{
byte type = (byte)BusModuleType.Unknown;
var config = new I2CDevice.Configuration(address, BusConfigurationI2C.ClockRate); // config for I2C-module with "address"
if (busConfig.Bus.TryGetRegister(config, BusConfigurationI2C.Timeout, BusModuleAPI.CmdGetType, out type)) // query module
{
// module with this address is online;
// check if it's already registered in BusModules:
BusModule busModule = this[new byte[] { address }];
if (busModule == null) // module with this address isn't registered
{
busModule = new BusModule(this, new byte[] { address }, (BusModuleType)type);
// query module control lines count with updating lines states:
//busModule.QueryControlLines(true);
// register this module in BusModules:
modulesAdded.Add(busModule);
BusModules.Add(busModule);
}
else // module with this address is already registered
{
// updated when added;
}
}
else
{
// module with this address is offline;
// check if it's already registered in BusModules:
BusModule busModule = this[new byte[] { address }];
if (busModule != null) // offline module
{
modulesRemoved.Add(busModule);
BusModules.Remove(busModule);
}
}
}
}
public BMP085(byte address, DeviceMode deviceMode)
{
Address = address;
_slaveConfig = new I2CDevice.Configuration(address, ClockRateKHz);
_oversamplingSetting = (byte)deviceMode;
// Get calibration data that will be used for future measurement taking.
GetCalibrationData();
// Take initial measurements.
TakeMeasurements();
// Take new measurements every 30 seconds.
//modificacion mia, en vez de tomar las mediciones aca, hago al metodo publico y lo llamo yo
//_sensorTimer = new Timer(TakeMeasurements, null, 200, 30000);
}
/// <summary>
/// Ensure to instantiate the MicroMaestro with the Robot given to the student and the device num (probably 13 or 14)
/// This will take care of connecting the MicroMaestro to the robot's system
/// </summary>
/// <param name="robo"> The robot this Simple is connected to. </param>
/// <param name="deviceNum"> The device number of this Simple. </param>
public I2CMotorController(Robot robo, ushort deviceAdd)
{
//attach to robot, allowing itself to be updated by the Robot thread when called
robot = robo;
robot.actuators.Add(this);
deviceAddress = deviceAdd;
//initialize the motor as not turning
canMove = true;
motorSpeed = 0;
motorBrake = 0;
//create I2C Device object representing both devices on our bus
conDeviceA = new I2CDevice.Configuration(deviceAddress, 100);
//create I2C Bus object using one of the devices on the bus
//I2CA = new I2CDevice(conDeviceA);
}
// Note: A constructor summary is auto-generated by the doc builder.
/// <summary></summary>
/// <remarks>This automatically checks that the socket supports Type I, and reserves the SDA and SCL pins.
/// An exception will be thrown if there is a problem with these checks.</remarks>
/// <param name="address">The address for the I2C device.</param>
/// <param name="clockRateKhz">The clock rate, in kHz, used when communicating with the I2C device.</param>
/// <param name="socket">The socket for this I2C device interface.</param>
/// <param name="module">The module using this I2C interface, which can be null if unspecified.</param>
public I2CBus(Socket socket, ushort address, int clockRateKhz, Module module)
{
socket.EnsureTypeIsSupported('I', module);
lock (I2CLock)
{
if (device == null)
{
socket.ReservePin(Socket.Pin.Eight, module);
socket.ReservePin(Socket.Pin.Nine, module);
device = new I2CDevice(new I2CDevice.Configuration(0, 50));
}
this.configuration = new I2CDevice.Configuration(address, clockRateKhz);
}
}
public static void Main()
{
OutputPort Led = new OutputPort(Pins.ONBOARD_LED, false);
byte[] Addr=new byte[2];
Addr[0]=0x00;
Addr[1]=0x01;
byte[] TxBuff = new byte[4];
TxBuff[0] = (byte)'1';
TxBuff[1] = (byte)'2';
TxBuff[2] = (byte)'3';
TxBuff[3] = (byte)'4';
byte[] RxBuff= new byte[4];
I2CDevice.Configuration I2C_Configuration = new I2CDevice.Configuration(0x50, 400);
I2CDevice I2C1 = new I2CDevice(I2C_Configuration);
I2CDevice.I2CTransaction[] WriteTran = new I2CDevice.I2CTransaction[]
{
I2CDevice.CreateWriteTransaction(Addr),
I2CDevice.CreateWriteTransaction(TxBuff)
};
I2CDevice.I2CTransaction[] ReadTran = new I2CDevice.I2CTransaction[]
{
I2CDevice.CreateWriteTransaction(Addr),
I2CDevice.CreateReadTransaction(RxBuff)
};
while(true)
{
Led.Write(true);
I2C1.Execute(WriteTran, 1000);
Debug.Print("Write Success!");
Thread.Sleep(200);
I2C1.Execute(ReadTran, 1000);
Debug.Print("Read Success!");
string ReadOut = new string(System.Text.Encoding.UTF8.GetChars(RxBuff));
Debug.Print("EEPROM CONTENT:"+ReadOut);
Led.Write(false);
Thread.Sleep(200);
}
}
public PolarBear(Robot robo, ushort deviceAdd)
: base(robo)
{
//attach to robot, allowing itself to be updated by the Robot thread when called
robot.actuators.Add(this);
deviceAddress = deviceAdd;
//initialize the motor as not turning
canMove = true;
velocity = 0;
brakeAmount = 0;
upperStopZone = 0;
lowerStopZone = 0;
minVelocity = -255;
maxVelocity = 255;
//create I2C Device object representing both devices on our bus
conDeviceA = new I2CDevice.Configuration(deviceAddress, 100);
}
public static void Main() {
led = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, ledState);
config = new I2CDevice.Configuration(address, clockRateKHz);
device = new I2CDevice(config);
WIZnet_W5100.Enable(SPI.SPI_module.SPI1, (Cpu.Pin)FEZ_Pin.Digital.Di10, (Cpu.Pin)FEZ_Pin.Digital.Di7, true);
Dhcp.EnableDhcp(new byte[] { 0x00, 0x26, 0x1C, 0x7B, 0x29, 0xE8 }, "tt");
while (true) {
uploadData(gatherData());
getHeaterStatus();
setHeaterStatus();
Thread.Sleep(updateTime);
}
}
public void Init()
{
LCD_I2C_Config = new I2CDevice.Configuration(LCD_I2C_Address, LCD_I2C_Speed);
LCD_I2C = new I2CDevice(LCD_I2C_Config);
Thread.Sleep(10);
WriteCommand(0x33);//Init Back to 8 bits mode befor set to 4 bits mode
Thread.Sleep(1);
WriteCommand(0x32);//Init Back to 8 bits mode befor set to 4 bits mode
Thread.Sleep(1);
WriteCommand(0x28);//Config to 4bits mode,2 Row display
Thread.Sleep(1);
WriteCommand(0x0C);//display on,cursor off
Thread.Sleep(1);
WriteCommand(0x01);//clear display
Thread.Sleep(1);
}