UsbCommunication.h

#pragma once
 
#pragma comment(lib, "Ws2_32.lib")
#include "BaseCommunication.h"
#include "UsbSettings.h"
 
#include <thread>
#include "UsbInformation.h"
#include "ClockUtilities.h"
 
#ifdef STARFLEETTOOLBOX_EXPORTS
#define USBCOMM __declspec(dllexport)
#else
#define USBCOMM __declspec(dllimport)
#endif
 
typedef struct UsbDevice {
    struct libusb_transfer* transfer;
    struct libusb_device_handle* device_handle;
    unsigned char input_endpoint; 
    struct libusb_context* usbContext;
 
    BaseDataExtractor* extractor;           // a pointer to the communication extractor
    HANDLE dataAvailableSemaphore;          // semaphore to warn that Command ACK is available
    HANDLE rawDataAvailableSemaphore;       // semaphore to warn that RAW Data are available
    HANDLE semReadyToConsume;               // synchronisation for data consumed
    string commandResult;                   // the command result
    bool treat = false;                     // indicates if data treater is in treatment
    vector<string> localVector;             // temporary local vector
    RawData extractedData;                  // the extracted raw data    
    bool interruptTransfer = true;          // indicates a transfert interruption
    CommunicationStatus commStatus;         // the connection status
    atomic<chrono::time_point<std::chrono::steady_clock>> lastUsbDataTime; // the last raw data  sent
};
 
class USBCOMM UsbCommunication :
    public BaseCommunication
{
public:
    const int COMMAND_ACK_TIMEOUT = 20000;
    const int MAX_SIZE_TO_READ = 40000;
 
    UsbCommunication();
    UsbCommunication(MONITORING_MODE monitoring);
    UsbCommunication(UsbSettings* settings);
    UsbCommunication(UsbSettings* settings, MONITORING_MODE monitoring);
    ~UsbCommunication();
 
    CommunicationStatus Connect();
    CommunicationStatus Connect(bool reconnecting);
 
    void Disconnect();
    
 
    string SendCommand(string commandToSend);
 
 
    RawData WaitForRawData(int waitTimeout, unsigned long* semStatus);
 
    static vector<UsbInformation> GetDeviceList();
protected:
    CommunicationStatus GetConnectionStatus();    
private:
    atomic<chrono::time_point<std::chrono::steady_clock>> _lastUsbDataTime;
 
    void Disconnect(bool reconnecting);
    CommunicationStatus Reconnect();
    std::atomic<bool> _stopHandle;
    std::atomic<bool> _connected;
 
    std::atomic<bool> _alreadydisconnected;
    std::atomic<bool> _disconnectCalledByPeer;
 
 
    std::atomic<int> _mainConnectionStatus; // useful for monitoring
 
    UsbDevice usbDevice;
    thread _usbReceiveData;    
 
    HANDLE _mutexSendAvailable;         // prevent the socket to be used from another process to send data
 
    void UsbEventDataReceiverBusiness(void* param);
 
    static void __stdcall callbackUSBReadTransferComplete(struct libusb_transfer* xfr);
};