public OLED_sh1106(ref SPI globalSPIDevice, OutputPort dcPin, OutputPort rsPin)
 {
     displayStr = "";
     spiDevice = globalSPIDevice;
     dataCommandPin = dcPin;
     resetOutputPort = rsPin;
 }

 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 DriverChip(Microsoft.SPOT.Hardware.SPI spi, byte address)
        {
            this.spi = spi;
            this.address = address;

            init();
        }

        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);
                }
            }
        }

 /// <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 static void Main()
        {
            int numLed = 32;
            var spi = new SPI(
                new SPI.Configuration(
                    Cpu.Pin.GPIO_NONE,
                    false,
                    0,
                    0,
                    false,
                    true,
                    2000,
                    SPI.SPI_module.SPI1));
            var colors = new byte[3 * numLed];
            var zeros = new byte[3 * ((numLed + 63) / 64)];

            while (true)
            {
                // all pixels off
                for (int i = 0; i < colors.Length; ++i) colors[i] = (byte)(0x80 | 0);
                // a progressive yellow/red blend
                for (byte i = 0; i < 32; ++i)
                {
                    colors[i * 3 + 1] = 0x80 | 32;
                    colors[i * 3 + 0] = (byte)(0x80 | (32 - i));
                    spi.Write(colors);
                    spi.Write(zeros);
                    Thread.Sleep(1000 / 32); // march at 32 pixels per second

                }
            }
        }

 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()
 {
     
     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);
        }

        public static void Initialize()
        {
            if (isInitialized)
                Shutdown();

            spi = new SPI(cmdConfig);
            reset = new OutputPort(Pins.GPIO_PIN_D13, true); // Unused pin.
            DREQ = new InputPort(Pins.GPIO_PIN_D3, false, Port.ResistorMode.PullUp);

            isInitialized = true;

            Reset();

            Command_Write(SCI_MODE, 0x800 | (1 << 2));
            Command_Write(SCI_CLOCKF, 7 << 13);
            Command_Write(SCI_VOL, 1);  // highest volume

            Debug.Print(Command_Read(SCI_VOL).ToString()); //  <------------ always returns 0

            if (Command_Read(SCI_VOL) != (0))
            {
                throw new Exception("Failed to initialize VS1053 encoder.");
            }

            spi.Config = dataConfig;
        }

 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;
 }

        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 GpioPwm(SPI spiInt)
 {
     Spi = spiInt;
     if (!IsGpioPwmCore())
     {
         throw(new SystemException("Tried to instantiate a GpioPwm class, but no GPIO/PWM core running on UberShield."));
     }
 }

        public LEDStripSpi()
        {
            NumOfLEDs = 32;

            _data = new SPI(new SPI.Configuration(Pins.GPIO_NONE, false, 0, 0, false, true, 100, SPI.SPI_module.SPI1));

            post_frame();
        }

    public static void Mount(string path, SPI.SPI_module spi, Cpu.Pin chipSelect, Cpu.Pin cardDetect)
    {
        if (_sdCardPath != null)
            throw new NotSupportedException();

        MountNative(path, (uint) spi, (uint) chipSelect, (uint) cardDetect);
        _sdCardPath = path;
    }

        /// <summary>
        /// Create a new instance of the RGBStrip.
        /// </summary>
        /// <param name="ledCount">Number of pixels (leds) in the strip.</param>
        /// <param name="spi">The spi object to use</param>
        public RGBStrip(int ledCount, SPI spi)
        {
            _spi = spi;
            DimFactor = 1;

            CreateBuffers(ledCount);
            SetupDimValueSwitch();
        }

        public void WriteInternal(SPI spi)
        {
            var data = GetData();
            if(data == null)
                return;

            spi.Config = Configuration;
            spi.Write(data);
        }

        public FL164KIF01(SPI spi)
        {
            _spi = spi;

            data1 = new byte[1];
            data2 = new byte[2];
            data4 = new byte[4];
            dataPage = new byte[PageSize + 4];
        }

        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();
        }