andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-06 07:49:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

test on Windows

Browse Source
This commit is contained in:
proddy
2024-08-01 22:12:33 +02:00
parent dac033e962
commit 4ec5739b67
7 changed files with 138 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
lib/espMqttClient/src/Helpers.h
View File

@@ -9,41 +9,51 @@ the LICENSE file.
#pragma once #pragma once
#if defined(ARDUINO_ARCH_ESP32) #if defined(ARDUINO_ARCH_ESP32)
#include <Arduino.h> // millis(), ESP.getFreeHeap(); #include <Arduino.h> // millis(), ESP.getFreeHeap();
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "esp_task_wdt.h" #include "esp_task_wdt.h"
#define EMC_SEMAPHORE_TAKE() xSemaphoreTake(_xSemaphore, portMAX_DELAY) #define EMC_SEMAPHORE_TAKE() xSemaphoreTake(_xSemaphore, portMAX_DELAY)
#define EMC_SEMAPHORE_GIVE() xSemaphoreGive(_xSemaphore) #define EMC_SEMAPHORE_GIVE() xSemaphoreGive(_xSemaphore)
#define EMC_GET_FREE_MEMORY() std::max(ESP.getMaxAllocHeap(), ESP.getMaxAllocPsram()) #define EMC_GET_FREE_MEMORY() std::max(ESP.getMaxAllocHeap(), ESP.getMaxAllocPsram())
#define EMC_YIELD() vTaskDelay(1) #define EMC_YIELD() vTaskDelay(1)
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "esp32%06llx", ESP.getEfuseMac()); #define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "esp32%06llx", ESP.getEfuseMac());
#elif defined(ARDUINO_ARCH_ESP8266) #elif defined(ARDUINO_ARCH_ESP8266)
#include <Arduino.h> // millis(), ESP.getFreeHeap(); #include <Arduino.h> // millis(), ESP.getFreeHeap();
#if EMC_ESP8266_MULTITHREADING #if EMC_ESP8266_MULTITHREADING
// This lib doesn't run use multithreading on ESP8266 // This lib doesn't run use multithreading on ESP8266
// _xSemaphore defined as std::atomic<bool> // _xSemaphore defined as std::atomic<bool>
#define EMC_SEMAPHORE_TAKE() while (_xSemaphore) { /*ESP.wdtFeed();*/ } _xSemaphore = true #define EMC_SEMAPHORE_TAKE() \
#define EMC_SEMAPHORE_GIVE() _xSemaphore = false while (_xSemaphore) { /*ESP.wdtFeed();*/ \
#else } \
#define EMC_SEMAPHORE_TAKE() _xSemaphore = true
#define EMC_SEMAPHORE_GIVE() #define EMC_SEMAPHORE_GIVE() _xSemaphore = false
#endif
#define EMC_GET_FREE_MEMORY() ESP.getMaxFreeBlockSize()
// no need to yield for ESP8266, the Arduino framework does this internally
// yielding in async is forbidden (will crash)
#define EMC_YIELD()
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "esp8266%06x", ESP.getChipId());
#elif defined(__linux__)
#include <chrono> // NOLINT [build/c++11]
#include <thread> // NOLINT [build/c++11] for yield()
#define millis() std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count()
#define EMC_GET_FREE_MEMORY() 1000000000
#define EMC_YIELD() std::this_thread::yield()
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "Client%04d%04d%04d", rand()%10000, rand()%10000, rand()%10000)
#include <mutex> // NOLINT [build/c++11]
#define EMC_SEMAPHORE_TAKE() mtx.lock();
#define EMC_SEMAPHORE_GIVE() mtx.unlock();
#else #else
#error Target platform not supported #define EMC_SEMAPHORE_TAKE()
#define EMC_SEMAPHORE_GIVE()
#endif
#define EMC_GET_FREE_MEMORY() ESP.getMaxFreeBlockSize()
// no need to yield for ESP8266, the Arduino framework does this internally
// yielding in async is forbidden (will crash)
#define EMC_YIELD()
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "esp8266%06x", ESP.getChipId());
#elif defined(__linux__)
#include <chrono> // NOLINT [build/c++11]
#include <thread> // NOLINT [build/c++11] for yield()
#define millis() std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count()
#define EMC_GET_FREE_MEMORY() 1000000000
#define EMC_YIELD() std::this_thread::yield()
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "Client%04d%04d%04d", rand() % 10000, rand() % 10000, rand() % 10000)
#include <mutex> // NOLINT [build/c++11]
#define EMC_SEMAPHORE_TAKE() mtx.lock();
#define EMC_SEMAPHORE_GIVE() mtx.unlock();
#elif defined(_WIN32)
#include <Arduino.h>
#define EMC_SEMAPHORE_TAKE()
#define EMC_SEMAPHORE_GIVE()
#define EMC_YIELD()
#define EMC_GET_FREE_MEMORY() 1000
#define EMC_GENERATE_CLIENTID(x)
#else
#error Target platform not supported
#endif #endif

