public static proto_IfaceIODevice_t devproxy_create() { global::System.IntPtr cPtr = protocommPINVOKE.devproxy_create(); proto_IfaceIODevice_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new proto_IfaceIODevice_t(cPtr, false); return(ret); }
public static proto_IfaceIODevice_t device_create(proto_iodev_devices_t type) { global::System.IntPtr cPtr = protocommPINVOKE.device_create((int)type); proto_IfaceIODevice_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new proto_IfaceIODevice_t(cPtr, false); return(ret); }
public static proto_hdle_t proto_master_create(proto_IfaceIODevice_t iodevice) { global::System.IntPtr cPtr = protocommPINVOKE.proto_master_create(proto_IfaceIODevice_t.getCPtr(iodevice)); proto_hdle_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new proto_hdle_t(cPtr, false); return(ret); }
public static SWIGTYPE_p_unsigned_char devemulslave_getRegisters(proto_IfaceIODevice_t _this) { global::System.IntPtr cPtr = protocommPINVOKE.devemulslave_getRegisters(proto_IfaceIODevice_t.getCPtr(_this)); SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); return(ret); }
/// <summary> /// Performs de the connection first step : ask for permission /// </summary> /// <param name="szUsbDevName"></param> void Backend_connect(string szUsbDevName) { _szDevName = szUsbDevName; /* We call the underlying USB connection except for emulsave*/ if (_szDevName == _ilist_dllDev[(int)proto_iodev_devices_t.PROTO_DEV_EMULSLAVE]) { // So if we did not selected with the emulsave type selector we force it now _eConfDllDevice = proto_iodev_devices_t.PROTO_DEV_EMULSLAVE; proto_IfaceIODevice_t dev = _dll_if.CreateDevice(proto_iodev_devices_t.PROTO_DEV_EMULSLAVE); _IsConnected = (_dll_if.Open(dev, "") == 0); OnDeviceconnected(); } else { // Check we did not selected unappropriate device type if (_eConfDllDevice == proto_iodev_devices_t.PROTO_DEV_EMULSLAVE) { DisplayAlert("Erreur", "Device type incorrect, select another", "Annuler"); return; } // We assynchronously run the permission // everything else is a true USB device _iusbManager.RequestPermAsync(szUsbDevName); } }
public int WriteRegisterToDevice(byte uiRegister, byte value) { proto_Frame_t frame = new proto_Frame_t(); proto_Command_t cmd = proto_Command_t.proto_CMD_SET; proto_frame_data_t data = new proto_frame_data_t(); data.req.reg = uiRegister; data.req.value = value; byte nbBytes = protocomm.proto_makeFrame(frame, cmd, data); byte[] buffer = new byte[protocomm.sizeof_proto_Frame_t()]; protocomm.protoframe_serialize(frame, buffer); // Create a protocole instance from frame decoding (device will not be used) proto_IfaceIODevice_t protodev = protocomm.devemulslave_create(); var protoHdle = protocomm.proto_master_create(protodev); int ret = _devHandle.connection.BulkTransfer(_devHandle.ep_out, buffer, 0, buffer.Length, BULK_XFER_TOUT_MS); if (ret >= 0) { Log.Debug(DroidPandaVcom.LOG_TAG, "xfer : successfully sent nb bytes : " + ret); // Receive the reply frame // First version - take the answer with the max size possible // Remember that the protocol expect the peer to seed **at most** the max frame size. // We reuse the buffer as R/W frame size are constant ret = _devHandle.connection.BulkTransfer(_devHandle.ep_in, buffer, 0, protocomm.sizeof_proto_Frame_t(), BULK_XFER_TOUT_MS); if (ret >= 0) { ret = protocomm.proto_pushToFrame(protoHdle, buffer, (uint)ret); if (ret >= 0) { var pcmd = protocomm.new_proto_Command_t_p(); switch (protocomm.proto_decodeFrame(protoHdle, pcmd, data)) { case proto_DecodeStatus_t.proto_COMPLETED: ret = (protocomm.proto_Command_t_p_value(pcmd) == proto_Command_t.proto_CMD_REPLY) ? 0 : 1; break; case proto_DecodeStatus_t.proto_REFUSED: ret = -1; break; default: break; } protocomm.delete_proto_Command_t_p(pcmd); } } else { Log.Debug(DroidPandaVcom.LOG_TAG, "xfer : failed to sent bytes"); } } return(ret); }
/// <summary> /// Initialize library /// </summary> /// <param name="device"> device pour la connexion </param> /// <param name="szPath"> path à passer au protocole </param> /// <returns> 0 if OK, otherwise < 0</returns> public int Open(proto_IfaceIODevice_t device, string szPath) { int ret = 0; m_device = device; // On cree l'instance de protocole m_handle = protocomm.proto_master_create(m_device); //5s de timeout TODO a moditifer plus tard pour le rendre paramètrable //On vérifie qu'il n'y a pas eu de problème lors de la connexion if (m_handle == null) { return(-1); } ret = protocomm.proto_master_open(m_handle, szPath); if (ret != 0) { return(-1); } return(ret); }
public static int devserial_setFD(proto_IfaceIODevice_t _this, int fd) { int ret = protocommPINVOKE.devserial_setFD(proto_IfaceIODevice_t.getCPtr(_this), fd); return(ret); }
public int UsbDevSetFd(proto_IfaceIODevice_t dev, DevHandle devh) { int ret = protocomm.devusbdev_setDev(dev, devh.fd, devh.ep_in, devh.ep_out, devh.max_pkt_size); return(ret); }
public int LibUsbSetFd(proto_IfaceIODevice_t dev, DevHandle devh) { int ret = protocomm.devlibusb_setFD(dev, devh.fd, devh.ep_in, devh.ep_out, devh.max_pkt_size); return(ret); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(proto_IfaceIODevice_t obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public int SerialSetFd(proto_IfaceIODevice_t dev, DevHandle devh) { int ret = protocomm.devserial_setFD(dev, devh.fd); return(ret); }
public static void proto_init(proto_hdle_t _this, proto_IfaceIODevice_t iodevice) { protocommPINVOKE.proto_init(proto_hdle_t.getCPtr(_this), proto_IfaceIODevice_t.getCPtr(iodevice)); }
/* TODO : put in common with the write register method */ public int ReadRegisterFromDevice(byte uiRegister, ref byte value) { // Build the request frame using dllCom proto_Frame_t frame = new proto_Frame_t(); proto_Command_t cmd = proto_Command_t.proto_CMD_GET; proto_frame_data_t data = new proto_frame_data_t(); data.req.reg = uiRegister; data.req.value = 0; byte nbBytes = protocomm.proto_makeFrame(frame, cmd, data); byte[] buffer = new byte[protocomm.sizeof_proto_Frame_t()]; protocomm.protoframe_serialize(frame, buffer); // Create a protocole instance from frame decoding (device will not be used) proto_IfaceIODevice_t protodev = protocomm.devemulslave_create(); var protoHdle = protocomm.proto_master_create(protodev); // Send request and receive reply int ret = _devHandle.connection.BulkTransfer(_devHandle.ep_out, buffer, 0, buffer.Length, BULK_XFER_TOUT_MS); if (ret >= 0) { Log.Debug(DroidPandaVcom.LOG_TAG, "xfer : successfully sent nb bytes : " + ret); // Receive the reply frame // First version - take the answer with the max size possible // TODO : Handle timeout as done by the library and returns its error. // We reuse the buffer as R/W frame size are constant ret = _devHandle.connection.BulkTransfer(_devHandle.ep_in, buffer, 0, protocomm.sizeof_proto_Frame_t(), BULK_XFER_TOUT_MS); if (ret >= 0) { ret = protocomm.proto_pushToFrame(protoHdle, buffer, (uint)ret); if (ret >= 0) { var pcmd = protocomm.new_proto_Command_t_p(); switch (protocomm.proto_decodeFrame(protoHdle, pcmd, data)) { case proto_DecodeStatus_t.proto_COMPLETED: if (protocomm.proto_Command_t_p_value(pcmd) == proto_Command_t.proto_CMD_REPLY) { value = data.reg_value; ret = 0; } else { ret = -1; } break; case proto_DecodeStatus_t.proto_REFUSED: ret = -1; break; default: break; } protocomm.delete_proto_Command_t_p(pcmd); } } else { Log.Debug(DroidPandaVcom.LOG_TAG, "read : failed to read nb bytes"); } } else { Log.Debug(DroidPandaVcom.LOG_TAG, "write : failed to sent nb bytes"); } return(ret); }
public static int devlibusb_getFD(proto_IfaceIODevice_t _this) { int ret = protocommPINVOKE.devlibusb_getFD(proto_IfaceIODevice_t.getCPtr(_this)); return(ret); }
public static int devlibusb_setFD(proto_IfaceIODevice_t _this, int fd, int ep_in, int ep_out, int max_pkt_size) { int ret = protocommPINVOKE.devlibusb_setFD(proto_IfaceIODevice_t.getCPtr(_this), fd, ep_in, ep_out, max_pkt_size); return(ret); }
private void Backend_OnPermReqCompleted(object sender, bool bPermissionGranted) { // Permission has been granted so ask for connection if (bPermissionGranted == true) { proto_IfaceIODevice_t dev = _dll_if.CreateDevice(_eConfDllDevice); int ret = 0; switch (_eConfDllDevice) { case proto_iodev_devices_t.PROTO_DEV_EMULSLAVE: break; case proto_iodev_devices_t.PROTO_DEV_SERIAL: ret = _dll_if.SerialSetFd(dev, _iusbManager.GetDeviceConnection()); if (ret == 0) { _IsConnected = (0 == _dll_if.Open(dev, "")); } ; break; case proto_iodev_devices_t.PROTO_DEV_USBDEV: ret = _dll_if.UsbDevSetFd(dev, _iusbManager.GetDeviceConnection()); if (ret == 0) { _IsConnected = (0 == _dll_if.Open(dev, "")); } break; case proto_iodev_devices_t.PROTO_DEV_LIBUSB: ret = _dll_if.LibUsbSetFd(dev, _iusbManager.GetDeviceConnection()); if (ret == 0) { _IsConnected = (0 == _dll_if.Open(dev, _szDevName)); } break; case proto_iodev_devices_t.PROTO_DEV_PROXY: _iusbProxy = new UsbProxy(); _iusbProxy.SetIUsbManager(ref _iusbManager); if (_iusbProxy.Start(_usConfProxyPort)) { string szProxyUrl = _iusbProxy.GetListenIpAddr() + protocomm.PROXY_URL_SEP + _usConfProxyPort.ToString(); _IsConnected = (0 == _dll_if.Open(dev, szProxyUrl)); if (!_IsConnected) { _iusbProxy.Stop(); } } break; default: break; } } else { // OUPS ! We did not have the permission // Cancel connection string szLog = "Permission to access USB device was not granted , cancelling"; _logfile.Info(szLog, ""); // Pour le stockage dans le fichier _lisLogs.Insert(0, DateTime.Now.ToString(" HH:mm ") + " " + szLog); //Pour l'affichage en temps réelle dans la dialogue } // Update GUI state OnDeviceconnected(); }
public static void devemulslave_getFlags(proto_IfaceIODevice_t _this, SWIGTYPE_p_unsigned_char FLAGS) { protocommPINVOKE.devemulslave_getFlags(proto_IfaceIODevice_t.getCPtr(_this), SWIGTYPE_p_unsigned_char.getCPtr(FLAGS)); }
public static void devemulslave_setFlags(proto_IfaceIODevice_t _this, byte FLAGS) { protocommPINVOKE.devemulslave_setFlags(proto_IfaceIODevice_t.getCPtr(_this), FLAGS); }