public static bool InterfaceDisconnect()
{
try
{
if (_serialIoManager != null)
{
_serialIoManager.Stop();
_serialIoManager.Dispose();
_serialIoManager = null;
}
if (_usbPort != null)
{
_usbPort.Close();
_usbPort.Dispose();
_usbPort = null;
}
lock (QueueLock)
{
ReadQueue.Clear();
}
}
catch (Exception)
{
return(false);
}
return(true);
}
protected async override void OnResume()
{
Log.Info(TAG, "OnResume");
base.OnResume();
var portInfo = Intent.GetParcelableExtra(EXTRA_TAG) as UsbSerialPortInfo;
int vendorId = portInfo.VendorId;
int deviceId = portInfo.DeviceId;
int portNumber = portInfo.PortNumber;
Log.Info(TAG, string.Format("VendorId: {0} DeviceId: {1} PortNumber: {2}", vendorId, deviceId, portNumber));
var drivers = await DeviceListActivity.FindAllDriversAsync(usbManager);
var driver = drivers.Where((d) => d.Device.VendorId == vendorId && d.Device.DeviceId == deviceId).FirstOrDefault();
if (driver == null)
{
throw new Exception("Driver specified in extra tag not found.");
}
port = driver.Ports [portNumber];
if (port == null)
{
titleTextView.Text = "No serial device.";
return;
}
Log.Info(TAG, "port=" + port);
titleTextView.Text = "Serial device: " + port.GetType().Name;
serialIoManager = new SerialInputOutputManager(port)
{
BaudRate = 115200,
DataBits = 8,
StopBits = StopBits.One,
Parity = Parity.None,
};
serialIoManager.DataReceived += (sender, e) => {
RunOnUiThread(() => {
UpdateReceivedData(e.Data);
});
};
serialIoManager.ErrorReceived += (sender, e) => {
RunOnUiThread(() => {
var intent = new Intent(this, typeof(DeviceListActivity));
StartActivity(intent);
});
};
Log.Info(TAG, "Starting IO manager ..");
try {
serialIoManager.Open(usbManager);
}
catch (Java.IO.IOException e) {
titleTextView.Text = "Error opening device: " + e.Message;
return;
}
}
public async Task <ICommsSerial> GetUSB(DeviceInfo di)
{
var usbManager = (UsbManager)Application.Context.GetSystemService(Context.UsbService);
foreach (var deviceListValue in usbManager.DeviceList.Values)
{
Log.Info(TAG, deviceListValue.ToJSON());
}
Log.Info(TAG, "Refreshing device list ...");
var drivers = await AndroidSerialBase.GetPorts(usbManager);
if (drivers.Count == 0)
{
Log.Info(TAG, "No usb devices");
return(null);
}
foreach (var driver in drivers)
{
Log.Info(TAG, string.Format("+ {0}: {1} port{2}", driver, drivers.Count, drivers.Count == 1 ? string.Empty : "s"));
Log.Info(TAG, string.Format("+ {0}: {1} ", driver.Device.ProductName, driver.Device.ManufacturerName));
}
var usbdevice = drivers.First(a =>
di.hardwareid.Contains(a.Device.VendorId.ToString("X4")) &&
di.hardwareid.Contains(a.Device.ProductId.ToString("X4")));
var permissionGranted =
await usbManager.RequestPermissionAsync(usbdevice.Device, Application.Context);
if (permissionGranted)
{
var portInfo = new UsbSerialPortInfo(drivers.First().Ports.First());
int vendorId = portInfo.VendorId;
int deviceId = portInfo.DeviceId;
int portNumber = portInfo.PortNumber;
Log.Info(TAG, string.Format("VendorId: {0} DeviceId: {1} PortNumber: {2}", vendorId, deviceId, portNumber));
var driver = drivers.Where((d) => d.Device.VendorId == vendorId && d.Device.DeviceId == deviceId).FirstOrDefault();
var port = driver.Ports[portNumber];
var serialIoManager = new SerialInputOutputManager(usbManager, port)
{
BaudRate = 57600,
DataBits = 8,
StopBits = StopBits.One,
Parity = Parity.None,
};
return(new AndroidSerial(serialIoManager));
}
return(null);
}
public AndroidSerial(SerialInputOutputManager serialIoManager)
{
this.serialIoManager = serialIoManager;
serialIoManager.DataReceived += (sender, e) =>
{
foreach (var b in e.Data)
{
readbuffer.Add(b);
}
};
serialIoManager.ErrorReceived += (sender, e) => { };
}
public AndroidSerial(SerialInputOutputManager serialIoManager)
{
this.serialIoManager = serialIoManager;
serialIoManager.DataReceived += (sender, e) =>
{
lock (readbuffer)
{
if (readbuffer.Position == readbuffer.Length && readbuffer.Length > 0)
{
//clear it
readbuffer.SetLength(0);
// add data
readbuffer.Write(e.Data);
// set readback start point
readbuffer.Position = 0;
// update toread
BytesToRead += e.Data.Length;
Android.Util.Log.Debug("AndroidSerial", "BytesToRead1 " + BytesToRead);
}
else
{
var pos = readbuffer.Position;
// goto end
readbuffer.Seek(0, SeekOrigin.End);
//write
readbuffer.Write(e.Data);
// seek back to readpos
readbuffer.Seek(pos, SeekOrigin.Begin);
BytesToRead += e.Data.Length;
Android.Util.Log.Debug("AndroidSerial", "BytesToRead2 " + BytesToRead);
}
}
};
serialIoManager.ErrorReceived += (sender, e) =>
{
Android.Util.Log.Debug("AndroidSerial", e.ExceptionObject.ToString());
};
}
public AndroidSerial(SerialInputOutputManager serialIoManager)
{
this.serialIoManager = serialIoManager;
serialIoManager.DataReceived += (sender, e) =>
{
lock (readbuffer)
{
if (readbuffer.Position == readbuffer.Length && readbuffer.Length > 0)
{
readbuffer.SetLength(0);
}
var pos = readbuffer.Position;
// goto end
readbuffer.Seek(0, SeekOrigin.End);
//write
readbuffer.Write(e.Data);
// seek back to readpos
readbuffer.Seek(pos, SeekOrigin.Begin);
BytesToRead += e.Data.Length;
}
};
serialIoManager.ErrorReceived += (sender, e) => { };
}
public async Task <ICommsSerial> GetUSB(DeviceInfo di)
{
var usbManager = (UsbManager)Application.Context.GetSystemService(Context.UsbService);
foreach (var deviceListValue in usbManager.DeviceList.Values)
{
Log.Info(TAG, "GetUSB " + deviceListValue.DeviceName);
}
Log.Info(TAG, "GetUSB " + "Refreshing device list ...");
var drivers = await AndroidSerialBase.GetPorts(usbManager);
if (drivers.Count == 0)
{
Log.Info(TAG, "GetUSB " + "No usb devices");
return(null);
}
foreach (var driver in drivers.ToArray())
{
Log.Info(TAG, string.Format("GetUSB " + "+ {0}: {1} ports {2}", driver, drivers.Count, driver.Ports.Count));
Log.Info(TAG, string.Format("GetUSB " + "+ {0}: {1} ", driver.Device.ProductName, driver.Device.ManufacturerName));
}
var usbdevice = drivers.First(a =>
di.hardwareid.Contains(a.Device.VendorId.ToString("X4")) &&
di.hardwareid.Contains(a.Device.ProductId.ToString("X4")));
var hasPermission = usbManager.HasPermission(usbdevice.Device);
var permissionGranted =
await usbManager.RequestPermissionAsync(usbdevice.Device, Application.Context);
if (permissionGranted)
{
if (!hasPermission)
{
return(await GetUSB(di));
}
var portnumber = 0;
var port = usbdevice.Ports.First();
if (usbdevice.Ports.Count > 1)
{
if (di.board.EndsWith("-P2"))
{
port = usbdevice.Ports[1];
portnumber = 1;
}
}
/*
* var defaultport = usbdevice.Ports.First();
* if (usbdevice.Ports.Count > 1)
* {
* ManualResetEvent mre = new ManualResetEvent(false);
*
* var handler = new Handler(MainActivity.Current.MainLooper);
*
* handler.Post(() =>
* {
* AlertDialog.Builder alert = new AlertDialog.Builder(MainActivity.Current);
* alert.SetTitle("Multiple Ports");
* alert.SetCancelable(false);
* var items = usbdevice.Ports.Select(a =>
* a.Device.GetInterface(a.PortNumber).Name ?? a.PortNumber.ToString())
* .ToArray();
* alert.SetSingleChoiceItems(items, 0, (sender, args) =>
* {
* defaultport = usbdevice.Ports[args.Which];
* });
*
* alert.SetNeutralButton("OK", (senderAlert, args) => { mre.Set(); });
*
* Dialog dialog = alert.Create();
* if(!MainActivity.Current.IsFinishing)
* dialog.Show();
* });
*
* mre.WaitOne();
* }
*/
var portInfo = new UsbSerialPortInfo(port);
int vendorId = portInfo.VendorId;
int deviceId = portInfo.DeviceId;
Log.Info(TAG,
string.Format("GetUSB " + "VendorId: {0} DeviceId: {1} PortNumber: {2}", vendorId, deviceId,
portnumber));
var serialIoManager = new SerialInputOutputManager(usbManager, port);
return(new AndroidSerial(serialIoManager)
{
PortName = usbdevice.Device.ProductName
});
}
return(null);
}
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 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);
}
async Task OnItemClick(object sender)
{
for (int i = 0; i < adapter.Count; i++)
{
selectedPortTest = adapter.GetItem(i);
// Поиск устройства
if (selectedPortTest.Driver.Device.VendorId == 6790 && selectedPortTest.Driver.Device.DeviceId == 1003)
{
ItemPort = i;
}
//
}
selectedPort = adapter.GetItem(ItemPort);
var permissionGranted = await usbManager.RequestPermissionAsync(selectedPort.Driver.Device, this);
if (permissionGranted)
{
//MessageBox("Доступ к USB получен!");
int vendorId = selectedPort.Driver.Device.VendorId;
int deviceId = selectedPort.Driver.Device.DeviceId;
int portNumber = 0;
var drivers = await FindAllDriversAsync(usbManager);
var driver = drivers.Where((d) => d.Device.VendorId == vendorId && d.Device.DeviceId == deviceId).FirstOrDefault();
if (driver == null)
{
throw new Exception("Driver specified in extra tag not found.");
}
port = driver.Ports[portNumber];
if (port == null)
{
MessageBox("No serial device.");
return;
}
serialIoManager = new SerialInputOutputManager(port)
{
BaudRate = 115200,
DataBits = 8,
StopBits = StopBits.One,
Parity = Parity.None,
};
serialIoManager.DataReceived += (sender, e) =>
{
RunOnUiThread(() =>
{
UpdateReceivedData(e.Data);
});
};
serialIoManager.ErrorReceived += (sender, e) =>
{
RunOnUiThread(() =>
{
var intent = new Intent(this, typeof(MainActivity));
StartActivity(intent);
});
};
try
{
serialIoManager.Open(usbManager);
}
catch (Java.IO.IOException e)
{
MessageBox("Error opening device: " + e.Message);
return;
}
}
}
private async void StartReceiving()
{
if (App.UsbManager == null || App.PortInfo == null)
{
ToastService.ToastShortMessage(AppResources.No_Device);
return;
}
var driver =
await FindDriversService.GetSpecificDriverAsync(App.UsbManager,
App.PortInfo);
if (driver != null)
{
_port = driver.Ports[App.PortInfo.PortNumber];
}
else
{
ToastService.ToastShortMessage(AppResources.No_Driver);
return;
}
CurrentDeviceName = _port.GetType().Name;
NotifyPropertyChanged(nameof(CurrentDeviceName));
_serialIoManager = new SerialInputOutputManager(_port)
{
BaudRate = CurrentSettings.BaudRate,
DataBits = CurrentSettings.DataBits,
StopBits = CurrentSettings.StopBits,
Parity = CurrentSettings.Parity
};
_serialIoManager.DataReceived += (sender, e) =>
{
Device.BeginInvokeOnMainThread(() => { UpdateReceivedData(e.Data); });
};
_serialIoManager.ErrorReceived += (sender, e) =>
{
Device.BeginInvokeOnMainThread(() =>
{
ToastService.ToastShortMessage(AppResources
.Received_Error);
});
};
ToastService.ToastShortMessage(AppResources.Port_Listening);
try
{
_serialIoManager.Open(App.UsbManager);
}
catch (Exception)
{
ToastService.ToastShortMessage(
$"{AppResources.Open_Failed}: {CurrentDeviceName}");
}
finally
{
NotifyPropertyChanged(nameof(PortCommand));
NotifyPropertyChanged(nameof(PortStatus));
}
}
protected async override void OnResume()
{
base.OnResume();
var portInfo = Intent.GetParcelableExtra(EXTRA_TAG) as UsbSerialPortInfo;
int vendorId = portInfo.VendorId;
int deviceId = portInfo.DeviceId;
int portNumber = portInfo.PortNumber;
var drivers = await FindAllDriversAsync(usbManager);
var driver = drivers.Where((d) => d.Device.VendorId == vendorId && d.Device.DeviceId == deviceId).FirstOrDefault();
if (driver == null)
{
throw new Exception("Driver specified in extra tag not found.");
}
port = driver.Ports[portNumber];
if (port == null)
{
bluetoothData1.Text = "No serial device.";
return;
}
serialIoManager = new SerialInputOutputManager(port)
{
//BaudRate = 115200,
BaudRate = 9600,
DataBits = 8,
StopBits = StopBits.One,
Parity = Parity.None,
};
serialIoManager.DataReceived += (sender, e) =>
{
RunOnUiThread(() =>
{
UpdateReceivedData(e.Data);
if (received_data == 0)
{
received_data = 1;
}
if (buffer[0] >= 0)
{
receive_buffer[receive_buffer_counter] = buffer[0]; // (byte)nextByte; //Load them in the received_buffer array.
}
//Search for the start signature in the received data stream.
if (receive_byte_previous == 'J' && receive_buffer[receive_buffer_counter] == 'B')
{
receive_buffer_counter = 0; //Reset the receive_buffer_counter counter if the start signature if found.
receive_start_detect++; //Increment the receive_start_detect to check for a full data stream reception.
if (receive_start_detect >= 2)
{
Set_data();
latLongJMCdrone = new LatLng(-l_lat_gps / 1000000.0, -l_lon_gps / 1000000.0);
if (start == 0)
{
wayPointArray[0] = latLongJMCdrone;
}
if (home_gps_set == 0 && number_used_sats > minSats && start == 2)
{
home_gps_set = 1;
home_lat_gps = l_lat_gps;
home_lon_gps = l_lon_gps;
homeLatLong = new LatLng(-home_lat_gps / 1000000.0, -home_lon_gps / 1000000.0);
wayPointArray[0] = homeLatLong;
}
if (home_gps_set == 1 && start == 0)
{
home_gps_set = 0;
}
if (fixCameraHomePoint / fixCameraHomePointDivisor != 1 || boolDragEnd || floatingButton2_clicked || floatingButton3_clicked || floatingButton4_clicked || number_used_sats == 0 || flight_mode >= 5)
{
mapFragment.GetMapAsync(this);//update Map
}
if (number_used_sats == 0)
{
Toast.MakeText(this, "No GPS signal", ToastLength.Long).Show();
progressBar1.SetProgress(1 + myRandowInt.Next(2, 5), false);
fixCameraHomePointDivisor = 1;
fixCameraHomePoint = 2;
}
if (number_used_sats > 0 && number_used_sats <= minSats)
{
progressBar1.SetProgress(number_used_sats * 7 + myRandowInt.Next(0, 5), false);
fixCameraHomePoint = 6;
}
if (number_used_sats > minSats)
{
fixCameraHomePoint = 7;
progressBar1.SetProgress(80 + myRandowInt.Next(5, 20), false);
}
if (flight_mode == 1)
{
bluetoothData1.Text = "1-Auto level";
}
if (flight_mode == 2)
{
bluetoothData1.Text = "2-Altitude hold";
}
if (flight_mode == 3)
{
bluetoothData1.Text = "3-GPS hold";
}
if (flight_mode == 4)
{
bluetoothData1.Text = "4-RTH active";
}
if (flight_mode == 5)
{
bluetoothData1.Text = "5-RTH I"; //5-RTH Increase altitude
}
if (flight_mode == 6)
{
bluetoothData1.Text = "6-RTH R"; //6-RTH Returning to home position
}
if (flight_mode == 7)
{
bluetoothData1.Text = "7-RTH L"; //7-RTH Landing
}
if (flight_mode == 8)
{
bluetoothData1.Text = "8-RTH F"; //8-RTH finished
}
if (flight_mode == 9)
{
bluetoothData1.Text = "9-Fly waypoint";
}
bluetoothData2.Text = (latLongJMCdrone.Latitude).ToString();
bluetoothData3.Text = (latLongJMCdrone.Longitude).ToString();
bluetoothData4.Text = number_used_sats.ToString();
bluetoothData5.Text = start.ToString();
bluetoothData6.Text = actual_compass_heading.ToString();
bluetoothData7.Text = battery_voltage.ToString();
bluetoothData8.Text = los_distance.ToString("0.") + " m";
fixCameraHomePointDivisor = fixCameraHomePoint;
}
}
else
{ //If there is no start signature detected.
receive_byte_previous = receive_buffer[receive_buffer_counter]; //Safe the current received byte for the next loop.
receive_buffer_counter++; //Increment the receive_buffer_counter variable.
if (receive_buffer_counter > 48)
{
receive_buffer_counter = 0; //Reset the receive_buffer_counter variable when it becomes larger than 38.
}
}
if (flight_mode == 9)
{
fixWayPoint = true;
}
if (flight_mode == 3 && fixWayPoint == false)
{
WriteData(send_buffer);
}
if (start == 2 && flight_mode == 3 && flyWayPointCounter <= addWayPointCounter + 1 && floatingButton3_clicked && fixWayPoint)
{
int latitude;
int longitude;
fixWayPoint = false;
flyWayPointCounter++;
floatingButton1.Hide();
floatingButton2.Hide();
floatingButton3.Hide();
floatingButton4.Hide();
if (flyWayPointCounter == addWayPointCounter + 1)
{ // +1 para retornar a origem !!!!
floatingButton3_clicked = false;
flyWayPointCounter = 0;
floatingButton1.Show();
floatingButton2.Show();
floatingButton3.Show();
floatingButton4.Show();
latitude = (int)(homeLatLong.Latitude * 1000000.0);
if (latitude < 0)
{
latitude *= -1; // deve ser um valor positivo// nao sei porque //deve ser por causa do sketch translatebyte do codigo arduino!!!!
}
longitude = (int)(homeLatLong.Longitude * 1000000.0);
if (longitude > 0)
{
longitude *= -1; // deve ser um valor negativo// nao sei porque //deve ser por causa do sketch translatebyte do codigo arduino!!!!
}
}
else
{
latitude = (int)(wayPointArray[flyWayPointCounter].Latitude * 1000000.0);
if (latitude < 0)
{
latitude *= -1; // deve ser um valor positivo// nao sei porque //deve ser por causa do sketch translatebyte do codigo arduino!!!!
}
longitude = (int)(wayPointArray[flyWayPointCounter].Longitude * 1000000.0);
if (longitude > 0)
{
longitude *= -1; // deve ser um valor negativo// nao sei porque //deve ser por causa do sketch translatebyte do codigo arduino!!!!
}
}
send_buffer[0] = (byte)'W';
send_buffer[1] = (byte)'P';
send_buffer[5] = (byte)(latitude >> 24);
send_buffer[4] = (byte)(latitude >> 16);
send_buffer[3] = (byte)(latitude >> 8);
send_buffer[2] = (byte)latitude;
send_buffer[9] = (byte)(longitude >> 24);
send_buffer[8] = (byte)(longitude >> 16);
send_buffer[7] = (byte)(longitude >> 8);
send_buffer[6] = (byte)longitude;
send_buffer[10] = (byte)'-';
check_byte = 0;
for (temp_byte = 2; temp_byte <= 10; temp_byte++)
{
check_byte ^= send_buffer[temp_byte];
}
send_buffer[11] = check_byte;
WriteData(send_buffer);
}
});
};
serialIoManager.ErrorReceived += (sender, e) =>
{
RunOnUiThread(() =>
{
var intent = new Intent(this, typeof(MainActivity));
StartActivity(intent);
});
};
try
{
serialIoManager.Open(usbManager);
}
catch (Java.IO.IOException e)
{
bluetoothData1.Text = "Error opening device: " + e.Message;
return;
}
}
// Réception de données Li-Fi avec port série micro USB
private async Task OpenLiFiReceiverPort()
{
UsbManager UsbSerialManager = AppActivity.ApplicationContext.GetSystemService(Context.UsbService) as UsbManager;
var Table = UsbSerialProber.DefaultProbeTable;
Table.AddProduct(0x1b4f, 0x0008, Java.Lang.Class.FromType(typeof(CdcAcmSerialDriver))); // IOIO OTG
var Prober = new UsbSerialProber(Table);
var Drivers = await Prober.FindAllDriversAsync(UsbSerialManager);
LiFiReceiverPort = null;
foreach (var Driver in Drivers) // On cherche notre driver (le récepteur Li-Fi)
{
foreach (var Port in Driver.Ports)
{
if (HexDump.ToHexString((short)Port.Driver.Device.VendorId) == "0403" && HexDump.ToHexString((short)Port.Driver.Device.ProductId) == "6015")
{
LiFiReceiverPort = Port;
}
}
}
if (LiFiReceiverPort == null) // Si il n'est pas branché on affiche un message
{
AppActivity.RunOnUiThread(() => { ReceiverStatus.Text = "Récepteur Li-Fi absent"; });
}
else
{
var IsPermissionGranted = await UsbSerialManager.RequestPermissionAsync(LiFiReceiverPort.Driver.Device, AppActivity.ApplicationContext);
if (IsPermissionGranted) // On demande la permission à l'utilisateur d'utiliser le récepteur (Android)
{
SerialIOManager = new SerialInputOutputManager(LiFiReceiverPort) // Configuration du port série
{
BaudRate = 115200,
DataBits = 8,
StopBits = StopBits.One,
Parity = Parity.None
};
SerialIOManager.DataReceived += (source, args) => // Thread de réception de données
{
ReceivedSerialData = Encoding.UTF8.GetString(args.Data); // Données recu
};
SerialIOManager.ErrorReceived += (source, args) => // Thread si il y a une erreur
{
AppActivity.RunOnUiThread(() =>
{
ReceiverStatus.Text = "Récepteur Li-Fi absent"; // On affiche un message de débranchement
SerialIOManager.Close();
});
};
try
{
SerialIOManager.Open(UsbSerialManager); // On ouvre le port
AppActivity.RunOnUiThread(() => { ReceiverStatus.Text = "Récepteur Li-Fi opérationnel"; });
}
catch (Java.IO.IOException Exception)
{
AppActivity.RunOnUiThread(() => { ReceiverStatus.Text = "Erreur récepteur Li-Fi: " + Exception.Message; });
}
}
else
{
AppActivity.RunOnUiThread(() => { ReceiverStatus.Text = "Permission requise"; });
}
}
}
public AndroidSerial(SerialInputOutputManager serialIoManager)
{
this.serialIoManager = serialIoManager;
}