16
lib/espMqttClient/src/Transport/ClientPosixIPAddress.cpp
View File

@@ -6,27 +6,27 @@ For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file. the LICENSE file.
*/ */
#if defined(__linux__) #if defined(__linux__) || defined(_WIN32)
#include "ClientPosixIPAddress.h" #include "ClientPosixIPAddress.h"
IPAddress::IPAddress() IPAddress::IPAddress()
: _address(0) { : _address(0) {
// empty // empty
} }
IPAddress::IPAddress(uint8_t p0, uint8_t p1, uint8_t p2, uint8_t p3) IPAddress::IPAddress(uint8_t p0, uint8_t p1, uint8_t p2, uint8_t p3)
: _address(0) { : _address(0) {
_address = (uint32_t)p0 << 24 | (uint32_t)p1 << 16 | (uint32_t)p2 << 8 | p3; _address = (uint32_t)p0 << 24 | (uint32_t)p1 << 16 | (uint32_t)p2 << 8 | p3;
} }
IPAddress::IPAddress(uint32_t address) IPAddress::IPAddress(uint32_t address)
: _address(address) { : _address(address) {
// empty // empty
} }
IPAddress::operator uint32_t() { IPAddress::operator uint32_t() {
return _address; return _address;
} }
#endif #endif

5
lib/espMqttClient/src/espMqttClient.cpp
View File

@@ -120,4 +120,9 @@ espMqttClient::espMqttClient()
, _client() { , _client() {
_transport = &_client; _transport = &_client;
} }
#elif defined(_WIN32)
// Windows
espMqttClient::espMqttClient()
: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO) {
}
#endif #endif

75
lib/espMqttClient/src/espMqttClient.h
View File

