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

use pio native to build standalone

Browse Source
This commit is contained in:
Proddy
2023-01-06 14:14:03 +01:00
parent ad2dbd6fc5
commit fbf799e4c4
13 changed files with 484 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib_standalone/Arduino.cpp
View File

@@ -15,6 +15,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef EMSESP_STANDALONE
#include <Arduino.h>
#include <stdio.h>
#include <stdarg.h>
@@ -125,3 +127,5 @@ double ledcSetup(uint8_t chan, double freq, uint8_t bit_num) {
};
void ledcAttachPin(uint8_t pin, uint8_t chan){};
void ledcWrite(uint8_t chan, uint32_t duty){};
#endif

202
lib_standalone/Arduino.h
View File

@@ -24,9 +24,13 @@
#include <cstdint>
#include <cstring>
#include <string>
#include <algorithm> // for count_if
#include "WString.h"
#include <Print.h>
#include <Printable.h>
#include <Stream.h>
#include <WString.h>
#include <iostream>
@@ -86,129 +90,83 @@ int vsnprintf_P(char * str, size_t size, const char * format, va_list ap);
class Print;
class Printable {
public:
virtual size_t printTo(Print & print) const = 0;
class NativeConsole: public Stream {
public:
void begin(unsigned long baud __attribute__((unused))) {
}
int available() override {
if (peek_ != -1)
return 1;
struct timeval timeout;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(STDIN_FILENO, &rfds);
timeout.tv_sec = 0;
timeout.tv_usec = 1000;
return ::select(STDIN_FILENO + 1, &rfds, NULL, NULL, &timeout) > 0 ? 1 : 0;
}
int read() override {
if (peek_ != -1) {
uint8_t c = peek_;
peek_ = -1;
return c;
}
if (available() > 0) {
uint8_t c;
int ret = ::read(STDIN_FILENO, &c, 1);
if (ret == 0) {
/* Ctrl+D */
return '\x04';
} else if (ret == 1) {
/* Remap Ctrl+Z to Ctrl-\ */
if (c == '\x1A')
c = '\x1C';
return c;
} else {
exit(1);
}
}
return -1;
}
int peek() override {
if (peek_ == -1)
peek_ = read();
return peek_;
}
size_t write(uint8_t c) override {
if (::write(STDOUT_FILENO, &c, 1) == 1) {
return 1;
} else {
exit(1);
}
}
size_t write(const uint8_t *buffer, size_t size) {
if (::write(STDOUT_FILENO, buffer, size) == (ssize_t)size) {
return size;
} else {
exit(1);
}
}
private:
int peek_ = -1;
};
class Print {
public:
virtual size_t write(uint8_t c) = 0;
virtual size_t write(const uint8_t * buffer, size_t size) = 0;
size_t print(char c) {
return write((uint8_t)c);
}
size_t print(const char * data) {
return write(reinterpret_cast<const uint8_t *>(data), strlen(data));
}
size_t print(const __FlashStringHelper * data) {
return print(reinterpret_cast<const char *>(data));
}
size_t print(const Printable & printable) {
return printable.printTo(*this);
}
size_t print(int value) {
return print(std::to_string(value).c_str());
}
size_t print(unsigned int value) {
return print(std::to_string(value).c_str());
}
size_t print(long value) {
return print(std::to_string(value).c_str());
}
size_t print(unsigned long value) {
return print(std::to_string(value).c_str());
}
size_t println() {
return print("\r\n");
}
size_t println(const char * data) {
return print(data) + println();
}
size_t println(const __FlashStringHelper * data) {
return print(reinterpret_cast<const char *>(data)) + println();
}
size_t println(const Printable & printable) {
return printable.printTo(*this) + println();
}
size_t println(int value) {
return print(std::to_string(value).c_str()) + println();
}
size_t println(unsigned int value) {
return print(std::to_string(value).c_str()) + println();
}
size_t println(long value) {
return print(std::to_string(value).c_str()) + println();
}
size_t println(unsigned long value) {
return print(std::to_string(value).c_str()) + println();
}
virtual void flush(){};
size_t print(const String & str) {
return print(str.c_str());
}
};
class Stream : public Print {
public:
virtual int available() = 0;
virtual int read() = 0;
virtual int peek() = 0;
};
class NativeConsole : public Stream {
public:
void begin(unsigned long baud __attribute__((unused))) {
}
int available() override {
if (peek() >= 0) {
return 1;
} else {
return 0;
}
}
int read() override {
peek();
if (peek_) {
peek_ = false;
return peek_data_;
} else {
return -1;
}
}
int peek() override {
if (!peek_) {
int ret = ::read(STDIN_FILENO, &peek_data_, 1);
peek_ = ret > 0;
}
if (peek_) {
return peek_data_;
} else {
return -1;
}
}
size_t write(uint8_t c) override {
return ::write(STDOUT_FILENO, &c, 1);
}
size_t write(const uint8_t * buffer, size_t size) override {
return ::write(STDOUT_FILENO, buffer, size);
}
private:
bool peek_ = false;
unsigned char peek_data_;
};
#include <Network.h>
#include "Network.h"
extern NativeConsole Serial;
extern ETHClass ETH;

75
lib_standalone/Print.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* mcu-app - Microcontroller application framework
* Copyright 2022 Simon Arlott
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PRINT_H_
#define PRINT_H_
#include <stdarg.h>
#include <unistd.h>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string>
#include <Printable.h>
#include <WString.h>
int vsnprintf_P(char *str, size_t size, const char *format, va_list ap);
class Print {
public:
virtual size_t write(uint8_t c) = 0;
virtual size_t write(const uint8_t *buffer, size_t size) { for (size_t i = 0; i < size; i++) { write(*buffer); buffer++; }; return size; };
void setWriteError(int err = 1) { err_ = err; }
int getWriteError() { return err_; }
void clearWriteError() {}
size_t print(char c) { return write((uint8_t)c); }
size_t print(const char *data) { return write(reinterpret_cast<const uint8_t *>(data), strlen(data)); }
size_t print(const Printable &printable) { return printable.printTo(*this); }
size_t print(int value) { return print(std::to_string(value).c_str()); }
size_t print(unsigned int value) { return print(std::to_string(value).c_str()); }
size_t print(long value) { return print(std::to_string(value).c_str()); }
size_t print(unsigned long value) { return print(std::to_string(value).c_str()); }
size_t printf(const char * format, ...) {
char str[4096] = { 0 };
va_list ap;
va_start(ap, format);
int ret = vsnprintf_P(str, sizeof(str), format, ap);
va_end(ap);
if (ret < 0)
return ret;
return print(str);
}
size_t println() { return print("\r\n"); }
size_t println(const char *data) { return print(data) + println(); }
size_t println(const Printable &printable) { return printable.printTo(*this) + println(); }
size_t println(int value) { return print(std::to_string(value).c_str()) + println(); }
size_t println(unsigned int value) { return print(std::to_string(value).c_str()) + println(); }
size_t println(long value) { return print(std::to_string(value).c_str()) + println(); }
size_t println(unsigned long value) { return print(std::to_string(value).c_str()) + println(); }
virtual void flush() { };
private:
int err_{0};
};
#endif

41
lib_standalone/Printable.h Normal file
View File

@@ -0,0 +1,41 @@
/*
Printable.h - Interface class that allows printing of complex types
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef Printable_h
#define Printable_h
#include <stdlib.h>
class Print;
/** The Printable class provides a way for new classes to allow themselves to be printed.
By deriving from Printable and implementing the printTo method, it will then be possible
for users to print out instances of this class by passing them into the usual
Print::print and Print::println methods.
*/
class Printable
{
public:
virtual ~Printable() {}
virtual size_t printTo(Print& p) const = 0;
};
#endif

4
lib_standalone/SecuritySettingsService.cpp
View File

@@ -1,3 +1,5 @@
#ifdef EMSESP_STANDALONE
#include <SecuritySettingsService.h>
#if FT_ENABLED(FT_SECURITY)
@@ -137,3 +139,5 @@ ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequest
}
#endif
#endif

