mirror of https://github.com/lumapu/ahoy.git
Patrick Amrhein
1 year ago
67 changed files with 2601 additions and 961 deletions
@ -0,0 +1 @@ |
|||
patches/GxEPD2_HAL.patch eol=lf |
|||
@ -0,0 +1,56 @@ |
|||
# Generate factory firmware (ESP32) |
|||
|
|||
If the firmware should already contain predefined settings this guide will help you to compile these into a single binary file. |
|||
|
|||
## Generate default settings |
|||
|
|||
First install on the requested platform the standard firmware and configure everything to your needs. Once you did all changes store them and export them to a `json` file. |
|||
|
|||
## Further prepare default settings |
|||
|
|||
First create a directory `data` inside the following project path: `src/`. |
|||
|
|||
As the export removes all your passwords you need to add them again to the `json` file. Open the `json` file with a text editor and search for all the `"pwd":""` sections. Between the second bunch of quotation marks you have to place the password. |
|||
|
|||
*Note: It's recommended to keep all information in one line to save space on the ESP littlefs partition* |
|||
|
|||
Next rename your export file to `settings.json` and move it to the new created directory. It should be look similar to this: |
|||
|
|||
``` |
|||
ahoy |
|||
|-- src |
|||
|-- data |
|||
|-- settings.json |
|||
|-- config |
|||
|-- network |
|||
... |
|||
``` |
|||
|
|||
## build firmware |
|||
|
|||
Choose your prefered environment and build firmware as usual. Once the process is finished you should find along with the standard `firmware.bin` an additional file called `firmware.factory.bin`. Both files are located here: `src/.pio/build/[ENVIRONMENT]/` |
|||
|
|||
## Upload to device |
|||
|
|||
Navigate to the firmware output directory `src/.pio/build/[ENVIRONMENT]/` and open a terminal or vice versa. |
|||
|
|||
Python: |
|||
`esptool.py -b 921600 write_flash --flash_mode dio --flash_size detect 0x0 firmware.factory.bin` |
|||
|
|||
Windows: |
|||
`esptool.exe -b 921600 write_flash --flash_mode dio --flash_size detect 0x0 firmware.factory.bin` |
|||
|
|||
The upload should be finished within one minute. |
|||
|
|||
## Testing |
|||
|
|||
Reboot your ESP an check if all your settings are present. |
|||
|
|||
## Keep updated with 'Mainline' |
|||
|
|||
From time to time a new version of AhoyDTU will be published. To get the changes into your already prepared factory binary generation environment you have to do only a few steps: |
|||
|
|||
1. pull new changes from remote: `git pull` |
|||
2. check if the `data` folder is still there and contains the `settings.json` |
|||
3. build and upload |
|||
4. enjoy |
|||
@ -0,0 +1,392 @@ |
|||
diff --git a/src/GxEPD2_EPD.cpp b/src/GxEPD2_EPD.cpp
|
|||
index 8df8bef..e9dfb19 100644
|
|||
--- a/src/GxEPD2_EPD.cpp
|
|||
+++ b/src/GxEPD2_EPD.cpp
|
|||
@@ -17,11 +17,10 @@
|
|||
#include <avr/pgmspace.h> |
|||
#endif |
|||
|
|||
-GxEPD2_EPD::GxEPD2_EPD(int16_t cs, int16_t dc, int16_t rst, int16_t busy, int16_t busy_level, uint32_t busy_timeout,
|
|||
+GxEPD2_EPD::GxEPD2_EPD(GxEPD2_HalInterface *hal, int16_t busy_level, uint32_t busy_timeout,
|
|||
uint16_t w, uint16_t h, GxEPD2::Panel p, bool c, bool pu, bool fpu) : |
|||
WIDTH(w), HEIGHT(h), panel(p), hasColor(c), hasPartialUpdate(pu), hasFastPartialUpdate(fpu), |
|||
- _cs(cs), _dc(dc), _rst(rst), _busy(busy), _busy_level(busy_level), _busy_timeout(busy_timeout), _diag_enabled(false),
|
|||
- _pSPIx(&SPI), _spi_settings(4000000, MSBFIRST, SPI_MODE0)
|
|||
+ _hal(hal), _busy_level(busy_level), _busy_timeout(busy_timeout), _diag_enabled(false)
|
|||
{ |
|||
_initial_write = true; |
|||
_initial_refresh = true; |
|||
@@ -54,44 +53,10 @@ void GxEPD2_EPD::init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset
|
|||
Serial.begin(serial_diag_bitrate); |
|||
_diag_enabled = true; |
|||
} |
|||
- if (_cs >= 0)
|
|||
- {
|
|||
- digitalWrite(_cs, HIGH); // preset (less glitch for any analyzer)
|
|||
- pinMode(_cs, OUTPUT);
|
|||
- digitalWrite(_cs, HIGH); // set (needed e.g. for RP2040)
|
|||
- }
|
|||
- if (_dc >= 0)
|
|||
- {
|
|||
- digitalWrite(_dc, HIGH); // preset (less glitch for any analyzer)
|
|||
- pinMode(_dc, OUTPUT);
|
|||
- digitalWrite(_dc, HIGH); // set (needed e.g. for RP2040)
|
|||
- }
|
|||
- _reset();
|
|||
- if (_busy >= 0)
|
|||
- {
|
|||
- pinMode(_busy, INPUT);
|
|||
- }
|
|||
- _pSPIx->begin();
|
|||
- if (_busy == MISO) // may be overridden
|
|||
- {
|
|||
- pinMode(_busy, INPUT);
|
|||
- }
|
|||
- if (_dc == MISO) // may be overridden, TTGO T5 V2.66
|
|||
- {
|
|||
- pinMode(_dc, OUTPUT);
|
|||
- }
|
|||
- if (_cs == MISO) // may be overridden
|
|||
- {
|
|||
- pinMode(_cs, INPUT);
|
|||
- }
|
|||
} |
|||
|
|||
void GxEPD2_EPD::end() |
|||
{ |
|||
- _pSPIx->end();
|
|||
- if (_cs >= 0) pinMode(_cs, INPUT);
|
|||
- if (_dc >= 0) pinMode(_dc, INPUT);
|
|||
- if (_rst >= 0) pinMode(_rst, INPUT);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::setBusyCallback(void (*busyCallback)(const void*), const void* busy_callback_parameter) |
|||
@@ -100,34 +65,27 @@ void GxEPD2_EPD::setBusyCallback(void (*busyCallback)(const void*), const void*
|
|||
_busy_callback_parameter = busy_callback_parameter; |
|||
} |
|||
|
|||
-void GxEPD2_EPD::selectSPI(SPIClass& spi, SPISettings spi_settings)
|
|||
-{
|
|||
- _pSPIx = &spi;
|
|||
- _spi_settings = spi_settings;
|
|||
-}
|
|||
-
|
|||
void GxEPD2_EPD::_reset() |
|||
{ |
|||
- if (_rst >= 0)
|
|||
{ |
|||
if (_pulldown_rst_mode) |
|||
{ |
|||
- digitalWrite(_rst, LOW);
|
|||
- pinMode(_rst, OUTPUT);
|
|||
- digitalWrite(_rst, LOW);
|
|||
+ _hal->rst(LOW);
|
|||
+ _hal->rstMode(OUTPUT);
|
|||
+ _hal->rst(LOW);
|
|||
delay(_reset_duration); |
|||
- pinMode(_rst, INPUT_PULLUP);
|
|||
+ _hal->rstMode(INPUT_PULLUP);
|
|||
delay(_reset_duration > 10 ? _reset_duration : 10); |
|||
} |
|||
else |
|||
{ |
|||
- digitalWrite(_rst, HIGH); // NEEDED for Waveshare "clever" reset circuit, power controller before reset pulse, preset (less glitch for any analyzer)
|
|||
- pinMode(_rst, OUTPUT);
|
|||
- digitalWrite(_rst, HIGH); // NEEDED for Waveshare "clever" reset circuit, power controller before reset pulse, set (needed e.g. for RP2040)
|
|||
+ _hal->rst(HIGH); // NEEDED for Waveshare "clever" reset circuit, power controller before reset pulse, preset (less glitch for any analyzer)
|
|||
+ _hal->rstMode(OUTPUT);
|
|||
+ _hal->rst(HIGH); // NEEDED for Waveshare "clever" reset circuit, power controller before reset pulse, set (needed e.g. for RP2040)
|
|||
delay(10); // NEEDED for Waveshare "clever" reset circuit, at least delay(2); |
|||
- digitalWrite(_rst, LOW);
|
|||
+ _hal->rst(LOW);
|
|||
delay(_reset_duration); |
|||
- digitalWrite(_rst, HIGH);
|
|||
+ _hal->rst(HIGH);
|
|||
delay(_reset_duration > 10 ? _reset_duration : 10); |
|||
} |
|||
_hibernating = false; |
|||
@@ -136,16 +94,15 @@ void GxEPD2_EPD::_reset()
|
|||
|
|||
void GxEPD2_EPD::_waitWhileBusy(const char* comment, uint16_t busy_time) |
|||
{ |
|||
- if (_busy >= 0)
|
|||
{ |
|||
delay(1); // add some margin to become active |
|||
unsigned long start = micros(); |
|||
while (1) |
|||
{ |
|||
- if (digitalRead(_busy) != _busy_level) break;
|
|||
+ if (_hal->getBusy() != _busy_level) break;
|
|||
if (_busy_callback) _busy_callback(_busy_callback_parameter); |
|||
else delay(1); |
|||
- if (digitalRead(_busy) != _busy_level) break;
|
|||
+ if (_hal->getBusy() != _busy_level) break;
|
|||
if (micros() - start > _busy_timeout) |
|||
{ |
|||
Serial.println("Busy Timeout!"); |
|||
@@ -169,120 +126,59 @@ void GxEPD2_EPD::_waitWhileBusy(const char* comment, uint16_t busy_time)
|
|||
} |
|||
(void) start; |
|||
} |
|||
- else delay(busy_time);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeCommand(uint8_t c) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- if (_dc >= 0) digitalWrite(_dc, LOW);
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- _pSPIx->transfer(c);
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- if (_dc >= 0) digitalWrite(_dc, HIGH);
|
|||
- _pSPIx->endTransaction();
|
|||
+ _hal->writeCmd(c);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeData(uint8_t d) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- _pSPIx->transfer(d);
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- _pSPIx->endTransaction();
|
|||
+ _hal->write(d);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeData(const uint8_t* data, uint16_t n) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- for (uint16_t i = 0; i < n; i++)
|
|||
- {
|
|||
- _pSPIx->transfer(*data++);
|
|||
- }
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- _pSPIx->endTransaction();
|
|||
+ _hal->write(data, n);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeDataPGM(const uint8_t* data, uint16_t n, int16_t fill_with_zeroes) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- for (uint16_t i = 0; i < n; i++)
|
|||
- {
|
|||
- _pSPIx->transfer(pgm_read_byte(&*data++));
|
|||
- }
|
|||
- while (fill_with_zeroes > 0)
|
|||
- {
|
|||
- _pSPIx->transfer(0x00);
|
|||
- fill_with_zeroes--;
|
|||
- }
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- _pSPIx->endTransaction();
|
|||
+ _hal->write(data, n, fill_with_zeroes);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeDataPGM_sCS(const uint8_t* data, uint16_t n, int16_t fill_with_zeroes) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- for (uint8_t i = 0; i < n; i++)
|
|||
- {
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- _pSPIx->transfer(pgm_read_byte(&*data++));
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- }
|
|||
- while (fill_with_zeroes > 0)
|
|||
- {
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- _pSPIx->transfer(0x00);
|
|||
- fill_with_zeroes--;
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
+ _hal->write(data, n);
|
|||
+ if (fill_with_zeroes > 0) {
|
|||
+ uint8_t buf[fill_with_zeroes];
|
|||
+ memset(buf, 0, fill_with_zeroes);
|
|||
+ _hal->write(buf, fill_with_zeroes);
|
|||
} |
|||
- _pSPIx->endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeCommandData(const uint8_t* pCommandData, uint8_t datalen) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- if (_dc >= 0) digitalWrite(_dc, LOW);
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- _pSPIx->transfer(*pCommandData++);
|
|||
- if (_dc >= 0) digitalWrite(_dc, HIGH);
|
|||
- for (uint8_t i = 0; i < datalen - 1; i++) // sub the command
|
|||
- {
|
|||
- _pSPIx->transfer(*pCommandData++);
|
|||
- }
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- _pSPIx->endTransaction();
|
|||
+ _hal->writeCmd(pCommandData, datalen, false);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeCommandDataPGM(const uint8_t* pCommandData, uint8_t datalen) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- if (_dc >= 0) digitalWrite(_dc, LOW);
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
- _pSPIx->transfer(pgm_read_byte(&*pCommandData++));
|
|||
- if (_dc >= 0) digitalWrite(_dc, HIGH);
|
|||
- for (uint8_t i = 0; i < datalen - 1; i++) // sub the command
|
|||
- {
|
|||
- _pSPIx->transfer(pgm_read_byte(&*pCommandData++));
|
|||
- }
|
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- _pSPIx->endTransaction();
|
|||
+ _hal->writeCmd(pCommandData, datalen, true);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_startTransfer() |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
- if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
+ _hal->startTransfer();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_transfer(uint8_t value) |
|||
{ |
|||
- _pSPIx->transfer(value);
|
|||
+ _hal->transfer(value);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_endTransfer() |
|||
{ |
|||
- if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
- _pSPIx->endTransaction();
|
|||
+ _hal->endTransfer();
|
|||
} |
|||
diff --git a/src/GxEPD2_EPD.h b/src/GxEPD2_EPD.h
|
|||
index 34c1145..1e8ea64 100644
|
|||
--- a/src/GxEPD2_EPD.h
|
|||
+++ b/src/GxEPD2_EPD.h
|
|||
@@ -13,9 +13,9 @@
|
|||
#define _GxEPD2_EPD_H_ |
|||
|
|||
#include <Arduino.h> |
|||
-#include <SPI.h>
|
|||
|
|||
#include <GxEPD2.h> |
|||
+#include <GxEPD2_Hal.h>
|
|||
|
|||
#pragma GCC diagnostic ignored "-Wunused-parameter" |
|||
//#pragma GCC diagnostic ignored "-Wsign-compare" |
|||
@@ -31,7 +31,7 @@ class GxEPD2_EPD
|
|||
const bool hasPartialUpdate; |
|||
const bool hasFastPartialUpdate; |
|||
// constructor |
|||
- GxEPD2_EPD(int16_t cs, int16_t dc, int16_t rst, int16_t busy, int16_t busy_level, uint32_t busy_timeout,
|
|||
+ GxEPD2_EPD(GxEPD2_HalInterface *hal, int16_t busy_level, uint32_t busy_timeout,
|
|||
uint16_t w, uint16_t h, GxEPD2::Panel p, bool c, bool pu, bool fpu); |
|||
virtual void init(uint32_t serial_diag_bitrate = 0); // serial_diag_bitrate = 0 : disabled |
|||
virtual void init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 10, bool pulldown_rst_mode = false); |
|||
@@ -97,7 +97,6 @@ class GxEPD2_EPD
|
|||
{ |
|||
return (a > b ? a : b); |
|||
}; |
|||
- void selectSPI(SPIClass& spi, SPISettings spi_settings);
|
|||
protected: |
|||
void _reset(); |
|||
void _waitWhileBusy(const char* comment = 0, uint16_t busy_time = 5000); |
|||
@@ -112,16 +111,15 @@ class GxEPD2_EPD
|
|||
void _transfer(uint8_t value); |
|||
void _endTransfer(); |
|||
protected: |
|||
- int16_t _cs, _dc, _rst, _busy, _busy_level;
|
|||
+ GxEPD2_HalInterface *_hal;
|
|||
+ int16_t _busy_level;
|
|||
uint32_t _busy_timeout; |
|||
bool _diag_enabled, _pulldown_rst_mode; |
|||
- SPIClass* _pSPIx;
|
|||
- SPISettings _spi_settings;
|
|||
bool _initial_write, _initial_refresh; |
|||
bool _power_is_on, _using_partial_mode, _hibernating; |
|||
bool _init_display_done; |
|||
uint16_t _reset_duration; |
|||
- void (*_busy_callback)(const void*);
|
|||
+ void (*_busy_callback)(const void*);
|
|||
const void* _busy_callback_parameter; |
|||
}; |
|||
|
|||
diff --git a/src/GxEPD2_Hal.h b/src/GxEPD2_Hal.h
|
|||
new file mode 100644 |
|||
index 0000000..13424b6
|
|||
--- /dev/null
|
|||
+++ b/src/GxEPD2_Hal.h
|
|||
@@ -0,0 +1,19 @@
|
|||
+#pragma once
|
|||
+
|
|||
+class GxEPD2_HalInterface {
|
|||
+ public:
|
|||
+ virtual void rstMode(uint8_t mode) = 0;
|
|||
+ virtual void rst(bool level) = 0;
|
|||
+ virtual int getBusy(void) = 0;
|
|||
+ virtual bool isRst(void) = 0;
|
|||
+
|
|||
+ virtual void write(uint8_t buf) = 0;
|
|||
+ virtual void write(const uint8_t *buf, uint16_t n) = 0;
|
|||
+ virtual void write(const uint8_t *buf, uint16_t n, int16_t fill_with_zeroes) = 0;
|
|||
+ virtual void writeCmd(const uint8_t val) = 0;
|
|||
+ virtual void writeCmd(const uint8_t* pCommandData, uint8_t datalen, bool isPGM) = 0;
|
|||
+
|
|||
+ virtual void startTransfer(void) = 0;
|
|||
+ virtual void endTransfer(void) = 0;
|
|||
+ virtual void transfer(const uint8_t val) = 0;
|
|||
+};
|
|||
diff --git a/src/epd/GxEPD2_150_BN.cpp b/src/epd/GxEPD2_150_BN.cpp
|
|||
index bfb3ddf..dba3d78 100644
|
|||
--- a/src/epd/GxEPD2_150_BN.cpp
|
|||
+++ b/src/epd/GxEPD2_150_BN.cpp
|
|||
@@ -14,8 +14,8 @@
|
|||
|
|||
#include "GxEPD2_150_BN.h" |
|||
|
|||
-GxEPD2_150_BN::GxEPD2_150_BN(int16_t cs, int16_t dc, int16_t rst, int16_t busy) :
|
|||
- GxEPD2_EPD(cs, dc, rst, busy, HIGH, 10000000, WIDTH, HEIGHT, panel, hasColor, hasPartialUpdate, hasFastPartialUpdate)
|
|||
+GxEPD2_150_BN::GxEPD2_150_BN(GxEPD2_HalInterface *hal) :
|
|||
+ GxEPD2_EPD(hal, HIGH, 10000000, WIDTH, HEIGHT, panel, hasColor, hasPartialUpdate, hasFastPartialUpdate)
|
|||
{ |
|||
} |
|||
|
|||
@@ -269,7 +269,7 @@ void GxEPD2_150_BN::refresh(int16_t x, int16_t y, int16_t w, int16_t h)
|
|||
int16_t y1 = y < 0 ? 0 : y; // limit |
|||
w1 = x1 + w1 < int16_t(WIDTH) ? w1 : int16_t(WIDTH) - x1; // limit |
|||
h1 = y1 + h1 < int16_t(HEIGHT) ? h1 : int16_t(HEIGHT) - y1; // limit |
|||
- if ((w1 <= 0) || (h1 <= 0)) return;
|
|||
+ if ((w1 <= 0) || (h1 <= 0)) return;
|
|||
// make x1, w1 multiple of 8 |
|||
w1 += x1 % 8; |
|||
if (w1 % 8 > 0) w1 += 8 - w1 % 8; |
|||
@@ -287,7 +287,7 @@ void GxEPD2_150_BN::powerOff()
|
|||
void GxEPD2_150_BN::hibernate() |
|||
{ |
|||
_PowerOff(); |
|||
- if (_rst >= 0)
|
|||
+ if (_hal->isRst())
|
|||
{ |
|||
_writeCommand(0x10); // deep sleep mode |
|||
_writeData(0x1); // enter deep sleep |
|||
diff --git a/src/epd/GxEPD2_150_BN.h b/src/epd/GxEPD2_150_BN.h
|
|||
index bc46a45..954b9c4 100644
|
|||
--- a/src/epd/GxEPD2_150_BN.h
|
|||
+++ b/src/epd/GxEPD2_150_BN.h
|
|||
@@ -16,6 +16,7 @@
|
|||
#define _GxEPD2_150_BN_H_ |
|||
|
|||
#include "../GxEPD2_EPD.h" |
|||
+#include "../GxEPD2_Hal.h"
|
|||
|
|||
class GxEPD2_150_BN : public GxEPD2_EPD |
|||
{ |
|||
@@ -33,7 +34,7 @@ class GxEPD2_150_BN : public GxEPD2_EPD
|
|||
static const uint16_t full_refresh_time = 4000; // ms, e.g. 3825000us |
|||
static const uint16_t partial_refresh_time = 800; // ms, e.g. 736000us |
|||
// constructor |
|||
- GxEPD2_150_BN(int16_t cs, int16_t dc, int16_t rst, int16_t busy);
|
|||
+ GxEPD2_150_BN(GxEPD2_HalInterface *hal);
|
|||
// methods (virtual) |
|||
// Support for Bitmaps (Sprites) to Controller Buffer and to Screen |
|||
void clearScreen(uint8_t value = 0xFF); // init controller memory and screen (default white) |
|||
@ -1,362 +0,0 @@ |
|||
diff --git a/src/GxEPD2_EPD.cpp b/src/GxEPD2_EPD.cpp
|
|||
index 8df8bef..91d7f49 100644
|
|||
--- a/src/GxEPD2_EPD.cpp
|
|||
+++ b/src/GxEPD2_EPD.cpp
|
|||
@@ -19,9 +19,9 @@
|
|||
|
|||
GxEPD2_EPD::GxEPD2_EPD(int16_t cs, int16_t dc, int16_t rst, int16_t busy, int16_t busy_level, uint32_t busy_timeout, |
|||
uint16_t w, uint16_t h, GxEPD2::Panel p, bool c, bool pu, bool fpu) : |
|||
- WIDTH(w), HEIGHT(h), panel(p), hasColor(c), hasPartialUpdate(pu), hasFastPartialUpdate(fpu),
|
|||
+ WIDTH(w), HEIGHT(h), panel(p), hasColor(c), hasPartialUpdate(pu), hasFastPartialUpdate(fpu), _sck(-1), _mosi(-1),
|
|||
_cs(cs), _dc(dc), _rst(rst), _busy(busy), _busy_level(busy_level), _busy_timeout(busy_timeout), _diag_enabled(false), |
|||
- _pSPIx(&SPI), _spi_settings(4000000, MSBFIRST, SPI_MODE0)
|
|||
+ _spi_settings(4000000, MSBFIRST, SPI_MODE0)
|
|||
{ |
|||
_initial_write = true; |
|||
_initial_refresh = true; |
|||
@@ -71,27 +71,30 @@ void GxEPD2_EPD::init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset
|
|||
{ |
|||
pinMode(_busy, INPUT); |
|||
} |
|||
- _pSPIx->begin();
|
|||
- if (_busy == MISO) // may be overridden
|
|||
- {
|
|||
- pinMode(_busy, INPUT);
|
|||
- }
|
|||
- if (_dc == MISO) // may be overridden, TTGO T5 V2.66
|
|||
- {
|
|||
- pinMode(_dc, OUTPUT);
|
|||
- }
|
|||
- if (_cs == MISO) // may be overridden
|
|||
+ if (_sck < 0) SPI.begin();
|
|||
+}
|
|||
+
|
|||
+void GxEPD2_EPD::init(int16_t sck, int16_t mosi, uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration, bool pulldown_rst_mode)
|
|||
+{
|
|||
+ if ((sck >= 0) && (mosi >= 0))
|
|||
{ |
|||
- pinMode(_cs, INPUT);
|
|||
- }
|
|||
+ _sck = sck;
|
|||
+ _mosi = mosi;
|
|||
+ digitalWrite(_sck, LOW);
|
|||
+ digitalWrite(_mosi, LOW);
|
|||
+ pinMode(_sck, OUTPUT);
|
|||
+ pinMode(_mosi, OUTPUT);
|
|||
+ } else _sck = -1;
|
|||
+ init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::end() |
|||
{ |
|||
- _pSPIx->end();
|
|||
if (_cs >= 0) pinMode(_cs, INPUT); |
|||
if (_dc >= 0) pinMode(_dc, INPUT); |
|||
if (_rst >= 0) pinMode(_rst, INPUT); |
|||
+ if (_sck >= 0) pinMode(_sck, INPUT);
|
|||
+ if (_mosi >= 0) pinMode(_mosi, INPUT);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::setBusyCallback(void (*busyCallback)(const void*), const void* busy_callback_parameter) |
|||
@@ -100,12 +103,6 @@ void GxEPD2_EPD::setBusyCallback(void (*busyCallback)(const void*), const void*
|
|||
_busy_callback_parameter = busy_callback_parameter; |
|||
} |
|||
|
|||
-void GxEPD2_EPD::selectSPI(SPIClass& spi, SPISettings spi_settings)
|
|||
-{
|
|||
- _pSPIx = &spi;
|
|||
- _spi_settings = spi_settings;
|
|||
-}
|
|||
-
|
|||
void GxEPD2_EPD::_reset() |
|||
{ |
|||
if (_rst >= 0) |
|||
@@ -174,115 +171,201 @@ void GxEPD2_EPD::_waitWhileBusy(const char* comment, uint16_t busy_time)
|
|||
|
|||
void GxEPD2_EPD::_writeCommand(uint8_t c) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
if (_dc >= 0) digitalWrite(_dc, LOW); |
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- _pSPIx->transfer(c);
|
|||
+ _spi_write(c);
|
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
if (_dc >= 0) digitalWrite(_dc, HIGH); |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeData(uint8_t d) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- _pSPIx->transfer(d);
|
|||
+ _spi_write(d);
|
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeData(const uint8_t* data, uint16_t n) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- for (uint16_t i = 0; i < n; i++)
|
|||
+ for (uint8_t i = 0; i < n; i++)
|
|||
{ |
|||
- _pSPIx->transfer(*data++);
|
|||
+ _spi_write(*data++);
|
|||
} |
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeDataPGM(const uint8_t* data, uint16_t n, int16_t fill_with_zeroes) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- for (uint16_t i = 0; i < n; i++)
|
|||
+ for (uint8_t i = 0; i < n; i++)
|
|||
{ |
|||
- _pSPIx->transfer(pgm_read_byte(&*data++));
|
|||
+ _spi_write(pgm_read_byte(&*data++));
|
|||
} |
|||
while (fill_with_zeroes > 0) |
|||
{ |
|||
- _pSPIx->transfer(0x00);
|
|||
+ _spi_write(0x00);
|
|||
fill_with_zeroes--; |
|||
} |
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeDataPGM_sCS(const uint8_t* data, uint16_t n, int16_t fill_with_zeroes) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
for (uint8_t i = 0; i < n; i++) |
|||
{ |
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- _pSPIx->transfer(pgm_read_byte(&*data++));
|
|||
+ _spi_write(pgm_read_byte(&*data++));
|
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
} |
|||
while (fill_with_zeroes > 0) |
|||
{ |
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- _pSPIx->transfer(0x00);
|
|||
+ _spi_write(0x00);
|
|||
fill_with_zeroes--; |
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
} |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeCommandData(const uint8_t* pCommandData, uint8_t datalen) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
if (_dc >= 0) digitalWrite(_dc, LOW); |
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- _pSPIx->transfer(*pCommandData++);
|
|||
+ _spi_write(*pCommandData++);
|
|||
if (_dc >= 0) digitalWrite(_dc, HIGH); |
|||
for (uint8_t i = 0; i < datalen - 1; i++) // sub the command |
|||
{ |
|||
- _pSPIx->transfer(*pCommandData++);
|
|||
+ _spi_write(*pCommandData++);
|
|||
} |
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_writeCommandDataPGM(const uint8_t* pCommandData, uint8_t datalen) |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
if (_dc >= 0) digitalWrite(_dc, LOW); |
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
- _pSPIx->transfer(pgm_read_byte(&*pCommandData++));
|
|||
+ _spi_write(pgm_read_byte(&*pCommandData++));
|
|||
if (_dc >= 0) digitalWrite(_dc, HIGH); |
|||
for (uint8_t i = 0; i < datalen - 1; i++) // sub the command |
|||
{ |
|||
- _pSPIx->transfer(pgm_read_byte(&*pCommandData++));
|
|||
+ _spi_write(pgm_read_byte(&*pCommandData++));
|
|||
} |
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_startTransfer() |
|||
{ |
|||
- _pSPIx->beginTransaction(_spi_settings);
|
|||
+ _beginTransaction(_spi_settings);
|
|||
if (_cs >= 0) digitalWrite(_cs, LOW); |
|||
} |
|||
|
|||
void GxEPD2_EPD::_transfer(uint8_t value) |
|||
{ |
|||
- _pSPIx->transfer(value);
|
|||
+ _spi_write(value);
|
|||
} |
|||
|
|||
void GxEPD2_EPD::_endTransfer() |
|||
{ |
|||
if (_cs >= 0) digitalWrite(_cs, HIGH); |
|||
- _pSPIx->endTransaction();
|
|||
+ _endTransaction();
|
|||
+}
|
|||
+
|
|||
+void GxEPD2_EPD::_beginTransaction(const SPISettings& settings)
|
|||
+{
|
|||
+ if (_sck < 0) SPI.beginTransaction(settings);
|
|||
+}
|
|||
+
|
|||
+void GxEPD2_EPD::_spi_write(uint8_t data)
|
|||
+{
|
|||
+ if (_sck < 0) SPI.transfer(data);
|
|||
+ else
|
|||
+ {
|
|||
+#if defined (ESP8266)
|
|||
+ yield();
|
|||
+#endif
|
|||
+ for (int i = 0; i < 8; i++)
|
|||
+ {
|
|||
+ digitalWrite(_mosi, (data & 0x80) ? HIGH : LOW);
|
|||
+ data <<= 1;
|
|||
+ digitalWrite(_sck, HIGH);
|
|||
+ digitalWrite(_sck, LOW);
|
|||
+ }
|
|||
+ }
|
|||
+}
|
|||
+
|
|||
+void GxEPD2_EPD::_endTransaction()
|
|||
+{
|
|||
+ if (_sck < 0) SPI.endTransaction();
|
|||
+}
|
|||
+
|
|||
+uint8_t GxEPD2_EPD::_readData()
|
|||
+{
|
|||
+ uint8_t data = 0;
|
|||
+ _beginTransaction(_spi_settings);
|
|||
+ if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
+ if (_sck < 0)
|
|||
+ {
|
|||
+ data = SPI.transfer(0);
|
|||
+ }
|
|||
+ else
|
|||
+ {
|
|||
+ pinMode(_mosi, INPUT);
|
|||
+ for (int i = 0; i < 8; i++)
|
|||
+ {
|
|||
+ data <<= 1;
|
|||
+ digitalWrite(_sck, HIGH);
|
|||
+ data |= digitalRead(_mosi);
|
|||
+ digitalWrite(_sck, LOW);
|
|||
+ }
|
|||
+ pinMode(_mosi, OUTPUT);
|
|||
+ }
|
|||
+ if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
+ _endTransaction();
|
|||
+ return data;
|
|||
+}
|
|||
+
|
|||
+void GxEPD2_EPD::_readData(uint8_t* data, uint16_t n)
|
|||
+{
|
|||
+ _beginTransaction(_spi_settings);
|
|||
+ if (_cs >= 0) digitalWrite(_cs, LOW);
|
|||
+ if (_sck < 0)
|
|||
+ {
|
|||
+ for (uint8_t i = 0; i < n; i++)
|
|||
+ {
|
|||
+ *data++ = SPI.transfer(0);
|
|||
+ }
|
|||
+ }
|
|||
+ else
|
|||
+ {
|
|||
+ pinMode(_mosi, INPUT);
|
|||
+ for (uint8_t i = 0; i < n; i++)
|
|||
+ {
|
|||
+ *data = 0;
|
|||
+ for (int i = 0; i < 8; i++)
|
|||
+ {
|
|||
+ *data <<= 1;
|
|||
+ digitalWrite(_sck, HIGH);
|
|||
+ *data |= digitalRead(_mosi);
|
|||
+ digitalWrite(_sck, LOW);
|
|||
+ }
|
|||
+ data++;
|
|||
+ }
|
|||
+ pinMode(_mosi, OUTPUT);
|
|||
+ }
|
|||
+ if (_cs >= 0) digitalWrite(_cs, HIGH);
|
|||
+ _endTransaction();
|
|||
} |
|||
diff --git a/src/GxEPD2_EPD.h b/src/GxEPD2_EPD.h
|
|||
index 34c1145..c480b7d 100644
|
|||
--- a/src/GxEPD2_EPD.h
|
|||
+++ b/src/GxEPD2_EPD.h
|
|||
@@ -8,6 +8,10 @@
|
|||
// Version: see library.properties |
|||
// |
|||
// Library: https://github.com/ZinggJM/GxEPD2 |
|||
+// To use SW SPI with GxEPD2:
|
|||
+// add the special call to the added init method BEFORE the normal init method:
|
|||
+// display.epd2.init(SW_SCK, SW_MOSI, 115200, true, 20, false); // define or replace SW_SCK, SW_MOSI
|
|||
+// display.init(115200); // needed to init upper level
|
|||
|
|||
#ifndef _GxEPD2_EPD_H_ |
|||
#define _GxEPD2_EPD_H_ |
|||
@@ -35,6 +39,7 @@ class GxEPD2_EPD
|
|||
uint16_t w, uint16_t h, GxEPD2::Panel p, bool c, bool pu, bool fpu); |
|||
virtual void init(uint32_t serial_diag_bitrate = 0); // serial_diag_bitrate = 0 : disabled |
|||
virtual void init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 10, bool pulldown_rst_mode = false); |
|||
+ virtual void init(int16_t sck, int16_t mosi, uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 20, bool pulldown_rst_mode = false);
|
|||
virtual void end(); // release SPI and control pins |
|||
// Support for Bitmaps (Sprites) to Controller Buffer and to Screen |
|||
virtual void clearScreen(uint8_t value) = 0; // init controller memory and screen (default white) |
|||
@@ -97,7 +102,6 @@ class GxEPD2_EPD
|
|||
{ |
|||
return (a > b ? a : b); |
|||
}; |
|||
- void selectSPI(SPIClass& spi, SPISettings spi_settings);
|
|||
protected: |
|||
void _reset(); |
|||
void _waitWhileBusy(const char* comment = 0, uint16_t busy_time = 5000); |
|||
@@ -111,17 +115,22 @@ class GxEPD2_EPD
|
|||
void _startTransfer(); |
|||
void _transfer(uint8_t value); |
|||
void _endTransfer(); |
|||
+ void _beginTransaction(const SPISettings& settings);
|
|||
+ void _spi_write(uint8_t data);
|
|||
+ void _endTransaction();
|
|||
+ public:
|
|||
+ uint8_t _readData();
|
|||
+ void _readData(uint8_t* data, uint16_t n);
|
|||
protected: |
|||
- int16_t _cs, _dc, _rst, _busy, _busy_level;
|
|||
+ int16_t _cs, _dc, _rst, _busy, _busy_level, _sck, _mosi;;
|
|||
uint32_t _busy_timeout; |
|||
bool _diag_enabled, _pulldown_rst_mode; |
|||
- SPIClass* _pSPIx;
|
|||
SPISettings _spi_settings; |
|||
bool _initial_write, _initial_refresh; |
|||
bool _power_is_on, _using_partial_mode, _hibernating; |
|||
bool _init_display_done; |
|||
uint16_t _reset_duration; |
|||
- void (*_busy_callback)(const void*);
|
|||
+ void (*_busy_callback)(const void*);
|
|||
const void* _busy_callback_parameter; |
|||
}; |
|||
|
|||
Binary file not shown.
@ -0,0 +1,79 @@ |
|||
import os |
|||
import subprocess |
|||
import shutil |
|||
from SCons.Script import DefaultEnvironment |
|||
Import("env") |
|||
|
|||
|
|||
def build_littlefs(): |
|||
if os.path.isfile('data/settings.json') == False: |
|||
return # nothing to do |
|||
|
|||
result = subprocess.run(["pio", "run", "--target", "buildfs", "--environment", env['PIOENV']]) |
|||
if result.returncode != 0: |
|||
print("Error building LittleFS:") |
|||
exit(1) |
|||
else: |
|||
print("LittleFS build successful") |
|||
|
|||
def merge_bins(): |
|||
if os.path.isfile('data/settings.json') == False: |
|||
return # nothing to do |
|||
|
|||
BOOTLOADER_OFFSET = 0x0000 |
|||
PARTITIONS_OFFSET = 0x8000 |
|||
FIRMWARE_OFFSET = 0x10000 |
|||
|
|||
if env['PIOENV'][:13] == "esp32-wroom32": |
|||
BOOTLOADER_OFFSET = 0x1000 |
|||
|
|||
flash_size = int(env.BoardConfig().get("upload.maximum_size", "1310720")) # 0x140000 |
|||
app0_offset = 0x10000 |
|||
if env['PIOENV'][:7] == "esp8266": |
|||
app0_offset = 0 |
|||
elif env['PIOENV'][:7] == "esp8285": |
|||
app0_offset = 0 |
|||
|
|||
littlefs_offset = 0x290000 |
|||
if flash_size == 0x330000: |
|||
littlefs_offset = 0x670000 |
|||
elif flash_size == 0x640000: |
|||
littlefs_offset = 0xc90000 |
|||
|
|||
# save current wd |
|||
start = os.getcwd() |
|||
os.chdir('.pio/build/' + env['PIOENV'] + '/') |
|||
|
|||
with open("bootloader.bin", "rb") as bootloader_file: |
|||
bootloader_data = bootloader_file.read() |
|||
|
|||
with open("partitions.bin", "rb") as partitions_file: |
|||
partitions_data = partitions_file.read() |
|||
|
|||
with open("firmware.bin", "rb") as firmware_file: |
|||
firmware_data = firmware_file.read() |
|||
|
|||
with open("littlefs.bin", "rb") as littlefs_file: |
|||
littlefs_data = littlefs_file.read() |
|||
|
|||
with open("firmware.factory.bin", "wb") as merged_file: |
|||
merged_file.write(b'\xFF' * BOOTLOADER_OFFSET) |
|||
merged_file.write(bootloader_data) |
|||
|
|||
merged_file.write(b'\xFF' * (PARTITIONS_OFFSET - (BOOTLOADER_OFFSET + len(bootloader_data)))) |
|||
merged_file.write(partitions_data) |
|||
|
|||
merged_file.write(b'\xFF' * (FIRMWARE_OFFSET - (PARTITIONS_OFFSET + len(partitions_data)))) |
|||
merged_file.write(firmware_data) |
|||
|
|||
merged_file.write(b'\xFF' * (littlefs_offset - (FIRMWARE_OFFSET + len(firmware_data)))) |
|||
merged_file.write(littlefs_data) |
|||
|
|||
os.chdir(start) |
|||
|
|||
def main(target, source, env): |
|||
build_littlefs() |
|||
merge_bins() |
|||
|
|||
# ensure that script is called once firmeware was compiled |
|||
env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", main) |
|||
@ -0,0 +1,304 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2024 Ahoy, https://github.com/lumpapu/ahoy
|
|||
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __EPD_HAL_H__ |
|||
#define __EPD_HAL_H__ |
|||
|
|||
#pragma once |
|||
#include "../../utils/spiPatcher.h" |
|||
#include <esp_rom_gpio.h> |
|||
#include <GxEPD2_BW.h> |
|||
|
|||
|
|||
#define EPD_DEFAULT_SPI_SPEED 4000000 // 4 MHz
|
|||
|
|||
class epdHal: public GxEPD2_HalInterface, public SpiPatcherHandle { |
|||
public: |
|||
epdHal() {} |
|||
|
|||
void patch() override { |
|||
esp_rom_gpio_connect_out_signal(mPinMosi, spi_periph_signal[mHostDevice].spid_out, false, false); |
|||
esp_rom_gpio_connect_in_signal(mPinBusy, spi_periph_signal[mHostDevice].spiq_in, false); |
|||
esp_rom_gpio_connect_out_signal(mPinClk, spi_periph_signal[mHostDevice].spiclk_out, false, false); |
|||
} |
|||
|
|||
void unpatch() override { |
|||
esp_rom_gpio_connect_out_signal(mPinMosi, SIG_GPIO_OUT_IDX, false, false); |
|||
esp_rom_gpio_connect_in_signal(mPinBusy, GPIO_MATRIX_CONST_ZERO_INPUT, false); |
|||
esp_rom_gpio_connect_out_signal(mPinClk, SIG_GPIO_OUT_IDX, false, false); |
|||
} |
|||
|
|||
void init(int8_t mosi, int8_t dc, int8_t sclk, int8_t cs, int8_t rst, int8_t busy, int32_t speed = EPD_DEFAULT_SPI_SPEED) { |
|||
mPinMosi = static_cast<gpio_num_t>(mosi); |
|||
mPinDc = static_cast<gpio_num_t>(dc); |
|||
mPinClk = static_cast<gpio_num_t>(sclk); |
|||
mPinCs = static_cast<gpio_num_t>(cs); |
|||
mPinRst = static_cast<gpio_num_t>(rst); |
|||
mPinBusy = static_cast<gpio_num_t>(busy); |
|||
mSpiSpeed = speed; |
|||
|
|||
#if defined(CONFIG_IDF_TARGET_ESP32S3) |
|||
mHostDevice = SPI3_HOST; |
|||
#else |
|||
mHostDevice = (14 == sclk) ? SPI2_HOST : SPI_HOST_OTHER; |
|||
#endif |
|||
|
|||
mSpiPatcher = SpiPatcher::getInstance(mHostDevice); |
|||
|
|||
gpio_reset_pin(mPinMosi); |
|||
gpio_set_direction(mPinMosi, GPIO_MODE_OUTPUT); |
|||
gpio_set_level(mPinMosi, 1); |
|||
|
|||
gpio_reset_pin(mPinClk); |
|||
gpio_set_direction(mPinClk, GPIO_MODE_OUTPUT); |
|||
gpio_set_level(mPinClk, 0); |
|||
|
|||
gpio_reset_pin(mPinCs); |
|||
spi_device_interface_config_t devcfg = { |
|||
.command_bits = 0, |
|||
.address_bits = 0, |
|||
.dummy_bits = 0, |
|||
.mode = 0, |
|||
.duty_cycle_pos = 0, |
|||
.cs_ena_pretrans = 0, |
|||
.cs_ena_posttrans = 0, |
|||
.clock_speed_hz = mSpiSpeed, |
|||
.input_delay_ns = 0, |
|||
.spics_io_num = mPinCs, |
|||
.flags = 0, |
|||
.queue_size = 1, |
|||
.pre_cb = nullptr, |
|||
.post_cb = nullptr |
|||
}; |
|||
mSpiPatcher->addDevice(mHostDevice, &devcfg, &spi); |
|||
|
|||
if(GPIO_NUM_NC != mPinRst) { |
|||
gpio_reset_pin(mPinRst); |
|||
gpio_set_direction(mPinRst, GPIO_MODE_OUTPUT); |
|||
gpio_set_level(mPinRst, HIGH); |
|||
} |
|||
|
|||
gpio_reset_pin(mPinDc); |
|||
gpio_set_direction(mPinDc, GPIO_MODE_OUTPUT); |
|||
gpio_set_level(mPinDc, HIGH); |
|||
|
|||
//gpio_reset_pin(mPinBusy);
|
|||
//gpio_set_direction(mPinBusy, GPIO_MODE_INPUT);
|
|||
} |
|||
|
|||
void rstMode(uint8_t mode) override { |
|||
if(GPIO_NUM_NC != mPinRst) |
|||
gpio_set_direction(mPinRst, static_cast<gpio_mode_t>(mode)); |
|||
} |
|||
|
|||
void rst(bool level) override { |
|||
if(GPIO_NUM_NC != mPinRst) |
|||
gpio_set_level(mPinRst, level); |
|||
} |
|||
|
|||
int getBusy(void) override { |
|||
return gpio_get_level(mPinBusy); |
|||
} |
|||
|
|||
bool isRst(void) override { |
|||
return (GPIO_NUM_NC != mPinRst); |
|||
} |
|||
|
|||
void write(uint8_t buf) override { |
|||
uint8_t data[1]; |
|||
data[0] = buf; |
|||
request_spi(); |
|||
|
|||
size_t spiLen = static_cast<size_t>(1u) << 3; |
|||
spi_transaction_t t = { |
|||
.flags = 0, |
|||
.cmd = 0, |
|||
.addr = 0, |
|||
.length = spiLen, |
|||
.rxlength = spiLen, |
|||
.user = NULL, |
|||
.tx_buffer = data, |
|||
.rx_buffer = data |
|||
}; |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t)); |
|||
|
|||
release_spi(); |
|||
} |
|||
|
|||
void write(const uint8_t *buf, uint16_t n) override { |
|||
uint8_t data[n]; |
|||
std::copy(&buf[0], &buf[n], &data[0]); |
|||
|
|||
request_spi(); |
|||
|
|||
size_t spiLen = static_cast<size_t>(n) << 3; |
|||
spi_transaction_t t = { |
|||
.flags = 0, |
|||
.cmd = 0, |
|||
.addr = 0, |
|||
.length = spiLen, |
|||
.rxlength = spiLen, |
|||
.user = NULL, |
|||
.tx_buffer = data, |
|||
.rx_buffer = data |
|||
}; |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t)); |
|||
|
|||
release_spi(); |
|||
} |
|||
|
|||
void write(const uint8_t *buf, uint16_t n, int16_t fill_with_zeroes) override { |
|||
uint8_t data[n + fill_with_zeroes]; |
|||
memset(data, 0, (n + fill_with_zeroes)); |
|||
for (uint16_t i = 0; i < n; i++) { |
|||
data[i] = pgm_read_byte(&*buf++); |
|||
} |
|||
|
|||
request_spi(); |
|||
spi_transaction_t t = { |
|||
.flags = SPI_TRANS_CS_KEEP_ACTIVE, |
|||
.cmd = 0, |
|||
.addr = 0, |
|||
.length = 1u, |
|||
.rxlength = 1u, |
|||
.user = NULL, |
|||
.tx_buffer = data, |
|||
.rx_buffer = data |
|||
}; |
|||
|
|||
size_t offs = 0; |
|||
spi_device_acquire_bus(spi, portMAX_DELAY); |
|||
while(offs < (n + fill_with_zeroes)) { |
|||
t.length = (64u << 3); |
|||
t.rxlength = t.length; |
|||
t.tx_buffer = &data[offs]; |
|||
offs += 64; |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t)); |
|||
} |
|||
spi_device_release_bus(spi); |
|||
|
|||
release_spi(); |
|||
} |
|||
|
|||
void writeCmd(const uint8_t val) override { |
|||
uint8_t data[1]; |
|||
data[0] = val; |
|||
|
|||
request_spi(); |
|||
gpio_set_level(mPinDc, LOW); |
|||
|
|||
size_t spiLen = static_cast<size_t>(1u) << 3; |
|||
spi_transaction_t t = { |
|||
.flags = 0, |
|||
.cmd = 0, |
|||
.addr = 0, |
|||
.length = spiLen, |
|||
.rxlength = spiLen, |
|||
.user = NULL, |
|||
.tx_buffer = data, |
|||
.rx_buffer = data |
|||
}; |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t)); |
|||
gpio_set_level(mPinDc, HIGH); |
|||
|
|||
release_spi(); |
|||
} |
|||
|
|||
void writeCmd(const uint8_t *buf, uint8_t n, bool isPGM) override { |
|||
uint8_t data[n-1]; |
|||
data[0] = (isPGM) ? pgm_read_byte(&*buf++) : buf[0]; |
|||
|
|||
request_spi(); |
|||
gpio_set_level(mPinDc, LOW); |
|||
spi_device_acquire_bus(spi, portMAX_DELAY); |
|||
|
|||
size_t spiLen = static_cast<size_t>(1u) << 3; |
|||
spi_transaction_t t = { |
|||
.flags = SPI_TRANS_CS_KEEP_ACTIVE, |
|||
.cmd = 0, |
|||
.addr = 0, |
|||
.length = spiLen, |
|||
.rxlength = spiLen, |
|||
.user = NULL, |
|||
.tx_buffer = data, |
|||
.rx_buffer = data |
|||
}; |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t)); |
|||
gpio_set_level(mPinDc, HIGH); |
|||
|
|||
if(isPGM) { |
|||
for (uint16_t i = 0; i < n; i++) { |
|||
data[i] = pgm_read_byte(&*buf++); |
|||
} |
|||
} else |
|||
std::copy(&buf[1], &buf[n], &data[0]); |
|||
|
|||
spiLen = static_cast<size_t>(n-1) << 3; |
|||
spi_transaction_t t1 = { |
|||
.flags = SPI_TRANS_CS_KEEP_ACTIVE, |
|||
.cmd = 0, |
|||
.addr = 0, |
|||
.length = spiLen, |
|||
.rxlength = spiLen, |
|||
.user = NULL, |
|||
.tx_buffer = data, |
|||
.rx_buffer = data |
|||
}; |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t1)); |
|||
spi_device_release_bus(spi); |
|||
|
|||
release_spi(); |
|||
} |
|||
|
|||
void startTransfer(void) override { |
|||
request_spi(); |
|||
} |
|||
|
|||
void endTransfer(void) override { |
|||
release_spi(); |
|||
} |
|||
|
|||
void transfer(const uint8_t val) override { |
|||
uint8_t data[1]; |
|||
data[0] = val; |
|||
|
|||
size_t spiLen = static_cast<size_t>(1u) << 3; |
|||
spi_transaction_t t = { |
|||
.flags = 0, |
|||
.cmd = 0, |
|||
.addr = 0, |
|||
.length = spiLen, |
|||
.rxlength = spiLen, |
|||
.user = NULL, |
|||
.tx_buffer = data, |
|||
.rx_buffer = data |
|||
}; |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t)); |
|||
} |
|||
|
|||
private: |
|||
inline void request_spi() { |
|||
mSpiPatcher->request(this); |
|||
} |
|||
|
|||
inline void release_spi() { |
|||
mSpiPatcher->release(); |
|||
} |
|||
|
|||
private: |
|||
gpio_num_t mPinMosi = GPIO_NUM_NC; |
|||
gpio_num_t mPinDc = GPIO_NUM_NC; |
|||
gpio_num_t mPinClk = GPIO_NUM_NC; |
|||
gpio_num_t mPinCs = GPIO_NUM_NC; |
|||
gpio_num_t mPinRst = GPIO_NUM_NC; |
|||
gpio_num_t mPinBusy = GPIO_NUM_NC; |
|||
int32_t mSpiSpeed = EPD_DEFAULT_SPI_SPEED; |
|||
|
|||
spi_host_device_t mHostDevice; |
|||
spi_device_handle_t spi; |
|||
SpiPatcher *mSpiPatcher; |
|||
}; |
|||
|
|||
#endif /*__EPD_HAL_H__*/ |
|||
@ -0,0 +1,67 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2024 Ahoy, https://github.com/lumpapu/ahoy
|
|||
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __MAX_VALUE__ |
|||
#define __MAX_VALUE__ |
|||
#pragma once |
|||
|
|||
#include <array> |
|||
#include <utility> |
|||
#include "../hm/hmDefines.h" |
|||
|
|||
template<class T=float> |
|||
class MaxPower { |
|||
public: |
|||
MaxPower() { |
|||
mTs = nullptr; |
|||
mMaxDiff = 60; |
|||
reset(); |
|||
} |
|||
|
|||
void setup(uint32_t *ts, uint16_t interval) { |
|||
mTs = ts; |
|||
mMaxDiff = interval * 4; |
|||
} |
|||
|
|||
void reset(void) { |
|||
mValues.fill(std::make_pair(0, 0.0)); |
|||
mLast = 0.0; |
|||
} |
|||
|
|||
void payloadEvent(uint8_t cmd, Inverter<> *iv) { |
|||
if(RealTimeRunData_Debug != cmd) |
|||
return; |
|||
|
|||
if(nullptr == iv) |
|||
return; |
|||
|
|||
if(iv->id >= MAX_NUM_INVERTERS) |
|||
return; |
|||
|
|||
record_t<> *rec = iv->getRecordStruct(RealTimeRunData_Debug); |
|||
mValues[iv->id] = std::make_pair(*mTs, iv->getChannelFieldValue(CH0, FLD_PAC, rec)); |
|||
} |
|||
|
|||
T getTotalMaxPower(void) { |
|||
T val = 0; |
|||
for(uint8_t i = 0; i < MAX_NUM_INVERTERS; i ++) { |
|||
if((mValues[i].first + mMaxDiff) >= *mTs) |
|||
val += mValues[i].second; |
|||
else if(mValues[i].first > 0) |
|||
return mLast; // old data
|
|||
} |
|||
if(val > mLast) |
|||
mLast = val; |
|||
return mLast; |
|||
} |
|||
|
|||
private: |
|||
uint32_t *mTs; |
|||
uint32_t mMaxDiff; |
|||
float mLast; |
|||
std::array<std::pair<uint32_t, T>, MAX_NUM_INVERTERS> mValues; |
|||
}; |
|||
|
|||
#endif |
|||
@ -0,0 +1,466 @@ |
|||
[ |
|||
{ |
|||
"id": "67bced2c4e728783", |
|||
"type": "mqtt in", |
|||
"z": "5de5756d190f9086", |
|||
"name": "", |
|||
"topic": "hoymiles/+", |
|||
"qos": "0", |
|||
"datatype": "auto-detect", |
|||
"broker": "319864a4e0fd913f", |
|||
"nl": false, |
|||
"rap": true, |
|||
"rh": 0, |
|||
"inputs": 0, |
|||
"x": 80, |
|||
"y": 2100, |
|||
"wires": [ |
|||
[ |
|||
"a55632ad0dff0b69" |
|||
] |
|||
] |
|||
}, |
|||
{ |
|||
"id": "a7f0d307d7cf77e2", |
|||
"type": "mqtt in", |
|||
"z": "5de5756d190f9086", |
|||
"name": "", |
|||
"topic": "hoymiles/X/#", |
|||
"qos": "0", |
|||
"datatype": "auto-detect", |
|||
"broker": "319864a4e0fd913f", |
|||
"nl": false, |
|||
"rap": true, |
|||
"rh": 0, |
|||
"inputs": 0, |
|||
"x": 90, |
|||
"y": 2260, |
|||
"wires": [ |
|||
[ |
|||
"7e17e5a3f4df3011", |
|||
"1a8cca488d53394a" |
|||
] |
|||
] |
|||
}, |
|||
{ |
|||
"id": "7e17e5a3f4df3011", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "Inverter X", |
|||
"active": false, |
|||
"tosidebar": true, |
|||
"console": false, |
|||
"tostatus": false, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "", |
|||
"statusType": "auto", |
|||
"x": 340, |
|||
"y": 2260, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "fb7357db50501627", |
|||
"type": "change", |
|||
"z": "5de5756d190f9086", |
|||
"name": "Tags setzen", |
|||
"rules": [ |
|||
{ |
|||
"t": "set", |
|||
"p": "payload", |
|||
"pt": "msg", |
|||
"to": "(\t $a := $split(topic, '/');\t [\t payload,\t {\t \"device\":$a[0],\t \"name\":$a[1],\t \"channel\":$a[2]\t }\t ]\t)\t", |
|||
"tot": "jsonata" |
|||
}, |
|||
{ |
|||
"t": "delete", |
|||
"p": "topic", |
|||
"pt": "msg" |
|||
} |
|||
], |
|||
"action": "", |
|||
"property": "", |
|||
"from": "", |
|||
"to": "", |
|||
"reg": false, |
|||
"x": 610, |
|||
"y": 2360, |
|||
"wires": [ |
|||
[ |
|||
"91a4607dfda84b67" |
|||
] |
|||
] |
|||
}, |
|||
{ |
|||
"id": "670eb9fbb5c31b2c", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "InfluxDB", |
|||
"active": false, |
|||
"tosidebar": true, |
|||
"console": false, |
|||
"tostatus": false, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "", |
|||
"statusType": "auto", |
|||
"x": 940, |
|||
"y": 2360, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "1a8cca488d53394a", |
|||
"type": "switch", |
|||
"z": "5de5756d190f9086", |
|||
"name": "", |
|||
"property": "$split(topic, '/')[2]", |
|||
"propertyType": "jsonata", |
|||
"rules": [ |
|||
{ |
|||
"t": "eq", |
|||
"v": "available", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "last_success", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "regex", |
|||
"v": "(ch[0-6])\\b", |
|||
"vt": "str", |
|||
"case": false |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "radio_stat", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "firmware", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "hardware", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "alarm", |
|||
"vt": "str" |
|||
} |
|||
], |
|||
"checkall": "true", |
|||
"repair": false, |
|||
"outputs": 7, |
|||
"x": 330, |
|||
"y": 2380, |
|||
"wires": [ |
|||
[ |
|||
"845aeb93e39092c5" |
|||
], |
|||
[ |
|||
"241a8e70e9fde93c" |
|||
], |
|||
[ |
|||
"fb7357db50501627" |
|||
], |
|||
[ |
|||
"9d38f021308664c1" |
|||
], |
|||
[ |
|||
"a508355f0cc87966" |
|||
], |
|||
[ |
|||
"d2c9aa1a8978aca6" |
|||
], |
|||
[ |
|||
"b27032beb597d5a7" |
|||
] |
|||
] |
|||
}, |
|||
{ |
|||
"id": "845aeb93e39092c5", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "available", |
|||
"active": true, |
|||
"tosidebar": false, |
|||
"console": false, |
|||
"tostatus": true, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "payload", |
|||
"statusType": "auto", |
|||
"x": 600, |
|||
"y": 2240, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "241a8e70e9fde93c", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "last_success", |
|||
"active": true, |
|||
"tosidebar": false, |
|||
"console": false, |
|||
"tostatus": true, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "payload", |
|||
"statusType": "auto", |
|||
"x": 610, |
|||
"y": 2300, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "9d38f021308664c1", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "radio_stat", |
|||
"active": false, |
|||
"tosidebar": true, |
|||
"console": false, |
|||
"tostatus": false, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "", |
|||
"statusType": "auto", |
|||
"x": 600, |
|||
"y": 2400, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "a508355f0cc87966", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "firmware", |
|||
"active": false, |
|||
"tosidebar": true, |
|||
"console": false, |
|||
"tostatus": false, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "", |
|||
"statusType": "auto", |
|||
"x": 600, |
|||
"y": 2440, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "d2c9aa1a8978aca6", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "hardware", |
|||
"active": false, |
|||
"tosidebar": true, |
|||
"console": false, |
|||
"tostatus": false, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "", |
|||
"statusType": "auto", |
|||
"x": 600, |
|||
"y": 2480, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "b27032beb597d5a7", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "alarm", |
|||
"active": false, |
|||
"tosidebar": true, |
|||
"console": false, |
|||
"tostatus": false, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "", |
|||
"statusType": "auto", |
|||
"x": 590, |
|||
"y": 2520, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "d814738cf55ad663", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "total", |
|||
"active": false, |
|||
"tosidebar": true, |
|||
"console": false, |
|||
"tostatus": false, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "", |
|||
"statusType": "auto", |
|||
"x": 590, |
|||
"y": 2160, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "a55632ad0dff0b69", |
|||
"type": "switch", |
|||
"z": "5de5756d190f9086", |
|||
"name": "", |
|||
"property": "$split(topic, '/')[1]", |
|||
"propertyType": "jsonata", |
|||
"rules": [ |
|||
{ |
|||
"t": "eq", |
|||
"v": "uptime", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "wifi_rssi", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "status", |
|||
"vt": "str" |
|||
}, |
|||
{ |
|||
"t": "eq", |
|||
"v": "total", |
|||
"vt": "str" |
|||
} |
|||
], |
|||
"checkall": "true", |
|||
"repair": false, |
|||
"outputs": 4, |
|||
"x": 330, |
|||
"y": 2100, |
|||
"wires": [ |
|||
[ |
|||
"1fbb0674d2576ee7" |
|||
], |
|||
[ |
|||
"e6be1c98ac55f511" |
|||
], |
|||
[ |
|||
"f9c2d3b30e34fdda" |
|||
], |
|||
[ |
|||
"d814738cf55ad663" |
|||
] |
|||
] |
|||
}, |
|||
{ |
|||
"id": "f9c2d3b30e34fdda", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "status", |
|||
"active": false, |
|||
"tosidebar": false, |
|||
"console": false, |
|||
"tostatus": true, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "payload", |
|||
"statusType": "auto", |
|||
"x": 590, |
|||
"y": 2100, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "e6be1c98ac55f511", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "wifi_rssi", |
|||
"active": false, |
|||
"tosidebar": false, |
|||
"console": false, |
|||
"tostatus": true, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "payload", |
|||
"statusType": "auto", |
|||
"x": 600, |
|||
"y": 2040, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "1fbb0674d2576ee7", |
|||
"type": "debug", |
|||
"z": "5de5756d190f9086", |
|||
"name": "uptime", |
|||
"active": false, |
|||
"tosidebar": false, |
|||
"console": false, |
|||
"tostatus": true, |
|||
"complete": "payload", |
|||
"targetType": "msg", |
|||
"statusVal": "payload", |
|||
"statusType": "auto", |
|||
"x": 590, |
|||
"y": 1980, |
|||
"wires": [] |
|||
}, |
|||
{ |
|||
"id": "91a4607dfda84b67", |
|||
"type": "change", |
|||
"z": "5de5756d190f9086", |
|||
"name": "Lösche", |
|||
"rules": [ |
|||
{ |
|||
"t": "delete", |
|||
"p": "payload[0].YieldDay", |
|||
"pt": "msg" |
|||
}, |
|||
{ |
|||
"t": "delete", |
|||
"p": "payload[0].MaxPower", |
|||
"pt": "msg" |
|||
}, |
|||
{ |
|||
"t": "delete", |
|||
"p": "payload[0].ALARM_MES_ID", |
|||
"pt": "msg" |
|||
} |
|||
], |
|||
"action": "", |
|||
"property": "", |
|||
"from": "", |
|||
"to": "", |
|||
"reg": false, |
|||
"x": 780, |
|||
"y": 2360, |
|||
"wires": [ |
|||
[ |
|||
"670eb9fbb5c31b2c" |
|||
] |
|||
] |
|||
}, |
|||
{ |
|||
"id": "319864a4e0fd913f", |
|||
"type": "mqtt-broker", |
|||
"name": "broker", |
|||
"broker": "localhost", |
|||
"port": "1883", |
|||
"clientid": "", |
|||
"autoConnect": true, |
|||
"usetls": false, |
|||
"protocolVersion": "4", |
|||
"keepalive": "60", |
|||
"cleansession": true, |
|||
"birthTopic": "", |
|||
"birthQos": "0", |
|||
"birthPayload": "", |
|||
"birthMsg": {}, |
|||
"closeTopic": "", |
|||
"closeQos": "0", |
|||
"closePayload": "", |
|||
"closeMsg": {}, |
|||
"willTopic": "", |
|||
"willQos": "0", |
|||
"willPayload": "", |
|||
"willMsg": {}, |
|||
"userProps": "", |
|||
"sessionExpiry": "" |
|||
} |
|||
] |
|||
Loading…
Reference in new issue