ParticipantUDP.h

#pragma once
 
#include "Messages/BinaryMsg.h"
#include "Messages/DestroyMsg.h"
#include "Messages/InvestigateMsg.h"
#include "Messages/ModelUrlMsg.h"
#include "Messages/NameMsg.h"
#include "Messages/ParticipantMsg.h"
#include "Messages/PoseMsg.h"
#include "Messages/NetworkIdMsg.h"
#include "Messages/ThingMsg.h"
#include "Participant.h"
 
#if !defined(NO_STD)
#include <functional>
#include <list>
// #include <unordered_map>
#endif
 
#if defined(_WIN32) || defined(_WIN64)
#include <winsock2.h>
#elif defined(__unix__) || defined(__APPLE__)
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#endif
 
namespace RoboidControl {
 
constexpr int MAX_SENDER_COUNT = 256;
 
class ParticipantUDP : public Participant {
#pragma region Init
 
 public:
  ParticipantUDP(int port = 7681);
  ParticipantUDP(const char* ipAddress, int port = 7681, int localPort = 7681);
 
  static ParticipantUDP* Isolated();
 
 
#pragma endregion Init
 
  bool isIsolated = false;
  Participant* remoteSite = nullptr;
 
  long publishInterval = 3000;  // 3 seconds
 
  const char* name = "ParticipantUDP";
 
 protected:
  char buffer[1024];
 
#if !defined(ARDUINO)
#if defined(__unix__) || defined(__APPLE__)
  int sock;
#elif defined(_WIN32) || defined(_WIN64)
  sockaddr_in remote_addr;
  sockaddr_in server_addr;
  sockaddr_in broadcast_addr;
#endif
#endif
 public:
  void begin();
  bool connected = false;
 
#pragma region Update
 
 public:
  virtual void Update(unsigned long currentTimeMs = 0) override;
 
 protected:
  unsigned long nextPublishMe = 0;
 
  virtual void UpdateMyThings(unsigned long currentTimeMs);
  virtual void UpdateOtherThings(unsigned long currentTimeMs);
 
#pragma endregion Update
 
#pragma region Send
 
  void SendThingInfo(Participant* remoteParticipant, Thing* thing);
  void PublishThingInfo(Thing* thing);
 
  bool Send(Participant* remoteParticipant, IMessage* msg);
  bool Publish(IMessage* msg);
 
#pragma endregion Send
 
#pragma region Receive
 
protected:
  void ReceiveData(unsigned char bufferSize,
                   char* senderIpAddress,
                   unsigned int senderPort);
  void ReceiveData(unsigned char bufferSize, Participant* remoteParticipant);
 
  void SetupUDP(int localPort, const char* remoteIpAddress, int remotePort);
 
  void ReceiveUDP();
 
  virtual void Process(Participant* sender, ParticipantMsg* msg);
  virtual void Process(Participant* sender, NetworkIdMsg* msg);
  virtual void Process(Participant* sender, InvestigateMsg* msg);
  virtual void Process(Participant* sender, ThingMsg* msg);
  virtual void Process(Participant* sender, NameMsg* msg);
  virtual void Process(Participant* sender, ModelUrlMsg* msg);
  virtual void Process(Participant* sender, PoseMsg* msg);
  virtual void Process(Participant* sender, BinaryMsg* msg);
 
#pragma endregion Receive
 
};
 
}  // namespace RoboidControl