197
lib_standalone/Stream.h Normal file
View File

@@ -0,0 +1,197 @@
/*
Stream.h - base class for character-based streams.
Copyright (c) 2010 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
parsing functions based on TextFinder library by Michael Margolis
*/
#ifndef Stream_h
#define Stream_h
#include <inttypes.h>
#include "Print.h"
#include "WString.h"
// compatability macros for testing
/*
#define getInt() parseInt()
#define getInt(skipChar) parseInt(skipchar)
#define getFloat() parseFloat()
#define getFloat(skipChar) parseFloat(skipChar)
#define getString( pre_string, post_string, buffer, length)
readBytesBetween( pre_string, terminator, buffer, length)
*/
class Stream: public Print
{
protected:
unsigned long _timeout; // number of milliseconds to wait for the next char before aborting timed read
unsigned long _startMillis; // used for timeout measurement
int timedRead(); // private method to read stream with timeout
int timedPeek(); // private method to peek stream with timeout
int peekNextDigit(); // returns the next numeric digit in the stream or -1 if timeout
public:
virtual int available() = 0;
virtual int read() = 0;
virtual int peek() = 0;
Stream():_startMillis(0)
{
_timeout = 1000;
}
virtual ~Stream() {}
// parsing methods
void setTimeout(unsigned long timeout); // sets maximum milliseconds to wait for stream data, default is 1 second
unsigned long getTimeout(void);
bool find(const char *target); // reads data from the stream until the target string is found
bool find(uint8_t *target)
{
return find((char *) target);
}
// returns true if target string is found, false if timed out (see setTimeout)
bool find(const char *target, size_t length); // reads data from the stream until the target string of given length is found
bool find(const uint8_t *target, size_t length)
{
return find((char *) target, length);
}
// returns true if target string is found, false if timed out
bool find(char target)
{
return find (&target, 1);
}
bool findUntil(const char *target, const char *terminator); // as find but search ends if the terminator string is found
bool findUntil(const uint8_t *target, const char *terminator)
{
return findUntil((char *) target, terminator);
}
bool findUntil(const char *target, size_t targetLen, const char *terminate, size_t termLen); // as above but search ends if the terminate string is found
bool findUntil(const uint8_t *target, size_t targetLen, const char *terminate, size_t termLen)
{
return findUntil((char *) target, targetLen, terminate, termLen);
}
long parseInt(); // returns the first valid (long) integer value from the current position.
// initial characters that are not digits (or the minus sign) are skipped
// integer is terminated by the first character that is not a digit.
float parseFloat(); // float version of parseInt
virtual size_t readBytes(char *buffer, size_t length) // read chars from stream into buffer
{
size_t total = 0;
while (length-- > 0) {
int c = read();
if (c == -1)
return total;
*buffer = c;
total++;
}
return total;
}
virtual size_t readBytes(uint8_t *buffer, size_t length)
{
return readBytes((char *) buffer, length);
}
// terminates if length characters have been read or timeout (see setTimeout)
// returns the number of characters placed in the buffer (0 means no valid data found)
size_t readBytesUntil(char terminator, char *buffer, size_t length) // as readBytes with terminator character
{
size_t total = 0;
while (length-- > 0) {
int c = read();
if (c == -1 || c == terminator)
return total;
*buffer = c;
total++;
}
return total;
}
size_t readBytesUntil(char terminator, uint8_t *buffer, size_t length)
{
return readBytesUntil(terminator, (char *) buffer, length);
}
// terminates if length characters have been read, timeout, or if the terminator character detected
// returns the number of characters placed in the buffer (0 means no valid data found)
#if 0
// Arduino String functions to be added here
virtual String readString() {
String str;
while (1) {
int c = read();
if (c == -1) {
break;
}
str.concat(c);
}
return str;
}
String readStringUntil(char terminator) {
String str;
while (1) {
int c = read();
if (c == -1 || c == terminator) {
break;
}
str.concat(c);
}
return str;
}
#endif
protected:
long parseInt(char skipChar); // as above but the given skipChar is ignored
// as above but the given skipChar is ignored
// this allows format characters (typically commas) in values to be ignored
float parseFloat(char skipChar); // as above but the given skipChar is ignored
struct MultiTarget {
const char *str; // string you're searching for
size_t len; // length of string you're searching for
size_t index; // index used by the search routine.
};
// This allows you to search for an arbitrary number of strings.
// Returns index of the target that is found first or -1 if timeout occurs.
int findMulti(struct MultiTarget *targets, int tCount);
};
#endif

4
lib_standalone/WString.cpp
View File

@@ -1,4 +1,6 @@
#ifdef EMSESP_STANDALONE
#include <Arduino.h>
#include "WString.h"
@@ -66,3 +68,5 @@ size_t strlcat(char * dst, const char * src, size_t siz) {
return (dlen + (s - src)); /* count does not include NUL */
}
#endif

4
lib_standalone/emsuart_standalone.cpp
View File

@@ -16,6 +16,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef EMSESP_STANDALONE
#include "emsuart_standalone.h"
#pragma GCC diagnostic push
@@ -86,3 +88,5 @@ char * EMSuart::hextoa(char * result, const uint8_t value) {
} // namespace emsesp
#pragma GCC diagnostic pop
#endif