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" 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 # 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 # PLASMA = 0x0801, ION = 0x0901
ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \ ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
ATTRS{idVendor}=="093c", ATTRS{idProduct}=="0801", \ 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` - `libusb-1.0-0-dev`
- `libpcap0.8-dev` - `libpcap0.8-dev`
- `build-essential` is recommended - `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 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; //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 //using the icsneoGetDeviceParameters() and icsneoSetDeviceParameters() functions
char *FireParameters[] = char *FireParameters[] =
{ {
"can1", "can2", "can3", "can4", "swcan", "lsftcan", "lin1", "lin2", "can1", "can2", "can3", "can4", "swcan", "lsftcan", "lin1", "lin2",
"lin3", "lin4", "cgi_baud", "cgi_tx_ifs_bit_times", "lin3", "lin4", "cgi_baud", "cgi_tx_ifs_bit_times",
"cgi_rx_ifs_bit_times", "cgi_chksum_enable", "network_enables", "cgi_rx_ifs_bit_times", "cgi_chksum_enable", "network_enables",
"network_enabled_on_boot", "pwm_man_timeout", "pwr_man_enable", "network_enabled_on_boot", "pwm_man_timeout", "pwr_man_enable",
"misc_io_initial_ddr", "misc_io_initial_latch", "misc_io_analog_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", "misc_io_report_period", "misc_io_on_report_events", "ain_sample_period",
"ain_threshold", "iso15765_separation_time_offset", "iso9141_kwp_settings", "ain_threshold", "iso15765_separation_time_offset", "iso9141_kwp_settings",
"perf_en", "iso_parity", "iso_msg_termination", "network_enables_2" "perf_en", "iso_parity", "iso_msg_termination", "network_enables_2"
}; };
@ -99,30 +99,30 @@ char *FireParameters[] =
char *VCAN3Parameters[] = char *VCAN3Parameters[] =
{ {
"can1", "can2", "network_enables", "network_enabled_on_boot", "iso15765_separation_time_offset", "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" "misc_io_on_report_events"
}; };
char *CANParameters[] = char *CANParameters[] =
{ {
"Mode", "SetBaudrate", "Baudrate", "NetworkType", "TqSeg1", "Mode", "SetBaudrate", "Baudrate", "NetworkType", "TqSeg1",
"TqSeg2", "TqProp", "TqSync", "BRP", "auto_baud" "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" "TqProp", "TqSync", "BRP", "high_speed_auto_switch", "auto_baud"
}; };
char *LINParameters[] = char *LINParameters[] =
{ {
"Baudrate", "spbrg", "brgh", "MasterResistor", "Mode" "Baudrate", "spbrg", "brgh", "MasterResistor", "Mode"
}; };
char *ISOKWPParms[] = 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" "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 || !icsneoTxMessages || !icsneoGetMessages || !icsneoWaitForRxMessagesWithTimeOut ||
!icsneoGetTimeStampForMsg || !icsneoEnableNetworkRXQueue || !icsneoGetISO15765Status || !icsneoTxMessagesEx || !icsneoGetTimeStampForMsg || !icsneoEnableNetworkRXQueue || !icsneoGetISO15765Status || !icsneoTxMessagesEx ||
!icsneoSetISO15765RxParameters || !icsneoGetConfiguration || !icsneoSendConfiguration || !icsneoSetISO15765RxParameters || !icsneoGetConfiguration || !icsneoSendConfiguration ||
!icsneoGetFireSettings || !icsneoSetFireSettings || !icsneoGetVCAN3Settings || !icsneoGetFireSettings || !icsneoSetFireSettings || !icsneoGetVCAN3Settings ||
!icsneoSetVCAN3Settings || !icsneoGetVCANRFSettings || !icsneoSetVCANRFSettings || !icsneoGetFire2Settings || !icsneoSetVCAN3Settings || !icsneoGetVCANRFSettings || !icsneoSetVCANRFSettings || !icsneoGetFire2Settings ||
!icsneoGetVCAN412Settings || !icsneoSetVCAN412Settings || !icsneoGetVCAN412Settings || !icsneoSetVCAN412Settings ||
!icsneoSetFire2Settings || !icsneoGetRADGalaxySettings || !icsneoSetRADGalaxySettings || !icsneoSetFire2Settings || !icsneoGetRADGalaxySettings || !icsneoSetRADGalaxySettings ||
!icsneoSetBitRate || !icsneoGetDeviceParameters || !icsneoSerialNumberToString || !icsneoSetBitRate || !icsneoGetDeviceParameters || !icsneoSerialNumberToString ||
!icsneoSetDeviceParameters || !icsneoGetLastAPIError || !icsneoGetErrorMessages || !icsneoSetDeviceParameters || !icsneoGetLastAPIError || !icsneoGetErrorMessages ||
!icsneoGetErrorInfo || !icsneoScriptLoad || !icsneoScriptStart || !icsneoScriptStop || !icsneoGetErrorInfo || !icsneoScriptLoad || !icsneoScriptStart || !icsneoScriptStop ||

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