@@ -22,59 +22,64 @@ the LICENSE file.
#if defined(ARDUINO_ARCH_ESP8266) #if defined(ARDUINO_ARCH_ESP8266)
class espMqttClient : public MqttClientSetup<espMqttClient> { class espMqttClient : public MqttClientSetup<espMqttClient> {
public: public:
espMqttClient(); espMqttClient();
protected: protected:
espMqttClientInternals::ClientSync _client; espMqttClientInternals::ClientSync _client;
}; };
class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> { class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
public: public:
espMqttClientSecure(); espMqttClientSecure();
espMqttClientSecure& setInsecure(); espMqttClientSecure & setInsecure();
espMqttClientSecure& setFingerprint(const uint8_t fingerprint[20]); espMqttClientSecure & setFingerprint(const uint8_t fingerprint[20]);
espMqttClientSecure& setTrustAnchors(const X509List *ta); espMqttClientSecure & setTrustAnchors(const X509List * ta);
espMqttClientSecure& setClientRSACert(const X509List *cert, const PrivateKey *sk); espMqttClientSecure & setClientRSACert(const X509List * cert, const PrivateKey * sk);
espMqttClientSecure& setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type); espMqttClientSecure & setClientECCert(const X509List * cert, const PrivateKey * sk, unsigned allowed_usages, unsigned cert_issuer_key_type);
espMqttClientSecure& setCertStore(CertStoreBase *certStore); espMqttClientSecure & setCertStore(CertStoreBase * certStore);
protected: protected:
espMqttClientInternals::ClientSecureSync _client; espMqttClientInternals::ClientSecureSync _client;
}; };
#endif #endif
#if defined(ARDUINO_ARCH_ESP32) #if defined(ARDUINO_ARCH_ESP32)
class espMqttClient : public MqttClientSetup<espMqttClient> { class espMqttClient : public MqttClientSetup<espMqttClient> {
public: public:
explicit espMqttClient(espMqttClientTypes::UseInternalTask useInternalTask); explicit espMqttClient(espMqttClientTypes::UseInternalTask useInternalTask);
explicit espMqttClient(uint8_t priority = 1, uint8_t core = 1); explicit espMqttClient(uint8_t priority = 1, uint8_t core = 1);
protected: protected:
espMqttClientInternals::ClientSync _client; espMqttClientInternals::ClientSync _client;
}; };
class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> { class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
public: public:
explicit espMqttClientSecure(espMqttClientTypes::UseInternalTask useInternalTask); explicit espMqttClientSecure(espMqttClientTypes::UseInternalTask useInternalTask);
explicit espMqttClientSecure(uint8_t priority = 1, uint8_t core = 1); explicit espMqttClientSecure(uint8_t priority = 1, uint8_t core = 1);
espMqttClientSecure& setInsecure(); espMqttClientSecure & setInsecure();
espMqttClientSecure& setCACert(const char* rootCA); espMqttClientSecure & setCACert(const char * rootCA);
espMqttClientSecure& setCertificate(const char* clientCa); espMqttClientSecure & setCertificate(const char * clientCa);
espMqttClientSecure& setPrivateKey(const char* privateKey); espMqttClientSecure & setPrivateKey(const char * privateKey);
espMqttClientSecure& setPreSharedKey(const char* pskIdent, const char* psKey); espMqttClientSecure & setPreSharedKey(const char * pskIdent, const char * psKey);
protected: protected:
espMqttClientInternals::ClientSecureSync _client; espMqttClientInternals::ClientSecureSync _client;
}; };
#endif
#if defined(__linux__) #elif defined(__linux__)
class espMqttClient : public MqttClientSetup<espMqttClient> { class espMqttClient : public MqttClientSetup<espMqttClient> {
public: public:
espMqttClient(); espMqttClient();
protected: protected:
espMqttClientInternals::ClientPosix _client; espMqttClientInternals::ClientPosix _client;
}; };
#elif defined(_WIN32)
class espMqttClient : public MqttClientSetup<espMqttClient> {
public:
espMqttClient();
};
#endif #endif

19
lib_standalone/Arduino.cpp
View File

