コード例 #1
0
        public static void FindNanoPad()
        {
            if (UtilValues.PublicValue.nanoPads.Length != 0)
            {
                Array.Clear(UtilValues.PublicValue.nanoPads, 0, UtilValues.PublicValue.nanoPads.Length);
                Array.Resize(ref UtilValues.PublicValue.nanoPads, 0);
            }
            HIDDevice.interfaceDetails[] Pads = HIDDevice.getConnectedPads();
            foreach (HIDDevice.interfaceDetails Pad in Pads)
            {
                SayobotNanoPad pad = new SayobotNanoPad
                {
                    devicePath = Pad.devicePath,
                    ProductID  = Pad.PID
                };
                pad.ReadingPadSettings();
                HIDDevice PadDevice = new HIDDevice(pad.devicePath, false);
                byte[]    writeData = CalcSHA(new byte[] { 0x02, 0x00, 0x00 });
                PadDevice.write(writeData);
                System.Threading.Thread.Sleep(100);
                byte[] readData = PadDevice.read();
                if (readData[1] == 0)
                {
                    pad.OSVersion = readData[4].ToString();
                }
                else
                {
                    pad.OSVersion = "Unknown";
                }

                writeData = CalcSHA(new byte[] { 0x02, 0x08, 0x01, 0x00 });
                PadDevice.write(writeData);
                System.Threading.Thread.Sleep(100);
                readData = PadDevice.read();
                if (readData[0] != 0xff)
                {
                    byte[] nameEncode = new byte[readData[2]];
                    Array.Copy(readData, 3, nameEncode, 0, readData[2]);
                    nameEncode = ChangeToSystemUnicodeEncoding(nameEncode);
                    pad.Name   = Encoding.Unicode.GetString(nameEncode);
                }
                else
                {
                    pad.Name = Pad.product;
                }

                PadDevice.close();

                Array.Resize(ref UtilValues.PublicValue.nanoPads, UtilValues.PublicValue.nanoPads.Length + 1);
                UtilValues.PublicValue.nanoPads[UtilValues.PublicValue.nanoPads.Length - 1] = pad;
            }
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: xbwpc/hid-sharp
        // Apologies for the repeated code, however i feel it provides a better demonstration
        // of the functionality of this code.
        public void useSynchronousOperation()
        {
            //Get the details of all connected USB HID devices
            HIDDevice.interfaceDetails[] devices = HIDDevice.getConnectedDevices();

            //Arbitrarily select one of the devices which we found in the previous step
            //record the details of this device to be used in the class constructor
            int    selectedDeviceIndex = 0;
            ushort VID        = devices[selectedDeviceIndex].VID;
            ushort PID        = devices[selectedDeviceIndex].PID;
            int    SN         = devices[selectedDeviceIndex].serialNumber;
            string devicePath = devices[selectedDeviceIndex].devicePath;

            //create a handle to the device by calling the constructor of the HID class
            //This can be done using either the VID/PID/Serialnumber, or the device path (string)
            //all of these details are available from the HIDDevice.interfaceDetails[] struct array created above
            //The "false" boolean in the constructor tells the class we only want synchronous operation
            HIDDevice device = new HIDDevice(devicePath, false);

            //OR, the normal usage when you know the VID and PID of the device
            //HIDDevice device = new HIDDevice(VID, PID, (ushort)SN, false);

            //Write some data to the device (the write method throws an exception if the data is longer than the report length
            //specified by the device, this length can be found in the HIDDevice.interfaceDetails struct)
            byte[] writeData = { 0x00, 0x01, 0x02, 0x03, 0x04 };
            device.write(writeData);    //Its that easy!!

            //Read some data synchronously from the device. This method blocks the calling thread until the data
            //is returned. This takes 1-20ms for most HID devices
            byte[] readData = device.read();    //again, that easy!

            //close the device to release all handles etc
            device.close();
        }
コード例 #3
0
        public bool startAsyncOperation(ushort MyDevVID, ushort MyDevPID)
        {
            //Get the details of all connected USB HID devices
            HIDDevice.interfaceDetails[] devices = HIDDevice.getConnectedDevices();


            //Arbitrarily select one of the devices which we found in the previous step
            //record the details of this device to be used in the class constructor
            int selectedDeviceIndex = -1;

            for (int i = 0; i < devices.Length; i++)
            {
                if ((devices[i].VID == MyDevVID) && (devices[i].PID == MyDevPID))
                {
                    selectedDeviceIndex = i;
                }
            }

            if (selectedDeviceIndex == -1)
            {
                return(false);
            }

            ushort VID        = devices[selectedDeviceIndex].VID;
            ushort PID        = devices[selectedDeviceIndex].PID;
            int    SN         = devices[selectedDeviceIndex].serialNumber;
            string devicePath = devices[selectedDeviceIndex].devicePath;

            //create a handle to the device by calling the constructor of the HID class
            //This can be done using either the VID/PID/Serialnumber, or the device path (string)
            //all of these details are available from the HIDDevice.interfaceDetails[] struct array created above
            //The "true" boolean in the constructor tells the class we want asynchronous operation this time
            device = new HIDDevice(devicePath, true);

            //OR, the normal usage when you know the VID and PID of the device
            //HIDDevice device = new HIDDevice(VID, PID, (ushort)SN, true);

            //next create the event handler for the incoming reports
            device.dataReceived += new HIDDevice.dataReceivedEvent(device_dataReceived);

            //Write some data to the device (the write method throws an exception if the data is longer than the report length
            //specified by the device, this length can be found in the HIDDevice.interfaceDetails struct)
            //The write method is identical to the synchronous mode of operation
            byte[] writeData = new byte[64];
            for (int i = 0; i < writeData.Length; i++)
            {
                writeData[i] = Convert.ToByte(i + 100);
            }

            device.write(writeData);    //Its that easy!!

            //Send your program off to do other stuff here, wait for UI events etc
            //When a report occurs, the device_dataReceived(byte[] message) method will be called
            //System.Threading.Thread.Sleep(100);

            //close the device to release all handles etc
            //device.close();
            return(true);
        }
コード例 #4
0
 private void button1_Click(object sender, EventArgs e)
 {
     if (OpenedPad != null)
     {
         OpenedPad.write(PadDevUtil.StringToByte(skinTextBox1.Text));
         System.Threading.Thread.Sleep(100);
         skinTextBox2.Text = PadDevUtil.ToHexString(OpenedPad.read());
     }
     else
     {
         skinTextBox2.Text = "没有连接触盘";
     }
 }
コード例 #5
0
 public void sendData(USB_ConfigReport config)
 {
     if (connected)
     {
         byte[] writeData = encodeConfigReport(config);
         try
         {
             device.write(241, writeData);    // F1 = 241   output reportid
         }
         catch (Exception)
         {
             Console.WriteLine("Cant send data!");
         }
     }
 }
コード例 #6
0
    protected bool receiveThread()
    {
        if (!isDeviceConnect())
        {
            return(true);
        }
        const int MaxRecvCount = 32;

        if (mRecvBytes == null)
        {
            mRecvBytes = new byte[MaxRecvCount];
        }
        // 只接收23个字节,如果不是23个字节,则丢弃该数据
        int readCount = mHIDDevice.read(ref mRecvBytes, 23);

        if (readCount != 0)
        {
            BinaryUtility.memmove(ref mRecvBytes, 0, 1, MaxRecvCount - 1);
            readCount -= 4;
            // 去除第一个字节和最后3个字节
            mInputBufferLock.waitForUnlock();
            addDataToInputBuffer(mRecvBytes, readCount);
            mInputBufferLock.unlock();
        }

        // 先同步发送列表
        mSendPacketLock.waitForUnlock();
        int count = mSendPacket.Count;

        for (int i = 0; i < count; ++i)
        {
            mOutputBufferList.Add(mSendPacket[i].toBytes());
        }
        mSendPacket.Clear();
        mSendPacketLock.unlock();
        // 发送所有需要发送的数据
        int sendCount = mOutputBufferList.Count;

        for (int i = 0; i < sendCount; ++i)
        {
            if (mOutputBufferList[i] != null)
            {
                mHIDDevice.write(mOutputBufferList[i]);
            }
        }
        mOutputBufferList.Clear();
        return(true);
    }
コード例 #7
0
        public void ReadingPadSettings()
        {
            HIDDevice Pad = new HIDDevice(devicePath, false);
            //读取按键信息
            const int countKey = 6;

            padKeys = new PadKeys[countKey];
            for (byte keyNo = 0; keyNo < countKey; keyNo++)
            {
                byte[] sendInformation = { 02, 06, 02, 00, keyNo };
                Pad.write(StaticUtilFunctions.CalcSHA(sendInformation));
                System.Threading.Thread.Sleep(100);
                byte[] receiveInformation = Pad.read();
                byte   ControlKey         = receiveInformation[7];
                byte   CharKey            = receiveInformation[8];
                this.padKeys[keyNo].charKeys = (PadSetConstValue.Keys.CharKeys)CharKey;

                //解析Control按键
                for (byte exp = 7; exp >= 0; exp--)
                {
                    if (ControlKey >= (1 << exp))
                    {
                        ControlKey -= (byte)(1 << exp);
                        this.padKeys[keyNo].controlKeys.SetValue(true, exp);
                    }
                }
            }
            //读取灯光信息
            const int countLight = 5;

            padLights = new PadLights[countLight];
            for (byte lightNo = 0; lightNo < countLight; lightNo++)
            {
                byte[] sendInformation = { 02, 07, 02, 00, lightNo };
                Pad.write(StaticUtilFunctions.CalcSHA(sendInformation));
                System.Threading.Thread.Sleep(100);
                byte[] receiveInformation = Pad.read();
                byte   LightData          = receiveInformation[7];
                this.padLights[lightNo].Speed = (PadSetConstValue.Light.Speed)(LightData << 6);
                byte LightMode = (byte)(LightData - (LightData << 6));
                if (LightMode >= 0x3a)
                {
                    padLights[lightNo].Mode         = PadSetConstValue.Light.Mode.Unknown;
                    padLights[lightNo].ColorMode    = PadSetConstValue.Light.ColorMode.Unknown;
                    padLights[lightNo].CustomColors = new Color[0];
                }
                else
                {
                    var PadSystemLightModes = Enum.GetValues(typeof(PadSetConstValue.Light.Mode));
                    for (int tmp = PadSystemLightModes.Length; tmp > 0; tmp--)
                    {
                        if (LightMode > (byte)PadSystemLightModes.GetValue(tmp - 1))
                        {
                            padLights[lightNo].Mode = (PadSetConstValue.Light.Mode)PadSystemLightModes.GetValue(tmp - 1);
                            try
                            {
                                padLights[lightNo].ColorMode = (PadSetConstValue.Light.ColorMode)
                                                               LightMode - (byte)padLights[lightNo].Mode;
                            }
                            catch (Exception)
                            {
                                padLights[lightNo].ColorMode = PadSetConstValue.Light.ColorMode.Unknown;
                            }
                        }
                    }
                }
            }
        }
コード例 #8
0
ファイル: CMCU.cs プロジェクト: leakkari/GUI-DesignProject
 // Used to communicate with the MCU. Can send bytes through USB
 public void SendReport(byte[] Report)
 {
     device.write(Report);
 }
コード例 #9
0
        void Send_HID_Data_PC_to_MCU()
        {
            byte[] writeData = new byte[64];
            //for (int i = 0; i < writeData.Length; i++)
            //{
            //    writeData[i] = Convert.ToByte(i + 100);
            //}

            writeData[0] = 0x55;

            if (ckReceiveData.Checked)
            {
                writeData[1] = 1;
            }
            else
            {
                writeData[1] = 0;
            }

            if (ckLED1.Checked)
            {
                writeData[2] = 1;
            }
            else
            {
                writeData[2] = 0;
            }

            if (ckLED2.Checked)
            {
                writeData[3] = 1;
            }
            else
            {
                writeData[3] = 0;
            }


            if (ckLED3.Checked)
            {
                writeData[4] = 1;
            }
            else
            {
                writeData[4] = 0;
            }

            writeData[5] = Convert.ToByte(tBarServo.Value);

            int MyINTVal = 0;

            if (txtU32ValOut.Text != "")
            {
                MyINTVal = Convert.ToInt32(txtU32ValOut.Text);
            }



            writeData[6] = (byte)(MyINTVal & 0xff);
            writeData[7] = (byte)((MyINTVal >> 8) & 0xff);
            writeData[8] = (byte)((MyINTVal >> 16) & 0xff);
            writeData[9] = (byte)((MyINTVal >> 24) & 0xff);

            float MyFloatVal = 0;

            if (txtfloatValOut.Text != "")
            {
                MyFloatVal = float.Parse(txtfloatValOut.Text, CultureInfo.InvariantCulture.NumberFormat);
            }
            byte[] FloatBytes = BitConverter.GetBytes(MyFloatVal);
            writeData[10] = FloatBytes[0];
            writeData[11] = FloatBytes[1];
            writeData[12] = FloatBytes[2];
            writeData[13] = FloatBytes[3];

            device.write(writeData);
        }