@ -11,23 +11,23 @@ void UnloadDLLAPI(HINSTANCE &hAPIDLL);
//Basic Functions //Basic Functions
typedef int (__stdcall *FINDNEODEVICES)(unsigned long DeviceTypes, NeoDevice *pNeoDevice, int *pNumDevices); 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 *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 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); int bConfigRead, unsigned char *bNetworkID, int * hObject);
typedef int (__stdcall *SERIALNUMBERTOSTRING) (unsigned long serial, char *data,unsigned long data_size); typedef int (__stdcall *SERIALNUMBERTOSTRING) (unsigned long serial, char *data,unsigned long data_size);
//Message Functions //Message Functions
typedef int (__stdcall *GETMESSAGES)(void * hObject, icsSpyMessage *pMsg, int * pNumberOfMessages, int * pNumberOfErrors); 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 *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 *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 *WAITFORRXMSGS)(void * hObject, unsigned int iTimeOut);
typedef int (__stdcall *ENABLERXQUEUE)(void * hObject, int iEnable); typedef int (__stdcall *ENABLERXQUEUE)(void * hObject, int iEnable);
typedef int (__stdcall *GETTSFORMSG)(void * hObject, icsSpyMessage *pMsg, double *pTimeStamp); 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); int lClearRxStatus, int *lTxStatus, int *lRxStatus);
typedef void (__stdcall *SETISO15765RXPARMS)(void * hObject, int lNetwork, int lEnable, typedef void (__stdcall *SETISO15765RXPARMS)(void * hObject, int lNetwork, int lEnable,
spyFilterLong *pFF_CFMsgFilter, icsSpyMessage *pTxMsg, spyFilterLong *pFF_CFMsgFilter, icsSpyMessage *pTxMsg,
int lCFTimeOutMs, int lFlowCBlockSize, int lCFTimeOutMs, int lFlowCBlockSize,
int lUsesExtendedAddressing, int lUseHardwareIfPresent); int lUsesExtendedAddressing, int lUseHardwareIfPresent);
typedef int (__stdcall *DOWNLOADISO15765_2_TXSCRIPT)(void * hObject, unsigned int NetworkID); 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 //Device Functions
typedef int (__stdcall *GETCONFIG)(void * hObject, unsigned char * pData, int * lNumBytes); 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 *GETFIRESETTINGS)(void * hObject, SFireSettings *pSettings, int iNumBytes);
typedef int (__stdcall *SETFIRESETTINGS)(void * hObject, SFireSettings *pSettings, int iNumBytes, int bSaveToEEPROM); 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 //Error Functions
typedef int (__stdcall *GETLASTAPIERROR)(void * hObject, unsigned long *pErrorNumber); typedef int (__stdcall *GETLASTAPIERROR)(void * hObject, unsigned long *pErrorNumber);
typedef int (__stdcall *GETERRMSGS)(void * hObject, int * pErrorMsgs, int * pNumberOfErrors); 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, TCHAR *szErrorDescriptionLong, int * lMaxLengthShort,
int * lMaxLengthLong,int * lErrorSeverity,int * lRestartNeeded); int * lMaxLengthLong,int * lErrorSeverity,int * lRestartNeeded);
@ -84,8 +84,8 @@ typedef int (__stdcall *STARTSOCKSERVER)(void * hObject, int iPort);
typedef int (__stdcall *STOPSOCKSERVER)(void * hObject); typedef int (__stdcall *STOPSOCKSERVER)(void * hObject);
//CoreMini Script functions //CoreMini Script functions
typedef int (__stdcall *SCRIPTSTART)(void * hObject, int iLocation); typedef int (__stdcall *SCRIPTSTART)(void * hObject, int iLocation);
typedef int (__stdcall *SCRIPTSTOP)(void * hObject); 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 *SCRIPTLOAD)(void * hObject, const unsigned char * bin, unsigned long len_bytes, int iLocation);
typedef int (__stdcall *SCRIPTCLEAR)(void * hObject, int iLocation); typedef int (__stdcall *SCRIPTCLEAR)(void * hObject, int iLocation);
typedef int (__stdcall *SCRIPTSTARTFBLOCK)(void * hObject,unsigned int fb_index); 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) //Deprecated (but still suppored in the DLL)
//////typedef int (__stdcall *OPENPORTEX)(int lPortSerialNumber, int lPortType, int lDriverType, //////typedef int (__stdcall *OPENPORTEX)(int lPortSerialNumber, int lPortType, int lDriverType,
////// int lIPAddressMSB, int lIPAddressLSBOrBaudRate,int bConfigRead, ////// int lIPAddressMSB, int lIPAddressLSBOrBaudRate,int bConfigRead,
////// unsigned char * bNetworkID, int * hObject); ////// 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); ////// unsigned char *bNetworkID, unsigned char *bSCPIDs, int * hObject);
//////typedef int (__stdcall *ENABLENETWORKCOM)(void * hObject, int Enable); //////typedef int (__stdcall *ENABLENETWORKCOM)(void * hObject, int Enable);
//////typedef int (__stdcall *FINDCOMDEVICES)(int lDriverType, int lGetSerialNumbers, int lStopAtFirst, int lUSBCommOnly, //////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) { if(shortFormat) {
// Some devices don't use the checksum, so might as well not calculate it if that's the case // 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 // 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); data.insert(data.begin(), 0xAA);
if(align16bit && data.size() % 2 == 1) // Some devices always expect 16-bit aligned data 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 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 // 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 // refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error); report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
} }
@ -237,7 +237,7 @@ bool IDeviceSettings::apply(bool temporary) {
}, Main51MessageFilter(Command::SetSettings), std::chrono::milliseconds(1000)); }, Main51MessageFilter(Command::SetSettings), std::chrono::milliseconds(1000));
if(!msg || msg->data[0] != 1) { if(!msg || msg->data[0] != 1) {
// Attempt to get the settings from the device so we're up to date if possible // 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 // refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error); report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
} }
@ -256,7 +256,7 @@ bool IDeviceSettings::apply(bool temporary) {
if(!ret) { if(!ret) {
report(APIEvent::Type::FailedToWrite, APIEvent::Severity::Error); report(APIEvent::Type::FailedToWrite, APIEvent::Severity::Error);
} }
return ret; return ret;
} }
bool IDeviceSettings::applyDefaults(bool temporary) { bool IDeviceSettings::applyDefaults(bool temporary) {
@ -275,7 +275,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
}, Main51MessageFilter(Command::SetDefaultSettings), std::chrono::milliseconds(1000)); }, Main51MessageFilter(Command::SetDefaultSettings), std::chrono::milliseconds(1000));
if(!msg || msg->data[0] != 1) { if(!msg || msg->data[0] != 1) {
// Attempt to get the settings from the device so we're up to date if possible // 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 // refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error); report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
} }
@ -305,7 +305,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
}, Main51MessageFilter(Command::SetSettings), std::chrono::milliseconds(1000)); }, Main51MessageFilter(Command::SetSettings), std::chrono::milliseconds(1000));
if(!msg || msg->data[0] != 1) { if(!msg || msg->data[0] != 1) {
// Attempt to get the settings from the device so we're up to date if possible // 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 // refresh succeeded but previously there was an error
report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error); report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
} }
@ -324,7 +324,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
if(!ret) { if(!ret) {
report(APIEvent::Type::FailedToWrite, APIEvent::Severity::Error); report(APIEvent::Type::FailedToWrite, APIEvent::Severity::Error);
} }
return ret; return ret;
} }
int64_t IDeviceSettings::getBaudrateFor(Network net) const { 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++) { for(size_t i = 0; i < msgCount; i++) {
neomessage_t* msg = &msgs[i]; neomessage_t* msg = &msgs[i];
switch(msg->type) { switch(msg->type) {
case ICSNEO_NETWORK_TYPE_CAN: // CAN case ICSNEO_NETWORK_TYPE_CAN: // CAN
{ {
neomessage_can_t* canMsg = (neomessage_can_t*) msg; neomessage_can_t* canMsg = (neomessage_can_t*) msg;
printf("\t0x%03x [%zu] ", canMsg->arbid, canMsg->length); 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 * \returns the entered character
* *
* This function repeatedly prompts the user for input until a matching input is entered * 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 input = getCharInput(std::vector<char> {'F', 'u', 'b', 'a', 'r'});
*/ */
char getCharInput(std::vector<char> allowed) { char getCharInput(std::vector<char> allowed) {
@ -537,7 +537,7 @@ int main() {
case '1': case '1':
{ {
// Shameless copy-paste from get messages above, demonstrating a callback // 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()) { switch(msg->network.getType()) {
case icsneo::Network::Type::CAN: case icsneo::Network::Type::CAN:
{ {

10
examples/csharp/csharp.i
View File

@ -7,7 +7,7 @@
#define DLLExport #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(imtype, out="System.IntPtr") uint8_t const *data "byte[]"
%typemap(cstype) uint8_t const *data "byte[]" %typemap(cstype) uint8_t const *data "byte[]"
@ -23,16 +23,16 @@
%typemap(csvarout, excode=SWIGEXCODE2) uint8_t const *data %{ %typemap(csvarout, excode=SWIGEXCODE2) uint8_t const *data %{
get { get {
byte[] ret = new byte[this.length]; byte[] ret = new byte[this.length];
System.IntPtr data = $imcall; System.IntPtr data = $imcall;
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length)$excode; System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length)$excode;
return ret; return ret;
} }
%} %}
%typemap(ctype) char *str "char *" %typemap(ctype) char *str "char *"
%typemap(imtype) char *str "System.Text.StringBuilder" %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" #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( public static extern void SWIGRegisterExceptionCallbacks_icsneocsharp(
ExceptionDelegate applicationDelegate, ExceptionDelegate applicationDelegate,
ExceptionDelegate arithmeticDelegate, ExceptionDelegate arithmeticDelegate,
ExceptionDelegate divideByZeroDelegate, ExceptionDelegate divideByZeroDelegate,
ExceptionDelegate indexOutOfRangeDelegate, ExceptionDelegate indexOutOfRangeDelegate,
ExceptionDelegate invalidCastDelegate, ExceptionDelegate invalidCastDelegate,
ExceptionDelegate invalidOperationDelegate, ExceptionDelegate invalidOperationDelegate,
ExceptionDelegate ioDelegate, ExceptionDelegate ioDelegate,
ExceptionDelegate nullReferenceDelegate, ExceptionDelegate nullReferenceDelegate,
ExceptionDelegate outOfMemoryDelegate, ExceptionDelegate outOfMemoryDelegate,
ExceptionDelegate overflowDelegate, ExceptionDelegate overflowDelegate,
ExceptionDelegate systemExceptionDelegate); ExceptionDelegate systemExceptionDelegate);
[global::System.Runtime.InteropServices.DllImport("icsneocsharp.dll", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_icsneocsharp")] [global::System.Runtime.InteropServices.DllImport("icsneocsharp.dll", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_icsneocsharp")]
@ -136,7 +136,7 @@ class icsneocsharpPINVOKE {
if (pendingException != null) if (pendingException != null)
pending = true; pending = true;
return pending; return pending;
} }
} }
public static void Set(global::System.Exception e) { 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 { public SWIGTYPE_p_void device {
set { set {
icsneocsharpPINVOKE.neodevice_t_device_set(swigCPtr, SWIGTYPE_p_void.getCPtr(value)); icsneocsharpPINVOKE.neodevice_t_device_set(swigCPtr, SWIGTYPE_p_void.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neodevice_t_device_get(swigCPtr); 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); SWIGTYPE_p_void ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
return ret; return ret;
} }
} }
public int handle { public int handle {
set { set {
icsneocsharpPINVOKE.neodevice_t_handle_set(swigCPtr, value); icsneocsharpPINVOKE.neodevice_t_handle_set(swigCPtr, value);
} }
get { get {
int ret = icsneocsharpPINVOKE.neodevice_t_handle_get(swigCPtr); int ret = icsneocsharpPINVOKE.neodevice_t_handle_get(swigCPtr);
return ret; return ret;
} }
} }
public uint type { public uint type {
set { set {
icsneocsharpPINVOKE.neodevice_t_type_set(swigCPtr, value); icsneocsharpPINVOKE.neodevice_t_type_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neodevice_t_type_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neodevice_t_type_get(swigCPtr);
return ret; return ret;
} }
} }
public string serial { public string serial {
set { set {
icsneocsharpPINVOKE.neodevice_t_serial_set(swigCPtr, value); icsneocsharpPINVOKE.neodevice_t_serial_set(swigCPtr, value);
} }
get { get {
string ret = icsneocsharpPINVOKE.neodevice_t_serial_get(swigCPtr); string ret = icsneocsharpPINVOKE.neodevice_t_serial_get(swigCPtr);
return ret; return ret;
} }
} }
public neodevice_t() : this(icsneocsharpPINVOKE.new_neodevice_t(), true) { 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 { public string description {
set { set {
icsneocsharpPINVOKE.neoevent_t_description_set(swigCPtr, value); icsneocsharpPINVOKE.neoevent_t_description_set(swigCPtr, value);
} }
get { get {
string ret = icsneocsharpPINVOKE.neoevent_t_description_get(swigCPtr); string ret = icsneocsharpPINVOKE.neoevent_t_description_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_time_t timestamp { public SWIGTYPE_p_time_t timestamp {
set { set {
icsneocsharpPINVOKE.neoevent_t_timestamp_set(swigCPtr, SWIGTYPE_p_time_t.getCPtr(value)); icsneocsharpPINVOKE.neoevent_t_timestamp_set(swigCPtr, SWIGTYPE_p_time_t.getCPtr(value));
if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve(); if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
} }
get { get {
SWIGTYPE_p_time_t ret = new SWIGTYPE_p_time_t(icsneocsharpPINVOKE.neoevent_t_timestamp_get(swigCPtr), true); 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(); if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
return ret; return ret;
} }
} }
public uint eventNumber { public uint eventNumber {
set { set {
icsneocsharpPINVOKE.neoevent_t_eventNumber_set(swigCPtr, value); icsneocsharpPINVOKE.neoevent_t_eventNumber_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neoevent_t_eventNumber_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neoevent_t_eventNumber_get(swigCPtr);
return ret; return ret;
} }
} }
public byte severity { public byte severity {
set { set {
icsneocsharpPINVOKE.neoevent_t_severity_set(swigCPtr, value); icsneocsharpPINVOKE.neoevent_t_severity_set(swigCPtr, value);
} }
get { get {
byte ret = icsneocsharpPINVOKE.neoevent_t_severity_get(swigCPtr); byte ret = icsneocsharpPINVOKE.neoevent_t_severity_get(swigCPtr);
return ret; return ret;
} }
} }
public string serial { public string serial {
set { set {
icsneocsharpPINVOKE.neoevent_t_serial_set(swigCPtr, value); icsneocsharpPINVOKE.neoevent_t_serial_set(swigCPtr, value);
} }
get { get {
string ret = icsneocsharpPINVOKE.neoevent_t_serial_get(swigCPtr); string ret = icsneocsharpPINVOKE.neoevent_t_serial_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_unsigned_char reserved { public SWIGTYPE_p_unsigned_char reserved {
set { set {
icsneocsharpPINVOKE.neoevent_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value)); icsneocsharpPINVOKE.neoevent_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neoevent_t_reserved_get(swigCPtr); 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); SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret; return ret;
} }
} }
public neoevent_t() : this(icsneocsharpPINVOKE.new_neoevent_t(), true) { 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 { public neomessage_statusbitfield_t status {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value)); icsneocsharpPINVOKE.neomessage_can_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_can_t_status_get(swigCPtr); 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); neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
return ret; return ret;
} }
} }
public ulong timestamp { public ulong timestamp {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_timestamp_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_can_t_timestamp_set(swigCPtr, value);
} }
get { get {
ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestamp_get(swigCPtr); ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestamp_get(swigCPtr);
return ret; return ret;
} }
} }
public ulong timestampReserved { public ulong timestampReserved {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_set(swigCPtr, value);
} }
get { get {
ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_get(swigCPtr); ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_get(swigCPtr);
return ret; return ret;
} }
} }
public byte[] data { public byte[] data {
@ -80,10 +80,10 @@ public class neomessage_can_t : global::System.IDisposable {
} }
get { get {
byte[] ret = new byte[this.length]; byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_can_t_data_get(swigCPtr); System.IntPtr data = icsneocsharpPINVOKE.neomessage_can_t_data_get(swigCPtr);
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length); 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 { public uint length {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_length_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_can_t_length_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_can_t_length_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_can_t_length_get(swigCPtr);
return ret; return ret;
} }
} }
public uint arbid { public uint arbid {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_arbid_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_can_t_arbid_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_can_t_arbid_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_can_t_arbid_get(swigCPtr);
return ret; return ret;
} }
} }
public ushort netid { public ushort netid {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_netid_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_can_t_netid_set(swigCPtr, value);
} }
get { get {
ushort ret = icsneocsharpPINVOKE.neomessage_can_t_netid_get(swigCPtr); ushort ret = icsneocsharpPINVOKE.neomessage_can_t_netid_get(swigCPtr);
return ret; return ret;
} }
} }
public byte type { public byte type {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_type_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_can_t_type_set(swigCPtr, value);
} }
get { get {
byte ret = icsneocsharpPINVOKE.neomessage_can_t_type_get(swigCPtr); byte ret = icsneocsharpPINVOKE.neomessage_can_t_type_get(swigCPtr);
return ret; return ret;
} }
} }
public byte dlcOnWire { public byte dlcOnWire {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_set(swigCPtr, value);
} }
get { get {
byte ret = icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_get(swigCPtr); byte ret = icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_unsigned_char reserved { public SWIGTYPE_p_unsigned_char reserved {
set { set {
icsneocsharpPINVOKE.neomessage_can_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value)); icsneocsharpPINVOKE.neomessage_can_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_can_t_reserved_get(swigCPtr); 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); SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret; return ret;
} }
} }
public neomessage_can_t() : this(icsneocsharpPINVOKE.new_neomessage_can_t(), true) { 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 { public neomessage_statusbitfield_t status {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value)); icsneocsharpPINVOKE.neomessage_eth_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_status_get(swigCPtr); 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); neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
return ret; return ret;
} }
} }
public ulong timestamp { public ulong timestamp {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_timestamp_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_eth_t_timestamp_set(swigCPtr, value);
} }
get { get {
ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestamp_get(swigCPtr); ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestamp_get(swigCPtr);
return ret; return ret;
} }
} }
public ulong timestampReserved { public ulong timestampReserved {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_set(swigCPtr, value);
} }
get { get {
ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_get(swigCPtr); ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_get(swigCPtr);
return ret; return ret;
} }
} }
public byte[] data { public byte[] data {
@ -80,10 +80,10 @@ public class neomessage_eth_t : global::System.IDisposable {
} }
get { get {
byte[] ret = new byte[this.length]; byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_eth_t_data_get(swigCPtr); System.IntPtr data = icsneocsharpPINVOKE.neomessage_eth_t_data_get(swigCPtr);
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length); 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 { public uint length {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_length_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_eth_t_length_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_eth_t_length_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_eth_t_length_get(swigCPtr);
return ret; return ret;
} }
} }
public byte preemptionFlags { public byte preemptionFlags {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_set(swigCPtr, value);
} }
get { get {
byte ret = icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_get(swigCPtr); byte ret = icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_unsigned_char reservedHeader { public SWIGTYPE_p_unsigned_char reservedHeader {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_reservedHeader_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value)); icsneocsharpPINVOKE.neomessage_eth_t_reservedHeader_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_reservedHeader_get(swigCPtr); 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); SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret; return ret;
} }
} }
public ushort netid { public ushort netid {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_netid_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_eth_t_netid_set(swigCPtr, value);
} }
get { get {
ushort ret = icsneocsharpPINVOKE.neomessage_eth_t_netid_get(swigCPtr); ushort ret = icsneocsharpPINVOKE.neomessage_eth_t_netid_get(swigCPtr);
return ret; return ret;
} }
} }
public byte type { public byte type {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_type_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_eth_t_type_set(swigCPtr, value);
} }
get { get {
byte ret = icsneocsharpPINVOKE.neomessage_eth_t_type_get(swigCPtr); byte ret = icsneocsharpPINVOKE.neomessage_eth_t_type_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_unsigned_char reserved { public SWIGTYPE_p_unsigned_char reserved {
set { set {
icsneocsharpPINVOKE.neomessage_eth_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value)); icsneocsharpPINVOKE.neomessage_eth_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_reserved_get(swigCPtr); 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); SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret; return ret;
} }
} }
public neomessage_eth_t() : this(icsneocsharpPINVOKE.new_neomessage_eth_t(), true) { 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 { public uint globalError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint transmitMessage { public uint transmitMessage {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_get(swigCPtr);
return ret; return ret;
} }
} }
public uint extendedFrame { public uint extendedFrame {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_get(swigCPtr);
return ret; return ret;
} }
} }
public uint remoteFrame { public uint remoteFrame {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_get(swigCPtr);
return ret; return ret;
} }
} }
public uint crcError { public uint crcError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canErrorPassive { public uint canErrorPassive {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_get(swigCPtr);
return ret; return ret;
} }
} }
public uint incompleteFrame { public uint incompleteFrame {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_get(swigCPtr);
return ret; return ret;
} }
} }
public uint lostArbitration { public uint lostArbitration {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_get(swigCPtr);
return ret; return ret;
} }
} }
public uint undefinedError { public uint undefinedError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canBusOff { public uint canBusOff {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canErrorWarning { public uint canErrorWarning {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canBusShortedPlus { public uint canBusShortedPlus {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canBusShortedGround { public uint canBusShortedGround {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_get(swigCPtr);
return ret; return ret;
} }
} }
public uint checksumError { public uint checksumError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint badMessageBitTimeError { public uint badMessageBitTimeError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint ifrData { public uint ifrData {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_get(swigCPtr);
return ret; return ret;
} }
} }
public uint hardwareCommError { public uint hardwareCommError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint expectedLengthError { public uint expectedLengthError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint incomingNoMatch { public uint incomingNoMatch {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_get(swigCPtr);
return ret; return ret;
} }
} }
public uint statusBreak { public uint statusBreak {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_get(swigCPtr);
return ret; return ret;
} }
} }
public uint avsiRecOverflow { public uint avsiRecOverflow {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_get(swigCPtr);
return ret; return ret;
} }
} }
public uint testTrigger { public uint testTrigger {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_get(swigCPtr);
return ret; return ret;
} }
} }
public uint audioComment { public uint audioComment {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_get(swigCPtr);
return ret; return ret;
} }
} }
public uint gpsData { public uint gpsData {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_get(swigCPtr);
return ret; return ret;
} }
} }
public uint analogDigitalInput { public uint analogDigitalInput {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_get(swigCPtr);
return ret; return ret;
} }
} }
public uint textComment { public uint textComment {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_get(swigCPtr);
return ret; return ret;
} }
} }
public uint networkMessageType { public uint networkMessageType {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_get(swigCPtr);
return ret; return ret;
} }
} }
public uint vsiTXUnderrun { public uint vsiTXUnderrun {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_get(swigCPtr);
return ret; return ret;
} }
} }
public uint vsiIFRCRCBit { public uint vsiIFRCRCBit {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_get(swigCPtr);
return ret; return ret;
} }
} }
public uint initMessage { public uint initMessage {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_get(swigCPtr);
return ret; return ret;
} }
} }
public uint flexraySecondStartupFrame { public uint flexraySecondStartupFrame {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_get(swigCPtr);
return ret; return ret;
} }
} }
public uint extended { public uint extended {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_get(swigCPtr);
return ret; return ret;
} }
} }
public uint hasValue { public uint hasValue {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_get(swigCPtr);
return ret; return ret;
} }
} }
public uint valueIsBoolean { public uint valueIsBoolean {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_get(swigCPtr);
return ret; return ret;
} }
} }
public uint highVoltage { public uint highVoltage {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_get(swigCPtr);
return ret; return ret;
} }
} }
public uint longMessage { public uint longMessage {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_get(swigCPtr);
return ret; return ret;
} }
} }
public uint globalChange { public uint globalChange {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_get(swigCPtr);
return ret; return ret;
} }
} }
public uint errorFrame { public uint errorFrame {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_get(swigCPtr);
return ret; return ret;
} }
} }
public uint endOfLongMessage { public uint endOfLongMessage {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linErrorRXBreakNotZero { public uint linErrorRXBreakNotZero {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linErrorRXBreakTooShort { public uint linErrorRXBreakTooShort {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linErrorRXSyncNot55 { public uint linErrorRXSyncNot55 {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linErrorRXDataGreaterEight { public uint linErrorRXDataGreaterEight {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linErrorTXRXMismatch { public uint linErrorTXRXMismatch {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linErrorMessageIDParity { public uint linErrorMessageIDParity {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linSyncFrameError { public uint linSyncFrameError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linIDFrameError { public uint linIDFrameError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linSlaveByteError { public uint linSlaveByteError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint rxTimeoutError { public uint rxTimeoutError {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_get(swigCPtr);
return ret; return ret;
} }
} }
public uint linNoSlaveData { public uint linNoSlaveData {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canfdESI { public uint canfdESI {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canfdIDE { public uint canfdIDE {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canfdRTR { public uint canfdRTR {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canfdFDF { public uint canfdFDF {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_get(swigCPtr);
return ret; return ret;
} }
} }
public uint canfdBRS { public uint canfdBRS {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_unsigned_int statusBitfield { public SWIGTYPE_p_unsigned_int statusBitfield {
set { set {
icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBitfield_set(swigCPtr, SWIGTYPE_p_unsigned_int.getCPtr(value)); icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBitfield_set(swigCPtr, SWIGTYPE_p_unsigned_int.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBitfield_get(swigCPtr); 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); SWIGTYPE_p_unsigned_int ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
return ret; return ret;
} }
} }
public neomessage_statusbitfield_t() : this(icsneocsharpPINVOKE.new_neomessage_statusbitfield_t(), true) { 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 { public neomessage_statusbitfield_t status {
set { set {
icsneocsharpPINVOKE.neomessage_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value)); icsneocsharpPINVOKE.neomessage_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_status_get(swigCPtr); 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); neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
return ret; return ret;
} }
} }
public ulong timestamp { public ulong timestamp {
set { set {
icsneocsharpPINVOKE.neomessage_t_timestamp_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_t_timestamp_set(swigCPtr, value);
} }
get { get {
ulong ret = icsneocsharpPINVOKE.neomessage_t_timestamp_get(swigCPtr); ulong ret = icsneocsharpPINVOKE.neomessage_t_timestamp_get(swigCPtr);
return ret; return ret;
} }
} }
public ulong timestampReserved { public ulong timestampReserved {
set { set {
icsneocsharpPINVOKE.neomessage_t_timestampReserved_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_t_timestampReserved_set(swigCPtr, value);
} }
get { get {
ulong ret = icsneocsharpPINVOKE.neomessage_t_timestampReserved_get(swigCPtr); ulong ret = icsneocsharpPINVOKE.neomessage_t_timestampReserved_get(swigCPtr);
return ret; return ret;
} }
} }
public byte[] data { public byte[] data {
@ -80,10 +80,10 @@ public class neomessage_t : global::System.IDisposable {
} }
get { get {
byte[] ret = new byte[this.length]; byte[] ret = new byte[this.length];
System.IntPtr data = icsneocsharpPINVOKE.neomessage_t_data_get(swigCPtr); System.IntPtr data = icsneocsharpPINVOKE.neomessage_t_data_get(swigCPtr);
System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length); 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 { public uint length {
set { set {
icsneocsharpPINVOKE.neomessage_t_length_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_t_length_set(swigCPtr, value);
} }
get { get {
uint ret = icsneocsharpPINVOKE.neomessage_t_length_get(swigCPtr); uint ret = icsneocsharpPINVOKE.neomessage_t_length_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_unsigned_char header { public SWIGTYPE_p_unsigned_char header {
set { set {
icsneocsharpPINVOKE.neomessage_t_header_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value)); icsneocsharpPINVOKE.neomessage_t_header_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_header_get(swigCPtr); 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); SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret; return ret;
} }
} }
public ushort netid { public ushort netid {
set { set {
icsneocsharpPINVOKE.neomessage_t_netid_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_t_netid_set(swigCPtr, value);
} }
get { get {
ushort ret = icsneocsharpPINVOKE.neomessage_t_netid_get(swigCPtr); ushort ret = icsneocsharpPINVOKE.neomessage_t_netid_get(swigCPtr);
return ret; return ret;
} }
} }
public byte type { public byte type {
set { set {
icsneocsharpPINVOKE.neomessage_t_type_set(swigCPtr, value); icsneocsharpPINVOKE.neomessage_t_type_set(swigCPtr, value);
} }
get { get {
byte ret = icsneocsharpPINVOKE.neomessage_t_type_get(swigCPtr); byte ret = icsneocsharpPINVOKE.neomessage_t_type_get(swigCPtr);
return ret; return ret;
} }
} }
public SWIGTYPE_p_unsigned_char reserved { public SWIGTYPE_p_unsigned_char reserved {
set { set {
icsneocsharpPINVOKE.neomessage_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value)); icsneocsharpPINVOKE.neomessage_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
} }
get { get {
global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_reserved_get(swigCPtr); 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); SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
return ret; return ret;
} }
} }
public neomessage_t() : this(icsneocsharpPINVOKE.new_neomessage_t(), true) { 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 { public ushort major {
set { set {
icsneocsharpPINVOKE.neoversion_t_major_set(swigCPtr, value); icsneocsharpPINVOKE.neoversion_t_major_set(swigCPtr, value);
} }
get { get {
ushort ret = icsneocsharpPINVOKE.neoversion_t_major_get(swigCPtr); ushort ret = icsneocsharpPINVOKE.neoversion_t_major_get(swigCPtr);
return ret; return ret;
} }
} }
public ushort minor { public ushort minor {
set { set {
icsneocsharpPINVOKE.neoversion_t_minor_set(swigCPtr, value); icsneocsharpPINVOKE.neoversion_t_minor_set(swigCPtr, value);
} }
get { get {
ushort ret = icsneocsharpPINVOKE.neoversion_t_minor_get(swigCPtr); ushort ret = icsneocsharpPINVOKE.neoversion_t_minor_get(swigCPtr);
return ret; return ret;
} }
} }
public ushort patch { public ushort patch {
set { set {
icsneocsharpPINVOKE.neoversion_t_patch_set(swigCPtr, value); icsneocsharpPINVOKE.neoversion_t_patch_set(swigCPtr, value);
} }
get { get {
ushort ret = icsneocsharpPINVOKE.neoversion_t_patch_get(swigCPtr); ushort ret = icsneocsharpPINVOKE.neoversion_t_patch_get(swigCPtr);
return ret; return ret;
} }
} }
public string metadata { public string metadata {
set { set {
icsneocsharpPINVOKE.neoversion_t_metadata_set(swigCPtr, value); icsneocsharpPINVOKE.neoversion_t_metadata_set(swigCPtr, value);
} }
get { get {
string ret = icsneocsharpPINVOKE.neoversion_t_metadata_get(swigCPtr); string ret = icsneocsharpPINVOKE.neoversion_t_metadata_get(swigCPtr);
return ret; return ret;
} }
} }
public string buildBranch { public string buildBranch {
set { set {
icsneocsharpPINVOKE.neoversion_t_buildBranch_set(swigCPtr, value); icsneocsharpPINVOKE.neoversion_t_buildBranch_set(swigCPtr, value);
} }
get { get {
string ret = icsneocsharpPINVOKE.neoversion_t_buildBranch_get(swigCPtr); string ret = icsneocsharpPINVOKE.neoversion_t_buildBranch_get(swigCPtr);
return ret; return ret;
} }
} }
public string buildTag { public string buildTag {
set { set {
icsneocsharpPINVOKE.neoversion_t_buildTag_set(swigCPtr, value); icsneocsharpPINVOKE.neoversion_t_buildTag_set(swigCPtr, value);
} }
get { get {
string ret = icsneocsharpPINVOKE.neoversion_t_buildTag_get(swigCPtr); string ret = icsneocsharpPINVOKE.neoversion_t_buildTag_get(swigCPtr);
return ret; return ret;
} }
} }
public string reserved { public string reserved {
set { set {
icsneocsharpPINVOKE.neoversion_t_reserved_set(swigCPtr, value); icsneocsharpPINVOKE.neoversion_t_reserved_set(swigCPtr, value);
} }
get { get {
string ret = icsneocsharpPINVOKE.neoversion_t_reserved_get(swigCPtr); string ret = icsneocsharpPINVOKE.neoversion_t_reserved_get(swigCPtr);
return ret; return ret;
} }
} }
public neoversion_t() : this(icsneocsharpPINVOKE.new_neoversion_t(), true) { 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; eventLimit = newLimit;
std::lock_guard<std::mutex> eventsLock(eventsMutex); std::lock_guard<std::mutex> eventsLock(eventsMutex);
if(enforceLimit()) if(enforceLimit())
add_internal_event(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventWarning)); 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); std::lock_guard<std::mutex> lk(eventLimitMutex);
return eventLimit; 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) * 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) { 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. // Removes any events of type TooManyEvents from the end before checking to avoid duplicates.
enforceLimit(); enforceLimit();

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

@ -125,8 +125,8 @@ protected:
} }
virtual device_eventhandler_t makeEventHandler() { virtual device_eventhandler_t makeEventHandler() {
return [this](APIEvent::Type type, APIEvent::Severity severity) { return [this](APIEvent::Type type, APIEvent::Severity severity) {
EventManager::GetInstance().add(type, severity, this); 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 #define NETID_INVALID 0xffff
/* Device types -- value of DeviceType of NeoDevice */ /* Device types -- value of DeviceType of NeoDevice */
/* Older devices have a value on a specific bit. Those values have not changed /* 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 * 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! * existing ones. I know it hurts, but it's just a number!
*/ */
//clang-format off //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[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, * \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. * 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. * 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 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 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. * 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. * 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(). * To invoke this behavior without finding devices again, call icsneo_freeUnconnectedDevices().
* *
* If the size provided is not large enough, the output will be truncated. * 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. * 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. * \brief Invalidate neodevice_t objects which have not been opened.
* *
* See icsneo_findAllDevices() for information regarding the neodevice_t validity contract. * See icsneo_findAllDevices() for information regarding the neodevice_t validity contract.
*/ */
extern void DLLExport icsneo_freeUnconnectedDevices(); 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), * 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. * and after the call holds the number of characters written.
* \returns True if str contains the string representation of the given serial number. * \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 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. * 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. * A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid. * 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. * 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. * If the size provided is not large enough, the output will be **NOT** be truncated.
* Nothing will be written to the output. * Nothing will be written to the output.
* Instead, an icsneo::APIEvent::BufferInsufficient will be available in icsneo_getLastError(). * 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. * \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. * \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. * \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 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. * 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); 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. * \brief Verify that a neodevice_t is valid.
* \param[in] device A pointer to the neodevice_t structure to operate on. * \param[in] device A pointer to the neodevice_t structure to operate on.
* \returns True if the neodevice_t is valid. * \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. * 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(). * 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. * See icsneo_findAllDevices() for information regarding the neodevice_t validity contract.
*/ */
extern bool DLLExport icsneo_isValidNeoDevice(const neodevice_t* device); 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 * \brief Connect to the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to open. * \param[in] device A pointer to the neodevice_t structure specifying the device to open.
* \returns True if the connection could be opened. * \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. * 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. * 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 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(). * 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); 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 * \brief Close an open connection to the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to close. * \param[in] device A pointer to the neodevice_t structure specifying the device to close.
* \returns True if the connection could be closed. * \returns True if the connection could be closed.
* *
* After this function succeeds, the neodevice_t will be invalid. * 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. * 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 * \brief Verify network connection for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the device is connected. * \returns True if the device is connected.
* *
* This function does not modify the working state of the device at all. * 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". * See icsneo_openDevice() for an explanation about the concept of being "open".
*/ */
extern bool DLLExport icsneo_isOpen(const neodevice_t* device); 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 * \brief Enable network communication for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if communication could be enabled. * \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". * 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) * 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 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, * 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. * 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 * \brief Disable network communication for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if communication could be disabled. * \returns True if communication could be disabled.
* *
* See icsneo_goOnline() for an explanation about the concept of being "online". * See icsneo_goOnline() for an explanation about the concept of being "online".
*/ */
extern bool DLLExport icsneo_goOffline(const neodevice_t* device); 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 * \brief Verify network communication for the specified hardware
* \param[in] device A pointer to the neodevice_t structure specifying the device to operate on. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if communication is enabled. * \returns True if communication is enabled.
* *
* This function does not modify the working state of the device at all. * 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". * See icsneo_goOnline() for an explanation about the concept of being "online".
*/ */
extern bool DLLExport icsneo_isOnline(const neodevice_t* device); 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 * \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. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if polling could be enabled. * \returns True if polling could be enabled.
* *
* By default, traffic the device receives will not reach the client application. * By default, traffic the device receives will not reach the client application.
* The client application must register traffic handlers, enable message polling, or both. * The client application must register traffic handlers, enable message polling, or both.
* This function addresses message polling. * This function addresses message polling.
* *
* With polling enabled, all traffic that the device receives will be stored in a buffer managed by the API. * 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 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. * The API managed buffer will only grow to a specified size, 20k messages by default.
* See icsneo_getPollingMessageLimit() and icsneo_setPollingMessageLimit() for more information. * See icsneo_getPollingMessageLimit() and icsneo_setPollingMessageLimit() for more information.
* *
* In high traffic situations, the default 20k message limit can be reached very quickly. * 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. * 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, * 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. * 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. * This function will succeed even if the device is not open.
*/ */
extern bool DLLExport icsneo_enableMessagePolling(const neodevice_t* device); 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 * \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. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if polling could be disabled. * \returns True if polling could be disabled.
* *
* See icsneo_enableMessagePolling() for more information about the message polling system. * 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. * Any messages left in the API managed buffer will be lost upon disabling polling.
*/ */
extern bool DLLExport icsneo_disableMessagePolling(const neodevice_t* device); 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 * \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. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if polling is enabled. * \returns True if polling is enabled.
* *
* This function does not modify the working state of the device at all. * This function does not modify the working state of the device at all.
* *
* See icsneo_enableMessagePolling() for an explanation about how polling works. * See icsneo_enableMessagePolling() for an explanation about how polling works.
*/ */
extern bool DLLExport icsneo_isMessagePollingEnabled(const neodevice_t* device); 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. * \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. * 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. * \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. * Messages are available using this function if icsneo_goOnline() and icsneo_enableMessagePolling() have been called.
* See those functions for more information. * See those functions for more information.
* *
* Messages are read out of the API managed buffer in order of oldest to newest. * 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. * 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. * 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. * 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 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. * 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(). * \warning Do not call icsneo_close() while another thread is waiting on icsneo_getMessages().
* Always allow the other thread to timeout first! * Always allow the other thread to timeout first!
* *
* ``` C * ``` C
* size_t messageCount; * size_t messageCount;
* bool result = icsneo_getMessages(device, NULL, &messageCount, 0); // Reading the message count * 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. * \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. * \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. * \returns Number of messages, or -1 if device is invalid.
* *
* See icsneo_enableMessagePolling() for more information about the message polling system. * See icsneo_enableMessagePolling() for more information about the message polling system.
*/ */
extern int DLLExport icsneo_getPollingMessageLimit(const neodevice_t* device); 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] device A pointer to the neodevice_t structure specifying the device to operate on.
* \param[in] newLimit The new limit to be enforced. * \param[in] newLimit The new limit to be enforced.
* \returns True if the limit was set successfully. * \returns True if the limit was set successfully.
* *
* See icsneo_enableMessagePolling() for more information about the message polling system. * 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 * 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. * 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), * 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. * and after the call holds the number of characters written.
* \returns True if str was written to * \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. * 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. * The constant ICSNEO_DEVICETYPE_LONGEST_NAME is defined for the client application to create static buffers of the correct length.
* *
* See also icsneo_describeDevice(). * See also icsneo_describeDevice().
* *
* A query for length (`str == NULL`) will return false. * A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid. * 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. * 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. * An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned. * 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), * 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. * and after the call holds the number of characters written.
* \returns True if str was written to * \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. * 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. * The constant ICSNEO_DEVICETYPE_LONGEST_NAME is defined for the client application to create static buffers of the correct length.
* *
* See also icsneo_describeDevice(). * See also icsneo_describeDevice().
* *
* A query for length (`str == NULL`) will return false. * A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid. * 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. * 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. * An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned. * 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. * \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. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the settings were applied. * \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. * 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. * 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. * 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); 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. * \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. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the settings were applied. * \returns True if the settings were applied.
* *
* See icsneo_settingsApply() for further information about applying settings. * 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. * 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); 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. * \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. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the default settings were applied. * \returns True if the default settings were applied.
* *
* See icsneo_settingsApply() for further information about applying settings. * See icsneo_settingsApply() for further information about applying settings.
* *
* This function sets the default settings such that they will survive device power cycles. * This function sets the default settings such that they will survive device power cycles.
*/ */
extern bool DLLExport icsneo_settingsApplyDefaults(const neodevice_t* device); 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. * \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. * \param[in] device A pointer to the neodevice_t structure specifying the device to operate on.
* \returns True if the default settings were applied. * \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. * 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. * 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); 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[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. * \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. * \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. * 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. * 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. * 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. * 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] 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. * \param[in] structureSize The size of the current device settings structure in bytes.
* \returns True if the settings were applied. * \returns True if the settings were applied.
* *
* This function immediately applies the provided settings. See icsneo_settingsApplyTemporary() for further information about applying settings. * 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. * 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. * 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] 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. * \param[in] structureSize The size of the current device settings structure in bytes.
* \returns True if the settings were applied. * \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 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. * 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. * 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. * 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] 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. * \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. * \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. * 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. * 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] 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) * \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. * \returns True if the baudrate could be set.
* *
* In the case of CAN, this function sets the standard CAN baudrate. * 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. * 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. * 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); 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] 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. * \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. * \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. * 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); 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] 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) * \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. * \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. * 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. * 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); 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] 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. * \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. * \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. * 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. * 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. * 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. * You may also have to set network dependent variables.
* For CAN, you must set the `arbid` attribute defined in neomessage_can_t. * 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. * 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. * 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. * For instance, for CAN, it is recommended to use neomessage_can_t as it exposes the `arbid` field.
* *
* ``` C * ``` C
* neomessage_can_t mySendMessage = {}; // Zero all before use * neomessage_can_t mySendMessage = {}; // Zero all before use
* uint8_t myData[3] = { 0xAA, 0xBB, 0xCC }; // Either heap or stack allocated is okay * 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.extendedFrame = true; // Extended (29-bit) arbitration IDs
* mySendMessage.status.canfdBRS = true; // CAN FD Baudrate Switch * mySendMessage.status.canfdBRS = true; // CAN FD Baudrate Switch
* bool result = icsneo_transmit(device, (neomessage_t*)&mySendMessage); * bool result = icsneo_transmit(device, (neomessage_t*)&mySendMessage);
* *
* myData[1] = 0x55; // The message and buffer can be safely reused for the next message * myData[1] = 0x55; // The message and buffer can be safely reused for the next message
* result = icsneo_transmit(device, (neomessage_t*)&mySendMessage); * 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] messages A pointer to the neomessage_t structures defining the messages.
* \param[in] count The number of messages to transmit. * \param[in] count The number of messages to transmit.
* \returns True if the messages were verified transmittable and enqueued for transmit. * \returns True if the messages were verified transmittable and enqueued for transmit.
* *
* See icsneo_transmit() for information regarding transmitting messages. * See icsneo_transmit() for information regarding transmitting messages.
* *
* On a per-network basis, messages will be transmitted in the order that they were enqueued. * 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. * 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); 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. * \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] 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. * \param[in] blocks Whether or not writing is a blocking action.
* *
* By default, writing is a blocking action. * By default, writing is a blocking action.
*/ */
extern void DLLExport icsneo_setWriteBlocks(const neodevice_t* device, bool blocks); 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), * 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. * and after the call holds the number of characters written.
* \returns True if str was written to * \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. * 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. * The constant ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION is defined for the client application to create static buffers of the correct length.
* *
* See also icsneo_getProductName(). * See also icsneo_getProductName().
* *
* A query for length (`str == NULL`) will return false. * A query for length (`str == NULL`) will return false.
* icsneo_getLastError() should be checked to verify that the neodevice_t provided was valid. * 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. * 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. * An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned. * 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] 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. * \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. * \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. * 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*); 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, * \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. * 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). * \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 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 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 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. * 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. * 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. * 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. * 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, * \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. * 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). * \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. * 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); 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. * \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. * \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. * \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. * 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. * 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. * 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. * 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. * 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. * 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); 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 * \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. * \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 event limit is reached, an icsneo::APIEvent::TooManyEvents will be flagged.
* *
* If the `newLimit` is smaller than the current event count, * If the `newLimit` is smaller than the current event count,
* events will be removed in order of decreasing age. * events will be removed in order of decreasing age.
* This will also flag an icsneo::APIEvent::TooManyEvents. * 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, * holds the maximum number of devicetype_t structures to be written,
* and after the call holds the number of devicetype_t structures written. * and after the call holds the number of devicetype_t structures written.
* \returns True if devices was written to * \returns True if devices was written to
* *
* See icsneo_getProductNameForType() to get textual descriptions of each device. * See icsneo_getProductNameForType() to get textual descriptions of each device.
* *
* A query for length (`devices == NULL`) will return false. * A query for length (`devices == NULL`) will return false.
* *
* If the count provided is not large enough, the output will be truncated. * 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. * An icsneo::APIEvent::OutputTruncatedError will be available in icsneo_getLastError() in this case.
* True will still be returned. * True will still be returned.

