public ExtendedSpiConfiguration( Cpu.Pin ChipSelect_Port, bool ChipSelect_ActiveState, uint ChipSelect_SetupTime, uint ChipSelect_HoldTime, bool Clock_IdleState, bool Clock_Edge, uint Clock_RateKHz, SPI.SPI_module SPI_mod, Cpu.Pin BusyPin, bool BusyPin_ActiveState, uint BitsPerTransfer ) : base(ChipSelect_Port, ChipSelect_ActiveState, ChipSelect_SetupTime, ChipSelect_HoldTime, Clock_IdleState, Clock_Edge, Clock_RateKHz, SPI_mod, BusyPin, BusyPin_ActiveState) { // Netduino's MCU can read/write 8 to 16 bits per transfer (variable-bit SPI) if (BitsPerTransfer < 8 || BitsPerTransfer > 16) { throw new ArgumentException(); } // use reflection to set the custom protected "BitsPerTransfer" property on our base class Type spiConfigurationType = typeof(SPI.Configuration); FieldInfo fieldInfo = spiConfigurationType.GetField("Custom_BitsPerTransfer", BindingFlags.NonPublic | BindingFlags.Instance); fieldInfo.SetValue(this, BitsPerTransfer); }
override public void GetSpiPins(SPI.SPI_module spi_mod, out Cpu.Pin msk, out Cpu.Pin miso, out Cpu.Pin mosi) { switch (spi_mod) { case SPI.SPI_module.SPI1: msk = Pins.GPIO_PORT_PIN_23; miso = Pins.GPIO_PORT_PIN_26; mosi = Pins.GPIO_PORT_PIN_25; break; case SPI.SPI_module.SPI2: msk = Pins.GPIO_PORT_PIN_36; miso = Pins.GPIO_PORT_PIN_11; mosi = Pins.GPIO_PORT_PIN_38; break; case SPI.SPI_module.SPI3: // These are the SSP3 pins that drive the CC2420 on the Mote2 msk = Pins.GPIO_PORT_PIN_34; miso = Pins.GPIO_PORT_PIN_41; mosi = Pins.GPIO_PORT_PIN_35; break; default: throw new NotSupportedException(); } }
/// <summary> /// Constructor /// </summary> /// <param name="csPin">CS pin for SPI interface</param> /// <param name="spiModule">SPI module</param> /// <param name="clockRateKhz">SPI clock rate (defaults to 1MHZ in other constructors)</param> public LIS302DL(Cpu.Pin csPin, SPI.SPI_module spiModule, uint clockRateKhz) { var spiConfig = new SPI.Configuration(csPin, false, 0, 0, true, true, clockRateKhz, spiModule); _spi = new SPI(spiConfig); Init(); }
public SSD1351(Cpu.Pin chipSelectPin, Cpu.Pin dcPin, Cpu.Pin resetPin, uint width, uint height, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = 9500) : base(chipSelectPin, dcPin, resetPin, width, height, spiModule, speedKHz) { Initialize(); }
public HttpWiflyImpl(HttpImplementationClient.RequestReceivedDelegate requestReceived, int localPort, DeviceType deviceType, SPI.SPI_module spiModule, Cpu.Pin chipSelect) { m_requestReceived = requestReceived; LocalPort = localPort; this.m_spiModule = spiModule; this.m_chipSelect = chipSelect; }
private byte[] _tmpPixel = new byte[12]; // Temporary buffer #endregion #region Constructor and Destructor /// <summary> /// WS2811Led constructor. /// </summary> /// <param name="striplength">Number of leds in the strip. Warning : will alocate a memory buffer 12 times this number.</param> /// <param name="SPImodule">The SPI module the strip is connected to. Only the MOSI line is used. SPI1 is used if parameter omited.</param> /// <param name="speed">The Hardwired speed of the strip. 800Khz is used if parameter is omited.</param> /// <param name="linearizationfactor">If set to a value >0 (default value=2.25) will build the lookup table using human linear perceived luminosity instead of direct PWM values.</param> public WS2811Led(int striplength, SPI.SPI_module SPImodule = SPI.SPI_module.SPI1, WS2811Speed speed = WS2811Speed.S800KHZ, double linearizationfactor = 2.25) { _StripLength = striplength; _StripLightNb = striplength * 3; //For later speed optimizations _StripBufferLen = striplength * 12; //For later speed optimizations // Initialize SPI // Set clock edge to false to remove the failing initial LED _WS2811SPIConfig = new SPI.Configuration(Cpu.Pin.GPIO_NONE, false, 0, 0, false, false, (uint)speed, SPImodule); try { _WS2811SPI = new SPI(_WS2811SPIConfig); } catch (Exception ex) { Debug.Print(ex.Message); throw; } // SPI Transmit buffer = 4 output byte per color, 3 colors per light _WS2811Buffer = new byte[4 * 3 * striplength]; // Compute fast byte to SPI lookup table. By default the linearisation of human perceived luminosity is on (Weber–Fechner law) _WS2811Table = new byte[1024]; BuildTable(linearizationfactor); //Clear all leds Clear(); Transmit(); }
/// <summary> /// Create a new SPIBus operating in the specified mode. /// </summary> /// <remarks> /// Mode CPOL CPHA /// 0 0 0 /// 1 0 1 /// 2 1 0 /// 3 1 1 /// </remarks> /// <param name="module">SPI module to configure.</param> /// <param name="chipSelect">Chip select pin.</param> /// <param name="mode">SPI Bus Mode - should be in the range 0 - 3.</param> /// <param name="speed">Speed of the SPI bus.</param> public SPIBus(SPI.SPI_module module, Cpu.Pin chipSelect, byte mode, ushort speed) { if (mode > 3) { throw new ArgumentException("SPI Mode should be in the range 0 - 3."); } byte cpha = 0; byte cpol = 0; switch (mode) { case 1: cpha = 1; break; case 2: cpol = 1; break; case 3: cpol = 1; cpha = 1; break; } Configure(module, chipSelect, cpha, cpol, speed); _spi = new SPI(_configuration); }
public ADC124S101(Cpu.Pin chipSelectPin, float supplyVoltage, uint clockRateKHz, SPI.SPI_module spiModule) { if (chipSelectPin == Cpu.Pin.GPIO_NONE) { throw new ArgumentOutOfRangeException("chipSelectPin"); } if (supplyVoltage <= 0.0f) { throw new ArgumentOutOfRangeException("supplyVoltage"); } this.chipSelectPin = chipSelectPin; this.supplyVoltage = supplyVoltage; SPI.Configuration config = new SPI.Configuration( chipSelectPin, //chip select port false, //IC is accessed when chip select is low 1, //setup time 1 ms, is actually min 10 ns 1, //hold chip select 1 ms after transfer true, //clock line is high if device is not selected false, //data is sampled at falling edge of clock clockRateKHz, //possible 10000 - 20000 KHz spiModule //select SPI bus ); this.spi = new SPI(config); }
override public void GetSpiPins(SPI.SPI_module spi_mod, out Cpu.Pin msk, out Cpu.Pin miso, out Cpu.Pin mosi) { switch (spi_mod) { case SPI.SPI_module.SPI1: msk = Pins.GPIO_PIN_B_13; miso = Pins.GPIO_PIN_B_14; mosi = Pins.GPIO_PIN_B_15; break; case SPI.SPI_module.SPI2: msk = Pins.GPIO_PIN_A_5; miso = Pins.GPIO_PIN_B_4; mosi = Pins.GPIO_PIN_A_7; break; case SPI.SPI_module.SPI3: msk = Pins.GPIO_PIN_C_10; miso = Pins.GPIO_PIN_C_11; mosi = Pins.GPIO_PIN_C_12; break; case SPI.SPI_module.SPI4: msk = Pins.GPIO_PIN_E_2; miso = Pins.GPIO_PIN_E_13; mosi = Pins.GPIO_PIN_E_6; break; default: throw new NotSupportedException(); } }
/// <summary>Initialize the CAN transceiver.</summary> /// <param name="baudrate">The selected baud rate.</param> /// <returns>True if configuration was successful.</returns> /// <remarks>Transceiver needs to be set to normal mode before starting TX/RX operations.</remarks> public bool InitCAN(SPI.SPI_module spiModule, Cpu.Pin chipSelect, byte[] baudrate) { if (baudrate.Length != 3) { throw new Exception("Baudrate settings should be 3-byte array of CNF1,2,3 registers."); } // Configure SPI var configSPI = new SPI.Configuration(chipSelect, LOW, 0, 0, HIGH, HIGH, 10000, spiModule); spi = new SPI(configSPI); // Write reset to the CAN transceiver. spi.Write(new byte[] { RESET }); //Read mode and make sure it is config Thread.Sleep(100); byte mode = (byte)(ReadRegister(CANSTAT) >> 5); if (mode != 0x04) { return(false); } else { SetCANBaud(baudrate); return(true); } }
public Adafruit1306OledDriver( Cpu.Pin dc, Cpu.Pin reset, Cpu.Pin chipSelect, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = 10000) { AutoRefreshScreen = true; var spiConfig = new SPI.Configuration( SPI_mod: spiModule, ChipSelect_Port: chipSelect, ChipSelect_ActiveState: false, ChipSelect_SetupTime: 0, ChipSelect_HoldTime: 0, Clock_IdleState: false, Clock_Edge: true, Clock_RateKHz: speedKHz ); this.Spi = new SPI(spiConfig); this.DcPin = new OutputPort(dc, false); this.ResetPin = new OutputPort(reset, false); }
public AdaFruitLPD8806(int width, int height, Cpu.Pin chipSelect, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = 10000) { Width = width; Height = height; PixelCount = Width * Height; PixelBufferEnd = (PixelCount - 1) * BytesPerPixel; FrameSize = Width * Height * BytesPerPixel; var spiConfig = new SPI.Configuration( SPI_mod: spiModule, ChipSelect_Port: chipSelect, ChipSelect_ActiveState: false, ChipSelect_SetupTime: 0, ChipSelect_HoldTime: 0, Clock_IdleState: false, Clock_Edge: true, Clock_RateKHz: speedKHz ); spi = new SPI(spiConfig); pixelBuffer = new byte[PixelCount * BytesPerPixel]; SetBackgroundColor(0, 0, 0); }
public PCD8544(Cpu.Pin chipSelectPin, Cpu.Pin dcPin, Cpu.Pin resetPin, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = 4000) { spiBuffer = new byte[Width * Height / 8]; dataCommandPort = new OutputPort(dcPin, true); resetPort = new OutputPort(resetPin, true); /* var spiConfig = new SPI.Configuration( * chipSelectPin, // chip select port * false, // IC is accessed when chip select is low * 0, // setup time 1 ms * 0, // hold chip select 1 ms after transfer * false, // clock line is low if device is not selected * true, // data is sampled at leading edge of clock * speedKHz, // clockrate is 4 kHz * spiModule // use first SPI bus * );*/ var spiConfig = new SPI.Configuration( SPI_mod: spiModule, ChipSelect_Port: chipSelectPin, ChipSelect_ActiveState: false, ChipSelect_SetupTime: 0, ChipSelect_HoldTime: 0, Clock_IdleState: false, Clock_Edge: true, Clock_RateKHz: speedKHz); spi = new SPI(spiConfig); Initialize(); }
/// <summary> /// Creates a new NeoPixelSPI with a given chip-select pin, using a given SPI module /// </summary> /// <param name="chipSelectPin">chip-select pin</param> /// <param name="spiModule">SPI module</param> public NeoPixelSPI(Cpu.Pin chipSelectPin, SPI.SPI_module spiModule) { uint speed = 6666; // 6.666 MHz SPI.Configuration spiConfig = new SPI.Configuration(chipSelectPin, false, 0, 0, false, true, speed, spiModule); this.spi = new SPI(spiConfig); }
public DisplayTFTSPIBase(Cpu.Pin chipSelectPin, Cpu.Pin dcPin, Cpu.Pin resetPin, uint width, uint height, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = 9500, bool idleClockState = false) { _width = width; _height = height; spiBuffer = new byte[_width * _height * sizeof(ushort)]; dataCommandPort = new OutputPort(dcPin, false); resetPort = new OutputPort(resetPin, true); var spiConfig = new SPI.Configuration( SPI_mod: spiModule, ChipSelect_Port: chipSelectPin, ChipSelect_ActiveState: false, ChipSelect_SetupTime: 0, ChipSelect_HoldTime: 0, Clock_IdleState: idleClockState, Clock_Edge: true, Clock_RateKHz: speedKHz); spi = new SPI(spiConfig); }
/// <summary> /// Constructor /// </summary> /// <param name="csPin">CS pin for SPI interface</param> /// <param name="spiModule">SPI module</param> public LIS302DL(Cpu.Pin csPin, SPI.SPI_module spiModule) { //The 302DL is a mode 3 device SPI.Configuration spiConfig = new SPI.Configuration(csPin, false, 0, 0, true, true, 10000, spiModule); _spi = new SPI(spiConfig); Init(); }
/// <summary> /// Creates a new instance of Lis302Dl class /// </summary> /// <param name="csPin">CS pin for SPI interface</param> /// <param name="spiModule">SPI module</param> /// <param name="Clock_Rate_KHZ">SPI clock rate (defaults to 1 MHz in other constructors)</param> /// <param name="config">LIS302DL configuration</param> public Lis302Dl(Cpu.Pin csPin, SPI.SPI_module spiModule, uint Clock_Rate_KHZ, Lis302Dl.Configuration config) { SPI.Configuration spiConfig = new SPI.Configuration(csPin, false, 0, 0, true, true, Clock_Rate_KHZ, spiModule); _spi = new SPI(spiConfig); this.config = config; Init(); }
public CanMCP2515AdapterSettings(SPI.SPI_module spi, Cpu.Pin chipSelect, Cpu.Pin interrupt, CanSpeed speed, AdapterFrequency frequency) : base(speed) { SPI = spi; ChipSelect = chipSelect; Interrupt = interrupt; Frequency = frequency; }
//--// public virtual void GetSpiPins(SPI.SPI_module spi_mod, out Cpu.Pin msk, out Cpu.Pin miso, out Cpu.Pin mosi) { msk = Cpu.Pin.GPIO_NONE; miso = Cpu.Pin.GPIO_NONE; mosi = Cpu.Pin.GPIO_NONE; NativeGetSpiPins(spi_mod, out msk, out miso, out mosi); }
public Mfrc522(SPI.SPI_module spiDevice, Cpu.Pin resetPowerDownPin, Cpu.Pin ssPin) { _resetPowerDown = new OutputPort(resetPowerDownPin, true); _ss = new OutputPort(ssPin, true); _spi = new SPI(new SPI.Configuration(Pins.GPIO_NONE, false, 0, 0, false, true, 1000, spiDevice)); Reset(); }
/// <summary> /// Create a new ADXL362 object using the specified SPI module. /// </summary> /// <param name="module">SPI module to use.</param> /// <param name="chipSelect">Chip select pin.</param> /// <param name="speed">Speed of the SPI bus.</param> public ADXL362(SPI.SPI_module module, Cpu.Pin chipSelect, ushort speed = 10) { // // ADXL362 works in SPI mode 0 (CPOL = 0, CPHA = 0). // _adxl362 = new SPIBus(module, chipSelect, speed); Reset(); Start(); }
public static void MountSD(string path, SPI.SPI_module spi, Cpu.Pin chipSelect, Cpu.Pin cardDetect) { if (SdCardPath != null) { throw new NotSupportedException(); } SDSPI_Mount(path, (uint)spi, (uint)chipSelect, (uint)cardDetect); SdCardPath = path; }
public ST7735(Cpu.Pin chipSelectPin, Cpu.Pin dcPin, Cpu.Pin resetPin, uint width, uint height, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = 9500, DisplayType displayType = DisplayType.ST7735R) : base(chipSelectPin, dcPin, resetPin, width, height, spiModule, speedKHz) { this.displayType = displayType; Initialize(); }
public Lm15Sgfnz07(SPI.SPI_module spi, Cpu.Pin cs, Cpu.Pin reset, Cpu.Pin rs) { var spiCfg = new SPI.Configuration(cs, false, 0, 0, true, true, 5000, spi); _spi = new SPI(spiCfg); _reset = new OutputPort(reset, true); _rs = new OutputPort(rs, false); Initialize(); }
public Configuration(Cpu.Pin ChipSelect_Port, bool ChipSelect_ActiveState, uint ChipSelect_SetupTime, uint ChipSelect_HoldTime, bool Clock_IdleState, bool Clock_Edge, uint Clock_RateKHz, SPI.SPI_module SPI_mod) { this.ChipSelect_Port = ChipSelect_Port; this.ChipSelect_ActiveState = ChipSelect_ActiveState; this.ChipSelect_SetupTime = ChipSelect_SetupTime; this.ChipSelect_HoldTime = ChipSelect_HoldTime; this.Clock_IdleState = Clock_IdleState; this.Clock_Edge = Clock_Edge; this.Clock_RateKHz = Clock_RateKHz; this.SPI_mod = SPI_mod; }
/// <summary> /// Creates a new nRF8001 device interface. /// </summary> /// <param name="rstPin">The application controller pin that the nRF8001's RST pin is connected to.</param> /// <param name="reqPin">The application controller pin that the nRF8001's REQn pin is connected to.</param> /// <param name="rdyPin">The application controller pin that the nRF8001's RDYn pin is connected to.</param> /// <param name="spiModule">The SPI module to use for communication with the nRF8001.</param> public Nrf8001(Cpu.Pin rstPin, Cpu.Pin reqPin, Cpu.Pin rdyPin, SPI.SPI_module spiModule) { _rst = new OutputPort(rstPin, true); _req = new OutputPort(reqPin, true); _rdy = new InterruptPort(rdyPin, false, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow); _spi = new SPI(new SPI.Configuration(Cpu.Pin.GPIO_NONE, false, 0, 0, false, true, 100, spiModule)); State = Nrf8001State.Unknown; Reset(); _rdy.OnInterrupt += OnRdyInterrupt; }
uint _numPixels; // strip's length /// <summary> /// Constructor /// </summary> /// <param name="color"> RGB value to initially set all LEDs to. Pass OFF or 0 to start with LEDs off. </param> /// <param name="numPixels"> Number of pixels in strip.</param> /// <param name="spiModule"> Optional paramter for specifying which SPI module. Omit this paramter to default to HERO S ports. </param> public HeroPixel(uint color, uint numPixels = 1, SPI.SPI_module spiModule = SPI.SPI_module.SPI4) { _numPixels = (numPixels > 0) ? numPixels : 1; _pixels = new uint[_numPixels]; _spiOut = new byte[kColorsPerPixel * kSpiBytesPerColor * _numPixels + 1]; // create array for output with +1 extra for START_OF_RST at the end setStripColor(color); // initialize SPI Configuration = new SPI.Configuration(Cpu.Pin.GPIO_NONE, false, 0, 0, false, false, 9000, spiModule); SPIDevice = new SPI(Configuration); }
override public void GetSpiPins(SPI.SPI_module spi_mod, out Cpu.Pin msk, out Cpu.Pin miso, out Cpu.Pin mosi) { if ((int)spi_mod == 0) { msk = Pins.SPI0_SCLK; miso = Pins.SPI0_MISO; mosi = Pins.SPI0_MOSI; } else { throw new NotImplementedException(); } }
/// <summary> /// Defines a chain of RGB LEDs /// </summary> /// <param name="Chipset">The chipset used to daisychain the LEDs</param> /// <param name="LedCount">The amount of LEDs in the chain</param> /// <param name="SPI_Device">The SPI bus the chain is connected to</param> /// <param name="ChipSelect_Port">If there's a CS circuitry, specify it's pin</param> /// <param name="ChipSelect_ActiveState">If there's a CS circuitry, specify it's active state</param> public RgbLedStrip(Chipsets Chipset, int LedCount, SPI.SPI_module SPI_Device, Cpu.Pin ChipSelect_Port, bool ChipSelect_ActiveState) { // The used chipset this._Chipset = Chipset; // Stores the amount of LEDs this.LedCount = LedCount; // Extends the arrays for the LED states and brightness this._LedState = new byte[LedCount * 3]; this._Brightness = new byte[LedCount]; // Settings for the LPD8806 chip if (Chipset == Chipsets.LPD8806) { // Creates a new buffer (final 3 bytes should always be 0 and tells the chain we're done for now) this._Buffer = new byte[LedCount * 3 + 3]; // Default sequence of the Adafruit strips this.Sequence = Sequences.GRB; } // Settings for the WS2801 chip if (Chipset == Chipsets.WS2801) { // Creates a new buffer this._Buffer = new byte[LedCount * 3]; // Default sequence of the Adafruit chains this.Sequence = Sequences.RGB; } // Configures the SPI bus this._Conn = new MultiSPI(new SPI.Configuration( ChipSelect_Port: ChipSelect_Port, ChipSelect_ActiveState: ChipSelect_ActiveState, ChipSelect_SetupTime: 0, ChipSelect_HoldTime: 0, Clock_IdleState: false, Clock_Edge: true, Clock_RateKHz: 1000, SPI_mod: SPI_Device )); // Set brightness only half way, most LED strips are just way too bright imho this.SetBrightnessAll(128); // Turns off all LEDs this.SetColorAll(0); // Writes for the first time this.Write(); }
override public void GetSpiPins(SPI.SPI_module spi_mod, out Cpu.Pin msk, out Cpu.Pin miso, out Cpu.Pin mosi) { switch (spi_mod) { case SPI.SPI_module.SPI1: msk = Pins.GPIO_PIN_6; miso = Pins.GPIO_PIN_7; mosi = Pins.GPIO_PIN_8; break; default: throw new NotSupportedException(); } }
public TouchConfiguration(SPI.SPI_module channel, FEZ_Pin.Digital chipSelect, FEZ_Pin.Digital touchIRQ) { this.channel = channel; this.chipSelect = (Cpu.Pin)chipSelect; this.touchIRQ = (Cpu.Pin)touchIRQ; }
//internal static byte[] _encodedName; /// <summary> /// Start Networking! If you want to use a static IP, make sure to set it before you start! /// Note: This call may block for up to 15 seconds waiting for the IP Address assignment. /// </summary> /// <param name="MacAddress">6-bytes the specify the Globally unique MAC address</param> /// <param name="name">Local Name of this device</param> /// <param name="spiBus"></param> /// <param name="resetPin"></param> /// <param name="interruptPin"></param> /// <param name="chipSelectPin"></param> public static void Start(byte[] MacAddress, string name, SPI.SPI_module spiBus, Cpu.Pin interruptPin, Cpu.Pin chipSelectPin) { Microsoft.SPOT.Debug.Assert(MacAddress != null, "MAC Address must be set to start networking."); Adapter.MacAddress = MacAddress; // Setting the Name to null will turn off naming... Adapter.Name = name; Adapter.SpiPort = spiBus; Adapter.IntPin = interruptPin; Adapter.CSPin = chipSelectPin; //if (responderThread.ThreadState == ThreadState.Running) return; //startupHold.Reset(); //if (responderThread.ThreadState == ThreadState.Unstarted) //{ // responderThread.Start(); //} //else if (responderThread.ThreadState == ThreadState.Stopped || responderThread.ThreadState == ThreadState.Suspended) //{ // Debug.WriteLine("Networking Thread being Restarted! Threadstate: " + responderThread.ThreadState.ToString()); // responderThread.Abort(); // Thread.Sleep(10); // responderThread = new Thread(MainService); //} MainService(); if (!Adapter.DhcpDisabled && (Adapter.DomainNameServer == null || Adapter.Gateway == null || Adapter.IPAddress == null)) { if (!startupHold.WaitOne(10000, true)) Debug.WriteLine("WARNING! Time out while waiting for DHCP, check your Interface Profile and connections to ENC28J60 Controller"); // wait 10 seconds for DHCP and DNS assignment } else if (Adapter.DhcpDisabled && Adapter.IPAddress != null && Adapter.Gateway != null && GatewayMac == null) { if (!startupHold.WaitOne(10000, true)) Debug.WriteLine("WARNING! Time out while waiting for Gateway to Respond to ARP request"); // wait 10 seconds for DHCP and DNS assignment } else { Debug.WriteLine("WARNING! Networking is not properly configured to start. "); } }
public SiliconStorageDevice(Cpu.Pin chipSelect, SPI.SPI_module spiModule) { _chipSelect = chipSelect; _spiModule = spiModule; }