public NavXMXP_SPI(SPI.Port port, byte updateRate = 50)
        {
            m_spi = new SPI(port);
            Thread.Sleep(250);
            //Read(DeviceRegister.WHOAMI, 2);
            //Read(DeviceRegister.WHOAMI, 2);
            Thread.Sleep(250);

        }

 public static extern int SystemParametersInfo(
     SPI Action,
     uint Param,
     ref int result,
     int updateIni
     );

 public TestADXRS450(SPI.Port port)
 {
     m_gyro = new ADXRS450_Gyro(port);
     m_port = (int)port;
     started = true;
 }

 public static extern bool SystemParametersInfo(SPI uiAction, uint uiParam, ref ANIMATIONINFO pvParam, SPIF fWinIni);

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

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

 private static extern bool _SystemParametersInfo_NONCLIENTMETRICS(SPI uiAction, int uiParam, [In, Out] ref NONCLIENTMETRICS pvParam, SPIF fWinIni);

 public static extern bool SystemParametersInfo(SPI uiAction, uint uiParam, ref MINIMIZEDMETRICS pvParam, uint fWinIni);

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

 public RegisterIO_SPI(SPI spi_port, int bitrate)
 {
     port = spi_port;
     this.bitrate = bitrate;
 }

 public TestADXL362(SPI.Port port)
 {
     m_accel = new ADXL362(port, AccelerometerRange.k2G);
     m_port = (int) port;
     started = true;
 }

 private static extern bool SystemParametersInfo(SPI uiAction, uint uiParam, IntPtr pvParam, SPIF fWinIni);

 public static void SystemParametersInfo(SPI uiAction, int uiParam, string pvParam, SPIF fWinIni)
 {
     if (!_SystemParametersInfo_String(uiAction, uiParam, pvParam, fWinIni))
     {
         HRESULT.ThrowLastError();
     }
 }

 private static extern bool _SystemParametersInfo_HIGHCONTRAST(SPI uiAction, int uiParam, [In, Out] ref HIGHCONTRAST pvParam, SPIF fWinIni);

 private static extern bool _SystemParametersInfo_String(SPI uiAction, int uiParam, [MarshalAs(UnmanagedType.LPWStr)] string pvParam, SPIF fWinIni);

 /// <summary>
 /// Constructs the AHRS class using SPI Communication, overriding the SPI bitrate.
 /// </summary>
 /// <remarks>
 /// The update rate may be between 4 Hz and 60 Hz, representing the number
 /// of updates per second sent by the sensor.
 /// <para/>
 /// This constructor should be used if communicating via SPI.
 /// <para/>
 /// Note that increasing the update rate may increase the CPU utilization.
 /// </remarks>
 /// <param name="spiPortId">The <see cref="SPI.Port">SPI Port</see> to use.</param>
 /// <param name="spiBitrate">The SPI bitrate to use (bits/seconds) (Maximum: 2,000,000)</param>
 /// <param name="updateRateHz">The Update Rate (Hz) [4..60] (Default 50)</param>
 public AHRS(SPI.Port spiPortId, int spiBitrate, byte updateRateHz = NavxDefaultUpdateRateHz)
 {
     CommonInit(updateRateHz);
     if (RobotBase.IsSimulation)
     {
         m_io = new SimulatorIO(updateRateHz, m_ioCompleteSink, m_boardCapabilities);
     }
     else
     {
         m_io = new RegisterIO(new RegisterIO_SPI(new SPI(spiPortId), spiBitrate), updateRateHz, m_ioCompleteSink,
             m_boardCapabilities);
     }
     m_ioThread.Start();
 }