public IOHandler()
{
RaspberryPi.Initialize();
this.I2C = new I2CBusPi();
this.SPI = new SPIBusPi(0);
this.PWMGenHighFreq = new PCA9685(this.I2C, 0x4C, -1, PCA9685.OutputInvert.Inverted, PCA9685.OutputDriverMode.OpenDrain);
this.PWMGenLowFreq = new PCA9685(this.I2C, 0x74, -1, PCA9685.OutputInvert.Inverted, PCA9685.OutputDriverMode.OpenDrain);
this.PWMGenHighFreq.SetFrequency(333);
this.PWMGenLowFreq.SetFrequency(50);
this.RailController = new Rail(this.PWMGenHighFreq.Outputs[0], new DigitalInPi(11), this.SPI, new DigitalOutPi(29), this.I2C, null)
{
TraceLogging = true
};
this.DrillController = new Drill(this.PWMGenHighFreq.Outputs[1], this.PWMGenLowFreq.Outputs[0]);
this.SampleController = new Sample(this.PWMGenLowFreq.Outputs[1]);
this.LEDController = new LEDs(this.PWMGenLowFreq.Outputs, this.PWMGenHighFreq.Outputs);
this.AuxSensors = new AuxSensors(this.SPI, this.I2C)
{
TraceLogging = false
};
this.SysSensors = new SysSensors();
this.Music = new MusicPlayer();
this.InitProcedure = new ISubsystem[] { this.RailController, this.DrillController, this.LEDController, this.AuxSensors, this.SysSensors, this.Music };
this.EStopProcedure = new ISubsystem[] { this.Music, this.RailController, this.DrillController, this.LEDController, this.AuxSensors, this.SysSensors };
this.UpdateProcedure = new ISubsystem[] { this.RailController, this.DrillController, this.LEDController /*, this.AuxSensors, this.SysSensors*/ };
if (this.EStopProcedure.Length < this.InitProcedure.Length || this.EStopProcedure.Length < this.UpdateProcedure.Length)
{
throw new Exception("A system is registered for init or updates, but not for emergency stop. For safety reasons, this is not permitted.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Scarlet.Components.Sensors.BNO055"/> class, which will communicate via
/// the given I2C bus.
/// </summary>
/// <param name="I2C"> The I2C bus to communicate over. </param>
/// <param name="ID"> ID of BNO055. -1 by default. You probably shouldn't change this. </param>
/// <param name="Address"> The I2C address of the BNO055. Defaults to 0x28. You probably shouldn't change this. </param>
public BNO055(II2CBus I2C, int ID = -1, byte Address = BNO055_ADDRESS_A)
{
this.ID = ID;
this.Address = Address;
this.I2C = I2C;
Begin();
}
public VEML6070(II2CBus Bus, byte Address = 0x38)
{
this.AddressLSB = Address;
this.AddressMSB = (byte)(Address + 1);
this.Bus = Bus;
SetRefreshSpeed((RefreshSpeed)this.Speed);
}
public static void Scan(II2CBus bus)
{
if (bus == null)
{
throw new ArgumentNullException("bus");
}
int count = 0;
const int clockRateKhz = 100;
const int timeout = 100;
const byte startAddress = 0x08;
const byte endAddress = 127;
Debug.Print("Scanning I2C Bus for devices starting at: " + HexString.GetString(startAddress) + " ... ");
for (byte address = startAddress; address < endAddress; address++)
{
var configuration = new I2CDevice.Configuration(address, clockRateKhz);
var buffer = new byte[] {
0
};
bool canRead = bus.Read(configuration, buffer, timeout);
bool canWrite = bus.Write(configuration, buffer, timeout);
if (canRead || canWrite)
{
count++;
Debug.Print("Address: 0x" + HexString.GetString(address) + ", Read => " + canRead + ", Write => " + canWrite);
}
}
Debug.Print("Scanning ended at: " + HexString.GetString(endAddress));
Debug.Print("Scanning found " + count + " devices.");
}
public HSPE16InputOnly(DeviceId id, I2CSlaveAddress address, II2CBus i2cBus)
: base(id, new MAX7311Driver(address, i2cBus))
{
byte[] setupAsInputs = { 0x06, 0xFF, 0xFF };
i2cBus.Execute(address, b => b.Write(setupAsInputs));
FetchState();
}
public HSPE16InputOnly(DeviceId id, I2CSlaveAddress address, II2CBus i2cBus, IHttpRequestController httpApi, ILogger logger)
: base(id, new MAX7311Driver(address, i2cBus), httpApi, logger)
{
byte[] setupAsInputs = { 0x06, 0xFF, 0xFF };
i2cBus.Execute(address, b => b.Write(setupAsInputs));
FetchState();
}
public HSREL5(DeviceId id, I2CSlaveAddress i2CAddress, II2CBus bus, IHttpRequestController httpApi, ILogger logger)
: base(id, new PCF8574Driver(i2CAddress, bus), httpApi, logger)
{
// Ensure that all relays are off by default. The first 5 ports are hardware inverted! The other ports are not inverted but the
// connected relays are inverted.
SetState(new byte[] { 0xFF });
CommitChanges(true);
}
public TinyRTC(II2CBus bus, byte clockI2CAddress = 0x68, byte eepromI2CAddress = 0x50, int clockRateKhz = 100)
{
_clock = new DS1307(bus, clockI2CAddress, clockRateKhz);
//_eeprom = new _eeprom(bus, eepromI2CAddress, clockRateKhz);
_addressedMemoryMap = new AddressMap();
// 4k byte of ram on eeprom >> Virtual Address 0..3999
// 56 byte of ram on clock >> Virtual Address 5000..5055
_addressedMemoryMap.MapRange(0, 3999, address => address, _eeprom);
}
public void Initialize()
{
this.I2C1 = new I2CBusPi();
this.SystemSensor = new INA226(this.I2C1, 0x48, 10, 0.150);
this.DrillSensor = new INA226(this.I2C1, 0x49, 15, 0.010);
this.RailSensor = new INA226(this.I2C1, 0x4A, 60, 0.002);
this.TakeReadings = true;
}
public MAX7311Driver(I2CSlaveAddress address, II2CBus i2CBus)
{
if (i2CBus == null)
{
throw new ArgumentNullException(nameof(i2CBus));
}
_address = address;
_i2CBus = i2CBus;
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/>
/// class with the I2C bus device this instance is connected to and
/// the bus address of that device.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="busAddress">
/// The bus address of the device.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null.
/// </exception>
/// <exception cref="IOException">
/// Unable to open the I2C bus.
/// </exception>
public MicrochipPotDeviceController(II2CBus device, Int32 busAddress) {
if (device == null) {
throw new ArgumentNullException("device");
}
this._busAddr = busAddress;
this._device = device;
if (!this._device.IsOpen) {
this._device.Open();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Scarlet.Components.Sensors.BNO055"/> class, which will communicate via
/// the given I2C bus.
/// </summary>
/// <param name="I2C"> The I2C bus to communicate over. </param>
/// <param name="ID"> ID of BNO055. -1 by default. You probably shouldn't change this. </param>
/// <param name="Address"> The I2C address of the BNO055. Defaults to 0x28. You probably shouldn't change this. </param>
/// <param name="GPS"> A GPS to use to correct for location-based magnetic declination. </param>
public BNO055(II2CBus I2C, int ID = -1, byte Address = BNO055_ADDRESS_A, IGPS GPS = null)
{
this.ID = ID;
this.Address = Address;
this.I2C = I2C;
this.GPS = GPS;
bool SetupSuccess = Begin();
if (!SetupSuccess)
{
Log.Output(Log.Severity.WARNING, Log.Source.SENSORS, "BNO055 failed to initialize. Perhaps the sensor is not connected?");
}
}
public CCToolsBoardController(IController controller, II2CBus i2cBus)
{
if (i2cBus == null)
{
throw new ArgumentNullException(nameof(i2cBus));
}
if (controller == null)
{
throw new ArgumentNullException(nameof(controller));
}
_controller = controller;
_i2CBus = i2cBus;
}
/// <summary> Prepares the PCS9535E device for use. </summary>
/// <param name="Bus"> The I2C bus used to communicate with the device. </param>
/// <param name="Address"> The I2C address that the device is using. </param>
public PCA9535E(II2CBus Bus, byte Address)
{
this.Bus = Bus;
this.Address = Address;
this.IsChannelOutput = new bool[16];
this.Inputs = new PCA9535Input[16];
this.Outputs = new PCA9535Output[16];
for (byte i = 0; i < this.Inputs.Length; i++)
{
this.IsChannelOutput[i] = false;
this.Inputs[i] = new PCA9535Input(this, i);
this.Outputs[i] = new PCA9535Output(this, i);
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/>
/// class with the I2C bus device this instance is connected to and
/// the bus address of that device.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="busAddress">
/// The bus address of the device.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null.
/// </exception>
/// <exception cref="IOException">
/// Unable to open the I2C bus.
/// </exception>
public MicrochipPotDeviceController(II2CBus device, Int32 busAddress)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
this._busAddr = busAddress;
this._device = device;
if (!this._device.IsOpen)
{
this._device.Open();
}
}
/// <summary>
/// Creates an object of type IGpioExpander.
/// </summary>
/// <param name="bus">Object of type II2CBus.</param>
/// <param name="address">GPIO expander address.</param>
/// <returns>Returns an object of type IGpioExpander.</returns>
/// <exception cref="ArgumentNullException">Object of type II2CBus is null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Invalid address value.</exception>
/// <exception cref="KeyNotFoundException">Device not found.</exception>
#if WIRING_PI
public static GpioExpander GetGpioExpander(this II2CBus bus, int address = GpioExpander.DefaultAddress)
{
if (bus is null)
{
throw ThrowHelper.ArgumentNullException(nameof(bus));
}
if (address is < 0 or > 127)
{
throw ThrowHelper.ArgumentOutOfRangeException(nameof(address), address);
}
return(new RaspberryPiExpander(bus.AddDevice(address)));
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/>. The <see cref="Dispose"/> method
/// leaves the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/> in an unusable state. After
/// calling <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/> so the garbage collector can reclaim
/// the memory that the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/> was occupying.</remarks>
public override void Dispose()
{
if (base.IsDisposed)
{
return;
}
if (this._device != null)
{
this._device.Dispose();
this._device = null;
}
if (this._aX != null)
{
this._aX.Dispose();
this._aX = null;
}
if (this._aY != null)
{
this._aY.Dispose();
this._aY = null;
}
if (this._aZ != null)
{
this._aZ.Dispose();
this._aZ = null;
}
if (this._x != null)
{
this._x.Dispose();
this._x = null;
}
if (this._y != null)
{
this._y.Dispose();
this._y = null;
}
if (this._z != null)
{
this._z.Dispose();
this._z = null;
}
base.Dispose();
}
public PCA9685(II2CBus Bus, byte I2CAddress = 0x60)
{
SetAllPWM(0, 0);
this.Bus.WriteRegister(this.Address, PCA9685_MODE2, new byte[] { OUTDRV });
this.Bus.WriteRegister(this.Address, PCA9685_MODE1, new byte[] { ALLCALL });
Thread.Sleep(5);
byte mode1 = this.Bus.ReadRegister(this.Address, PCA9685_MODE1, 1)[0];
this.Bus.WriteRegister(this.Address, PCA9685_MODE1, new byte[] { (byte)(mode1 & ~SLEEP) });
Thread.Sleep(5);
SetFrequency(Frequency);
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/>. The <see cref="Dispose"/> method leaves the
/// <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/> in an unusable state. After calling
/// <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/> so the garbage collector can reclaim the memory that
/// the <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/> was occupying.</remarks>
public void Dispose()
{
if (this._isDisposed)
{
return;
}
// Try to abort gracefully first.
lock (_syncLock) {
this._pollAbort = true;
}
Thread.Sleep(100);
if ((this._pollThread != null) && (this._pollThread.IsAlive))
{
try {
// Graceful abort did not complete in time. Force terminate.
this._pollThread.Abort();
}
catch (ThreadAbortException) {
Thread.ResetAbort();
}
finally {
this._pollThread = null;
}
}
// Cleanup everything else.
if (this._device != null)
{
this._device.Dispose();
this._device = null;
}
if (this._pinCache != null)
{
this._pinCache.Clear();
this._pinCache = null;
}
if (this._currentStates != null)
{
this._currentStates.Clear();
this._currentStates = null;
}
this._isDisposed = true;
GC.SuppressFinalize(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/>
/// class with the I2C bus device, bus address of PCA9685 device,
/// target frequency, and frequency correction factor.
/// </summary>
/// <param name="bus">
/// The I2C bus device used to communicate with the PCA9685 chip.
/// </param>
/// <param name="address">
/// The address of the PCA9685 on the I2C bus.
/// </param>
/// <param name="targetFreq">
/// The target PWM frequency to set.
/// </param>
/// <param name="freqCorrectionFactor">
/// The PWM frequency correction factor.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="bus"/> cannot be null.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="targetFreq"/> must be between 40Hz and 1000Hz.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The specified I2C bus instance has been disposed and can no longer be used.
/// </exception>
/// <exception cref="IOException">
/// An I/O error occurred. The specified address is inacessible or the
/// I2C transaction failed.
/// </exception>
public PCA9685GpioProvider(II2CBus bus, Int32 address, Decimal targetFreq, Decimal freqCorrectionFactor)
{
if (bus == null)
{
throw new ArgumentNullException("bus");
}
this._pinCache = new List <IPCA9685Pin>();
this._busAddr = address;
this._busDevice = bus;
if (!this._busDevice.IsOpen)
{
this._busDevice.Open();
}
this._busDevice.WriteBytes(this._busAddr, new Byte[] { PCA9685_MODE1, (Byte)0x00 });
this.SetFrequency(targetFreq, freqCorrectionFactor);
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/>. The
/// <see cref="Dispose"/> method leaves the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/> in an unusable
/// state. After calling <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/> so the garbage
/// collector can reclaim the memory that the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/> was occupying.</remarks>
public void Dispose()
{
if (this._isDisposed)
{
return;
}
if (this._device != null)
{
this._device.Dispose();
this._device = null;
}
this._isDisposed = true;
GC.SuppressFinalize(this);
}
public I2CHardwareBridge(I2CSlaveAddress address, II2CBus i2cBus, IHomeAutomationTimer timer)
{
if (i2cBus == null)
{
throw new ArgumentNullException(nameof(i2cBus));
}
if (timer == null)
{
throw new ArgumentNullException(nameof(timer));
}
_address = address;
_i2CBus = i2cBus;
DHT22Accessor = new DHT22Accessor(this, timer);
}
public I2CHardwareBridge(I2CSlaveAddress address, II2CBus i2cBus, ISchedulerService schedulerService)
{
if (i2cBus == null)
{
throw new ArgumentNullException(nameof(i2cBus));
}
if (schedulerService == null)
{
throw new ArgumentNullException(nameof(schedulerService));
}
_address = address;
_i2CBus = i2cBus;
DHT22Accessor = new DHT22Accessor(this, schedulerService);
}
static void Main(string[] args)
{
int DEGREES_OFFSET = -20;
StateStore.Start("MagTest");
BeagleBone.Initialize(SystemMode.DEFAULT, true);
BBBPinManager.AddMappingsI2C(BBBPin.P9_17, BBBPin.P9_26);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_IF_NONE);
II2CBus I2C = I2CBBB.I2CBus1;
Console.WriteLine("Status: BBB Pin Mapings Complete");
if (I2C == null)
{
Console.WriteLine("ERROR: I2C not mapped correctly. Fix First");
}
else
{
Console.WriteLine("Status: I2C Not null");
BNO055 magObj = new BNO055(I2C);
Console.WriteLine("Status: BNO055 object created");
magObj.SetMode(BNO055.OperationMode.OPERATION_MODE_COMPASS);
magObj.Begin();
double direction;
while (true)
{
Tuple <float, float, float> magnets;
magnets = magObj.GetVector(BNO055.VectorType.VECTOR_MAGNETOMETER);
// Convert magnetic readings to degrees
direction = getDegrees(magnets);
//Add the offset from specific location
direction += DEGREES_OFFSET;
// Make sure degrees value is between 0 and 360
direction = standarize(direction);
Console.WriteLine(direction);
}
}
}
protected override void DisposeManagedResources()
{
if (_i2CBus != null)
{
_i2CBus.Dispose();
_i2CBus = null;
}
if (_spiBus != null)
{
_spiBus.Dispose();
_spiBus = null;
}
if (_onboardLed != null)
{
_onboardLed.Dispose();
_onboardLed = null;
}
}
public AdafruitMotorPWM(Motors Motor, II2CBus Bus, byte Address = 0x60)
{
this.Bus = Bus;
this.Address = Address;
this.Motor = Motor;
SetAllPWM(0, 0);
this.Bus.WriteRegister(this.Address, PCA9685_MODE2, new byte[] { OUTDRV });
this.Bus.WriteRegister(this.Address, PCA9685_MODE1, new byte[] { ALLCALL });
Thread.Sleep(5);
byte mode1 = this.Bus.ReadRegister(this.Address, PCA9685_MODE1, 1)[0];
this.Bus.WriteRegister(this.Address, PCA9685_MODE1, new byte[] { (byte)(mode1 & ~SLEEP) });
Thread.Sleep(5);
SetFrequency(Frequency);
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/>
/// class with the I2C device that represents the physical connection
/// to the gyro.
/// </summary>
/// <param name="device">
/// The I2C device that represents the physical connection to the gyro.
/// If null, then it is assumed that the host is a revision 2 or higher
/// board and a default <see cref="CyrusBuilt.MonoPi.IO.I2C.I2CBus"/>
/// using the rev 2 I2C bus path will be used instead.
/// </param>
/// <exception cref="IOException">
/// Unable to open the specified I2C bus device.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The specified device instance has been disposed.
/// </exception>
public ADXL345(II2CBus device)
: base() {
if (device == null) {
device = new I2CBus(BoardRevision.Rev2);
}
this._device = device;
if (!this._device.IsOpen) {
this._device.Open();
}
this._x = new AxisGyroscope(this, 20f);
this._y = new AxisGyroscope(this, 20f);
this._z = new AxisGyroscope(this, 20f);
this._aX = (AxisGyroscope)this._x;
this._aY = (AxisGyroscope)this._y;
this._aZ = (AxisGyroscope)this._z;
}
public CCToolsBoardController(IController controller, II2CBus i2cBus, IHttpRequestController httpApi, ILogger log)
{
if (i2cBus == null)
{
throw new ArgumentNullException(nameof(i2cBus));
}
if (controller == null)
{
throw new ArgumentNullException(nameof(controller));
}
if (httpApi == null)
{
throw new ArgumentNullException(nameof(httpApi));
}
_controller = controller;
_i2CBus = i2cBus;
_httpApi = httpApi;
_log = log;
}
// TODO: Implement the following:
// - Subaddress set (and use)
// - All call set (and use)
// - Software reset
/// <summary> Prepares the PCA9685 device for use. </summary>
/// <remarks> During setup, there will be quite a bit of communication with the device (70+ bytes). </remarks>
/// <param name="Bus"> The I2C bus that the device will communicate over. </param>
/// <param name="Address"> The I2C address set via the device's physical address pins. </param>
/// <param name="ExtOscFreq"> If there is an external oscillator, set the frequency here. If there isn't, set to -1. </param>
/// <param name="InvertMode"> Sets device-wide output invert mode. </param>
/// <param name="DriverMode"> Sets device-wide output driver configuration. </param>
/// <param name="DisableMode"> Sets device-wide output disable behaviour. </param>
/// <exception cref="ArgumentException"> If invalid oscillator frequency is provided. </exception>
public PCA9685(II2CBus Bus, byte Address, int ExtOscFreq = -1, OutputInvert InvertMode = OutputInvert.Regular, OutputDriverMode DriverMode = OutputDriverMode.TotemPole, OutputDisableBehaviour DisableMode = OutputDisableBehaviour.Low)
{
this.Bus = Bus;
this.PartAddress = Address;
this.ExtOscFreq = ExtOscFreq;
if (ExtOscFreq < -1 || ExtOscFreq > 50000000)
{
throw new ArgumentException("Invalid oscillator frequency supplied. Must be between 0 and 50 MHz, or -1 for internal oscillator.");
}
this.Outputs = new PWMOutputPCA9685[16];
for (byte i = 0; i < this.Outputs.Length; i++)
{
this.Outputs[i] = new PWMOutputPCA9685(i, this);
}
this.AllOutputs = new PWMOutputPCA9685(255, this);
this.InvertMode = InvertMode;
this.DriverMode = DriverMode;
this.DisableMode = DisableMode;
SetupDevice();
ReadAllStates();
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/>. The <see cref="Dispose"/> method leaves the
/// <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/> in an unusable state. After calling
/// <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/> so the garbage collector can reclaim the memory that
/// the <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/> was occupying.</remarks>
public void Dispose()
{
if (this._isDisposed)
{
return;
}
if (this._busDevice != null)
{
this._busDevice.Dispose();
this._busDevice = null;
}
if (this._pinCache != null)
{
this._pinCache.Clear();
this._pinCache = null;
}
this._isDisposed = true;
GC.SuppressFinalize(this);
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotentiometerBase"/>
/// class with the I2C device connection, pin A0,A1, and A2 states,
/// the potentiometer (channel) provided by the device, how to do
/// non-volatile I/O and the initial value for devices which are not
/// capable of non-volatile wipers.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="pinA0">
/// Whether the device's address pin A0 is high (true) or low (false).
/// </param>
/// <param name="pinA1">
/// Whether the device's address pin A1 is high (true) or low (false).
/// </param>
/// <param name="pinA2">
/// Whether the device's address pin A2 is high (true) or low (false).
/// </param>
/// <param name="channel">
/// Which of the potentiometers provided by the device to control.
/// </param>
/// <param name="nonVolatileMode">
/// The way non-volatile reads or writes are done.
/// </param>
/// <param name="initialNonVolWiperValue">
/// The value for devices which are not capable of non-volatile wipers.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null. - or - <paramref name="channel"/>
/// cannot be null.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="channel"/> is not supported by this device.
/// </exception>
/// <exception cref="System.IO.IOException">
/// Unable to open the I2C bus.
/// </exception>
protected MicrochipPotentiometerBase(II2CBus device, Boolean pinA0, Boolean pinA1, Boolean pinA2,
MicrochipPotChannel channel, MicrochipPotNonVolatileMode nonVolatileMode, Int32 initialNonVolWiperValue)
: base()
{
if (device == null)
{
throw new ArgumentNullException("device");
}
if (!this.IsChannelSupported(channel))
{
throw new ArgumentException("Specified channel not supported by device.", "channel");
}
this._channel = channel;
this._nonVolMode = nonVolatileMode;
Int32 deviceAddr = BuildI2CAddress(pinA0, pinA1, pinA2);
this._controller = new MicrochipPotDeviceController(device, deviceAddr);
this.WiperActionEvent += this.MicrochipPotentiometerBase_WiperActionEvent;
this.Initialize(initialNonVolWiperValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/>
/// class with the I2C device that represents the physical connection
/// to the gyro.
/// </summary>
/// <param name="device">
/// The I2C device that represents the physical connection to the gyro.
/// If null, then it is assumed that the host is a revision 2 or higher
/// board and a default <see cref="CyrusBuilt.MonoPi.IO.I2C.I2CBus"/>
/// using the rev 2 I2C bus path will be used instead.
/// </param>
/// <exception cref="IOException">
/// Unable to open the specified I2C bus device.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The specified device instance has been disposed.
/// </exception>
public ADXL345(II2CBus device)
: base()
{
if (device == null)
{
device = new I2CBus(BoardRevision.Rev2);
}
this._device = device;
if (!this._device.IsOpen)
{
this._device.Open();
}
this._x = new AxisGyroscope(this, 20f);
this._y = new AxisGyroscope(this, 20f);
this._z = new AxisGyroscope(this, 20f);
this._aX = (AxisGyroscope)this._x;
this._aY = (AxisGyroscope)this._y;
this._aZ = (AxisGyroscope)this._z;
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MCP4552"/>
/// class with the I2C device that is the connection to MCP4552,
/// whether the address pin A0 is high or not, Whether the device's
/// address pin A1 is high, and the initial value of the wiper.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="pinA0">
/// Whether the device's address pin A0 is high (true) or low (false).
/// </param>
/// <param name="pinA1">
/// Whether the device's address pin A1 is high (true) or low (false).
/// </param>
/// <param name="initialValue">
/// The initial value to set.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null.
/// </exception>
/// <exception cref="System.IO.IOException">
/// Unable to open the I2C bus.
/// </exception>
public MCP4552(II2CBus device, Boolean pinA0, Boolean pinA1, Int32 initialValue)
: base(device, pinA0, pinA1, PIN_NOT_AVAILABLE, MicrochipPotChannel.A,
MicrochipPotNonVolatileMode.VolatileOnly, initialValue) {
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MCP4631"/>
/// class with the I2C device connection, pin A0, A1, and A2 states,
/// the potentiometer (channel) provided by the device, and the
/// initial value for devices which are not capable of non-volatile wipers.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="pinA0">
/// Whether the device's address pin A0 is high (true) or low (false).
/// </param>
/// <param name="pinA1">
/// Whether the device's address pin A1 is high (true) or low (false).
/// </param>
/// <param name="pinA2">
/// Whether the device's address pin A2 is high (true) or low (false).
/// </param>
/// <param name="channel">
/// Which of the potentiometers provided by the device to control.
/// </param>
/// <param name="initialValue">
/// The value for devices which are not capable of non-volatile wipers.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null. - or - <paramref name="channel"/>
/// cannot be null.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="channel"/> is not supported by this device.
/// </exception>
/// <exception cref="System.IO.IOException">
/// Unable to open the I2C bus.
/// </exception>
public MCP4631(II2CBus device, Boolean pinA0, Boolean pinA1, Boolean pinA2,
MicrochipPotChannel channel, Int32 initialValue)
: base(device, pinA0, pinA1, pinA2, channel, MicrochipPotNonVolatileMode.VolatileOnly, initialValue) {
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/>
/// class with the I2C bus device, bus address of PCA9685 device,
/// target frequency, and frequency correction factor.
/// </summary>
/// <param name="bus">
/// The I2C bus device used to communicate with the PCA9685 chip.
/// </param>
/// <param name="address">
/// The address of the PCA9685 on the I2C bus.
/// </param>
/// <param name="targetFreq">
/// The target PWM frequency to set.
/// </param>
/// <param name="freqCorrectionFactor">
/// The PWM frequency correction factor.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="bus"/> cannot be null.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="targetFreq"/> must be between 40Hz and 1000Hz.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The specified I2C bus instance has been disposed and can no longer be used.
/// </exception>
/// <exception cref="IOException">
/// An I/O error occurred. The specified address is inacessible or the
/// I2C transaction failed.
/// </exception>
public PCA9685GpioProvider(II2CBus bus, Int32 address, Decimal targetFreq, Decimal freqCorrectionFactor) {
if (bus == null) {
throw new ArgumentNullException("bus");
}
this._pinCache = new List<IPCA9685Pin>();
this._busAddr = address;
this._busDevice = bus;
if (!this._busDevice.IsOpen) {
this._busDevice.Open();
}
this._busDevice.WriteBytes(this._busAddr, new Byte[] { PCA9685_MODE1, (Byte)0x00 });
this.SetFrequency(targetFreq, freqCorrectionFactor);
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/>
/// class with the I2C bus device, bus address of PCA9685 device,
/// and target frequency.
/// </summary>
/// <param name="bus">
/// The I2C bus device used to communicate with the PCA9685 chip.
/// </param>
/// <param name="address">
/// The address of the PCA9685 on the I2C bus.
/// </param>
/// <param name="targetFreq">
/// The target PWM frequency to set.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="targetFreq"/> must be between 40Hz and 1000Hz.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The specified I2C bus instance has been disposed and can no longer be used.
/// </exception>
/// <exception cref="IOException">
/// An I/O error occurred. The specified address is inacessible or the
/// I2C transaction failed.
/// </exception>
public PCA9685GpioProvider(II2CBus bus, Int32 address, Decimal targetFreq)
: this(bus, address, targetFreq, Decimal.One) {
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/>. The
/// <see cref="Dispose"/> method leaves the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/> in an unusable
/// state. After calling <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/> so the garbage
/// collector can reclaim the memory that the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotDeviceController"/> was occupying.</remarks>
public void Dispose() {
if (this._isDisposed) {
return;
}
if (this._device != null) {
this._device.Dispose();
this._device = null;
}
this._isDisposed = true;
GC.SuppressFinalize(this);
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/>. The <see cref="Dispose"/> method leaves the
/// <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/> in an unusable state. After calling
/// <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/> so the garbage collector can reclaim the memory that
/// the <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/> was occupying.</remarks>
public void Dispose() {
if (this._isDisposed) {
return;
}
if (this._busDevice != null) {
this._busDevice.Dispose();
this._busDevice = null;
}
if (this._pinCache != null) {
this._pinCache.Clear();
this._pinCache = null;
}
this._isDisposed = true;
GC.SuppressFinalize(this);
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/>. The <see cref="Dispose"/> method
/// leaves the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/> in an unusable state. After
/// calling <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/> so the garbage collector can reclaim
/// the memory that the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/> was occupying.</remarks>
public override void Dispose() {
if (base.IsDisposed) {
return;
}
if (this._device != null) {
this._device.Dispose();
this._device = null;
}
if (this._aX != null) {
this._aX.Dispose();
this._aX = null;
}
if (this._aY != null) {
this._aY.Dispose();
this._aY = null;
}
if (this._aZ != null) {
this._aZ.Dispose();
this._aZ = null;
}
if (this._x != null) {
this._x.Dispose();
this._x = null;
}
if (this._y != null) {
this._y.Dispose();
this._y = null;
}
if (this._z != null) {
this._z.Dispose();
this._z = null;
}
base.Dispose();
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/>
/// class with the I2C bus device that is the connection to the PCF8574,
/// and the bus address of the device.
/// </summary>
/// <param name="device">
/// The I2C bus device that is the connection to the PCF8574.
/// </param>
/// <param name="address">
/// The bus address of the device.
/// </param>
public PCF8574GpioProvider(II2CBus device, Int32 address) {
if (device == null) {
throw new ArgumentNullException("device");
}
this._device = device;
if (!this._device.IsOpen) {
this._device.Open();
}
this._busAddress = address;
this._pinCache = new List<IPCF8574Pin>();
this._currentStates = new BitSet(MAX_IO_PINS);
foreach (IPCF8574Pin pin in PCF8574Pin.ALL) {
this._pinCache.Add(pin);
this._pinCache[this._pinCache.IndexOf(pin)].SetState(PinState.High);
this._currentStates.Set(pin.Address, true);
}
}
public Mpu6050Api(II2CBus bus, byte chipAddress = 0x68)
{
_i2CDeviceSocket = new I2CDeviceSocket(bus, chipAddress);
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.Honeywell.HMC5883L"/>
/// class with the I2C device that represents the physical connection
/// to the gyro and the bus address of the device.
/// </summary>
/// <param name="device">
/// The I2C device that represents the physical connection to the gyro.
/// If null, then it is assumed that the host is a revision 2 or higher
/// board and a default <see cref="CyrusBuilt.MonoPi.IO.I2C.I2CBus"/>
/// using the rev 2 I2C bus path will be used instead.
/// </param>
/// <param name="address">
/// The bus address of the device.
/// </param>
/// <exception cref="IOException">
/// Unable to open the specified I2C bus device.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The specified device instance has been disposed.
/// </exception>
public HMC5883L(II2CBus device, Int32 address)
: this(device) {
this._address = address;
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.Components.Gyroscope.AnalogDevices.ADXL345"/>
/// class with the I2C device that represents the physical connection
/// to the gyro and the bus address of the device.
/// </summary>
/// <param name="device">
/// The I2C device that represents the physical connection to the gyro.
/// If null, then it is assumed that the host is a revision 2 or higher
/// board and a default <see cref="CyrusBuilt.MonoPi.IO.I2C.I2CBus"/>
/// using the rev 2 I2C bus path will be used instead.
/// </param>
/// <param name="busAddress">
/// The bus address of the device.
/// </param>
/// <exception cref="IOException">
/// Unable to open the specified I2C bus device.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The specified device instance has been disposed.
/// </exception>
public ADXL345(II2CBus device, Int32 busAddress)
: this(device) {
this._address = busAddress;
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
/// <remarks>Call <see cref="Dispose"/> when you are finished using the
/// <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/>. The <see cref="Dispose"/> method leaves the
/// <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/> in an unusable state. After calling
/// <see cref="Dispose"/>, you must release all references to the
/// <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/> so the garbage collector can reclaim the memory that
/// the <see cref="CyrusBuilt.MonoPi.IO.PCF.PCF8574GpioProvider"/> was occupying.</remarks>
public void Dispose() {
if (this._isDisposed) {
return;
}
// Try to abort gracefully first.
lock (_syncLock) {
this._pollAbort = true;
}
Thread.Sleep(100);
if ((this._pollThread != null) && (this._pollThread.IsAlive)) {
try {
// Graceful abort did not complete in time. Force terminate.
this._pollThread.Abort();
}
catch (ThreadAbortException) {
Thread.ResetAbort();
}
finally {
this._pollThread = null;
}
}
// Cleanup everything else.
if (this._device != null) {
this._device.Dispose();
this._device = null;
}
if (this._pinCache != null) {
this._pinCache.Clear();
this._pinCache = null;
}
if (this._currentStates != null) {
this._currentStates.Clear();
this._currentStates = null;
}
this._isDisposed = true;
GC.SuppressFinalize(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MCP4541"/>
/// class with the I2C device that is the connection to MCP4541,
/// whether the address pin A0 is high or not, and the way to
/// handle non-volatile I/O.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="pinA0">
/// Whether the device's address pin A0 is high (true) or low (false).
/// </param>
/// <param name="nonVolatileMode">
/// The way non-volatile reads or writes are done.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null.
/// </exception>
/// <exception cref="System.IO.IOException">
/// Unable to open the I2C bus.
/// </exception>
public MCP4541(II2CBus device, Boolean pinA0, MicrochipPotNonVolatileMode nonVolatileMode)
: base(device, pinA0, PIN_NOT_AVAILABLE, PIN_NOT_AVAILABLE,
MicrochipPotChannel.A, nonVolatileMode, INITIALVALUE_LOADED_FROM_EEPROM) {
}
public I2CDeviceSocket(II2CBus bus, byte chipAddress)
{
_bus = bus;
_chipAddress = chipAddress;
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MicrochipPotentiometerBase"/>
/// class with the I2C device connection, pin A0,A1, and A2 states,
/// the potentiometer (channel) provided by the device, how to do
/// non-volatile I/O and the initial value for devices which are not
/// capable of non-volatile wipers.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="pinA0">
/// Whether the device's address pin A0 is high (true) or low (false).
/// </param>
/// <param name="pinA1">
/// Whether the device's address pin A1 is high (true) or low (false).
/// </param>
/// <param name="pinA2">
/// Whether the device's address pin A2 is high (true) or low (false).
/// </param>
/// <param name="channel">
/// Which of the potentiometers provided by the device to control.
/// </param>
/// <param name="nonVolatileMode">
/// The way non-volatile reads or writes are done.
/// </param>
/// <param name="initialNonVolWiperValue">
/// The value for devices which are not capable of non-volatile wipers.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null. - or - <paramref name="channel"/>
/// cannot be null.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="channel"/> is not supported by this device.
/// </exception>
/// <exception cref="System.IO.IOException">
/// Unable to open the I2C bus.
/// </exception>
protected MicrochipPotentiometerBase(II2CBus device, Boolean pinA0, Boolean pinA1, Boolean pinA2,
MicrochipPotChannel channel, MicrochipPotNonVolatileMode nonVolatileMode, Int32 initialNonVolWiperValue)
: base() {
if (device == null) {
throw new ArgumentNullException("device");
}
if (!this.IsChannelSupported(channel)) {
throw new ArgumentException("Specified channel not supported by device.", "channel");
}
this._channel = channel;
this._nonVolMode = nonVolatileMode;
Int32 deviceAddr = BuildI2CAddress(pinA0, pinA1, pinA2);
this._controller = new MicrochipPotDeviceController(device, deviceAddr);
this.WiperActionEvent += this.MicrochipPotentiometerBase_WiperActionEvent;
this.Initialize(initialNonVolWiperValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="CyrusBuilt.MonoPi.IO.PCA.PCA9685GpioProvider"/>
/// class with the I2C bus device and bus address of PCA9685 device.
/// This overload uses the default target frequency value.
/// </summary>
/// <param name="bus">
/// The I2C bus device used to communicate with the PCA9685 chip.
/// </param>
/// <param name="address">
/// The address of the PCA9685 on the I2C bus.
/// </param>
/// <exception cref="ObjectDisposedException">
/// The specified I2C bus instance has been disposed and can no longer be used.
/// </exception>
/// <exception cref="IOException">
/// An I/O error occurred. The specified address is inacessible or the
/// I2C transaction failed.
/// </exception>
public PCA9685GpioProvider(II2CBus bus, Int32 address)
: this(bus, address, DEFAULT_FREQUENCY) {
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="CyrusBuilt.MonoPi.Components.Potentiometers.Microchip.MCP4661"/>
/// class with the I2C device connection, pin A0, A1, and A2 states,
/// the potentiometer (channel) provided by the device, and how to
/// do non-volatile I/O.
/// </summary>
/// <param name="device">
/// The I2C bus device this instance is connected to.
/// </param>
/// <param name="pinA0">
/// Whether the device's address pin A0 is high (true) or low (false).
/// </param>
/// <param name="pinA1">
/// Whether the device's address pin A1 is high (true) or low (false).
/// </param>
/// <param name="pinA2">
/// Whether the device's address pin A2 is high (true) or low (false).
/// </param>
/// <param name="channel">
/// Which of the potentiometers provided by the device to control.
/// </param>
/// <param name="nonVolatileMode">
/// The way non-volatile reads or writes are done.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/> cannot be null. - or - <paramref name="channel"/>
/// cannot be null.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="channel"/> is not supported by this device.
/// </exception>
/// <exception cref="System.IO.IOException">
/// Unable to open the I2C bus.
/// </exception>
public MCP4661(II2CBus device, Boolean pinA0, Boolean pinA1, Boolean pinA2,
MicrochipPotChannel channel, MicrochipPotNonVolatileMode nonVolatileMode)
: base(device, pinA0, pinA1, pinA2, channel, nonVolatileMode, INITIALVALUE_LOADED_FROM_EEPROM) {
}