2
platform/posix/ftdi.cpp
View File

@ -173,7 +173,7 @@ bool FTDI::FTDIContext::closeDevice() {
return true; return true;
int ret = ftdi_usb_close(context); int ret = ftdi_usb_close(context);
if(ret != 0) if(ret != 0)
return false; return false;
deviceOpen = 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) /* 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. * 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 * 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. * 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. * 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() PCAPDLL::~PCAPDLL()
{ {
closeDLL(); closeDLL();
} }
@ -20,12 +20,12 @@ void PCAPDLL::closeDLL()
dll = nullptr; dll = nullptr;
} }
bool PCAPDLL::ok() const bool PCAPDLL::ok() const
{ {
return dll != nullptr; return dll != nullptr;
} }
PCAPDLL::PCAPDLL() PCAPDLL::PCAPDLL()
{ {
#ifdef NPCAP #ifdef NPCAP
BOOL(WINAPI * SetDllDirectory)(LPCTSTR); BOOL(WINAPI * SetDllDirectory)(LPCTSTR);
@ -64,10 +64,10 @@ PCAPDLL::PCAPDLL()
if(findalldevs_ex == NULL || open == NULL || if(findalldevs_ex == NULL || open == NULL ||
freealldevs == NULL || close == NULL || freealldevs == NULL || close == NULL ||
stats == NULL || next_ex == NULL || stats == NULL || next_ex == NULL ||
sendpacket == NULL || sendpacket == NULL ||
sendqueue_alloc == NULL || sendqueue_alloc == NULL ||
sendqueue_queue == NULL || sendqueue_destroy == NULL || sendqueue_queue == NULL || sendqueue_destroy == NULL ||
sendqueue_transmit == NULL || sendqueue_transmit == NULL ||
datalink == NULL || datalink == NULL ||
createsrcstr == NULL || setbuff == NULL) { createsrcstr == NULL || setbuff == NULL) {
closeDLL(); closeDLL();

34
test/eventmanagertest.cpp
View File

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