public bool intDevice() { // 可能抛出“无法访问已释放的对象”的异常 try { loopDevice = usbDevices[0x04b4, 0x3031] as CyUSBDevice; } catch { loopDevice = null; } //PID 0x1004 is used for cardio //if (loopDevice == null) loopDevice = usbDevices[0x04b4, 0x1004] as CyUSBDevice; if (loopDevice != null) { try { usbName = loopDevice.FriendlyName; outEndpoint = loopDevice.EndPointOf(0x02) as CyBulkEndPoint; inEndpoint = loopDevice.EndPointOf(0x86) as CyBulkEndPoint; outEndpoint.TimeOut = 500; inEndpoint.TimeOut = 1000; _isUSBAvailable = true; InitializeParams(); PreReadAsysnchonous(); } catch (Exception ex) { return(false); } return(true); } else { _isUSBAvailable = false; return(false); } }
void usbDevices_DeviceRemoved(object sender, EventArgs e) { MyDevice = null; inEndpoint = null; SetDevice(); openPort(); }
public bool ReConnect() { MyUsb = MyUsbList[0x04B4, 0x1004] as CyUSBDevice; if (MyUsb != null) { MyUsb.ReConnect(); MyUsb = MyUsbList[0x04B4, 0x00F1] as CyUSBDevice; } else { MyUsb = MyUsbList[0x04B4, 0x00F1] as CyUSBDevice; } if (MyUsb != null) { MyOutPoint = MyUsb.EndPointOf(0x02); MyInPoint = MyUsb.EndPointOf(0x86); MyControlPoint = MyUsb.ControlEndPt; Reset(); return(true); } else { return(false); } }
/*Summary * This is the event handler for device removal. This method resets the device count and searches for the device with * VID-PID 04b4-1003 */ void usbDevices_DeviceRemoved(object sender, EventArgs e) { bRunning = false; if (tListen != null && tListen.IsAlive == true) { tListen.Abort(); tListen.Join(); tListen = null; } MyDevice = null; EndPoint = null; SetDevice(false); if (StartBtn.Text.Equals("Start") == false) { { DevicesComboBox.Enabled = true; EndPointsComboBox.Enabled = true; PpxBox.Enabled = true; QueueBox.Enabled = true; StartBtn.Text = "Start"; bRunning = false; t2 = DateTime.Now; elapsed = t2 - t1; xferRate = (long)(XferBytes / elapsed.TotalMilliseconds); xferRate = xferRate / (int)100 * (int)100; StartBtn.BackColor = Color.Aquamarine; } } }
public override bool Recover() { try { if (loopDevice != null) { loopDevice.Dispose(); loopDevice = null; } if (usbDevices != null) { usbDevices.DeviceRemoved -= usbDevices_DeviceRemoved; usbDevices.DeviceAttached -= usbDevices_DeviceAttached; usbDevices.Dispose(); usbDevices = null; } } catch (System.Exception ex) { } inEndpoint = null; outEndpoint = null; usbDevices = new USBDeviceList(CyConst.DEVICES_CYUSB); usbDevices.DeviceRemoved += new EventHandler(usbDevices_DeviceRemoved); usbDevices.DeviceAttached += new EventHandler(usbDevices_DeviceAttached); return(intDevice()); }
private void SetDevice() { USBDevice dev = usbDevices[46084, 4099]; if (dev != null) { cyDevice = (CyUSBDevice)dev; controlEndPoint = null; bulkInEndPoint = null; GetEndpointsOfNode(cyDevice.Tree); if (controlEndPoint != null) { isReady = true; name = dev.FriendlyName; version = GetFirmwareVer(); revision = GetRevision(); DeviceReadyEventArgs args = new DeviceReadyEventArgs(); args.DeviceName = name; args.VidPid = new[] { dev.VendorID, dev.ProductID }; args.Version = version; args.Revision = revision; DeviceReady?.Invoke(this, args); } } else { isReady = false; DeviceNotReady?.Invoke(this, null); } }
public static bool SendVendorRequest(CyUSBDevice usbDevice, MonoUsbDeviceHandle monoDeviceHandle, byte reqCode, byte[] data, ushort value = 0, ushort index = 0) { if (data == null) { data = new byte[0]; } if (usbDevice != null) { CyControlEndPoint ctrlEpt = usbDevice.ControlEndPt; ctrlEpt.TimeOut = TIMEOUT; ctrlEpt.Direction = CyConst.DIR_TO_DEVICE; ctrlEpt.ReqType = CyConst.REQ_VENDOR; ctrlEpt.Target = CyConst.TGT_DEVICE; ctrlEpt.ReqCode = reqCode; ctrlEpt.Value = value; ctrlEpt.Index = index; int bytes = data.Length; ctrlEpt.XferData(ref data, ref bytes); return(bytes == data.Length); } else { short bytes = (short)data.Length; byte requestType = CyConst.DIR_TO_DEVICE + CyConst.REQ_VENDOR + CyConst.TGT_DEVICE; int ret = MonoUsbApi.ControlTransfer(monoDeviceHandle, requestType, reqCode, (short)value, (short)index, data, bytes, TIMEOUT); return(ret == data.Length); } }
private void ConfigFX3Device(string FileName, CyUSBDevice myDevice) { if (MyDevice != null) { FX3_FWDWNLOAD_ERROR_CODE enmResult = FX3_FWDWNLOAD_ERROR_CODE.SUCCESS; CyFX3Device fx3 = myDevice as CyFX3Device; if (fx3 != null) { enmResult = fx3.DownloadFw(FileName, FX3_FWDWNLOAD_MEDIA_TYPE.RAM); } else { MessageBox.Show("Please check whether the device is FX3 device", "Device ERROR", MessageBoxButton.OK, MessageBoxImage.Error); return; } if (enmResult != FX3_FWDWNLOAD_ERROR_CODE.SUCCESS) { MessageBox.Show("Config error", "Device ERROR", MessageBoxButton.OK, MessageBoxImage.Error); } string report = string.Format("Program {0}\n", fx3.GetFwErrorString(enmResult)); tbxInfo.AppendText(report); } else { MessageBox.Show("Please select the USB device", "Device ERROR", MessageBoxButton.OK, MessageBoxImage.Error); } }
void usbDevices_DeviceRemoved(object sender, EventArgs e) { bRunning = false; if (!ThreadData.IsAddingCompleted) { ThreadData.CompleteAdding(); } MyDevice = null; BulkInEndPoint = null; BulkOutEndPoint = null; RefreshDeviceLists(false); RefreshEndPoint(); tbxInfo.AppendText("USB Disconnect\n"); lblUsbName.Content = "C# USB - no device"; lblUsbName.Foreground = Brushes.Red; btnStartAcq.IsEnabled = false; btnCmdSend.IsEnabled = false; btnStartAcq.Content = "Start"; btnSetUsb.Content = "Set"; btnStartAcq.Background = new SolidColorBrush(Color.FromRgb(27, 129, 62)); cbxDeviceLists.IsEnabled = true; btnSetUsb.IsEnabled = true; cbxInEndPoint.IsEnabled = true; cbxOutEndPoint.IsEnabled = true; cbxPpx.IsEnabled = true; cbxXferQueue.IsEnabled = true; }
private void InitEndInPoints(CyUSBDevice usbDevice) { int endPointCount = (int)usbDevice.EndPointCount; int index1 = 0; int index2 = 0; for (int index3 = 1; index3 < endPointCount; ++index3) { if (((int)usbDevice.EndPoints[index3].Address & 128) == 128) { index1 = index3; } else { index2 = index3; } } if (endPointCount == 3) { this.InEndpt = usbDevice.USBCfgs[0].Interfaces[0].EndPoints[index1]; this.OutEndpt = usbDevice.USBCfgs[0].Interfaces[0].EndPoints[index2]; } else { this.InEndpt = (CyUSBEndPoint)null; this.OutEndpt = (CyUSBEndPoint)null; } }
static void ResetFX2FifoStatus(CyUSBDevice TE_USB_FX2_USBDevice) { if (TE_USB_FX2_USBDevice == null) { Console.WriteLine("Error,no device is selected"); return; } //cout << endl << "Resetting all FIFOs" << endl; Console.WriteLine("Resetting all FIFOs"); byte[] Command = new byte[64]; byte[] Reply = new byte[64]; int CmdLength = 64; int ReplyLength = 64; uint TIMEOUT_MS = 100000; Command[0] = (byte)FX2_Commands.RESET_FIFO_STATUS; Command[1] = 0; //reset all fifos if (TE_USB_FX2.TE_USB_FX2.TE_USB_FX2_SendCommand(ref TE_USB_FX2_USBDevice, ref Command, ref CmdLength, ref Reply, ref ReplyLength, TIMEOUT_MS) == false) { //cout << "Error" << endl; Console.WriteLine("Error Send Command Reset all fifos"); } Command[0] = (byte)FX2_Commands.INITALIZE; //0xA0;//comand SWITCH_MODE Command[1] = 1; //FIFO mode : is not in the documentation if (TE_USB_FX2.TE_USB_FX2.TE_USB_FX2_SendCommand(ref TE_USB_FX2_USBDevice, ref Command, ref CmdLength, ref Reply, ref ReplyLength, TIMEOUT_MS) == false) { //cout << "Error" << endl; Console.WriteLine("Error Switch Mode Fifo Mode"); } }
private void Form1_Load(object sender, EventArgs e) { string tmp_folder = "C:\\tmp\\AINGF_V2\\"; try { if (!Directory.Exists(tmp_folder)) { Directory.CreateDirectory(tmp_folder); } string[] filePaths = Directory.GetFiles(tmp_folder); foreach (string filePath in filePaths) { File.Delete(filePath); } } catch { MessageBox.Show("Temp Folder flush error."); } //Thread th1 = new Thread(new ThreadStart(prepareEX)); //th1.Start(); usbDevices = new USBDeviceList(CyConst.DEVICES_CYUSB); MyDevice = usbDevices[0x04B4, 0x1003] as CyUSBDevice; }
public void prepareEX() { USBDeviceList usbDevices = new USBDeviceList(CyConst.DEVICES_CYUSB); CyUSBDevice MyDevice = usbDevices[0x04B4, 0x1003] as CyUSBDevice; if (MyDevice != null) { MyDevice.Reset(); Thread.Sleep(1000); MyDevice.ReConnect(); Thread.Sleep(1000); if (MyDevice.BulkInEndPt != null) { MyDevice.BulkInEndPt.Reset(); } if (MyDevice.BulkOutEndPt != null) { MyDevice.BulkInEndPt.TimeOut = 500; for (int i = 0; i < 640 * 480 * 2 / 512; i++) { int len = 512; byte[] buf = new byte[len]; if (false == MyDevice.BulkInEndPt.XferData(ref buf, ref len, true)) { ready = true; break; } } } } return; }
public Fx2Device(CyUSBDevice usbDevice, MonoUsbProfile usbProfile, EDeviceType deviceType = EDeviceType.Unknown) { if (usbDevice != null) { USBDevice = usbDevice; } if (usbProfile != null) { USBProfile = usbProfile; } DeviceType = deviceType; if (deviceType == EDeviceType.Unknown) { Console.WriteLine($"+ {this}"); } if (deviceType == EDeviceType.DAC_SA || deviceType == EDeviceType.ADC_SA) { if (usbDevice != null) { CyBulkEndPoint outEndpoint = usbDevice.EndPointOf(0x01) as CyBulkEndPoint; CyBulkEndPoint inEndpoint = usbDevice.EndPointOf(0x81) as CyBulkEndPoint; avalonPacket = new AvalonPacket(outEndpoint, inEndpoint); } else { avalonPacket = new MonoAvalonPacket(MonoDeviceHandle); } } }
/*Summary * Search the device with VID-PID 04b4-00F1 and if found, select the end point */ private void SetDevice() { USBDevice dev = usbDevices[0x04B4, 0x00F1]; if (dev != null) { MyDevice = (CyUSBDevice)dev; GetEndpointsOfNode(MyDevice.Tree); PpxBox.Text = "8"; //Set default value to 8 Packets if (EndPointsComboBox.Items.Count > 0) { EndPointsComboBox.SelectedIndex = 0; StartBtn.Enabled = true; } Text = MyDevice.FriendlyName; } else { StartBtn.Enabled = false; EndPointsComboBox.Items.Clear(); EndPointsComboBox.Text = ""; Text = "C# Streamer - no device"; } }
public static bool Initialize() { bool retVal = true; m_USBDevices = new USBDeviceList(CyConst.DEVICES_CYUSB); m_USBDevices.DeviceAttached += new EventHandler(usbDevices_DeviceAttached); m_USBDevices.DeviceRemoved += new EventHandler(usbDevices_DeviceRemoved); // Get the first device having VendorID == 0x04B4 and ProductID == 0x8613 for (int i = 0; i < m_USBDevices.Count; i++) { m_CyUSBDevice = m_USBDevices[i] as CyFX3Device; if ((m_CyUSBDevice != null) && (m_CyUSBDevice.ProductID == 0x4720)) { //Fr.BootProgrammerDeviceFound(); break; } } //m_CyUSBDevice = m_USBDevices[0x04B4, 0x00F0] as CyUSBDevice; if (m_CyUSBDevice != null) { Status = m_CyUSBDevice.FriendlyName + " connected."; m_EndPoint = m_CyUSBDevice.EndPoints[0]; } else { m_EndPoint = null; } return(retVal); }
public bool ReadFWCommand(ref byte[] inBuffer) { bool retValue = false; try { int buffCnt = 512; m_USBDevices = new USBDeviceList(CyConst.DEVICES_CYUSB); FxDev = m_USBDevices[0] as CyUSBDevice; bulkEpt = FxDev.BulkOutEndPt; retValue = bulkEpt.XferData(ref inBuffer, ref buffCnt, false); Thread.Sleep(50); bulkEpt = FxDev.BulkInEndPt; if (bulkEpt != null) { inBuffer = new byte[512]; retValue = bulkEpt.XferData(ref inBuffer, ref buffCnt, false); } } catch (Exception ex) { retValue = false; } return(retValue); }
public bool findDevices() { this.usbDevices = new USBDeviceList((byte)1); this.usbDevices = this.listDevices(); this.device = this.usbDevices[this.vendorId, this.productId] as CyUSBDevice; return(true); }
public static byte[] ReceiveVendorResponse(CyUSBDevice usbDevice, MonoUsbDeviceHandle monoDeviceHandle, byte reqCode, int length, ushort value = 0, ushort index = 0) { if (usbDevice != null) { CyControlEndPoint ctrlEpt = usbDevice.ControlEndPt; ctrlEpt.TimeOut = TIMEOUT; ctrlEpt.Direction = CyConst.DIR_FROM_DEVICE; ctrlEpt.ReqType = CyConst.REQ_VENDOR; ctrlEpt.Target = CyConst.TGT_DEVICE; ctrlEpt.ReqCode = reqCode; ctrlEpt.Value = value; ctrlEpt.Index = index; int bytes = length; byte[] buffer = new byte[bytes]; ctrlEpt.XferData(ref buffer, ref bytes); if (bytes == buffer.Length) { return(buffer); } } else { short bytes = (short)length; byte[] data = new byte[bytes]; byte requestType = CyConst.DIR_FROM_DEVICE + CyConst.REQ_VENDOR + CyConst.TGT_DEVICE; int ret = MonoUsbApi.ControlTransfer(monoDeviceHandle, requestType, reqCode, (short)value, (short)index, data, bytes, TIMEOUT); if (ret == data.Length) { return(data); } } return(null); }
public Form1() { InitializeComponent(); USBDeviceList usbDevices = new USBDeviceList(CyConst.DEVICES_CYUSB); MyDevice = usbDevices[0] as CyUSBDevice; if (MyDevice != null) { CtrlEndPt = MyDevice.ControlEndPt; } else { labelCardStatus.Text = "No acquisition card was found"; buttonStart.Enabled = false; } resolutionCombo.SelectedIndex = 2; listView1.View = View.Details; listView1.GridLines = true; listView1.Columns.Add("SN"); listView1.Columns.Add("CH_A"); listView1.Columns.Add("CH_B"); }
/* * // This one must be corrected, cause trouble * public static bool TE_USB_FX2_DisplayDriverInformation(ref CyUSBDevice TE_USB_FX2_USBDevice, ref USBDeviceList USBdevList, int CardNumber) * { * * int CardCounted = 0; // Trenz Board * int DeviceNumber = 0; // Cypress Board ( number >= TrenzBoard) * * int CypressDeviceNumber = 0; * int TrenzDeviceNumber = 0; * * UInt16 PID = 0x0000; * UInt16 VID = 0x0000; * * uint DriverVersion1 = 0; * * string DriverName1 = null; * * //Creation of a list of USB device that use the CYUSB.SYS driver * USBdevList = new USBDeviceList(CyConst.DEVICES_CYUSB); * //If exist at least an USB device that use the CYUSB.SYS driver, * //I search and count the number of these devices that are of Trenz Electronic * if (USBdevList.Count != 0) * { * foreach (USBDevice USBdev in USBdevList) * { * PID = USBdev.ProductID; * VID = USBdev.VendorID; * //Number of Cypress Card augmented by one * CypressDeviceNumber++; * if ((((PID == 0x0300) && (VID == 0x0bd0)) == true)) //0x0bd0 . 0x0bd0 * { * //Number of Trenz Card (a subcategory of Cypress Card) augmented by one * //CardCount++; * TrenzDeviceNumber++; * Console.WriteLine("PID e VID: {0}, {1}", PID, VID); * // CardNumber=TrenzDeviceNumber-1 by definition. * if ((TrenzDeviceNumber - 1) == CardNumber) * { * //I store the DeviceNumber that identify the Trenz Card (CardNumber) requested * DeviceNumber = CypressDeviceNumber - 1; * Console.WriteLine("DeviceNumber: {0}", DeviceNumber); * } * } * } * } * * //At this point I memorize the Cards Counted and zeroed the variable that I have used in the counting. * CardCounted = TrenzDeviceNumber; * //Console.WriteLine("CardCounted: {0}", CardCount); * TrenzDeviceNumber = 0; * //Now I search the Trenz USB Device with the Card Number (CardNo) specified * if (((CardNumber >= 0) && (CardNumber < CardCounted)) == true) //CardCounted * { * USBDevice USBdev = USBdevList[DeviceNumber]; * PID = USBdev.ProductID; * VID = USBdev.VendorID; * if ((((PID == 0x0300) && (VID == 0x0bd0)) == true)) * { * TE_USB_FX2_USBDevice = USBdev as CyUSBDevice; * Console.WriteLine("USBdev {0} ", TE_USB_FX2_USBDevice); * * //I cast the abstract USBdev in a concrete CyUSBDevice * TE_USB_FX2_USBDevice = USBdev as CyUSBDevice; * DriverVersion1 = TE_USB_FX2_USBDevice.DriverVersion; * Console.WriteLine("DriverVersion {0} ", DriverVersion1); * DriverName1 = TE_USB_FX2_USBDevice.DriverName; * Console.WriteLine("Original Name of the Driver {0} ", DriverName1); * * return true; * } * else * { * TE_USB_FX2_USBDevice = null; * return false; * } * } * else * { * TE_USB_FX2_USBDevice = null; * return false; * } * } */ /* * * 3.4 TE_USB_FX2_SendCommand() * * 3.4.1 Declaration * public static bool TE_USB_FX2_SendCommand(ref CyUSBDevice TE_USB_FX2_USBDevice, ref byte[] Command, ref int CmdLength, * ref byte[] Reply, ref int ReplyLength, uint Timeout) * * 3.4.2 Function Call * Your application program shall call this function like this: * TE_USB_FX2.TE_USB_FX2.TE_USB_FX2_SendCommand (ref TE_USB_FX2_USBDevice, ref Command, ref CmdLength, ref Reply, * ref ReplyLength, Timeout); * * 3.4.3 Description * This function takes an already initialized USB device (previously selected by TE_USB_FX2_Open()) and sends a command *(API command) to the USB FX2 microcontroller (USB FX2 API command) or to the MicroBlaze embedded processor *(MicroBlaze API command) through the USB FX2 microcontroller endpoint EP1 buffer. * This function is normally used to send 64 bytes packets to the USB endpoint EP1 (0x01). * This function is also able to obtain the response of the USB FX2 microcontroller or MicroBlaze embedded processor through * the USB FX2 microcontroller endpoint EP1 (0x81). * 3.4.4 Parameters * 1. ref CyUSBDevice TE_USB-FX2_USBDevice * CyUSBDevice is a type defined in CyUSB.dll. This parameter points to the module selected by TE_USB_FX2_Open(). * This parameter is passed by reference (ref). See pages 70-93 of CyUSB.NET.pdf (Cypress CyUSB .NET DLL Programmer's Reference) * 2. ref byte[] Command * This parameter is passed by reference (ref). It is the byte array that contains the commands to send to USB FX2 microcontroller *(FX2_Commands) or to the MicroBlaze embedded processor (MB_Commands). * The byte array shall be properly initialized using instructions similar to the following ones: * Command[0] = (byte)FX2_Commands.I2C_WRITE; * Command[1] = (byte)FX2_Commands.MB_I2C_ADDRESS; * Command[2] = (byte)FX2_Commands.I2C_BYTES; * Command[3] = (byte)0; * Command[4] = (byte)0; * Command[5] = (byte)0; * Command[6] = (byte)Command2MB; * 3. ref int CmdLength * This parameter (passed by reference (ref)) is the length (in bytes) of the previous byte array; it is the length of the * packet to transmit to USB FX2 controller endpoint EP1 (0x01). It is typically initialized to 64 bytes. * 4. ref byte[] Reply * This parameter (passed by reference (ref)) is the byte array that contains the response to the command sent to the * USB FX2 microcontroller (FX2_Commands) or to the MicroBlaze embedded processor (MB_Commands). * 5. ref int ReplyLength * This parameter (passed by reference (ref)) is the length (in bytes) of the previous byte array; it is the length of * the packet to transmit to the USB FX2 microcontroller endpoint EP1 (0x81). It is typically initialized to 64 byes, * but normally the meaningful bytes are less. The parameter is a reference, meaning that the method can modify its value. * The number of bytes actually received is passed back in ReplyLength. * 6. uint Timeout * The unsigned integer value is the time in milliseconds assigned to the synchronous method XferData() of data transfer used * by CyUSB.dll. * Timeout is the time that is allowed to the function for sending/receiving the data packet passed to the function; * this timeout shall be large enough to allow the data/command transmission/reception. Otherwise the transmission/reception will fail. See 1.1.2 Timeout Setting. * 3.4.5 Return Value * 1. bool : logical type * This function returns true if it is able to send a command to EP1 and receive a response within 2*Timeout milliseconds. * This function returns false otherwise. * */ /// <summary> /// ///// /// </summary> /// <param name="TE03xxUSBdevice"></param> /// <param name="Command"></param> /// <param name="CmdLength"></param> /// <param name="Reply"></param> /// <param name="ReplyLength"></param> /// <param name="Timeout"></param> /// <returns></returns> public static bool TE_USB_FX2_SendCommand(ref CyUSBDevice TE_USB_FX2_USBDevice, ref byte[] Command, ref int CmdLength, ref byte[] Reply, ref int ReplyLength, uint Timeout) { bool bResultCommand = false; bool bResultReply = false; //Concrete class CyBulkEndPoint inEndpoint1 = null; CyBulkEndPoint outEndpoint1 = null; if (TE_USB_FX2_USBDevice != null) { //CyBulkEndPoint TE03xxUSBDeviceConcrete = TE03xxUSBdevice as CyBulkEndPoint; //Select the endpoint of IN number 1 (EP1 INPUT) inEndpoint1 = TE_USB_FX2_USBDevice.EndPointOf(0x81) as CyBulkEndPoint; //Select the endpoint of OUT number 1 (EP1 OUTPUT) outEndpoint1 = TE_USB_FX2_USBDevice.EndPointOf(0x01) as CyBulkEndPoint; // Set the timeout outEndpoint1.TimeOut = Timeout; inEndpoint1.TimeOut = Timeout; //calls the XferData function for bulk transfer(OUT) in the cyusb.dll bResultCommand = outEndpoint1.XferData(ref Command, ref CmdLength); //Console.WriteLine("bResultCommand {0} ", bResultCommand); //Console.WriteLine("Command[0] {0:X2} ", Command[0]); //Console.WriteLine("CmdLength {0} ", CmdLength); //uint inUSBstatus1 = inEndpoint1.UsbdStatus; //Console.WriteLine("UsbdStatus {0:X8} e ", inUSBstatus1); //uint inUSBstatus2 = inEndpoint1.NtStatus; //Console.WriteLine("NtStatus {0:X8} e ", inUSBstatus2); if (bResultCommand == true) { //calls the XferData function for bulk transfer(IN) in the cyusb.dll bResultReply = inEndpoint1.XferData(ref Reply, ref ReplyLength); //Console.WriteLine("bResultReply {0} ", bResultReply); } else { return(false); } if ((bResultCommand && bResultReply) == true) { return(true); } else { return(false); } } else { return(false); } }
internal void Init(CyUSBDevice usbDevice) { this.USB3 = usbDevice.bSuperSpeed; this.InitEndInPoints(usbDevice); this.cameraBufferLength = this.InEndpt.MaxPktSize; this.USB3 = this.cameraBufferLength != 512; this.buffers = new byte[this.cameraBufferLength]; }
private void SetDevice() { MyDevice = usbDevices[M280DEF.USB_VID, M280DEF.USB_PID] as CyUSBDevice; if (MyDevice != null) { // USB High Speed Check /* * if (MyDevice.bHighSpeed == false) * { * MessageBox.Show("M280 supports USB2.0 only."); * MyDevice = null; * inEndpoint = null; * ep0 = null; * } * else */ if (inEndpoint == null) { // Set the IN and OUT endpoints inEndpoint = MyDevice.EndPointOf(0x86) as CyBulkEndPoint; ep0 = MyDevice.ControlEndPt; // Set time out inEndpoint.TimeOut = M280DEF.TRANSFER_TIMEOUT; ep0.TimeOut = M280DEF.TRANSFER_TIMEOUT; // Get Image Info GetImageInfo(); // Initialize Camera module SendCommand(M280DEF.CMD_INIT_CAMERA, 0, 0); // Turn on USB connected LED //ST: Comment as we move the code to service //labUSBConImg.Image = global::M280_SampleApp.Properties.Resources.green3; // Start Check status //ST: Comment as we move the code to service //this.timCheckStatus.Start(); } } else { inEndpoint = null; ep0 = null; // Turn off USB connected LED //ST: Comment as we move the code to service //labUSBConImg.Image = global::M280_SampleApp.Properties.Resources.gray3; //labSysReadyImg.Image = global::M280_SampleApp.Properties.Resources.gray3; //labReadyImg.Image = global::M280_SampleApp.Properties.Resources.gray3; //labBusyImg.Image = global::M280_SampleApp.Properties.Resources.gray3; //labButtonImg.Image = global::M280_SampleApp.Properties.Resources.gray3; //// Stop checking status thread //this.timCheckStatus.Stop(); this.bInitM280 = false; this.bSysBusy = false; } }
internal void Init(CyUSBDevice usbDevice) { this.camProperties.Init(usbDevice); this.camComLayer.Init(usbDevice); this.ReadCMOSRegisters(); this.ReadCalibration(); this.camComLayer.SendCalibration(ref this.camProperties.calibration); this.camImg = new BCamImg(2048, this.GetImageMaxHeightSize()); }
/* * 3.6 TE_USB_FX2_SetData() * * 3.6.1 Declaration * public static bool TE_USB_FX2_SetData(ref CyUSBDevice TE_USB_FX2_USBDevice, ref byte[] DataWrite, ref int DataWriteLength, * int PipeNo, uint Timeout, int BufferSize) * * 3.6.2 Function Call * Your application program shall call this function like this: * TE_USB_FX2.TE_USB_FX2.TE_USB_FX2_SetData(ref TE_USB_FX2_USBDevice, ref DataWrite, ref DataWriteLength, PI_EP8, Timeout, * BufferSize); * * 3.6.3 Description * This function takes an already initialized USB device (CyUSBDevice is a type defined in CyUSB.dll), selected by * TE_USB_FX2_Open(), and writes data to the USB FX2 microcontroller endpoint EP8 (0x08). This data is then passed to the FPGA. * If there is not a proper connection (not using FX22MB_REG0_START_RX) between FPGA and USB FX2 microcontroller, * the function can experience a strange behavior. For example, a very low throughput (9-10 Mbyte/s even if a 22-24 Mbyte/s are * expected) is measured or the function fails returning false. These happen because buffer EP8 (the HW buffer, not the * SW buffer of the driver whose size is given by BufferSize parameter) is already full (it is not properly read/emptied by the * FPGA) and no longer able to receive further packets. * 3.6.4 Data throughput expected * The maximum data throughput expected (with a DataWriteLength= 120*10^6) is 24 Mbyte/s (PacketSize = BufferSize =131,072) * but in fact this value is variable between 22-24 Mbyte/s (the mean value seems 24 Mbyte/s); so if you measure this range * of values, the data reception can be considered normal. * The data throughput is variable in two way: * 1. depends on which host computer is used (on some host computers this value is even higher: 29 Mbyte/s) * 2. vary with every function call * 3.6.5 DataWrite size shall not be too large * TE_USB_FX2_SetData() seems unable to use too large arrays or, more precisely, this fact seems variable by changing host * computer. To be safe, do not try to transfer in a single packet very large data (120 millions of byte); transfer the same * data with many packets (1,200 packets * 100,000 byte) and copy the data in a single large data array if necessary (with * Buffer.BlockCopy()). Buffer.BlockCopy seems not to hinder throughput too much (max 2 Mbyte/s). * 3.6.5.1 Reduced version (pseudo code) * PACKETLENGTH=100000; * packets=1200; * byte[] data = new byte[packetlen*packets]; * byte[] buffer = new byte[packetlen]; * for (int i = 0; i < packets; i++) * { * Buffer.BlockCopy(data, total_cnt, buffer, 0, packetlen); * TE_USB_FX2_SetData(ref TE_USB_FX2_USBDevice, ref buffer, ref packetlen, PI_EP8, TIMEOUT_MS,BUFFER_SIZE); * total_cnt += packetlen; * } * 3.6.5.2 Expanded version (code) * SendFPGAcommand(ref TE_USB_FX2_USBDevice, MB_Commands.FX22MB_REG0_START_RX, TIMEOUT_MS); * //ElapsedTime.Start(); //StopWatch start * Stopwatch stopWatch = new Stopwatch(); * stopWatch.Start(); * for (int i = 0; i < packets; i++) * { * packetlen = PACKETLENGTH; * Buffer.BlockCopy(data, total_cnt, buffer, 0, packetlen); * if (TE_USB_FX2.TE_USB_FX2.TE_USB_FX2_SetData(ref TE_USB_FX2_USBDevice, ref buffer, ref packetlen, PI_EP8, TIMEOUT_MS, * BUFFER_SIZE) == false) errors++; * else total_cnt += packetlen; * } * //total_cnt += (packetlen * packets); * stopWatch.Stop(); * 3.6.6 DataWrite size shall not be too small * The reason is described in section 1.1.4 PacketSize. * PacketSize has also a strong influence on DataThroughput. If PacketSize is too small (512 byte for example) you can achieve * very low data throughput (2.2 Mbyte/s) even if you use a large driver buffer (driver buffer size = 131,072 byte). * See 6 TE_USB_FX2_CyUSB.dll: Data Transfer Throughput Optimization. * * 3.6.7 Parameters * 1. ref CyUSBDevice TE_USB-FX2_USBDevice * This parameter is passed by reference (ref). It points to the module selected by TE_USB_FX2_Open(). See pages 70-93 of * CyUSB.NET.pdf (Cypress CyUSB .NET DLL Programmer's Reference) * 2. ref byte[] DataWrite * This parameter is passed by reference (ref). C# applications use directly TE_USB_FX2_CyUSB.dll based on CyUSB.dll. To avoid * copying back and forth large amount of data between these two DLLs, data is passed by reference and not by value. * This parameter points to the byte array that contains the data to be written to buffer EP8 (0x08) of USB FX2 microcontroller. * Data contained in EP8 are then read by the FPGA. * 3. ref int DataWriteLength * This parameter is passed by reference (ref). This parameter is the length (in bytes) of the previous byte array; * it is the length of the packet read from FX2 USB endpoint EP6 (0x86). Normally it is PacketLength. * 4. int PipeNumber * This parameter is the value that identify the endpoint used for the data transfer. It is called PipeNumber because it * identifies the buffer (pipe) used by the USB FX2 microcontroller. * 5. uint Timeout. * The unsigned integer value is the time in milliseconds assigned to the synchronous method XferData() of data transfer used by * CyUSB.dll. * Timeout is the time that is allowed to the function for sending/receiving the data packet passed to the function; this * timeout shall be large enough to allow the data/command transmission/reception. Otherwise the transmission/reception will * fail. See 1.1.2 Timeout Setting. * 6. int BufferSize * The integer value is the dimension (in bytes) of the driver buffer (SW) used in data transmission of a single endpoint * (EP8 0x08 in this case); the total buffer size is the sum of all BufferSize of every endpoint used. * The BufferSize has a strong influence on DataThroughput. If BufferSize is too small, DataThroughput can be 1/3-1/2 of * the maximum value (from a maximum value of 24 Mbyte/s for write transactions to an actual value of 14 Mbyte/s). * If BufferSize has a large value (a roomy buffer), the program shall be able to cope with the non-deterministic behavior of * C# without losing packets. * * 3.6.8 Return Value * 1. bool: logical type * This function returns true if it is able to write data to buffer EP8 within Timeout milliseconds. * This function returns false otherwise. * */ public static bool TE_USB_FX2_SetData(ref CyUSBDevice TE_USB_FX2_USBDevice, ref byte[] DataWrite, ref int DataWriteLength, int PipeNo, uint Timeout, int BufferSize) //public static bool TE_USB_FX2_SetData(ref CyBulkEndPoint outEndpointPipeNo, ref byte[] DataWrite, ref int DataWriteLength) { bool bResultDataRead = false; byte PipeNoHex = 0x00; CyBulkEndPoint outEndpointPipeNo = null; //Shortest and more portable way to select the Address using the PipeNumber if (PipeNo == 8) { PipeNoHex = 0x08; } else { PipeNoHex = 0x00; } if ((TE_USB_FX2_USBDevice != null) && (PipeNoHex == 0x08)) { outEndpointPipeNo = TE_USB_FX2_USBDevice.EndPointOf(PipeNoHex) as CyBulkEndPoint; outEndpointPipeNo.TimeOut = Timeout; //int MaxPacketSize= outEndpointPipeNo.MaxPktSize; //Console.WriteLine("MaxPacketSize {0} ", MaxPacketSize); //int XferSize1 = outEndpointPipeNo.XferSize; //Console.WriteLine("XferSize {0} ", XferSize1); //outEndpointPipeNo.XferMode = XMODE.DIRECT; outEndpointPipeNo.XferSize = BufferSize;// 131072; //calls the XferData function for bulk transfer(IN) in the cyusb.dll bResultDataRead = outEndpointPipeNo.XferData(ref DataWrite, ref DataWriteLength); //Console.WriteLine("bResultDataRead {0} ", bResultDataRead); //uint inUSBstatus1 = outEndpointPipeNo.UsbdStatus; //Console.WriteLine("UsbdStatus {0:X8} e ", inUSBstatus1); //uint inUSBstatus2 = outEndpointPipeNo.NtStatus; //Console.WriteLine("NtStatus {0:X8} e ", inUSBstatus2); if (bResultDataRead == true) { return(true); } else { return(false); } } else { return(false); } }
public void GetDevice() { if (DeviceAttached == true) { myDevice = usbDevices[0x04b4, 0x00F1] as CyUSBDevice; // check for device with VID/PID of 0x04B4/0x1002 myFX3Device = usbDevices[0x04B4, 0x00F3] as CyFX3Device; if ((myFX3Device != null) && (myDevice == null)) // If myDevice exists { button1.Enabled = true; button2.Enabled = false; button3.Enabled = false; StatLabel1.Text = "NEXT STEP: Use Download Firmware button to load image into FX3"; rtConsole.AppendText("EZ-USB FX3 Bootloader Device connected\n"); } else if ((myDevice != null) && (myFX3Device == null)) // If myDevice exists { BulkOutEndPt = myDevice.EndPointOf(0x02) as CyBulkEndPoint; //Assign EP2 as BulkOutEP and EP6 as BulkInEP button3.Enabled = true; button1.Enabled = false; button2.Enabled = false; rtConsole.AppendText("FX3 - Xilinx Slave Serial Programmer detected\n"); StatLabel1.Text = "NEXT STEP: Use Select Bitstream button to select the .bin file for FPGA "; } else if ((firmwaredownloaded) && (myDevice != null)) { button1.Enabled = false; rtConsole.AppendText("NO FX3 - Xilinx Slave Serial Programmer detected\n"); StatLabel1.Text = "NEXT STEP: Reset the FX3 board and Download the right image into FX3"; } else { button1.Enabled = false; button2.Enabled = false; button3.Enabled = false; rtConsole.AppendText("No EZ-USB FX3 device is connected\n"); StatLabel1.Text = "NEXT STEP: Connect EZ-USB FX3 board to PC using an USB cable"; DeviceAttached = false; } } if (DeviceAttached == false) { DisableApp(); // there is either no device attached or the attached device is not a FX2 } else { EnableApp(); // the attached device is a FX2LP with our VID/PID } }
public DDSUSBChip(CyUSBDevice CyUSBDevice) { cyUSBDevice = CyUSBDevice; // Switch to interface 1 which provides several Endpoints cyUSBDevice.AltIntfc = 1; // Define Endpoints EP1OUT = cyUSBDevice.EndPointOf(0x01); EP1IN = cyUSBDevice.EndPointOf(0x81); EP2OUT = cyUSBDevice.EndPointOf(0x02); }
public static bool SendFPGAcommand(ref CyUSBDevice TE_USB_FX2_USBDevice, MB_Commands Command, uint Timeout) { if (TE_USB_FX2_USBDevice == null) { Console.WriteLine("Error,no device is selected"); return(false); } bool bResultCommand_FX22MB = false; byte[] cmd_FX22MB_REG0 = new byte[64]; byte[] reply_FX22MB_REG0 = new byte[64]; int cmd_length_FX22MB_REG0 = 64; int reply_length_FX22MB_REG0 = 64; //Command layout: //0xAD - Command type I2C write //0x3F - Address (I2C address of Microblaze) //0x0C - I2C_BYTES //0x00 - FX22MB_REG0_NOP //0x00 - FX22MB_REG0_NOP //0x00 - FX22MB_REG0_NOP //0x?? - Command //0x AD 3F 0C 00 00 00 ?? cmd_FX22MB_REG0[0] = (byte)FX2_Commands.I2C_WRITE; cmd_FX22MB_REG0[1] = (byte)FX2_Parameters.MB_I2C_ADDRESS; cmd_FX22MB_REG0[2] = (byte)FX2_Parameters.I2C_BYTES; cmd_FX22MB_REG0[3] = (byte)MB_Commands.FX22MB_REG0_NOP; cmd_FX22MB_REG0[4] = (byte)MB_Commands.FX22MB_REG0_NOP; cmd_FX22MB_REG0[5] = (byte)MB_Commands.FX22MB_REG0_NOP; cmd_FX22MB_REG0[6] = (byte)Command; bResultCommand_FX22MB = TE_USB_FX2.TE_USB_FX2.TE_USB_FX2_SendCommand(ref TE_USB_FX2_USBDevice, ref cmd_FX22MB_REG0, ref cmd_length_FX22MB_REG0, ref cmd_FX22MB_REG0, ref reply_length_FX22MB_REG0, Timeout); //bResultCommand_FX22MB_REG0_START = inEndpointCmd.XferData(ref cmd_FX22MB_REG0_START, ref cmd_length_FX22MB_REG0_START); //Console.WriteLine("bResultCommand_FX22MB_REG0_START {0}", bResultCommand_FX22MB_REG0_START); //bResultReply_FX22MB_REG0_START = outEndpointCmd.XferData(ref reply_FX22MB_REG0_START, ref reply_length_FX22MB_REG0_START); //END //Console.WriteLine("bResultReply_FX22MB_REG0_START {0}", bResultReply_FX22MB_REG0_START); if (bResultCommand_FX22MB) { return(true); } else { return(false); } }
/*Summary * Search the device with VID-PID 04b4-00F1 and if found, select the end point */ private void SetDevice(bool bPreserveSelectedDevice) { int nCurSelection = 0; if (DevicesComboBox.Items.Count > 0) { nCurSelection = DevicesComboBox.SelectedIndex; DevicesComboBox.Items.Clear(); } int nDeviceList = usbDevices.Count; for (int nCount = 0; nCount < nDeviceList; nCount++) { USBDevice fxDevice = usbDevices[nCount]; String strmsg; strmsg = "(0x" + fxDevice.VendorID.ToString("X4") + " - 0x" + fxDevice.ProductID.ToString("X4") + ") " + fxDevice.FriendlyName; DevicesComboBox.Items.Add(strmsg); } if (DevicesComboBox.Items.Count > 0) { DevicesComboBox.SelectedIndex = ((bPreserveSelectedDevice == true) ? nCurSelection : 0); } USBDevice dev = usbDevices[DevicesComboBox.SelectedIndex]; if (dev != null) { MyDevice = (CyUSBDevice)dev; GetEndpointsOfNode(MyDevice.Tree); PpxBox.Text = "16"; //Set default value to 8 Packets QueueBox.Text = "8"; if (EndPointsComboBox.Items.Count > 0) { EndPointsComboBox.SelectedIndex = 0; StartBtn.Enabled = true; } else { StartBtn.Enabled = false; } Text = MyDevice.FriendlyName; } else { StartBtn.Enabled = false; EndPointsComboBox.Items.Clear(); EndPointsComboBox.Text = ""; Text = "C# Streamer - no device"; } }
private void usbDevices_DeviceRemoved(object sender, EventArgs e) { // release usb device _isUSBAvailable = false; if (loopDevice != null) { loopDevice.Dispose(); } loopDevice = null; // intDevice(); OnDeviceRemoved(); }