@@ -17,7 +17,6 @@
#ifdef EMSESP_STANDALONE #ifdef EMSESP_STANDALONE
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <iostream> #include <iostream>
@@ -57,8 +56,11 @@ void ClientLoop(void * arg) {
} }
} }
#ifndef UNITY_INCLUDE_CONFIG_H
// we have another main that overrides this when using Unity in test_api.cpp
int main(int argc __attribute__((unused)), char * argv[] __attribute__((unused))) { int main(int argc __attribute__((unused)), char * argv[] __attribute__((unused))) {
setup(); setup();
std::thread t = std::thread(ClientLoop, nullptr); std::thread t = std::thread(ClientLoop, nullptr);
// while (millis() <= 10 * 1000) { // while (millis() <= 10 * 1000) {
while (1) { while (1) {
@@ -69,10 +71,7 @@ int main(int argc __attribute__((unused)), char * argv[] __attribute__((unused))
t.join(); t.join();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
#endif
// unsigned long millis() {
// return __millis;
// }
int64_t esp_timer_get_time() { int64_t esp_timer_get_time() {
return __millis; return __millis;
@@ -139,13 +138,13 @@ uint32_t analogReadMilliVolts(uint8_t pin) {
return 0; return 0;
} }
void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation){}; void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation) {};
void analogSetAttenuation(adc_attenuation_t attenuation){}; void analogSetAttenuation(adc_attenuation_t attenuation) {};
void dacWrite(uint8_t pin, uint8_t value){}; void dacWrite(uint8_t pin, uint8_t value) {};
double ledcSetup(uint8_t chan, double freq, uint8_t bit_num) { double ledcSetup(uint8_t chan, double freq, uint8_t bit_num) {
return 0; return 0;
}; };
void ledcAttachPin(uint8_t pin, uint8_t chan){}; void ledcAttachPin(uint8_t pin, uint8_t chan) {};
void ledcWrite(uint8_t chan, uint32_t duty){}; void ledcWrite(uint8_t chan, uint32_t duty) {};
#endif #endif

46
lib_standalone/Arduino.h
View File

@@ -32,6 +32,10 @@
#include <iostream> #include <iostream>
#include "WString.h" #include "WString.h"
#include "Network.h"
extern ETHClass ETH;
extern WiFiClass WiFi;
typedef double double_t; typedef double double_t;
@@ -86,6 +90,21 @@ int vsnprintf_P(char * str, size_t size, const char * format, va_list ap);
#define pgm_read_float(addr) (*(const float *)(addr)) #define pgm_read_float(addr) (*(const float *)(addr))
#define pgm_read_ptr(addr) (*(const void **)(addr)) #define pgm_read_ptr(addr) (*(const void **)(addr))
// #if defined(__linux__)
#include <chrono> // NOLINT [build/c++11]
#include <thread> // NOLINT [build/c++11] for yield()
#define millis() std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count()
// #endif
int64_t esp_timer_get_time();
void delay(unsigned long millis);
void yield(void);
void setup(void);
void loop(void);
class Print; class Print;
class NativeConsole : public Stream { class NativeConsole : public Stream {
@@ -94,6 +113,11 @@ class NativeConsole : public Stream {
} }
int available() override { int available() override {
#if defined(_WIN32)
// added for EMS-ESP
return 1;
#else
if (peek_ != -1) if (peek_ != -1)
return 1; return 1;
@@ -107,6 +131,7 @@ class NativeConsole : public Stream {
timeout.tv_usec = 1000; timeout.tv_usec = 1000;
return ::select(STDIN_FILENO + 1, &rfds, NULL, NULL, &timeout) > 0 ? 1 : 0; return ::select(STDIN_FILENO + 1, &rfds, NULL, NULL, &timeout) > 0 ? 1 : 0;
#endif
} }
int read() override { int read() override {
@@ -163,27 +188,6 @@ class NativeConsole : public Stream {
int peek_ = -1; int peek_ = -1;
}; };
#include "Network.h"
extern NativeConsole Serial; extern NativeConsole Serial;
extern ETHClass ETH;
extern WiFiClass WiFi;
// unsigned long millis();
#if defined(__linux__)
#include <chrono> // NOLINT [build/c++11]
#include <thread> // NOLINT [build/c++11] for yield()
#define millis() std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count()
#endif
int64_t esp_timer_get_time();
void delay(unsigned long millis);
void yield(void);
void setup(void);
void loop(void);
#endif #endif

7
lib_standalone/Print.h
View File

@@ -86,7 +86,12 @@ class Print {
return print(str); return print(str);
} }
size_t println() { size_t println() {
// added for EMS-ESP
#if defined(_WIN32)
return print("\n");
#else
return print("\r\n"); return print("\r\n");
#endif
} }
size_t println(const char * data) { size_t println(const char * data) {
return print(data) + println(); return print(data) + println();
@@ -106,7 +111,7 @@ class Print {
size_t println(unsigned long value) { size_t println(unsigned long value) {
return print(std::to_string(value).c_str()) + println(); return print(std::to_string(value).c_str()) + println();
} }
virtual void flush(){}; virtual void flush() {};
private: private:
int err_{0}; int err_{0};