/// <summary> /// Writes a byte to the SPI device. /// </summary> /// <param name="value">The byte to be written to the SPI device.</param> public override void WriteByte(byte value) { _winDevice.Write(new[] { value }); }
// Wrapper to send SPI commands two bytes at a time (register -> data) private void sendCommand(SpiDevice dev, byte register, byte data) { dev.Write(new byte[] { register, data }); }
private async Task StartScenarioAsync() { String spiDeviceSelector = SpiDevice.GetDeviceSelector(); IReadOnlyList<DeviceInformation> devices = await DeviceInformation.FindAllAsync(spiDeviceSelector); // 0 = Chip select line to use. var ADXL345_Settings = new SpiConnectionSettings(0); // 5MHz is the rated speed of the ADXL345 accelerometer. ADXL345_Settings.ClockFrequency = 5000000; // The accelerometer expects an idle-high clock polarity. // We use Mode3 to set the clock polarity and phase to: CPOL = 1, CPHA = 1. ADXL345_Settings.Mode = SpiMode.Mode3; // If this next line crashes with an ArgumentOutOfRangeException, // then the problem is that no SPI devices were found. // // If the next line crashes with Access Denied, then the problem is // that access to the SPI device (ADXL345) is denied. // // The call to FromIdAsync will also crash if the settings are invalid. // // FromIdAsync produces null if there is a sharing violation on the device. // This will result in a NullReferenceException a few lines later. adxl345Sensor = await SpiDevice.FromIdAsync(devices[0].Id, ADXL345_Settings); // // Initialize the accelerometer: // // For this device, we create 2-byte write buffers: // The first byte is the register address we want to write to. // The second byte is the contents that we want to write to the register. // // 0x31 is address of data format register, 0x01 sets range to +- 4Gs. byte[] WriteBuf_DataFormat = new byte[] { 0x31, 0x01 }; // 0x2D is address of power control register, 0x08 puts the accelerometer into measurement mode. byte[] WriteBuf_PowerControl = new byte[] { 0x2D, 0x08 }; // Write the register settings. // // If this next line crashes with a NullReferenceException, then // there was a sharing violation on the device. // (See comment earlier in this function.) // // If this next line crashes for some other reason, then there was // an error communicating with the device. adxl345Sensor.Write(WriteBuf_DataFormat); adxl345Sensor.Write(WriteBuf_PowerControl); // Start the polling timer. timer = new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(100) }; timer.Tick += Timer_Tick; timer.Start(); }
/// <summary> /// Writes a byte to the SPI device. /// </summary> /// <param name="data">The byte to be written to the SPI device.</param> public override void WriteByte(byte data) { _winDevice.Write(new[] { data }); }
/* Initialization for SPI accelerometer */ private async void InitSPIAccel() { try { var settings = new SpiConnectionSettings(SPI_CHIP_SELECT_LINE); settings.ClockFrequency = 5000000; /* 5MHz is the rated speed of the ADXL345 accelerometer */ settings.Mode = SpiMode.Mode3; /* The accelerometer expects an idle-high clock polarity, we use Mode3 * to set the clock polarity and phase to: CPOL = 1, CPHA = 1 */ string aqs = SpiDevice.GetDeviceSelector(); /* Get a selector string that will return all SPI controllers on the system */ var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the SPI bus controller devices with our selector string */ SPIAccel = await SpiDevice.FromIdAsync(dis[0].Id, settings); /* Create an SpiDevice with our bus controller and SPI settings */ if (SPIAccel == null) { Text_Status.Text = string.Format( "SPI Controller {0} is currently in use by " + "another application. Please ensure that no other applications are using SPI.", dis[0].Id); return; } } catch (Exception ex) { Text_Status.Text = "SPI Initialization failed. Exception: " + ex.Message; return; } /* * Initialize the accelerometer: * * For this device, we create 2-byte write buffers: * The first byte is the register address we want to write to. * The second byte is the contents that we want to write to the register. */ byte[] WriteBuf_DataFormat = new byte[] { ACCEL_REG_DATA_FORMAT, 0x01 }; /* 0x01 sets range to +- 4Gs */ byte[] WriteBuf_PowerControl = new byte[] { ACCEL_REG_POWER_CONTROL, 0x08 }; /* 0x08 puts the accelerometer into measurement mode */ /* Write the register settings */ try { SPIAccel.Write(WriteBuf_DataFormat); SPIAccel.Write(WriteBuf_PowerControl); } /* If the write fails display the error and stop running */ catch (Exception ex) { Text_Status.Text = "Failed to communicate with device: " + ex.Message; return; } /* Now that everything is initialized, create a timer so we read data every 100mS */ periodicTimer = new Timer(this.TimerCallback, null, 0, 100); }
private async Task Init() { var deviceSelector = I2cDevice.GetDeviceSelector(); var controllers = await DeviceInformation.FindAllAsync(deviceSelector); _mcp3425 = await I2cDevice.FromIdAsync(controllers[0].Id, new I2cConnectionSettings(0x68) { BusSpeed = I2cBusSpeed.FastMode }); _mcp3425.Write(new byte[] { 0x98 }); // 16bit _tsl2561 = await I2cDevice.FromIdAsync(controllers[0].Id, new I2cConnectionSettings(0x39) { BusSpeed = I2cBusSpeed.FastMode }); _tsl2561.Write(new byte[] { 0x80, 0x03 }); // power on :) // spi stuff var settings = new SpiConnectionSettings(0); settings.ClockFrequency = 10000000; settings.Mode = SpiMode.Mode0; string spiAqs = SpiDevice.GetDeviceSelector("SPI0"); var deviceInformation = await DeviceInformation.FindAllAsync(spiAqs); _spiDevice = await SpiDevice.FromIdAsync(deviceInformation[0].Id, settings); endFrame = new byte[(int)Math.Ceiling(leds / 16d)]; for (var i = 0; i < endFrame.Length; i++) { endFrame[i] = 0x0; } // start _spiDevice.Write(new byte[4]); // all off _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); _spiDevice.Write(new byte[] { 0xE0, 0x0, 0x0, 0x0 }); // end _spiDevice.Write(endFrame); }
/// <summary> /// Writes a byte to the SPI device. /// </summary> /// <param name="value">The byte to be written to the SPI device.</param> public override void WriteByte(byte value) { _winDevice.Write(new[] { _isInverted?ReverseByte(value) : value }); }
internal async Task Initialize(byte frequency, byte nodeId, byte networkId) { var settings = new SpiConnectionSettings(0); settings.ClockFrequency = 5000000; /* 5MHz is the rated speed of the ADXL345 accelerometer */ settings.Mode = SpiMode.Mode3; string aqs = SpiDevice.GetDeviceSelector(); /* Get a selector string that will return all SPI controllers on the system */ var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the SPI bus controller devices with our selector string */ _spiDevice = await SpiDevice.FromIdAsync(dis[0].Id, settings); /* Create an SpiDevice with our bus controller and SPI settings */ _spiDevice.ConnectionSettings.Mode = SpiMode.Mode0; _spiDevice.ConnectionSettings.ClockFrequency = 5000; _gpioController = GpioController.GetDefault(); _selectpin = _gpioController.OpenPin(22); _selectpin.SetDriveMode(GpioPinDriveMode.Output); byte[][] config = { new byte[] { REG_OPMODE, RF_OPMODE_SEQUENCER_ON | RF_OPMODE_LISTEN_OFF | RF_OPMODE_STANDBY }, new byte[] { REG_DATAMODUL, RF_DATAMODUL_DATAMODE_PACKET | RF_DATAMODUL_MODULATIONTYPE_FSK | RF_DATAMODUL_MODULATIONSHAPING_00 }, new byte[] { REG_BITRATEMSB, RF_BITRATEMSB_55555}, new byte[] { REG_BITRATELSB, RF_BITRATELSB_55555}, new byte[] { REG_FDEVMSB, RF_FDEVMSB_50000}, new byte[] { REG_FDEVLSB, RF_FDEVLSB_50000}, new byte[] { REG_FRFMSB, RF_FRFMSB_915 }, /* 0x08 */ new byte[] { REG_FRFMID, RF_FRFMID_915 }, /* 0x09 */ new byte[] { REG_FRFLSB, RF_FRFLSB_915 }, new byte[] { REG_RXBW, RF_RXBW_DCCFREQ_010 | RF_RXBW_MANT_16 | RF_RXBW_EXP_2 }, new byte[] { REG_DIOMAPPING1, RF_DIOMAPPING1_DIO0_01 }, new byte[] { REG_DIOMAPPING2, RF_DIOMAPPING2_CLKOUT_OFF }, new byte[]{ REG_IRQFLAGS2, RF_IRQFLAGS2_FIFOOVERRUN }, new byte[]{ REG_RSSITHRESH, 220 }, new byte[] { REG_SYNCCONFIG, RF_SYNC_ON | RF_SYNC_FIFOFILL_AUTO | RF_SYNC_SIZE_2 | RF_SYNC_TOL_0 }, new byte[]{ REG_SYNCVALUE1, 0x2D }, // attempt to make this compatible with sync1 byte of RFM12B lib /* 0x30 */ new byte[]{ REG_SYNCVALUE2, networkId }, // NETWORK ID /* 0x37 */ new byte[]{ REG_PACKETCONFIG1, RF_PACKET1_FORMAT_VARIABLE | RF_PACKET1_DCFREE_OFF | RF_PACKET1_CRC_ON | RF_PACKET1_CRCAUTOCLEAR_ON | RF_PACKET1_ADRSFILTERING_OFF }, /* 0x38 */ new byte[]{ REG_PAYLOADLENGTH, 66 }, // in variable length mode: the max frame size, not used in TX //* 0x39 */ { REG_NODEADRS, nodeID }, // turned off because we're not using address filtering /* 0x3C */ new byte[]{ REG_FIFOTHRESH, RF_FIFOTHRESH_TXSTART_FIFONOTEMPTY | RF_FIFOTHRESH_VALUE }, // TX on FIFO not empty /* 0x3D */ new byte[]{ REG_PACKETCONFIG2, RF_PACKET2_RXRESTARTDELAY_2BITS | RF_PACKET2_AUTORXRESTART_ON | RF_PACKET2_AES_OFF }, // RXRESTARTDELAY must match transmitter PA ramp-down time (bitrate dependent) //for BR-19200: /* 0x3D */ { REG_PACKETCONFIG2, RF_PACKET2_RXRESTARTDELAY_NONE | RF_PACKET2_AUTORXRESTART_ON | RF_PACKET2_AES_OFF }, // RXRESTARTDELAY must match transmitter PA ramp-down time (bitrate dependent) /* 0x6F */ new byte[]{ REG_TESTDAGC, RF_DAGC_IMPROVED_LOWBETA0 }, // run DAGC continuously in RX mode for Fading Margin Improvement, recommended default for AfcLowBetaOn=0 }; foreach (var configValue in config) { _spiDevice.Write(configValue); } SetHighPower(); }