public IOBus()
{
// Initialize the map. Entries are null by default, indicating
// no device at the specified address.
_deviceMap = new IIODevice[256];
_registeredDevices = new List <IIODevice>();
}
/// <summary>
/// Create a new SerialTextFile and attach the instance to the specfied serial port.
/// </summary>
/// <param name="port">Serial port name.</param>
/// <param name="baudRate">Baud rate.</param>
/// <param name="parity">Parity.</param>
/// <param name="dataBits">Data bits.</param>
/// <param name="stopBits">Stop bits.</param>
/// <param name="endOfLine">Text indicating the end of a line of text.</param>
public SerialTextFile(IIODevice device, SerialPortName port, int baudRate, Parity parity, int dataBits, StopBits stopBits,
string endOfLine)
{
serialPort = device.CreateSerialPort(port, baudRate, dataBits, parity, stopBits);
LINE_END = endOfLine;
serialPort.DataReceived += SerialPortDataReceived;
}
public Vc0706(IIODevice device, SerialPortName portName, int baud)
{
serialPort = device.CreateSerialPort(portName, baud);
/*serialPort = device.CreateSerialMessagePort(
* portName: portName,
* suffixDelimiter: Encoding.ASCII.GetBytes("\r\n"),
* baudRate: baud,
* preserveDelimiter: true,
* readBufferSize: 512);*/
serialPort.Open();
switch (baud)
{
case 9600:
default:
SetBaud9600();
break;
case 19200:
SetBaud19200();
break;
case 38400:
SetBaud38400();
break;
case 57600:
SetBaud57600();
break;
}
}
/// <summary>
/// Add device to the I/O registry
/// </summary>
/// <param name="port">Assigned port for the IODevice</param>
/// <param name="device">IODevice instance</param>
/// <returns>True if port was assigned successfully, false if por was previously assigned</returns>
public bool AddIODevice(ushort port, IIODevice device)
{
// validate port validity
IsValidPort(port, device);
// is used
if (IsUsedPort(port, device))
{
throw new Exception($"IO Device requires {device.IOPortLength} ports. The selected port does not meet the device requirements.");
}
// verify if port was previously assiged to another I/O device
if (_portsAndDevices.ContainsKey(port))
{
return(false);
}
// assign the device a DeviceId
_devicesAndIds.Add(_deviceId, device);
// reserve all the required ports for the I/O device, even more that one
for (short i = 0; i < device.IOPortLength; i++)
{
_portsAndDevices.Add((ushort)(port + i), _deviceId);
}
// increment DeviceId
_deviceId++;
return(true);
}
public OLED128x32Wing(II2cBus i2cBus, IIODevice device, IPin pinA, IPin pinB, IPin pinC) :
this(i2cBus,
device.CreateDigitalInputPort(pinA, InterruptMode.EdgeBoth, ResistorMode.InternalPullUp),
device.CreateDigitalInputPort(pinB, InterruptMode.EdgeBoth, ResistorMode.InternalPullUp),
device.CreateDigitalInputPort(pinC, InterruptMode.EdgeBoth, ResistorMode.InternalPullUp))
{
}
public Gc9a01(IIODevice device, ISpiBus spiBus, IPin chipSelectPin, IPin dcPin, IPin resetPin) :
base(device, spiBus, chipSelectPin, dcPin, resetPin, 240, 240, DisplayColorMode.Format16bppRgb565)
{
Initialize();
SetRotation(Rotation.Normal);
}
/// <summary>
/// Create a new ADXL337 sensor object.
/// </summary>
/// <param name="x">Analog pin connected to the X axis output from the ADXL377 sensor.</param>
/// <param name="y">Analog pin connected to the Y axis output from the ADXL377 sensor.</param>
/// <param name="z">Analog pin connected to the Z axis output from the ADXL377 sensor.</param>
/// <param name="updateInterval">Update interval for the sensor, set to 0 to put the sensor in polling mode.</param>
/// <<param name="accelerationChangeNotificationThreshold">Acceleration change threshold.</param>
public Adxl377(IIODevice device, IPin x, IPin y, IPin z, ushort updateInterval = 100,
double accelerationChangeNotificationThreshold = 0.1F)
{
if ((updateInterval != 0) && (updateInterval < MinimumPollingPeriod))
{
throw new ArgumentOutOfRangeException(nameof(updateInterval),
"Update interval should be 0 or greater than " + MinimumPollingPeriod);
}
_xPort = device.CreateAnalogInputPort(x);
_yPort = device.CreateAnalogInputPort(y);
_zPort = device.CreateAnalogInputPort(z);
//
// Now set the default calibration data.
//
XVoltsPerG = 0.00825;
YVoltsPerG = 0.00825;
ZVoltsPerG = 0.00825;
SupplyVoltage = 3.3;
if (updateInterval > 0)
{
var t = StartUpdating();
}
else
{
Update().RunSynchronously();
}
}
/// <summary>
/// Creates a SevenSegment connected to the especified IPins to a IODevice
/// </summary>
/// <param name="device"></param>
/// <param name="pinA"></param>
/// <param name="pinB"></param>
/// <param name="pinC"></param>
/// <param name="pinD"></param>
/// <param name="pinE"></param>
/// <param name="pinF"></param>
/// <param name="pinG"></param>
/// <param name="pinDecimal"></param>
/// <param name="isCommonCathode"></param>
public FourDigitSevenSegment(
IIODevice device,
IPin pinDigit1, IPin pinDigit2,
IPin pinDigit3, IPin pinDigit4,
IPin pinA, IPin pinB,
IPin pinC, IPin pinD,
IPin pinE, IPin pinF,
IPin pinG, IPin pinDecimal,
bool isCommonCathode) :
this(
device.CreateDigitalOutputPort(pinDigit1),
device.CreateDigitalOutputPort(pinDigit2),
device.CreateDigitalOutputPort(pinDigit3),
device.CreateDigitalOutputPort(pinDigit4),
device.CreateDigitalOutputPort(pinA),
device.CreateDigitalOutputPort(pinB),
device.CreateDigitalOutputPort(pinC),
device.CreateDigitalOutputPort(pinD),
device.CreateDigitalOutputPort(pinE),
device.CreateDigitalOutputPort(pinF),
device.CreateDigitalOutputPort(pinG),
device.CreateDigitalOutputPort(pinDecimal),
isCommonCathode)
{
}
/// <summary>
/// Initializes SPI connection and control pins
/// </summary>
/// <param name="chipEnablePin">
/// Number representing the chip enable pin. This pin will be set to drive output
/// </param>
/// <param name="chipSelectLine">
/// Number representing the chip select line. For RPi2, this is typically 0
/// </param>
/// <param name="interruptPin">
/// Number representing the interrupt pin. This should be a Pull-up pin, and will drive Input
/// </param>
public void Initialize(IIODevice device, ISpiBus spiBus, IPin chipEnablePin, IPin chipSelectLine, IPin interruptPin)
{
_SpiBus = spiBus;
_cePin = device.CreateDigitalOutputPort(chipEnablePin, false);
_csPin = device.CreateDigitalOutputPort(chipSelectLine, false);
_irqPin = device.CreateDigitalInputPort(interruptPin, InterruptMode.EdgeFalling, resistorMode: ResistorMode.PullUp);
_irqPin.Changed += InterruptGpioPin_ValueChanged;
// Module reset time
Task.Delay(100).GetAwaiter().GetResult();
IsInitialized = true;
// Set reasonable default values
Address = Encoding.UTF8.GetBytes("NRF1");
DataRate = DataRate.DR2Mbps;
IsDynamicPayload = true;
IsAutoAcknowledge = true;
FlushReceiveBuffer();
FlushTransferBuffer();
ClearIrqMasks();
SetRetries(5, 60);
// Setup, CRC enabled, Power Up, PRX
SetReceiveMode();
}
public Ssd1327(IIODevice device, ISpiBus spiBus, IPin chipSelectPin, IPin dcPin, IPin resetPin)
{
this.spiBus = (SpiBus)spiBus;
spiBuffer = new byte[Width * Height / 2];
spiReceive = new byte[Width * Height / 2];
dataCommandPort = device.CreateDigitalOutputPort(dcPin, false);
if (resetPin != null)
{
resetPort = device.CreateDigitalOutputPort(resetPin, true);
}
if (chipSelectPin != null)
{
chipSelectPort = device.CreateDigitalOutputPort(chipSelectPin, false);
}
spiPeripheral = new SpiPeripheral(spiBus, chipSelectPort);
Initialize();
Thread.Sleep(300);
FillBuffer();
Show();
}
public RegisterManager(IIODevice device, ISpiBus spiBus, IPin chipSelectPin)
{
// Chip select pin configuration
ChipSelectGpioPin = device.CreateDigitalOutputPort(chipSelectPin, initialState: true);
Rfm9XLoraModem = new SpiPeripheral(spiBus, ChipSelectGpioPin);
}
/// <summary>
/// Creates an instance of the A4988 Stepper Motor Driver
/// </summary>
/// <param name="device">The IIoDevice instance that can create Digital Output Ports</param>
/// <param name="step">The Meadow pin connected to the STEP pin of the A4988</param>
/// <param name="direction">The Meadow pin connected to the DIR pin of the A4988</param>
/// <param name="enable">The (optional) Meadow pin connected to the ENABLE pin of the A4988</param>
/// <param name="ms1">The (optional) Meadow pin connected to the MS1 pin of the A4988</param>
/// <param name="ms2">The (optional) Meadow pin connected to the MS2 pin of the A4988</param>
/// <param name="ms3">The (optional) Meadow pin connected to the MS3 pin of the A4988</param>
/// <remarks>You must provide either all of the micro-step (MS) lines or none of them</remarks>
public A4988(IIODevice device, IPin step, IPin direction, IPin enable, IPin ms1, IPin ms2, IPin ms3)
{
stepPort = device.CreateDigitalOutputPort(step);
directionPort = device.CreateDigitalOutputPort(direction);
if (enable != null)
{
this.enable = device.CreateDigitalOutputPort(enable);
}
// micro-step lines (for now) are all-or-nothing
// TODO: rethink this?
if (new IPin[] { ms1, ms2, ms3 }.All(p => p != null))
{
this.ms1 = device.CreateDigitalOutputPort(ms1);
this.ms2 = device.CreateDigitalOutputPort(ms2);
this.ms3 = device.CreateDigitalOutputPort(ms3);
}
else if (new IPin[] { ms1, ms2, ms3 }.All(p => p == null))
{
// nop
}
else
{
throw new ArgumentException("All micro-step pins must be either null or valid pins");
}
StepAngle = 1.8f; // common default
RotationSpeedDivisor = 2;
}
/// <summary>
/// Gets the digital output values for the specified <see cref="DOBit"/>s. A read from the controller will only be performed if no previous
/// read was performed within the specified timeout.
/// </summary>
/// <param name="bits">The DO bits.</param>
/// <param name="minFresh">The minimum amount of time before data is considered stale and a re-read is required.</param>
/// <returns>
/// The values.
/// </returns>
public static IEnumerable <int> GetValues(this IEnumerable <DOBit> bits, TimeSpan minFresh)
{
var devGroups = bits.GroupBy(b => b.Device);
foreach (var devGroup in devGroups)
{
IIODevice dev = (IIODevice)devGroup.Key;
List <DOBit> orderedBits = devGroup.OrderBy(b => b.Channel).ToList();
bool allFresh = true;
foreach (DOBit bit in orderedBits)
{
if (DateTime.Now - bit.LastRead > minFresh)
{
allFresh = false;
break;
}
}
if (!allFresh)
{
int[] values = dev.GetDOBits(orderedBits.Select(b => b.Channel).ToArray());
DateTime readTime = DateTime.Now;
for (int i = 0; i < values.Length; i++)
{
orderedBits[i].Update(readTime, values[i]);
}
}
}
return(bits.Select(b => b.GetLast()));
}
/// <summary>
/// New instance of the AnalogWaterLevel class.
/// </summary>
/// <param name="analogPin">Analog pin the temperature sensor is connected to.</param>
/// <param name="sensorType">Type of sensor attached to the analog port.</param>
/// <param name="calibration">Calibration for the analog temperature sensor. Only used if sensorType is set to Custom.</param>
public AnalogWaterLevel(
IIODevice device,
IPin analogPin,
Calibration calibration = null
) : this(device.CreateAnalogInputPort(analogPin), calibration)
{
}
public Ili9488(IIODevice device, ISpiBus spiBus, IPin chipSelectPin, IPin dcPin, IPin resetPin,
uint width = 320, uint height = 480, DisplayColorMode displayColorMode = DisplayColorMode.Format12bppRgb444)
: base(device, spiBus, chipSelectPin, dcPin, resetPin, width, height, displayColorMode)
{
Initialize();
SetRotation(Rotation.Normal);
}
/// <summary>
/// Creates a Capacitive soil moisture sensor object with the specified analog pin and a IO device.
/// </summary>
/// <param name="device"></param>
/// <param name="analogPin"></param>
public Capacitive(
IIODevice device,
IPin analogPin,
float minimumVoltageCalibration = 0f,
float maximumVoltageCalibration = 3.3f) :
this(device.CreateAnalogInputPort(analogPin), minimumVoltageCalibration, maximumVoltageCalibration)
{
}
/// <summary>
/// Create a new MAG3110 object using the default parameters for the component.
/// </summary>
/// <param name="device"></param>
/// <param name="interruptPin">Digital pin connected to the alarm interrupt pin on the RTC.</param>
/// <param name="i2cBus">The I2C Bus the peripheral is connected to</param>
/// <param name="address">I2C Bus address of the peripheral</param>
public Ds3231(
IIODevice device,
II2cBus i2cBus,
IPin interruptPin = null,
byte address = 0x68)
: base(new I2cPeripheral(i2cBus, address), device, interruptPin)
{
}
/// <summary>
/// New instance of the AnalogTemperatureSensor class.
/// </summary>
/// <param name="analogPin">Analog pin the temperature sensor is connected to.</param>
/// <param name="sensorType">Type of sensor attached to the analog port.</param>
/// <param name="calibration">Calibration for the analog temperature sensor.</param>
public AnalogTemperature(
IIODevice device,
IPin analogPin,
KnownSensorType sensorType,
Calibration calibration = null
) : this(device.CreateAnalogInputPort(analogPin), sensorType, calibration)
{
}
public ST7735(IIODevice device, ISpiBus spiBus, IPin chipSelectPin, IPin dcPin, IPin resetPin,
uint width, uint height,
DisplayType displayType = DisplayType.ST7735R) : base(device, spiBus, chipSelectPin, dcPin, resetPin, width, height)
{
this.displayType = displayType;
Initialize();
}
/// <summary>
/// Create a new ADXL362 object using the specified SPI module.
/// </summary>
/// <param name="spiBus">Spi Bus object</param>
/// <param name="chipSelect">Chip select pin.</param>
public Adxl362(IIODevice device, ISpiBus spiBus, IPin chipSelect)
{
//
// ADXL362 works in SPI mode 0 (CPOL = 0, CPHA = 0).
//
_adxl362 = new SpiPeripheral(spiBus, device.CreateDigitalOutputPort(chipSelect));
Reset();
Start();
}
/// <summary>
/// Creates an instance of the NAU7802 Driver class
/// </summary>
/// <param name="bus"></param>
public Hx711(IIODevice device, IPin sck, IPin dout)
{
this.sck = device.CreateDigitalOutputPort(sck);
this.dout = device.CreateDigitalInputPort(dout);
createdPorts = true; // we need to dispose what we create
CalculateRegisterValues(sck, dout);
Start();
}
/// <summary>
/// Instantiates a new RotaryEncoder on the specified pins that has an integrated button.
/// </summary>
/// <param name="aPhasePin"></param>
/// <param name="bPhasePin"></param>
/// <param name="buttonPin"></param>
/// <param name="resistor"></param>
/// <param name="debounceDuration"></param>
public RotaryEncoderWithButton(IIODevice device, IPin aPhasePin, IPin bPhasePin, IPin buttonPin, ResistorMode buttonResistorMode = ResistorMode.InternalPullDown)
: base(device, aPhasePin, bPhasePin)
{
_button = new PushButton(device, buttonPin, buttonResistorMode);
_button.Clicked += ButtonClicked;
_button.PressEnded += ButtonPressEnded;
_button.PressStarted += ButtonPressStarted;
}
/// <summary>
/// Creates a FC28 soil moisture sensor object with the especified analog pin, digital pin and IO device.
/// </summary>
/// <param name="analogPort"></param>
/// <param name="digitalPort"></param>
public Fc28(
IIODevice device,
IPin analogPin,
IPin digitalPin,
float minimumVoltageCalibration = 0f,
float maximumVoltageCalibration = 3.3f) :
this(device.CreateAnalogInputPort(analogPin), device.CreateDigitalOutputPort(digitalPin), minimumVoltageCalibration, maximumVoltageCalibration)
{
}
public St7735(IIODevice device, ISpiBus spiBus, IPin chipSelectPin, IPin dcPin, IPin resetPin,
uint width, uint height,
DisplayType displayType = DisplayType.ST7735R, DisplayColorMode displayColorMode = DisplayColorMode.Format12bppRgb444)
: base(device, spiBus, chipSelectPin, dcPin, resetPin, width, height, displayColorMode)
{
this.displayType = displayType;
Initialize();
}
/// <summary>
/// Instantiates a new RotaryEncoder on the specified pins that has an integrated button.
/// </summary>
/// <param name="aPhasePin"></param>
/// <param name="bPhasePin"></param>
/// <param name="buttonPin"></param>
/// <param name="buttonCircuitTerminationType"></param>
/// <param name="debounceDuration"></param>
public RotaryEncoderWithButton(IIODevice device, IPin aPhasePin, IPin bPhasePin, IPin buttonPin, int debounceDuration = 20)
: base(device, aPhasePin, bPhasePin)
{
_button = new PushButton(device, buttonPin, debounceDuration);
_button.Clicked += ButtonClicked;
_button.PressEnded += ButtonPressEnded;
_button.PressStarted += ButtonPressStarted;
}
public IDigitalInputPort CreateInputPort(IIODevice device, IPin pin, bool enablePullUp = false)
{
if (pin != null)
{
return(device.CreateDigitalInputPort(pin, InterruptMode.None, ResistorMode.PullUp));
}
throw new Exception("Pin is out of range");
}
/// <summary>
/// Create a new SSD1306 object using the default parameters for
/// </summary>
/// <remarks>
/// Note that by default, any pixels out of bounds will throw and exception.
/// This can be changed by setting the <seealso cref="IgnoreOutOfBoundsPixels" />
/// property to true.
/// </remarks>
///
protected SSD1306(IIODevice device, ISpiBus spiBus, IPin chipSelectPin, IPin dcPin, IPin resetPin)
{
dataCommandPort = device.CreateDigitalOutputPort(dcPin, false);
resetPort = device.CreateDigitalOutputPort(resetPin, true);
chipSelectPort = device.CreateDigitalOutputPort(chipSelectPin, false);
_spiPeripheral = new SpiPeripheral(spiBus, chipSelectPort);
connectionType = ConnectionType.SPI;
}
public ArducamMini(IIODevice device, ISpiBus spiBus, IPin chipSelectPin, II2cBus i2cBus, byte address = 0x30)
{
i2cDevice = new I2cPeripheral(i2cBus, address);
chipSelectPort = device.CreateDigitalOutputPort(chipSelectPin);
spiDevice = new SpiPeripheral(spiBus, chipSelectPort);
Initialize();
}
/// <summary>
/// This will explain the pins for 74HC595
/// </summary>
/// <param name="device">Board Device.</param>
/// <param name="data">Pin 14 on the 74. That will indicate what value of bit we want to push to the shift register. Also known as SER</param>
/// <param name="latch">Pin 12 on the 74. This will push to Qa - Qh when set to HIGH all of the values we included thus far. Also known as RCLK.</param>
/// <param name="clock">Pin 11 on the 74. Thi swill push one bit from <see cref="data"/> to the shift register temp storage when set to HIGH.</param>
/// <param name="clear">Pin 10 on the 74. Inverse pin. Normally should be set to LOW. When clearing need to be set to HIGH. use <see cref="Clear"/> function </param>
/// <param name="outputEnable">Pin 13 on the 74. Invese pin just like <see cref="clear"/> pin. Normally want to be set to LOW. When High output pins are disabled. <see cref="Disable"/> and <see cref="Enable"/> functions.</param>
public Shift74HC595(IIODevice device, IPin data, IPin latch, IPin clock, IPin clear = null, IPin outputEnable = null) :
this(
device.CreateDigitalOutputPort(data),
device.CreateDigitalOutputPort(latch),
device.CreateDigitalOutputPort(clock),
clear == null ? null : device.CreateDigitalOutputPort(clear, true),
outputEnable == null ? null : device.CreateDigitalOutputPort(outputEnable)
)
{
}
public static void Main(string[] args)
{
IIOCmdSrv srv = new IIOCmdSrv();
// Connect to IIO command server
if (srv.Connect("10.44.2.243") == false)
{
Console.WriteLine("Connect Failed");
return;
}
/* Show IIO Server Version Infromation */
Console.WriteLine("Server Version: " + srv.Version());
/* List Available IIO Devices on the Server */
IIODevice [] iio_devices = srv.ListDevices();
foreach (var device in iio_devices)
Console.WriteLine("iio_devices are:" + device);
/* A single server may handle multiple devices/drivers */
IIODevice ad9467 = new IIODevice(srv, "cf-ad9643-core-lpc");
/* Read the name attribute */
Console.WriteLine("Device Name: " + ad9467.Read("name"));
/* Read the in_voltage_scale_available attribute */
Console.WriteLine("in_voltage_scale_available: " + ad9467.Read("in_voltage_scale_available"));
/* Set test modes for AD9467 Channel 0*/
ad9467.Write("in_voltage0_test_mode", "checkerboard");
/* Get For Samples */
byte[] buf = ad9467.Sample(10);
for (var i = 0; i < buf.Length; i+=2)
Console.Write(string.Format("0x{0:X}\n",BitConverter.ToInt16(buf, i)));
/* Turn test modes off */
ad9467.Write("in_voltage0_test_mode", "off");
/* Get 10 Samples */
buf = ad9467.Sample(10);
for (var i = 0; i < buf.Length; i+=2)
Console.Write(string.Format("0x{0:X}\n",BitConverter.ToInt16(buf, i)));
/* Test Direct Register Access methods */
Console.WriteLine("Device ID (dec): " + ad9467.RegRead(0x1));
/* List all device attributes */
string [] attributes = ad9467.ListAttributes();
foreach (string s in attributes)
Console.WriteLine("Attributes are: " + s);
/* Disconnect Server */
srv.Disconnect();
}
public void AddDevice(IIODevice device)
{
if (_devices.Contains(device))
{
throw new InvalidOperationException("This component has already been added to the bus.");
}
_devices.Add(device);
UpdateDispatchTable(device);
}
public IIODevice[] ListDevices()
{
IIODevice[] devices = null;
string[] strDevices;
string tmp;
int i = 0;
tmp = Read("show\n", true);
if (tmp != null)
{
strDevices = tmp.Trim().Split(' ');
devices = new IIODevice[strDevices.Length];
foreach (var d in strDevices)
{
devices[i] = new IIODevice(this, d);
i++;
}
}
return devices;
}
/// <summary>
/// Constructs the object using the specifyed custom Data storage and I/O device
/// objects.
/// </summary>
/// <param name="data">The Data object that stores memory and registers</param>
/// <param name="ioDevice">The I/O device to be used by the I/O instructions</param>
public VirtualMachine(Data data, IIODevice ioDevice)
{
Data = data;
Processor = new Processor(Data, ioDevice);
Disassembler = new Disassembler(Data);
}
/// <summary>
/// Creates a new Processor object.
/// </summary>
/// <param name="data">A Data object that represents the machine state.</param>
/// <param name="ioDevice">An IIODevice object that represents the IODevice.</param>
public Processor(Data data, IIODevice ioDevice)
{
Data = data;
IODevice = ioDevice;
}
