public STM32SerialPort(UsbDevice device,
int portNumber,
IUsbSerialDriver driver) : base(device, portNumber)
{
Driver = driver;
ENABLE_ASYNC_READS = true;
}
private void WireupUsb(IUsbSerialDriver device)
{
UsbManager manager = (UsbManager)GetSystemService(UsbService);
var port1 = device.Ports[0];
UsbDeviceConnection connection = manager.OpenDevice(device.Device);
port1.Open(connection);
port1.SetParameters(115200, DataBits._8, StopBits._1, Parity.None);
var buffer = new byte[500];
Log.Debug("main", "here");
var timeout = (int)TimeSpan.FromSeconds(1).TotalMilliseconds;
port1.CtsChanged += Port1_CtsChanged;
port1.Rts = true;
while (true)
{
var bytesRead = port1.Read(buffer, timeout);
if (bytesRead > 0)
{
var str = Encoding.ASCII.GetString(buffer, 0, bytesRead);
Log.Debug("card read", str);
}
Thread.Sleep(50);
}
}
//public CdcAcmSerialPort(UsbDevice device, int portNumber) : base(device, portNumber)
//{
// mEnableAsyncReads = (Build.VERSION.SdkInt >= BuildVersionCodes.JellyBeanMr1);
//}
public CdcAcmSerialPort(UsbDevice device,
int portNumber,
IUsbSerialDriver driver) : base(device, portNumber)
{
mEnableAsyncReads =
Build.VERSION.SdkInt >= BuildVersionCodes.JellyBeanMr1;
//mEnableAsyncReads = false;
Driver = driver;
}
public virtual IList <IUsbSerialDriver> FindAllDrivers(UsbManager usbManager)
{
var result = new List <IUsbSerialDriver>();
foreach (UsbDevice usbDevice in usbManager.DeviceList.Values)
{
IUsbSerialDriver driver = ProbeDevice(usbDevice);
if (driver != null)
{
result.Add(driver);
}
}
return(result);
}
public async Task <bool> ConnectDevice(ISerialDevice device, Action <byte[]> receivedDataAction)
{
_receivedDataAction = receivedDataAction ?? throw new ArgumentNullException(nameof(receivedDataAction));
var connectDevice = device as SerialDevice;
if (connectDevice == null)
{
throw new ArgumentNullException(nameof(device));
}
bool result = false;
IUsbSerialDriver driver = connectDevice.Driver;
if (await _usbManager.RequestPermissionAsync(driver.Device, _context))
{
_connectedPortManager = new PortManager(driver.Ports[0])
{
BaudRate = 115200,
DataBits = DataBits.Eight,
StopBits = StopBits.One,
Parity = Parity.None,
};
_connectedPortManager.DataReceived += (sender, args) =>
{
if (args?.Data?.Any() ?? false)
{
_receivedDataAction?.Invoke(args.Data);
}
};
_connectedPortManager.ErrorReceived += (sender, args) =>
{
Debugger.Break(); //To look at args
Debug.WriteLine($"An error occurred on the serial device: {(args?.ExceptionObject as Exception)?.ToString() ?? "(unknown)"}");
};
_connectedPortManager.Run(_usbManager);
result = true;
}
return(result);
}
private void StartBotClicked(object sender, EventArgs e)
{
serialAttached = true;
manager = (UsbManager)GetSystemService(Context.UsbService);
driver = UsbSerialProber.DefaultProber.FindAllDrivers(manager)[0];
port = driver.Ports[0];
var connection = manager.OpenDevice(driver.Device);
port.Open(connection);
port.SetParameters(9600, 8, StopBits.One, Parity.None);
ip = text.Text;
Thread t = new Thread(x => tcpCommunication());
t.Start();
udp = new UDPCommunication(ip, 4815);
mc.start();
}
/**
* Finds and builds all possible {@link UsbSerialDriver UsbSerialDrivers}
* from the currently-attached {@link UsbDevice} hierarchy. This method does
* not require permission from the Android USB system, since it does not
* open any of the devices.
*
* @param usbManager
* @return a list, possibly empty, of all compatible drivers
*/
public List <IUsbSerialDriver> FindAllDrivers(UsbManager usbManager)
{
List <IUsbSerialDriver> result = new List <IUsbSerialDriver>();
var deviceList = usbManager.DeviceList;
var values = deviceList.Values;
foreach (UsbDevice usbDevice in values)
{
IUsbSerialDriver driver = ProbeDevice(usbDevice);
if (driver != null)
{
result.Add(driver);
}
else
{
usbDevice.Dispose();//richard: dispose unused UsbDevice to avoid GREF leak
}
}
((Java.Lang.Object)values).Dispose(); //richard: avoid GREF leak
((Java.Lang.Object)deviceList).Dispose();
return(result);
}
protected override void OnResume()
{
base.OnResume();
#region USB adatkapcsoalt beállítása
//Először elkérjük a komplett USB managert
this.m_UsbManager = GetSystemService(Context.UsbService) as UsbManager;
//Megkeressük a legelső (egyetlen) USB eszközt
List <IUsbSerialDriver> devices = FindAllDriversAsync(this.m_UsbManager);
IUsbSerialDriver hardware = devices.FirstOrDefault();
if (hardware != null)
{
this.m_SerialPort = hardware.Ports.FirstOrDefault();
if (this.m_SerialPort != null)
{
//Ha találtunk eszközt, hozzáférést érünk az eszközhöz
PendingIntent pi = PendingIntent.GetBroadcast(this, 0, new Intent("ACTION_USB_PERMISSION"), 0);
this.m_UsbManager.RequestPermission(this.m_SerialPort.Driver.Device, pi);
//if(task.Result == true)
{
//Ha megkaptuk a hozzáférést akkor megynitjuk az eszközt mint sorosport
this.m_SerialIO = new SerialInputOutputManager(this.m_SerialPort)
{
BaudRate = 9600,
DataBits = 8,
StopBits = StopBits.One,
Parity = Parity.None,
};
this.m_SerialIO.DataReceived += (sender, e) =>
{
this.RunOnUiThread(() =>
{
this.OnReceiveSerialData(e.Data);
});
};
this.m_SerialIO.ErrorReceived += (sender, e) =>
{
this.RunOnUiThread(() =>
{
var intent = new Intent(this, typeof(MainActivity));
StartActivity(intent);
});
};
try
{
this.m_SerialIO.Open(this.m_UsbManager);
this.m_Web.EvaluateJavascript("ext_stateChanged('OK')", null);
return;
}
catch (Java.IO.IOException e)
{
this.m_Web.EvaluateJavascript("ext_stateChanged('ERROR')", null);
return;
}
}
}
}
this.m_Web.EvaluateJavascript("ext_stateChanged('Unknown')", null);
#endregion
}
public FtdiSerialPort(UsbDevice device,
int portNumber,
IUsbSerialDriver driver) : base(device, portNumber)
{
Driver = driver;
}
public static bool InterfaceConnect(string port, object parameter)
{
if (_usbPort != null)
{
return(true);
}
try
{
_connectPort = port;
_connectParameter = parameter;
if (!(parameter is ConnectParameterType connectParameter))
{
return(false);
}
if (!port.StartsWith(PortId, StringComparison.OrdinalIgnoreCase))
{
InterfaceDisconnect();
return(false);
}
List <IUsbSerialDriver> availableDrivers = GetDriverList(connectParameter.UsbManager);
if (availableDrivers.Count <= 0)
{
InterfaceDisconnect();
return(false);
}
string portData = port.Remove(0, PortId.Length);
int portIndex = -1;
if ((portData.Length > 0) && (portData[0] == ':'))
{ // special id
if (portData.StartsWith(":SER=", StringComparison.OrdinalIgnoreCase))
{ // serial number
string id = portData.Remove(0, 5);
int index = 0;
foreach (IUsbSerialDriver serialDriver in availableDrivers)
{
if (serialDriver.Ports[0] != null && string.Compare(serialDriver.Ports[0].Serial, id, StringComparison.Ordinal) == 0)
{
portIndex = index;
break;
}
index++;
}
}
}
else
{
portIndex = Convert.ToInt32(port.Remove(0, PortId.Length));
}
if ((portIndex < 0) || (portIndex >= availableDrivers.Count))
{
InterfaceDisconnect();
return(false);
}
IUsbSerialDriver driver = availableDrivers[portIndex];
UsbDeviceConnection connection = connectParameter.UsbManager.OpenDevice(driver.Device);
if (connection == null)
{
InterfaceDisconnect();
return(false);
}
if (driver.Ports.Count < 1)
{
InterfaceDisconnect();
return(false);
}
_usbPort = driver.Ports[0];
_usbPort.Open(connection);
_usbPort.SetParameters(9600, 8, StopBits.One, Parity.None);
if (_usbPort is FtdiSerialDriver.FtdiSerialPort ftdiPort)
{
ftdiPort.LatencyTimer = LatencyTime;
if (ftdiPort.LatencyTimer != LatencyTime)
{
InterfaceDisconnect();
return(false);
}
}
_currentWordLength = 8;
_currentParity = EdInterfaceObd.SerialParity.None;
_usbPort.DTR = false;
_usbPort.RTS = false;
lock (QueueLock)
{
ReadQueue.Clear();
}
_serialIoManager = new SerialInputOutputManager(_usbPort);
_serialIoManager.DataReceived += (sender, e) =>
{
lock (QueueLock)
{
foreach (byte value in e.Data)
{
ReadQueue.Enqueue(value);
}
DataReceiveEvent.Set();
}
};
_serialIoManager.Start(UsbBlockSize);
if (_currentBaudRate != 0 && _currentWordLength != 0)
{
if (InterfaceSetConfig(EdInterfaceObd.Protocol.Uart, _currentBaudRate, _currentWordLength, _currentParity, false) != EdInterfaceObd.InterfaceErrorResult.NoError)
{
InterfaceDisconnect();
return(false);
}
InterfaceSetDtr(_currentDtr);
InterfaceSetRts(_currentRts);
}
Ediabas?.LogString(EdiabasNet.EdLogLevel.Ifh, "Connected");
_reconnectRequired = false;
}
catch (Exception)
{
InterfaceDisconnect();
return(false);
}
return(true);
}
public SerialDevice(IUsbSerialDriver driver)
{
_driver = driver ?? throw new ArgumentNullException(nameof(driver));
}
public void OnClick(View v)
{
if (v.Id == btn_Connect.Id)
{
manager = (UsbManager)GetSystemService(UsbService);
IList <IUsbSerialDriver> availableDrivers = UsbSerialProber.DefaultProber.FindAllDrivers(manager);
if (availableDrivers.Count == 0)
{
tv_Info.Append("No devices found");
}
else
{
// Open a connection to the first available driver.
PendingIntent mPermissionIntent = PendingIntent.GetBroadcast(this, 0, Intent.SetAction("ACTION_USB_PERMISSION"), 0);
driver = availableDrivers[0];
manager.RequestPermission(driver.Device, mPermissionIntent);
connection = manager.OpenDevice(driver.Device);
if (connection == null)
{
tv_Info.Append("You probably need to call UsbManager.requestPermission(driver.getDevice(), ..)");
}
else
{
port = driver.Ports[0];
tv_Info.Append("Connected to USB");
port.Open(connection);
port.SetParameters(9600, 8, StopBits.One, Parity.None);
byte[] bytes = new byte[1024];
port.Read(bytes, 1000);
}
}
ThreadPool.QueueUserWorkItem(delegate(object state) {
while (connection != null)
{
try
{
byte[] readBuffer = new byte[1024];
int message = port.Read(readBuffer, readBuffer.Length);
string input = Encoding.ASCII.GetString(readBuffer, 0, message);
if (input != "")
{
RunOnUiThread(() => {
tv_Info.Text = input;
});
}
}
catch (TimeoutException e)
{
// Console.WriteLine(e.ToString());
}
}
}, null);
}
else if (v.Id == btn_Send.Id)
{
try
{
//port.SetParameters(115200, 8, StopBits.One, Parity.None);
byte[] buffer = Encoding.ASCII.GetBytes(et_SendToServer.Text);
int numBytesRead = port.Write(buffer, 1024);
}
catch (IOException e)
{
tv_Info.Append(e.ToString());
}
}
else if (v.Id == btn_Disconnect.Id)
{
port.Close();
}
else if (v.Id == btn_clear.Id)
{
tv_Info.Text = null;
}
}
