aaribaud/ESPSomfy-RTS
0
0
Fork 0
mirror of https://github.com/rstrouse/ESPSomfy-RTS.git synced 2025-12-12 18:42:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Initial commit

Browse source
This commit is contained in:
Robert Strouse 2023-01-09 18:15:30 -08:00
commit ee367e7111
28 changed files with 53359 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

172
SSDP.h Normal file
View file

@ -0,0 +1,172 @@
#ifndef SSDP_h
#define SSDP_h
#include <Arduino.h>
#include <WiFi.h>
#include <AsyncUDP.h>
#define SSDP_UUID_SIZE 42
#define SSDP_SCHEMA_URL_SIZE 64
#define SSDP_DEVICE_TYPE_SIZE 64
#define SSDP_FRIENDLY_NAME_SIZE 64
#define SSDP_SERIAL_NUMBER_SIZE 37
#define SSDP_PRESENTATION_URL_SIZE 64
#define SSDP_MODEL_NAME_SIZE 64
#define SSDP_MODEL_URL_SIZE 64
#define SSDP_MODEL_VERSION_SIZE 32
#define SSDP_MANUFACTURER_SIZE 64
#define SSDP_MANUFACTURER_URL_SIZE 64
#define SSDP_INTERVAL_SECONDS 1800
#define SSDP_MULTICAST_TTL 2
#define SSDP_HTTP_PORT 80
#define SSDP_CHILD_DEVICES 0
#define SSDP_QUEUE_SIZE 5
//#define DEBUG_SSDP Serial
//#define DEBUG_SSDP_PACKET Serial
typedef enum {
NONE,
SEARCH,
NOTIFY
} ssdp_method_t;
#define SSDP_FIELD_LEN 128
#define SSDP_LOCATION_LEN 256
typedef enum {
UNKNOWN,
MULTICAST,
UNICAST
} ssdp_req_types_t;
typedef struct ssdp_packet_t {
bool pending;
unsigned long recvd;
ssdp_method_t method;
char req [SSDP_FIELD_LEN];
char st [SSDP_FIELD_LEN];
char man [SSDP_FIELD_LEN];
char agent [SSDP_FIELD_LEN];
char host [SSDP_LOCATION_LEN];
uint8_t mx;
ssdp_req_types_t type;
bool valid;
};
class UPNPDeviceType {
char m_usn[SSDP_MANUFACTURER_URL_SIZE];
public:
UPNPDeviceType();
UPNPDeviceType(const char *deviceType);
UPNPDeviceType(const String& deviceType) { UPNPDeviceType(deviceType.c_str()); }
UPNPDeviceType(const String& deviceType, const String& uuid);
UPNPDeviceType(const char *deviceType, const char *uuid, const char *friendlyName);
UPNPDeviceType(const char *deviceType, const char *uuid);
UPNPDeviceType(const String& deviceType, const String& uuid, const String& friendlyName) { UPNPDeviceType(deviceType.c_str(), uuid.c_str(), friendlyName.c_str()); }
unsigned long lastNotified;
char schemaURL[SSDP_SCHEMA_URL_SIZE];
char uuid[SSDP_UUID_SIZE];
char deviceType[SSDP_DEVICE_TYPE_SIZE];
char friendlyName[SSDP_FRIENDLY_NAME_SIZE];
char serialNumber[SSDP_SERIAL_NUMBER_SIZE];
char presentationURL[SSDP_PRESENTATION_URL_SIZE];
char manufacturer[SSDP_MANUFACTURER_SIZE];
char manufacturerURL[SSDP_MANUFACTURER_URL_SIZE];
char modelName[SSDP_MODEL_NAME_SIZE];
char modelURL[SSDP_MODEL_URL_SIZE];
char modelNumber[SSDP_MODEL_VERSION_SIZE];
bool isActive;
void setSchemaURL(const char *url);
void setDeviceType(const char *dtype);
void setUUID(const char *id);
void setName(const char *name);
void setURL(const char *url);
void setSerialNumber(const char *sn);
void setSerialNumber(const uint32_t sn);
void setModelName(const char *name);
void setModelNumber(const char *num);
void setModelURL(const char *url);
void setManufacturer(const char *name);
void setManufacturerURL(const char *url);
//char *getUSN();
char *getUSN(const char *st);
void setChipId(uint32_t chipId);
};
typedef struct ssdp_response_t {
bool waiting;
IPAddress address;
uint16_t port;
UPNPDeviceType *dev;
bool sendUUID;
unsigned long sendTime;
char st[SSDP_DEVICE_TYPE_SIZE];
};
class SSDPClass {
uint8_t m_cdeviceTypes = SSDP_CHILD_DEVICES + 1;
protected:
ssdp_response_t sendQueue[SSDP_QUEUE_SIZE];
//ssdp_response_t sendQueue[SSDP_QUEUE_SIZE];
//void _send(ssdp_method_t method, UPNPDeviceType *dev, bool useUUID);
//void _sendAll(ssdp_method_t method, bool useUUID);
void _startTimer();
void _stopTimer();
void _sendNotify();
void _sendNotify(UPNPDeviceType *d);
void _sendNotify(UPNPDeviceType *d, bool root);
void _sendNotify(const char *);
void _sendByeBye();
void _sendByeBye(UPNPDeviceType *d);
void _sendByeBye(UPNPDeviceType *d, bool root);
void _sendByeBye(const char *);
void _sendQueuedResponses();
void _sendResponse(IPAddress addr, uint16_t port, UPNPDeviceType *d, char *st, bool sendUUID);
AsyncUDP _server;
hw_timer_t* _timer = nullptr;
uint16_t _port = SSDP_HTTP_PORT;
uint8_t _ttl = SSDP_MULTICAST_TTL;
uint32_t _interval = SSDP_INTERVAL_SECONDS;
void _processRequest(AsyncUDPPacket &p);
void _parsePacket(ssdp_packet_t *pkt, AsyncUDPPacket &p);
void _printPacket(ssdp_packet_t *pkt);
bool _startsWith(const char* pre, const char* str);
void _addToSendQueue(IPAddress addr, uint16_t port, UPNPDeviceType *d, char *st, uint8_t sec, bool sendUUID);
public:
SSDPClass();
~SSDPClass();
UPNPDeviceType deviceTypes[SSDP_CHILD_DEVICES + 1];
bool begin();
void loop();
void end();
bool isStarted = false;
IPAddress localIP();
UPNPDeviceType* getDeviceTypes(uint8_t ndx);
UPNPDeviceType* getDeviceType(uint8_t ndx);
UPNPDeviceType* findDeviceByType(char *devType);
UPNPDeviceType* findDeviceByUUID(char *uuid);
void setHTTPPort(uint16_t port);
void setTTL(uint8_t ttl);
void setInterval(uint32_t interval);
void schema(WiFiClient client) { schema((Print&)std::ref(client)); }
void schema(Print &print);
void setDeviceType(uint8_t ndx, UPNPDeviceType *dt);
void setDeviceType(uint8_t ndx, const String& type) { setDeviceType(ndx, type.c_str()); }
void setDeviceType(uint8_t ndx, const char *type);
void setUUID(uint8_t ndx, const char *uuid);
void setUUID(uint8_t ndx, const char *prefix, uint32_t id);
void setName(uint8_t ndx, const char *name);
void setURL(uint8_t ndx, const char *url);
void setSchemaURL(uint8_t ndx, const char *url);
void setSerialNumber(uint8_t ndx, const char *serialNumber);
void setModelName(uint8_t ndx, const char *name);
void setModelNumber(uint8_t ndx, const char *num);
void setModelURL(uint8_t ndx, const char *url);
void setManufacturer(uint8_t ndx, const char *name);
void setManufacturerURL(uint8_t ndx, const char *url);
void setActive(uint8_t ndx, bool bActive);
void setChipId(uint8_t ndx, uint32_t chipId);
};
#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SSSDP)
extern SSDPClass SSDP;
#endif
#endif