// USB中断接收函数
private static void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
Console.WriteLine(e.Buffer.ToString(), 0, e.Count);
// txtReadInt.Text = Encoding.Default.GetString(e.Buffer, 0, e.Count);
// MessageBox.Show(Encoding.Default.GetString(e.Buffer, 0, e.Count));
//SetText(Encoding.Default.GetString(e.Buffer, 0, e.Count));
}
private void HeadsetReader_DataReceived(object sender, EndpointDataEventArgs e)
{
var buffer = new byte[e.Count];
Array.Copy(e.Buffer, 0, buffer, 0, buffer.Length);
UsbEndpointReader reader = sender as UsbEndpointReader;
if (reader != null)
{
//Find the slot this belongs to
int?index = null;
foreach (var slot in _slots)
{
if (slot.Value.DataReader == reader)
{
index = slot.Key;
break;
}
}
if (index.HasValue)
{
if (HeadsetDataReceived != null)
{
HeadsetDataReceived(this, new DataReceivedEventArgs(index.Value, buffer));
}
}
}
}
public void reader_DataReceived(object sender, EndpointDataEventArgs e)
{
if (run)
{
var data = e.Buffer;
var input1 = ControllerState.deserialize(getFastInput1(ref data));
if (gcn1ok)
{
JoystickHelper.setJoystick(ref gcn1, input1, 1, gcn1DZ);
}
}
else
{
reader.DataReceivedEnabled = false;
if (GCNAdapter != null)
{
if (GCNAdapter.IsOpen)
{
if (!ReferenceEquals(wholeGCNAdapter, null))
{
wholeGCNAdapter.ReleaseInterface(0);
}
GCNAdapter.Close();
}
GCNAdapter = null;
UsbDevice.Exit();
DriverLog(null, new Logging.LogEventArgs("Closing driver thread..."));
}
DriverLog(null, new Logging.LogEventArgs("Driver thread has been stopped."));
}
}
protected static void read_usb(object sender, EndpointDataEventArgs e)
{
Debug.Assert(e != null && e.Buffer != null);
caLibUsbAdapter.read_lock.WaitOne();
if (e.Count > 0)
{
// add to queue; NB: incomming buffer is fixed-sizem so .ForEach()
// cannot be used
for (int i = 0; i < e.Count; i++)
{
thisptr.usb_queue.Enqueue(e.Buffer[i]);
}
if (thisptr.boot_mode)
{
caLibUsbAdapter.read_event.Set();
}
else
{
thisptr.process_usb();
}
}
caLibUsbAdapter.read_lock.ReleaseMutex();
}
private void ControlRead(object sender, EndpointDataEventArgs e)
{
var report = PSVRReport.Parse(e.Buffer);
Debug.WriteLine("Report: " + report.ReportType);
switch (report.ReportType)
{
case PSVRReportType.Info:
//result for
break;
case PSVRReportType.Status:
//hmd status
break;
case PSVRReportType.Result:
//result for command
var type = (PSVRReportType)report.Data[4];
Debug.WriteLine("Got response to request: {0}", type);
Action action;
PostActions.TryGetValue(type, out action);
if (action != null)
{
PostActions.Remove(type);
ThreadPool.QueueUserWorkItem((a) => { ((Action)a).Invoke(); }, action);
}
break;
}
}
private void DataReceivedHandler(object sender, EndpointDataEventArgs e)
{
if (DataReceived != null)
{
DataReceived.Invoke(sender, e);
}
}
private void ProcessReceievedData(object sender, EndpointDataEventArgs e)
{
byte[] BytesReceived = e.Buffer.Take(32).ToArray();
var ADCValues = Calculations.ConvertToADCValues(BytesReceived);
WriteValues(ADCValues);
}
void epReader_DataReceived(object sender, EndpointDataEventArgs e)
{
var cmd = (ClovershellCommand)e.Buffer[0];
var arg = e.Buffer[1];
var len = e.Buffer[2] | (e.Buffer[3] * 0x100);
proceedPacket(cmd, arg, e.Buffer, 4, len);
}
//Async Read Method
private void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
if (globalCallback != null)
{
Console.WriteLine("OnRxEndPointData");
globalCallback(e.Buffer, e.Count);
}
}
private void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
UsbReceiverAction = UsbReceiverActionFunction;
if ((myUsbDevice.IsOpen) && (reader != null))
{
ketthuc = this.BeginInvoke(UsbReceiverAction, (Encoding.Default.GetString(e.Buffer, 0, e.Count)));
}
}
void HandleDataReceived(object sender, EndpointDataEventArgs e)
{
lock (readBuffer) {
long currentPosition = readBuffer.Position;
readBuffer.Position = readBuffer.Length;
readBuffer.Write(e.Buffer, 0, e.Count);
readBuffer.Position = currentPosition;
}
}
private void DeviceForwarder_DataReceived(object sender, EndpointDataEventArgs e)
{
//Send it out to the host
UsbEndpointReader reader = sender as UsbEndpointReader;
if (reader != null)
{
_device.WriteOutgoingData(reader.EpNum & 0x7F, e.Buffer, 0, e.Count);
}
}
private void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
double captureval1 = ((int)(e.Buffer[0] * 256 + e.Buffer[1]) * .0009988f);
double captureval2 = ((int)(e.Buffer[2] * 256 + e.Buffer[3]) * .0009988f);
MeasTime = DateTime.Now;
ElapsedTime = MeasTime - StartTime;
AddPoint(ElapsedTime.TotalMilliseconds * 0.001, captureval1, captureval2);
}
void pinState_DataReceived(object sender, EndpointDataEventArgs e)
{
int transferLength;
pinState.Read(pinStateBuffer, 1000, out transferLength);
if (pinStateBuffer[0] == (byte)DeviceResponse.CurrentReadings)
{
Pin1.UpdateValue(pinStateBuffer[1], pinStateBuffer[2]);
Pin2.UpdateValue(pinStateBuffer[3], pinStateBuffer[4]);
Pin3.UpdateValue(pinStateBuffer[5], pinStateBuffer[6]);
Pin4.UpdateValue(pinStateBuffer[7], pinStateBuffer[8]);
Pin5.UpdateValue(pinStateBuffer[9], pinStateBuffer[10]);
Pin6.UpdateValue(pinStateBuffer[11], pinStateBuffer[12]);
Pin7.UpdateValue(pinStateBuffer[13], pinStateBuffer[14]);
Pin8.UpdateValue(pinStateBuffer[15], pinStateBuffer[16]);
Pin9.UpdateValue(pinStateBuffer[17], pinStateBuffer[18]);
Pin10.UpdateValue(pinStateBuffer[19], pinStateBuffer[20]);
Pin11.UpdateValue(pinStateBuffer[21], pinStateBuffer[22]);
Pin12.UpdateValue(pinStateBuffer[23], pinStateBuffer[24]);
Pin13.UpdateValue(pinStateBuffer[25], pinStateBuffer[26]);
Pin14.UpdateValue(pinStateBuffer[27], pinStateBuffer[28]);
/// Pin interrupts.
/// TODO: This is really hacky and needs to be cleaned up.
int PortAInterrupt = pinStateBuffer[29];
int PortBInterrupt = pinStateBuffer[30];
if ((PortAInterrupt & (1 << 4)) > 0) // RA4 = Pin1
{
Pin1.RaiseDigitalInValueChanged();
}
if ((PortAInterrupt & (1 << 5)) > 0) // RA5 = Pin14
{
Pin14.RaiseDigitalInValueChanged();
}
if ((PortBInterrupt & (1 << 7)) > 0) // RB7 = Pin8
{
Pin8.RaiseDigitalInValueChanged();
}
if ((PortBInterrupt & (1 << 7)) > 0) // RB5 = Pin9
{
Pin9.RaiseDigitalInValueChanged();
}
if ((PortBInterrupt & (1 << 7)) > 0) // RB4 = Pin10
{
Pin10.RaiseDigitalInValueChanged();
}
if ((PortBInterrupt & (1 << 7)) > 0) // RB6 = Pin11
{
Pin11.RaiseDigitalInValueChanged();
}
}
}
private void OnDataReceived_LoopTest(object sender, EndpointDataEventArgs e)
{
if (mBenchMarkParameters.Verify)
{
for (int i = 0; i < e.Count; i++)
{
if (mbInLoopTestError)
{
if (e.Buffer[i] == 0)
{
mLoopTestOffset = 0;
mbInLoopTestError = false;
}
else
{
continue;
}
}
if (mLoopTestOffset >= loopTestBytes.Length)
{
mLoopTestOffset = 0;
mLoopTestCompletedPackets++;
}
if (e.Buffer[i] == loopTestBytes[mLoopTestOffset])
{
mLoopTestOffset++;
}
else
{
mbInLoopTestError = true;
if (mLoopTestCompletedPackets > 0)
{
mEndPointStopWatch.PacketErrorCount++;
SetStatus(string.Format("Data validation mismatch at position:{0}/{1}.", i, loopTestBytes.Length), true);
}
break;
}
}
if (mLoopTestCompletedPackets == 0)
{
return;
}
}
if (!mEndPointStopWatch.IsStarted)
{
mEndPointStopWatch.DiffWithNow();
return;
}
UpdateDataRate(e.Count);
}
private void reader_DataReceived(object sender, EndpointDataEventArgs e)
{
Logger.WriteLine("Incoming: " + BitConverter.ToString(e.Buffer, 0, e.Count));
lock (_writer)
{
Logger.LogData('O', e.Buffer, 0, e.Count);
}
if (IncomingDataReceived != null)
{
IncomingDataReceived(this, new HCIEventEventArgs(e.Buffer, e.Count));
}
}
private void SensorRead(object sender, EndpointDataEventArgs e)
{
var data = e.Buffer;
var pressedButton = (ControlButtons)data[0];
Volume = data[2];
var status = data[8];
IsWorn = (status & 0x1) == 0x1 ? true : false;
IsDisplayActive = (status & 0x2) == 0x2 ? false : true;
IsMuted = (status & 0x8) == 0x8 ? true : false;
IsEarphoneConnected = (status & 0x10) == 0x10 ? true : false;
Proximity1 = data[39];
Proximity2 = data[40];
//2 sets of sensor data per packet?
var pos = 16;
var timeStamp = BitConverter.ToUInt32(data, pos);
Gyro[0] = BitConverter.ToInt16(data, pos + 4);
Gyro[1] = BitConverter.ToInt16(data, pos + 6);
Gyro[2] = BitConverter.ToInt16(data, pos + 8);
Accel[0] = BitConverter.ToInt16(data, pos + 10);
Accel[1] = BitConverter.ToInt16(data, pos + 12);
Accel[2] = BitConverter.ToInt16(data, pos + 14);
LastTimeStamp = timeStamp;
//process
pos += 16;
timeStamp = BitConverter.ToUInt32(data, pos);
Gyro[0] = BitConverter.ToInt16(data, pos + 4);
Gyro[1] = BitConverter.ToInt16(data, pos + 6);
Gyro[2] = BitConverter.ToInt16(data, pos + 8);
Accel[0] = BitConverter.ToInt16(data, pos + 10);
Accel[1] = BitConverter.ToInt16(data, pos + 12);
Accel[2] = BitConverter.ToInt16(data, pos + 14);
LastTimeStamp = timeStamp;
//process
OnPacketReceive?.Invoke(null, null);
}
public void reader_DataReceived(object sender, EndpointDataEventArgs e)
{
if (run)
{
var data = e.Buffer;
var input1 = GCNState.GetState(getFastInput1(ref data));
var input2 = GCNState.GetState(getFastInput2(ref data));
var input3 = GCNState.GetState(getFastInput3(ref data));
var input4 = GCNState.GetState(getFastInput4(ref data));
if (gcn1ok)
{
JoystickHelper.setJoystick(input1, 1, gcn1DZ);
}
if (gcn2ok)
{
JoystickHelper.setJoystick(input2, 2, gcn2DZ);
}
if (gcn3ok)
{
JoystickHelper.setJoystick(input3, 3, gcn3DZ);
}
if (gcn4ok)
{
JoystickHelper.setJoystick(input4, 4, gcn4DZ);
}
}
else
{
reader.DataReceivedEnabled = false;
if (GCNAdapter != null)
{
if (GCNAdapter.IsOpen)
{
if (!ReferenceEquals(wholeGCNAdapter, null))
{
wholeGCNAdapter.ReleaseInterface(0);
}
GCNAdapter.Close();
}
GCNAdapter = null;
UsbDevice.Exit();
Log(null, new LogEventArgs("Closing driver thread..."));
}
Log(null, new LogEventArgs("Driver thread has been stopped."));
}
}
void epReader_DataReceived(object sender, EndpointDataEventArgs e)
{
#if VERY_DEBUG
Debug.WriteLine("<-[CLV] " + BitConverter.ToString(e.Buffer, 0, e.Count));
#endif
int pos = 0;
int count = e.Count;
while (count > 0)
{
var cmd = (ClovershellCommand)e.Buffer[pos];
var arg = e.Buffer[pos + 1];
var len = e.Buffer[pos + 2] | (e.Buffer[pos + 3] * 0x100);
proceedPacket(cmd, arg, e.Buffer, pos + 4, len);
count -= len + 4;
pos += len + 4;
}
}
private static void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
Pigeon_Comm_Data data = Data.DataParse(e.Buffer);
if (data.Head == 0x66)
{
Pigeon_Settings settingss = new Pigeon_Settings();
settingss.Brightness = 10;
settingss.ProfileIdx = 0;
settingss.KeyDef = 3;
settingss.RLELen = 615;
byte[] a = Data.ToBytes(settingss);
Pigeon_Settings settings = Data.ParseDataBodyToStructure <Pigeon_Settings>(e.Buffer);
if (settings.Brightness == 1)
{
}
}
}
private void ProcessReceievedData(object sender, EndpointDataEventArgs e)
{
byte[] BytesReceived = e.Buffer.Take(32).ToArray();
string Value = Encoding.ASCII.GetString(BytesReceived);
List <Tuple <int, int> > ADCValues = new List <Tuple <int, int> >();
ADCValues = Calculations.ConvertToADCValues(BytesReceived);
if (ADCValues.Count == DI2008.EnabledAnalogChannels + 1) //+1 is for the Digital Channel readout
{
WriteAnalogValues(ADCValues);
int DigitalStatusByte = ADCValues[DI2008.EnabledAnalogChannels].Item2;
if (DigitalStatusByte <= 128 && DigitalStatusByte >= 0)
{
WriteDigitalValues(DigitalStatusByte);
}
}
}
private void Reader_DataReceived(object sender, EndpointDataEventArgs e)
{
InterruptType type = (InterruptType)e.Buffer[0];
LCTFState state = (LCTFState)e.Buffer[1];
int wavelength = Convert.ToInt32(BitConverter.ToSingle(e.Buffer, 4));
Task.Run(() =>
{
// _logger.Debug(m => m($"{interrupt.Type}"));
switch (type)
{
case InterruptType.Error:
var onError = this.OnError;
onError?.Invoke(state, wavelength);
break;
case InterruptType.TuningDone:
var onTuningDone = this.OnTuningDone;
onTuningDone?.Invoke(wavelength);
break;
case InterruptType.CalibrationDone:
var onCalibrationDone = this.OnCalibrationDone;
onCalibrationDone?.Invoke();
break;
case InterruptType.StateChanged:
var onStateChanged = this.OnStateChanged;
onStateChanged?.Invoke(state, wavelength);
break;
case InterruptType.Busy:
var onBusy = this.OnBusy;
onBusy?.Invoke(state, wavelength);
break;
default:
break;
}
});
}
private void mEp_DataReceived(object sender, EndpointDataEventArgs e)
{
Array.Copy(e.Buffer, rawControlData, e.Count);
//reader.Read(buf, 0, 64, 1000, out readByteCount);
if (this.RawData != null)
{
RawData(this, rawControlData);
}
CheckStateChanged(rawControlData);
//Array.Copy(buf, 0, rawControlData, 0, e.Count);
//moved this section out of CheckStateChanged since we want this to go off after the data from buf has been copied over to rawControlData
if ((Enum.GetValues(typeof(ButtonEnum)).Length > 0) && (this.ButtonStateChanged != null))
{
ButtonStateChanged(this, stateChangedArray);
}
}
private void EndpointReader_DataReceived(object sender, EndpointDataEventArgs e)
{
if (EndpointsAreDisposed())
{
return;
}
var response = new Response(e.Buffer, e.Count);
var sequenceNumber = response.SequenceNumber;
System.Diagnostics.Debug.WriteLine($"Received seqNo {response.SequenceNumber}...");
if (pendingRequests.TryGetValue(sequenceNumber, out Request pendingRequest))
{
if (pendingRequest.CancellationToken.IsCancellationRequested)
{
if (pendingRequests.TryRemove(sequenceNumber, out _))
{
pendingRequest.CancellationToken.ThrowIfCancellationRequested();
}
else
{
throw new KeyNotFoundException($"A cancelled response was received for sequence number ${sequenceNumber} but no pending requests exist matching that sequence number.");
}
}
if (!pendingRequests.TryRemove(sequenceNumber, out _))
{
throw new KeyNotFoundException($"A response was received for sequence number ${sequenceNumber} but something unexpectedly removed the request from the list of pending requests.");
}
pendingRequest.ResponseCallback(response);
}
else
{
throw new KeyNotFoundException($"A response was received for sequence number ${sequenceNumber} but no pending requests exist matching that sequence number.");
}
}
private void OnDataReceived(object sender, EndpointDataEventArgs e)
{
if (chkLogToFile.Checked && mLogFileStream != null)
{
if (ckShowAsHex.Checked)
{
// get the bytes as a hex string
StringBuilder sb = GetHexString(e.Buffer, 0, e.Count);
// get the hexstring as bytes and write to log file
Byte[] data = Encoding.UTF8.GetBytes(sb.ToString());
mLogFileStream.Write(data, 0, data.Length);
}
else
{
mLogFileStream.Write(e.Buffer, 0, e.Count);
}
}
else
{
showBytes(e.Buffer, e.Count);
}
}
private void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
LastDataEventDate = DateTime.Now;
if (InvokeRequired)
{
BeginInvoke((MethodInvoker) delegate
{
try
{
richTextBoxReceive.AppendText(Encoding.Default.GetString(e.Buffer, 0, e.Count) + "\n");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
});
}
else
{
richTextBoxReceive.AppendText(Encoding.Default.GetString(e.Buffer, 0, e.Count) + "\n");
}
}
void trinket_DataReceived(object sender, EndpointDataEventArgs e)
{
try
{
// we got data but the port was never opened?
if (port == null)
{
if (lastPortName != null) // hmm, we have a name of the port, try opening it
{
port = new SerialPort(lastPortName);
port.Open();
port.ReadTimeout = 200;
port.ReceivedBytesThreshold = 1;
port.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);
}
}
}
catch (Exception ex)
{
notifyIcon.ShowBalloonTip(1000, "Trinket Fake USB Serial", "Serial Port Opening Error: " + ex.Message, ToolTipIcon.Error);
}
if (port != null && port.IsOpen == true)
{
try
{
// we have a port that is usable, send the data
port.Write(e.Buffer, 0, e.Count);
bytesProcessed += e.Count;
}
catch (Exception ex)
{
notifyIcon.ShowBalloonTip(1000, "Trinket Fake USB Serial", "Serial Port Sending Error: " + ex.Message, ToolTipIcon.Error);
}
}
}
private void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
AddMsg($" > {e.Count} data received");
Array.Copy(e.Buffer, 0, _recvBuf, 0, 8640);
Array.Copy(e.Buffer, 8640, adcBuf, 0, 5120);
int k = 0;
for (int i = 0; i < 5120 - 16; i = i + 16)
{
timerPlotBuf[k] = BitConverter.ToInt16(adcBuf, i);
// timerPlotBuf[k] = BitConverter.ToInt16(e.Buffer, i);
k++;
}
Dispatcher.Invoke(new UpdatePlot(AddPlot), timerPlotBuf);
//Dispatcher.Invoke(new ShowMsg(CreatImg));
for (int i = 0; i < 8640; i = i + 4)
{
_trackImage[i / 4] = BitConverter.ToSingle(_recvBuf, i);
}
for (int i = 8; i < 80; i++)
{
for (int j = 0; j < 27; j++)
{
_matrixDataTemp[i - 8, j] = _trackImage[j + i * 27];
}
}
var result = kalmanFiltering.TraceTableEstablishment(_matrixDataTemp);
if (result.Count > 0)
{
if (kalmanFiltering.StartFlag == 0)
{
var temp = kalmanFiltering.TrackingIni(result);
for (int i = 0; i < 6; i++)
{
kalmanFiltering.PredictPosition[i] = temp[i];
}
trackNum = 0;
}
else
{
kalmanFiltering.Tracking(result);
xTemp[trackNum] = kalmanFiltering.CurrentPosition[0] * 100;
yTemp[trackNum] = kalmanFiltering.CurrentPosition[3] * 100;
trackNum++;
}
}
else
{
if (kalmanFiltering.TrackCount > 0)
{
kalmanFiltering.MissCount++;
}
if (kalmanFiltering.MissCount > 50)
{
double[] plotTemp = new double[kalmanFiltering.TrackCount * 2];
for (int i = 0; i < kalmanFiltering.TrackCount; i++)
{
plotTemp[i] = xTemp[i];
plotTemp[i + kalmanFiltering.TrackCount] = yTemp[i];
}
//Dispatcher.Invoke(new UpdateTrack(AddTrack), plotTemp);
trackNum = 0;
kalmanFiltering.TrackCount = 0;
kalmanFiltering.StartFlag = 0;
}
}
if (_dataState == DataState.Started)
{
Dispatcher.Invoke(new UpdateBytesDelegate(SaveData), adcBuf);
}
}
private void OnRxEndPointData(object sender, EndpointDataEventArgs e)
{
_msgserver.AddMsg(_msgserver._usbBindList, $" > {e.Count} data received");
_actionBlock.Post(e.Buffer);
}
private void _reader_DataReceived(object sender, EndpointDataEventArgs e)
{
char cmd = (char)e.Buffer[2];
switch (cmd)
{
case 'E':
{
Logger.WriteLine("Raw: Received error/busy response: " +
BitConverter.ToString(e.Buffer, 0, e.Count), Logger.LoggingLevel.VeryVerbose);
//Need to find the first (oldest) message matching this command and mark it as ready to send
//HACK: This really should use a sequence ID or something, but this works well enough
lock (_messages)
{
for (int i = 0; i < _messages.Count; i++)
{
if (_messages[i].Data[2] == e.Buffer[4])
{
_messages[i].Status = MessageStatus.ReadyToSend;
break;
}
}
}
break;
}
case 'A':
{
Logger.WriteLine("Raw: Received acknowledgement response: " +
BitConverter.ToString(e.Buffer, 0, e.Count), Logger.LoggingLevel.VeryVerbose);
//Need to find the first (oldest) message matching this command and delete it
//HACK: This really should use a sequence ID or something, but this works well enough
// There's also the potential for this to fill up all available memory...don't care for now...
lock (_messages)
{
for (int i = 0; i < _messages.Count; i++)
{
if (_messages[i].Data[2] == e.Buffer[3])
{
_messages.RemoveAt(i);
break;
}
}
}
break;
}
case 'U':
{
Logger.WriteLine("Raw: Received control request: " +
BitConverter.ToString(e.Buffer, 0, e.Count), Logger.LoggingLevel.Verbose);
//Received control request
int bmRequestType = e.Buffer[3];
int bRequest = e.Buffer[4];
int wValue = e.Buffer[5] | (e.Buffer[6] << 8);
int wIndex = e.Buffer[7] | (e.Buffer[8] << 8);
int wLength = e.Buffer[9] | (e.Buffer[10] << 8);
var attachedData = new byte[wLength];
Array.Copy(e.Buffer, 11, attachedData, 0, wLength);
var arg = new ControlRequestEventArgs(bmRequestType, bRequest, wValue, wIndex, wLength, attachedData);
_currentDevice.OnControlRequestReceived(arg);
if (arg.CanIgnore && arg.Ignore)
{
_Write(new byte[] { (byte)'U', 0x00 });
}
else if (arg.Stall)
{
_Write(new byte[] { (byte)'U', 0x02 });
}
else
{
var ret = new byte[2 + (arg.ReturnData != null ? arg.ReturnData.Length : 0)];
ret[0] = (byte)'U';
ret[1] = 0x01;
if (arg.ReturnData != null)
{
Array.Copy(arg.ReturnData, 0, ret, 2, arg.ReturnData.Length);
}
_Write(ret);
}
break;
}
case 'F':
{
//If e.Buffer[3] is non-zero, USB is connected, otherwise disconnected. Apparently.
Logger.WriteLine("Raw: Received event: " +
BitConverter.ToString(e.Buffer, 0, e.Count), Logger.LoggingLevel.Verbose);
break;
}
case 'D':
{
Logger.WriteLine("Raw: Received descriptor request: " +
BitConverter.ToString(e.Buffer, 0, e.Count), Logger.LoggingLevel.Verbose);
//Received descriptor request
int wValue = e.Buffer[3] | (e.Buffer[4] << 8);
int wIndex = e.Buffer[5] | (e.Buffer[6] << 8);
var arg = new DescriptorRequestedEventArgs(wValue, wIndex);
_currentDevice.OnDescriptorRequested(arg);
//HACK: We tacked on the endpoint configuration stuff to the device descriptor,
// so if that's what we're returning, generate and tack it on here
byte[] ret;
if (((wValue >> 8) & 0xFF) == 0x01)
{
ret = new byte[1 + arg.DescriptorData.Length + 1 + (_currentDevice.Endpoints.Count * 4)];
ret[0] = (byte)'D';
Array.Copy(arg.DescriptorData, 0, ret, 1, arg.DescriptorData.Length);
ret[1 + arg.DescriptorData.Length] = (byte)_currentDevice.Endpoints.Count;
for (int i = 0; i < _currentDevice.Endpoints.Count; i++)
{
ret[1 + arg.DescriptorData.Length + 1 + (i * 4) + 0] =
(byte)(_currentDevice.Endpoints[i].Endpoint | (byte)_currentDevice.Endpoints[i].Direction);
ret[1 + arg.DescriptorData.Length + 1 + (i * 4) + 1] = (byte)_currentDevice.Endpoints[i].Type;
ret[1 + arg.DescriptorData.Length + 1 + (i * 4) + 2] = (byte)(_currentDevice.Endpoints[i].MaximumPacketSize & 0xFF);
ret[1 + arg.DescriptorData.Length + 1 + (i * 4) + 3] = (byte)((_currentDevice.Endpoints[i].MaximumPacketSize >> 8) & 0xFF);
}
}
else
{
ret = new byte[1 + (arg.DescriptorData != null ? arg.DescriptorData.Length : 0)];
ret[0] = (byte)'D';
if (arg.DescriptorData != null)
{
Array.Copy(arg.DescriptorData, 0, ret, 1, arg.DescriptorData.Length);
}
}
_Write(ret);
break;
}
case 'I':
{
Logger.WriteLine("Raw: Received incoming data: " +
BitConverter.ToString(e.Buffer, 0, e.Count), Logger.LoggingLevel.Verbose);
//Incoming endpoint data received
int count = (e.Buffer[0] | (e.Buffer[1] << 8));
if (count > 0)
{
var data = new byte[count - 2];
Array.Copy(e.Buffer, 4, data, 0, data.Length);
_currentDevice.OnIncomingDataReceived(new IncomingDataEventArgs(e.Buffer[3], data));
}
break;
}
default:
{
Logger.WriteLine("Raw: Received unknown data: " +
BitConverter.ToString(e.Buffer, 0, e.Count), Logger.LoggingLevel.Verbose);
break;
}
}
}
