internal async Task Setup(uint pktVersion) { _currentTask = new TaskCompletionSource <bool>(); // construct a HID output report to send to the device HidOutputReport outReport = Hid.CreateOutputReport(); YUSBPkt.imm_FormatConfReset(outReport, pktVersion); // Send the output report asynchronously _devState = DevState.ResetSend; var u = await Hid.SendOutputReportAsync(outReport); if (u != 65) { _devState = DevState.IOError; throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Reset PKT"); } Task <bool> task = _currentTask.Task; Task taskDone = await Task.WhenAny(task, Task.Delay(1000)); if (taskDone != task) { throw new YAPI_Exception(YAPI.IO_ERROR, "Device does not respond to reset"); } }
public static Task <DevInfo> CheckDeviceAsync(Service svc, int devId) { DevState lastKnownState = null; Task.Run(() => { lastKnownState = svc.GetKnownDevState(devId); }); return(Task.Run(() => { DevAddr addr = svc.GetDevAddr(devId); DevReport devReport = svc.GetCurrDevReport(addr); return new DevInfo(lastKnownState, devReport); })); }
public YUSBDevice(YUSBWatcher watcher, YUSBHub hub, HidDevice hid, DeviceInformation info) { _watcher = watcher; _hub = hub; _yctx = hub._yctx; Hid = hid; Info = info; hid.InputReportReceived += OnInputReportEvent; _devState = DevState.Detected; _pktAckDelay = 0; }
private async Task sendRequest(byte[] request, YGenericHub.RequestAsyncResult asyncResult, object asyncContext) { int pos = 0; if (_currentRequest != null) { await _currentRequest.GetResponse(); } //Debug.WriteLine(string.Format("{0}:Check last request is sent", Environment.CurrentManagedThreadId)); _currentRequest = new YRequest(request, asyncResult, asyncContext, 10000); while (pos < request.Length) { if (_hid == null) { _devState = DevState.IOError; _currentRequest = null; throw new YAPI_Exception(YAPI.IO_ERROR, "USB device has been stopped"); } // construct a HID output report to send to the device HidOutputReport outReport; try { outReport = _hid.CreateOutputReport(); } catch (Exception ex) { _devState = DevState.IOError; _currentRequest = null; throw new YAPI_Exception(YAPI.IO_ERROR, "Error during CreateOutputReport():" + ex.Message); } int size = YUSBPkt.imm_FormatTCP(outReport, request, pos, true); // Send the output report asynchronously uint u; try { u = await _hid.SendOutputReportAsync(outReport); } catch (Exception ex) { _devState = DevState.IOError; _currentRequest = null; throw new YAPI_Exception(YAPI.IO_ERROR, "Error during SendOutputReportAsync():" + ex.Message); } if (u != 65) { _devState = DevState.IOError; _watcher.imm_removeUsableDevice(this); return; } pos += size; } //Debug.WriteLine(string.Format("{0}:sent", Environment.CurrentManagedThreadId)); }
//get dev state public DevState getState() { DevState state = new DevState(); state.type = typeData.name; state.exp = exp; state.lvl = lvl; state.energy = energy; state.activity = currActivity; return(state); }
//set dev state public void setState(DevState state) //set ups a dev using all the state from a dev { // <-- set type here //startUp(typeData); for (int i = 1; i < state.lvl; i++) { levelUp(); } exp = state.exp; energy = state.energy; currActivity = state.activity; energyFactor = updateEnergyFactor(); }
private async Task checkMetaUTC() { if (_lastMetaUTC + META_UTC_DELAY < YAPI.GetTickCount()) { HidOutputReport outReport = Hid.CreateOutputReport(); YUSBPkt.imm_FormatMetaUTC(outReport, true); var u = await Hid.SendOutputReportAsync(outReport); if (u != 65) { _devState = DevState.IOError; throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Start PKT"); } _lastMetaUTC = YAPI.GetTickCount(); } }
internal async Task Start(byte pktAckDelay) { // construct a HID output report to send to the device HidOutputReport outReport = Hid.CreateOutputReport(); //("Activate USB pkt ack (%dms)\n", dev->pktAckDelay); YUSBPkt.imm_FormatConfStart(outReport, 1, pktAckDelay); // Send the output report asynchronously _devState = DevState.StartSend; var u = await Hid.SendOutputReportAsync(outReport); if (u != 65) { _devState = DevState.IOError; throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Start PKT"); } }
/// <summary> /// 获取屏幕上所有音频和视频设备 /// </summary> public string GetVideoAndAudioDev() { string result = ""; DevState state = DevState.None; VideoAndAudioDev devs = new VideoAndAudioDev(); string devName = string.Empty; MepgHelper.ExecVideoCommand(VideoAndAudioList, (sender, e) => { state = MepgHelper.GetDevId(e.Data, state, ref devs, ref devName); }, (sender, e) => { _events.Publish(new DevListMessage { Data = devs }, (t) => { Task.Factory.StartNew(t); }); }); return(result); }
// Update is called once per frame void Update() { if (Input.GetKeyDown(KeyCode.F1)) { if (state == DevState.Test) { state = DevState.Debug; } else { state = DevState.Test; } } if (source.isPlaying && SceneManager.GetActiveScene().buildIndex != 0 && SceneManager.GetActiveScene().buildIndex != 14) { source.Stop(); } else if (!source.isPlaying && (SceneManager.GetActiveScene().buildIndex == 0 || SceneManager.GetActiveScene().buildIndex == 14)) { source.Play(); } }
public static DevState GetDevId(string msg, DevState state, ref VideoAndAudioDev dev, ref string devName) { if (!string.IsNullOrWhiteSpace(msg)) { if (msg.Contains(VideoDevConst)) { state = DevState.VideoState; } else if (msg.Contains(AudioStateConst)) { state = DevState.AudioState; } else if (msg.Contains(DevIdConst)) { string devId = msg.Substring(msg.IndexOf(DevIdConst), msg.Length - msg.IndexOf(DevIdConst)).Replace(DevIdConst, "").Replace("\"", "").Trim(); switch (state) { case DevState.VideoState: dev.Videos.Add(new VideoDev() { DevId = devId, DevName = EncoderHelper.ASCIToUtf8(devName) }); break; case DevState.AudioState: dev.Audios.Add(new AudioDev() { DevId = devId, DevName = EncoderHelper.ASCIToUtf8(devName) }); break; } } devName = msg; } return(state); }
private void imm_handleNotifcation(YPktStreamHead ystream) { string functionId; int firstByte = ystream.imm_GetByte(0); bool isV2 = ystream.StreamType == YGenericHub.YSTREAM_NOTICE_V2; if (isV2 || firstByte <= NOTIFY_1STBYTE_MAXTINY || firstByte >= NOTIFY_1STBYTE_MINSMALL) { int funcvalType = (firstByte >> NOTIFY_V2_TYPE_OFS) & NOTIFY_V2_TYPE_MASK; int funydx = firstByte & NOTIFY_V2_FUNYDX_MASK; YPEntry ypEntry = imm_getYPEntryFromYdx(funydx); if (ypEntry != null) { if (ypEntry.Index == funydx) { if (funcvalType == YGenericHub.NOTIFY_V2_FLUSHGROUP) { // not yet used by devices } else { if ((firstByte & NOTIFY_V2_IS_SMALL_FLAG) != 0) { // added on 2015-02-25, remove code below when confirmed dead code throw new YAPI_Exception(YAPI.IO_ERROR, "Hub Should not fwd notification"); } int len = (int)ystream.Len; byte[] data = new byte[len]; ystream.imm_CopyData(data, 0); string funcval = YGenericHub.imm_decodePubVal(funcvalType, data, 1, len - 1); _hub.imm_handleValueNotification(SerialNumber, ypEntry.FuncId, funcval); } } } } else { string serial = ystream.imm_GetString(0, YAPI.YOCTO_SERIAL_LEN); if (SerialNumber == null) { SerialNumber = serial; } uint p = YAPI.YOCTO_SERIAL_LEN; int type = ystream.imm_GetByte(p++); switch (type) { case NOTIFY_PKT_NAME: _logicalname = ystream.imm_GetString(p, YAPI.YOCTO_LOGICAL_LEN); _beacon = ystream.imm_GetByte(p + YAPI.YOCTO_LOGICAL_LEN); break; case NOTIFY_PKT_PRODNAME: _product = ystream.imm_GetString(p, YAPI.YOCTO_PRODUCTNAME_LEN); break; case NOTIFY_PKT_CHILD: break; case NOTIFY_PKT_FIRMWARE: _firmware = ystream.imm_GetString(p, YAPI.YOCTO_FIRMWARE_LEN); p += YAPI.YOCTO_FIRMWARE_LEN; p += 2; _deviceid = (ushort)(ystream.imm_GetByte(p) + (ystream.imm_GetByte(p + 1) << 8)); break; case NOTIFY_PKT_FUNCNAME: functionId = ystream.imm_GetString(p, YAPI.YOCTO_FUNCTION_LEN); p += YAPI.YOCTO_FUNCTION_LEN; string funcname = ystream.imm_GetString(p, YAPI.YOCTO_LOGICAL_LEN); if (!_usbYP.ContainsKey(functionId)) { _usbYP[functionId] = new YPEntry(serial, functionId, YPEntry.BaseClass.Function); } _usbYP[functionId].LogicalName = funcname; break; case NOTIFY_PKT_FUNCVAL: functionId = ystream.imm_GetString(p, YAPI.YOCTO_FUNCTION_LEN); p += YAPI.YOCTO_FUNCTION_LEN; string funcval = ystream.imm_GetString(p, YAPI.YOCTO_PUBVAL_SIZE); _hub.imm_handleValueNotification(serial, functionId, funcval); break; case NOTIFY_PKT_STREAMREADY: _devState = DevState.StreamReadyReceived; _wp = new WPEntry(_logicalname, _product, _deviceid, "", _beacon, SerialNumber); _yctx._Log("Device " + SerialNumber + " ready.\n"); _currentTask.SetResult(true); break; case NOTIFY_PKT_LOG: //FIXME: handle log notification break; case NOTIFY_PKT_FUNCNAMEYDX: functionId = ystream.imm_GetString(p, YAPI.YOCTO_FUNCTION_LEN - 1); p += YAPI.YOCTO_FUNCTION_LEN - 1; byte funclass = ystream.imm_GetByte(p++); funcname = ystream.imm_GetString(p, YAPI.YOCTO_LOGICAL_LEN); p += YAPI.YOCTO_LOGICAL_LEN; byte funydx = ystream.imm_GetByte(p); if (!_usbYP.ContainsKey(functionId)) { _usbYP[functionId] = new YPEntry(serial, functionId, YPEntry.BaseClass.forByte(funclass)); } // update ydx _usbYP[functionId].Index = funydx; _usbYP[functionId].LogicalName = funcname; break; case NOTIFY_PKT_PRODINFO: break; default: //fixme: Find why this happening on my dev computer throw new YAPI_Exception(YAPI.IO_ERROR, "Invalid Notification"); } } }
internal async Task streamHandler(List <YPktStreamHead> streams) { foreach (YPktStreamHead s in streams) { uint streamType = s.StreamType; switch (streamType) { case YGenericHub.YSTREAM_NOTICE: case YGenericHub.YSTREAM_NOTICE_V2: imm_handleNotifcation(s); break; case YGenericHub.YSTREAM_TCP_CLOSE: case YGenericHub.YSTREAM_TCP: if (_devState != DevState.StreamReadyReceived || _currentRequest == null) { continue; } _currentRequest.imm_AddIncommingData(s); if (streamType == YGenericHub.YSTREAM_TCP_CLOSE) { // construct a HID output report to send to the device HidOutputReport outReport = Hid.CreateOutputReport(); YUSBPkt.imm_FormatTCP(outReport, null, 0, true); // Send the output report asynchronously var u = await Hid.SendOutputReportAsync(outReport); if (u != 65) { _devState = DevState.IOError; _watcher.imm_removeUsableDevice(this); return; } _currentRequest.imm_Close(); } break; case YGenericHub.YSTREAM_EMPTY: break; case YGenericHub.YSTREAM_REPORT: if (_devState == DevState.StreamReadyReceived) { imm_handleTimedNotification(s); } break; case YGenericHub.YSTREAM_REPORT_V2: if (_devState == DevState.StreamReadyReceived) { handleTimedNotificationV2(s); } break; default: _yctx._Log("drop unknown ystream:" + s); break; } } }
internal async void OnInputReportEvent(HidDevice sender, HidInputReportReceivedEventArgs args) { if (_devState == DevState.Detected || _devState == DevState.IOError) { // drop all packet until reset has been sent return; } try { byte[] bb = args.Report.Data.ToArray(); long ofs = 1; //skip first byte that is not part of the packet List <YPktStreamHead> streams = new List <YPktStreamHead>(); while (ofs < bb.Length) { YPktStreamHead s = YPktStreamHead.imm_Decode(ofs, bb); if (s == null) { break; } //Debug.WriteLine(s.ToString()); streams.Add(s); ofs += s.Len + 2; } YPktStreamHead streamHead = streams[0]; switch (_devState) { case DevState.ResetSend: if (streamHead.PktType != YUSBPkt.YPKT_CONF || streamHead.StreamType != YUSBPkt.USB_CONF_RESET) { return; } byte low = streamHead.imm_GetByte(0); uint hig = streamHead.imm_GetByte(1); uint devapi = (hig << 8) + low; _devVersion = devapi; if (imm_CheckVersionCompatibility(devapi) < 0) { return; } await Start(_pktAckDelay); break; case DevState.StartSend: if (streamHead.PktType != YUSBPkt.YPKT_CONF || streamHead.StreamType != YUSBPkt.USB_CONF_START) { return; } if (_devVersion >= YUSBPkt.YPKT_USB_VERSION_BCD) { _pktAckDelay = streamHead.imm_GetByte(1); } else { _pktAckDelay = 0; } _lastpktno = streamHead.PktNumber; _devState = DevState.StartReceived; break; case DevState.StreamReadyReceived: case DevState.StartReceived: if (_devState == DevState.StreamReadyReceived || _devState == DevState.StartReceived) { if (_pktAckDelay > 0 && _lastpktno == streamHead.PktNumber) { //late retry : drop it since we already have the packet. return; } uint expectedPktNo = (_lastpktno + 1) & 7; if (streamHead.PktNumber != expectedPktNo) { String message = "Missing packet (look of pkt " + expectedPktNo + " but get " + streamHead.PktNumber + ")"; _yctx._Log(message + "\n"); _yctx._Log("Set YAPI.RESEND_MISSING_PKT on YAPI.InitAPI()\n"); _devState = DevState.IOError; _watcher.imm_removeUsableDevice(this); return; } _lastpktno = streamHead.PktNumber; await streamHandler(streams); await checkMetaUTC(); } break; default: return; } } catch (YAPI_Exception ex) { _yctx._Log(ex.Message + "\n"); _yctx._Log("Set YAPI.RESEND_MISSING_PKT on YAPI.InitAPI()\n"); _devState = DevState.IOError; _watcher.imm_removeUsableDevice(this); if (_currentTask != null) { _currentTask.SetException(ex); } } }
public DevInfo(DevState state, DevReport report) { }