Files
meshcore-open/third_party/flserial/lib/flserial.dart
T
just-stuff-tm 2474389099 Fix Linux USB open crash and the glibc 2.39 release bundle.
BETA-99.0.0 segfaults when a USB companion transmits as soon as the port
opens, and the Linux release fails to load on Ubuntu 24.04 and Linux
Mint 22 (glibc 2.39). Fixes #600.

fl_open starts SerialThread before Dart installs fl_set_callback. A Seeed
Wio Tracker L1 sends bytes immediately, and the reader called that null
pointer (segfault at ip 0, FlSerial+0x44b8). Vendor MeshEnvy/flserial
e1864de under third_party/flserial. That is the 0.3.5 FFI API this app
already calls (openPort, setCallback, setByteSize8, setDTR), not official
grzesl/flserial 0.7.3. The reader waits until the callback is set, and
the port mutexes are initialized before the thread starts. Merging this
makes zjs81/meshcore-open the owner of that vendored copy.

The release libflserial.so needed GLIBC_2.42 for cfsetispeed and
cfsetospeed, so USB discovery failed on glibc 2.39 before the port
opened. Bind those symbols at GLIBC_2.2.5 and pass the legacy baud values
those symbols expect. 115200 is octal 0010002. glibc 2.42 turned the B*
macros into plain numbers, so passing 115200 to the old symbol would
select the wrong rate.

flutter_onnxruntime 1.9.0 needs libonnxruntime.so.1 from ONNX Runtime
1.28.3. The zip did not ship that file, and the plugin RUNPATH was the
build machine's download directory. The loader uses the plugin path for
this library. The install copies libonnxruntime.so, .so.1, .so.1.28.3,
and libonnxruntime_providers_shared.so into bundle/lib. The plugin build
RPATH is $ORIGIN followed by the download directory: $ORIGIN is bundle/lib
at runtime, and the download directory is what ld needs while linking.
Dropping it makes the release link fail. The executable keeps DT_RPATH
$ORIGIN/lib for its own plugins.

Checked on Ubuntu 26.04.1 (glibc 2.43) with Flutter 3.47.7. Opening
/dev/ttyACM0 at 115200 set both termios2 speeds to 115200 and delivered
data after fl_set_callback (last length 402). The built libflserial.so
has no GLIBC_2.42 requirement. flutter build linux --release succeeded.
With the plugin's absolute build path removed and LD_LIBRARY_PATH unset,
ldd resolved libonnxruntime.so.1 from bundle/lib.
2026-10-16 20:11:05 -04:00

453 lines
12 KiB
Dart

