WLED/wled00/fcn_declare.h

396 lines
13 KiB
C
Raw Normal View History

2021-03-25 20:00:08 +01:00
#ifndef WLED_FCN_DECLARE_H
#define WLED_FCN_DECLARE_H
/*
* All globally accessible functions are declared here
*/
//alexa.cpp
2023-01-12 20:35:34 +01:00
#ifndef WLED_DISABLE_ALEXA
2021-03-25 20:00:08 +01:00
void onAlexaChange(EspalexaDevice* dev);
void alexaInit();
void handleAlexa();
void onAlexaChange(EspalexaDevice* dev);
2023-01-12 20:35:34 +01:00
#endif
2021-03-25 20:00:08 +01:00
//blynk.cpp
#ifndef WLED_DISABLE_BLYNK
2021-03-25 20:00:08 +01:00
void initBlynk(const char* auth, const char* host, uint16_t port);
void handleBlynk();
void updateBlynk();
#endif
2021-03-25 20:00:08 +01:00
//button.cpp
2021-05-19 18:39:16 +02:00
void shortPressAction(uint8_t b=0);
void longPressAction(uint8_t b=0);
void doublePressAction(uint8_t b=0);
2021-05-19 18:39:16 +02:00
bool isButtonPressed(uint8_t b=0);
2021-03-25 20:00:08 +01:00
void handleButton();
void handleIO();
//cfg.cpp
bool deserializeConfig(JsonObject doc, bool fromFS = false);
void deserializeConfigFromFS();
2021-03-25 20:00:08 +01:00
bool deserializeConfigSec();
void serializeConfig();
void serializeConfigSec();
template<typename DestType>
bool getJsonValue(const JsonVariant& element, DestType& destination) {
if (element.isNull()) {
return false;
}
destination = element.as<DestType>();
return true;
}
template<typename DestType, typename DefaultType>
bool getJsonValue(const JsonVariant& element, DestType& destination, const DefaultType defaultValue) {
if(!getJsonValue(element, destination)) {
destination = defaultValue;
return false;
}
return true;
}
2021-03-25 20:00:08 +01:00
//colors.cpp
uint32_t color_blend(uint32_t,uint32_t,uint16_t,bool b16=false);
uint32_t color_add(uint32_t,uint32_t);
inline uint32_t colorFromRgbw(byte* rgbw) { return uint32_t((byte(rgbw[3]) << 24) | (byte(rgbw[0]) << 16) | (byte(rgbw[1]) << 8) | (byte(rgbw[2]))); }
2021-03-25 20:00:08 +01:00
void colorHStoRGB(uint16_t hue, byte sat, byte* rgb); //hue, sat to rgb
void colorKtoRGB(uint16_t kelvin, byte* rgb);
void colorCTtoRGB(uint16_t mired, byte* rgb); //white spectrum to rgb
void colorXYtoRGB(float x, float y, byte* rgb); // only defined if huesync disabled TODO
void colorRGBtoXY(byte* rgb, float* xy); // only defined if huesync disabled TODO
void colorFromDecOrHexString(byte* rgb, char* in);
bool colorFromHexString(byte* rgb, const char* in);
uint32_t colorBalanceFromKelvin(uint16_t kelvin, uint32_t rgb);
uint16_t approximateKelvinFromRGB(uint32_t rgb);
void setRandomColor(byte* rgb);
uint8_t gamma8_cal(uint8_t b, float gamma);
void calcGammaTable(float gamma);
uint8_t gamma8(uint8_t b);
uint32_t gamma32(uint32_t);
2021-03-25 20:00:08 +01:00
//dmx.cpp
void initDMX();
void handleDMX();
//e131.cpp
void handleE131Packet(e131_packet_t* p, IPAddress clientIP, byte protocol);
void handleArtnetPollReply(IPAddress ipAddress);
void prepareArtnetPollReply(ArtPollReply* reply);
void sendArtnetPollReply(ArtPollReply* reply, IPAddress ipAddress, uint16_t portAddress);
2021-03-25 20:00:08 +01:00
//file.cpp
bool handleFileRead(AsyncWebServerRequest*, String path);
bool writeObjectToFileUsingId(const char* file, uint16_t id, JsonDocument* content);
bool writeObjectToFile(const char* file, const char* key, JsonDocument* content);
bool readObjectFromFileUsingId(const char* file, uint16_t id, JsonDocument* dest);
bool readObjectFromFile(const char* file, const char* key, JsonDocument* dest);
void updateFSInfo();
void closeFile();
//hue.cpp
void handleHue();
void reconnectHue();
void onHueError(void* arg, AsyncClient* client, int8_t error);
void onHueConnect(void* arg, AsyncClient* client);
void sendHuePoll();
void onHueData(void* arg, AsyncClient* client, void *data, size_t len);
//improv.cpp
void handleImprovPacket();
void sendImprovStateResponse(uint8_t state, bool error = false);
void sendImprovInfoResponse();
void sendImprovRPCResponse(uint8_t commandId);
2021-03-25 20:00:08 +01:00
//ir.cpp
void applyRepeatActions();
byte relativeChange(byte property, int8_t amount, byte lowerBoundary = 0, byte higherBoundary = 0xFF);
2021-03-25 20:00:08 +01:00
void decodeIR(uint32_t code);
void decodeIR24(uint32_t code);
void decodeIR24OLD(uint32_t code);
void decodeIR24CT(uint32_t code);
void decodeIR40(uint32_t code);
void decodeIR44(uint32_t code);
void decodeIR21(uint32_t code);
void decodeIR6(uint32_t code);
void decodeIR9(uint32_t code);
2021-05-18 09:48:58 +02:00
void decodeIRJson(uint32_t code);
2021-03-25 20:00:08 +01:00
void initIR();
void handleIR();
//json.cpp
#include "ESPAsyncWebServer.h"
#include "src/dependencies/json/ArduinoJson-v6.h"
#include "src/dependencies/json/AsyncJson-v6.h"
#include "FX.h"
2021-06-10 02:52:20 +02:00
void deserializeSegment(JsonObject elem, byte it, byte presetId = 0);
bool deserializeState(JsonObject root, byte callMode = CALL_MODE_DIRECT_CHANGE, byte presetId = 0);
void serializeSegment(JsonObject& root, Segment& seg, byte id, bool forPreset = false, bool segmentBounds = true);
2022-10-08 18:25:51 +02:00
void serializeState(JsonObject root, bool forPreset = false, bool includeBri = true, bool segmentBounds = true, bool selectedSegmentsOnly = false);
2021-03-25 20:00:08 +01:00
void serializeInfo(JsonObject root);
void serializeModeNames(JsonArray arr, const char *qstring);
void serializeModeData(JsonObject root);
void serveJson(AsyncWebServerRequest* request);
#ifdef WLED_ENABLE_JSONLIVE
2021-03-25 20:00:08 +01:00
bool serveLiveLeds(AsyncWebServerRequest* request, uint32_t wsClient = 0);
#endif
2021-03-25 20:00:08 +01:00
//led.cpp
void setValuesFromSegment(uint8_t s);
void setValuesFromMainSeg();
void setValuesFromFirstSelectedSeg();
2021-03-25 20:00:08 +01:00
void resetTimebase();
void toggleOnOff();
void applyBri();
void applyFinalBri();
void applyValuesToSelectedSegs();
void colorUpdated(byte callMode);
void stateUpdated(byte callMode);
2021-03-25 20:00:08 +01:00
void updateInterfaces(uint8_t callMode);
void handleTransitions();
void handleNightlight();
byte scaledBri(byte in);
//lx_parser.cpp
bool parseLx(int lxValue, byte* rgbw);
void parseLxJson(int lxValue, byte segId, bool secondary);
//mqtt.cpp
bool initMqtt();
void publishMqtt();
//ntp.cpp
2021-05-27 00:09:52 +02:00
void handleTime();
2021-03-25 20:00:08 +01:00
void handleNetworkTime();
void sendNTPPacket();
2023-01-06 09:24:29 +01:00
bool checkNTPResponse();
2021-03-25 20:00:08 +01:00
void updateLocalTime();
void getTimeString(char* out);
bool checkCountdown();
void setCountdown();
byte weekdayMondayFirst();
void checkTimers();
void calculateSunriseAndSunset();
2021-05-27 02:02:02 +02:00
void setTimeFromAPI(uint32_t timein);
2021-03-25 20:00:08 +01:00
//overlay.cpp
void handleOverlayDraw();
void _overlayAnalogCountdown();
void _overlayAnalogClock();
//playlist.cpp
void shufflePlaylist();
void unloadPlaylist();
int16_t loadPlaylist(JsonObject playlistObject, byte presetId = 0);
2021-03-25 20:00:08 +01:00
void handlePlaylist();
2022-10-08 18:25:51 +02:00
void serializePlaylist(JsonObject obj);
2021-03-25 20:00:08 +01:00
//presets.cpp
void initPresetsFile();
void handlePresets();
bool applyPreset(byte index, byte callMode = CALL_MODE_DIRECT_CHANGE);
2021-10-04 20:22:04 +02:00
inline bool applyTemporaryPreset() {return applyPreset(255);};
void savePreset(byte index, const char* pname = nullptr, JsonObject saveobj = JsonObject());
inline void saveTemporaryPreset() {savePreset(255);};
2021-03-25 20:00:08 +01:00
void deletePreset(byte index);
2023-01-06 09:24:29 +01:00
bool getPresetName(byte index, String& name);
2021-03-25 20:00:08 +01:00
//set.cpp
bool isAsterisksOnly(const char* str, byte maxLen);
void handleSettingsSet(AsyncWebServerRequest *request, byte subPage);
bool handleSet(AsyncWebServerRequest *request, const String& req, bool apply=true);
//udp.cpp
void notify(byte callMode, bool followUp=false);
uint8_t realtimeBroadcast(uint8_t type, IPAddress client, uint16_t length, byte *buffer, uint8_t bri=255, bool isRGBW=false);
2021-03-25 20:00:08 +01:00
void realtimeLock(uint32_t timeoutMs, byte md = REALTIME_MODE_GENERIC);
void exitRealtime();
2021-03-25 20:00:08 +01:00
void handleNotifications();
void setRealtimePixel(uint16_t i, byte r, byte g, byte b, byte w);
void refreshNodeList();
void sendSysInfoUDP();
//network.cpp
int getSignalQuality(int rssi);
void WiFiEvent(WiFiEvent_t event);
2021-03-25 20:00:08 +01:00
//um_manager.cpp
typedef enum UM_Data_Types {
UMT_BYTE = 0,
UMT_UINT16,
UMT_INT16,
UMT_UINT32,
UMT_INT32,
UMT_FLOAT,
UMT_DOUBLE,
UMT_BYTE_ARR,
UMT_UINT16_ARR,
UMT_INT16_ARR,
UMT_UINT32_ARR,
UMT_INT32_ARR,
UMT_FLOAT_ARR,
UMT_DOUBLE_ARR
} um_types_t;
2022-06-08 21:14:01 +02:00
typedef struct UM_Exchange_Data {
// should just use: size_t arr_size, void **arr_ptr, byte *ptr_type
size_t u_size; // size of u_data array
um_types_t *u_type; // array of data types
void **u_data; // array of pointers to data
2022-06-08 21:14:01 +02:00
UM_Exchange_Data() {
u_size = 0;
u_type = nullptr;
u_data = nullptr;
2022-06-08 21:14:01 +02:00
}
~UM_Exchange_Data() {
if (u_type) delete[] u_type;
if (u_data) delete[] u_data;
2022-06-08 21:14:01 +02:00
}
} um_data_t;
const unsigned int um_data_size = sizeof(um_data_t); // 12 bytes
2022-06-08 21:14:01 +02:00
2021-03-25 20:00:08 +01:00
class Usermod {
2022-06-08 21:14:01 +02:00
protected:
um_data_t *um_data; // um_data should be allocated using new in (derived) Usermod's setup() or constructor
2021-03-25 20:00:08 +01:00
public:
2022-06-08 21:14:01 +02:00
Usermod() { um_data = nullptr; }
virtual ~Usermod() { if (um_data) delete um_data; }
2022-06-11 18:55:23 +02:00
virtual void setup() = 0; // pure virtual, has to be overriden
virtual void loop() = 0; // pure virtual, has to be overriden
2021-09-30 05:23:32 +02:00
virtual void handleOverlayDraw() {}
2021-10-17 17:14:55 +02:00
virtual bool handleButton(uint8_t b) { return false; }
2022-06-08 21:14:01 +02:00
virtual bool getUMData(um_data_t **data) { if (data) *data = nullptr; return false; };
2021-03-25 20:00:08 +01:00
virtual void connected() {}
2022-06-11 18:55:23 +02:00
virtual void appendConfigData() {}
2021-03-25 20:00:08 +01:00
virtual void addToJsonState(JsonObject& obj) {}
virtual void addToJsonInfo(JsonObject& obj) {}
virtual void readFromJsonState(JsonObject& obj) {}
virtual void addToConfig(JsonObject& obj) {}
virtual bool readFromConfig(JsonObject& obj) { return true; } // Note as of 2021-06 readFromConfig() now needs to return a bool, see usermod_v2_example.h
virtual void onMqttConnect(bool sessionPresent) {}
virtual bool onMqttMessage(char* topic, char* payload) { return false; }
virtual void onUpdateBegin(bool) {}
2021-03-25 20:00:08 +01:00
virtual uint16_t getId() {return USERMOD_ID_UNSPECIFIED;}
};
class UsermodManager {
2021-03-25 20:00:08 +01:00
private:
Usermod* ums[WLED_MAX_USERMODS];
byte numMods = 0;
public:
void loop();
2021-09-30 05:23:32 +02:00
void handleOverlayDraw();
2021-10-17 17:14:55 +02:00
bool handleButton(uint8_t b);
2022-06-08 21:14:01 +02:00
bool getUMData(um_data_t **um_data, uint8_t mod_id = USERMOD_ID_RESERVED); // USERMOD_ID_RESERVED will poll all usermods
2021-03-25 20:00:08 +01:00
void setup();
void connected();
2022-06-11 18:55:23 +02:00
void appendConfigData();
2021-03-25 20:00:08 +01:00
void addToJsonState(JsonObject& obj);
void addToJsonInfo(JsonObject& obj);
void readFromJsonState(JsonObject& obj);
void addToConfig(JsonObject& obj);
2021-06-25 01:26:15 +02:00
bool readFromConfig(JsonObject& obj);
void onMqttConnect(bool sessionPresent);
bool onMqttMessage(char* topic, char* payload);
void onUpdateBegin(bool);
2021-03-25 20:00:08 +01:00
bool add(Usermod* um);
Usermod* lookup(uint16_t mod_id);
byte getModCount() {return numMods;};
2021-03-25 20:00:08 +01:00
};
//usermods_list.cpp
void registerUsermods();
//usermod.cpp
void userSetup();
void userConnected();
void userLoop();
//util.cpp
int getNumVal(const String* req, uint16_t pos);
void parseNumber(const char* str, byte* val, byte minv=0, byte maxv=255);
bool getVal(JsonVariant elem, byte* val, byte minv=0, byte maxv=255);
bool updateVal(const char* req, const char* key, byte* val, byte minv=0, byte maxv=255);
bool oappend(const char* txt); // append new c string to temp buffer efficiently
bool oappendi(int i); // append new number to temp buffer efficiently
void sappend(char stype, const char* key, int val);
void sappends(char stype, const char* key, char* val);
void prepareHostname(char* hostname);
bool isAsterisksOnly(const char* str, byte maxLen);
2021-11-14 16:56:34 +01:00
bool requestJSONBufferLock(uint8_t module=255);
void releaseJSONBufferLock();
uint8_t extractModeName(uint8_t mode, const char *src, char *dest, uint8_t maxLen);
2022-07-23 22:00:19 +02:00
uint8_t extractModeSlider(uint8_t mode, uint8_t slider, char *dest, uint8_t maxLen, uint8_t *var = nullptr);
int16_t extractModeDefaults(uint8_t mode, const char *segVar);
uint16_t crc16(const unsigned char* data_p, size_t length);
um_data_t* simulateSound(uint8_t simulationId);
void enumerateLedmaps();
#ifdef WLED_ADD_EEPROM_SUPPORT
2021-03-25 20:00:08 +01:00
//wled_eeprom.cpp
void applyMacro(byte index);
void deEEP();
void deEEPSettings();
void clearEEPROM();
#endif
2021-03-25 20:00:08 +01:00
//wled_math.cpp
#ifndef WLED_USE_REAL_MATH
2022-02-10 16:09:16 +01:00
template <typename T> T atan_t(T x);
float cos_t(float phi);
float sin_t(float x);
float tan_t(float x);
float acos_t(float x);
float asin_t(float x);
float floor_t(float x);
float fmod_t(float num, float denom);
#else
#include <math.h>
#define sin_t sin
#define cos_t cos
#define tan_t tan
#define asin_t asin
#define acos_t acos
#define atan_t atan
#define fmod_t fmod
#define floor_t floor
#endif
2021-03-25 20:00:08 +01:00
//wled_serial.cpp
void handleSerial();
2022-02-01 20:02:46 +01:00
void updateBaudRate(uint32_t rate);
2021-03-25 20:00:08 +01:00
//wled_server.cpp
bool isIp(String str);
2022-03-01 23:37:28 +01:00
void createEditHandler(bool enable);
2021-03-25 20:00:08 +01:00
bool captivePortal(AsyncWebServerRequest *request);
void initServer();
void serveIndexOrWelcome(AsyncWebServerRequest *request);
void serveIndex(AsyncWebServerRequest* request);
String msgProcessor(const String& var);
void serveMessage(AsyncWebServerRequest* request, uint16_t code, const String& headl, const String& subl="", byte optionT=255);
String settingsProcessor(const String& var);
String dmxProcessor(const String& var);
void serveSettings(AsyncWebServerRequest* request, bool post = false);
void serveSettingsJS(AsyncWebServerRequest* request);
2021-03-25 20:00:08 +01:00
//ws.cpp
void handleWs();
void wsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len);
void sendDataWs(AsyncWebSocketClient * client = nullptr);
//xml.cpp
void XML_response(AsyncWebServerRequest *request, char* dest = nullptr);
void URL_response(AsyncWebServerRequest *request);
void getSettingsJS(byte subPage, char* dest);
#endif