C# Main.UsbSetupPacket类代码示例

 public bool TurnOffLight(LightColour colour)
 {
     var modifiedColour = (short)colour * 0x100;
     var packet = new UsbSetupPacket(0x48, 0x12, (short)0x0c0a, (short)modifiedColour, (short)0x0000);
     int temp2;
     return MyUsbDevice.ControlTransfer(ref packet, new byte[0], 0, out temp2);
 }

 /// <summary>
 /// Read analog voltage from a spesific channel
 /// </summary>
 /// <param name="channel">0 for RESET pin, 1 for SCK pin, 2 for internal Temperature sensor</param>
 /// <returns>Analog voltage in 10bit resoultion</returns>
 public ushort analogRead(byte channel)
 {
     byte[] buffer_ = new byte[8];
     int whatIsThis = 8;
     MySetupPacket = new UsbSetupPacket(0xC0, 15, channel, 0, 8);
     MyUsbDevice.ControlTransfer(ref MySetupPacket, buffer_, 8, out whatIsThis);
     return (ushort)((buffer_[1] <<8) + (buffer_[0]));
 }

 public override bool ControlTransfer(SafeHandle InterfaceHandle,
                                      UsbSetupPacket SetupPacket,
                                      IntPtr Buffer,
                                      int BufferLength,
                                      out int LengthTransferred)
 {
     return WinUsb_ControlTransfer(InterfaceHandle, SetupPacket, Buffer, BufferLength, out LengthTransferred, IntPtr.Zero);
 }

        /// <summary>
        /// Always returns 0x22 (34) so far
        /// </summary>
        /// <returns></returns>
        public ushort GetInitStatus()
        {
            UsbSetupPacket setup = new UsbSetupPacket(0xC0, 0x10, 0x0, 0x0, 0x1);
            int len = 0;

            byte[] buf = new byte[1];
            MyUsbDevice.ControlTransfer(ref setup, buf, (ushort)buf.Length, out len);

            return buf[0];
        }

        public void SetTilt(sbyte tiltValue)
        {
            if (!MyUsbDevice.IsOpen)
            {
                InitDevice();
            }
            ushort mappedValue = (ushort)(0xff00 | (byte)tiltValue);

            UsbSetupPacket setup = new UsbSetupPacket(0x40, 0x31, mappedValue, 0x0, 0x0);
            int len = 0;
            MyUsbDevice.ControlTransfer(ref setup, IntPtr.Zero, 0, out len);
        }

 public override bool ControlTransfer(SafeHandle interfaceHandle,
                                      UsbSetupPacket setupPacket,
                                      IntPtr buffer,
                                      int bufferLength,
                                      out int lengthTransferred)
 {
     return LibUsbDriverIO.ControlTransfer(interfaceHandle,
                                           setupPacket,
                                           buffer,
                                           bufferLength,
                                           out lengthTransferred,
                                           UsbConstants.DEFAULT_TIMEOUT);
 }

        public unsafe override void GetFeature(byte[] buffer, int offset, int count)
        {
            Throw.If.OutOfRange(buffer, offset, count);
			
			try
			{
				UsbSetupPacket packet = new UsbSetupPacket (0x80 | 0x20, buffer[offset], (short)0x1, 0, 33);

				int transferred;

				_device.ControlTransfer (ref packet, buffer, count, out transferred);
			}
			finally
			{
			}
        }

        public static Boolean checkProtocol(UsbDevice device)
        {
            Boolean r = false;

            string message = "";
            short messageLength = 2;

            UsbSetupPacket setupPacket = new UsbSetupPacket();
            setupPacket.RequestType = (byte)((byte)UsbConstants.USB_DIR_IN | (byte) UsbConstants.USB_TYPE_VENDOR);
            setupPacket.Request = (byte)ACCESSORY_GET_PROTOCOL;
            setupPacket.Value = 0;
            setupPacket.Index = 0;
            setupPacket.Length = 0;

            int resultTransferred;

            r = device.ControlTransfer(ref setupPacket, message, messageLength, out resultTransferred);

            return r;
        }

        private static void SetFnKeyMode(FnKeyMode mode)
        {
            UsbDevice keyboard = null;

            try
            {
                keyboard = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(0x046d, 0xc31f));

                if (keyboard == null)
                {
                    throw new KeyboardNotFoundException("Could not find Logitech K290 device. It's not connected or libusb-win32 is not installed.");
                }

                var setupPacket = new UsbSetupPacket(0x40, 2, 0x001a, (short)mode, 0);
                int sentBytesCount;

                if (keyboard.ControlTransfer(ref setupPacket, null, 0, out sentBytesCount) == false)
                {
                    throw new ApplicationException(
                        string.Format(
                            "Error transferring control data to the device. Code: {0}. Message: {1}.",
                            UsbDevice.LastErrorNumber,
                            UsbDevice.LastErrorString));
                }
            }
            catch
            {
                throw;
            }
            finally
            {
                if (keyboard != null)
                {
                    keyboard.Close();
                }

                UsbDevice.Exit();
            }
        }

		private void timer1_Tick(object sender, EventArgs e)
		{
			//double t = (ti++)/1000.0;
			//plotter.AddData(2);

			if (_usbDevice != null)
			{
				s.Restart();
				UsbSetupPacket setup = new UsbSetupPacket((byte)(UsbCtrlFlags.RequestType_Vendor | UsbCtrlFlags.Recipient_Device | UsbCtrlFlags.Direction_In), (byte)OUSBRequest.ReadADCBuffer, 0, 0, 0);
				int length;
				if (!_usbDevice.ControlTransfer(ref setup, buffer, buffer.Length, out length))
					usbDisconnected();
				else if (length >= 2)
				{
					double time = (double)BitConverter.ToInt16(buffer, 0) / 250000.0;
					if (plotter.SampleTime == 0) 
						plotter.SampleTime = time;
					else
						plotter.SampleTime = (plotter.SampleTime*19 + time)/20;

					//int time = BitConverter.ToInt16(buffer, 0);
					//lblOut.Text = time.ToString();
					//plotter.AddData(time);

					for (int i = 2; i<length; i += 2)
					{
						double adc = BitConverter.ToInt16(buffer, i) * 5.0 / 1024.0;
						plotter.AddData(adc);
					}
				}

				s.Stop();
				double elapsed = s.ElapsedTicks * 1000.0 / Stopwatch.Frequency;
				lblOut.Text = plotter.SampleTime.ToString();
			}
		}

        public void OnControlRequestReceived(ControlRequestEventArgs e)
        {
            if ((e.bmRequestType == 0x80) && (e.bRequest == 0x06))
              {
            //Descriptor request, let the other event handle it
              }
              else if ((e.bmRequestType == 0x00) && (e.bRequest == 0x05))
              {
            //Let the library handle it, needs it to set the address in the Teensy
              }
              else if ((e.bmRequestType == 0x00) && (e.bRequest == 0x09))
              {
            //Let the library handle it, needs it to configure the endpoints in the Teensy
              }
              else
              {
            //Issue the request to the real device, and return whatever it did
            var setup = new UsbSetupPacket((byte)e.bmRequestType, (byte)e.bRequest,
              (short)e.wValue, (short)e.wIndex, (short)e.wLength);
            int transferred;

            if ((e.bmRequestType & 0x80) > 0)
            {
              var ret = new byte[e.wLength];
              _forwardee.ControlTransfer(ref setup, ret, ret.Length, out transferred);
              e.ReturnData = new byte[transferred];
              Array.Copy(ret, 0, e.ReturnData, 0, e.ReturnData.Length);
            }
            else
            {
              _forwardee.ControlTransfer(ref setup, e.AttachedData, e.AttachedData.Length, out transferred);
            }

            e.Ignore = false;
              }
        }

    /// <summary>
    /// Sends command to uDMX
    /// </summary>
    /// <returns><c>true</c>, if command was sent, <c>false</c> otherwise.</returns>
    /// <param name="command">Command.</param>
    /// <param name="cvalue">Cvalue.</param>
    /// <param name="cindex">Cindex.</param>
    /// <param name="buffer">Buffer.</param>
    private bool SendCommand(Command command, short cvalue, short cindex, byte[] buffer)
    {
        bool result = false;
        int transfered;

        UsbSetupPacket packet = new UsbSetupPacket ();
        // This is alegedly ignored by the uDMX, but let's play nice
        packet.RequestType = (byte)UsbRequestType.TypeVendor | (byte)UsbRequestRecipient.RecipDevice | (byte)UsbEndpointDirection.EndpointOut;
        packet.Request = (byte)command;
        packet.Value = cvalue;
        packet.Index = cindex;
        packet.Length = cvalue;

        // create empty buffer if the buffer is null
        if (buffer == null)
          buffer = new byte[0];

        // Send data and get the result
        if (_device.ControlTransfer (ref packet, buffer, buffer.Length, out transfered))
        {
          result = true;
        }

        return result;
    }

        public static Byte[] ReadEepromBlock(UInt16 address, int length)
        {
            Byte[] data = new Byte[length];

            UsbSetupPacket packet = new UsbSetupPacket((byte)UsbRequestType.TypeVendor | (byte)UsbRequestRecipient.RecipDevice | (byte)UsbEndpointDirection.EndpointIn, (byte)Request.ReadEepromBlock, (short)address, 0, (short)data.Length);
            int transfered;
            device.ControlTransfer(ref packet, data, data.Length, out transfered);

            return data;
        }

        public static void Reboot()
        {
            UsbSetupPacket packet = new UsbSetupPacket((byte)UsbRequestType.TypeVendor | (byte)UsbRequestRecipient.RecipDevice | (byte)UsbEndpointDirection.EndpointOut, (byte)Request.Reboot, 0, 0, 0);
            int transfered;
            object buffer = null;
            device.ControlTransfer(ref packet, buffer, 0, out transfered);

            Disconnect();
        }

        private static Byte[] GetReport()
        {
            int expected = 8;
            Byte[] data = new Byte[expected];
            UsbSetupPacket packet = new UsbSetupPacket((byte)UsbRequestType.TypeVendor | (byte)UsbRequestRecipient.RecipDevice | (byte)UsbEndpointDirection.EndpointIn, (byte)Request.GetReport, 0, 0, 0);
            int transfered;
            device.ControlTransfer(ref packet, data, data.Length, out transfered);

            return data;
        }