/// <summary> /// Initializes a new instance of the <see cref="OLEDCClick"/> class. /// </summary> /// <param name="socket">The socket on which the OLEDc Click board is inserted on MikroBus.Net</param> /// <exception cref="PinInUseException">If some pins are already used by another driver, then the exception is thrown.</exception> /// <example>Example usage: /// <code language = "C#"> /// var _oled = new OLEDCClick(Hardware.SocketFour); /// </code> /// <code language = "VB"> /// Dim _oled as OLEDCClick = New OLEDCClick(Hardware.SocketFour) /// </code> /// </example> public OLEDCClick(Hardware.Socket socket) { try { Hardware.CheckPins(socket, socket.Miso, socket.Cs, socket.Sck, socket.Rst, socket.An, socket.Pwm); _spiConfig = new SPI.Configuration(socket.Cs, false, 0, 0, true, true, 40000, socket.SpiModule); if (Hardware.SPIBus == null) { Hardware.SPIBus = new SPI(_spiConfig); } _resetPin = new OutputPort(socket.Rst, true); _dcPin = new OutputPort(socket.Pwm, true); _rwPin = new OutputPort(socket.An, true); _canvas = new MikroBitmap(_canvasWidth, _canvasHeight); InitilizeOLED(); } catch (PinInUseException ex) { throw new PinInUseException(ex.Message); } }
/// <summary> /// Constructor intializes read and write at 10mhz /// </summary> /// <param name="ChipSelectPin">CS pin</param> /// <param name="HoldPin">HOLD pin</param> public RamStream(Cpu.Pin ChipSelectPin, Cpu.Pin HoldPin) { hold_port = new OutputPort(HoldPin, true); hold_port.Write(true); SPI.Configuration config = new SPI.Configuration(ChipSelectPin, false, 0, 0, false, true, 10000, SPI.SPI_module.SPI1); spi_driver = new SPI(config); }
/// <summary>Constructs a new instance.</summary> /// <param name="socketNumber">The socket that this module is plugged in to.</param> public DisplayN18(int socketNumber) : base(WpfMode.Separate) { this.byteArray = new byte[1]; this.shortArray = new ushort[2]; this.isBgr = true; this.socket = Socket.GetSocket(socketNumber, true, this, null); this.socket.EnsureTypeIsSupported('S', this); this.resetPin = GTI.DigitalOutputFactory.Create(this.socket, Socket.Pin.Three, false, this); this.backlightPin = GTI.DigitalOutputFactory.Create(this.socket, Socket.Pin.Four, true, this); this.rsPin = GTI.DigitalOutputFactory.Create(this.socket, Socket.Pin.Five, false, this); this.spiConfig = new GTI.SpiConfiguration(false, 0, 0, false, true, 12000); this.netMFSpiConfig = new SPI.Configuration(this.socket.CpuPins[6], this.spiConfig.IsChipSelectActiveHigh, this.spiConfig.ChipSelectSetupTime, this.spiConfig.ChipSelectHoldTime, this.spiConfig.IsClockIdleHigh, this.spiConfig.IsClockSamplingEdgeRising, this.spiConfig.ClockRateKHz, this.socket.SPIModule); this.spi = GTI.SpiFactory.Create(this.socket, this.spiConfig, GTI.SpiSharing.Shared, this.socket, Socket.Pin.Six, this); this.Reset(); this.ConfigureDisplay(); base.OnDisplayConnected("Display N18", 128, 160, DisplayOrientation.Normal, null); this.Clear(); }
public bool InitCAN(enBaudRate baudrate, UInt16 filter, UInt16 mask) { // Configure SPI var configSPI = new SPI.Configuration(Pins.GPIO_NONE, LOW, 0, 0, HIGH, HIGH, 10000, SPI.SPI_module.SPI1); //a0 D10 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); // BECKER WHAT IS HAPPENING HERE. // byte mode = (byte)(ReadRegister(CANSTAT)); // >> 5); // if (mode != 0x04) // { // return false; // } // else // Must set the filters and masks while the 2515 is in reset state. //SetMask(mask, filter); //SetCANBaud(baudrate); return(true); }
public static void Main() { SerialPort UART = new SerialPort("COM1", 9600); SPI.Configuration config = new SPI.Configuration((Cpu.Pin)FEZ_Pin.Digital.Di10, false, 0, 0, true, true, 250, SPI.SPI_module.SPI1); SPI Spi = new SPI(config); UART.Open(); string Datoreaded = ""; byte[] datain = new byte[1]; byte[] dataout = new byte[1]; while (true) { // Sleep for 500 milliseconds Thread.Sleep(500); dataout[0] = (byte)0x55; datain[0] = (byte)0; Spi.WriteRead(dataout, datain); Datoreaded = datain[0].ToString(); Datoreaded += "\n\r"; byte[] buffer = Encoding.UTF8.GetBytes(Datoreaded); UART.Write(buffer, 0, buffer.Length); } }
/// <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 static void Main() { SPI.Configuration spiConfig = new SPI.Configuration( ShieldConfiguration.CurrentConfiguration.SpiChipSelectPin, false, 100, 100, false, true, 1000, ShieldConfiguration.CurrentConfiguration.SpiModule ); var spi = new SPI(spiConfig); var statusBuffer = new byte[2]; // Watch the LEDs on UberShield. If they are showing the bootloader // flashing pattern, there's no SPI connectivity. If the lights // alternate off / red / green / redgreen then you're quad-winning. // If they're off, you're not in bootloader mode. while (true) { statusBuffer[0] = 0x01; for (byte counter = 0; counter <= 3; ++counter) { statusBuffer[1] = (byte)((counter << 2) | 0x03); spi.Write(statusBuffer); Thread.Sleep(500); } } }
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); }
private void NativeBitmapSpi(Bitmap bitmap, SPI.Configuration config, int xSrc, int ySrc, int width, int height, GT.Mainboard.BPP bpp) { if (bpp != GT.Mainboard.BPP.BPP16_BGR_BE) { throw new ArgumentOutOfRangeException("bpp", "Only BPP16_BGR_BE supported"); } if (!this.configSet) { Display.BitmapFormat = GHI.Utilities.Bitmaps.Format.Bpp16BgrBe; Display.CurrentRotation = Display.Rotation.Normal; Display.Type = Display.DisplayType.Spi; Display.ControlPin = Cpu.Pin.GPIO_NONE; Display.BacklightPin = Cpu.Pin.GPIO_NONE; Display.ResetPin = Cpu.Pin.GPIO_NONE; Display.SpiConfiguration = config; Display.Width = bitmap.Width; Display.Height = bitmap.Height; Display.Save(); this.configSet = true; } bitmap.Flush(xSrc, ySrc, width, height); }
public EPDBase(Cpu.Pin chipSelectPin, Cpu.Pin dcPin, Cpu.Pin resetPin, Cpu.Pin busyPin, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = (uint)9500) { dataCommandPort = new OutputPort(dcPin, false); resetPort = new OutputPort(resetPin, true); busyPort = new InputPort(busyPin, true, Port.ResistorMode.Disabled); 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); imageBuffer = new byte[Width * Height / 8]; for (int i = 0; i < Width * Height / 8; i++) { imageBuffer[i] = 0xff; } Initialize(); }
/// <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); } }
/// <summary> /// Main program loop. /// </summary> public static void Main() { SPI.Configuration spiConfig = new SPI.Configuration( ChipSelect_Port: Pins.GPIO_PIN_D7, // Chip select is digital IO 7. ChipSelect_ActiveState: false, // Chip select is active low. ChipSelect_SetupTime: 0, // Amount of time between selection and the clock starting ChipSelect_HoldTime: 0, // Amount of time the device must be active after the data has been read. Clock_Edge: false, // Sample on the falling edge. Clock_IdleState: false, // Clock is idle when low. Clock_RateKHz: 10, // 10KHz clock speed. SPI_mod: SPI_Devices.SPI1 // Use SPI1 ); SPI spi = new SPI(spiConfig); int count = 0; while (true) { byte[] dataOut = new byte[] { 0 }; byte[] dataIn = new byte[REG_SIZE]; spi.WriteRead(dataOut, dataIn, 1); count++; string message = "Read " + count.ToString() + ":"; for (int index = 0; index < dataIn.Length; index++) { message += " " + Hexadecimal(dataIn[index]); } Debug.Print(message); Debug.Print(DecodeTime(dataIn)); Thread.Sleep(2000); } }
public NRFC(Hardware.Socket socket) { Hardware.CheckPins(socket, socket.Miso, socket.Mosi, socket.Cs, socket.Sck, socket.Rst, socket.Int); _spiConfig = new SPI.Configuration(socket.Cs, false, 0, 0, false, true, 2000, socket.SpiModule); if (Hardware.SPIBus == null) { Hardware.SPIBus = new SPI(_spiConfig); } // Initialize IRQ Port _irqPin = new InterruptPort(socket.Int, false, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow); _irqPin.OnInterrupt += HandleInterrupt; // Initialize Chip Enable Port _cePin = new OutputPort(socket.Rst, false); // Module reset time Thread.Sleep(100); _initialized = true; _transmitSuccessFlag = new ManualResetEvent(false); _transmitFailedFlag = new ManualResetEvent(false); }
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(); }
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); }
void Initialize(GoSocket socket) { // now try to bind to the socket (and verify our module's uniqueId) if (!base.BindSocket(socket, _moduleGuid)) { throw new ArgumentException(); } // get socket's physical pins and SPI bus Cpu.Pin socketGpioPin; SPI.SPI_module socketSpiModule; Cpu.Pin socketSpiSlaveSelectPin; // socket.GetPhysicalResources(out socketGpioPin, out socketSpiModule, out socketSpiSlaveSelectPin); _spiConfig = new SPI.Configuration(socketSpiSlaveSelectPin, false, 0, 0, false, false, 500, socketSpiModule); _spi = new SPI(_spiConfig); // wire up event handlers _interruptPort = new InterruptPort((Cpu.Pin)socketGpioPin, false, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeBoth); _interruptPort.OnInterrupt += _interruptPort_OnInterrupt; // read initial button state _isPressed = !_interruptPort.Read(); }
/// <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(); }
public static void Main() { var config = new SPI.Configuration(SPI_mod: SPI_Devices.SPI1, ChipSelect_Port: Pins.GPIO_PIN_D8, ChipSelect_ActiveState: false, ChipSelect_SetupTime: 0, ChipSelect_HoldTime: 0, Clock_IdleState: true, Clock_Edge: true, Clock_RateKHz: 10); var shiftRegister = new x74595(8, config); DigitalOutputPort relayPort = shiftRegister.CreateOutputPort(0, false); var relay = new Relay(relayPort); while (true) { // toggle the relay relay.Toggle(); Debug.Print("Relay on: " + relay.IsOn.ToString()); // wait for 5 seconds Thread.Sleep(1000); } }
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); }
/// <summary> /// Default constructor for the Current Click board. /// </summary> /// <param name="socket">The MBN Socket that the Current click is inserted into.</param> /// <param name="shuntResistorResistorValue">The value in Ohms of the resistor in the ShuntResistor Terminal Block</param> /// <param name="userDefinedShuntResistor"> /// Optional User Defined value of the ShuntResistor Resistor. /// To use a User Defined ShuntResistor Resistor, set the value of the <see cref="ShuntResistor"/> to SR_CUSTOM /// </param> public CurrentClick(Hardware.Socket socket, ShuntResistor shuntResistorResistorValue, float userDefinedShuntResistor = 1f) { try { Hardware.CheckPins(socket, socket.Miso, socket.Mosi, socket.Cs, socket.Sck); _spiConfig = new SPI.Configuration(socket.Cs, false, 0, 0, true, true, 1000, socket.SpiModule); if (Hardware.SPIBus == null) { Hardware.SPIBus = new SPI(_spiConfig); } if (shuntResistorResistorValue == ShuntResistor.SR_CUSTOM) { _userdefinedShuntResistorValue = userDefinedShuntResistor; } else { _shuntResistorResistorValue = shuntResistorResistorValue; } } // Catch only the PinInUse exception, so that program will halt on other exceptions // Send it directly to caller catch (PinInUseException ex) { throw new PinInUseException(ex.Message); } }
private byte _currentResistance; // Resistance /// <summary> /// Main class for the MikroE Digipot Click board driver /// </summary> /// <param name="socket">The socket on which the Digipot Click board is plugged on MikroBus.Net</param> /// <param name="initialResistance">The initial resistance the Digipot should be initialized with.</param> /// <exception cref="System.InvalidOperationException">Thrown if some pins are already in use by another board on the same socket</exception> public DigiPotClick(Hardware.Socket socket, byte initialResistance) { try { // Checks if needed SPI pins are available Hardware.CheckPins(socket, socket.Cs, socket.Sck, socket.Mosi, socket.Miso); // Initialize SPI _spiConfig = new SPI.Configuration( socket.Cs, // Cpu.Pin ChipSelect_Port, false, // bool ChipSelect_ActiveState, 10, // uint ChipSelect_SetupTime, 20, // uint ChipSelect_HoldTime, true, // bool Clock_IdleState, false, // bool Clock_Edge, 10000, // uint Clock_RateKHz, socket.SpiModule); if (Hardware.SPIBus == null) { Hardware.SPIBus = new SPI(_spiConfig); } _currentResistance = initialResistance; } // Catch only the PinInUse exception, so that program will halt on other exceptions // Send it directly to caller catch (PinInUseException) { throw new PinInUseException(); } }
/// <summary> /// c'tor /// </summary> /// <param name="socket">the Gadgeteer socket that the strip is on</param> /// <param name="numLeds">the number of LEDs in the strip</param> public LedStripLPD8806(GT.Socket socket, int numLeds) { var spiConfig = new SPI.Configuration(Cpu.Pin.GPIO_NONE, false, // chip select active state 0, // chip select setup time 0, // chip select hold time false, // clock idle state true, // clock edge (true = rising) 2000, // 2mhz SPI.SPI_module.SPI1 ); // the protocol seems to be that we need to write 1 + (1 per 64 LEDs) bytes // at the end of each update (I've only tested this on a 32-LED strip) int latchBytes = ((numLeds + 63) / 64) * 3; mLedByteCount = numLeds * 3; mData = new byte[mLedByteCount + latchBytes]; mNumLeds = numLeds; // mLedStrip = new SPI(socket, spiConfig, SPI.Sharing.Exclusive, null); mLedStrip = new SPI(spiConfig); // start with all the LEDs off for (int i = 0; i < mLedByteCount; i++) { mData[i] = MASK; } // give the strip an inital poke of the latch bytes (no idea // why this is needed) mLedStrip.Write(new byte[latchBytes]); // push the initial values (all off) to the strip SendUpdate(); }
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> /// 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(); }
/// <summary> /// Method for initializing the decoder. Must be called before ANY other method. /// </summary> public static void Initialize() { cancelPlayback = false; SPI.SPI_module spi_module; spi_module = SPI.SPI_module.SPI1; dataConfig = new SPI.Configuration((Cpu.Pin)FEZ_Pin.Digital.Di2, false, 0, 0, false, true, 2000, spi_module); cmdConfig = new SPI.Configuration((Cpu.Pin)FEZ_Pin.Digital.Di9, false, 0, 0, false, true, 2000, spi_module); DREQ = new InputPort((Cpu.Pin)FEZ_Pin.Digital.Di3, false, Port.ResistorMode.PullUp); spi = new SPI(dataConfig); Reset(); SCIWrite(SCI_MODE, SM_SDINEW); SCIWrite(SCI_CLOCKF, 0x98 << 8); SCIWrite(SCI_VOL, 0x2828); //ClearPlayback(); if (SCIRead(SCI_VOL) != (0x2828)) { throw new Exception("VS1053: Failed to initialize MP3 Decoder."); } else { Debug.Print("VS1053: Initialized MP3 Decoder."); } }
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); }
private void ConfigureBusForDevice(SpiDeviceSettings settings) { int newHash = settings.GetHashCode(); if (newHash == _lastConfigHash) { return; } SPI.Configuration result; if (_knownConfigs.Contains(settings)) { result = (SPI.Configuration)_knownConfigs[settings]; } else { result = new SPI.Configuration(settings.SoftChipSelectEnabled ? Cpu.Pin.GPIO_NONE : (Cpu.Pin)settings.ChipSelectPin, settings.ChipSelectActiveState, settings.ChipSelectSetupTime, settings.ChipSelectHoldTime, settings.ClockIdleState, settings.ClockEdge, settings.ClockRateKHz, _module); _knownConfigs.Add(settings, result); } _spotSpi.Config = result; _lastConfigHash = newHash; }
public Nokia_5110(bool useBacklight, Cpu.Pin latch, Cpu.Pin backlight, Cpu.Pin reset, Cpu.Pin dataCommand) { if (useBacklight) { this.backlight = new PWM(backlight); } SPI.Configuration spiConfiguration = new SPI.Configuration( latch, // 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 4000, // clockrate is 15 MHz SPI.SPI_module.SPI1 // use first SPI bus ); spi = new SPI(spiConfiguration); this.reset = new OutputPort(reset, true); this.dataMode = new OutputPort(dataCommand, true); Initialize(); }
public static void Upload(PageCollection pageCollection) { OutputPort onboardLed = new OutputPort(ShieldConfiguration.CurrentConfiguration.OnboardLedPin, true); SPI.Configuration spiConfig = new SPI.Configuration( ShieldConfiguration.CurrentConfiguration.SpiChipSelectPin, false, 100, 100, false, true, 1000, ShieldConfiguration.CurrentConfiguration.SpiModule ); var spi = new SpotSpi(spiConfig); var uploader = new Uploader(spi); if (uploader.IsShieldInBootloaderMode()) { var uploadStatusIndicator = new UploadStatusIndicator( spi ); try { //var securityRegisterData = uploader.SecurityRegisterRead(); //var userData = new byte[Constants.SecurityRegisterUserFieldLength]; //Array.Copy(securityRegisterData, 4, userData, 0, userData.Length); //var userDataString = new string(System.Text.Encoding.UTF8.GetChars(userData)); //Debug.Print("Programming \"" + userDataString + "\""); uploadStatusIndicator.Status = UploadStatusIndicator.UploadStatus.Uploading; uploader.UploadBitstream(pageCollection); uploadStatusIndicator.Status = UploadStatusIndicator.UploadStatus.Succeeded; } catch { // Any exception is a failed upload uploadStatusIndicator.Status = UploadStatusIndicator.UploadStatus.Failed; throw; } finally { onboardLed.Write(false); } } else { // Flash the onboard LED to indicate upload failure due to // not being in bootstrapping mode Thread.Sleep(500); onboardLed.Write(false); Thread.Sleep(500); onboardLed.Write(true); Thread.Sleep(500); onboardLed.Write(false); } }
/// <summary> /// Writes an array of unsigned short arguments to the interface. /// </summary> /// <param name="spiDev">The underlying SPI object. Omit this parameter when you call that method</param> /// <param name="pConfig">The SPI configuration used for this transfer.</param> /// <param name="pArray">The buffer that will write to the interface.</param> public static void Write(this SPI spiDev, SPI.Configuration pConfig, UInt16[] pArray) { lock (Hardware.SpiLock) { spiDev.Config = pConfig; spiDev.Write(pArray); } }
/// <summary> /// Writes an array of bytes to the interface, and reads an array of bytes from the interface. /// </summary> /// <param name="spiDev">The underlying SPI object. Omit this parameter when you call that method</param> /// <param name="pConfig">The SPI configuration used for this transfer.</param> /// <param name="writeBuffer">The buffer whose contents will be written to the interface.</param> /// <param name="writeOffset">The offset in writeBuffer to start write data from.</param> /// <param name="writeCount">The number of elements in writeBuffer to write.</param> /// <param name="readBuffer">The buffer that will store the data that is read from the interface.</param> /// <param name="readOffset">The offset in readBuffer to start read data from.</param> /// <param name="readCount">The number of elements in readBuffer to fill.</param> /// <param name="startReadOffset">The offset in time, measured in transacted elements from writeBuffer, when to start reading back data into readBuffer.</param> public static void WriteRead(this SPI spiDev, SPI.Configuration pConfig, byte[] writeBuffer, int writeOffset, int writeCount, byte[] readBuffer, int readOffset, int readCount, int startReadOffset) { lock (Hardware.SpiLock) { spiDev.Config = pConfig; spiDev.WriteRead(writeBuffer, writeOffset, writeCount, readBuffer, readOffset, readCount, startReadOffset); } }
private uint spiSpeed = 8000; // kHz #endregion Fields #region Constructors //, int socketNumberTwo) // Note: A constructor summary is auto-generated by the doc builder. /// <summary></summary> /// <param name="socketNumber">The socket that this module is plugged in to.</param> /// <param name="socketNumberTwo">The second socket that this module is plugged in to.</param> public DisplayS22(int socketNumber) : base(WPFRenderOptions.Intercept) { // This finds the Socket instance from the user-specified socket number. // This will generate user-friendly error messages if the socket is invalid. // If there is more than one socket on this module, then instead of "null" for the last parameter, // put text that identifies the socket to the user (e.g. "S" if there is a socket type S) socket = Socket.GetSocket(socketNumber, true, this, null); socket.EnsureTypeIsSupported('S', this); socket.ReservePin(Socket.Pin.Three, this); // reset socket.ReservePin(Socket.Pin.Four, this); // back light socket.ReservePin(Socket.Pin.Five, this); // D/C socket.ReservePin(Socket.Pin.Six, this); // CS socket.ReservePin(Socket.Pin.Seven, this); // MOSI socket.ReservePin(Socket.Pin.Eight, this); // MISO socket.ReservePin(Socket.Pin.Nine, this); // SCK /* * Serial peripheral interface (SPI). * Pin 7 is MOSI line, pin 8 is MISO line, pin 9 is SCK line. * In addition, pins 3, 4 and 5 are general-purpose input/outputs, with pin 3 supporting interrupt capabilities. */ pinReset = new GTI.DigitalOutput(socket, Socket.Pin.Three, false, this); // pin 3 pinBacklight = new GTI.DigitalOutput(socket, Socket.Pin.Four, false, this); // pin 4 pinDC = new GTI.DigitalOutput(socket, Socket.Pin.Five, false, this); // pin 5 spiConfig = new GTI.SPI.Configuration(false, 0, 0, false, true, spiSpeed); netMFSpiConfig = new SPI.Configuration(socket.CpuPins[6], spiConfig.ChipSelectActiveState, spiConfig.ChipSelectSetupTime, spiConfig.ChipSelectHoldTime, spiConfig.ClockIdleState, spiConfig.ClockEdge, spiConfig.ClockRateKHz, socket.SPIModule); spi = new GTI.SPI(socket, spiConfig, GTI.SPI.Sharing.Shared, socket, Socket.Pin.Six, this); Reset(); ConfigureDisplay(); Clear(); SetBacklight(true); }
/// <summary>Constructor</summary> /// <param name="socketNumber">The socket that this module is plugged in to.</param> public Display(ModelType model, int socketNumber) : base(WPFRenderOptions.Intercept) { #region UTFT ushort[] dsx = {239, 239, 239, 239, 239, 239, 175, 175, 239, 127, 127, 239, 271, 479, 239, 239, 239, 239, 239, 239, 479, 319, 239, 175, 127, 239, 239, 319, 319}; ushort[] dsy = {319, 399, 319, 319, 319, 319, 219, 219, 399, 159, 127, 319, 479, 799, 319, 319, 319, 319, 319, 319, 799, 479, 319, 219, 159, 319, 319, 479, 479}; byte[] dtm = { 16, 16, 16, 8, 8, 16, 8, (byte)DisplayTransferMode.SERIAL_4PIN, 16, (byte)DisplayTransferMode.SERIAL_5PIN, (byte)DisplayTransferMode.SERIAL_5PIN, 16, 16, 16, 8, 16, (byte)DisplayTransferMode.LATCHED_16, 8, 16, 8, 16, 16, 16, 8, (byte)DisplayTransferMode.SERIAL_5PIN, (byte)DisplayTransferMode.SERIAL_5PIN, (byte)DisplayTransferMode.SERIAL_4PIN, 16, 16 }; disp_x_size = dsx[(byte)model]; disp_y_size = dsy[(byte)model]; display_transfer_mode = dtm[(byte)model]; display_model = (byte)model; if (display_transfer_mode == (byte)DisplayTransferMode.SERIAL_4PIN) { display_transfer_mode = 1; display_serial_mode = (byte)DisplayTransferMode.SERIAL_4PIN; } if (display_transfer_mode == (byte)DisplayTransferMode.SERIAL_5PIN) { display_transfer_mode = 1; display_serial_mode = (byte)DisplayTransferMode.SERIAL_5PIN; } if (display_transfer_mode != 1) { //_set_direction_registers(display_transfer_mode); //P_RS = portOutputRegister(digitalPinToPort(RS)); //B_RS = digitalPinToBitMask(RS); //P_WR = portOutputRegister(digitalPinToPort(WR)); //B_WR = digitalPinToBitMask(WR); //P_CS = portOutputRegister(digitalPinToPort(CS)); //B_CS = digitalPinToBitMask(CS); //P_RST = portOutputRegister(digitalPinToPort(RST)); //B_RST = digitalPinToBitMask(RST); //if (display_transfer_mode == LATCHED_16) //{ // P_ALE = portOutputRegister(digitalPinToPort(SER)); // B_ALE = digitalPinToBitMask(SER); // pinMode(SER, OUTPUT); // cbi(P_ALE, B_ALE); // pinMode(8, OUTPUT); // digitalWrite(8, LOW); //} //pinMode(RS, OUTPUT); //pinMode(WR, OUTPUT); //pinMode(CS, OUTPUT); //pinMode(RST, OUTPUT); } else { //P_SDA = portOutputRegister(digitalPinToPort(RS)); //B_SDA = digitalPinToBitMask(RS); //P_SCL = portOutputRegister(digitalPinToPort(WR)); //B_SCL = digitalPinToBitMask(WR); //P_CS = portOutputRegister(digitalPinToPort(CS)); //B_CS = digitalPinToBitMask(CS); //P_RST = portOutputRegister(digitalPinToPort(RST)); //B_RST = digitalPinToBitMask(RST); //if (display_serial_mode != SERIAL_4PIN) //{ // P_RS = portOutputRegister(digitalPinToPort(SER)); // B_RS = digitalPinToBitMask(SER); // pinMode(SER, OUTPUT); //} //pinMode(RS, OUTPUT); //pinMode(WR, OUTPUT); //pinMode(CS, OUTPUT); //pinMode(RST, OUTPUT); } #endregion socket = Socket.GetSocket(socketNumber, true, this, null); socket.EnsureTypeIsSupported('S', this); /* * Serial peripheral interface (SPI). * Pin 7 is MOSI line, pin 8 is MISO line, pin 9 is SCK line. * In addition, pins 3, 4 and 5 are general-purpose input/outputs, with pin 3 supporting interrupt capabilities. */ pinReset = new GTI.DigitalOutput(socket, Socket.Pin.Three, false, this); // pin 3 pinBacklight = new GTI.DigitalOutput(socket, Socket.Pin.Four, false, this); // pin 4 pinDc = new GTI.DigitalOutput(socket, Socket.Pin.Five, false, this); // pin 5 spiConfig = new GTI.SPI.Configuration(false, 0, 0, false, true, 12000); netMFSpiConfig = new SPI.Configuration(socket.CpuPins[6], spiConfig.ChipSelectActiveState, spiConfig.ChipSelectSetupTime, spiConfig.ChipSelectHoldTime, spiConfig.ClockIdleState, spiConfig.ClockEdge, spiConfig.ClockRateKHz, socket.SPIModule); spi = new GTI.SPI(socket, spiConfig, GTI.SPI.Sharing.Shared, socket, Socket.Pin.Six, this); Reset(); ConfigureDisplay(); Clear(); SetBacklight(true); }
/// <summary> /// �R���X�g���N�^ /// </summary> /// <param name="pin">SS�s��</param> /// <param name="module">SPI���W���[��</param> public SpiController(Cpu.Pin pin, SPI.SPI_module module) { SPI.Configuration config = new SPI.Configuration(pin, false, 1, 1, false, true, 200, module); spi = new SPI(config); }
public byte Wiper_Reg; //Wiper Register public MCP4131(Cpu.Pin cs_pin, SPI.SPI_module mod) { MCP4131_Config = new SPI.Configuration(cs_pin, false, 0, 0, false, true, 800, mod); MCP4131_SPI = new SPI(MCP4131_Config); }