sven/libicsneo
1
0
Fork 0
mirror of https://github.com/intrepidcs/libicsneo.git synced 2026-08-05 01:18:36 +02:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' of intrepidcs.homeip.net:paulhollinsky/icsneonext

Browse Source
This commit is contained in:
Paul Hollinsky
2018-11-20 09:42:29 -05:00
parent 8ef2260fbe 9f7f2c5f55
commit 2ade9116eb
24 changed files with 358 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/icsneo/api/error.h
+5 -2
View File
@@ -26,6 +26,9 @@ class Device;
class APIError {
public:
typedef std::chrono::system_clock ErrorClock;
typedef std::chrono::time_point<ErrorClock> ErrorTimePoint;
enum ErrorType : uint32_t {
Any = 0, // Used for filtering, should not appear in data
@@ -73,7 +76,7 @@ public:
Severity getSeverity() const noexcept { return Severity(errorStruct.severity); }
std::string getDescription() const noexcept { return std::string(errorStruct.description); }
const Device* getDevice() const noexcept { return device; } // Will return nullptr if this is an API-wide error
std::chrono::time_point<std::chrono::high_resolution_clock> getTimestamp() const noexcept { return timepoint; }
ErrorTimePoint getTimestamp() const noexcept { return timepoint; }
bool isForDevice(const Device* forDevice) const noexcept { return forDevice == device; }
bool isForDevice(std::string serial) const noexcept;
@@ -91,7 +94,7 @@ public:
private:
neoerror_t errorStruct;
std::string serial;
std::chrono::time_point<std::chrono::high_resolution_clock> timepoint;
ErrorTimePoint timepoint;
const Device* device;
void init(ErrorType error);
include/icsneo/api/errormanager.h
+3 -3
View File
@@ -26,9 +26,9 @@ public:
get(ret, filter, max);
return ret;
}
void get(std::vector<APIError>& errors, ErrorFilter filter, size_t max = 0) { get(errors, max, filter); }
void get(std::vector<APIError>& errors, size_t max = 0, ErrorFilter filter = ErrorFilter());
bool getLastError(APIError& error, ErrorFilter filter = ErrorFilter());
void get(std::vector<APIError>& outErrors, ErrorFilter filter, size_t max = 0) { get(outErrors, max, filter); }
void get(std::vector<APIError>& outErrors, size_t max = 0, ErrorFilter filter = ErrorFilter());
bool getLastError(APIError& outErrors, ErrorFilter filter = ErrorFilter());
void add(APIError error) {
std::lock_guard<std::mutex> lk(mutex);
include/icsneo/communication/message/neomessage.h
+3 -3
View File
@@ -107,8 +107,8 @@ typedef struct {
uint8_t header[4];
uint16_t netid;
uint8_t type;
uint8_t reserved[9];
} neomessage_t;
uint8_t reserved[17];
} neomessage_t; // 64 bytes total
// Any time you add another neomessage_*_t type, make sure to add it to the static_asserts below!
typedef struct {
@@ -120,7 +120,7 @@ typedef struct {
uint16_t netid;
uint8_t type;
uint8_t dlcOnWire;
char reserved[8];
char reserved[16];
} neomessage_can_t;
#pragma pack(pop)
include/icsneo/communication/network.h
+17
View File
@@ -142,6 +142,8 @@ public:
return "Other";
case Type::Internal:
return "Internal";
case Type::Ethernet:
return "Ethernet";
case Type::Invalid:
default:
return "Invalid Type";
@@ -187,6 +189,21 @@ public:
case NetID::Invalid:
case NetID::Any:
return Type::Invalid;
case NetID::Ethernet:
case NetID::Ethernet_DAQ:
case NetID::OP_Ethernet1:
case NetID::OP_Ethernet2:
case NetID::OP_Ethernet3:
case NetID::OP_Ethernet4:
case NetID::OP_Ethernet5:
case NetID::OP_Ethernet6:
case NetID::OP_Ethernet7:
case NetID::OP_Ethernet8:
case NetID::OP_Ethernet9:
case NetID::OP_Ethernet10:
case NetID::OP_Ethernet11:
case NetID::OP_Ethernet12:
return Type::Ethernet;
default:
return Type::Other;
}
include/icsneo/device/device.h
+6 -6
View File
@@ -103,29 +103,29 @@ protected:
template<typename Transport>
std::unique_ptr<ICommunication> makeTransport() { return std::unique_ptr<ICommunication>(new Transport(err, getWritableNeoDevice())); }
virtual void setupTransport(ICommunication* transport) {}
virtual void setupTransport(ICommunication* stransport) { (void)stransport; }
virtual std::shared_ptr<Packetizer> makePacketizer() { return std::make_shared<Packetizer>(err); }
virtual void setupPacketizer(Packetizer* packetizer) {}
virtual void setupPacketizer(Packetizer* spacketizer) { (void)spacketizer; }
virtual std::unique_ptr<Encoder> makeEncoder(std::shared_ptr<Packetizer> p) { return std::unique_ptr<Encoder>(new Encoder(err, p)); }
virtual void setupEncoder(Encoder* encoder) {}
virtual void setupEncoder(Encoder* sencoder) { (void)sencoder; }
virtual std::unique_ptr<Decoder> makeDecoder() { return std::unique_ptr<Decoder>(new Decoder(err)); }
virtual void setupDecoder(Decoder* decoder) {}
virtual void setupDecoder(Decoder* sdecoder) { (void)sdecoder; }
virtual std::shared_ptr<Communication> makeCommunication(
std::unique_ptr<ICommunication> t,
std::shared_ptr<Packetizer> p,
std::unique_ptr<Encoder> e,
std::unique_ptr<Decoder> d) { return std::make_shared<Communication>(err, std::move(t), p, std::move(e), std::move(d)); }
virtual void setupCommunication(Communication* com) {}
virtual void setupCommunication(Communication* scom) { (void)scom; }
template<typename Settings>
std::unique_ptr<IDeviceSettings> makeSettings(std::shared_ptr<Communication> com) {
return std::unique_ptr<IDeviceSettings>(new Settings(com));
}
virtual void setupSettings(IDeviceSettings* settings) {}
virtual void setupSettings(IDeviceSettings* ssettings) { (void)ssettings; }
// END Initialization Functions
void handleInternalMessage(std::shared_ptr<Message> message);
include/icsneo/device/neovifire2/neovifire2eth.h
+11 -13
View File
@@ -15,13 +15,12 @@ public:
std::vector<std::shared_ptr<Device>> found;
for(auto& foundDev : PCAP::FindAll()) {
auto packetizer = std::make_shared<Packetizer>();
auto decoder = std::unique_ptr<Decoder>(new Decoder());
for(auto& payload : foundDev.discoveryPackets)
packetizer->input(payload);
for(auto& packet : packetizer->output()) {
auto fakedev = std::shared_ptr<NeoVIFIRE2ETH>(new NeoVIFIRE2ETH({}));
for (auto& payload : foundDev.discoveryPackets)
fakedev->com->packetizer->input(payload);
for (auto& packet : fakedev->com->packetizer->output()) {
std::shared_ptr<Message> msg;
if(!decoder->decode(msg, packet))
if (!fakedev->com->decoder->decode(msg, packet))
continue; // We failed to decode this packet
if(!msg || msg->network.getNetID() != Network::NetID::Main51)
@@ -44,17 +43,16 @@ public:
return found;
}
protected:
virtual void setupSettings(IDeviceSettings* settings) {
// TODO Check firmware version, old firmwares will reset Ethernet settings on settings send
settings->readonly = true;
}
private:
NeoVIFIRE2ETH(neodevice_t neodevice) : NeoVIFIRE2(neodevice) {
initialize<PCAP, NeoVIFIRE2Settings>();
productId = PRODUCT_ID;
}
protected:
virtual void setupSettings(IDeviceSettings* ssettings) {
// TODO Check firmware version, old firmwares will reset Ethernet settings on settings send
ssettings->readonly = true;
}
};
}
include/icsneo/device/radgalaxy/radgalaxy.h
+6 -7
View File
@@ -47,18 +47,17 @@ public:
return found;
}
protected:
void setupPacketizer(Packetizer* packetizer) override {
packetizer->disableChecksum = true;
packetizer->align16bit = false;
}
private:
RADGalaxy(neodevice_t neodevice) : Device(neodevice) {
initialize<PCAP>();
getWritableNeoDevice().type = DEVICE_TYPE;
productId = PRODUCT_ID;
}
protected:
void setupPacketizer(Packetizer* packetizer) override {
packetizer->disableChecksum = true;
packetizer->align16bit = false;
}
};
}
include/icsneo/device/radstar2/radstar2eth.h
-1
View File
@@ -43,7 +43,6 @@ public:
return found;
}
private:
RADStar2ETH(neodevice_t neodevice) : RADStar2(neodevice) {
initialize<PCAP>();
}
include/icsneo/platform/windows/ftdi.h
+1 -1
View File
@@ -8,7 +8,7 @@ namespace icsneo {
class FTDI : public VCP {
public:
FTDI(device_errorhandler_t err, neodevice_t& forDevice) : VCP(err, forDevice) {}
static std::vector<neodevice_t> FindByProduct(int product) { return VCP::FindByProduct(product, L"serenum"); }
static std::vector<neodevice_t> FindByProduct(int product) { return VCP::FindByProduct(product, { L"serenum", L"ftdibus" }); }
};
}
include/icsneo/platform/windows/pcap.h
+1
View File
@@ -27,6 +27,7 @@ public:
bool close();
private:
PCAPDLL pcap;
device_errorhandler_t err;
char errbuf[PCAP_ERRBUF_SIZE] = { 0 };
neodevice_t& device;
uint8_t deviceMAC[6];
include/icsneo/platform/windows/stm32.h
+1 -1
View File
@@ -8,7 +8,7 @@ namespace icsneo {
class STM32 : public VCP {
public:
STM32(device_errorhandler_t err, neodevice_t& forDevice) : VCP(err, forDevice) {}
static std::vector<neodevice_t> FindByProduct(int product) { return VCP::FindByProduct(product, L"usbser"); }
static std::vector<neodevice_t> FindByProduct(int product) { return VCP::FindByProduct(product, { L"usbser" }); }
};
}
include/icsneo/platform/windows/vcp.h
+1 -1
View File
@@ -16,7 +16,7 @@ namespace icsneo {
// Virtual COM Port Communication
class VCP : public ICommunication {
public:
static std::vector<neodevice_t> FindByProduct(int product, wchar_t* driverName);
static std::vector<neodevice_t> FindByProduct(int product, std::vector<std::wstring> driverName);
static bool IsHandleValid(neodevice_handle_t handle);
typedef void(*fn_boolCallback)(bool success);