private int ReceiveRaw() { if (handle == IntPtr.Zero) { return(-2); } HIDapi.hid_set_nonblocking(handle, 0); byte[] raw_buf = new byte[report_len]; int ret = HIDapi.hid_read(handle, raw_buf, new UIntPtr(report_len)); if (ret > 0) { lock (reports) { reports.Enqueue(new Report(raw_buf, System.DateTime.Now)); } if (ts_en == raw_buf[1]) { DebugPrint(string.Format("Duplicate timestamp enqueued. TS: {0:X2}", ts_en), DebugType.THREADING); } ts_en = raw_buf[1]; DebugPrint(string.Format("Enqueue. Bytes read: {0:D}. Timestamp: {1:X2}", ret, raw_buf[1]), DebugType.THREADING); } return(ret); }
private byte[] Subcommand(byte sc, byte[] buf, uint len, bool print = true) { byte[] buf_ = new byte[report_len]; byte[] response = new byte[report_len]; Array.Copy(default_buf, 0, buf_, 2, 8); Array.Copy(buf, 0, buf_, 11, len); buf_[10] = sc; buf_[1] = global_count; buf_[0] = 0x1; if (global_count == 0xf) { global_count = 0; } else { ++global_count; } if (print) { PrintArray(buf_, DebugType.COMMS, len, 11, "Subcommand 0x" + string.Format("{0:X2}", sc) + " sent. Data: 0x{0:S}"); } ; HIDapi.hid_write(handle, buf_, new UIntPtr(len + 11)); int res = HIDapi.hid_read_timeout(handle, response, new UIntPtr(report_len), 50); if (res < 1) { DebugPrint("No response.", DebugType.COMMS); } else if (print) { PrintArray(response, DebugType.COMMS, report_len - 1, 1, "Response ID 0x" + string.Format("{0:X2}", response[0]) + ". Data: 0x{0:S}"); } return(response); }
void Awake() { if (instance != null) { Destroy(gameObject); } instance = this; int i = 0; j = new List <Joycon>(); bool isLeft = false; HIDapi.hid_init(); IntPtr ptr = HIDapi.hid_enumerate(vendor_id, 0x0); IntPtr top_ptr = ptr; if (ptr == IntPtr.Zero) { ptr = HIDapi.hid_enumerate(vendor_id_, 0x0); if (ptr == IntPtr.Zero) { HIDapi.hid_free_enumeration(ptr); Debug.Log("No Joy-Cons found!"); } } hid_device_info enumerate; while (ptr != IntPtr.Zero) { enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); Debug.Log(enumerate.product_id); if (enumerate.product_id == product_l || enumerate.product_id == product_r) { if (enumerate.product_id == product_l) { isLeft = true; Debug.Log("Left Joy-Con connected."); } else if (enumerate.product_id == product_r) { isLeft = false; Debug.Log("Right Joy-Con connected."); } else { Debug.Log("Non Joy-Con input device skipped."); } IntPtr handle = HIDapi.hid_open_path(enumerate.path); HIDapi.hid_set_nonblocking(handle, 1); j.Add(new Joycon(handle, EnableIMU, EnableLocalize & EnableIMU, 0.05f, isLeft)); ++i; } ptr = enumerate.next; } HIDapi.hid_free_enumeration(top_ptr); }
public static bool FindWiimotes() { IntPtr ptr = HIDapi.hid_enumerate(vid, pid); if (ptr == IntPtr.Zero) { ptr = HIDapi.hid_enumerate(vid, pid2); if (ptr == IntPtr.Zero) { return(false); } } IntPtr cur_ptr = ptr; hid_device_info enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); bool found = false; while (cur_ptr != IntPtr.Zero) { DS4 remote = null; bool fin = false; foreach (DS4 r in Controllers) { if (fin) { continue; } if (r.hidapi_path.Equals(enumerate.path)) { remote = r; fin = true; } } if (remote == null) { IntPtr handle = HIDapi.hid_open_path(enumerate.path); remote = new DS4(handle, enumerate.path); Debug.Log("Found New Remote: " + remote.hidapi_path); Controllers.Add(remote); // TODO: Initialization (?) } cur_ptr = enumerate.next; if (cur_ptr != IntPtr.Zero) { enumerate = (hid_device_info)Marshal.PtrToStructure(cur_ptr, typeof(hid_device_info)); } } HIDapi.hid_free_enumeration(ptr); return(found); }
public void Cleanup() { if (hidapi_handle != IntPtr.Zero) { HIDapi.hid_close(hidapi_handle); hidapi_handle = IntPtr.Zero; } }
public void ExitProtocol() { for (int i = 0; i < j.Count; ++i) { j[i].Detach(); } HIDapi.hid_exit(); }
/// \brief Attempts to recieve RAW DATA to the given bluetooth HID device. This is essentially a wrapper around HIDApi. /// \param hidapi_wiimote The HIDApi device handle to write to. /// \param buf The data to write. /// \sa Wiimote::ReadWiimoteData() /// \warning DO NOT use this unless you absolutely need to bypass the given Wiimote communication functions. /// Use the functionality provided by Wiimote instead. public static int RecieveRaw(IntPtr hidapi_wiimote, byte[] buf) { if (hidapi_wiimote == IntPtr.Zero) return -2; HIDapi.hid_set_nonblocking(hidapi_wiimote, 1); int res = HIDapi.hid_read(hidapi_wiimote, buf, new UIntPtr(Convert.ToUInt32(buf.Length))); return res; }
void hid_write(byte[] buf) { buf[0] = hid_timestamp; for (int i = 0; i < rawhidTxSize; ++i) { send_buffer_[i + 1] = buf[i]; } HIDapi.hid_write(handle, send_buffer_, new UIntPtr(rawhidTxSize + 1)); }
/// \brief Disables the given \c Wiimote by closing its bluetooth HID connection. Also removes the remote from Wiimotes /// \param remote The remote to cleanup public static void Cleanup(Wiimote remote) { if (remote != null) { if (remote.hidapi_handle != IntPtr.Zero) HIDapi.hid_close(remote.hidapi_handle); Wiimotes.Remove(remote); } }
public bool FindOmni() { Debug.Log(System.DateTime.Now.ToLongTimeString() + ": OmniManager(FindOmni) - Trying to find the Omni"); ushort vendor = 0; ushort product = 0; vendor = vendor_id_omni; product = product_id_omni; IntPtr ptr = HIDapi.hid_enumerate(vendor, product); IntPtr cur_ptr = ptr; if (ptr == IntPtr.Zero) { return(false); } hid_device_info enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); bool found = false; while (cur_ptr != IntPtr.Zero) { IntPtr handle = HIDapi.hid_open_path(enumerate.path); if (enumerate.path.Contains("mi_04")) { hidapi_handle = handle; HIDapi.hid_set_nonblocking(hidapi_handle, 1); found = true; omniDisconnected = false; break; } if (enumerate.path.Contains("mi_00")) { hidapi_handle = handle; HIDapi.hid_set_nonblocking(hidapi_handle, 1); found = true; omniDisconnected = false; break; } cur_ptr = enumerate.next; if (cur_ptr != IntPtr.Zero) { enumerate = (hid_device_info)Marshal.PtrToStructure(cur_ptr, typeof(hid_device_info)); } } HIDapi.hid_free_enumeration(ptr); Debug.Log(System.DateTime.Now.ToLongTimeString() + ": OmniManager(FindOmni) - Result of trying to find the Omni = " + found); return(found); }
public static void Cleanup(DS4 remote) { if (remote != null) { if (remote.hidapi_handle != IntPtr.Zero) { HIDapi.hid_close(remote.hidapi_handle); } Controllers.Remove(remote); } }
public static int RecieveRaw(IntPtr hidapi_handle, byte[] buf) { if (hidapi_handle == IntPtr.Zero) { return(-2); } HIDapi.hid_set_nonblocking(hidapi_handle, 1); int res = HIDapi.hid_read(hidapi_handle, buf, new UIntPtr(Convert.ToUInt32(buf.Length))); return(res); }
public bool FindOmni() { Debug.Log("finding omni"); ushort vendor = 0; ushort product = 0; vendor = vendor_id_omni; product = product_id_omni; IntPtr ptr = HIDapi.hid_enumerate(vendor, product); IntPtr cur_ptr = ptr; if (ptr == IntPtr.Zero) { return(false); } hid_device_info enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); bool found = false; while (cur_ptr != IntPtr.Zero) { IntPtr handle = HIDapi.hid_open_path(enumerate.path); if (enumerate.path.Contains("mi_04")) { hidapi_handle = handle; HIDapi.hid_set_nonblocking(hidapi_handle, 1); found = true; break; } if (enumerate.path.Contains("mi_00")) { hidapi_handle = handle; HIDapi.hid_set_nonblocking(hidapi_handle, 1); found = true; break; } cur_ptr = enumerate.next; if (cur_ptr != IntPtr.Zero) { enumerate = (hid_device_info)Marshal.PtrToStructure(cur_ptr, typeof(hid_device_info)); } } HIDapi.hid_free_enumeration(ptr); Debug.Log(found); return(found); }
void Start() { joycons = new List <JoyCon>(); HIDapi.hid_init(); IntPtr ptr = HIDapi.hid_enumerate(VENDOR_TOP, 0x0); IntPtr top_ptr = ptr; if (ptr == IntPtr.Zero) { ptr = HIDapi.hid_enumerate(VENDOR_ID, 0x0); if (ptr == IntPtr.Zero) { HIDapi.hid_free_enumeration(ptr); Debug.Log("No Joy-Cons found!"); } } while (ptr != IntPtr.Zero) { var enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); Debug.Log(enumerate.product_id); if (enumerate.product_id == PRODUCT_L_ID || enumerate.product_id == PRODUCT_R_ID) { var type = JoyConType.NONE; if (enumerate.product_id == PRODUCT_L_ID) { type = JoyConType.LEFT; Debug.Log("Left Joy-Con connected."); } else if (enumerate.product_id == PRODUCT_R_ID) { type = JoyConType.RIGHT; Debug.Log("Right Joy-Con connected."); } IntPtr handle = HIDapi.hid_open_path(enumerate.path); HIDapi.hid_set_nonblocking(handle, 1); joycons.Add(new JoyCon(type, handle, true)); } ptr = enumerate.next; } HIDapi.hid_free_enumeration(top_ptr); //TODO: Move to other place Attach(); }
public void Awake() { instance = this; int i = 0; j = new List <Joycon>(); bool isLeft = false; HIDapi.hid_init(); IntPtr ptr = HIDapi.hid_enumerate(vendor_id, 0x0); IntPtr top_ptr = ptr; if (ptr == IntPtr.Zero) { ptr = HIDapi.hid_enumerate(vendor_id_, 0x0); if (ptr == IntPtr.Zero) { HIDapi.hid_free_enumeration(ptr); } } hid_device_info enumerate; while (ptr != IntPtr.Zero) { enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); if (enumerate.product_id == product_l || enumerate.product_id == product_r) { if (enumerate.product_id == product_l) { isLeft = true; } else if (enumerate.product_id == product_r) { isLeft = false; } else { } IntPtr handle = HIDapi.hid_open_path(enumerate.path); HIDapi.hid_set_nonblocking(handle, 1); j.Add(new Joycon(handle, EnableIMU, EnableLocalize & EnableIMU, 0.05f, isLeft)); ++i; } ptr = enumerate.next; } HIDapi.hid_free_enumeration(top_ptr); }
int hid_read() { int res; byte[] r = new byte[rawhidRxSize]; res = HIDapi.hid_read_timeout(handle, r, new UIntPtr(rawhidRxSize), HID_TIMEOUT_UNITY); if (res > 0) { lock (rec_buffer) { rec_buffer = r; } } return(res); }
private static void SendThread() { while (true) { lock (WriteQueue) { if (WriteQueue.Count != 0) { WriteQueueData wqd = WriteQueue.Dequeue(); int res = HIDapi.hid_write(wqd.pointer, wqd.data, new UIntPtr(Convert.ToUInt32(wqd.data.Length))); if (res == -1) Debug.LogError("HidAPI reports error " + res + " on write: " + Marshal.PtrToStringUni(HIDapi.hid_error(wqd.pointer))); else if (Debug_Messages) Debug.Log("Sent " + res + "b: [" + wqd.data[0].ToString("X").PadLeft(2, '0') + "] " + BitConverter.ToString(wqd.data, 1)); } } Thread.Sleep(MaxWriteFrequency); } }
private void SendRumble(byte[] buf) { byte[] buf_ = new byte[report_len]; buf_[0] = 0x10; buf_[1] = global_count; if (global_count == 0xf) { global_count = 0; } else { ++global_count; } Array.Copy(buf, 0, buf_, 2, 8); PrintArray(buf_, DebugType.RUMBLE, format: "Rumble data sent: {0:S}"); HIDapi.hid_write(handle, buf_, new UIntPtr(report_len)); }
bool TryConnect() { IntPtr ptr = HIDapi.hid_enumerate(USB_VID, USB_PID); if (ptr == IntPtr.Zero) { HIDapi.hid_free_enumeration(ptr); DebugPrint("USB receiver not found."); return(false); } hid_device_info enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); handle = HIDapi.hid_open_path(enumerate.path); HIDapi.hid_set_nonblocking(handle, 1); HIDapi.hid_free_enumeration(ptr); addReport(setup_buffer); return(true); }
public void Detach() { stop_polling = true; PrintArray(max, format: "Max {0:S}", d: DebugType.IMU); PrintArray(sum, format: "Sum {0:S}", d: DebugType.IMU); if (state > state_.NO_JOYCONS) { Subcommand(0x30, new byte[] { 0x0 }, 1); Subcommand(0x40, new byte[] { 0x0 }, 1); Subcommand(0x48, new byte[] { 0x0 }, 1); Subcommand(0x3, new byte[] { 0x3f }, 1); } if (state > state_.DROPPED) { HIDapi.hid_close(handle); } state = state_.NOT_ATTACHED; }
private int ReceiveRaw() { if (handle == IntPtr.Zero) { return(-2); } HIDapi.hid_set_nonblocking(handle, 0); byte[] rawBuf = new byte[ReportLen]; int ret = HIDapi.hid_read(handle, rawBuf, new UIntPtr(ReportLen)); if (ret > 0) { lock (reports) { reports.Enqueue(new Report(rawBuf, DateTime.Now)); } } return(ret); }
private int ReceiveRaw() { if (handle == IntPtr.Zero) { return(-2); } HIDapi.hid_set_nonblocking(handle, 0); byte[] raw_buf = new byte[report_len]; int ret = HIDapi.hid_read(handle, raw_buf, new UIntPtr(report_len)); if (ret > 0) { lock (reports) { reports.Enqueue(new Report(raw_buf, System.DateTime.Now)); } ts_en = raw_buf[1]; } return(ret); }
public byte[] Send(IntPtr handle) { var data = this.GetByteData(); HIDapi.hid_write(handle, data, new UIntPtr((uint)data.Length)); //Debug.Log("Send Data: " + Helper.ByteArrayToString(data)); if (GlobalCount == 0xF) { GlobalCount = 0; } else { GlobalCount++; } var responseData = new byte[ReportLen]; int result = 0; int count = 0; while (result != 1) { result = HIDapi.hid_read_timeout(handle, responseData, new UIntPtr((uint)ReportLen), 50); // TODO: Check error type count++; if (count > 8) { break; } } if (result < 1) { //Debug.Log("No response."); } else { //Debug.Log("Recieve Data: " + Helper.ByteArrayToString(responseData)); } return(responseData); }
public int ReadData(ref byte[] packet) { if (omniDisconnected) //if disconnected, don't do anything { return(-2); } if (hidapi_handle == IntPtr.Zero) { return(-2); } Array.Clear(inputBuf, 0, 65); HIDapi.hid_read(hidapi_handle, inputBuf, new UIntPtr(Convert.ToUInt32(inputBuf.Length))); if (inputBuf[0] != 0xEF) //Checking for invalid message { Debug.LogError(System.DateTime.Now.ToLongTimeString() + ": OmniManager(ReadData) - The Omni has been diconnected and is no longer being detected."); omniDisconnected = true; Cleanup(); } //if (inputBuf[1] == 26) if (inputBuf[2] == 156) // hex 9C { packet = new byte[inputBuf[1]]; Buffer.BlockCopy(inputBuf, 0, packet, 0, inputBuf[1]); } else { return(-2); //pods off or write data } //Debug.Log(inputBuf[2].ToString()); return(inputBuf[1]); }
public void Detach() { end = true; if (State > State.NO_JOYCONS) { new Subcommand(SubcommandType.SetPlayerLights).PackByte(0x0).Send(handle); new Subcommand(SubcommandType.EnableIMU).PackBool(false).Send(handle); new Subcommand(SubcommandType.EnableVibration).PackBool(false).Send(handle); new Subcommand(SubcommandType.SetInputReportMode).PackByte(0x3f).Send(handle); } if (State > State.DROPPED) { HIDapi.hid_close(handle); } State = State.NOT_ATTACHED; //Debug.Log("Detached."); }
private static int rwPage(IntPtr handle, byte address, byte[] s, byte[] r) { int res = 0; s[0] = 0; s[1] = address; res = HIDapi.hid_send_feature_report(handle, s, new UIntPtr(sendlen)); if (res < 1) { return(-1); } res = HIDapi.hid_read_timeout(handle, r, new UIntPtr(recvlen), 1000); if (res < 1) { return(-2); } if (r[1] != s[1]) { return(-3); } return(0); }
void Start() { dummy_buf = new byte[rawhidTxSize]; for (int i = 0; i < rawhidTxSize; ++i) { dummy_buf[i] = 0; } dummy_buf[1] = (byte)Command.NULL; hid_timestamp = 2; setup_buffer = new byte[rawhidTxSize]; setup_buffer[1] = (byte)Command.SETUP; setup_buffer[2] = RECV_TICKRATE_MS; setup_buffer[3] = RADIO_TIMEOUT; setup_buffer[4] = HID_TIMEOUT; setup_buffer[5] = WAND_TICKRATE_MS; rec_buffer = new byte[rawhidRxSize]; HIDapi.hid_init(); connected = TryConnect(); send_buffer_ = new byte[rawhidTxSize + 1]; send_buffer_[0] = 0; StartCoroutine("TransmitLoop"); }
public int SendData(byte[] data) { if (hidapi_handle == IntPtr.Zero) { return(-2); } if (data.Length > 64) { return(-1); } Array.Clear(outputBuf, 0, 65); outputBuf[0] = (byte)0x00; // Maybe change Buffer.BlockCopy(data, 0, outputBuf, 1, data.Length); int res = 0; res = HIDapi.hid_write(hidapi_handle, outputBuf, new UIntPtr(Convert.ToUInt32(outputBuf.Length))); return(res); }
private static int rw(byte start_page, int bytes, byte[] in_buf, bool read = true) { bool connect_success = true; IntPtr ptr = HIDapi.hid_enumerate(USB_VID, USB_PID); if (ptr == IntPtr.Zero) { HIDapi.hid_free_enumeration(ptr); connect_success = false; return(-4); } hid_device_info enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); IntPtr handle = HIDapi.hid_open_path(enumerate.path); HIDapi.hid_set_nonblocking(handle, 1); HIDapi.hid_free_enumeration(ptr); if (!connect_success) { HIDapi.hid_close(handle); return(-4); } int numPages = bytes / pagelen; if (bytes % pagelen != 0) { ++numPages; } int in_buf_ind = 0; byte[] r = new byte[recvlen]; byte[] s = new byte[sendlen]; for (int i = start_page; i < start_page + numPages; ++i) { byte cmd = (byte)(read ? i & ~0x80 : i | 0x80); if (!read) { for (int j = 2; j < sendlen; ++j) { if (in_buf_ind < bytes) { s[j] = in_buf[in_buf_ind]; ++in_buf_ind; } } } s[0] = 0; s[1] = cmd; int res = 0; int err = 0; res = HIDapi.hid_send_feature_report(handle, s, new UIntPtr(sendlen)); if (res < 1) { err = -1; } else { res = HIDapi.hid_read_timeout(handle, r, new UIntPtr(recvlen), 1000); if (res < 1) { err = -2; } if (r[1] != s[1]) { err = -3; } } if (err == 0) { if (read) { for (int j = 2; j < recvlen; ++j) { if (in_buf_ind < bytes) { in_buf[in_buf_ind] = r[j]; ++in_buf_ind; } } } } else { HIDapi.hid_close(handle); return(err); } string formatstr = string.Concat(String.Format("page {0:D}, read: {1:B}, data: ", i, read), "{0:S}"); PrintArray(r, format: formatstr); } HIDapi.hid_close(handle); return(0); }
public int Attach(byte leds_ = 0x0, bool imu = true, float alpha = 0.01f, bool localize = false) { imu_enabled = imu; do_localize = localize & imu; filterweight = alpha; state = state_.NOT_ATTACHED; HIDapi.hid_init(); IntPtr ptr = HIDapi.hid_enumerate(vendor_id, 0x0); if (ptr == IntPtr.Zero) { ptr = HIDapi.hid_enumerate(vendor_id_, 0x0); if (ptr == IntPtr.Zero) { HIDapi.hid_free_enumeration(ptr); DebugPrint("No Joy-Cons found.", DebugType.ALL); state = state_.NO_JOYCONS; return(-1); } } hid_device_info enumerate = (hid_device_info)Marshal.PtrToStructure(ptr, typeof(hid_device_info)); if (enumerate.product_id == product_l) { isLeft = true; DebugPrint("Left Joy-Con connected.", DebugType.ALL); } else if (enumerate.product_id == product_r) { DebugPrint("Right Joy-Con connected.", DebugType.ALL); } else { HIDapi.hid_free_enumeration(ptr); DebugPrint("No Joy-Cons found.", DebugType.ALL); state = state_.NO_JOYCONS; return(-1); } handle = HIDapi.hid_open_path(enumerate.path); HIDapi.hid_set_nonblocking(handle, 1); HIDapi.hid_free_enumeration(ptr); state = state_.ATTACHED; byte[] a = { 0x0 }; // Input report mode Subcommand(0x3, new byte[] { 0x3f }, 1, false); a[0] = 0x1; dump_calibration_data(); // Connect a[0] = 0x01; Subcommand(0x1, a, 1); a[0] = 0x02; Subcommand(0x1, a, 1); a[0] = 0x03; Subcommand(0x1, a, 1); a[0] = leds_; Subcommand(0x30, a, 1); Subcommand(0x40, new byte[] { (imu_enabled ? (byte)0x1 : (byte)0x0) }, 1, true); Subcommand(0x3, new byte[] { 0x30 }, 1, true); Subcommand(0x48, new byte[] { 0x1 }, 1, true); DebugPrint("Done with init.", DebugType.COMMS); return(0); }