static Config() { Latch = new OutputPort(Pins.GPIO_PIN_D9, false); Device = new SPI.Configuration( ChipSelect_Port: Pins.GPIO_NONE, // SS-pin = slave select, not used ChipSelect_ActiveState: false, // SS-pin active state ChipSelect_SetupTime: 0, // The setup time for the SS port ChipSelect_HoldTime: 0, // The hold time for the SS port Clock_IdleState: true, // The idle state of the clock Clock_Edge: true, // The sampling clock edge Clock_RateKHz: 30000, // The SPI clock rate in KHz ==> enough to start with, let's see how high we can take this later on SPI_mod: SPI.SPI_module.SPI1 // The used SPI bus (refers to a MOSI MISO and SCLK pinset) => default pins, also the ones used on the pwm shield // specifically: sin = 11, (netduino send, tlc in) and sclck = 13 ); // better to pass in the pins, and let the ports and pwms be managed insode the device Blank = new PWM(Pins.GPIO_PIN_D10); Gsclk = new PWM(Pins.GPIO_PIN_D6); LayerPorts=new[] { new OutputPort(Pins.GPIO_PIN_D5, false), new OutputPort(Pins.GPIO_PIN_D4, false), new OutputPort(Pins.GPIO_PIN_D3, false), new OutputPort(Pins.GPIO_PIN_D2, false), new OutputPort(Pins.GPIO_PIN_D7, false), new OutputPort(Pins.GPIO_PIN_D8, false) }; SideLength = 6; TlcChannelCount = 112; }
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); } }
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); }
/// <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 var spiConfig = new SPI.Configuration(csPin, false, 0, 0, true, true, 10000, spiModule); _spi = new SPI(spiConfig); Init(); }
public CpuProgrammer() { if (Instance != null) { throw new InvalidOperationException(); } Instance = this; //_spiConfig = new SPI.Configuration( // SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D10, // false, // 0, // 0, // false, // true, // 5000, // SPI_Devices.SPI1); _spiConfig = new SPI.Configuration( SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D10, false, 20, 20, false, true, 2000, SPI_Devices.SPI1); _spi = new SPI(_spiConfig); }
public static void Main() { SPI.Configuration spiConfig = new SPI.Configuration( Pins.GPIO_PIN_D2, false, 100, 100, false, true, 1000, SPI.SPI_module.SPI1 ); spi = new SPI(spiConfig); GP = new GpioPwm(spi); GP.PwmStop(); byte channel; for (channel = 0; channel < 32; channel++) { GP.SetPwmParameter(channel, GpioPwm.PwmParameter.Rise, 0); GP.SetPwmParameter(channel, GpioPwm.PwmParameter.Fall, 0); GP.SetPwmParameter(channel, GpioPwm.PwmParameter.Period, 10000); GP.SetPinType(channel, GpioPwm.PinType.Input); } for (channel = 32; channel < 64; channel++) { GP.SetPinType(channel, GpioPwm.PinType.Input); } GP.SetGroupPin(GpioPwm.PinGroup.Lower, 0); GP.SetGroupPin(GpioPwm.PinGroup.Upper, 0); GP.PwmGo(); pwmRunning = true; new Program(); }
public AudioShield(SPI.SPI_module module, Cpu.Pin dataSelectPin, Cpu.Pin cmdSelectPin, Cpu.Pin dreqPin) { dataConfig = new SPI.Configuration(dataSelectPin, false, 0, 0, false, true, 2000, module, dreqPin, false); cmdConfig = new SPI.Configuration(cmdSelectPin, false, 0, 0, false, true, 2000, module, dreqPin, false); dreq = new InputPort(dreqPin, false, Port.ResistorMode.PullUp); spi = new SPI(cmdConfig); }
public static void Main() { SPI.Configuration spiConfig = new SPI.Configuration( Pins.GPIO_PIN_D0, false, 100, 100, false, true, 1000, SPI.SPI_module.SPI1 ); var spi = new SPI(spiConfig); var TxBuffer = new byte[6]; var RxBuffer = new byte[6]; PWMStop(spi); int i = 0; for (i = 0; i < 32; i++) { SetPWM(spi, (byte)i, i, i + 1, 80); } // SetPWM(spi, 0, 1, 9, 13); SetTerminate(spi, 0); PWMStart(spi); GreenLEDOn(spi); }
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 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); } }
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 void Deselect() { CurrentConfig = new SPI.Configuration(CurrentConfig.ChipSelect_Port, false, CurrentConfig.ChipSelect_SetupTime, CurrentConfig.ChipSelect_HoldTime, CurrentConfig.Clock_IdleState, CurrentConfig.Clock_Edge, CurrentConfig.Clock_RateKHz, CurrentConfig.SPI_mod); }
public static void Main() { SPI.Configuration[] max6675SpiCfg; // variables that will be used to extract the information from // the incoming serial bits from the MAX6675 chip byte[] outBfr = new byte[2]; byte[] inBfr = new byte[2]; // data will be used to store the extracted information short data; double tempF; double tempC; double tempK; int count = 0; max6675SpiCfg = new SPI.Configuration[1]; max6675SpiCfg[0] = new SPI.Configuration( Pins.GPIO_PIN_D8, // CS to digtalOut pin 9 false, // CS pin active state 0, // CS port set up time 0, // CS port hold time false, // Idle state of clock true, // Signal edge to sample on 1000, // Clock speed in KHz SPI_Devices.SPI1 // Using SPI bus 1 ); // Creating a new instance of SPI object max6675Spi = new SPI (max6675SpiCfg[0]); //Reading from MAX6675 board and displaying data while(true) { max6675Spi.Config = max6675SpiCfg[0]; max6675Spi.WriteRead(outBfr, inBfr); data = (short) (inBfr[0] << 5 | inBfr[1] >> 3); tempC = data / 4.0; tempK = tempC + 273.15; tempF = tempC * 1.8 + 32.0; // using debug to output the information to the computer screen Debug.Print(" Reading:" + count.ToString("F")); Debug.Print(" Temp F:" + tempF.ToString("F")); Debug.Print(" Temp C:" + tempC.ToString("F")); Debug.Print(" "); Thread.Sleep(500); count++; } }
public void Initialize() { var spiConfig = new SPI.Configuration(_chipSelect, false, 0, 0, false, true, 12000, _spiModule); var spi = new SPI(spiConfig); // Instantiate the block driver var driver = new FL164KIF01BlockDriver(spi, Oxygen.Hardware.UserLed, 4); // Instantiate the file system passing the block driver for the underlying storage medium _tfs = new TinyFileSystem(driver); }
public SpiFloorIndicator(SPI.SPI_module module, FEZ_Pin.Digital latchPin) { var config = new SPI.Configuration(Cpu.Pin.GPIO_NONE, false, 0, 0, false, true, 200, module); spi = new SPI(config); latch = new OutputPort((Cpu.Pin) latchPin, true); CurrentFloor = 1; timer = new ExtendedTimer(UpdateIndicator, null, DateTime.Now, TimeSpan.FromTicks(25 * TimeSpan.TicksPerMillisecond)); }
/// <summary> /// Start SPI operations. Forces RPi SPI0 pins P1-19 (MOSI), P1-21 (MISO), /// P1-23 (CLK), P1-24 (CE0) and P1-26 (CE1) to alternate function ALT0, /// which enables those pins for SPI interface. You should call bcm2835_spi_end() /// when all SPI funcitons are complete to return the pins to their default functions /// </summary> /// <param name="config"></param> public SPI(SPI.Configuration config) { this.config = config; // initialize the io string[] arg = { "gpio", "load", "spi" }; main(3, arg); //configure the right speed if (wiringPiSPISetup(config.SPI_mod, (int)(config.Clock_RateKHz * 1000)) < 0) { throw new Exception("Unable to initialize bcm2835.so library"); } }
/// <summary> /// Initializes a new SPI device /// </summary> /// <param name="config">The SPI-module configuration</param> public SPIExtension(SPI.Configuration config, bool useSoftwareChipSelect = false) { // The timing of the Netduino pin 4, Netduino Plus pin 4 and Netduino Mini pin 13 have a small bug, probably in the IC or NETMF itself. // // They all refer to the same pin ID on the AT91SAM7X512: (int)12 // - SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D4 // - SecretLabs.NETMF.Hardware.NetduinoPlus.Pins.GPIO_PIN_D4 // - SecretLabs.NETMF.Hardware.NetduinoMini.Pins.GPIO_PIN_13 // // To work around this problem we use a software chip select. A bit slower, but it works. // We will include this work-around until the actual bug is fixed. bool SoftwareChipSelect = false; //if ((int)config.ChipSelect_Port == 12 && ( // Tools.HardwareProvider == "Netduino" || Tools.HardwareProvider == "NetduinoMini" || Tools.HardwareProvider == "NetduinoPlus" //)) //{ // Debug.Print("MultiSPI: Software ChipSelect enabled to prevent timing issues"); // Debug.Print("MultiSPI: See http://netduino.codeplex.com/workitem/3 for more"); // SoftwareChipSelect = true; //} // Sets the configuration in a local value this.spiConfiguration = config; // When we use a software chipset we need to record some more details if (SoftwareChipSelect) { this.softwareCS = new OutputPort(config.ChipSelect_Port, !config.ChipSelect_ActiveState); this.softwareCS_ActiveState = config.ChipSelect_ActiveState; this.useSoftwareCS = true; // Copies the Configuration, but without Chip Select pin this.spiConfiguration = new SPI.Configuration( Cpu.Pin.GPIO_NONE, spiConfiguration.BusyPin_ActiveState, spiConfiguration.ChipSelect_SetupTime, spiConfiguration.ChipSelect_HoldTime, spiConfiguration.Clock_IdleState, spiConfiguration.Clock_Edge, spiConfiguration.Clock_RateKHz, spiConfiguration.SPI_mod, spiConfiguration.BusyPin, spiConfiguration.BusyPin_ActiveState ); } // If no SPI Device exists yet, we create it's first instance if (spiDevice == null) { // Creates the SPI Device spiDevice = new SPI(this.spiConfiguration); } }
/// <summary> /// Code for using a 74HC595 Shift Register /// </summary> /// <param name="latchPin">Pin connected to register latch on the 74HC595</param> /// <param name="spiModule">SPI module being used to send data to the shift register</param> public ShiftRegister74HC595(Cpu.Pin latchPin, SPI.SPI_module spiModule, uint speedKHz = 1000) { var spiConfig = new SPI.Configuration( SPI_mod: spiModule, ChipSelect_Port: latchPin, ChipSelect_ActiveState: false, ChipSelect_SetupTime: 0, ChipSelect_HoldTime: 0, Clock_IdleState: false, Clock_Edge: true, Clock_RateKHz: speedKHz ); Spi = new SPI(spiConfig); }
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); }
public SpiDevice() { SPI.Configuration config = new SPI.Configuration(Pins.GPIO_NONE, // Verify these values! false, 0, 0, false, false, 48000, SPI_Devices.SPI1); _device = new SPI(config); }
public L3G4200D() { // write your code here spi_settings = new SPI.Configuration(SecretLabs.NETMF.Hardware.NetduinoPlus.Pins.GPIO_PIN_D9 , true , 100 , 0 , false , true , 100 , SPI_Devices.SPI1 ); gyro_module = new SPI(spi_settings); }
public Shifter74Hc595LcdTransferProvider(SPI.SPI_module spiBus, Cpu.Pin latchPin, BitOrder bitOrder) { _bitOrder = bitOrder; var spiConfig = new SPI.Configuration( latchPin, false, // active state 0, // setup time 0, // hold time false, // clock idle state true, // clock edge 1000, // clock rate spiBus); _spi = new SPI(spiConfig); }
public Lis302Dl(SPI.SPI_module spiModule, Cpu.Pin chipSelect) { var spiCfg = new SPI.Configuration(chipSelect, false, 0, 0, //5,8 true, true, 5000, spiModule); _spi = new SPI(spiCfg); byte[] whoAmI = Read(WhoAmiReg, 1); if (whoAmI[0] != 0x3B) throw new InvalidOperationException("LIS302DL not available"); Write(CtrlReg1, 0x47); _currentSensitivity = ToSensitivity(Scale.Full2K3); }
public static void Main() { SPI.Configuration spiConfig = new SPI.Configuration( Pins.GPIO_PIN_D2, false, 100, 100, false, true, 1000, SPI.SPI_module.SPI1 ); var spi = new SPI(spiConfig); var GP = new GpioPwm(spi); // LEDThrob(GP); ButtonLED(GP); }
public static void Main() { InterruptPort przycisk = new InterruptPort(Pins.GPIO_PIN_A_0, false, Port.ResistorMode.PullDown, Port.InterruptMode.InterruptEdgeLevelHigh);//przycisk var green = new PWM(Cpu.PWMChannel.PWM_0, 300, 0, false);//zielona var orange = new PWM(Cpu.PWMChannel.PWM_1, 300, 0, false);//pomaranczowa var red = new PWM(Cpu.PWMChannel.PWM_2, 300, 0, false); //czerwona var blue = new PWM(Cpu.PWMChannel.PWM_3, 300, 0, false);//niebieska green.Start(); orange.Start(); red.Start(); blue.Start(); int x = 0, y = 0, z = 0; var timer = new System.Threading.Timer(TimerCallback, null, 0, 1000); SPI.Configuration MyConfig = new SPI.Configuration(Pins.GPIO_PIN_E_3, false, 0, 0, true, true, 1000, SPI.SPI_module.SPI1); MySPI = new SPI(MyConfig); Config(); while (true) { red.DutyCycle = 0; green.DutyCycle = 0; blue.DutyCycle = 0; orange.DutyCycle = 0; if((ReadRegister(0x2D)>150)&&(ReadRegister(0x2D)<230)) { red.DutyCycle = 1; green.DutyCycle = 1; blue.DutyCycle = 1; orange.DutyCycle = 1; } if ((ReadRegister(0x29) > 160) && (ReadRegister(0x29) < 230)) blue.DutyCycle = 1; if ((ReadRegister(0x29) < 140) && (ReadRegister(0x29) > 20)) orange.DutyCycle = 1; if ((ReadRegister(0x2B) > 160) && (ReadRegister(0x2B) < 230)) red.DutyCycle = 1; if ((ReadRegister(0x2B) < 140) && (ReadRegister(0x2B) > 20)) green.DutyCycle = 1; x = DateTime.Now.Millisecond; if (x + 200 >= 999) x -= 999; Debug.Print(ReadRegister(0x29).ToString() + " " + ReadRegister(0x2B).ToString() + " " + ReadRegister(0x2D).ToString() + " " + x); while (DateTime.Now.Millisecond<= x + 200) { } } }
public Shifter74Hc595LcdTransferProvider(SPI.SPI_module spiBus, Cpu.Pin latchPin, BitOrder bitOrder, ShifterSetup setup) : base(setup) { _bitOrder = bitOrder; var spiConfig = new SPI.Configuration( Cpu.Pin.GPIO_NONE, //latchPin, false, // active state 0, // setup time 0, // hold time false, // clock idle state true, // clock edge 1000, // clock rate spiBus); _spi = new SPI(spiConfig); _latchPort = new OutputPort(latchPin, true); }
public AD5206(Cpu.Pin csPin) { Configuration = new SPI.Configuration( csPin, // /CS pin false, // /CS active LOW 0, // /CS setup time 0, // /CS hold time false, // clock low on idle true, // rising edge data 1000, // SPI clock rate in KHz SPI_Devices.SPI1 // MOSI MISO and SCLK pinset ); if (SPI == null) { SPI = new SPI(Configuration); } }
public AdaFruitSSD1306(Cpu.Pin dc, Cpu.Pin reset, Cpu.Pin chipSelect, SPI.SPI_module spiModule = SPI.SPI_module.SPI1, uint speedKHz = 10000) { AutoRefreshScreen = false; 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 ); dcPin = new OutputPort(dc, false); resetPin = new OutputPort(reset, false); }
public LPD6803(SPI.SPI_module spiModule, int numPixels) { var spiConfig = new SPI.Configuration(Cpu.Pin.GPIO_NONE, true, 0, 0, false, true, 500, spiModule); spi = new SPI(spiConfig); NumPixels = numPixels; // On a LPD6803, the PWM counter is shared with the data pin. // This means, when we send data, we must align the data to 256 bits (32 bytes, 16 ushorts) // We also have to consider the 4 byte header. var bufferLength = numPixels + 2; var alignment = 32 - (bufferLength % 32); bufferLength += alignment; Debug.Assert(bufferLength % 32 == 0); buffer = new ushort[bufferLength]; new Thread(WriteLoop).Start(); }
public LPD6803(SPI.SPI_module spiModule, int numPixels) { var spiConfig = new SPI.Configuration(Cpu.Pin.GPIO_NONE, true, 0, 0, false, true, 500, spiModule); spi = new SPI(spiConfig); NumPixels = numPixels; // On a LPD6803, the PWM counter is shared with the data pin. // This means, when we send data, we must align the data to 256 bits (32 bytes, 16 ushorts) // We also have to consider the 4 byte header. var bufferLength = numPixels + 2; var alignment = 32 - (bufferLength % 32); bufferLength += alignment; Debug.Assert(bufferLength % 32 == 0); buffer = new ushort[bufferLength]; oc = new OutputCompare((Cpu.Pin) FEZ_Pin.Digital.Di10, false, 2); oc.Set(false, new uint[] {1, 1}, 0, 2, true); }
public Md5Chip() { if (Instance != null) { throw new InvalidOperationException(); } Instance = this; _spiConfig = new SPI.Configuration( SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D10, false, 0, 0, false, true, 5000, SPI_Devices.SPI1); _spi = new SPI(_spiConfig); }