mirror of
https://github.com/intrepidcs/libicsneo.git
synced 2026-08-05 01:18:36 +02:00
Communication::Command refactored out of Communication
This commit is contained in:
Paul Hollinsky
+159
-158
@@ -1,158 +1,159 @@
|
||||
#include "communication/include/communication.h"
|
||||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <queue>
|
||||
#include <iomanip>
|
||||
#include <cstring>
|
||||
#include <mutex>
|
||||
#include <condition_variable>
|
||||
#include "communication/include/messagedecoder.h"
|
||||
#include "communication/include/packetizer.h"
|
||||
|
||||
using namespace icsneo;
|
||||
|
||||
int Communication::messageCallbackIDCounter = 1;
|
||||
|
||||
uint8_t Communication::ICSChecksum(const std::vector<uint8_t>& data) {
|
||||
uint32_t checksum = 0;
|
||||
for(auto i = 0; i < data.size(); i++)
|
||||
checksum += data[i];
|
||||
checksum = ~checksum;
|
||||
checksum++;
|
||||
return (uint8_t)checksum;
|
||||
}
|
||||
|
||||
std::vector<uint8_t>& Communication::packetWrap(std::vector<uint8_t>& data, bool addChecksum) {
|
||||
if(addChecksum)
|
||||
data.push_back(ICSChecksum(data));
|
||||
data.insert(data.begin(), 0xAA);
|
||||
if(align16bit && data.size() % 2 == 1)
|
||||
data.push_back('A');
|
||||
return data;
|
||||
}
|
||||
|
||||
bool Communication::open() {
|
||||
if(isOpen)
|
||||
return true;
|
||||
|
||||
spawnThreads();
|
||||
isOpen = true;
|
||||
return impl->open();
|
||||
}
|
||||
|
||||
void Communication::spawnThreads() {
|
||||
readTaskThread = std::thread(&Communication::readTask, this);
|
||||
}
|
||||
|
||||
void Communication::joinThreads() {
|
||||
if(readTaskThread.joinable())
|
||||
readTaskThread.join();
|
||||
}
|
||||
|
||||
bool Communication::close() {
|
||||
if(!isOpen)
|
||||
return false;
|
||||
|
||||
isOpen = false;
|
||||
closing = true;
|
||||
joinThreads();
|
||||
|
||||
return impl->close();
|
||||
}
|
||||
|
||||
bool Communication::sendPacket(std::vector<uint8_t>& bytes) {
|
||||
return impl->write(Communication::packetWrap(bytes));
|
||||
}
|
||||
|
||||
bool Communication::sendCommand(Communication::Command cmd, std::vector<uint8_t> arguments) {
|
||||
std::vector<uint8_t> bytes;
|
||||
bytes.push_back((uint8_t)cmd);
|
||||
for(auto& b : arguments)
|
||||
bytes.push_back(b);
|
||||
bytes.insert(bytes.begin(), (uint8_t)Network::NetID::Main51 | ((uint8_t)bytes.size() << 4));
|
||||
return sendPacket(bytes);
|
||||
}
|
||||
|
||||
bool Communication::getSettingsSync(std::vector<uint8_t>& data, std::chrono::milliseconds timeout) {
|
||||
sendCommand(Command::GetSettings);
|
||||
std::shared_ptr<Message> msg = waitForMessageSync(MessageFilter(Network::NetID::RED_READ_BAUD_SETTINGS), timeout);
|
||||
if(!msg)
|
||||
return false;
|
||||
|
||||
data = std::move(msg->data);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Communication::getSerialNumberSync(std::string& serial, std::chrono::milliseconds timeout) {
|
||||
sendCommand(Command::RequestSerialNumber);
|
||||
std::shared_ptr<Message> msg = waitForMessageSync(MessageFilter(Network::NetID::RED_OLDFORMAT), timeout);
|
||||
if(!msg)
|
||||
return false;
|
||||
|
||||
std::cout << "Got " << msg->data.size() << " bytes" << std::endl;
|
||||
for(size_t i = 0; i < msg->data.size(); i++) {
|
||||
std::cout << std::hex << (int)msg->data[i] << ' ' << std::dec;
|
||||
if(i % 16 == 15)
|
||||
std::cout << std::endl;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
int Communication::addMessageCallback(const MessageCallback& cb) {
|
||||
messageCallbacks.insert(std::make_pair(messageCallbackIDCounter, cb));
|
||||
return messageCallbackIDCounter++;
|
||||
}
|
||||
|
||||
bool Communication::removeMessageCallback(int id) {
|
||||
try {
|
||||
messageCallbacks.erase(id);
|
||||
return true;
|
||||
} catch(...) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<Message> Communication::waitForMessageSync(MessageFilter f, std::chrono::milliseconds timeout) {
|
||||
std::mutex m;
|
||||
std::condition_variable cv;
|
||||
std::shared_ptr<Message> returnedMessage;
|
||||
int cb = addMessageCallback(MessageCallback([&m, &returnedMessage, &cv](std::shared_ptr<Message> message) {
|
||||
{
|
||||
std::lock_guard<std::mutex> lk(m);
|
||||
returnedMessage = message;
|
||||
}
|
||||
cv.notify_one();
|
||||
}, f));
|
||||
|
||||
// We have now added the callback, wait for it to return from the other thread
|
||||
std::unique_lock<std::mutex> lk(m);
|
||||
cv.wait_for(lk, timeout, [&returnedMessage]{ return !!returnedMessage; }); // `!!shared_ptr` checks if the ptr has a value
|
||||
|
||||
// We don't actually check that we got a message, because either way we want to remove the callback (since it should only happen once)
|
||||
removeMessageCallback(cb);
|
||||
|
||||
// Then we either will return the message we got or we will return the empty shared_ptr, caller responsible for checking
|
||||
return returnedMessage;
|
||||
}
|
||||
|
||||
void Communication::readTask() {
|
||||
std::vector<uint8_t> readBytes;
|
||||
Packetizer packetizer;
|
||||
MessageDecoder decoder;
|
||||
|
||||
while(!closing) {
|
||||
readBytes.clear();
|
||||
if(impl->readWait(readBytes)) {
|
||||
if(packetizer.input(readBytes)) {
|
||||
for(auto& packet : packetizer.output()) {
|
||||
auto msg = decoder.decodePacket(packet);
|
||||
for(auto& cb : messageCallbacks) { // We might have closed while reading or processing
|
||||
if(!closing) {
|
||||
cb.second.callIfMatch(msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#include "communication/include/communication.h"
|
||||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <queue>
|
||||
#include <iomanip>
|
||||
#include <cstring>
|
||||
#include <mutex>
|
||||
#include <condition_variable>
|
||||
#include "communication/include/command.h"
|
||||
#include "communication/include/messagedecoder.h"
|
||||
#include "communication/include/packetizer.h"
|
||||
|
||||
using namespace icsneo;
|
||||
|
||||
int Communication::messageCallbackIDCounter = 1;
|
||||
|
||||
uint8_t Communication::ICSChecksum(const std::vector<uint8_t>& data) {
|
||||
uint32_t checksum = 0;
|
||||
for(auto i = 0; i < data.size(); i++)
|
||||
checksum += data[i];
|
||||
checksum = ~checksum;
|
||||
checksum++;
|
||||
return (uint8_t)checksum;
|
||||
}
|
||||
|
||||
std::vector<uint8_t>& Communication::packetWrap(std::vector<uint8_t>& data, bool addChecksum) {
|
||||
if(addChecksum)
|
||||
data.push_back(ICSChecksum(data));
|
||||
data.insert(data.begin(), 0xAA);
|
||||
if(align16bit && data.size() % 2 == 1)
|
||||
data.push_back('A');
|
||||
return data;
|
||||
}
|
||||
|
||||
bool Communication::open() {
|
||||
if(isOpen)
|
||||
return true;
|
||||
|
||||
spawnThreads();
|
||||
isOpen = true;
|
||||
return impl->open();
|
||||
}
|
||||
|
||||
void Communication::spawnThreads() {
|
||||
readTaskThread = std::thread(&Communication::readTask, this);
|
||||
}
|
||||
|
||||
void Communication::joinThreads() {
|
||||
if(readTaskThread.joinable())
|
||||
readTaskThread.join();
|
||||
}
|
||||
|
||||
bool Communication::close() {
|
||||
if(!isOpen)
|
||||
return false;
|
||||
|
||||
isOpen = false;
|
||||
closing = true;
|
||||
joinThreads();
|
||||
|
||||
return impl->close();
|
||||
}
|
||||
|
||||
bool Communication::sendPacket(std::vector<uint8_t>& bytes) {
|
||||
return impl->write(Communication::packetWrap(bytes));
|
||||
}
|
||||
|
||||
bool Communication::sendCommand(Command cmd, std::vector<uint8_t> arguments) {
|
||||
std::vector<uint8_t> bytes;
|
||||
bytes.push_back((uint8_t)cmd);
|
||||
for(auto& b : arguments)
|
||||
bytes.push_back(b);
|
||||
bytes.insert(bytes.begin(), (uint8_t)Network::NetID::Main51 | ((uint8_t)bytes.size() << 4));
|
||||
return sendPacket(bytes);
|
||||
}
|
||||
|
||||
bool Communication::getSettingsSync(std::vector<uint8_t>& data, std::chrono::milliseconds timeout) {
|
||||
sendCommand(Command::GetSettings);
|
||||
std::shared_ptr<Message> msg = waitForMessageSync(MessageFilter(Network::NetID::RED_READ_BAUD_SETTINGS), timeout);
|
||||
if(!msg)
|
||||
return false;
|
||||
|
||||
data = std::move(msg->data);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Communication::getSerialNumberSync(std::string& serial, std::chrono::milliseconds timeout) {
|
||||
sendCommand(Command::RequestSerialNumber);
|
||||
std::shared_ptr<Message> msg = waitForMessageSync(MessageFilter(Network::NetID::RED_OLDFORMAT), timeout);
|
||||
if(!msg)
|
||||
return false;
|
||||
|
||||
std::cout << "Got " << msg->data.size() << " bytes" << std::endl;
|
||||
for(size_t i = 0; i < msg->data.size(); i++) {
|
||||
std::cout << std::hex << (int)msg->data[i] << ' ' << std::dec;
|
||||
if(i % 16 == 15)
|
||||
std::cout << std::endl;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
int Communication::addMessageCallback(const MessageCallback& cb) {
|
||||
messageCallbacks.insert(std::make_pair(messageCallbackIDCounter, cb));
|
||||
return messageCallbackIDCounter++;
|
||||
}
|
||||
|
||||
bool Communication::removeMessageCallback(int id) {
|
||||
try {
|
||||
messageCallbacks.erase(id);
|
||||
return true;
|
||||
} catch(...) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<Message> Communication::waitForMessageSync(MessageFilter f, std::chrono::milliseconds timeout) {
|
||||
std::mutex m;
|
||||
std::condition_variable cv;
|
||||
std::shared_ptr<Message> returnedMessage;
|
||||
int cb = addMessageCallback(MessageCallback([&m, &returnedMessage, &cv](std::shared_ptr<Message> message) {
|
||||
{
|
||||
std::lock_guard<std::mutex> lk(m);
|
||||
returnedMessage = message;
|
||||
}
|
||||
cv.notify_one();
|
||||
}, f));
|
||||
|
||||
// We have now added the callback, wait for it to return from the other thread
|
||||
std::unique_lock<std::mutex> lk(m);
|
||||
cv.wait_for(lk, timeout, [&returnedMessage]{ return !!returnedMessage; }); // `!!shared_ptr` checks if the ptr has a value
|
||||
|
||||
// We don't actually check that we got a message, because either way we want to remove the callback (since it should only happen once)
|
||||
removeMessageCallback(cb);
|
||||
|
||||
// Then we either will return the message we got or we will return the empty shared_ptr, caller responsible for checking
|
||||
return returnedMessage;
|
||||
}
|
||||
|
||||
void Communication::readTask() {
|
||||
std::vector<uint8_t> readBytes;
|
||||
Packetizer packetizer;
|
||||
MessageDecoder decoder;
|
||||
|
||||
while(!closing) {
|
||||
readBytes.clear();
|
||||
if(impl->readWait(readBytes)) {
|
||||
if(packetizer.input(readBytes)) {
|
||||
for(auto& packet : packetizer.output()) {
|
||||
auto msg = decoder.decodePacket(packet);
|
||||
for(auto& cb : messageCallbacks) { // We might have closed while reading or processing
|
||||
if(!closing) {
|
||||
cb.second.callIfMatch(msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
#ifndef __COMMAND_H_
|
||||
#define __COMMAND_H_
|
||||
|
||||
namespace icsneo {
|
||||
|
||||
enum class Command : uint8_t {
|
||||
EnableNetworkCommunication = 0x07,
|
||||
RequestSerialNumber = 0xA1,
|
||||
SetSettings = 0xA4, // Previously known as RED_CMD_SET_BAUD_REQ, follow up with SaveSettings to write to EEPROM
|
||||
GetSettings = 0xA5, // Previously known as RED_CMD_READ_BAUD_REQ
|
||||
SaveSettings = 0xA6
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,71 +1,65 @@
|
||||
#ifndef __COMMUNICATION_H_
|
||||
#define __COMMUNICATION_H_
|
||||
|
||||
#include "communication/include/icommunication.h"
|
||||
#include "communication/include/network.h"
|
||||
#include "communication/include/messagecallback.h"
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
#include <atomic>
|
||||
#include <thread>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
|
||||
namespace icsneo {
|
||||
|
||||
class Communication {
|
||||
public:
|
||||
static uint8_t ICSChecksum(const std::vector<uint8_t>& data);
|
||||
|
||||
Communication(std::shared_ptr<ICommunication> com) : impl(com) {}
|
||||
virtual ~Communication() { close(); }
|
||||
|
||||
bool open();
|
||||
bool close();
|
||||
virtual void spawnThreads();
|
||||
virtual void joinThreads();
|
||||
bool rawWrite(const std::vector<uint8_t>& bytes) { return impl->write(bytes); }
|
||||
std::vector<uint8_t>& packetWrap(std::vector<uint8_t>& data, bool addChecksum = true);
|
||||
bool sendPacket(std::vector<uint8_t>& bytes);
|
||||
|
||||
enum class Command : uint8_t {
|
||||
EnableNetworkCommunication = 0x07,
|
||||
RequestSerialNumber = 0xA1,
|
||||
SetSettings = 0xA4, // Previously known as RED_CMD_SET_BAUD_REQ, follow up with SaveSettings to write to EEPROM
|
||||
GetSettings = 0xA5, // Previously known as RED_CMD_READ_BAUD_REQ
|
||||
SaveSettings = 0xA6
|
||||
};
|
||||
virtual bool sendCommand(Command cmd, bool boolean) { return sendCommand(cmd, std::vector<uint8_t>({ (uint8_t)boolean })); }
|
||||
virtual bool sendCommand(Command cmd, std::vector<uint8_t> arguments = {});
|
||||
bool getSettingsSync(std::vector<uint8_t>& data, std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
|
||||
bool getSerialNumberSync(std::string& serial, std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
|
||||
|
||||
int addMessageCallback(const MessageCallback& cb);
|
||||
bool removeMessageCallback(int id);
|
||||
std::shared_ptr<Message> waitForMessageSync(MessageFilter f = MessageFilter(), std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
|
||||
|
||||
void setAlign16Bit(bool enable) { align16bit = enable; }
|
||||
|
||||
class Packet {
|
||||
public:
|
||||
Network network;
|
||||
std::vector<uint8_t> data;
|
||||
};
|
||||
|
||||
protected:
|
||||
std::shared_ptr<ICommunication> impl;
|
||||
static int messageCallbackIDCounter;
|
||||
std::map<int, MessageCallback> messageCallbacks;
|
||||
std::atomic<bool> closing{false};
|
||||
|
||||
private:
|
||||
bool isOpen = false;
|
||||
bool align16bit = true; // Not needed for Gigalog, Galaxy, etc and newer
|
||||
|
||||
std::thread readTaskThread;
|
||||
void readTask();
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#ifndef __COMMUNICATION_H_
|
||||
#define __COMMUNICATION_H_
|
||||
|
||||
#include "communication/include/icommunication.h"
|
||||
#include "communication/include/command.h"
|
||||
#include "communication/include/network.h"
|
||||
#include "communication/include/messagecallback.h"
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
#include <atomic>
|
||||
#include <thread>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
|
||||
namespace icsneo {
|
||||
|
||||
class Communication {
|
||||
public:
|
||||
static uint8_t ICSChecksum(const std::vector<uint8_t>& data);
|
||||
|
||||
Communication(std::shared_ptr<ICommunication> com) : impl(com) {}
|
||||
virtual ~Communication() { close(); }
|
||||
|
||||
bool open();
|
||||
bool close();
|
||||
virtual void spawnThreads();
|
||||
virtual void joinThreads();
|
||||
bool rawWrite(const std::vector<uint8_t>& bytes) { return impl->write(bytes); }
|
||||
std::vector<uint8_t>& packetWrap(std::vector<uint8_t>& data, bool addChecksum = true);
|
||||
bool sendPacket(std::vector<uint8_t>& bytes);
|
||||
|
||||
virtual bool sendCommand(Command cmd, bool boolean) { return sendCommand(cmd, std::vector<uint8_t>({ (uint8_t)boolean })); }
|
||||
virtual bool sendCommand(Command cmd, std::vector<uint8_t> arguments = {});
|
||||
bool getSettingsSync(std::vector<uint8_t>& data, std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
|
||||
bool getSerialNumberSync(std::string& serial, std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
|
||||
|
||||
int addMessageCallback(const MessageCallback& cb);
|
||||
bool removeMessageCallback(int id);
|
||||
std::shared_ptr<Message> waitForMessageSync(MessageFilter f = MessageFilter(), std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
|
||||
|
||||
void setAlign16Bit(bool enable) { align16bit = enable; }
|
||||
|
||||
class Packet {
|
||||
public:
|
||||
Network network;
|
||||
std::vector<uint8_t> data;
|
||||
};
|
||||
|
||||
protected:
|
||||
std::shared_ptr<ICommunication> impl;
|
||||
static int messageCallbackIDCounter;
|
||||
std::map<int, MessageCallback> messageCallbacks;
|
||||
std::atomic<bool> closing{false};
|
||||
|
||||
private:
|
||||
bool isOpen = false;
|
||||
bool align16bit = true; // Not needed for Gigalog, Galaxy, etc and newer
|
||||
|
||||
std::thread readTaskThread;
|
||||
void readTask();
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,102 +1,103 @@
|
||||
#ifndef __MULTICHANNELCOMMUNICATION_H_
|
||||
#define __MULTICHANNELCOMMUNICATION_H_
|
||||
|
||||
#include "communication/include/communication.h"
|
||||
#include "communication/include/icommunication.h"
|
||||
|
||||
namespace icsneo {
|
||||
|
||||
class MultiChannelCommunication : public Communication {
|
||||
public:
|
||||
MultiChannelCommunication(std::shared_ptr<ICommunication> com) : Communication(com) {}
|
||||
void spawnThreads();
|
||||
void joinThreads();
|
||||
bool sendCommand(Communication::Command cmd, std::vector<uint8_t> arguments);
|
||||
|
||||
protected:
|
||||
bool preprocessPacket(std::deque<uint8_t>& usbReadFifo);
|
||||
|
||||
private:
|
||||
enum class CommandType : uint8_t {
|
||||
PlasmaReadRequest = 0x10, // Status read request to HSC
|
||||
PlasmaStatusResponse = 0x11, // Status response by HSC
|
||||
HostPC_to_Vnet1 = 0x20, // Host PC data to Vnet module-1
|
||||
Vnet1_to_HostPC = 0x21, // Vnet module-1 data to host PC
|
||||
HostPC_to_Vnet2 = 0x30, // Host PC data to Vnet module-2
|
||||
Vnet2_to_HostPC = 0x31, // Vnet module-2 data to host PC
|
||||
HostPC_to_Vnet3 = 0x40, // Host PC data to Vnet module-3
|
||||
Vnet3_to_HostPC = 0x41, // Vnet module-3 data to host PC
|
||||
HostPC_to_SDCC1 = 0x50, // Host PC data to write to SDCC-1
|
||||
HostPC_from_SDCC1 = 0x51, // Host PC wants data read from SDCC-1
|
||||
SDCC1_to_HostPC = 0x52, // SDCC-1 data to host PC
|
||||
HostPC_to_SDCC2 = 0x60, // Host PC data to write to SDCC-2
|
||||
HostPC_from_SDCC2 = 0x61, // Host PC wants data read from SDCC-2
|
||||
SDCC2_to_HostPC = 0x62, // SDCC-2 data to host PC
|
||||
PC_to_LSOC = 0x70, // Host PC data to LSOCC
|
||||
LSOCC_to_PC = 0x71, // LSOCC data to host PC
|
||||
HostPC_to_Microblaze = 0x80, // Host PC data to microblaze processor
|
||||
Microblaze_to_HostPC = 0x81 // Microblaze processor data to host PC
|
||||
};
|
||||
static bool CommandTypeIsValid(CommandType cmd) {
|
||||
switch(cmd) {
|
||||
case CommandType::PlasmaReadRequest:
|
||||
case CommandType::PlasmaStatusResponse:
|
||||
case CommandType::HostPC_to_Vnet1:
|
||||
case CommandType::Vnet1_to_HostPC:
|
||||
case CommandType::HostPC_to_Vnet2:
|
||||
case CommandType::Vnet2_to_HostPC:
|
||||
case CommandType::HostPC_to_Vnet3:
|
||||
case CommandType::Vnet3_to_HostPC:
|
||||
case CommandType::HostPC_to_SDCC1:
|
||||
case CommandType::HostPC_from_SDCC1:
|
||||
case CommandType::SDCC1_to_HostPC:
|
||||
case CommandType::HostPC_to_SDCC2:
|
||||
case CommandType::HostPC_from_SDCC2:
|
||||
case CommandType::SDCC2_to_HostPC:
|
||||
case CommandType::PC_to_LSOC:
|
||||
case CommandType::LSOCC_to_PC:
|
||||
case CommandType::HostPC_to_Microblaze:
|
||||
case CommandType::Microblaze_to_HostPC:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
static bool CommandTypeHasAddress(CommandType cmd) {
|
||||
// Check CommandTypeIsValid before this, you will get false on an invalid command
|
||||
switch(cmd) {
|
||||
case CommandType::SDCC1_to_HostPC:
|
||||
case CommandType::SDCC2_to_HostPC:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
static uint16_t CommandTypeDefinesLength(CommandType cmd) {
|
||||
// Check CommandTypeIsValid before this, you will get 0 on an invalid command
|
||||
switch(cmd) {
|
||||
case CommandType::PlasmaStatusResponse:
|
||||
return 2;
|
||||
default:
|
||||
return 0; // Length is defined by following bytes in message
|
||||
}
|
||||
}
|
||||
|
||||
enum class PreprocessState {
|
||||
SearchForCommand,
|
||||
ParseAddress,
|
||||
ParseLength,
|
||||
GetData
|
||||
};
|
||||
PreprocessState state = PreprocessState::SearchForCommand;
|
||||
uint16_t currentCommandLength;
|
||||
CommandType currentCommandType;
|
||||
size_t currentReadIndex = 0;
|
||||
|
||||
std::thread mainChannelReadThread;
|
||||
void readTask();
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#ifndef __MULTICHANNELCOMMUNICATION_H_
|
||||
#define __MULTICHANNELCOMMUNICATION_H_
|
||||
|
||||
#include "communication/include/communication.h"
|
||||
#include "communication/include/icommunication.h"
|
||||
#include "communication/include/command.h"
|
||||
|
||||
namespace icsneo {
|
||||
|
||||
class MultiChannelCommunication : public Communication {
|
||||
public:
|
||||
MultiChannelCommunication(std::shared_ptr<ICommunication> com) : Communication(com) {}
|
||||
void spawnThreads();
|
||||
void joinThreads();
|
||||
bool sendCommand(Command cmd, std::vector<uint8_t> arguments);
|
||||
|
||||
protected:
|
||||
bool preprocessPacket(std::deque<uint8_t>& usbReadFifo);
|
||||
|
||||
private:
|
||||
enum class CommandType : uint8_t {
|
||||
PlasmaReadRequest = 0x10, // Status read request to HSC
|
||||
PlasmaStatusResponse = 0x11, // Status response by HSC
|
||||
HostPC_to_Vnet1 = 0x20, // Host PC data to Vnet module-1
|
||||
Vnet1_to_HostPC = 0x21, // Vnet module-1 data to host PC
|
||||
HostPC_to_Vnet2 = 0x30, // Host PC data to Vnet module-2
|
||||
Vnet2_to_HostPC = 0x31, // Vnet module-2 data to host PC
|
||||
HostPC_to_Vnet3 = 0x40, // Host PC data to Vnet module-3
|
||||
Vnet3_to_HostPC = 0x41, // Vnet module-3 data to host PC
|
||||
HostPC_to_SDCC1 = 0x50, // Host PC data to write to SDCC-1
|
||||
HostPC_from_SDCC1 = 0x51, // Host PC wants data read from SDCC-1
|
||||
SDCC1_to_HostPC = 0x52, // SDCC-1 data to host PC
|
||||
HostPC_to_SDCC2 = 0x60, // Host PC data to write to SDCC-2
|
||||
HostPC_from_SDCC2 = 0x61, // Host PC wants data read from SDCC-2
|
||||
SDCC2_to_HostPC = 0x62, // SDCC-2 data to host PC
|
||||
PC_to_LSOC = 0x70, // Host PC data to LSOCC
|
||||
LSOCC_to_PC = 0x71, // LSOCC data to host PC
|
||||
HostPC_to_Microblaze = 0x80, // Host PC data to microblaze processor
|
||||
Microblaze_to_HostPC = 0x81 // Microblaze processor data to host PC
|
||||
};
|
||||
static bool CommandTypeIsValid(CommandType cmd) {
|
||||
switch(cmd) {
|
||||
case CommandType::PlasmaReadRequest:
|
||||
case CommandType::PlasmaStatusResponse:
|
||||
case CommandType::HostPC_to_Vnet1:
|
||||
case CommandType::Vnet1_to_HostPC:
|
||||
case CommandType::HostPC_to_Vnet2:
|
||||
case CommandType::Vnet2_to_HostPC:
|
||||
case CommandType::HostPC_to_Vnet3:
|
||||
case CommandType::Vnet3_to_HostPC:
|
||||
case CommandType::HostPC_to_SDCC1:
|
||||
case CommandType::HostPC_from_SDCC1:
|
||||
case CommandType::SDCC1_to_HostPC:
|
||||
case CommandType::HostPC_to_SDCC2:
|
||||
case CommandType::HostPC_from_SDCC2:
|
||||
case CommandType::SDCC2_to_HostPC:
|
||||
case CommandType::PC_to_LSOC:
|
||||
case CommandType::LSOCC_to_PC:
|
||||
case CommandType::HostPC_to_Microblaze:
|
||||
case CommandType::Microblaze_to_HostPC:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
static bool CommandTypeHasAddress(CommandType cmd) {
|
||||
// Check CommandTypeIsValid before this, you will get false on an invalid command
|
||||
switch(cmd) {
|
||||
case CommandType::SDCC1_to_HostPC:
|
||||
case CommandType::SDCC2_to_HostPC:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
static uint16_t CommandTypeDefinesLength(CommandType cmd) {
|
||||
// Check CommandTypeIsValid before this, you will get 0 on an invalid command
|
||||
switch(cmd) {
|
||||
case CommandType::PlasmaStatusResponse:
|
||||
return 2;
|
||||
default:
|
||||
return 0; // Length is defined by following bytes in message
|
||||
}
|
||||
}
|
||||
|
||||
enum class PreprocessState {
|
||||
SearchForCommand,
|
||||
ParseAddress,
|
||||
ParseLength,
|
||||
GetData
|
||||
};
|
||||
PreprocessState state = PreprocessState::SearchForCommand;
|
||||
uint16_t currentCommandLength;
|
||||
CommandType currentCommandType;
|
||||
size_t currentReadIndex = 0;
|
||||
|
||||
std::thread mainChannelReadThread;
|
||||
void readTask();
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,126 +1,127 @@
|
||||
#include "communication/include/multichannelcommunication.h"
|
||||
#include "communication/include/messagedecoder.h"
|
||||
#include "communication/include/packetizer.h"
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
using namespace icsneo;
|
||||
|
||||
void MultiChannelCommunication::spawnThreads() {
|
||||
mainChannelReadThread = std::thread(&MultiChannelCommunication::readTask, this);
|
||||
}
|
||||
|
||||
void MultiChannelCommunication::joinThreads() {
|
||||
if(mainChannelReadThread.joinable())
|
||||
mainChannelReadThread.join();
|
||||
}
|
||||
|
||||
bool MultiChannelCommunication::sendCommand(Communication::Command cmd, std::vector<uint8_t> arguments) {
|
||||
std::vector<uint8_t> bytes;
|
||||
bytes.push_back((uint8_t)cmd);
|
||||
for(auto& b : arguments)
|
||||
bytes.push_back(b);
|
||||
bytes.insert(bytes.begin(), 0xB | ((uint8_t)bytes.size() << 4));
|
||||
bytes = Communication::packetWrap(bytes);
|
||||
bytes.insert(bytes.begin(), {(uint8_t)CommandType::HostPC_to_Vnet1, (uint8_t)bytes.size(), (uint8_t)(bytes.size() >> 8)});
|
||||
return rawWrite(bytes);
|
||||
}
|
||||
|
||||
void MultiChannelCommunication::readTask() {
|
||||
bool readMore = true;
|
||||
std::deque<uint8_t> usbReadFifo;
|
||||
std::vector<uint8_t> readBytes;
|
||||
std::vector<uint8_t> payloadBytes;
|
||||
Packetizer packetizer;
|
||||
MessageDecoder decoder;
|
||||
|
||||
while(!closing) {
|
||||
if(readMore) {
|
||||
readBytes.clear();
|
||||
if(impl->readWait(readBytes)) {
|
||||
readMore = false;
|
||||
usbReadFifo.insert(usbReadFifo.end(), std::make_move_iterator(readBytes.begin()), std::make_move_iterator(readBytes.end()));
|
||||
}
|
||||
} else {
|
||||
switch(state) {
|
||||
case PreprocessState::SearchForCommand:
|
||||
if(usbReadFifo.size() < 1) {
|
||||
readMore = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
currentCommandType = (CommandType)usbReadFifo[0];
|
||||
|
||||
if(!CommandTypeIsValid(currentCommandType)) {
|
||||
std::cout << "cnv" << std::hex << (int)currentCommandType << ' ' << std::dec;
|
||||
usbReadFifo.pop_front();
|
||||
continue;
|
||||
}
|
||||
|
||||
currentReadIndex = 1;
|
||||
|
||||
if(CommandTypeHasAddress(currentCommandType)) {
|
||||
state = PreprocessState::ParseAddress;
|
||||
continue; // No commands which define an address also define a length, so we can just continue from there
|
||||
}
|
||||
|
||||
currentCommandLength = CommandTypeDefinesLength(currentCommandType);
|
||||
if(currentCommandLength == 0) {
|
||||
state = PreprocessState::ParseLength;
|
||||
continue;
|
||||
}
|
||||
|
||||
state = PreprocessState::GetData;
|
||||
continue;
|
||||
case PreprocessState::ParseAddress:
|
||||
// The address is represented by a 4 byte little endian
|
||||
// Don't care about it yet
|
||||
currentReadIndex += 4;
|
||||
// Intentionally fall through
|
||||
case PreprocessState::ParseLength:
|
||||
state = PreprocessState::ParseLength; // Set state in case we've fallen through, but later need to go around again
|
||||
|
||||
if(usbReadFifo.size() < currentReadIndex + 2) { // Come back we have more data
|
||||
readMore = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
// The length is represented by a 2 byte little endian
|
||||
currentCommandLength = usbReadFifo[currentReadIndex++];
|
||||
currentCommandLength |= usbReadFifo[currentReadIndex++] << 8;
|
||||
// Intentionally fall through
|
||||
case PreprocessState::GetData:
|
||||
state = PreprocessState::GetData; // Set state in case we've fallen through, but later need to go around again
|
||||
|
||||
if(usbReadFifo.size() <= currentReadIndex + currentCommandLength) { // Come back we have more data
|
||||
readMore = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
for(auto i = 0; i < currentReadIndex; i++)
|
||||
usbReadFifo.pop_front();
|
||||
|
||||
payloadBytes.clear();
|
||||
payloadBytes.resize(currentCommandLength);
|
||||
for(auto i = 0; i < currentCommandLength; i++) {
|
||||
payloadBytes[i] = usbReadFifo[0];
|
||||
usbReadFifo.pop_front();
|
||||
}
|
||||
|
||||
if(packetizer.input(payloadBytes)) {
|
||||
for(auto& packet : packetizer.output()) {
|
||||
auto msg = decoder.decodePacket(packet);
|
||||
for(auto& cb : messageCallbacks) { // We might have closed while reading or processing
|
||||
if(!closing) {
|
||||
cb.second.callIfMatch(msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
state = PreprocessState::SearchForCommand;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
#include "communication/include/multichannelcommunication.h"
|
||||
#include "communication/include/command.h"
|
||||
#include "communication/include/messagedecoder.h"
|
||||
#include "communication/include/packetizer.h"
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
using namespace icsneo;
|
||||
|
||||
void MultiChannelCommunication::spawnThreads() {
|
||||
mainChannelReadThread = std::thread(&MultiChannelCommunication::readTask, this);
|
||||
}
|
||||
|
||||
void MultiChannelCommunication::joinThreads() {
|
||||
if(mainChannelReadThread.joinable())
|
||||
mainChannelReadThread.join();
|
||||
}
|
||||
|
||||
bool MultiChannelCommunication::sendCommand(Command cmd, std::vector<uint8_t> arguments) {
|
||||
std::vector<uint8_t> bytes;
|
||||
bytes.push_back((uint8_t)cmd);
|
||||
for(auto& b : arguments)
|
||||
bytes.push_back(b);
|
||||
bytes.insert(bytes.begin(), 0xB | ((uint8_t)bytes.size() << 4));
|
||||
bytes = Communication::packetWrap(bytes);
|
||||
bytes.insert(bytes.begin(), {(uint8_t)CommandType::HostPC_to_Vnet1, (uint8_t)bytes.size(), (uint8_t)(bytes.size() >> 8)});
|
||||
return rawWrite(bytes);
|
||||
}
|
||||
|
||||
void MultiChannelCommunication::readTask() {
|
||||
bool readMore = true;
|
||||
std::deque<uint8_t> usbReadFifo;
|
||||
std::vector<uint8_t> readBytes;
|
||||
std::vector<uint8_t> payloadBytes;
|
||||
Packetizer packetizer;
|
||||
MessageDecoder decoder;
|
||||
|
||||
while(!closing) {
|
||||
if(readMore) {
|
||||
readBytes.clear();
|
||||
if(impl->readWait(readBytes)) {
|
||||
readMore = false;
|
||||
usbReadFifo.insert(usbReadFifo.end(), std::make_move_iterator(readBytes.begin()), std::make_move_iterator(readBytes.end()));
|
||||
}
|
||||
} else {
|
||||
switch(state) {
|
||||
case PreprocessState::SearchForCommand:
|
||||
if(usbReadFifo.size() < 1) {
|
||||
readMore = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
currentCommandType = (CommandType)usbReadFifo[0];
|
||||
|
||||
if(!CommandTypeIsValid(currentCommandType)) {
|
||||
std::cout << "cnv" << std::hex << (int)currentCommandType << ' ' << std::dec;
|
||||
usbReadFifo.pop_front();
|
||||
continue;
|
||||
}
|
||||
|
||||
currentReadIndex = 1;
|
||||
|
||||
if(CommandTypeHasAddress(currentCommandType)) {
|
||||
state = PreprocessState::ParseAddress;
|
||||
continue; // No commands which define an address also define a length, so we can just continue from there
|
||||
}
|
||||
|
||||
currentCommandLength = CommandTypeDefinesLength(currentCommandType);
|
||||
if(currentCommandLength == 0) {
|
||||
state = PreprocessState::ParseLength;
|
||||
continue;
|
||||
}
|
||||
|
||||
state = PreprocessState::GetData;
|
||||
continue;
|
||||
case PreprocessState::ParseAddress:
|
||||
// The address is represented by a 4 byte little endian
|
||||
// Don't care about it yet
|
||||
currentReadIndex += 4;
|
||||
// Intentionally fall through
|
||||
case PreprocessState::ParseLength:
|
||||
state = PreprocessState::ParseLength; // Set state in case we've fallen through, but later need to go around again
|
||||
|
||||
if(usbReadFifo.size() < currentReadIndex + 2) { // Come back we have more data
|
||||
readMore = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
// The length is represented by a 2 byte little endian
|
||||
currentCommandLength = usbReadFifo[currentReadIndex++];
|
||||
currentCommandLength |= usbReadFifo[currentReadIndex++] << 8;
|
||||
// Intentionally fall through
|
||||
case PreprocessState::GetData:
|
||||
state = PreprocessState::GetData; // Set state in case we've fallen through, but later need to go around again
|
||||
|
||||
if(usbReadFifo.size() <= currentReadIndex + currentCommandLength) { // Come back we have more data
|
||||
readMore = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
for(auto i = 0; i < currentReadIndex; i++)
|
||||
usbReadFifo.pop_front();
|
||||
|
||||
payloadBytes.clear();
|
||||
payloadBytes.resize(currentCommandLength);
|
||||
for(auto i = 0; i < currentCommandLength; i++) {
|
||||
payloadBytes[i] = usbReadFifo[0];
|
||||
usbReadFifo.pop_front();
|
||||
}
|
||||
|
||||
if(packetizer.input(payloadBytes)) {
|
||||
for(auto& packet : packetizer.output()) {
|
||||
auto msg = decoder.decodePacket(packet);
|
||||
for(auto& cb : messageCallbacks) { // We might have closed while reading or processing
|
||||
if(!closing) {
|
||||
cb.second.callIfMatch(msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
state = PreprocessState::SearchForCommand;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user