sven
/
libicsneo
mirror of https://github.com/intrepidcs/libicsneo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove trailing white-space

pull/25/head
Kyle Schwarz 2020-08-11 13:42:13 -04:00
parent 1d286be1e4
commit afda617894
27 changed files with 2655 additions and 2655 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
99-intrepidcs.rules
View File

@ -4,7 +4,7 @@ KERNEL=="ttyUSB?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
KERNEL=="ttyACM?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
# neoVI ION/PLASMA PIDs are not in the latest ftdi_sio driver so lets make a
# rule to add it when we see a new unclaimed device.
# rule to add it when we see a new unclaimed device.
# PLASMA = 0x0801, ION = 0x0901
ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
ATTRS{idVendor}=="093c", ATTRS{idProduct}=="0801", \

2
README.md
View File

@ -122,7 +122,7 @@ The dependencies are as follows
- `libusb-1.0-0-dev`
- `libpcap0.8-dev`
- `build-essential` is recommended
If you'd like to be able to run programs that use this library without being root, consider using the included udev rules
```

28
api/icsneolegacy/dllhelper/icsneo40DLLAPI.cpp
View File

@ -81,17 +81,17 @@ SCRIPTWRITEAPPSIGNAL icsneoScriptWriteAppSignal;
//SCRIPTWRITETXMESSAGE icsneoScriptWriteTxMessage;
//The following are valid strings for setting parameters on devices
//The following are valid strings for setting parameters on devices
//using the icsneoGetDeviceParameters() and icsneoSetDeviceParameters() functions
char *FireParameters[] =
{
"can1", "can2", "can3", "can4", "swcan", "lsftcan", "lin1", "lin2",
"lin3", "lin4", "cgi_baud", "cgi_tx_ifs_bit_times",
"cgi_rx_ifs_bit_times", "cgi_chksum_enable", "network_enables",
"network_enabled_on_boot", "pwm_man_timeout", "pwr_man_enable",
"misc_io_initial_ddr", "misc_io_initial_latch", "misc_io_analog_enable",
"misc_io_report_period", "misc_io_on_report_events", "ain_sample_period",
"ain_threshold", "iso15765_separation_time_offset", "iso9141_kwp_settings",
"cgi_rx_ifs_bit_times", "cgi_chksum_enable", "network_enables",
"network_enabled_on_boot", "pwm_man_timeout", "pwr_man_enable",
"misc_io_initial_ddr", "misc_io_initial_latch", "misc_io_analog_enable",
"misc_io_report_period", "misc_io_on_report_events", "ain_sample_period",
"ain_threshold", "iso15765_separation_time_offset", "iso9141_kwp_settings",
"perf_en", "iso_parity", "iso_msg_termination", "network_enables_2"
};
@ -99,30 +99,30 @@ char *FireParameters[] =
char *VCAN3Parameters[] =
{
"can1", "can2", "network_enables", "network_enabled_on_boot", "iso15765_separation_time_offset",
"perf_en", "misc_io_initial_ddr", "misc_io_initial_latch", "misc_io_report_period",
"perf_en", "misc_io_initial_ddr", "misc_io_initial_latch", "misc_io_report_period",
"misc_io_on_report_events"
};
char *CANParameters[] =
char *CANParameters[] =
{
"Mode", "SetBaudrate", "Baudrate", "NetworkType", "TqSeg1",
"TqSeg2", "TqProp", "TqSync", "BRP", "auto_baud"
};
char *SWCANParameters[] =
char *SWCANParameters[] =
{
"Mode", "SetBaudrate", "Baudrate", "NetworkType", "TqSeg1", "TqSeg2",
"Mode", "SetBaudrate", "Baudrate", "NetworkType", "TqSeg1", "TqSeg2",
"TqProp", "TqSync", "BRP", "high_speed_auto_switch", "auto_baud"
};
char *LINParameters[] =
char *LINParameters[] =
{
"Baudrate", "spbrg", "brgh", "MasterResistor", "Mode"
};
char *ISOKWPParms[] =
{
"Baudrate", "spbrg", "brgh", "init_steps", "init_step_count",
"Baudrate", "spbrg", "brgh", "init_steps", "init_step_count",
"p2_500us", "p3_500us", "p4_500us", "chksum_enabled"
};
@ -203,14 +203,14 @@ bool LoadDLLAPI(HINSTANCE &hAPIDLL)
if(!icsneoFindNeoDevices || !icsneoOpenNeoDevice || !icsneoClosePort || !icsneoFreeObject ||
if(!icsneoFindNeoDevices || !icsneoOpenNeoDevice || !icsneoClosePort || !icsneoFreeObject ||
!icsneoTxMessages || !icsneoGetMessages || !icsneoWaitForRxMessagesWithTimeOut ||
!icsneoGetTimeStampForMsg || !icsneoEnableNetworkRXQueue || !icsneoGetISO15765Status || !icsneoTxMessagesEx ||
!icsneoSetISO15765RxParameters || !icsneoGetConfiguration || !icsneoSendConfiguration ||
!icsneoGetFireSettings || !icsneoSetFireSettings || !icsneoGetVCAN3Settings ||
!icsneoSetVCAN3Settings || !icsneoGetVCANRFSettings || !icsneoSetVCANRFSettings || !icsneoGetFire2Settings ||
!icsneoGetVCAN412Settings || !icsneoSetVCAN412Settings ||
!icsneoSetFire2Settings || !icsneoGetRADGalaxySettings || !icsneoSetRADGalaxySettings ||
!icsneoSetFire2Settings || !icsneoGetRADGalaxySettings || !icsneoSetRADGalaxySettings ||
!icsneoSetBitRate || !icsneoGetDeviceParameters || !icsneoSerialNumberToString ||
!icsneoSetDeviceParameters || !icsneoGetLastAPIError || !icsneoGetErrorMessages ||
!icsneoGetErrorInfo || !icsneoScriptLoad || !icsneoScriptStart || !icsneoScriptStop ||

30
api/icsneolegacy/dllhelper/icsneo40DLLAPI.h
View File

@ -11,23 +11,23 @@ void UnloadDLLAPI(HINSTANCE &hAPIDLL);
//Basic Functions
typedef int (__stdcall *FINDNEODEVICES)(unsigned long DeviceTypes, NeoDevice *pNeoDevice, int *pNumDevices);
typedef int (__stdcall *OPENNEODEVICE)(NeoDevice *pNeoDevice, void * hObject, unsigned char *bNetworkIDs, int bConfigRead, int bSyncToPC);
typedef int (__stdcall *CLOSEPORT)(void * hObject, int *pNumberOfErrors);
typedef int (__stdcall *CLOSEPORT)(void * hObject, int *pNumberOfErrors);
typedef void (__stdcall *FREEOBJECT)(void * hObject);
typedef int (__stdcall *OPENPORTEX)(void * lPortNumber, int lPortType, int lDriverType, int lIPAddressMSB, int lIPAddressLSBOrBaudRate,
typedef int (__stdcall *OPENPORTEX)(void * lPortNumber, int lPortType, int lDriverType, int lIPAddressMSB, int lIPAddressLSBOrBaudRate,
int bConfigRead, unsigned char *bNetworkID, int * hObject);
typedef int (__stdcall *SERIALNUMBERTOSTRING) (unsigned long serial, char *data,unsigned long data_size);
//Message Functions
typedef int (__stdcall *GETMESSAGES)(void * hObject, icsSpyMessage *pMsg, int * pNumberOfMessages, int * pNumberOfErrors);
typedef int (__stdcall *TXMESSAGES)(void * hObject, icsSpyMessage *pMsg, int lNetworkID, int lNumMessages);
typedef int (__stdcall *GETMESSAGES)(void * hObject, icsSpyMessage *pMsg, int * pNumberOfMessages, int * pNumberOfErrors);
typedef int (__stdcall *TXMESSAGES)(void * hObject, icsSpyMessage *pMsg, int lNetworkID, int lNumMessages);
typedef int (__stdcall *TXMESSAGESEX)(void * hObject,icsSpyMessage *pMsg, unsigned int lNetworkID,unsigned int lNumMessages,unsigned int *NumTxed, unsigned int zero2);
typedef int (__stdcall *WAITFORRXMSGS)(void * hObject, unsigned int iTimeOut);
typedef int (__stdcall *ENABLERXQUEUE)(void * hObject, int iEnable);
typedef int (__stdcall *GETTSFORMSG)(void * hObject, icsSpyMessage *pMsg, double *pTimeStamp);
typedef void (__stdcall *GETISO15765STATUS)(void * hObject, int lNetwork, int lClearTxStatus,
typedef void (__stdcall *GETISO15765STATUS)(void * hObject, int lNetwork, int lClearTxStatus,
int lClearRxStatus, int *lTxStatus, int *lRxStatus);
typedef void (__stdcall *SETISO15765RXPARMS)(void * hObject, int lNetwork, int lEnable,
spyFilterLong *pFF_CFMsgFilter, icsSpyMessage *pTxMsg,
typedef void (__stdcall *SETISO15765RXPARMS)(void * hObject, int lNetwork, int lEnable,
spyFilterLong *pFF_CFMsgFilter, icsSpyMessage *pTxMsg,
int lCFTimeOutMs, int lFlowCBlockSize,
int lUsesExtendedAddressing, int lUseHardwareIfPresent);
typedef int (__stdcall *DOWNLOADISO15765_2_TXSCRIPT)(void * hObject, unsigned int NetworkID);
@ -36,7 +36,7 @@ typedef int (__stdcall *TXISO15765_2_MESSAGE)(void * hObject, stCM_ISO157652_TxM
//Device Functions
typedef int (__stdcall *GETCONFIG)(void * hObject, unsigned char * pData, int * lNumBytes);
typedef int (__stdcall *SENDCONFIG)(void * hObject, unsigned char * pData, int lNumBytes);
typedef int (__stdcall *SENDCONFIG)(void * hObject, unsigned char * pData, int lNumBytes);
typedef int (__stdcall *GETFIRESETTINGS)(void * hObject, SFireSettings *pSettings, int iNumBytes);
typedef int (__stdcall *SETFIRESETTINGS)(void * hObject, SFireSettings *pSettings, int iNumBytes, int bSaveToEEPROM);
@ -66,7 +66,7 @@ typedef int (__stdcall *SETDEVICEPARMS)(void * hObject, char *pParmValue, int *p
//Error Functions
typedef int (__stdcall *GETLASTAPIERROR)(void * hObject, unsigned long *pErrorNumber);
typedef int (__stdcall *GETERRMSGS)(void * hObject, int * pErrorMsgs, int * pNumberOfErrors);
typedef int (__stdcall *GETERRORINFO)(int lErrorNumber, TCHAR *szErrorDescriptionShort,
typedef int (__stdcall *GETERRORINFO)(int lErrorNumber, TCHAR *szErrorDescriptionShort,
TCHAR *szErrorDescriptionLong, int * lMaxLengthShort,
int * lMaxLengthLong,int * lErrorSeverity,int * lRestartNeeded);
@ -84,8 +84,8 @@ typedef int (__stdcall *STARTSOCKSERVER)(void * hObject, int iPort);
typedef int (__stdcall *STOPSOCKSERVER)(void * hObject);
//CoreMini Script functions
typedef int (__stdcall *SCRIPTSTART)(void * hObject, int iLocation);
typedef int (__stdcall *SCRIPTSTOP)(void * hObject);
typedef int (__stdcall *SCRIPTSTART)(void * hObject, int iLocation);
typedef int (__stdcall *SCRIPTSTOP)(void * hObject);
typedef int (__stdcall *SCRIPTLOAD)(void * hObject, const unsigned char * bin, unsigned long len_bytes, int iLocation);
typedef int (__stdcall *SCRIPTCLEAR)(void * hObject, int iLocation);
typedef int (__stdcall *SCRIPTSTARTFBLOCK)(void * hObject,unsigned int fb_index);
@ -99,15 +99,15 @@ typedef int (__stdcall *SCRIPTWRITEISO15765TXMESSAGE)(void * hObject, unsigned
//Deprecated (but still suppored in the DLL)
//////typedef int (__stdcall *OPENPORTEX)(int lPortSerialNumber, int lPortType, int lDriverType,
////// int lIPAddressMSB, int lIPAddressLSBOrBaudRate,int bConfigRead,
//////typedef int (__stdcall *OPENPORTEX)(int lPortSerialNumber, int lPortType, int lDriverType,
////// int lIPAddressMSB, int lIPAddressLSBOrBaudRate,int bConfigRead,
////// unsigned char * bNetworkID, int * hObject);
//////
//////typedef int (__stdcall *OPENPORT)(int lPortNumber, int lPortType, int lDriverType,
//////typedef int (__stdcall *OPENPORT)(int lPortNumber, int lPortType, int lDriverType,
////// unsigned char *bNetworkID, unsigned char *bSCPIDs, int * hObject);
//////typedef int (__stdcall *ENABLENETWORKCOM)(void * hObject, int Enable);
//////typedef int (__stdcall *FINDCOMDEVICES)(int lDriverType, int lGetSerialNumbers, int lStopAtFirst, int lUSBCommOnly,
////// int *p_lDeviceTypes, int *p_lComPorts, int *p_lSerialNumbers, int *lNumDevices);
////// int *p_lDeviceTypes, int *p_lComPorts, int *p_lSerialNumbers, int *lNumDevices);

2
communication/packetizer.cpp
View File

@ -17,7 +17,7 @@ std::vector<uint8_t>& Packetizer::packetWrap(std::vector<uint8_t>& data, bool sh
if(shortFormat) {
// Some devices don't use the checksum, so might as well not calculate it if that's the case
// Either way the byte is still expected to be present in the bytestream for short messages
data.push_back(disableChecksum ? 0x00 : ICSChecksum(data));
data.push_back(disableChecksum ? 0x00 : ICSChecksum(data));
}
data.insert(data.begin(), 0xAA);
if(align16bit && data.size() % 2 == 1) // Some devices always expect 16-bit aligned data

12
device/idevicesettings.cpp
View File

@ -217,7 +217,7 @@ bool IDeviceSettings::apply(bool temporary) {
if(!msg || msg->data[0] != 1) { // We did not receive a response
// Attempt to get the settings from the device so we're up to date if possible
if(refresh()) {
if(refresh()) {
// refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
}
@ -237,7 +237,7 @@ bool IDeviceSettings::apply(bool temporary) {
}, Main51MessageFilter(Command::SetSettings), std::chrono::milliseconds(1000));
if(!msg || msg->data[0] != 1) {
// Attempt to get the settings from the device so we're up to date if possible
if(refresh()) {
if(refresh()) {
// refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
}
@ -256,7 +256,7 @@ bool IDeviceSettings::apply(bool temporary) {
if(!ret) {
report(APIEvent::Type::FailedToWrite, APIEvent::Severity::Error);
}
return ret;
return ret;
}
bool IDeviceSettings::applyDefaults(bool temporary) {
@ -275,7 +275,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
}, Main51MessageFilter(Command::SetDefaultSettings), std::chrono::milliseconds(1000));
if(!msg || msg->data[0] != 1) {
// Attempt to get the settings from the device so we're up to date if possible
if(refresh()) {
if(refresh()) {
// refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
}
@ -305,7 +305,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
}, Main51MessageFilter(Command::SetSettings), std::chrono::milliseconds(1000));
if(!msg || msg->data[0] != 1) {
// Attempt to get the settings from the device so we're up to date if possible
if(refresh()) {
if(refresh()) {
// refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
}
@ -324,7 +324,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
if(!ret) {
report(APIEvent::Type::FailedToWrite, APIEvent::Severity::Error);
}
return ret;
return ret;
}
int64_t IDeviceSettings::getBaudrateFor(Network net) const {

2
examples/c/interactive/src/main.c
View File

@ -467,7 +467,7 @@ int main() {
for(size_t i = 0; i < msgCount; i++) {
neomessage_t* msg = &msgs[i];
switch(msg->type) {
case ICSNEO_NETWORK_TYPE_CAN: // CAN
case ICSNEO_NETWORK_TYPE_CAN: // CAN
{
neomessage_can_t* canMsg = (neomessage_can_t*) msg;
printf("\t0x%03x [%zu] ", canMsg->arbid, canMsg->length);

4
examples/cpp/interactive/src/InteractiveExample.cpp
View File

@ -128,7 +128,7 @@ void printDeviceWarnings(std::shared_ptr<icsneo::Device> device) {
* \returns the entered character
*
* This function repeatedly prompts the user for input until a matching input is entered
* Example usage:
* Example usage:
* char input = getCharInput(std::vector<char> {'F', 'u', 'b', 'a', 'r'});
*/
char getCharInput(std::vector<char> allowed) {
@ -537,7 +537,7 @@ int main() {
case '1':
{
// Shameless copy-paste from get messages above, demonstrating a callback
int callbackID = selectedDevice->addMessageCallback(icsneo::MessageCallback([](std::shared_ptr<icsneo::Message> msg){
int callbackID = selectedDevice->addMessageCallback(icsneo::MessageCallback([](std::shared_ptr<icsneo::Message> msg){
switch(msg->network.getType()) {
case icsneo::Network::Type::CAN:
{

10
examples/csharp/csharp.i
View File

@ -7,7 +7,7 @@
#define DLLExport
%typemap(ctype) uint8_t const *data "unsigned char *"
%typemap(ctype) uint8_t const *data "unsigned char *"
%typemap(imtype, out="System.IntPtr") uint8_t const *data "byte[]"
%typemap(cstype) uint8_t const *data "byte[]"
@ -23,16 +23,16 @@
%typemap(csvarout, excode=SWIGEXCODE2) uint8_t const *data %{
get {
byte[] ret = new byte[this.length];
System.IntPtr data = $imcall;
byte[] ret = new byte[this.length];
System.IntPtr data = $imcall;
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length)$excode;
return ret;
return ret;
}
%}
%typemap(ctype) char *str "char *"
%typemap(imtype) char *str "System.Text.StringBuilder"
%typemap(cstype) char *str "System.Text.StringBuilder"
%typemap(cstype) char *str "System.Text.StringBuilder"
%{
#include "icsneo/icsneoc.h"

2180
examples/csharp/csharp_wrap.c
View File

File diff suppressed because it is too large Load Diff

10
examples/csharp/icsneocsharpPINVOKE.cs
View File

@ -36,14 +36,14 @@ class icsneocsharpPINVOKE {
public static extern void SWIGRegisterExceptionCallbacks_icsneocsharp(
ExceptionDelegate applicationDelegate,
ExceptionDelegate arithmeticDelegate,
ExceptionDelegate divideByZeroDelegate,
ExceptionDelegate indexOutOfRangeDelegate,
ExceptionDelegate divideByZeroDelegate,
ExceptionDelegate indexOutOfRangeDelegate,
ExceptionDelegate invalidCastDelegate,
ExceptionDelegate invalidOperationDelegate,
ExceptionDelegate ioDelegate,
ExceptionDelegate nullReferenceDelegate,
ExceptionDelegate outOfMemoryDelegate,
ExceptionDelegate overflowDelegate,
ExceptionDelegate outOfMemoryDelegate,
ExceptionDelegate overflowDelegate,
ExceptionDelegate systemExceptionDelegate);
[global::System.Runtime.InteropServices.DllImport("icsneocsharp.dll", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_icsneocsharp")]
@ -136,7 +136,7 @@ class icsneocsharpPINVOKE {
if (pendingException != null)
pending = true;
return pending;
}
}
}
public static void Set(global::System.Exception e) {

16
examples/csharp/neodevice_t.cs
View File

@ -46,42 +46,42 @@ public class neodevice_t : global::System.IDisposable {
public SWIGTYPE_p_void device {
set {
icsneocsharpPINVOKE.neodevice_t_device_set(swigCPtr, SWIGTYPE_p_void.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neodevice_t_device_get(swigCPtr);
SWIGTYPE_p_void ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
return ret;
}
}
}
public int handle {
set {
icsneocsharpPINVOKE.neodevice_t_handle_set(swigCPtr, value);
}
}
get {
int ret = icsneocsharpPINVOKE.neodevice_t_handle_get(swigCPtr);
return ret;
}
}
}
public uint type {
set {
icsneocsharpPINVOKE.neodevice_t_type_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neodevice_t_type_get(swigCPtr);
return ret;
}
}
}
public string serial {
set {
icsneocsharpPINVOKE.neodevice_t_serial_set(swigCPtr, value);
}
}
get {
string ret = icsneocsharpPINVOKE.neodevice_t_serial_get(swigCPtr);
return ret;
}
}
}
public neodevice_t() : this(icsneocsharpPINVOKE.new_neodevice_t(), true) {

24
examples/csharp/neoevent_t.cs
View File

@ -46,64 +46,64 @@ public class neoevent_t : global::System.IDisposable {
public string description {
set {
icsneocsharpPINVOKE.neoevent_t_description_set(swigCPtr, value);
}
}
get {
string ret = icsneocsharpPINVOKE.neoevent_t_description_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_time_t timestamp {
set {
icsneocsharpPINVOKE.neoevent_t_timestamp_set(swigCPtr, SWIGTYPE_p_time_t.getCPtr(value));
if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
}
}
get {
SWIGTYPE_p_time_t ret = new SWIGTYPE_p_time_t(icsneocsharpPINVOKE.neoevent_t_timestamp_get(swigCPtr), true);
if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
}
public uint eventNumber {
set {
icsneocsharpPINVOKE.neoevent_t_eventNumber_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neoevent_t_eventNumber_get(swigCPtr);
return ret;
}
}
}
public byte severity {
set {
icsneocsharpPINVOKE.neoevent_t_severity_set(swigCPtr, value);
}
}
get {
byte ret = icsneocsharpPINVOKE.neoevent_t_severity_get(swigCPtr);
return ret;
}
}
}
public string serial {
set {
icsneocsharpPINVOKE.neoevent_t_serial_set(swigCPtr, value);
}
}
get {
string ret = icsneocsharpPINVOKE.neoevent_t_serial_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_unsigned_char reserved {
set {
icsneocsharpPINVOKE.neoevent_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neoevent_t_reserved_get(swigCPtr);
SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret;
}
}
}
public neoevent_t() : this(icsneocsharpPINVOKE.new_neoevent_t(), true) {

42
examples/csharp/neomessage_can_t.cs
View File

@ -46,32 +46,32 @@ public class neomessage_can_t : global::System.IDisposable {
public neomessage_statusbitfield_t status {
set {
icsneocsharpPINVOKE.neomessage_can_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_can_t_status_get(swigCPtr);
neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
return ret;
}
}
}
public ulong timestamp {
set {
icsneocsharpPINVOKE.neomessage_can_t_timestamp_set(swigCPtr, value);
}
}
get {
ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestamp_get(swigCPtr);
return ret;
}
}
}
public ulong timestampReserved {
set {
icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_set(swigCPtr, value);
}
}
get {
ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_get(swigCPtr);
return ret;
}
}
}
public byte[] data {
@ -80,10 +80,10 @@ public class neomessage_can_t : global::System.IDisposable {
}
get {
byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_can_t_data_get(swigCPtr);
byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_can_t_data_get(swigCPtr);
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length);
return ret;
return ret;
}
}
@ -91,62 +91,62 @@ public class neomessage_can_t : global::System.IDisposable {
public uint length {
set {
icsneocsharpPINVOKE.neomessage_can_t_length_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_can_t_length_get(swigCPtr);
return ret;
}
}
}
public uint arbid {
set {
icsneocsharpPINVOKE.neomessage_can_t_arbid_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_can_t_arbid_get(swigCPtr);
return ret;
}
}
}
public ushort netid {
set {
icsneocsharpPINVOKE.neomessage_can_t_netid_set(swigCPtr, value);
}
}
get {
ushort ret = icsneocsharpPINVOKE.neomessage_can_t_netid_get(swigCPtr);
return ret;
}
}
}
public byte type {
set {
icsneocsharpPINVOKE.neomessage_can_t_type_set(swigCPtr, value);
}
}
get {
byte ret = icsneocsharpPINVOKE.neomessage_can_t_type_get(swigCPtr);
return ret;
}
}
}
public byte dlcOnWire {
set {
icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_set(swigCPtr, value);
}
}
get {
byte ret = icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_unsigned_char reserved {
set {
icsneocsharpPINVOKE.neomessage_can_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_can_t_reserved_get(swigCPtr);
SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret;
}
}
}
public neomessage_can_t() : this(icsneocsharpPINVOKE.new_neomessage_can_t(), true) {

42
examples/csharp/neomessage_eth_t.cs
View File

@ -46,32 +46,32 @@ public class neomessage_eth_t : global::System.IDisposable {
public neomessage_statusbitfield_t status {
set {
icsneocsharpPINVOKE.neomessage_eth_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_status_get(swigCPtr);
neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
return ret;
}
}
}
public ulong timestamp {
set {
icsneocsharpPINVOKE.neomessage_eth_t_timestamp_set(swigCPtr, value);
}
}
get {
ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestamp_get(swigCPtr);
return ret;
}
}
}
public ulong timestampReserved {
set {
icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_set(swigCPtr, value);
}
}
get {
ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_get(swigCPtr);
return ret;
}
}
}
public byte[] data {
@ -80,10 +80,10 @@ public class neomessage_eth_t : global::System.IDisposable {
}
get {
byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_eth_t_data_get(swigCPtr);
byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_eth_t_data_get(swigCPtr);
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length);
return ret;
return ret;
}
}
@ -91,63 +91,63 @@ public class neomessage_eth_t : global::System.IDisposable {
public uint length {
set {
icsneocsharpPINVOKE.neomessage_eth_t_length_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_eth_t_length_get(swigCPtr);
return ret;
}
}
}
public byte preemptionFlags {
set {
icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_set(swigCPtr, value);
}
}
get {
byte ret = icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_unsigned_char reservedHeader {
set {
icsneocsharpPINVOKE.neomessage_eth_t_reservedHeader_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_reservedHeader_get(swigCPtr);
SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret;
}
}
}
public ushort netid {
set {
icsneocsharpPINVOKE.neomessage_eth_t_netid_set(swigCPtr, value);
}
}
get {
ushort ret = icsneocsharpPINVOKE.neomessage_eth_t_netid_get(swigCPtr);
return ret;
}
}
}
public byte type {
set {
icsneocsharpPINVOKE.neomessage_eth_t_type_set(swigCPtr, value);
}
}
get {
byte ret = icsneocsharpPINVOKE.neomessage_eth_t_type_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_unsigned_char reserved {
set {
icsneocsharpPINVOKE.neomessage_eth_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_reserved_get(swigCPtr);
SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret;
}
}
}
public neomessage_eth_t() : this(icsneocsharpPINVOKE.new_neomessage_eth_t(), true) {

224
examples/csharp/neomessage_statusbitfield_t.cs
View File

@ -46,562 +46,562 @@ public class neomessage_statusbitfield_t : global::System.IDisposable {
public uint globalError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_get(swigCPtr);
return ret;
}
}
}
public uint transmitMessage {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_get(swigCPtr);
return ret;
}
}
}
public uint extendedFrame {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_get(swigCPtr);
return ret;
}
}
}
public uint remoteFrame {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_get(swigCPtr);
return ret;
}
}
}
public uint crcError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_get(swigCPtr);
return ret;
}
}
}
public uint canErrorPassive {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_get(swigCPtr);
return ret;
}
}
}
public uint incompleteFrame {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_get(swigCPtr);
return ret;
}
}
}
public uint lostArbitration {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_get(swigCPtr);
return ret;
}
}
}
public uint undefinedError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_get(swigCPtr);
return ret;
}
}
}
public uint canBusOff {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_get(swigCPtr);
return ret;
}
}
}
public uint canErrorWarning {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_get(swigCPtr);
return ret;
}
}
}
public uint canBusShortedPlus {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_get(swigCPtr);
return ret;
}
}
}
public uint canBusShortedGround {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_get(swigCPtr);
return ret;
}
}
}
public uint checksumError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_get(swigCPtr);
return ret;
}
}
}
public uint badMessageBitTimeError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_get(swigCPtr);
return ret;
}
}
}
public uint ifrData {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_get(swigCPtr);
return ret;
}
}
}
public uint hardwareCommError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_get(swigCPtr);
return ret;
}
}
}
public uint expectedLengthError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_get(swigCPtr);
return ret;
}
}
}
public uint incomingNoMatch {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_get(swigCPtr);
return ret;
}
}
}
public uint statusBreak {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_get(swigCPtr);
return ret;
}
}
}
public uint avsiRecOverflow {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_get(swigCPtr);
return ret;
}
}
}
public uint testTrigger {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_get(swigCPtr);
return ret;
}
}
}
public uint audioComment {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_get(swigCPtr);
return ret;
}
}
}
public uint gpsData {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_get(swigCPtr);
return ret;
}
}
}
public uint analogDigitalInput {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_get(swigCPtr);
return ret;
}
}
}
public uint textComment {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_get(swigCPtr);
return ret;
}
}
}
public uint networkMessageType {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_get(swigCPtr);
return ret;
}
}
}
public uint vsiTXUnderrun {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_get(swigCPtr);
return ret;
}
}
}
public uint vsiIFRCRCBit {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_get(swigCPtr);
return ret;
}
}
}
public uint initMessage {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_get(swigCPtr);
return ret;
}
}
}
public uint flexraySecondStartupFrame {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_get(swigCPtr);
return ret;
}
}
}
public uint extended {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_get(swigCPtr);
return ret;
}
}
}
public uint hasValue {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_get(swigCPtr);
return ret;
}
}
}
public uint valueIsBoolean {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_get(swigCPtr);
return ret;
}
}
}
public uint highVoltage {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_get(swigCPtr);
return ret;
}
}
}
public uint longMessage {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_get(swigCPtr);
return ret;
}
}
}
public uint globalChange {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_get(swigCPtr);
return ret;
}
}
}
public uint errorFrame {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_get(swigCPtr);
return ret;
}
}
}
public uint endOfLongMessage {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_get(swigCPtr);
return ret;
}
}
}
public uint linErrorRXBreakNotZero {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_get(swigCPtr);
return ret;
}
}
}
public uint linErrorRXBreakTooShort {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_get(swigCPtr);
return ret;
}
}
}
public uint linErrorRXSyncNot55 {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_get(swigCPtr);
return ret;
}
}
}
public uint linErrorRXDataGreaterEight {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_get(swigCPtr);
return ret;
}
}
}
public uint linErrorTXRXMismatch {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_get(swigCPtr);
return ret;
}
}
}
public uint linErrorMessageIDParity {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_get(swigCPtr);
return ret;
}
}
}
public uint linSyncFrameError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_get(swigCPtr);
return ret;
}
}
}
public uint linIDFrameError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_get(swigCPtr);
return ret;
}
}
}
public uint linSlaveByteError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_get(swigCPtr);
return ret;
}
}
}
public uint rxTimeoutError {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_get(swigCPtr);
return ret;
}
}
}
public uint linNoSlaveData {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_get(swigCPtr);
return ret;
}
}
}
public uint canfdESI {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_get(swigCPtr);
return ret;
}
}
}
public uint canfdIDE {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_get(swigCPtr);
return ret;
}
}
}
public uint canfdRTR {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_get(swigCPtr);
return ret;
}
}
}
public uint canfdFDF {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_get(swigCPtr);
return ret;
}
}
}
public uint canfdBRS {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_unsigned_int statusBitfield {
set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBitfield_set(swigCPtr, SWIGTYPE_p_unsigned_int.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBitfield_get(swigCPtr);
SWIGTYPE_p_unsigned_int ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
return ret;
}
}
}
public neomessage_statusbitfield_t() : this(icsneocsharpPINVOKE.new_neomessage_statusbitfield_t(), true) {

38
examples/csharp/neomessage_t.cs
View File

@ -46,32 +46,32 @@ public class neomessage_t : global::System.IDisposable {
public neomessage_statusbitfield_t status {
set {
icsneocsharpPINVOKE.neomessage_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_status_get(swigCPtr);
neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
return ret;
}
}
}
public ulong timestamp {
set {
icsneocsharpPINVOKE.neomessage_t_timestamp_set(swigCPtr, value);
}
}
get {
ulong ret = icsneocsharpPINVOKE.neomessage_t_timestamp_get(swigCPtr);
return ret;
}
}
}
public ulong timestampReserved {
set {
icsneocsharpPINVOKE.neomessage_t_timestampReserved_set(swigCPtr, value);
}
}
get {
ulong ret = icsneocsharpPINVOKE.neomessage_t_timestampReserved_get(swigCPtr);
return ret;
}
}
}
public byte[] data {
@ -80,10 +80,10 @@ public class neomessage_t : global::System.IDisposable {
}
get {
byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_t_data_get(swigCPtr);
byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_t_data_get(swigCPtr);
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length);
return ret;
return ret;
}
}
@ -91,53 +91,53 @@ public class neomessage_t : global::System.IDisposable {
public uint length {
set {
icsneocsharpPINVOKE.neomessage_t_length_set(swigCPtr, value);
}
}
get {
uint ret = icsneocsharpPINVOKE.neomessage_t_length_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_unsigned_char header {
set {
icsneocsharpPINVOKE.neomessage_t_header_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_header_get(swigCPtr);
SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret;
}
}
}
public ushort netid {
set {
icsneocsharpPINVOKE.neomessage_t_netid_set(swigCPtr, value);
}
}
get {
ushort ret = icsneocsharpPINVOKE.neomessage_t_netid_get(swigCPtr);
return ret;
}
}
}
public byte type {
set {
icsneocsharpPINVOKE.neomessage_t_type_set(swigCPtr, value);
}
}
get {
byte ret = icsneocsharpPINVOKE.neomessage_t_type_get(swigCPtr);
return ret;
}
}
}
public SWIGTYPE_p_unsigned_char reserved {
set {
icsneocsharpPINVOKE.neomessage_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
}
}
get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_reserved_get(swigCPtr);
SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret;
}
}
}
public neomessage_t() : this(icsneocsharpPINVOKE.new_neomessage_t(), true) {

28
examples/csharp/neoversion_t.cs
View File

@ -46,71 +46,71 @@ public class neoversion_t : global::System.IDisposable {
public ushort major {
set {
icsneocsharpPINVOKE.neoversion_t_major_set(swigCPtr, value);
}
}
get {
ushort ret = icsneocsharpPINVOKE.neoversion_t_major_get(swigCPtr);
return ret;
}
}
}
public ushort minor {
set {
icsneocsharpPINVOKE.neoversion_t_minor_set(swigCPtr, value);
}
}
get {
ushort ret = icsneocsharpPINVOKE.neoversion_t_minor_get(swigCPtr);
return ret;
}
}
}
public ushort patch {
set {
icsneocsharpPINVOKE.neoversion_t_patch_set(swigCPtr, value);
}
}
get {
ushort ret = icsneocsharpPINVOKE.neoversion_t_patch_get(swigCPtr);
return ret;
}
}
}
public string metadata {
set {
icsneocsharpPINVOKE.neoversion_t_metadata_set(swigCPtr, value);
}
}
get {
string ret = icsneocsharpPINVOKE.neoversion_t_metadata_get(swigCPtr);
return ret;
}
}
}
public string buildBranch {
set {
icsneocsharpPINVOKE.neoversion_t_buildBranch_set(swigCPtr, value);
}
}
get {
string ret = icsneocsharpPINVOKE.neoversion_t_buildBranch_get(swigCPtr);
return ret;
}
}
}
public string buildTag {
set {
icsneocsharpPINVOKE.neoversion_t_buildTag_set(swigCPtr, value);
}
}
get {
string ret = icsneocsharpPINVOKE.neoversion_t_buildTag_get(swigCPtr);
return ret;
}
}
}
public string reserved {
set {
icsneocsharpPINVOKE.neoversion_t_reserved_set(swigCPtr, value);
}
}
get {
string ret = icsneocsharpPINVOKE.neoversion_t_reserved_get(swigCPtr);
return ret;
}
}
}
public neoversion_t() : this(icsneocsharpPINVOKE.new_neoversion_t(), true) {

2324
examples/java/java_wrap.c
View File

File diff suppressed because it is too large Load Diff

6
include/icsneo/api/eventmanager.h
View File

@ -117,11 +117,11 @@ public:
eventLimit = newLimit;
std::lock_guard<std::mutex> eventsLock(eventsMutex);
if(enforceLimit())
if(enforceLimit())
add_internal_event(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventWarning));
}
size_t getEventLimit() const {
size_t getEventLimit() const {
std::lock_guard<std::mutex> lk(eventLimitMutex);
return eventLimit;
}
@ -180,7 +180,7 @@ private:
* Otherwise, remove the oldest event, push the event to the back and push a APIEvent::TooManyEvents to the back (in that order)
*/
void add_internal_event(APIEvent event) {
// Ensure the event list is at most exactly full (size of eventLimit - 1, leaving room for a potential APIEvent::TooManyEvents)
// Ensure the event list is at most exactly full (size of eventLimit - 1, leaving room for a potential APIEvent::TooManyEvents)
// Removes any events of type TooManyEvents from the end before checking to avoid duplicates.
enforceLimit();

4
include/icsneo/device/device.h
View File

@ -125,8 +125,8 @@ protected:
}
virtual device_eventhandler_t makeEventHandler() {
return [this](APIEvent::Type type, APIEvent::Severity severity) {
EventManager::GetInstance().add(type, severity, this);
return [this](APIEvent::Type type, APIEvent::Severity severity) {
EventManager::GetInstance().add(type, severity, this);
};
}

4
include/icsneo/icsnVC40.h
View File

@ -141,8 +141,8 @@ typedef unsigned __int64 uint64_t;
#define NETID_INVALID 0xffff
/* Device types -- value of DeviceType of NeoDevice */
/* Older devices have a value on a specific bit. Those values have not changed
* to support existing apps using the api. New devices can fill in between the
/* Older devices have a value on a specific bit. Those values have not changed
* to support existing apps using the api. New devices can fill in between the
* existing ones. I know it hurts, but it's just a number!
*/
//clang-format off

224
include/icsneo/icsneoc.h
View File

@ -22,16 +22,16 @@ extern "C" {
* \param[out] devices Pointer to memory where devices should be written. If NULL, the current number of detected devices is written to count.
* \param[inout] count Pointer to a size_t, which should initially contain the number of devices the buffer can hold,
* and will afterwards contain the number of devices found.
*
*
* For each found device, a neodevice_t structure will be written into the memory you provide.
*
*
* The neodevice_t can later be passed by reference into the API to perform actions relating to the device.
* The neodevice_t contains a handle to the internal memory for the icsneo::Device object.
* The memory for the internal icsneo::Device object is managed by the API.
*
*
* Any neodevice_t objects which have not been opened will become invalid when icsneo_findAllDevices() is called again.
* To invoke this behavior without finding devices again, call icsneo_freeUnconnectedDevices().
*
*
* If the size provided is not large enough, the output will be truncated.
* An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
*/
@ -39,7 +39,7 @@ extern void DLLExport icsneo_findAllDevices(neodevice_t* devices, size_t* count)
/**
* \brief Invalidate neodevice_t objects which have not been opened.
*
*
* See icsneo_findAllDevices() for information regarding the neodevice_t validity contract.
*/
extern void DLLExport icsneo_freeUnconnectedDevices();
@ -52,16 +52,16 @@ extern void DLLExport icsneo_freeUnconnectedDevices();
* holds the maximum number of characters to be written (so str must be of size count + 1 to account for the NULL terminator),
* and after the call holds the number of characters written.
* \returns True if str contains the string representation of the given serial number.
*
*
* On older devices, the serial number is one like 138635, the numerical representation is the same as the string representation.
*
*
* On newer devices, the serial number is one like RS2259, and this function can convert the numerical value back into the string seen on the back of the device.
*
*
* A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid.
*
*
* The client application should provide a buffer of size 7, as serial numbers are always 6 characters or fewer.
*
*
* If the size provided is not large enough, the output will be **NOT** be truncated.
* Nothing will be written to the output.
* Instead, an icsneo::APIEvent::BufferInsufficient will be available in icsneo_getLastError().
@ -73,9 +73,9 @@ extern bool DLLExport icsneo_serialNumToString(uint32_t num, char* str, size_t*
* \brief Convert a serial number in string format to its numerical representation.
* \param[in] str A NULL terminated string containing the string representation of an Intrepid serial number.
* \returns The numerical representation of the serial number, or 0 if the conversion was unsuccessful.
*
*
* On older devices, the serial number is one like 138635, and this string will simply be returned as a number.
*
*
* On newer devices, the serial number is one like RS2259, and this function can convert that string to a number.
*/
extern uint32_t DLLExport icsneo_serialStringToNum(const char* str);
@ -84,10 +84,10 @@ extern uint32_t DLLExport icsneo_serialStringToNum(const char* str);
* \brief Verify that a neodevice_t is valid.
* \param[in] device A pointer to the neodevice_t structure to operate on.
* \returns True if the neodevice_t is valid.
*
*
* This check is automatically performed at the beginning of any API function that operates on a device.
* If there is a failure, an icsneo::APIEvent::InvalidNeoDevice will be available in icsneo_getLastError().
*
*
* See icsneo_findAllDevices() for information regarding the neodevice_t validity contract.
*/
extern bool DLLExport icsneo_isValidNeoDevice(const neodevice_t* device);
@ -96,13 +96,13 @@ extern bool DLLExport icsneo_isValidNeoDevice(const neodevice_t* device);
* \brief Connect to the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to open.
* \returns True if the connection could be opened.
*
*
* The device **MUST** be opened before any other functions which operate on the device will be valid.
*
*
* See icsneo_goOnline() for information about enabling network communication once the device is open.
*
*
* If the open did not succeed, icsneo_getLastError() should provide more information about why.
*
*
* If the device was already open, an icsneo::APIEvent::DeviceCurrentlyOpen will be available in icsneo_getLastError().
*/
extern bool DLLExport icsneo_openDevice(const neodevice_t* device);
@ -111,7 +111,7 @@ extern bool DLLExport icsneo_openDevice(const neodevice_t* device);
* \brief Close an open connection to the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to close.
* \returns True if the connection could be closed.
*
*
* After this function succeeds, the neodevice_t will be invalid.
* To connect again, you must call icsneo_findAllDevices() or similar to re-find the device.
*/
@ -121,9 +121,9 @@ extern bool DLLExport icsneo_closeDevice(const neodevice_t* device);
* \brief Verify network connection for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the device is connected.
*
*
* This function does not modify the working state of the device at all.
*
*
* See icsneo_openDevice() for an explanation about the concept of being "open".
*/
extern bool DLLExport icsneo_isOpen(const neodevice_t* device);
@ -132,12 +132,12 @@ extern bool DLLExport icsneo_isOpen(const neodevice_t* device);
* \brief Enable network communication for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if communication could be enabled.
*
*
* The device is not "online" when it is first opened. It is not possible to receive or transmit while the device is "offline".
* Network controllers are disabled. (i.e. In the case of CAN, the hardware will not send ACKs on the client application's behalf)
*
*
* This allows filtering or handlers to be set up before allowing traffic to flow.
*
*
* This also allows device settings to be set (i.e. baudrates) before enabling the controllers,
* which prevents momentarily causing loss of communication if the baud rates are not correct.
*/
@ -147,7 +147,7 @@ extern bool DLLExport icsneo_goOnline(const neodevice_t* device);
* \brief Disable network communication for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if communication could be disabled.
*
*
* See icsneo_goOnline() for an explanation about the concept of being "online".
*/
extern bool DLLExport icsneo_goOffline(const neodevice_t* device);
@ -156,9 +156,9 @@ extern bool DLLExport icsneo_goOffline(const neodevice_t* device);
* \brief Verify network communication for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if communication is enabled.
*
*
* This function does not modify the working state of the device at all.
*
*
* See icsneo_goOnline() for an explanation about the concept of being "online".
*/
extern bool DLLExport icsneo_isOnline(const neodevice_t* device);
@ -167,23 +167,23 @@ extern bool DLLExport icsneo_isOnline(const neodevice_t* device);
* \brief Enable buffering of messages for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if polling could be enabled.
*
*
* By default, traffic the device receives will not reach the client application.
* The client application must register traffic handlers, enable message polling, or both.
* This function addresses message polling.
*
*
* With polling enabled, all traffic that the device receives will be stored in a buffer managed by the API.
* The client application should then call icsneo_getMessages() periodically to take ownership of the messages in that buffer.
*
*
* The API managed buffer will only grow to a specified size, 20k messages by default.
* See icsneo_getPollingMessageLimit() and icsneo_setPollingMessageLimit() for more information.
*
*
* In high traffic situations, the default 20k message limit can be reached very quickly.
* The client application will have to call icsneo_getMessages() very often to avoid losing messages, or change the limit.
*
*
* If the message limit is exceeded before a call to icsneo_getMessages() takes ownership of the messages,
* the oldest message will be dropped (**LOST**) and an icsneo::APIEvent::PollingMessageOverflow will be flagged for the device.
*
*
* This function will succeed even if the device is not open.
*/
extern bool DLLExport icsneo_enableMessagePolling(const neodevice_t* device);
@ -192,9 +192,9 @@ extern bool DLLExport icsneo_enableMessagePolling(const neodevice_t* device);
* \brief Disable buffering of messages for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if polling could be disabled.
*
*
* See icsneo_enableMessagePolling() for more information about the message polling system.
*
*
* Any messages left in the API managed buffer will be lost upon disabling polling.
*/
extern bool DLLExport icsneo_disableMessagePolling(const neodevice_t* device);
@ -203,9 +203,9 @@ extern bool DLLExport icsneo_disableMessagePolling(const neodevice_t* device);
* \brief Verify message polling status for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if polling is enabled.
*
*
* This function does not modify the working state of the device at all.
*
*
* See icsneo_enableMessagePolling() for an explanation about how polling works.
*/
extern bool DLLExport icsneo_isMessagePollingEnabled(const neodevice_t* device);
@ -219,22 +219,22 @@ extern bool DLLExport icsneo_isMessagePollingEnabled(const neodevice_t* device);
* \param[in] timeout The number of milliseconds to wait for a message to arrive. A value of 0 indicates a non-blocking call.
* Querying for the current message count is always asynchronous and ignores this value.
* \returns True if the messages were read out successfully (even if there were no messages to read) or if the count was read successfully.
*
*
* Messages are available using this function if icsneo_goOnline() and icsneo_enableMessagePolling() have been called.
* See those functions for more information.
*
*
* Messages are read out of the API managed buffer in order of oldest to newest.
* As they are read out, they are removed from the API managed buffer.
*
*
* If size is too small to contain all messages, as many messages as will fit will be read out.
* Subsequent calls to icsneo_getMessages() can retrieve any messages which were not read out.
*
*
* The memory for the data pointer within the neomessage_t is managed by the API. Do *not* attempt to free the data pointer.
* The memory will become invalid the next time icsneo_getMessages() is called for this device.
*
*
* \warning Do not call icsneo_close() while another thread is waiting on icsneo_getMessages().
* Always allow the other thread to timeout first!
*
*
* ``` C
* size_t messageCount;
* bool result = icsneo_getMessages(device, NULL, &messageCount, 0); // Reading the message count
@ -266,7 +266,7 @@ extern bool DLLExport icsneo_getMessages(const neodevice_t* device, neomessage_t
* \brief Get the maximum number of messages which will be held in the API managed buffer for the specified hardware.
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns Number of messages, or -1 if device is invalid.
*
*
* See icsneo_enableMessagePolling() for more information about the message polling system.
*/
extern int DLLExport icsneo_getPollingMessageLimit(const neodevice_t* device);
@ -276,9 +276,9 @@ extern int DLLExport icsneo_getPollingMessageLimit(const neodevice_t* device);
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \param[in] newLimit The new limit to be enforced.
* \returns True if the limit was set successfully.
*
*
* See icsneo_enableMessagePolling() for more information about the message polling system.
*
*
* Setting the maximum lower than the current number of stored messages will cause the oldest messages
* to be dropped (**LOST**) and an icsneo::APIEvent::PollingMessageOverflow to be flagged for the device.
*/
@ -309,16 +309,16 @@ extern bool DLLExport icsneo_removeMessageCallback(const neodevice_t* device, in
* holds the maximum number of characters to be written (so str must be of size maxLength + 1 to account for the NULL terminator),
* and after the call holds the number of characters written.
* \returns True if str was written to
*
*
* In the case of a neoVI FIRE 2, this function will write a string "neoVI FIRE 2" with a NULL terminator into str.
*
*
* The constant ICSNEO_DEVICETYPE_LONGEST_NAME is defined for the client application to create static buffers of the correct length.
*
*
* See also icsneo_describeDevice().
*
*
* A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid.
*
*
* If the size provided is not large enough, the output will be truncated.
* An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned.
@ -333,16 +333,16 @@ extern bool DLLExport icsneo_getProductName(const neodevice_t* device, char* str
* holds the maximum number of characters to be written (so str must be of size maxLength + 1 to account for the NULL terminator),
* and after the call holds the number of characters written.
* \returns True if str was written to
*
*
* In the case of a neoVI FIRE 2, this function will write a string "neoVI FIRE 2" with a NULL terminator into str.
*
*
* The constant ICSNEO_DEVICETYPE_LONGEST_NAME is defined for the client application to create static buffers of the correct length.
*
*
* See also icsneo_describeDevice().
*
*
* A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid.
*
*
* If the size provided is not large enough, the output will be truncated.
* An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned.
@ -360,11 +360,11 @@ extern bool DLLExport icsneo_settingsRefresh(const neodevice_t* device);
* \brief Commit the settings structure for a specified device to non-volatile storage.
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the settings were applied.
*
*
* When modifications are made to the device settings, this function (or icsneo_settingsApplyTemporary()) must be called to send the changes to the device and make them active.
*
*
* This function sets the settings such that they will survive device power cycles.
*
*
* If the function fails, the settings will be refreshed so that the structure in the API matches the one held by the device.
*/
extern bool DLLExport icsneo_settingsApply(const neodevice_t* device);
@ -373,9 +373,9 @@ extern bool DLLExport icsneo_settingsApply(const neodevice_t* device);
* \brief Apply the settings structure for a specified device temporarily.
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the settings were applied.
*
*
* See icsneo_settingsApply() for further information about applying settings.
*
*
* This function sets the settings such that they will revert to the values saved in non-volatile storage when the device loses power.
*/
extern bool DLLExport icsneo_settingsApplyTemporary(const neodevice_t* device);
@ -384,9 +384,9 @@ extern bool DLLExport icsneo_settingsApplyTemporary(const neodevice_t* device);
* \brief Apply the default settings structure for a specified device.
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the default settings were applied.
*
*
* See icsneo_settingsApply() for further information about applying settings.
*
*
* This function sets the default settings such that they will survive device power cycles.
*/
extern bool DLLExport icsneo_settingsApplyDefaults(const neodevice_t* device);
@ -395,9 +395,9 @@ extern bool DLLExport icsneo_settingsApplyDefaults(const neodevice_t* device);
* \brief Apply the default settings structure for a specified device temporarily.
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the default settings were applied.
*
*
* See icsneo_settingsApply() for further information about applying settings. See icsneo_settingsApplyDefaults() for further information about applying default settings.
*
*
* This function sets the default settings such that they will revert to the values saved in non-volatile storage when the device loses power.
*/
extern bool DLLExport icsneo_settingsApplyDefaultsTemporary(const neodevice_t* device);
@ -408,11 +408,11 @@ extern bool DLLExport icsneo_settingsApplyDefaultsTemporary(const neodevice_t* d
* \param[out] structure A pointer to a device settings structure for the current device.
* \param[in] structureSize The size of the current device settings structure in bytes.
* \returns Number of bytes written to structure, or -1 if the operation failed.
*
*
* See icsneo_settingsApply() for further information about applying settings. See icsneo_settingsApplyDefaults() for further information about applying default settings.
*
*
* This function sets the default settings such that they will revert to the values saved in non-volatile storage when the device loses power.
*
*
* If possible, use functions specific to the operation you want to acomplish (such as icsneo_setBaudrate()) instead of modifying the structure directly.
* This allows the client application to work with other hardware.
*/
@ -424,9 +424,9 @@ extern int DLLExport icsneo_settingsReadStructure(const neodevice_t* device, voi
* \param[in] structure A pointer to a device settings structure for the current device.
* \param[in] structureSize The size of the current device settings structure in bytes.
* \returns True if the settings were applied.
*
*
* This function immediately applies the provided settings. See icsneo_settingsApplyTemporary() for further information about applying settings.
*
*
* If possible, use functions specific to the operation you want to acomplish (such as icsneo_setBaudrate()) instead of modifying the structure directly.
* This allows the client application to work with other hardware.
*/
@ -438,11 +438,11 @@ extern bool DLLExport icsneo_settingsApplyStructure(const neodevice_t* device, c
* \param[in] structure A pointer to a device settings structure for the current device.
* \param[in] structureSize The size of the current device settings structure in bytes.
* \returns True if the settings were applied.
*
*
* This function immediately applies the provided settings. See icsneo_settingsApply() for further information about applying settings.
*
*
* This function sets the default settings such that they will revert to the values saved in non-volatile storage when the device loses power.
*
*
* If possible, use functions specific to the operation you want to acomplish (such as icsneo_setBaudrate()) instead of modifying the structure directly.
* This allows the client application to work with other hardware.
*/
@ -453,7 +453,7 @@ extern bool DLLExport icsneo_settingsApplyStructureTemporary(const neodevice_t*
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \param[in] netid The network for which the baudrate should be retrieved.
* \returns The value in baud with no multipliers. (i.e. 500k becomes 500000) A negative value is returned if an error occurs.
*
*
* In the case of CAN, this function gets the standard CAN baudrate.
* See icsneo_getFDBaudrate() to get the baudrate for (the baudrate-switched portion of) CAN FD.
*/
@ -465,10 +465,10 @@ extern int64_t DLLExport icsneo_getBaudrate(const neodevice_t* device, uint16_t
* \param[in] netid The network to which the new baudrate should apply.
* \param[in] newBaudrate The requested baudrate, with no multipliers. (i.e. 500K CAN should be represented as 500000)
* \returns True if the baudrate could be set.
*
*
* In the case of CAN, this function sets the standard CAN baudrate.
* See icsneo_setFDBaudrate() to set the baudrate for (the baudrate-switched portion of) CAN FD.
*
*
* Call icsneo_settingsApply() or similar to make the changes active on the device.
*/
extern bool DLLExport icsneo_setBaudrate(const neodevice_t* device, uint16_t netid, int64_t newBaudrate);
@ -478,7 +478,7 @@ extern bool DLLExport icsneo_setBaudrate(const neodevice_t* device, uint16_t net
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \param[in] netid The network for which the baudrate should be retrieved.
* \returns The value in baud with no multipliers. (i.e. 500k becomes 500000) A negative value is returned if an error occurs.
*
*
* See icsneo_getBaudrate() to get the baudrate for the non baudrate-switched portion of CAN FD, classical CAN 2.0, and other network types.
*/
extern int64_t DLLExport icsneo_getFDBaudrate(const neodevice_t* device, uint16_t netid);
@ -489,9 +489,9 @@ extern int64_t DLLExport icsneo_getFDBaudrate(const neodevice_t* device, uint16_
* \param[in] netid The network to which the new baudrate should apply.
* \param[in] newBaudrate The requested baudrate, with no multipliers. (i.e. 2Mbaud CAN FD should be represented as 2000000)
* \returns True if the baudrate could be set.
*
*
* See icsneo_setBaudrate() to set the baudrate for the non baudrate-switched portion of CAN FD, classical CAN 2.0, and other network types.
*
*
* Call icsneo_settingsApply() or similar to make the changes active on the device.
*/
extern bool DLLExport icsneo_setFDBaudrate(const neodevice_t* device, uint16_t netid, int64_t newBaudrate);
@ -501,21 +501,21 @@ extern bool DLLExport icsneo_setFDBaudrate(const neodevice_t* device, uint16_t n
* \param[in] device A pointer to the neodevice_t structure specifying the device to transmit on.
* \param[in] message A pointer to the neomessage_t structure defining the message.
* \returns True if the message was verified transmittable and enqueued for transmit.
*
*
* To transmit a message, you must set the `data`, `length`, and `netid` attributes of the neomessage_t.
*
*
* The `data` attribute must be set to a pointer to a buffer of at least `length` which holds the payload bytes.
* This buffer only needs to be valid for the duration of this call, and can safely be deallocated or reused after the return.
*
*
* You may also have to set network dependent variables.
* For CAN, you must set the `arbid` attribute defined in neomessage_can_t.
*
*
* Other attributes of the neomessage_t such as `timestamp`, `type` and `reserved` which are not used should be set to 0. Unused status bits should also be set to 0.
*
*
* Any types defined `neomessage_*_t` are designed to be binary compatible with neomessage_t.
*
*
* For instance, for CAN, it is recommended to use neomessage_can_t as it exposes the `arbid` field.
*
*
* ``` C
* neomessage_can_t mySendMessage = {}; // Zero all before use
* uint8_t myData[3] = { 0xAA, 0xBB, 0xCC }; // Either heap or stack allocated is okay
@ -527,7 +527,7 @@ extern bool DLLExport icsneo_setFDBaudrate(const neodevice_t* device, uint16_t n
* mySendMessage.status.extendedFrame = true; // Extended (29-bit) arbitration IDs
* mySendMessage.status.canfdBRS = true; // CAN FD Baudrate Switch
* bool result = icsneo_transmit(device, (neomessage_t*)&mySendMessage);
*
*
* myData[1] = 0x55; // The message and buffer can be safely reused for the next message
* result = icsneo_transmit(device, (neomessage_t*)&mySendMessage);
* ```
@ -540,11 +540,11 @@ extern bool DLLExport icsneo_transmit(const neodevice_t* device, const neomessag
* \param[in] messages A pointer to the neomessage_t structures defining the messages.
* \param[in] count The number of messages to transmit.
* \returns True if the messages were verified transmittable and enqueued for transmit.
*
*
* See icsneo_transmit() for information regarding transmitting messages.
*
*
* On a per-network basis, messages will be transmitted in the order that they were enqueued.
*
*
* In this case, messages will be enqueued in order of increasing index.
*/
extern bool DLLExport icsneo_transmitMessages(const neodevice_t* device, const neomessage_t* messages, size_t count);
@ -553,7 +553,7 @@ extern bool DLLExport icsneo_transmitMessages(const neodevice_t* device, const n
* \brief Set the behavior of whether writing is a blocking action or not.
* \param[in] device A pointer to the neodevice_t structure specifying the device to transmit on.
* \param[in] blocks Whether or not writing is a blocking action.
*
*
* By default, writing is a blocking action.
*/
extern void DLLExport icsneo_setWriteBlocks(const neodevice_t* device, bool blocks);
@ -566,16 +566,16 @@ extern void DLLExport icsneo_setWriteBlocks(const neodevice_t* device, bool bloc
* holds the maximum number of characters to be written (so str must be of size maxLength + 1 to account for the NULL terminator),
* and after the call holds the number of characters written.
* \returns True if str was written to
*
*
* In the case of a neoVI FIRE 2 with serial number CY2285, this function will write a string "neoVI FIRE 2 CY2285" with a NULL terminator into str.
*
*
* The constant ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION is defined for the client application to create static buffers of the correct length.
*
*
* See also icsneo_getProductName().
*
*
* A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid.
*
*
* If the size provided is not large enough, the output will be truncated.
* An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned.
@ -593,7 +593,7 @@ extern neoversion_t DLLExport icsneo_getVersion(void);
* \param[in] callback A function pointer with void return type and a single neoevent_t parameter.
* \param[in] filter Unused for now. Exists as a placeholder here for future backwards-compatibility.
* \returns The id of the callback added. Does not error.
*
*
* Do not attempt to add or remove callbacks inside of a callback, as the stored callbacks are locked during calls.
*/
extern int DLLExport icsneo_addEventCallback(void (*callback)(neoevent_t), void*);
@ -611,16 +611,16 @@ extern bool DLLExport icsneo_removeEventCallback(int id);
* \param[inout] size A pointer to a size_t which, prior to the call,
* holds the maximum number of events to be written, and after the call holds the number of events written.
* \returns True if the events were read out successfully (even if there were no events to report).
*
*
* Events contain INFO and WARNINGS, and may potentially contain one TooManyEvents WARNING at the end. No ERRORS are found in Events, see icsneo_getLastError() instead.
*
*
* Events can be caused by API usage, such as providing too small of a buffer or disconnecting from a device.
*
*
* Events can also occur asynchronously to the client application threads, in the case of a device communication event or similar.
*
*
* Events are read out of the API managed buffer in order of oldest to newest.
* As they are read out, they are removed from the API managed buffer.
*
*
* If size is too small to contain all events, as many events as will fit will be read out.
* Subsequent calls to icsneo_getEvents() can retrieve any events which were not read out.
*/
@ -633,7 +633,7 @@ extern bool DLLExport icsneo_getEvents(neoevent_t* events, size_t* size);
* \param[inout] size A pointer to a size_t which, prior to the call,
* holds the maximum number of events to be written, and after the call holds the number of events written.
* \returns True if the events were read out successfully (even if there were no events to report).
*
*
* See icsneo_getEvents() for more information about the event system.
*/
extern bool DLLExport icsneo_getDeviceEvents(const neodevice_t* device, neoevent_t* events, size_t* size);
@ -642,15 +642,15 @@ extern bool DLLExport icsneo_getDeviceEvents(const neodevice_t* device, neoevent
* \brief Read out the last error which occurred in API operation on this thread.
* \param[out] error A pointer to a buffer which a neoevent_t structure will be written to.
* \returns True if an error was read out.
*
*
* All errors are stored on a per-thread basis, meaning that calling icsneo_getLastError() will return the last error that occured on the calling thread.
* Any errors can only be retrieved through this function, and NOT icsneo_getEvents() or similar! Only INFO and WARNING level events are accessible through those.
* Only the last error is stored, so the intention is for this function to be called immediately following another failed API call.
*
*
* The API error system is thread-safe. Only an API error which occurred on the current thread will be returned.
*
*
* See icsneo_getEvents() for more information about the event system.
*
*
* This operation removes the returned error from the buffer, so subsequent calls to error functions will not include the error.
*/
extern bool DLLExport icsneo_getLastError(neoevent_t* error);
@ -670,9 +670,9 @@ extern void DLLExport icsneo_discardDeviceEvents(const neodevice_t* device);
/**
* \brief Set the number of events which will be held in the API managed buffer before icsneo::APIEvent::TooManyEvents
* \param[in] newLimit The new limit. Must be >10. 1 event slot is always reserved for a potential icsneo::APIEvent::TooManyEvents, so (newLimit - 1) other events can be stored.
*
*
* If the event limit is reached, an icsneo::APIEvent::TooManyEvents will be flagged.
*
*
* If the `newLimit` is smaller than the current event count,
* events will be removed in order of decreasing age.
* This will also flag an icsneo::APIEvent::TooManyEvents.
@ -693,11 +693,11 @@ extern size_t DLLExport icsneo_getEventLimit(void);
* holds the maximum number of devicetype_t structures to be written,
* and after the call holds the number of devicetype_t structures written.
* \returns True if devices was written to
*
*
* See icsneo_getProductNameForType() to get textual descriptions of each device.
*
*
* A query for length (`devices == NULL`) will return false.
*
*
* If the count provided is not large enough, the output will be truncated.
* An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned.

2
platform/posix/ftdi.cpp
View File

@ -173,7 +173,7 @@ bool FTDI::FTDIContext::closeDevice() {
return true;
int ret = ftdi_usb_close(context);
if(ret != 0)
if(ret != 0)
return false;
deviceOpen = false;

2
platform/posix/linux/stm32linux.cpp
View File

@ -92,7 +92,7 @@ std::vector<neodevice_t> STM32::FindByProduct(int product) {
/* This directory will have directories (links) for all devices using the cdc_acm driver (as STM32 devices do)
* There will also be other files and directories providing information about the driver in here. We want to ignore them.
* Devices will be named like "7-2:1.0" where 7 is the enumeration for the USB controller, 2 is the device enumeration on
* that specific controller (will change if the device is unplugged and replugged), 1 is the device itself and 0 is
* that specific controller (will change if the device is unplugged and replugged), 1 is the device itself and 0 is
* enumeration for different services provided by the device. We're looking for the service that provides TTY.
* For now we find the directories with a digit for the first character, these are likely to be our USB devices.
*/

14
platform/windows/internal/pcapdll.cpp
View File

@ -9,7 +9,7 @@ const PCAPDLL& PCAPDLL::getInstance()
}
PCAPDLL::~PCAPDLL()
{
{
closeDLL();
}
@ -20,12 +20,12 @@ void PCAPDLL::closeDLL()
dll = nullptr;
}
bool PCAPDLL::ok() const
{
return dll != nullptr;
bool PCAPDLL::ok() const
{
return dll != nullptr;
}
PCAPDLL::PCAPDLL()
PCAPDLL::PCAPDLL()
{
#ifdef NPCAP
BOOL(WINAPI * SetDllDirectory)(LPCTSTR);
@ -64,10 +64,10 @@ PCAPDLL::PCAPDLL()
if(findalldevs_ex == NULL || open == NULL ||
freealldevs == NULL || close == NULL ||
stats == NULL || next_ex == NULL ||
sendpacket == NULL ||
sendpacket == NULL ||
sendqueue_alloc == NULL ||
sendqueue_queue == NULL || sendqueue_destroy == NULL ||
sendqueue_transmit == NULL ||
sendqueue_transmit == NULL ||
datalink == NULL ||
createsrcstr == NULL || setbuff == NULL) {
closeDLL();

34
test/eventmanagertest.cpp
View File

@ -78,7 +78,7 @@ TEST_F(EventManagerTest, MultithreadedEventCallbacksTest) {
*/
TEST_F(EventManagerTest, SingleThreadEventCallbacksTest) {
int callCounter = 0;
// increments counter when baudrate events show up
int id1 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter](std::shared_ptr<APIEvent>){
callCounter++;
@ -125,7 +125,7 @@ TEST_F(EventManagerTest, SingleThreadEventCallbacksTest) {
EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOpen, APIEvent::Severity::EventInfo));
EXPECT_EQ(callCounter, 6);
EXPECT_EQ(EventManager::GetInstance().removeEventCallback(id2), false);
EXPECT_EQ(EventManager::GetInstance().removeEventCallback(id1), true);
@ -229,7 +229,7 @@ TEST_F(EventManagerTest, MultithreadedTest) {
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::BufferInsufficient);
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::OutputTruncated);
});
@ -252,7 +252,7 @@ TEST_F(EventManagerTest, MultithreadedTest) {
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::DeviceCurrentlyOffline);
EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOnline, APIEvent::Severity::Error));
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::DeviceCurrentlyOnline);
EventManager::GetInstance().add(APIEvent(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error));
@ -277,7 +277,7 @@ TEST_F(EventManagerTest, MultithreadedTest) {
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SettingsChecksumError);
EventManager::GetInstance().add(APIEvent(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error));
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SWCANSettingsNotAvailable);
});
@ -294,7 +294,7 @@ TEST_F(EventManagerTest, MultithreadedTest) {
// Should be 500 {OutputTruncated, Warning}, 500 {OutputTruncated, Info}, 1000 {CANFDNotSupported, Warning}, 500 {CANFDSettingsNotAvailable, Info}, 500 {FailedToWrite, Info}
EXPECT_EQ(EventCount(), 3000);
auto events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
EXPECT_EQ(EventCount(), 2500);
EXPECT_EQ(events.size(), 500);
@ -327,7 +327,7 @@ TEST_F(EventManagerTest, CountTest) {
// Adds actual event
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
// Manually tries to add some TooManyEvents, these should not be added.
EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventWarning));
EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventInfo));
@ -349,7 +349,7 @@ TEST_F(EventManagerTest, CountTest) {
// default limit is 10000
for(int i = 0; i < 11000; i++)
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
EXPECT_EQ(EventCount(), 10000);
}
@ -366,10 +366,10 @@ TEST_F(EventManagerTest, GetDefaultTest) {
}
auto events = EventManager::GetInstance().get();
EXPECT_EQ(events.size(), 10);
EXPECT_EQ(EventCount(), 0);
for(int i = 0; i < 5; i++) {
EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::UnexpectedNetworkType);
EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventWarning);
@ -480,7 +480,7 @@ TEST_F(EventManagerTest, GetFilterTest) {
EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
}
// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SWCANSettingsNotAvailable));
EXPECT_EQ(events.size(), 0);
EXPECT_EQ(EventCount(), 5);
@ -556,7 +556,7 @@ TEST_F(EventManagerTest, GetSizeFilterTest) {
EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
}
// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(-1, EventFilter(APIEvent::Type::SWCANSettingsNotAvailable));
EXPECT_EQ(events.size(), 0);
EXPECT_EQ(EventCount(), 5);
@ -606,7 +606,7 @@ TEST_F(EventManagerTest, GetLastErrorMultipleTest) {
* Checks that only the latest 49 are kept, and a TooManyEvents warning exists at the end.
*/
TEST_F(EventManagerTest, TestAddWarningsOverflow) {
// space for 49 normal events, 1 reserved for TooManyEvents
SetEventLimit(50);
@ -640,7 +640,7 @@ TEST_F(EventManagerTest, TestAddWarningsOverflow) {
* Checks that only the latest 49 are kept, and a TOoManyEvents warning exists at the end.
*/
TEST_F(EventManagerTest, TestAddWarningsInfoOverflow) {
// space for 49 normal events, 1 reserved for TooManyEvents
SetEventLimit(50);
@ -665,7 +665,7 @@ TEST_F(EventManagerTest, TestAddWarningsInfoOverflow) {
for(int i = 2; i < 49; i++)
EXPECT_EQ(events.at(i).getType(), APIEvent::Type::ParameterOutOfRange);
EXPECT_EQ(events.at(49).getType(), APIEvent::Type::TooManyEvents);
}
@ -723,14 +723,14 @@ TEST_F(EventManagerTest, SetEventLimitTest) {
// Test truncating existing list when new limit set
for(int i = 0; i < 9001; i++)
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
EXPECT_EQ(EventCount(), 9001);
// Sets new limit to be exactly full.
SetEventLimit(9002);
EXPECT_EQ(GetEventLimit(), 9002);
EXPECT_EQ(EventCount(), 9001);
// 1 overflowed.
SetEventLimit(9001);
EXPECT_EQ(GetEventLimit(), 9001);