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);
}