import 'dart:async';
import 'dart:convert';
import 'dart:ffi';
import 'dart:io';
import 'dart:typed_data';
import 'package:ffi/ffi.dart';
import 'package:flserial/flserial_exception.dart';
import 'flserial_bindings_generated.dart';
const String _libName = 'flserial';
const int _serialIOBuffLen = 1024 * 8;
/// The dynamic library in which the symbols for [FlserialBindings] can be found.
final DynamicLibrary dylib = () {
if (Platform.isMacOS || Platform.isIOS) {
return DynamicLibrary.open('$_libName.framework/$_libName');
}
if (Platform.isAndroid || Platform.isLinux) {
return DynamicLibrary.open('lib$_libName.so');
}
if (Platform.isWindows) {
return DynamicLibrary.open('$_libName.dll');
}
throw UnsupportedError('Unknown platform: ${Platform.operatingSystem}');
}();
/// The bindings to the native functions in [_dylib].
final FlserialBindings bindings = FlserialBindings(dylib);
/// Native pointer to string conversion
String nativeInt8ToString(Pointer<Int8> pointer, {bool allowMalformed = true}) {
var ptrName = pointer.cast<Utf8>();
final ptrNameCodeUnits = pointer.cast<Uint8>();
var list = ptrNameCodeUnits.asTypedList(ptrName.length);
return utf8.decode(list, allowMalformed: allowMalformed);
}
/// String conversion to native pointer, memory should be free outside function
Pointer<Char> stringToNativeInt8(String str, {Allocator allocator = calloc}) {
final units = utf8.encode(str);
final result = allocator<Uint8>(units.length + 1);
final nativeString = result.asTypedList(units.length + 1);
nativeString.setAll(0, units);
nativeString[units.length] = 0;
return result.cast<Char>();
}
/// List conversion to native pointer, memory should be free outside function
Pointer<Char> int8ListToPointerInt8(
Uint8List units,
Pointer<Uint8> pointer, {
Allocator allocator = calloc,
}) {
final nativeString = pointer.asTypedList(units.length + 1); //blobBytes
nativeString.setAll(0, units);
nativeString[units.length] = 0;
return pointer.cast<Char>();
}
Pointer<Double> listToPointerDouble(List<double> sample) {
final Pointer<Double> pointer = calloc.allocate<Double>(
sample.length,
alignment: 8,
);
final nativeSamples = pointer.asTypedList(sample.length);
nativeSamples.setAll(0, sample);
return pointer.cast<Double>();
}
/// Native pointer conversion to list
Int8List nativeInt8ToInt8List(Pointer<Int8> pointer) {
var ptrName = pointer.cast<Utf8>();
final ptrNameCodeUnits = pointer.cast<Int8>();
var list = ptrNameCodeUnits.asTypedList(ptrName.length);
return list;
}
/// Open serial port status
enum FlOpenStatus { open, closed, error }
/// Class for incoming data handling
class FlSerialEventArgs {
FlSerialEventArgs(this.serial, this.len, this.cts, this.dsr);
final FlSerial serial;
final int len;
final bool cts, dsr;
}
/// Main serial wrapper class over ffi
class FlSerial {
int flh = -1;
bool prevCTS = false;
bool prevDSR = false;
var onSerialData = StreamController<FlSerialEventArgs>();
Pointer<Char> serialReadBuff = Pointer.fromAddress(0);
Pointer<Uint8> serialWriteBuff = Pointer.fromAddress(0);
/// Init should be called at program start, after FlSerial creation
/// Function is used to make array of internal port structs for 16 parallel processing ports
int init() {
return bindings.fl_init(16);
}
/// Setting callback to native code. Used for incoming data signal
void setCallback(int flh, {required DartflcallbackFunction callback}) {
final nativeCallable = NativeCallable<flcallbackFunction>.listener(
callback,
);
bindings.fl_set_callback(flh, nativeCallable.nativeFunction);
}
/// Listing serial ports. Platform depend
static List<String> listPorts() {
List<String> list = List<String>.empty(growable: true);
Allocator allocator = calloc;
var result = allocator<Char>(1024);
for (int i = 0; i < 255; i++) {
int len = bindings.fl_ports(i, 1024, result);
if (len > 0) {
String resultStr = result.cast<Utf8>().toDartString(length: len);
list.add(resultStr);
} else {
break;
}
}
allocator.free(result);
return list;
}
/// Internal function for serial port handler checking
int _checkFLH(int handler) {
if (handler >= 0 && handler < MAX_PORT_COUNT) {
return FlError.FL_ERROR_OK;
}
throw FlSerialException(FlError.FL_ERROR_HANDLER, msg: "$handler");
}
/// Function for openning serial port
FlOpenStatus openPort(String portname, int baudrate) {
prevCTS = false;
prevDSR = false;
Pointer<Char> ptr = stringToNativeInt8(portname);
flh = bindings.fl_open(flh, ptr, baudrate);
calloc.free(ptr);
int error = bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_LAST_ERROR, -1);
int flerror = FlError.FL_ERROR_UNKNOW;
if (error > 0) {
/// error mapping
String msg = "Port open error: $portname";
switch (error) {
case 1:
case 3:
flerror = FlError.FL_ERROR_PORT_NOT_EXIST;
msg += " port not exist";
break;
case 2:
flerror = FlError.FL_ERROR_PORT_ALLREADY_OPEN;
msg += " port allready open";
break;
}
bindings.fl_close(flh);
flh = -1;
throw FlSerialException(flerror, msg: msg);
}
onSerialData = StreamController<FlSerialEventArgs>();
Allocator allocator = calloc;
serialReadBuff = allocator<Char>(_serialIOBuffLen);
serialWriteBuff = allocator<Uint8>(_serialIOBuffLen);
setCallback(
flh,
callback: (cflh, len) async {
if (len > 0) {
onSerialData.add(FlSerialEventArgs(this, len, prevCTS, prevDSR));
}
},
);
return isOpen();
}
/// Function check is serial port opened
FlOpenStatus isOpen() {
if (flh < 0) {
return FlOpenStatus.closed;
}
int error = bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_LAST_ERROR, -1);
if (error > 0) {
return FlOpenStatus.error;
}
int nres = bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_IS_PORT_OPEN, -1);
if (nres == 0) {
return FlOpenStatus.closed;
}
return FlOpenStatus.open;
}
/// Get last error message. Return empty string if no error
String getLastError() {
_checkFLH(flh);
int res = bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_LAST_ERROR, -1);
String strres = "";
switch (res) {
case FlError.FL_ERROR_OK:
strres = "0: None";
break;
case FlError.FL_ERROR_PORT_ALLREADY_OPEN:
strres = "$res: Port allready open";
break;
case FlError.FL_ERROR_PORT_NOT_EXIST:
strres = "$res: Port not exist";
break;
default:
strres = "-1: Unknow error";
break;
}
return strres;
}
/*
Future<int> _readLineStatus() async {
_checkFLH(flh);
bool currCTS = getCTS();
bool currDSR = getDSR();
if(currCTS != prevCTS || prevDSR != currDSR)
{
prevCTS = currCTS;
prevDSR = currDSR;
onSerialData.broadcast(FlSerialEventArgs(
readBuff.length, Uint8List(0), currCTS, currDSR));
}
return 0;
}*/
/// Internal function to read serial data from lower layer with desired len. If no data is present, empty list is returned
Uint8List _readList(int len) {
_checkFLH(flh);
if (len > _serialIOBuffLen) {
len = _serialIOBuffLen;
}
int intres = bindings.fl_read(flh, len, serialReadBuff);
if (intres <= 0) {
return Uint8List(0);
}
final ptrNameCodeUnits = serialReadBuff.cast<Uint8>();
var list = ptrNameCodeUnits.asTypedList(intres);
return list;
}
/// Read full read bufer from serial port
Uint8List readList() {
_checkFLH(flh);
return readListLen(1024 * 8);
}
/// Read desired len from serial port buffer
Uint8List readListLen(int len) {
_checkFLH(flh);
return _readList(len);
}
/// Read single byte
int read() {
_checkFLH(flh);
Uint8List data = _readList(1);
if (data.isNotEmpty) {
return data.first;
}
return -1;
}
/// Write list data to serial port
int write(Uint8List data) {
_checkFLH(flh);
Pointer<Char> ptr = int8ListToPointerInt8(data, serialWriteBuff);
int res = bindings.fl_write(flh, data.length, ptr);
return res;
}
/// Close serial port and free resources
int closePort() {
_checkFLH(flh);
bindings.fl_close(flh);
onSerialData.close();
Allocator allocator = calloc;
if (serialReadBuff.value != 0) {
allocator.free(serialReadBuff);
}
if (serialWriteBuff.value != 0) {
allocator.free(serialWriteBuff);
}
flh = -1;
return flh;
}
/// Uniwersal function to control serial port
int ctrl(int cmd, int value) {
_checkFLH(flh);
return bindings.fl_ctrl(flh, cmd, value);
}
/// Function set RTS line in serial port
int setRTS(bool value) {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_RTS, value ? 1 : 0);
}
/// Function set CTS line in serial port
bool getCTS() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_GET_CTS, 0) > 0 ? true : false;
}
/// Get status of DTR line
int setDTR(bool value) {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_DTR, value ? 1 : 0);
}
/// Get status of DSR line
bool getDSR() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_GET_DSR, 0) > 0 ? true : false;
}
/// Set byte size to 5 bits
int setByteSize5() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_BYTESIZE_5, 0);
}
/// Set byte size to 6 bits
int setByteSize6() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_BYTESIZE_6, 0);
}
/// Set byte size to 7 bits
int setByteSize7() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_BYTESIZE_7, 0);
}
/// Set byte size to 8 bits
int setByteSize8() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_BYTESIZE_8, 0);
}
/// Set bit parity to none
int setBitParityNone() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_PARITY_NONE, 0);
}
/// Set bit parity to odd
int setBitParityOdd() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_PARITY_ODD, 0);
}
// Set bit parity to even
int setBitParityEven() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_PARITY_EVEN, 0);
}
// Set bit parity to mark
int setBitParityMark() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_PARITY_MARK, 0);
}
// Set bit parity to space
int setBitParitySpace() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_PARITY_SPACE, 0);
}
/// Set stop bits to one
int setStopBits1() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_STOPBITS_ONE, 0);
}
/// Set stop bits to one and half
int setStopBits1_5() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_STOPBITS_ONE_POINT_FIVE, 0);
}
/// Set stop bits to two
int setStopBits2() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_STOPBITS_TWO, 0);
}
/// Disable flow control
int setFlowControlNone() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_FLOWCONTROL_NONE, 0);
}
/// Set hardware flow control
int setFlowControlHardware() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_FLOWCONTROL_HARDWARE, 0);
}
/// Set xon/xoff flow control (software)
int setFlowControlSoftware() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_SET_FLOWCONTROL_SOFTWARE, 0);
}
/// Waiting for status line change
int setWaitStatusChange() {
_checkFLH(flh);
return bindings.fl_ctrl(flh, FlCtrl.FL_CTRL_GET_STATUS_CHANGE, 0);
}
/// Free resources. Serial port should not be used after calling this function
int free() {
return bindings.fl_free();
}
}