Senseair S8 also works on ESP8266 now

ampel-firmware/co2_sensor.cpp

@@ -18,17 +18,19 @@ namespace config {
 }
 
 #if defined(ESP8266)
-// For ESP8266 : RX on GPIO3, TX on GPIO1
-//TODO: Really not sure it works
-#   define S8_UART_PORT  0
+#  include "src/lib/EspSoftwareSerial/SoftwareSerial.h"
+#  define S8_RX_PIN 13         // GPIO13, a.k.a. D7, connected to S8 Tx pin.
+#  define S8_TX_PIN 15         // GPIO15, a.k.a. D8, connected to S8 Rx pin.
+SoftwareSerial S8_serial(S8_RX_PIN, S8_TX_PIN);
 #endif
 #if defined(ESP32)
-// For ESP32 : RX on GPIO17, TX on GPIO16
-#   define S8_UART_PORT  2
+// GPIO16 connected to S8 Tx pin.
+// GPIO17 connected to S8 Rx pin.
+#  define S8_UART_PORT  2
+HardwareSerial S8_serial(S8_UART_PORT);
 #endif
 
 namespace sensor {
-  HardwareSerial S8_serial(S8_UART_PORT);
   S8_UART *sensor_S8;
   S8_sensor s8;
   uint16_t co2 = 0;

ampel-firmware/src/lib/EspSoftwareSerial/LICENSE

+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
\ No newline at end of file

ampel-firmware/src/lib/EspSoftwareSerial/README.md

+# EspSoftwareSerial
+
+## Implementation of the Arduino software serial library for the ESP8266 / ESP32 family
+
+This fork implements interrupt service routine best practice.
+In the receive interrupt, instead of blocking for whole bytes
+at a time - voiding any near-realtime behavior of the CPU - only level
+change and timestamp are recorded. The more time consuming phase
+detection and byte assembly are done in the main code.
+
+Except at high bitrates, depending on other ongoing activity,
+interrupts in particular, this software serial adapter
+supports full duplex receive and send. At high bitrates (115200bps)
+send bit timing can be improved at the expense of blocking concurrent
+full duplex receives, with the `SoftwareSerial::enableIntTx(false)` function call.
+
+The same functionality is given as the corresponding AVR library but
+several instances can be active at the same time. Speed up to 115200 baud
+is supported. Besides a constructor compatible to the AVR SoftwareSerial class,
+and updated constructor that takes no arguments exists, instead the `begin()`
+function can handle the pin assignments and logic inversion.
+It also has optional input buffer capacity arguments for byte buffer and ISR bit buffer.
+This way, it is a better drop-in replacement for the hardware serial APIs on the ESP MCUs.
+
+Please note that due to the fact that the ESPs always have other activities
+ongoing, there will be some inexactness in interrupt timings. This may
+lead to inevitable, but few, bit errors when having heavy data traffic
+at high baud rates.
+
+This library supports ESP8266, ESP32, ESP32-S2 and ESP32-C3 devices.
+
+## Resource optimization
+
+The memory footprint can be optimized to just fit the amount of expected
+incoming asynchronous data.
+For this, the `SoftwareSerial` constructor provides two arguments. First, the
+octet buffer capacity for assembled received octets can be set. Read calls are
+satisfied from this buffer, freeing it in return.
+Second, the signal edge detection buffer of 32bit fields can be resized.
+One octet may require up to to 10 fields, but fewer may be needed,
+depending on the bit pattern. Any read or write calls check this buffer
+to assemble received octets, thus promoting completed octets to the octet
+buffer, freeing fields in the edge detection buffer.
+
+Look at the swsertest.ino example. There, on reset, ASCII characters ' ' to 'z'
+are sent. This happens not as a block write, but in a single write call per
+character. As the example uses a local loopback wire, every outgoing bit is
+immediately received back. Therefore, any single write call causes up to
+10 fields - depending on the exact bit pattern - to be occupied in the signal
+edge detection buffer. In turn, as explained before, each single write call
+also causes received bit assembly to be performed, promoting these bits from
+the signal edge detection buffer to the octet buffer as soon as possible.
+Explaining by way of contrast, if during a a single write call, perhaps because
+of using block writing, more than a single octet is received, there will be a
+need for more than 10 fields in the signal edge detection buffer.
+The necessary capacity of the octet buffer only depends on the amount of incoming
+data until the next read call.
+
+For the swsertest.ino example, this results in the following optimized
+constructor arguments to spend only the minimum RAM on buffers required:
+
+The octet buffer capacity (`bufCapacity`) is 95 (93 characters net plus two tolerance).
+The signal edge detection buffer capacity (`isrBufCapacity`) is 11, as each
+single octet can have up to 11 bits on the wire,
+which are immediately received during the write, and each
+write call causes the signal edge detection to promote the previously sent and
+received bits to the octet buffer.
+
+In a more generalized scenario, calculate the bits (use message size in octets
+times 10) that may be asynchronously received to determine the value for
+`isrBufCapacity` in the constructor. Also use the number of received octets
+that must be buffered for reading as the value of `bufCapacity`.
+The more frequently your code calls write or read functions, the greater the
+chances are that you can reduce the `isrBufCapacity` footprint without losing data,
+and each time you call read to fetch from the octet buffer, you reduce the
+need for space there.
+
+## SoftwareSerialConfig and parity
+The configuration of the data stream is done via a `SoftwareSerialConfig`
+argument to `begin()`. Word lengths can be set to between 5 and 8 bits, parity
+can be N(one), O(dd) or E(ven) and 1 or 2 stop bits can be used. The default is
+`SWSERIAL_8N1` using 8 bits, no parity and 1 stop bit but any combination can
+be used, e.g. `SWSERIAL_7E2`. If using EVEN or ODD parity, any parity errors
+can be detected with the `readParity()` and `parityEven()` or `parityOdd()`
+functions respectively. Note that the result of `readParity()` always applies
+to the preceding `read()` or `peek()` call, and is undefined if they report
+no data or an error.
+
+To allow flexible 9-bit and data/addressing protocols, the additional parity
+modes MARK and SPACE are also available. Furthermore, the parity mode can be
+individually set in each call to `write()`.
+
+This allows a simple implementation of protocols where the parity bit is used to
+distinguish between data and addresses/commands ("9-bit" protocols). First set
+up SoftwareSerial with parity mode SPACE, e.g. `SWSERIAL_8S1`. This will add a
+parity bit to every byte sent, setting it to logical zero (SPACE parity).
+
+To detect incoming bytes with the parity bit set (MARK parity), use the
+`readParity()` function. To send a byte with the parity bit set, just add
+`MARK` as the second argument when writing, e.g. `write(ch, SWSERIAL_PARITY_MARK)`.
+
+## Checking for correct pin selection / configuration 
+In general, most pins on the ESP8266 and ESP32 devices can be used by SoftwareSerial, 
+however each device has a number of pins that have special functions or require careful
+handling to prevent undesirable situations, for example they are connected to the 
+on-board SPI flash memory or they are used to determine boot and programming modes 
+after powerup or brownouts. These pins are not able to be configured by this library.
+
+The exact list for each device can be found in the
+[ESP32 data sheet](https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf)
+in sections 2.2 (Pin Descriptions) and 2.4 (Strapping pins). There is a discussion
+dedicated to the use of GPIO12 in this
+[note about GPIO12](https://github.com/espressif/esp-idf/tree/release/v3.2/examples/storage/sd_card#note-about-gpio12).
+Refer to the `isValidGPIOpin()`, `isValidRxGPIOpin()` and `isValidTxGPIOpin()`
+functions for the GPIO restrictions enforced by this library by default.
+
+The easiest and safest method is to test the object returned at runtime, to see if 
+it is valid. For example:
+
+```
+#include <SoftwareSerial.h>
+
+#define MYPORT_TX 12
+#define MYPORT_RX 13
+
+SoftwareSerial myPort;
+
+[...]
+
+Serial.begin(115200); // Standard hardware serial port
+
+myPort.begin(38400, SWSERIAL_8N1, MYPORT_RX, MYPORT_TX, false);
+if (!myPort) { // If the object did not initialize, then its configuration is invalid
+  Serial.println("Invalid SoftwareSerial pin configuration, check config"); 
+  while (1) { // Don't continue with invalid configuration
+    delay (1000);
+  }
+} 
+
+[...]
+```
+
+## Using and updating EspSoftwareSerial in the esp8266com/esp8266 Arduino build environment
+
+EspSoftwareSerial is both part of the BSP download for ESP8266 in Arduino,
+and it is set up as a Git submodule in the esp8266 source tree,
+specifically in `.../esp8266/libraries/SoftwareSerial` when using a Github
+repository clone in your Arduino sketchbook hardware directory.
+This supersedes any version of EspSoftwareSerial installed for instance via
+the Arduino library manager, it is not required to install EspSoftwareSerial
+for the ESP8266 separately at all, but doing so has ill effect.
+
+The responsible maintainer of the esp8266 repository has kindly shared the
+following command line instructions to use, if one wishes to manually
+update EspSoftwareSerial to a newer release than pulled in via the ESP8266 Arduino BSP:
+
+To update esp8266/arduino SoftwareSerial submodule to lastest master:
+
+Clean it (optional):
+```shell
+$ rm -rf libraries/SoftwareSerial
+$ git submodule update --init
+```
+Now update it:
+```shell
+$ cd libraries/SoftwareSerial
+$ git checkout master
+$ git pull
+```

ampel-firmware/src/lib/EspSoftwareSerial/SoftwareSerial.cpp

+/*
+
+SoftwareSerial.cpp - Implementation of the Arduino software serial for ESP8266/ESP32.
+Copyright (c) 2015-2016 Peter Lerup. All rights reserved.
+Copyright (c) 2018-2019 Dirk O. Kaar. All rights 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
+
+*/
+
+#include "SoftwareSerial.h"
+#include <Arduino.h>
+
+#ifndef ESP32
+uint32_t SoftwareSerial::m_savedPS = 0;
+#else
+portMUX_TYPE SoftwareSerial::m_interruptsMux = portMUX_INITIALIZER_UNLOCKED;
+#endif
+
+inline void IRAM_ATTR SoftwareSerial::disableInterrupts()
+{
+#ifndef ESP32
+    m_savedPS = xt_rsil(15);
+#else
+    taskENTER_CRITICAL(&m_interruptsMux);
+#endif
+}
+
+inline void IRAM_ATTR SoftwareSerial::restoreInterrupts()
+{
+#ifndef ESP32
+    xt_wsr_ps(m_savedPS);
+#else
+    taskEXIT_CRITICAL(&m_interruptsMux);
+#endif
+}
+
+constexpr uint8_t BYTE_ALL_BITS_SET = ~static_cast<uint8_t>(0);
+
+SoftwareSerial::SoftwareSerial() {
+    m_isrOverflow = false;
+    m_rxGPIOPullupEnabled = true;
+}
+
+SoftwareSerial::SoftwareSerial(int8_t rxPin, int8_t txPin, bool invert)
+{
+    m_isrOverflow = false;
+    m_rxGPIOPullupEnabled = true;
+    m_rxPin = rxPin;
+    m_txPin = txPin;
+    m_invert = invert;
+}
+
+SoftwareSerial::~SoftwareSerial() {
+    end();
+}
+
+bool SoftwareSerial::isValidGPIOpin(int8_t pin) {
+#if defined(ESP8266)
+    return (pin >= 0 && pin <= 16) && !isFlashInterfacePin(pin);
+#elif defined(ESP32)
+    // Remove the strapping pins as defined in the datasheets, they affect bootup and other critical operations
+    // Remmove the flash memory pins on related devices, since using these causes memory access issues.
+#ifdef CONFIG_IDF_TARGET_ESP32
+    // Datasheet https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf,
+    // Pinout    https://docs.espressif.com/projects/esp-idf/en/latest/esp32/_images/esp32-devkitC-v4-pinout.jpg    
+    return (pin == 1) || (pin >= 3 && pin <= 5) ||
+        (pin >= 12 && pin <= 15) ||
+        (!psramFound() && pin >= 16 && pin <= 17) ||
+        (pin >= 18 && pin <= 19) ||
+        (pin >= 21 && pin <= 23) || (pin >= 25 && pin <= 27) || (pin >= 32 && pin <= 39);
+#elif CONFIG_IDF_TARGET_ESP32S2
+    // Datasheet https://www.espressif.com/sites/default/files/documentation/esp32-s2_datasheet_en.pdf,
+    // Pinout    https://docs.espressif.com/projects/esp-idf/en/latest/esp32s2/_images/esp32-s2_saola1-pinout.jpg
+    return (pin >= 1 && pin <= 21) || (pin >= 33 && pin <= 44);
+#elif CONFIG_IDF_TARGET_ESP32C3
+    // Datasheet https://www.espressif.com/sites/default/files/documentation/esp32-c3_datasheet_en.pdf, 
+    // Pinout    https://docs.espressif.com/projects/esp-idf/en/latest/esp32c3/_images/esp32-c3-devkitm-1-v1-pinout.jpg
+    return (pin >= 0 && pin <= 1) || (pin >= 3 && pin <= 7) || (pin >= 18 && pin <= 21);
+#else 
+    return true;
+#endif
+#else
+    return true;
+#endif
+}
+
+bool SoftwareSerial::isValidRxGPIOpin(int8_t pin) {
+    return isValidGPIOpin(pin)
+#if defined(ESP8266)
+        && (pin != 16)
+#endif
+        ;
+}
+
+bool SoftwareSerial::isValidTxGPIOpin(int8_t pin) {
+    return isValidGPIOpin(pin)
+#if defined(ESP32)
+#ifdef CONFIG_IDF_TARGET_ESP32
+        && (pin < 34)
+#elif CONFIG_IDF_TARGET_ESP32S2
+        && (pin <= 45)
+#elif CONFIG_IDF_TARGET_ESP32C3
+        // no restrictions
+#endif
+#endif
+        ;
+}
+
+bool SoftwareSerial::hasRxGPIOPullUp(int8_t pin) {
+#if defined(ESP32)
+    return !(pin >= 34 && pin <= 39);
+#else
+    (void)pin;
+    return true;
+#endif
+}
+
+void SoftwareSerial::setRxGPIOPullUp() {
+    if (m_rxValid) {
+        pinMode(m_rxPin, hasRxGPIOPullUp(m_rxPin) && m_rxGPIOPullupEnabled ? INPUT_PULLUP : INPUT);
+    }
+}
+
+void SoftwareSerial::begin(uint32_t baud, SoftwareSerialConfig config,
+    int8_t rxPin, int8_t txPin,
+    bool invert, int bufCapacity, int isrBufCapacity) {
+    if (-1 != rxPin) m_rxPin = rxPin;
+    if (-1 != txPin) m_txPin = txPin;
+    m_oneWire = (m_rxPin == m_txPin);
+    m_invert = invert;
+    m_dataBits = 5 + (config & 07);
+    m_parityMode = static_cast<SoftwareSerialParity>(config & 070);
+    m_stopBits = 1 + ((config & 0300) ? 1 : 0);
+    m_pduBits = m_dataBits + static_cast<bool>(m_parityMode) + m_stopBits;
+    m_bitCycles = (ESP.getCpuFreqMHz() * 1000000UL + baud / 2) / baud;
+    m_intTxEnabled = true;
+    if (isValidRxGPIOpin(m_rxPin)) {
+        m_buffer.reset(new circular_queue<uint8_t>((bufCapacity > 0) ? bufCapacity : 64));
+        if (m_parityMode)
+        {
+            m_parityBuffer.reset(new circular_queue<uint8_t>((m_buffer->capacity() + 7) / 8));
+            m_parityInPos = m_parityOutPos = 1;
+        }
+        m_isrBuffer.reset(new circular_queue<uint32_t, SoftwareSerial*>((isrBufCapacity > 0) ?
+            isrBufCapacity : m_buffer->capacity() * (2 + m_dataBits + static_cast<bool>(m_parityMode))));
+        if (m_buffer && (!m_parityMode || m_parityBuffer) && m_isrBuffer) {
+            m_rxValid = true;
+            setRxGPIOPullUp();
+        }
+    }
+    if (isValidTxGPIOpin(m_txPin)) {
+        m_txValid = true;
+        if (!m_oneWire) {
+            pinMode(m_txPin, OUTPUT);
+            digitalWrite(m_txPin, !m_invert);
+        }
+    }
+    if (!m_rxEnabled) { enableRx(true); }
+}
+
+void SoftwareSerial::end()
+{
+    enableRx(false);
+    m_txValid = false;
+    if (m_buffer) {
+        m_buffer.reset();
+    }
+    m_parityBuffer.reset();
+    if (m_isrBuffer) {
+        m_isrBuffer.reset();
+    }
+}
+
+uint32_t SoftwareSerial::baudRate() {
+    return ESP.getCpuFreqMHz() * 1000000UL / m_bitCycles;
+}
+
+void SoftwareSerial::setTransmitEnablePin(int8_t txEnablePin) {
+    if (isValidTxGPIOpin(txEnablePin)) {
+        m_txEnableValid = true;
+        m_txEnablePin = txEnablePin;
+        pinMode(m_txEnablePin, OUTPUT);
+        digitalWrite(m_txEnablePin, LOW);
+    }
+    else {
+        m_txEnableValid = false;
+    }
+}
+
+void SoftwareSerial::enableIntTx(bool on) {
+    m_intTxEnabled = on;
+}
+
+void SoftwareSerial::enableRxGPIOPullup(bool on) {
+    m_rxGPIOPullupEnabled = on;
+    setRxGPIOPullUp();
+}
+
+void SoftwareSerial::enableTx(bool on) {
+    if (m_txValid && m_oneWire) {
+        if (on) {
+            enableRx(false);
+            pinMode(m_txPin, OUTPUT);
+            digitalWrite(m_txPin, !m_invert);
+        }
+        else {
+            setRxGPIOPullUp();
+            enableRx(true);
+        }
+    }
+}
+
+void SoftwareSerial::enableRx(bool on) {
+    if (m_rxValid) {
+        if (on) {
+            m_rxLastBit = m_pduBits - 1;
+            // Init to stop bit level and current cycle
+            m_isrLastCycle = (ESP.getCycleCount() | 1) ^ m_invert;
+            if (m_bitCycles >= (ESP.getCpuFreqMHz() * 1000000UL) / 74880UL)
+                attachInterruptArg(digitalPinToInterrupt(m_rxPin), reinterpret_cast<void (*)(void*)>(rxBitISR), this, CHANGE);
+            else
+                attachInterruptArg(digitalPinToInterrupt(m_rxPin), reinterpret_cast<void (*)(void*)>(rxBitSyncISR), this, m_invert ? RISING : FALLING);
+        }
+        else {
+            detachInterrupt(digitalPinToInterrupt(m_rxPin));
+        }
+        m_rxEnabled = on;
+    }
+}
+
+int SoftwareSerial::read() {
+    if (!m_rxValid) { return -1; }
+    if (!m_buffer->available()) {
+        rxBits();
+        if (!m_buffer->available()) { return -1; }
+    }
+    auto val = m_buffer->pop();
+    if (m_parityBuffer)
+    {
+        m_lastReadParity = m_parityBuffer->peek() & m_parityOutPos;
+        m_parityOutPos <<= 1;
+        if (!m_parityOutPos)
+        {
+            m_parityOutPos = 1;
+            m_parityBuffer->pop();
+        }
+    }
+    return val;
+}
+
+int SoftwareSerial::read(uint8_t* buffer, size_t size) {
+    if (!m_rxValid) { return 0; }
+    int avail;
+    if (0 == (avail = m_buffer->pop_n(buffer, size))) {
+        rxBits();
+        avail = m_buffer->pop_n(buffer, size);
+    }
+    if (!avail) return 0;
+    if (m_parityBuffer) {
+        uint32_t parityBits = avail;
+        while (m_parityOutPos >>= 1) ++parityBits;
+        m_parityOutPos = (1 << (parityBits % 8));
+        m_parityBuffer->pop_n(nullptr, parityBits / 8);
+    }
+    return avail;
+}
+
+size_t SoftwareSerial::readBytes(uint8_t* buffer, size_t size) {
+    if (!m_rxValid || !size) { return 0; }
+    size_t count = 0;
+    auto start = millis();
+    do {
+        auto readCnt = read(&buffer[count], size - count);
+        count += readCnt;
+        if (count >= size) break;
+        if (readCnt) start = millis();
+        else optimistic_yield(1000UL);
+    } while (millis() - start < _timeout);
+    return count;
+}
+
+int SoftwareSerial::available() {
+    if (!m_rxValid) { return 0; }
+    rxBits();
+    int avail = m_buffer->available();
+    if (!avail) {
+        optimistic_yield(10000UL);
+    }
+    return avail;
+}
+
+void IRAM_ATTR SoftwareSerial::preciseDelay(bool sync) {
+    if (!sync)
+    {
+        // Reenable interrupts while delaying to avoid other tasks piling up
+        if (!m_intTxEnabled) { restoreInterrupts(); }
+        const auto expired = ESP.getCycleCount() - m_periodStart;
+        const int32_t remaining = m_periodDuration - expired;
+        const int32_t ms = remaining > 0 ? remaining / 1000L / static_cast<int32_t>(ESP.getCpuFreqMHz()) : 0;
+        if (ms > 0)
+        {
+            delay(ms);
+        }
+        else
+        {
+            optimistic_yield(10000UL);
+        }
+    }
+    while ((ESP.getCycleCount() - m_periodStart) < m_periodDuration) {}
+    // Disable interrupts again if applicable
+    if (!sync && !m_intTxEnabled) { disableInterrupts(); }
+    m_periodDuration = 0;
+    m_periodStart = ESP.getCycleCount();
+}
+
+void IRAM_ATTR SoftwareSerial::writePeriod(
+    uint32_t dutyCycle, uint32_t offCycle, bool withStopBit) {
+    preciseDelay(true);
+    if (dutyCycle)
+    {
+        digitalWrite(m_txPin, HIGH);
+        m_periodDuration += dutyCycle;
+        if (offCycle || (withStopBit && !m_invert)) preciseDelay(!withStopBit || m_invert);
+    }
+    if (offCycle)
+    {
+        digitalWrite(m_txPin, LOW);
+        m_periodDuration += offCycle;
+        if (withStopBit && m_invert) preciseDelay(false);
+    }
+}
+
+size_t SoftwareSerial::write(uint8_t byte) {
+    return write(&byte, 1);
+}
+
+size_t SoftwareSerial::write(uint8_t byte, SoftwareSerialParity parity) {
+    return write(&byte, 1, parity);
+}
+
+size_t SoftwareSerial::write(const uint8_t* buffer, size_t size) {
+    return write(buffer, size, m_parityMode);
+}
+
+size_t IRAM_ATTR SoftwareSerial::write(const uint8_t* buffer, size_t size, SoftwareSerialParity parity) {
+    if (m_rxValid) { rxBits(); }
+    if (!m_txValid) { return -1; }
+
+    if (m_txEnableValid) {
+        digitalWrite(m_txEnablePin, HIGH);
+    }
+    // Stop bit: if inverted, LOW, otherwise HIGH
+    bool b = !m_invert;
+    uint32_t dutyCycle = 0;
+    uint32_t offCycle = 0;
+    if (!m_intTxEnabled) {
+        // Disable interrupts in order to get a clean transmit timing
+        disableInterrupts();
+    }
+    const uint32_t dataMask = ((1UL << m_dataBits) - 1);
+    bool withStopBit = true;
+    m_periodDuration = 0;
+    m_periodStart = ESP.getCycleCount();
+    for (size_t cnt = 0; cnt < size; ++cnt) {
+        uint8_t byte = pgm_read_byte(buffer + cnt) & dataMask;
+        // push LSB start-data-parity-stop bit pattern into uint32_t
+        // Stop bits: HIGH
+        uint32_t word = ~0UL;
+        // inverted parity bit, performance tweak for xor all-bits-set word
+        if (parity && m_parityMode)
+        {
+            uint32_t parityBit;
+            switch (parity)
+            {
+            case SWSERIAL_PARITY_EVEN:
+                // from inverted, so use odd parity
+                parityBit = byte;
+                parityBit ^= parityBit >> 4;
+                parityBit &= 0xf;
+                parityBit = (0x9669 >> parityBit) & 1;
+                break;
+            case SWSERIAL_PARITY_ODD:
+                // from inverted, so use even parity
+                parityBit = byte;
+                parityBit ^= parityBit >> 4;
+                parityBit &= 0xf;
+                parityBit = (0x6996 >> parityBit) & 1;
+                break;
+            case SWSERIAL_PARITY_MARK:
+                parityBit = 0;
+                break;
+            case SWSERIAL_PARITY_SPACE:
+                // suppresses warning parityBit uninitialized
+            default:
+                parityBit = 1;
+                break;
+            }
+            word ^= parityBit;
+        }
+        word <<= m_dataBits;
+        word |= byte;
+        // Start bit: LOW
+        word <<= 1;
+        if (m_invert) word = ~word;
+        for (int i = 0; i <= m_pduBits; ++i) {
+            bool pb = b;
+            b = word & (1UL << i);
+            if (!pb && b) {
+                writePeriod(dutyCycle, offCycle, withStopBit);
+                withStopBit = false;
+                dutyCycle = offCycle = 0;
+            }
+            if (b) {
+                dutyCycle += m_bitCycles;
+            }
+            else {
+                offCycle += m_bitCycles;
+            }
+        }
+        withStopBit = true;
+    }
+    writePeriod(dutyCycle, offCycle, true);
+    if (!m_intTxEnabled) {
+        // restore the interrupt state if applicable
+        restoreInterrupts();
+    }
+    if (m_txEnableValid) {
+        digitalWrite(m_txEnablePin, LOW);
+    }
+    return size;
+}
+
+void SoftwareSerial::flush() {
+    if (!m_rxValid) { return; }
+    m_buffer->flush();
+    if (m_parityBuffer)
+    {
+        m_parityInPos = m_parityOutPos = 1;
+        m_parityBuffer->flush();
+    }
+}
+
+bool SoftwareSerial::overflow() {
+    bool res = m_overflow;
+    m_overflow = false;
+    return res;
+}
+
+int SoftwareSerial::peek() {
+    if (!m_rxValid) { return -1; }
+    if (!m_buffer->available()) {
+        rxBits();
+        if (!m_buffer->available()) return -1;
+    }
+    auto val = m_buffer->peek();
+    if (m_parityBuffer) m_lastReadParity = m_parityBuffer->peek() & m_parityOutPos;
+    return val;
+}
+
+void SoftwareSerial::rxBits() {
+#ifdef ESP8266
+    if (m_isrOverflow.load()) {
+        m_overflow = true;
+        m_isrOverflow.store(false);
+    }
+#else
+    if (m_isrOverflow.exchange(false)) {
+        m_overflow = true;
+    }
+#endif
+
+    m_isrBuffer->for_each(m_isrBufferForEachDel);
+
+    // A stop bit can go undetected if leading data bits are at same level
+    // and there was also no next start bit yet, so one word may be pending.
+    // Check that there was no new ISR data received in the meantime, inserting an
+    // extraneous stop level bit out of sequence breaks rx.
+    if (m_rxLastBit < m_pduBits - 1) {
+        const uint32_t detectionCycles = (m_pduBits - 1 - m_rxLastBit) * m_bitCycles;
+        if (!m_isrBuffer->available() && ESP.getCycleCount() - m_isrLastCycle > detectionCycles) {
+            // Produce faux stop bit level, prevents start bit maldetection
+            // cycle's LSB is repurposed for the level bit
+            rxBits(((m_isrLastCycle + detectionCycles) | 1) ^ m_invert);
+        }
+    }
+}
+
+void SoftwareSerial::rxBits(const uint32_t isrCycle) {
+    const bool level = (m_isrLastCycle & 1) ^ m_invert;
+
+    // error introduced by edge value in LSB of isrCycle is negligible
+    uint32_t cycles = isrCycle - m_isrLastCycle;
+    m_isrLastCycle = isrCycle;
+
+    uint32_t bits = cycles / m_bitCycles;
+    if (cycles % m_bitCycles > (m_bitCycles >> 1)) ++bits;
+    while (bits > 0) {
+        // start bit detection
+        if (m_rxLastBit >= (m_pduBits - 1)) {
+            // leading edge of start bit?
+            if (level) break;
+            m_rxLastBit = -1;
+            --bits;
+            continue;
+        }
+        // data bits
+        if (m_rxLastBit < (m_dataBits - 1)) {
+            uint8_t dataBits = min(bits, static_cast<uint32_t>(m_dataBits - 1 - m_rxLastBit));
+            m_rxLastBit += dataBits;
+            bits -= dataBits;
+            m_rxCurByte >>= dataBits;
+            if (level) { m_rxCurByte |= (BYTE_ALL_BITS_SET << (8 - dataBits)); }
+            continue;
+        }
+        // parity bit
+        if (m_parityMode && m_rxLastBit == (m_dataBits - 1)) {
+            ++m_rxLastBit;
+            --bits;
+            m_rxCurParity = level;
+            continue;
+        }
+        // stop bits
+        // Store the received value in the buffer unless we have an overflow
+        // if not high stop bit level, discard word
+        if (bits >= static_cast<uint32_t>(m_pduBits - 1 - m_rxLastBit) && level) {
+            m_rxCurByte >>= (sizeof(uint8_t) * 8 - m_dataBits);
+            if (!m_buffer->push(m_rxCurByte)) {
+                m_overflow = true;
+            }
+            else {
+                if (m_parityBuffer)
+                {
+                    if (m_rxCurParity) {
+                        m_parityBuffer->pushpeek() |= m_parityInPos;
+                    }
+                    else {
+                        m_parityBuffer->pushpeek() &= ~m_parityInPos;
+                    }
+                    m_parityInPos <<= 1;
+                    if (!m_parityInPos)
+                    {
+                        m_parityBuffer->push();
+                        m_parityInPos = 1;
+                    }
+                }
+            }
+        }
+        m_rxLastBit = m_pduBits - 1;
+        // reset to 0 is important for masked bit logic
+        m_rxCurByte = 0;
+        m_rxCurParity = false;
+        break;
+    }
+}
+
+void IRAM_ATTR SoftwareSerial::rxBitISR(SoftwareSerial* self) {
+    uint32_t curCycle = ESP.getCycleCount();
+    bool level = digitalRead(self->m_rxPin);
+
+    // Store level and cycle in the buffer unless we have an overflow
+    // cycle's LSB is repurposed for the level bit
+    if (!self->m_isrBuffer->push((curCycle | 1U) ^ !level)) self->m_isrOverflow.store(true);
+}
+
+void IRAM_ATTR SoftwareSerial::rxBitSyncISR(SoftwareSerial* self) {
+    uint32_t start = ESP.getCycleCount();
+    uint32_t wait = self->m_bitCycles - 172U;
+
+    bool level = self->m_invert;
+    // Store level and cycle in the buffer unless we have an overflow
+    // cycle's LSB is repurposed for the level bit
+    if (!self->m_isrBuffer->push(((start + wait) | 1U) ^ !level)) self->m_isrOverflow.store(true);
+
+    for (uint32_t i = 0; i < self->m_pduBits; ++i) {
+        while (ESP.getCycleCount() - start < wait) {};
+        wait += self->m_bitCycles;
+
+        // Store level and cycle in the buffer unless we have an overflow
+        // cycle's LSB is repurposed for the level bit
+        if (digitalRead(self->m_rxPin) != level)
+        {
+            if (!self->m_isrBuffer->push(((start + wait) | 1U) ^ level)) self->m_isrOverflow.store(true);
+            level = !level;
+        }
+    }
+}
+
+void SoftwareSerial::onReceive(Delegate<void(int available), void*> handler) {
+    receiveHandler = handler;
+}
+
+void SoftwareSerial::perform_work() {
+    if (!m_rxValid) { return; }
+    rxBits();
+    if (receiveHandler) {
+        int avail = m_buffer->available();
+        if (avail) { receiveHandler(avail); }
+    }
+}

ampel-firmware/src/lib/EspSoftwareSerial/SoftwareSerial.h

+/*
+SoftwareSerial.h
+
+SoftwareSerial.cpp - Implementation of the Arduino software serial for ESP8266/ESP32.
+Copyright (c) 2015-2016 Peter Lerup. All rights reserved.
+Copyright (c) 2018-2019 Dirk O. Kaar. All rights 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 __SoftwareSerial_h
+#define __SoftwareSerial_h
+
+#include "circular_queue/circular_queue.h"
+#include <Stream.h>
+
+enum SoftwareSerialParity : uint8_t {
+    SWSERIAL_PARITY_NONE = 000,
+    SWSERIAL_PARITY_EVEN = 020,
+    SWSERIAL_PARITY_ODD = 030,
+    SWSERIAL_PARITY_MARK = 040,
+    SWSERIAL_PARITY_SPACE = 070,
+};
+
+enum SoftwareSerialConfig {
+    SWSERIAL_5N1 = SWSERIAL_PARITY_NONE,
+    SWSERIAL_6N1,
+    SWSERIAL_7N1,
+    SWSERIAL_8N1,
+    SWSERIAL_5E1 = SWSERIAL_PARITY_EVEN,
+    SWSERIAL_6E1,
+    SWSERIAL_7E1,
+    SWSERIAL_8E1,
+    SWSERIAL_5O1 = SWSERIAL_PARITY_ODD,
+    SWSERIAL_6O1,
+    SWSERIAL_7O1,
+    SWSERIAL_8O1,
+    SWSERIAL_5M1 = SWSERIAL_PARITY_MARK,
+    SWSERIAL_6M1,
+    SWSERIAL_7M1,
+    SWSERIAL_8M1,
+    SWSERIAL_5S1 = SWSERIAL_PARITY_SPACE,
+    SWSERIAL_6S1,
+    SWSERIAL_7S1,
+    SWSERIAL_8S1,
+    SWSERIAL_5N2 = 0200 | SWSERIAL_PARITY_NONE,
+    SWSERIAL_6N2,
+    SWSERIAL_7N2,
+    SWSERIAL_8N2,
+    SWSERIAL_5E2 = 0200 | SWSERIAL_PARITY_EVEN,
+    SWSERIAL_6E2,
+    SWSERIAL_7E2,
+    SWSERIAL_8E2,
+    SWSERIAL_5O2 = 0200 | SWSERIAL_PARITY_ODD,
+    SWSERIAL_6O2,
+    SWSERIAL_7O2,
+    SWSERIAL_8O2,
+    SWSERIAL_5M2 = 0200 | SWSERIAL_PARITY_MARK,
+    SWSERIAL_6M2,
+    SWSERIAL_7M2,
+    SWSERIAL_8M2,
+    SWSERIAL_5S2 = 0200 | SWSERIAL_PARITY_SPACE,
+    SWSERIAL_6S2,
+    SWSERIAL_7S2,
+    SWSERIAL_8S2,
+};
+
+/// This class is compatible with the corresponding AVR one, however,
+/// the constructor takes no arguments, for compatibility with the
+/// HardwareSerial class.
+/// Instead, the begin() function handles pin assignments and logic inversion.
+/// It also has optional input buffer capacity arguments for byte buffer and ISR bit buffer.
+/// Bitrates up to at least 115200 can be used.
+class SoftwareSerial : public Stream {
+public:
+    SoftwareSerial();
+    /// Ctor to set defaults for pins.
+    /// @param rxPin the GPIO pin used for RX
+    /// @param txPin -1 for onewire protocol, GPIO pin used for twowire TX
+    SoftwareSerial(int8_t rxPin, int8_t txPin = -1, bool invert = false);
+    SoftwareSerial(const SoftwareSerial&) = delete;
+    SoftwareSerial& operator= (const SoftwareSerial&) = delete;
+    virtual ~SoftwareSerial();
+    /// Configure the SoftwareSerial object for use.
+    /// @param baud the TX/RX bitrate
+    /// @param config sets databits, parity, and stop bit count
+    /// @param rxPin -1 or default: either no RX pin, or keeps the rxPin set in the ctor
+    /// @param txPin -1 or default: either no TX pin (onewire), or keeps the txPin set in the ctor
+    /// @param invert true: uses invert line level logic
+    /// @param bufCapacity the capacity for the received bytes buffer
+    /// @param isrBufCapacity 0: derived from bufCapacity. The capacity of the internal asynchronous
+    ///	       bit receive buffer, a suggested size is bufCapacity times the sum of
+    ///	       start, data, parity and stop bit count.
+    void begin(uint32_t baud, SoftwareSerialConfig config,
+        int8_t rxPin, int8_t txPin, bool invert,
+        int bufCapacity = 64, int isrBufCapacity = 0);
+    void begin(uint32_t baud, SoftwareSerialConfig config,
+        int8_t rxPin, int8_t txPin) {
+        begin(baud, config, rxPin, txPin, m_invert);
+    }
+    void begin(uint32_t baud, SoftwareSerialConfig config,
+        int8_t rxPin) {
+        begin(baud, config, rxPin, m_txPin, m_invert);
+    }
+    void begin(uint32_t baud, SoftwareSerialConfig config = SWSERIAL_8N1) {
+        begin(baud, config, m_rxPin, m_txPin, m_invert);
+    }
+
+    uint32_t baudRate();
+    /// Transmit control pin.
+    void setTransmitEnablePin(int8_t txEnablePin);
+    /// Enable (default) or disable interrupts during tx.
+    void enableIntTx(bool on);
+    /// Enable (default) or disable internal rx GPIO pullup.
+    void enableRxGPIOPullup(bool on);
+
+    bool overflow();
+
+    int available() override;
+#if defined(ESP8266)
+    int availableForWrite() override {
+#else
+    int availableForWrite() {
+#endif
+        if (!m_txValid) return 0;
+        return 1;
+    }
+    int peek() override;
+    int read() override;
+    /// @returns The verbatim parity bit associated with the last successful read() or peek() call
+    bool readParity()
+    {
+        return m_lastReadParity;
+    }
+    /// @returns The calculated bit for even parity of the parameter byte
+    static bool parityEven(uint8_t byte) {
+        byte ^= byte >> 4;
+        byte &= 0xf;
+        return (0x6996 >> byte) & 1;
+    }
+    /// @returns The calculated bit for odd parity of the parameter byte
+    static bool parityOdd(uint8_t byte) {
+        byte ^= byte >> 4;
+        byte &= 0xf;
+        return (0x9669 >> byte) & 1;
+    }
+    /// The read(buffer, size) functions are non-blocking, the same as readBytes but without timeout
+    int read(uint8_t* buffer, size_t size)
+#if defined(ESP8266)
+        override
+#endif
+        ;
+    /// The read(buffer, size) functions are non-blocking, the same as readBytes but without timeout
+    int read(char* buffer, size_t size) {
+        return read(reinterpret_cast<uint8_t*>(buffer), size);
+    }
+    /// @returns The number of bytes read into buffer, up to size. Times out if the limit set through
+    ///          Stream::setTimeout() is reached.
+    size_t readBytes(uint8_t* buffer, size_t size) override;
+    /// @returns The number of bytes read into buffer, up to size. Times out if the limit set through
+    ///          Stream::setTimeout() is reached.
+    size_t readBytes(char* buffer, size_t size) override {
+        return readBytes(reinterpret_cast<uint8_t*>(buffer), size);
+    }
+    void flush() override;
+    size_t write(uint8_t byte) override;
+    size_t write(uint8_t byte, SoftwareSerialParity parity);
+    size_t write(const uint8_t* buffer, size_t size) override;
+    size_t write(const char* buffer, size_t size) {
+        return write(reinterpret_cast<const uint8_t*>(buffer), size);
+    }
+    size_t write(const uint8_t* buffer, size_t size, SoftwareSerialParity parity);
+    size_t write(const char* buffer, size_t size, SoftwareSerialParity parity) {
+        return write(reinterpret_cast<const uint8_t*>(buffer), size, parity);
+    }
+    operator bool() const {
+        return (-1 == m_rxPin || m_rxValid) && (-1 == m_txPin || m_txValid) && !(-1 == m_rxPin && m_oneWire);
+    }
+
+    /// Disable or enable interrupts on the rx pin.
+    void enableRx(bool on);
+    /// One wire control.
+    void enableTx(bool on);
+
+    // AVR compatibility methods.
+    bool listen() { enableRx(true); return true; }
+    void end();
+    bool isListening() { return m_rxEnabled; }
+    bool stopListening() { enableRx(false); return true; }
+
+    /// Set an event handler for received data.
+    void onReceive(Delegate<void(int available), void*> handler);
+
+    /// Run the internal processing and event engine. Can be iteratively called
+    /// from loop, or otherwise scheduled.
+    void perform_work();
+
+    using Print::write;
+
+private:
+    // If sync is false, it's legal to exceed the deadline, for instance,
+    // by enabling interrupts.
+    void preciseDelay(bool sync);
+    // If withStopBit is set, either cycle contains a stop bit.
+    // If dutyCycle == 0, the level is not forced to HIGH.
+    // If offCycle == 0, the level remains unchanged from dutyCycle.
+    void writePeriod(
+        uint32_t dutyCycle, uint32_t offCycle, bool withStopBit);
+    bool isValidGPIOpin(int8_t pin);
+    bool isValidRxGPIOpin(int8_t pin);
+    bool isValidTxGPIOpin(int8_t pin);
+    // result is only defined for a valid Rx GPIO pin
+    bool hasRxGPIOPullUp(int8_t pin);
+    // safely set the pin mode for the Rx GPIO pin
+    void setRxGPIOPullUp();
+    /* check m_rxValid that calling is safe */
+    void rxBits();
+    void rxBits(const uint32_t isrCycle);
+    static void disableInterrupts();
+    static void restoreInterrupts();
+
+    static void rxBitISR(SoftwareSerial* self);
+    static void rxBitSyncISR(SoftwareSerial* self);
+
+    // Member variables
+    int8_t m_rxPin = -1;
+    int8_t m_txPin = -1;
+    int8_t m_txEnablePin = -1;
+    uint8_t m_dataBits;
+    bool m_oneWire;
+    bool m_rxValid = false;
+    bool m_rxEnabled = false;
+    bool m_txValid = false;
+    bool m_txEnableValid = false;
+    bool m_invert;
+    /// PDU bits include data, parity and stop bits; the start bit is not counted.
+    uint8_t m_pduBits;
+    bool m_intTxEnabled;
+    bool m_rxGPIOPullupEnabled;
+    SoftwareSerialParity m_parityMode;
+    uint8_t m_stopBits;
+    bool m_lastReadParity;
+    bool m_overflow = false;
+    uint32_t m_bitCycles;
+    uint8_t m_parityInPos;
+    uint8_t m_parityOutPos;
+    int8_t m_rxLastBit; // 0 thru (m_pduBits - m_stopBits - 1): data/parity bits. -1: start bit. (m_pduBits - 1): stop bit.
+    uint8_t m_rxCurByte = 0;
+    std::unique_ptr<circular_queue<uint8_t> > m_buffer;
+    std::unique_ptr<circular_queue<uint8_t> > m_parityBuffer;
+    uint32_t m_periodStart;
+    uint32_t m_periodDuration;
+#ifndef ESP32
+    static uint32_t m_savedPS;
+#else
+    static portMUX_TYPE m_interruptsMux;
+#endif
+    // the ISR stores the relative bit times in the buffer. The inversion corrected level is used as sign bit (2's complement):
+    // 1 = positive including 0, 0 = negative.
+    std::unique_ptr<circular_queue<uint32_t, SoftwareSerial*> > m_isrBuffer;
+    const Delegate<void(uint32_t&&), SoftwareSerial*> m_isrBufferForEachDel = { [](SoftwareSerial* self, uint32_t&& isrCycle) { self->rxBits(isrCycle); }, this };
+    std::atomic<bool> m_isrOverflow;
+    uint32_t m_isrLastCycle;
+    bool m_rxCurParity = false;
+    Delegate<void(int available), void*> receiveHandler;
+};
+
+#endif // __SoftwareSerial_h

ampel-firmware/src/lib/EspSoftwareSerial/circular_queue/Delegate.h

+/*
+Delegate.h - An efficient interchangeable C function ptr and C++ std::function delegate
+Copyright (c) 2019 Dirk O. Kaar. All rights 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 __Delegate_h
+#define __Delegate_h
+
+#if defined(ESP8266)
+#include <c_types.h>
+#elif defined(ESP32)
+#include <esp_attr.h>
+#else
+#define IRAM_ATTR
+#endif
+
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+#include <functional>
+#include <cstddef>
+#else
+#include "circular_queue/ghostl.h"
+#endif
+
+namespace
+{
+
+    template<typename R, typename... P>
+    R IRAM_ATTR vPtrToFunPtrExec(void* fn, P... args)
+    {
+        using target_type = R(P...);
+        return reinterpret_cast<target_type*>(fn)(std::forward<P...>(args...));
+    }
+
+}
+
+namespace delegate
+{
+    namespace detail
+    {
+
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+        template<typename A, typename R, typename... P>
+        class DelegatePImpl {
+        public:
+            using target_type = R(P...);
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A, P...);
+            using FunVPPtr = R(*)(void*, P...);
+            using FunctionType = std::function<target_type>;
+        public:
+            DelegatePImpl()
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegatePImpl(std::nullptr_t)
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            ~DelegatePImpl()
+            {
+                if (FUNC == kind)
+                    functional.~FunctionType();
+                else if (FPA == kind)
+                    obj.~A();
+            }
+
+            DelegatePImpl(const DelegatePImpl& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(del.functional);
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    new (&obj) A(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegatePImpl(DelegatePImpl&& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(std::move(del.functional));
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    new (&obj) A(std::move(del.obj));
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegatePImpl(FunAPtr fnA, const A& obj)
+            {
+                kind = FPA;
+                DelegatePImpl::fnA = fnA;
+                new (&this->obj) A(obj);
+            }
+
+            DelegatePImpl(FunAPtr fnA, A&& obj)
+            {
+                kind = FPA;
+                DelegatePImpl::fnA = fnA;
+                new (&this->obj) A(std::move(obj));
+            }
+
+            DelegatePImpl(FunPtr fn)
+            {
+                kind = FP;
+                DelegatePImpl::fn = fn;
+            }
+
+            template<typename F> DelegatePImpl(F functional)
+            {
+                kind = FUNC;
+                new (&this->functional) FunctionType(std::forward<F>(functional));
+            }
+
+            DelegatePImpl& operator=(const DelegatePImpl& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FUNC == kind)
+                    {
+                        functional.~FunctionType();
+                    }
+                    else if (FPA == kind)
+                    {
+                        obj.~A();
+                    }
+                    if (FUNC == del.kind)
+                    {
+                        new (&this->functional) FunctionType();
+                    }
+                    else if (FPA == del.kind)
+                    {
+                        new (&obj) A;
+                    }
+                    kind = del.kind;
+                }
+                if (FUNC == del.kind)
+                {
+                    functional = del.functional;
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = del.obj;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegatePImpl& operator=(DelegatePImpl&& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FUNC == kind)
+                    {
+                        functional.~FunctionType();
+                    }
+                    else if (FPA == kind)
+                    {
+                        obj.~A();
+                    }
+                    if (FUNC == del.kind)
+                    {
+                        new (&this->functional) FunctionType();
+                    }
+                    else if (FPA == del.kind)
+                    {
+                        new (&obj) A;
+                    }
+                    kind = del.kind;
+                }
+                if (FUNC == del.kind)
+                {
+                    functional = std::move(del.functional);
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = std::move(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegatePImpl& operator=(FunPtr fn)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FPA == kind)
+                {
+                    obj.~A();
+                }
+                kind = FP;
+                this->fn = fn;
+                return *this;
+            }
+
+            DelegatePImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FPA == kind)
+                {
+                    obj.~A();
+                }
+                kind = FP;
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else if (FPA == kind)
+                {
+                    return fnA;
+                }
+                else
+                {
+                    return functional ? true : false;
+                }
+            }
+
+            static R IRAM_ATTR vPtrToFunAPtrExec(void* self, P... args)
+            {
+                return static_cast<DelegatePImpl*>(self)->fnA(
+                    static_cast<DelegatePImpl*>(self)->obj,
+                    std::forward<P...>(args...));
+            };
+
+            operator FunVPPtr() const
+            {
+                if (FP == kind)
+                {
+                    return vPtrToFunPtrExec<R, P...>;
+                }
+                else if (FPA == kind)
+                {
+                    return vPtrToFunAPtrExec;
+                }
+                else
+                {
+                    return [](void* self, P... args) -> R
+                    {
+                        return static_cast<DelegatePImpl*>(self)->functional(std::forward<P...>(args...));
+                    };
+                }
+            }
+
+            void* arg() const
+            {
+                if (FP == kind)
+                {
+                    return reinterpret_cast<void*>(fn);
+                }
+                else
+                {
+                    return const_cast<DelegatePImpl*>(this);
+                }
+            }
+
+            operator FunctionType() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else if (FPA == kind)
+                {
+                    return [this](P... args) { return fnA(obj, std::forward<P...>(args...)); };
+                }
+                else
+                {
+                    return functional;
+                }
+            }
+
+            R IRAM_ATTR operator()(P... args) const
+            {
+                if (FP == kind)
+                {
+                    return fn(std::forward<P...>(args...));
+                }
+                else if (FPA == kind)
+                {
+                    return fnA(obj, std::forward<P...>(args...));
+                }
+                else
+                {
+                    return functional(std::forward<P...>(args...));
+                }
+            }
+
+        protected:
+            union {
+                FunctionType functional;
+                FunPtr fn;
+                struct {
+                    FunAPtr fnA;
+                    A obj;
+                };
+            };
+            enum { FUNC, FP, FPA } kind;
+        };
+#else
+        template<typename A, typename R, typename... P>
+        class DelegatePImpl {
+        public:
+            using target_type = R(P...);
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A, P...);
+            using FunVPPtr = R(*)(void*, P...);
+        public:
+            DelegatePImpl()
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegatePImpl(std::nullptr_t)
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegatePImpl(const DelegatePImpl& del)
+            {
+                kind = del.kind;
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = del.obj;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegatePImpl(DelegatePImpl&& del)
+            {
+                kind = del.kind;
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = std::move(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegatePImpl(FunAPtr fnA, const A& obj)
+            {
+                kind = FPA;
+                DelegatePImpl::fnA = fnA;
+                this->obj = obj;
+            }
+
+            DelegatePImpl(FunAPtr fnA, A&& obj)
+            {
+                kind = FPA;
+                DelegatePImpl::fnA = fnA;
+                this->obj = std::move(obj);
+            }
+
+            DelegatePImpl(FunPtr fn)
+            {
+                kind = FP;
+                DelegatePImpl::fn = fn;
+            }
+
+            template<typename F> DelegatePImpl(F functional)
+            {
+                kind = FP;
+                fn = std::forward<F>(functional);
+            }
+
+            DelegatePImpl& operator=(const DelegatePImpl& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FPA == kind)
+                    {
+                        obj = {};
+                    }
+                    kind = del.kind;
+                }
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = del.obj;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegatePImpl& operator=(DelegatePImpl&& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FPA == kind)
+                    {
+                        obj = {};
+                    }
+                    kind = del.kind;
+                }
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = std::move(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegatePImpl& operator=(FunPtr fn)
+            {
+                if (FPA == kind)
+                {
+                    obj = {};
+                }
+                kind = FP;
+                this->fn = fn;
+                return *this;
+            }
+
+            DelegatePImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                if (FPA == kind)
+                {
+                    obj = {};
+                }
+                kind = FP;
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else
+                {
+                    return fnA;
+                }
+            }
+
+            static R IRAM_ATTR vPtrToFunAPtrExec(void* self, P... args)
+            {
+                return static_cast<DelegatePImpl*>(self)->fnA(
+                    static_cast<DelegatePImpl*>(self)->obj,
+                    std::forward<P...>(args...));
+            };
+
+            operator FunVPPtr() const
+            {
+                if (FP == kind)
+                {
+                    return vPtrToFunPtrExec<R, P...>;
+                }
+                else
+                {
+                    return vPtrToFunAPtrExec;
+                }
+            }
+
+            void* arg() const
+            {
+                if (FP == kind)
+                {
+                    return reinterpret_cast<void*>(fn);
+                }
+                else
+                {
+                    return const_cast<DelegatePImpl*>(this);
+                }
+            }
+
+            R IRAM_ATTR operator()(P... args) const
+            {
+                if (FP == kind)
+                {
+                    return fn(std::forward<P...>(args...));
+                }
+                else
+                {
+                    return fnA(obj, std::forward<P...>(args...));
+                }
+            }
+
+        protected:
+            union {
+                FunPtr fn;
+                FunAPtr fnA;
+            };
+            A obj;
+            enum { FP, FPA } kind;
+        };
+#endif
+
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+        template<typename R, typename... P>
+        class DelegatePImpl<void, R, P...> {
+        public:
+            using target_type = R(P...);
+        protected:
+            using FunPtr = target_type*;
+            using FunctionType = std::function<target_type>;
+            using FunVPPtr = R(*)(void*, P...);
+        public:
+            DelegatePImpl()
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegatePImpl(std::nullptr_t)
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            ~DelegatePImpl()
+            {
+                if (FUNC == kind)
+                    functional.~FunctionType();
+            }
+
+            DelegatePImpl(const DelegatePImpl& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(del.functional);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegatePImpl(DelegatePImpl&& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(std::move(del.functional));
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegatePImpl(FunPtr fn)
+            {
+                kind = FP;
+                DelegatePImpl::fn = fn;
+            }
+
+            template<typename F> DelegatePImpl(F functional)
+            {
+                kind = FUNC;
+                new (&this->functional) FunctionType(std::forward<F>(functional));
+            }
+
+            DelegatePImpl& operator=(const DelegatePImpl& del)
+            {
+                if (this == &del) return *this;
+                if (FUNC == kind && FUNC != del.kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FUNC != kind && FUNC == del.kind)
+                {
+                    new (&this->functional) FunctionType();
+                }
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    functional = del.functional;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegatePImpl& operator=(DelegatePImpl&& del)
+            {
+                if (this == &del) return *this;
+                if (FUNC == kind && FUNC != del.kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FUNC != kind && FUNC == del.kind)
+                {
+                    new (&this->functional) FunctionType();
+                }
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    functional = std::move(del.functional);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegatePImpl& operator=(FunPtr fn)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                    kind = FP;
+                }
+                DelegatePImpl::fn = fn;
+                return *this;
+            }
+
+            DelegatePImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                }
+                kind = FP;
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else
+                {
+                    return functional ? true : false;
+                }
+            }
+
+            operator FunVPPtr() const
+            {
+                if (FP == kind)
+                {
+                    return vPtrToFunPtrExec<R, P...>;
+                }
+                else
+                {
+                    return [](void* self, P... args) -> R
+                    {
+                        return static_cast<DelegatePImpl*>(self)->functional(std::forward<P...>(args...));
+                    };
+                }
+            }
+
+            void* arg() const
+            {
+                if (FP == kind)
+                {
+                    return reinterpret_cast<void*>(fn);
+                }
+                else
+                {
+                    return const_cast<DelegatePImpl*>(this);
+                }
+            }
+
+            operator FunctionType() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else
+                {
+                    return functional;
+                }
+            }
+
+            R IRAM_ATTR operator()(P... args) const
+            {
+                if (FP == kind)
+                {
+                    return fn(std::forward<P...>(args...));
+                }
+                else
+                {
+                    return functional(std::forward<P...>(args...));
+                }
+            }
+
+        protected:
+            union {
+                FunctionType functional;
+                FunPtr fn;
+            };
+            enum { FUNC, FP } kind;
+        };
+#else
+        template<typename R, typename... P>
+        class DelegatePImpl<void, R, P...> {
+        public:
+            using target_type = R(P...);
+        protected:
+            using FunPtr = target_type*;
+            using FunVPPtr = R(*)(void*, P...);
+        public:
+            DelegatePImpl()
+            {
+                fn = nullptr;
+            }
+
+            DelegatePImpl(std::nullptr_t)
+            {
+                fn = nullptr;
+            }
+
+            DelegatePImpl(const DelegatePImpl& del)
+            {
+                fn = del.fn;
+            }
+
+            DelegatePImpl(DelegatePImpl&& del)
+            {
+                fn = std::move(del.fn);
+            }
+
+            DelegatePImpl(FunPtr fn)
+            {
+                DelegatePImpl::fn = fn;
+            }
+
+            template<typename F> DelegatePImpl(F fn)
+            {
+                DelegatePImpl::fn = std::forward<F>(fn);
+            }
+
+            DelegatePImpl& operator=(const DelegatePImpl& del)
+            {
+                if (this == &del) return *this;
+                fn = del.fn;
+                return *this;
+            }
+
+            DelegatePImpl& operator=(DelegatePImpl&& del)
+            {
+                if (this == &del) return *this;
+                fn = std::move(del.fn);
+                return *this;
+            }
+
+            DelegatePImpl& operator=(FunPtr fn)
+            {
+                DelegatePImpl::fn = fn;
+                return *this;
+            }
+
+            DelegatePImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                return fn;
+            }
+
+            operator FunVPPtr() const
+            {
+                return vPtrToFunPtrExec<R, P...>;
+            }
+
+            void* arg() const
+            {
+                return reinterpret_cast<void*>(fn);
+            }
+
+            R IRAM_ATTR operator()(P... args) const
+            {
+                return fn(std::forward<P...>(args...));
+            }
+
+        protected:
+            FunPtr fn;
+        };
+#endif
+
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+        template<typename A, typename R>
+        class DelegateImpl {
+        public:
+            using target_type = R();
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A);
+            using FunctionType = std::function<target_type>;
+            using FunVPPtr = R(*)(void*);
+        public:
+            DelegateImpl()
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegateImpl(std::nullptr_t)
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            ~DelegateImpl()
+            {
+                if (FUNC == kind)
+                    functional.~FunctionType();
+                else if (FPA == kind)
+                    obj.~A();
+            }
+
+            DelegateImpl(const DelegateImpl& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(del.functional);
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    new (&obj) A(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegateImpl(DelegateImpl&& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(std::move(del.functional));
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    new (&obj) A(std::move(del.obj));
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegateImpl(FunAPtr fnA, const A& obj)
+            {
+                kind = FPA;
+                DelegateImpl::fnA = fnA;
+                new (&this->obj) A(obj);
+            }
+
+            DelegateImpl(FunAPtr fnA, A&& obj)
+            {
+                kind = FPA;
+                DelegateImpl::fnA = fnA;
+                new (&this->obj) A(std::move(obj));
+            }
+
+            DelegateImpl(FunPtr fn)
+            {
+                kind = FP;
+                DelegateImpl::fn = fn;
+            }
+
+            template<typename F> DelegateImpl(F functional)
+            {
+                kind = FUNC;
+                new (&this->functional) FunctionType(std::forward<F>(functional));
+            }
+
+            DelegateImpl& operator=(const DelegateImpl& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FUNC == kind)
+                    {
+                        functional.~FunctionType();
+                    }
+                    else if (FPA == kind)
+                    {
+                        obj.~A();
+                    }
+                    if (FUNC == del.kind)
+                    {
+                        new (&this->functional) FunctionType();
+                    }
+                    else if (FPA == del.kind)
+                    {
+                        new (&obj) A;
+                    }
+                    kind = del.kind;
+                }
+                if (FUNC == del.kind)
+                {
+                    functional = del.functional;
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = del.obj;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegateImpl& operator=(DelegateImpl&& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FUNC == kind)
+                    {
+                        functional.~FunctionType();
+                    }
+                    else if (FPA == kind)
+                    {
+                        obj.~A();
+                    }
+                    if (FUNC == del.kind)
+                    {
+                        new (&this->functional) FunctionType();
+                    }
+                    else if (FPA == del.kind)
+                    {
+                        new (&obj) A;
+                    }
+                    kind = del.kind;
+                }
+                if (FUNC == del.kind)
+                {
+                    functional = std::move(del.functional);
+                }
+                else if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = std::move(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegateImpl& operator=(FunPtr fn)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FPA == kind)
+                {
+                    obj.~A();
+                }
+                kind = FP;
+                this->fn = fn;
+                return *this;
+            }
+
+            DelegateImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FPA == kind)
+                {
+                    obj.~A();
+                }
+                kind = FP;
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else if (FPA == kind)
+                {
+                    return fnA;
+                }
+                else
+                {
+                    return functional ? true : false;
+                }
+            }
+
+            static R IRAM_ATTR vPtrToFunAPtrExec(void* self)
+            {
+                return static_cast<DelegateImpl*>(self)->fnA(
+                    static_cast<DelegateImpl*>(self)->obj);
+            };
+
+            operator FunVPPtr() const
+            {
+                if (FP == kind)
+                {
+                    return reinterpret_cast<FunVPPtr>(fn);
+                }
+                else if (FPA == kind)
+                {
+                    return vPtrToFunAPtrExec;
+                }
+                else
+                {
+                    return [](void* self) -> R
+                    {
+                        return static_cast<DelegateImpl*>(self)->functional();
+                    };
+                }
+            }
+
+            void* arg() const
+            {
+                if (FP == kind)
+                {
+                    return nullptr;
+                }
+                else
+                {
+                    return const_cast<DelegateImpl*>(this);
+                }
+            }
+
+            operator FunctionType() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else if (FPA == kind)
+                {
+                    return [this]() { return fnA(obj); };
+                }
+                else
+                {
+                    return functional;
+                }
+            }
+
+            R IRAM_ATTR operator()() const
+            {
+                if (FP == kind)
+                {
+                    return fn();
+                }
+                else if (FPA == kind)
+                {
+                    return fnA(obj);
+                }
+                else
+                {
+                    return functional();
+                }
+            }
+
+        protected:
+            union {
+                FunctionType functional;
+                FunPtr fn;
+                struct {
+                    FunAPtr fnA;
+                    A obj;
+                };
+            };
+            enum { FUNC, FP, FPA } kind;
+        };
+#else
+        template<typename A, typename R>
+        class DelegateImpl {
+        public:
+            using target_type = R();
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A);
+            using FunVPPtr = R(*)(void*);
+        public:
+            DelegateImpl()
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegateImpl(std::nullptr_t)
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegateImpl(const DelegateImpl& del)
+            {
+                kind = del.kind;
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = del.obj;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegateImpl(DelegateImpl&& del)
+            {
+                kind = del.kind;
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = std::move(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegateImpl(FunAPtr fnA, const A& obj)
+            {
+                kind = FPA;
+                DelegateImpl::fnA = fnA;
+                this->obj = obj;
+            }
+
+            DelegateImpl(FunAPtr fnA, A&& obj)
+            {
+                kind = FPA;
+                DelegateImpl::fnA = fnA;
+                this->obj = std::move(obj);
+            }
+
+            DelegateImpl(FunPtr fn)
+            {
+                kind = FP;
+                DelegateImpl::fn = fn;
+            }
+
+            template<typename F> DelegateImpl(F fn)
+            {
+                kind = FP;
+                DelegateImpl::fn = std::forward<F>(fn);
+            }
+
+            DelegateImpl& operator=(const DelegateImpl& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FPA == kind)
+                    {
+                        obj = {};
+                    }
+                    kind = del.kind;
+                }
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = del.obj;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegateImpl& operator=(DelegateImpl&& del)
+            {
+                if (this == &del) return *this;
+                if (kind != del.kind)
+                {
+                    if (FPA == kind)
+                    {
+                        obj = {};
+                    }
+                    kind = del.kind;
+                }
+                if (FPA == del.kind)
+                {
+                    fnA = del.fnA;
+                    obj = std::move(del.obj);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegateImpl& operator=(FunPtr fn)
+            {
+                if (FPA == kind)
+                {
+                    obj = {};
+                }
+                kind = FP;
+                this->fn = fn;
+                return *this;
+            }
+
+            DelegateImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                if (FPA == kind)
+                {
+                    obj = {};
+                }
+                kind = FP;
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else
+                {
+                    return fnA;
+                }
+            }
+
+            static R IRAM_ATTR vPtrToFunAPtrExec(void* self)
+            {
+                return static_cast<DelegateImpl*>(self)->fnA(
+                    static_cast<DelegateImpl*>(self)->obj);
+            };
+
+            operator FunVPPtr() const
+            {
+                if (FP == kind)
+                {
+                    return reinterpret_cast<FunVPPtr>(fn);
+                }
+                else
+                {
+                    return vPtrToFunAPtrExec;
+                }
+            }
+
+            void* arg() const
+            {
+                if (FP == kind)
+                {
+                    return nullptr;
+                }
+                else
+                {
+                    return const_cast<DelegateImpl*>(this);
+                }
+            }
+
+            R IRAM_ATTR operator()() const
+            {
+                if (FP == kind)
+                {
+                    return fn();
+                }
+                else
+                {
+                    return fnA(obj);
+                }
+            }
+
+        protected:
+            union {
+                FunPtr fn;
+                FunAPtr fnA;
+            };
+            A obj;
+            enum { FP, FPA } kind;
+        };
+#endif
+
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+        template<typename R>
+        class DelegateImpl<void, R> {
+        public:
+            using target_type = R();
+        protected:
+            using FunPtr = target_type*;
+            using FunctionType = std::function<target_type>;
+            using FunVPPtr = R(*)(void*);
+        public:
+            DelegateImpl()
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            DelegateImpl(std::nullptr_t)
+            {
+                kind = FP;
+                fn = nullptr;
+            }
+
+            ~DelegateImpl()
+            {
+                if (FUNC == kind)
+                    functional.~FunctionType();
+            }
+
+            DelegateImpl(const DelegateImpl& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(del.functional);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegateImpl(DelegateImpl&& del)
+            {
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    new (&functional) FunctionType(std::move(del.functional));
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+            }
+
+            DelegateImpl(FunPtr fn)
+            {
+                kind = FP;
+                DelegateImpl::fn = fn;
+            }
+
+            template<typename F> DelegateImpl(F functional)
+            {
+                kind = FUNC;
+                new (&this->functional) FunctionType(std::forward<F>(functional));
+            }
+
+            DelegateImpl& operator=(const DelegateImpl& del)
+            {
+                if (this == &del) return *this;
+                if (FUNC == kind && FUNC != del.kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FUNC != kind && FUNC == del.kind)
+                {
+                    new (&this->functional) FunctionType();
+                }
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    functional = del.functional;
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegateImpl& operator=(DelegateImpl&& del)
+            {
+                if (this == &del) return *this;
+                if (FUNC == kind && FUNC != del.kind)
+                {
+                    functional.~FunctionType();
+                }
+                else if (FUNC != kind && FUNC == del.kind)
+                {
+                    new (&this->functional) FunctionType();
+                }
+                kind = del.kind;
+                if (FUNC == del.kind)
+                {
+                    functional = std::move(del.functional);
+                }
+                else
+                {
+                    fn = del.fn;
+                }
+                return *this;
+            }
+
+            DelegateImpl& operator=(FunPtr fn)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                    kind = FP;
+                }
+                DelegateImpl::fn = fn;
+                return *this;
+            }
+
+            DelegateImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                if (FUNC == kind)
+                {
+                    functional.~FunctionType();
+                }
+                kind = FP;
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else
+                {
+                    return functional ? true : false;
+                }
+            }
+
+            operator FunVPPtr() const
+            {
+                if (FP == kind)
+                {
+                    return reinterpret_cast<FunVPPtr>(fn);
+                }
+                else
+                {
+                    return [](void* self) -> R
+                    {
+                        return static_cast<DelegateImpl*>(self)->functional();
+                    };
+                }
+            }
+
+            void* arg() const
+            {
+                if (FP == kind)
+                {
+                    return nullptr;
+                }
+                else
+                {
+                    return const_cast<DelegateImpl*>(this);
+                }
+            }
+
+            operator FunctionType() const
+            {
+                if (FP == kind)
+                {
+                    return fn;
+                }
+                else
+                {
+                    return functional;
+                }
+            }
+
+            R IRAM_ATTR operator()() const
+            {
+                if (FP == kind)
+                {
+                    return fn();
+                }
+                else
+                {
+                    return functional();
+                }
+            }
+
+        protected:
+            union {
+                FunctionType functional;
+                FunPtr fn;
+            };
+            enum { FUNC, FP } kind;
+        };
+#else
+        template<typename R>
+        class DelegateImpl<void, R> {
+        public:
+            using target_type = R();
+        protected:
+            using FunPtr = target_type*;
+            using FunVPPtr = R(*)(void*);
+        public:
+            DelegateImpl()
+            {
+                fn = nullptr;
+            }
+
+            DelegateImpl(std::nullptr_t)
+            {
+                fn = nullptr;
+            }
+
+            DelegateImpl(const DelegateImpl& del)
+            {
+                fn = del.fn;
+            }
+
+            DelegateImpl(DelegateImpl&& del)
+            {
+                fn = std::move(del.fn);
+            }
+
+            DelegateImpl(FunPtr fn)
+            {
+                DelegateImpl::fn = fn;
+            }
+
+            template<typename F> DelegateImpl(F fn)
+            {
+                DelegateImpl::fn = std::forward<F>(fn);
+            }
+
+            DelegateImpl& operator=(const DelegateImpl& del)
+            {
+                if (this == &del) return *this;
+                fn = del.fn;
+                return *this;
+            }
+
+            DelegateImpl& operator=(DelegateImpl&& del)
+            {
+                if (this == &del) return *this;
+                fn = std::move(del.fn);
+                return *this;
+            }
+
+            DelegateImpl& operator=(FunPtr fn)
+            {
+                DelegateImpl::fn = fn;
+                return *this;
+            }
+
+            DelegateImpl& IRAM_ATTR operator=(std::nullptr_t)
+            {
+                fn = nullptr;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                return fn;
+            }
+
+            operator FunVPPtr() const
+            {
+                return reinterpret_cast<FunVPPtr>(fn);
+            }
+
+            void* arg() const
+            {
+                return nullptr;
+            }
+
+            R IRAM_ATTR operator()() const
+            {
+                return fn();
+            }
+
+        protected:
+            FunPtr fn;
+        };
+#endif
+
+        template<typename A = void, typename R = void, typename... P>
+        class Delegate : private detail::DelegatePImpl<A, R, P...>
+        {
+        public:
+            using target_type = R(P...);
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A, P...);
+            using FunVPPtr = R(*)(void*, P...);
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            using FunctionType = std::function<target_type>;
+#endif
+        public:
+            using detail::DelegatePImpl<A, R, P...>::operator bool;
+            using detail::DelegatePImpl<A, R, P...>::arg;
+            using detail::DelegatePImpl<A, R, P...>::operator();
+
+            operator FunVPPtr() { return detail::DelegatePImpl<A, R, P...>::operator FunVPPtr(); }
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            operator FunctionType() { return detail::DelegatePImpl<A, R, P...>::operator FunctionType(); }
+#endif
+
+            Delegate() : detail::DelegatePImpl<A, R, P...>::DelegatePImpl() {}
+
+            Delegate(std::nullptr_t) : detail::DelegatePImpl<A, R, P...>::DelegatePImpl(nullptr) {}
+
+            Delegate(const Delegate& del) : detail::DelegatePImpl<A, R, P...>::DelegatePImpl(
+                static_cast<const detail::DelegatePImpl<A, R, P...>&>(del)) {}
+
+            Delegate(Delegate&& del) : detail::DelegatePImpl<A, R, P...>::DelegatePImpl(
+                std::move(static_cast<detail::DelegatePImpl<A, R, P...>&>(del))) {}
+
+            Delegate(FunAPtr fnA, const A& obj) : detail::DelegatePImpl<A, R, P...>::DelegatePImpl(fnA, obj) {}
+
+            Delegate(FunAPtr fnA, A&& obj) : detail::DelegatePImpl<A, R, P...>::DelegatePImpl(fnA, std::move(obj)) {}
+
+            Delegate(FunPtr fn) : detail::DelegatePImpl<A, R, P...>::DelegatePImpl(fn) {}
+
+            template<typename F> Delegate(F functional) : detail::DelegatePImpl<A, R, P...>::DelegatePImpl(std::forward<F>(functional)) {}
+
+            Delegate& operator=(const Delegate& del) {
+                detail::DelegatePImpl<A, R, P...>::operator=(del);
+                return *this;
+            }
+
+            Delegate& operator=(Delegate&& del) {
+                detail::DelegatePImpl<A, R, P...>::operator=(std::move(del));
+                return *this;
+            }
+
+            Delegate& operator=(FunPtr fn) {
+                detail::DelegatePImpl<A, R, P...>::operator=(fn);
+                return *this;
+            }
+
+            Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+                detail::DelegatePImpl<A, R, P...>::operator=(nullptr);
+                return *this;
+            }
+        };
+
+        template<typename A, typename R, typename... P>
+        class Delegate<A*, R, P...> : private detail::DelegatePImpl<A*, R, P...>
+        {
+        public:
+            using target_type = R(P...);
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A*, P...);
+            using FunVPPtr = R(*)(void*, P...);
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            using FunctionType = std::function<target_type>;
+#endif
+        public:
+            using detail::DelegatePImpl<A*, R, P...>::operator bool;
+            using detail::DelegatePImpl<A*, R, P...>::operator();
+
+            operator FunVPPtr() const
+            {
+                if (detail::DelegatePImpl<A*, R, P...>::FPA == detail::DelegatePImpl<A*, R, P...>::kind)
+                {
+                    return reinterpret_cast<FunVPPtr>(detail::DelegatePImpl<A*, R, P...>::fnA);
+                }
+                else
+                {
+                    return detail::DelegatePImpl<A*, R, P...>::operator FunVPPtr();
+                }
+            }
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            operator FunctionType() { return detail::DelegatePImpl<A*, R, P...>::operator FunctionType(); }
+#endif
+            void* arg() const
+            {
+                if (detail::DelegatePImpl<A*, R, P...>::FPA == detail::DelegatePImpl<A*, R, P...>::kind)
+                {
+                    return detail::DelegatePImpl<A*, R, P...>::obj;
+                }
+                else
+                {
+                    return detail::DelegatePImpl<A*, R, P...>::arg();
+                }
+            }
+
+            Delegate() : detail::DelegatePImpl<A*, R, P...>::DelegatePImpl() {}
+
+            Delegate(std::nullptr_t) : detail::DelegatePImpl<A*, R, P...>::DelegatePImpl(nullptr) {}
+
+            Delegate(const Delegate& del) : detail::DelegatePImpl<A*, R, P...>::DelegatePImpl(
+                static_cast<const detail::DelegatePImpl<A*, R, P...>&>(del)) {}
+
+            Delegate(Delegate&& del) : detail::DelegatePImpl<A*, R, P...>::DelegatePImpl(
+                std::move(static_cast<detail::DelegatePImpl<A*, R, P...>&>(del))) {}
+
+            Delegate(FunAPtr fnA, A* obj) : detail::DelegatePImpl<A*, R, P...>::DelegatePImpl(fnA, obj) {}
+
+            Delegate(FunPtr fn) : detail::DelegatePImpl<A*, R, P...>::DelegatePImpl(fn) {}
+
+            template<typename F> Delegate(F functional) : detail::DelegatePImpl<A*, R, P...>::DelegatePImpl(std::forward<F>(functional)) {}
+
+            Delegate& operator=(const Delegate& del) {
+                detail::DelegatePImpl<A*, R, P...>::operator=(del);
+                return *this;
+            }
+
+            Delegate& operator=(Delegate&& del) {
+                detail::DelegatePImpl<A*, R, P...>::operator=(std::move(del));
+                return *this;
+            }
+
+            Delegate& operator=(FunPtr fn) {
+                detail::DelegatePImpl<A*, R, P...>::operator=(fn);
+                return *this;
+            }
+
+            Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+                detail::DelegatePImpl<A*, R, P...>::operator=(nullptr);
+                return *this;
+            }
+        };
+
+        template<typename R, typename... P>
+        class Delegate<void, R, P...> : private detail::DelegatePImpl<void, R, P...>
+        {
+        public:
+            using target_type = R(P...);
+        protected:
+            using FunPtr = target_type*;
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            using FunctionType = std::function<target_type>;
+#endif
+            using FunVPPtr = R(*)(void*, P...);
+        public:
+            using detail::DelegatePImpl<void, R, P...>::operator bool;
+            using detail::DelegatePImpl<void, R, P...>::arg;
+            using detail::DelegatePImpl<void, R, P...>::operator();
+
+            operator FunVPPtr() const { return detail::DelegatePImpl<void, R, P...>::operator FunVPPtr(); }
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            operator FunctionType() { return detail::DelegatePImpl<void, R, P...>::operator FunctionType(); }
+#endif
+
+            Delegate() : detail::DelegatePImpl<void, R, P...>::DelegatePImpl() {}
+
+            Delegate(std::nullptr_t) : detail::DelegatePImpl<void, R, P...>::DelegatePImpl(nullptr) {}
+
+            Delegate(const Delegate& del) : detail::DelegatePImpl<void, R, P...>::DelegatePImpl(
+                static_cast<const detail::DelegatePImpl<void, R, P...>&>(del)) {}
+
+            Delegate(Delegate&& del) : detail::DelegatePImpl<void, R, P...>::DelegatePImpl(
+                std::move(static_cast<detail::DelegatePImpl<void, R, P...>&>(del))) {}
+
+            Delegate(FunPtr fn) : detail::DelegatePImpl<void, R, P...>::DelegatePImpl(fn) {}
+
+            template<typename F> Delegate(F functional) : detail::DelegatePImpl<void, R, P...>::DelegatePImpl(std::forward<F>(functional)) {}
+
+            Delegate& operator=(const Delegate& del) {
+                detail::DelegatePImpl<void, R, P...>::operator=(del);
+                return *this;
+            }
+
+            Delegate& operator=(Delegate&& del) {
+                detail::DelegatePImpl<void, R, P...>::operator=(std::move(del));
+                return *this;
+            }
+
+            Delegate& operator=(FunPtr fn) {
+                detail::DelegatePImpl<void, R, P...>::operator=(fn);
+                return *this;
+            }
+
+            Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+                detail::DelegatePImpl<void, R, P...>::operator=(nullptr);
+                return *this;
+            }
+        };
+
+        template<typename A, typename R>
+        class Delegate<A, R> : private detail::DelegateImpl<A, R>
+        {
+        public:
+            using target_type = R();
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A);
+            using FunVPPtr = R(*)(void*);
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            using FunctionType = std::function<target_type>;
+#endif
+        public:
+            using detail::DelegateImpl<A, R>::operator bool;
+            using detail::DelegateImpl<A, R>::arg;
+            using detail::DelegateImpl<A, R>::operator();
+
+            operator FunVPPtr() { return detail::DelegateImpl<A, R>::operator FunVPPtr(); }
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            operator FunctionType() { return detail::DelegateImpl<A, R>::operator FunctionType(); }
+#endif
+
+            Delegate() : detail::DelegateImpl<A, R>::DelegateImpl() {}
+
+            Delegate(std::nullptr_t) : detail::DelegateImpl<A, R>::DelegateImpl(nullptr) {}
+
+            Delegate(const Delegate& del) : detail::DelegateImpl<A, R>::DelegateImpl(
+                static_cast<const detail::DelegateImpl<A, R>&>(del)) {}
+
+            Delegate(Delegate&& del) : detail::DelegateImpl<A, R>::DelegateImpl(
+                std::move(static_cast<detail::DelegateImpl<A, R>&>(del))) {}
+
+            Delegate(FunAPtr fnA, const A& obj) : detail::DelegateImpl<A, R>::DelegateImpl(fnA, obj) {}
+
+            Delegate(FunAPtr fnA, A&& obj) : detail::DelegateImpl<A, R>::DelegateImpl(fnA, std::move(obj)) {}
+
+            Delegate(FunPtr fn) : detail::DelegateImpl<A, R>::DelegateImpl(fn) {}
+
+            template<typename F> Delegate(F functional) : detail::DelegateImpl<A, R>::DelegateImpl(std::forward<F>(functional)) {}
+
+            Delegate& operator=(const Delegate& del) {
+                detail::DelegateImpl<A, R>::operator=(del);
+                return *this;
+            }
+
+            Delegate& operator=(Delegate&& del) {
+                detail::DelegateImpl<A, R>::operator=(std::move(del));
+                return *this;
+            }
+
+            Delegate& operator=(FunPtr fn) {
+                detail::DelegateImpl<A, R>::operator=(fn);
+                return *this;
+            }
+
+            Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+                detail::DelegateImpl<A, R>::operator=(nullptr);
+                return *this;
+            }
+        };
+
+        template<typename A, typename R>
+        class Delegate<A*, R> : private detail::DelegateImpl<A*, R>
+        {
+        public:
+            using target_type = R();
+        protected:
+            using FunPtr = target_type*;
+            using FunAPtr = R(*)(A*);
+            using FunVPPtr = R(*)(void*);
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            using FunctionType = std::function<target_type>;
+#endif
+        public:
+            using detail::DelegateImpl<A*, R>::operator bool;
+            using detail::DelegateImpl<A*, R>::operator();
+
+            operator FunVPPtr() const
+            {
+                if (detail::DelegateImpl<A*, R>::FPA == detail::DelegateImpl<A*, R>::kind)
+                {
+                    return reinterpret_cast<FunVPPtr>(detail::DelegateImpl<A*, R>::fnA);
+                }
+                else
+                {
+                    return detail::DelegateImpl<A*, R>::operator FunVPPtr();
+                }
+            }
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            operator FunctionType() { return detail::DelegateImpl<A*, R>::operator FunctionType(); }
+#endif
+            void* arg() const
+            {
+                if (detail::DelegateImpl<A*, R>::FPA == detail::DelegateImpl<A*, R>::kind)
+                {
+                    return detail::DelegateImpl<A*, R>::obj;
+                }
+                else
+                {
+                    return detail::DelegateImpl<A*, R>::arg();
+                }
+            }
+
+            Delegate() : detail::DelegateImpl<A*, R>::DelegateImpl() {}
+
+            Delegate(std::nullptr_t) : detail::DelegateImpl<A*, R>::DelegateImpl(nullptr) {}
+
+            Delegate(const Delegate& del) : detail::DelegateImpl<A*, R>::DelegateImpl(
+                static_cast<const detail::DelegateImpl<A*, R>&>(del)) {}
+
+            Delegate(Delegate&& del) : detail::DelegateImpl<A*, R>::DelegateImpl(
+                std::move(static_cast<detail::DelegateImpl<A*, R>&>(del))) {}
+
+            Delegate(FunAPtr fnA, A* obj) : detail::DelegateImpl<A*, R>::DelegateImpl(fnA, obj) {}
+
+            Delegate(FunPtr fn) : detail::DelegateImpl<A*, R>::DelegateImpl(fn) {}
+
+            template<typename F> Delegate(F functional) : detail::DelegateImpl<A*, R>::DelegateImpl(std::forward<F>(functional)) {}
+
+            Delegate& operator=(const Delegate& del) {
+                detail::DelegateImpl<A*, R>::operator=(del);
+                return *this;
+            }
+
+            Delegate& operator=(Delegate&& del) {
+                detail::DelegateImpl<A*, R>::operator=(std::move(del));
+                return *this;
+            }
+
+            Delegate& operator=(FunPtr fn) {
+                detail::DelegateImpl<A*, R>::operator=(fn);
+                return *this;
+            }
+
+            Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+                detail::DelegateImpl<A*, R>::operator=(nullptr);
+                return *this;
+            }
+        };
+
+        template<typename R>
+        class Delegate<void, R> : private detail::DelegateImpl<void, R>
+        {
+        public:
+            using target_type = R();
+        protected:
+            using FunPtr = target_type*;
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            using FunctionType = std::function<target_type>;
+#endif
+            using FunVPPtr = R(*)(void*);
+        public:
+            using detail::DelegateImpl<void, R>::operator bool;
+            using detail::DelegateImpl<void, R>::arg;
+            using detail::DelegateImpl<void, R>::operator();
+
+            operator FunVPPtr() const { return detail::DelegateImpl<void, R>::operator FunVPPtr(); }
+#if !defined(ARDUINO) || defined(ESP8266) || defined(ESP32)
+            operator FunctionType() { return detail::DelegateImpl<void, R>::operator FunctionType(); }
+#endif
+
+            Delegate() : detail::DelegateImpl<void, R>::DelegateImpl() {}
+
+            Delegate(std::nullptr_t) : detail::DelegateImpl<void, R>::DelegateImpl(nullptr) {}
+
+            Delegate(const Delegate& del) : detail::DelegateImpl<void, R>::DelegateImpl(
+                static_cast<const detail::DelegateImpl<void, R>&>(del)) {}
+
+            Delegate(Delegate&& del) : detail::DelegateImpl<void, R>::DelegateImpl(
+                std::move(static_cast<detail::DelegateImpl<void, R>&>(del))) {}
+
+            Delegate(FunPtr fn) : detail::DelegateImpl<void, R>::DelegateImpl(fn) {}
+
+            template<typename F> Delegate(F functional) : detail::DelegateImpl<void, R>::DelegateImpl(std::forward<F>(functional)) {}
+
+            Delegate& operator=(const Delegate& del) {
+                detail::DelegateImpl<void, R>::operator=(del);
+                return *this;
+            }
+
+            Delegate& operator=(Delegate&& del) {
+                detail::DelegateImpl<void, R>::operator=(std::move(del));
+                return *this;
+            }
+
+            Delegate& operator=(FunPtr fn) {
+                detail::DelegateImpl<void, R>::operator=(fn);
+                return *this;
+            }
+
+            Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+                detail::DelegateImpl<void, R>::operator=(nullptr);
+                return *this;
+            }
+        };
+    }
+}
+
+template<typename A = void, typename R = void, typename... P> class Delegate;
+template<typename A, typename R, typename... P> class Delegate<R(P...), A> : public delegate::detail::Delegate<A, R, P...>
+{
+public:
+    Delegate() : delegate::detail::Delegate<A, R, P...>::Delegate() {}
+
+    Delegate(std::nullptr_t) : delegate::detail::Delegate<A, R, P...>::Delegate(nullptr) {}
+
+    Delegate(const Delegate& del) : delegate::detail::Delegate<A, R, P...>::Delegate(
+        static_cast<const delegate::detail::Delegate<A, R, P...>&>(del)) {}
+
+    Delegate(Delegate&& del) : delegate::detail::Delegate<A, R, P...>::Delegate(
+        std::move(static_cast<delegate::detail::Delegate<A, R, P...>&>(del))) {}
+
+    Delegate(typename delegate::detail::Delegate<A, R, P...>::FunAPtr fnA, const A& obj) : delegate::detail::Delegate<A, R, P...>::Delegate(fnA, obj) {}
+
+    Delegate(typename delegate::detail::Delegate<A, R, P...>::FunAPtr fnA, A&& obj) : delegate::detail::Delegate<A, R, P...>::Delegate(fnA, std::move(obj)) {}
+
+    Delegate(typename delegate::detail::Delegate<A, R, P...>::FunPtr fn) : delegate::detail::Delegate<A, R, P...>::Delegate(fn) {}
+
+    template<typename F> Delegate(F functional) : delegate::detail::Delegate<A, R, P...>::Delegate(std::forward<F>(functional)) {}
+
+    Delegate& operator=(const Delegate& del) {
+        delegate::detail::Delegate<A, R, P...>::operator=(del);
+        return *this;
+    }
+
+    Delegate& operator=(Delegate&& del) {
+        delegate::detail::Delegate<A, R, P...>::operator=(std::move(del));
+        return *this;
+    }
+
+    Delegate& operator=(typename delegate::detail::Delegate<A, R, P...>::FunPtr fn) {
+        delegate::detail::Delegate<A, R, P...>::operator=(fn);
+        return *this;
+    }
+
+    Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+        delegate::detail::Delegate<A, R, P...>::operator=(nullptr);
+        return *this;
+    }
+};
+
+template<typename R, typename... P> class Delegate<R(P...)> : public delegate::detail::Delegate<void, R, P...>
+{
+public:
+    Delegate() : delegate::detail::Delegate<void, R, P...>::Delegate() {}
+
+    Delegate(std::nullptr_t) : delegate::detail::Delegate<void, R, P...>::Delegate(nullptr) {}
+
+    Delegate(const Delegate& del) : delegate::detail::Delegate<void, R, P...>::Delegate(
+        static_cast<const delegate::detail::Delegate<void, R, P...>&>(del)) {}
+
+    Delegate(Delegate&& del) : delegate::detail::Delegate<void, R, P...>::Delegate(
+        std::move(static_cast<delegate::detail::Delegate<void, R, P...>&>(del))) {}
+
+    Delegate(typename delegate::detail::Delegate<void, R, P...>::FunPtr fn) : delegate::detail::Delegate<void, R, P...>::Delegate(fn) {}
+
+    template<typename F> Delegate(F functional) : delegate::detail::Delegate<void, R, P...>::Delegate(std::forward<F>(functional)) {}
+
+    Delegate& operator=(const Delegate& del) {
+        delegate::detail::Delegate<void, R, P...>::operator=(del);
+        return *this;
+    }
+
+    Delegate& operator=(Delegate&& del) {
+        delegate::detail::Delegate<void, R, P...>::operator=(std::move(del));
+        return *this;
+    }
+
+    Delegate& operator=(typename delegate::detail::Delegate<void, R, P...>::FunPtr fn) {
+        delegate::detail::Delegate<void, R, P...>::operator=(fn);
+        return *this;
+    }
+
+    Delegate& IRAM_ATTR operator=(std::nullptr_t) {
+        delegate::detail::Delegate<void, R, P...>::operator=(nullptr);
+        return *this;
+    }
+};
+
+#endif // __Delegate_h

ampel-firmware/src/lib/EspSoftwareSerial/circular_queue/MultiDelegate.h

+/*
+MultiDelegate.h - A queue or event multiplexer based on the efficient Delegate
+class
+Copyright (c) 2019-2020 Dirk O. Kaar. All rights 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 __MULTIDELEGATE_H
+#define __MULTIDELEGATE_H
+
+#include <iterator>
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+#include <atomic>
+#else
+#include "circular_queue/ghostl.h"
+#endif
+
+#if defined(ESP8266)
+#include <interrupts.h>
+using esp8266::InterruptLock;
+#elif defined(ARDUINO)
+class InterruptLock {
+public:
+    InterruptLock() {
+        noInterrupts();
+    }
+    ~InterruptLock() {
+        interrupts();
+    }
+};
+#else
+#include <mutex>
+#endif
+
+namespace
+{
+
+    template< typename Delegate, typename R, bool ISQUEUE = false, typename... P>
+    struct CallP
+    {
+        static R execute(Delegate& del, P... args)
+        {
+            return del(std::forward<P...>(args...));
+        }
+    };
+
+    template< typename Delegate, bool ISQUEUE, typename... P>
+    struct CallP<Delegate, void, ISQUEUE, P...>
+    {
+        static bool execute(Delegate& del, P... args)
+        {
+            del(std::forward<P...>(args...));
+            return true;
+        }
+    };
+
+    template< typename Delegate, typename R, bool ISQUEUE = false>
+    struct Call
+    {
+        static R execute(Delegate& del)
+        {
+            return del();
+        }
+    };
+
+    template< typename Delegate, bool ISQUEUE>
+    struct Call<Delegate, void, ISQUEUE>
+    {
+        static bool execute(Delegate& del)
+        {
+            del();
+            return true;
+        }
+    };
+
+}
+
+namespace delegate
+{
+    namespace detail
+    {
+
+        template< typename Delegate, typename R, bool ISQUEUE = false, size_t QUEUE_CAPACITY = 32, typename... P>
+        class MultiDelegatePImpl
+        {
+        public:
+            MultiDelegatePImpl() = default;
+            ~MultiDelegatePImpl()
+            {
+                *this = nullptr;
+            }
+
+            MultiDelegatePImpl(const MultiDelegatePImpl&) = delete;
+            MultiDelegatePImpl& operator=(const MultiDelegatePImpl&) = delete;
+
+            MultiDelegatePImpl(MultiDelegatePImpl&& md)
+            {
+                first = md.first;
+                last = md.last;
+                unused = md.unused;
+                nodeCount = md.nodeCount;
+                md.first = nullptr;
+                md.last = nullptr;
+                md.unused = nullptr;
+                md.nodeCount = 0;
+            }
+
+            MultiDelegatePImpl(const Delegate& del)
+            {
+                add(del);
+            }
+
+            MultiDelegatePImpl(Delegate&& del)
+            {
+                add(std::move(del));
+            }
+
+            MultiDelegatePImpl& operator=(MultiDelegatePImpl&& md)
+            {
+                first = md.first;
+                last = md.last;
+                unused = md.unused;
+                nodeCount = md.nodeCount;
+                md.first = nullptr;
+                md.last = nullptr;
+                md.unused = nullptr;
+                md.nodeCount = 0;
+                return *this;
+            }
+
+            MultiDelegatePImpl& operator=(std::nullptr_t)
+            {
+                if (last)
+                    last->mNext = unused;
+                if (first)
+                    unused = first;
+                while (unused)
+                {
+                    auto to_delete = unused;
+                    unused = unused->mNext;
+                    delete(to_delete);
+                }
+                return *this;
+            }
+
+            MultiDelegatePImpl& operator+=(const Delegate& del)
+            {
+                add(del);
+                return *this;
+            }
+
+            MultiDelegatePImpl& operator+=(Delegate&& del)
+            {
+                add(std::move(del));
+                return *this;
+            }
+
+        protected:
+            struct Node_t
+            {
+                ~Node_t()
+                {
+                    mDelegate = nullptr; // special overload in Delegate
+                }
+                Node_t* mNext = nullptr;
+                Delegate mDelegate;
+            };
+
+            Node_t* first = nullptr;
+            Node_t* last = nullptr;
+            Node_t* unused = nullptr;
+            size_t nodeCount = 0;
+
+            // Returns a pointer to an unused Node_t,
+            // or if none are available allocates a new one,
+            // or nullptr if limit is reached
+            Node_t* IRAM_ATTR get_node_unsafe()
+            {
+                Node_t* result = nullptr;
+                // try to get an item from unused items list
+                if (unused)
+                {
+                    result = unused;
+                    unused = unused->mNext;
+                }
+                // if no unused items, and count not too high, allocate a new one
+                else if (nodeCount < QUEUE_CAPACITY)
+                {
+#if defined(ESP8266) || defined(ESP32)            	
+                    result = new (std::nothrow) Node_t;
+#else
+                    result = new Node_t;
+#endif
+                    if (result)
+                        ++nodeCount;
+                }
+                return result;
+            }
+
+            void recycle_node_unsafe(Node_t* node)
+            {
+                node->mDelegate = nullptr; // special overload in Delegate
+                node->mNext = unused;
+                unused = node;
+            }
+
+#ifndef ARDUINO
+            std::mutex mutex_unused;
+#endif
+        public:
+            class iterator : public std::iterator<std::forward_iterator_tag, Delegate>
+            {
+            public:
+                Node_t* current = nullptr;
+                Node_t* prev = nullptr;
+                const Node_t* stop = nullptr;
+
+                iterator(MultiDelegatePImpl& md) : current(md.first), stop(md.last) {}
+                iterator() = default;
+                iterator(const iterator&) = default;
+                iterator& operator=(const iterator&) = default;
+                iterator& operator=(iterator&&) = default;
+                operator bool() const
+                {
+                    return current && stop;
+                }
+                bool operator==(const iterator& rhs) const
+                {
+                    return current == rhs.current;
+                }
+                bool operator!=(const iterator& rhs) const
+                {
+                    return !operator==(rhs);
+                }
+                Delegate& operator*() const
+                {
+                    return current->mDelegate;
+                }
+                Delegate* operator->() const
+                {
+                    return &current->mDelegate;
+                }
+                iterator& operator++() // prefix
+                {
+                    if (current && stop != current)
+                    {
+                        prev = current;
+                        current = current->mNext;
+                    }
+                    else
+                        current = nullptr; // end
+                    return *this;
+                }
+                iterator& operator++(int) // postfix
+                {
+                    iterator tmp(*this);
+                    operator++();
+                    return tmp;
+                }
+            };
+
+            iterator begin()
+            {
+                return iterator(*this);
+            }
+            iterator end() const
+            {
+                return iterator();
+            }
+
+            const Delegate* IRAM_ATTR add(const Delegate& del)
+            {
+                return add(Delegate(del));
+            }
+
+            const Delegate* IRAM_ATTR add(Delegate&& del)
+            {
+                if (!del)
+                    return nullptr;
+
+#ifdef ARDUINO
+                InterruptLock lockAllInterruptsInThisScope;
+#else
+                std::lock_guard<std::mutex> lock(mutex_unused);
+#endif
+
+                Node_t* item = ISQUEUE ? get_node_unsafe() :
+#if defined(ESP8266) || defined(ESP32)            	
+                    new (std::nothrow) Node_t;
+#else
+                    new Node_t;
+#endif
+                if (!item)
+                    return nullptr;
+
+                item->mDelegate = std::move(del);
+                item->mNext = nullptr;
+
+                if (last)
+                    last->mNext = item;
+                else
+                    first = item;
+                last = item;
+
+                return &item->mDelegate;
+            }
+
+            iterator erase(iterator it)
+            {
+                if (!it)
+                    return end();
+#ifdef ARDUINO
+                InterruptLock lockAllInterruptsInThisScope;
+#else
+                std::lock_guard<std::mutex> lock(mutex_unused);
+#endif
+                auto to_recycle = it.current;
+
+                if (last == it.current)
+                    last = it.prev;
+                it.current = it.current->mNext;
+                if (it.prev)
+                {
+                    it.prev->mNext = it.current;
+                }
+                else
+                {
+                    first = it.current;
+                }
+                if (ISQUEUE)
+                    recycle_node_unsafe(to_recycle);
+                else
+                    delete to_recycle;
+                return it;
+            }
+
+            bool erase(const Delegate* const del)
+            {
+                auto it = begin();
+                while (it)
+                {
+                    if (del == &(*it))
+                    {
+                        erase(it);
+                        return true;
+                    }
+                    ++it;
+                }
+                return false;
+            }
+
+            operator bool() const
+            {
+                return first;
+            }
+
+            R operator()(P... args)
+            {
+                auto it = begin();
+                if (!it)
+                    return {};
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return {};
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return {};
+#endif
+
+                R result;
+                do
+                {
+                    result = CallP<Delegate, R, ISQUEUE, P...>::execute(*it, args...);
+                    if (result && ISQUEUE)
+                        it = erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+                return result;
+            }
+        };
+
+        template< typename Delegate, typename R = void, bool ISQUEUE = false, size_t QUEUE_CAPACITY = 32>
+        class MultiDelegateImpl : public MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>
+        {
+        public:
+            using MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>::MultiDelegatePImpl;
+
+            R operator()()
+            {
+                auto it = this->begin();
+                if (!it)
+                    return {};
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return {};
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return {};
+#endif
+
+                R result;
+                do
+                {
+                    result = Call<Delegate, R, ISQUEUE>::execute(*it);
+                    if (result && ISQUEUE)
+                        it = this->erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+                return result;
+            }
+        };
+
+        template< typename Delegate, typename R, bool ISQUEUE, size_t QUEUE_CAPACITY, typename... P> class MultiDelegate;
+
+        template< typename Delegate, typename R, bool ISQUEUE, size_t QUEUE_CAPACITY, typename... P>
+        class MultiDelegate<Delegate, R(P...), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY, P...>
+        {
+        public:
+            using MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY, P...>::MultiDelegatePImpl;
+        };
+
+        template< typename Delegate, typename R, bool ISQUEUE, size_t QUEUE_CAPACITY>
+        class MultiDelegate<Delegate, R(), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegateImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>
+        {
+        public:
+            using MultiDelegateImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>::MultiDelegateImpl;
+        };
+
+        template< typename Delegate, bool ISQUEUE, size_t QUEUE_CAPACITY, typename... P>
+        class MultiDelegate<Delegate, void(P...), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegatePImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY, P...>
+        {
+        public:
+            using MultiDelegatePImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY, P...>::MultiDelegatePImpl;
+
+            void operator()(P... args)
+            {
+                auto it = this->begin();
+                if (!it)
+                    return;
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return;
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return;
+#endif
+
+                do
+                {
+                    CallP<Delegate, void, ISQUEUE, P...>::execute(*it, args...);
+                    if (ISQUEUE)
+                        it = this->erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+            }
+        };
+
+        template< typename Delegate, bool ISQUEUE, size_t QUEUE_CAPACITY>
+        class MultiDelegate<Delegate, void(), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegateImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY>
+        {
+        public:
+            using MultiDelegateImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY>::MultiDelegateImpl;
+
+            void operator()()
+            {
+                auto it = this->begin();
+                if (!it)
+                    return;
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return;
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return;
+#endif
+
+                do
+                {
+                    Call<Delegate, void, ISQUEUE>::execute(*it);
+                    if (ISQUEUE)
+                        it = this->erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+            }
+        };
+
+    }
+
+}
+
+/**
+The MultiDelegate class template can be specialized to either a queue or an event multiplexer.
+It is designed to be used with Delegate, the efficient runtime wrapper for C function ptr and C++ std::function.
+@tparam Delegate specifies the concrete type that MultiDelegate bases the queue or event multiplexer on.
+@tparam ISQUEUE modifies the generated MultiDelegate class in subtle ways. In queue mode (ISQUEUE == true),
+               the value of QUEUE_CAPACITY enforces the maximum number of simultaneous items the queue can contain.
+               This is exploited to minimize the use of new and delete by reusing already allocated items, thus
+               reducing heap fragmentation. In event multiplexer mode (ISQUEUE = false), new and delete are
+               used for allocation of the event handler items.
+               If the result type of the function call operator of Delegate is void, calling a MultiDelegate queue
+               removes each item after calling it; a Multidelegate event multiplexer keeps event handlers until
+               explicitly removed.
+               If the result type of the function call operator of Delegate is non-void, in a MultiDelegate queue
+               the type-conversion to bool of that result determines if the item is immediately removed or kept
+               after each call: if true is returned, the item is removed. A Multidelegate event multiplexer keeps event
+               handlers until they are explicitly removed.
+@tparam QUEUE_CAPACITY is only used if ISQUEUE == true. Then, it sets the maximum capacity that the queue dynamically
+               allocates from the heap. Unused items are not returned to the heap, but are managed by the MultiDelegate
+               instance during its own lifetime for efficiency.
+*/
+template< typename Delegate, bool ISQUEUE = false, size_t QUEUE_CAPACITY = 32>
+class MultiDelegate : public delegate::detail::MultiDelegate<Delegate, typename Delegate::target_type, ISQUEUE, QUEUE_CAPACITY>
+{
+public:
+    using delegate::detail::MultiDelegate<Delegate, typename Delegate::target_type, ISQUEUE, QUEUE_CAPACITY>::MultiDelegate;
+};
+
+#endif // __MULTIDELEGATE_H

ampel-firmware/src/lib/EspSoftwareSerial/circular_queue/circular_queue.h

+/*
+circular_queue.h - Implementation of a lock-free circular queue for EspSoftwareSerial.
+Copyright (c) 2019 Dirk O. Kaar. All rights 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 __circular_queue_h
+#define __circular_queue_h
+
+#ifdef ARDUINO
+#include <Arduino.h>
+#endif
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+#include <atomic>
+#include <memory>
+#include <algorithm>
+#include "Delegate.h"
+using std::min;
+#else
+#include "ghostl.h"
+#endif
+
+#if !defined(ESP32) && !defined(ESP8266)
+#define IRAM_ATTR
+#endif
+
+/*!
+    @brief	Instance class for a single-producer, single-consumer circular queue / ring buffer (FIFO).
+            This implementation is lock-free between producer and consumer for the available(), peek(),
+            pop(), and push() type functions.
+*/
+template< typename T, typename ForEachArg = void >
+class circular_queue
+{
+public:
+    /*!
+        @brief	Constructs a valid, but zero-capacity dummy queue.
+    */
+    circular_queue() : m_bufSize(1)
+    {
+        m_inPos.store(0);
+        m_outPos.store(0);
+    }
+    /*!
+        @brief  Constructs a queue of the given maximum capacity.
+    */
+    circular_queue(const size_t capacity) : m_bufSize(capacity + 1), m_buffer(new T[m_bufSize])
+    {
+        m_inPos.store(0);
+        m_outPos.store(0);
+    }
+    circular_queue(circular_queue&& cq) :
+        m_bufSize(cq.m_bufSize), m_buffer(cq.m_buffer), m_inPos(cq.m_inPos.load()), m_outPos(cq.m_outPos.load())
+    {}
+    ~circular_queue()
+    {
+        m_buffer.reset();
+    }
+    circular_queue(const circular_queue&) = delete;
+    circular_queue& operator=(circular_queue&& cq)
+    {
+        m_bufSize = cq.m_bufSize;
+        m_buffer = cq.m_buffer;
+        m_inPos.store(cq.m_inPos.load());
+        m_outPos.store(cq.m_outPos.load());
+    }
+    circular_queue& operator=(const circular_queue&) = delete;
+
+    /*!
+        @brief	Get the numer of elements the queue can hold at most.
+    */
+    size_t capacity() const
+    {
+        return m_bufSize - 1;
+    }
+
+    /*!
+        @brief	Resize the queue. The available elements in the queue are preserved.
+                This is not lock-free and concurrent producer or consumer access
+                will lead to corruption.
+        @return True if the new capacity could accommodate the present elements in
+                the queue, otherwise nothing is done and false is returned.
+    */
+    bool capacity(const size_t cap);
+
+    /*!
+        @brief	Discard all data in the queue.
+    */
+    void flush()
+    {
+        m_outPos.store(m_inPos.load());
+    }
+
+    /*!
+        @brief	Get a snapshot number of elements that can be retrieved by pop.
+    */
+    size_t available() const
+    {
+        int avail = static_cast<int>(m_inPos.load() - m_outPos.load());
+        if (avail < 0) avail += m_bufSize;
+        return avail;
+    }
+
+    /*!
+        @brief	Get the remaining free elementes for pushing.
+    */
+    size_t available_for_push() const
+    {
+        int avail = static_cast<int>(m_outPos.load() - m_inPos.load()) - 1;
+        if (avail < 0) avail += m_bufSize;
+        return avail;
+    }
+
+    /*!
+        @brief	Peek at the next element pop will return without removing it from the queue.
+        @return An rvalue copy of the next element that can be popped. If the queue is empty,
+                return an rvalue copy of the element that is pending the next push.
+    */
+    T peek() const
+    {
+        const auto outPos = m_outPos.load(std::memory_order_relaxed);
+        std::atomic_thread_fence(std::memory_order_acquire);
+        return m_buffer[outPos];
+    }
+
+    /*!
+        @brief	Peek at the next pending input value.
+        @return A reference to the next element that can be pushed.
+    */
+    inline T& IRAM_ATTR pushpeek() __attribute__((always_inline))
+    {
+        const auto inPos = m_inPos.load(std::memory_order_relaxed);
+        std::atomic_thread_fence(std::memory_order_acquire);
+        return m_buffer[inPos];
+    }
+
+    /*!
+        @brief	Release the next pending input value, accessible by pushpeek(), into the queue.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    inline bool IRAM_ATTR push() __attribute__((always_inline))
+    {
+        const auto inPos = m_inPos.load(std::memory_order_acquire);
+        const size_t next = (inPos + 1) % m_bufSize;
+        if (next == m_outPos.load(std::memory_order_relaxed)) {
+            return false;
+        }
+    
+        std::atomic_thread_fence(std::memory_order_acquire);
+    
+        m_inPos.store(next, std::memory_order_release);
+        return true;
+    }
+
+    /*!
+        @brief	Move the rvalue parameter into the queue.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    inline bool IRAM_ATTR push(T&& val) __attribute__((always_inline))
+    {
+        const auto inPos = m_inPos.load(std::memory_order_acquire);
+        const size_t next = (inPos + 1) % m_bufSize;
+        if (next == m_outPos.load(std::memory_order_relaxed)) {
+            return false;
+        }
+    
+        std::atomic_thread_fence(std::memory_order_acquire);
+    
+        m_buffer[inPos] = std::move(val);
+    
+        std::atomic_thread_fence(std::memory_order_release);
+    
+        m_inPos.store(next, std::memory_order_release);
+        return true;
+    }
+
+    /*!
+        @brief	Push a copy of the parameter into the queue.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    inline bool IRAM_ATTR push(const T& val) __attribute__((always_inline))
+    {
+        T v(val);
+        return push(std::move(v));
+    }
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    /*!
+        @brief	Push copies of multiple elements from a buffer into the queue,
+                in order, beginning at buffer's head.
+        @return The number of elements actually copied into the queue, counted
+                from the buffer head.
+    */
+    size_t push_n(const T* buffer, size_t size);
+#endif
+
+    /*!
+        @brief	Pop the next available element from the queue.
+        @return An rvalue copy of the popped element, or a default
+                value of type T if the queue is empty.
+    */
+    T pop();
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    /*!
+        @brief	Pop multiple elements in ordered sequence from the queue to a buffer.
+                If buffer is nullptr, simply discards up to size elements from the queue.
+        @return The number of elements actually popped from the queue to
+                buffer.
+    */
+    size_t pop_n(T* buffer, size_t size);
+#endif
+
+    /*!
+        @brief	Iterate over and remove each available element from queue,
+                calling back fun with an rvalue reference of every single element.
+    */
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    void for_each(const Delegate<void(T&&), ForEachArg>& fun);
+#else
+    void for_each(Delegate<void(T&&), ForEachArg> fun);
+#endif
+
+    /*!
+        @brief	In reverse order, iterate over, pop and optionally requeue each available element from the queue,
+                calling back fun with a reference of every single element.
+                Requeuing is dependent on the return boolean of the callback function. If it
+                returns true, the requeue occurs.
+    */
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    bool for_each_rev_requeue(const Delegate<bool(T&), ForEachArg>& fun);
+#else
+    bool for_each_rev_requeue(Delegate<bool(T&), ForEachArg> fun);
+#endif
+
+protected:
+    const T defaultValue = {};
+    size_t m_bufSize;
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    std::unique_ptr<T[]> m_buffer;
+#else
+    std::unique_ptr<T> m_buffer;
+#endif
+    std::atomic<size_t> m_inPos;
+    std::atomic<size_t> m_outPos;
+};
+
+template< typename T, typename ForEachArg >
+bool circular_queue<T, ForEachArg>::capacity(const size_t cap)
+{
+    if (cap + 1 == m_bufSize) return true;
+    else if (available() > cap) return false;
+    std::unique_ptr<T[] > buffer(new T[cap + 1]);
+    const auto available = pop_n(buffer, cap);
+    m_buffer.reset(buffer);
+    m_bufSize = cap + 1;
+    std::atomic_thread_fence(std::memory_order_release);
+    m_inPos.store(available, std::memory_order_relaxed);
+    m_outPos.store(0, std::memory_order_release);
+    return true;
+}
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+template< typename T, typename ForEachArg >
+size_t circular_queue<T, ForEachArg>::push_n(const T* buffer, size_t size)
+{
+    const auto inPos = m_inPos.load(std::memory_order_acquire);
+    const auto outPos = m_outPos.load(std::memory_order_relaxed);
+
+    size_t blockSize = (outPos > inPos) ? outPos - 1 - inPos : (outPos == 0) ? m_bufSize - 1 - inPos : m_bufSize - inPos;
+    blockSize = min(size, blockSize);
+    if (!blockSize) return 0;
+    int next = (inPos + blockSize) % m_bufSize;
+
+    std::atomic_thread_fence(std::memory_order_acquire);
+
+    auto dest = m_buffer.get() + inPos;
+    std::copy_n(std::make_move_iterator(buffer), blockSize, dest);
+    size = min(size - blockSize, outPos > 1 ? static_cast<size_t>(outPos - next - 1) : 0);
+    next += size;
+    dest = m_buffer.get();
+    std::copy_n(std::make_move_iterator(buffer + blockSize), size, dest);
+
+    std::atomic_thread_fence(std::memory_order_release);
+
+    m_inPos.store(next, std::memory_order_release);
+    return blockSize + size;
+}
+#endif
+
+template< typename T, typename ForEachArg >
+T circular_queue<T, ForEachArg>::pop()
+{
+    const auto outPos = m_outPos.load(std::memory_order_acquire);
+    if (m_inPos.load(std::memory_order_relaxed) == outPos) return defaultValue;
+
+    std::atomic_thread_fence(std::memory_order_acquire);
+
+    auto val = std::move(m_buffer[outPos]);
+
+    std::atomic_thread_fence(std::memory_order_release);
+
+    m_outPos.store((outPos + 1) % m_bufSize, std::memory_order_release);
+    return val;
+}
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+template< typename T, typename ForEachArg >
+size_t circular_queue<T, ForEachArg>::pop_n(T* buffer, size_t size) {
+    size_t avail = size = min(size, available());
+    if (!avail) return 0;
+    const auto outPos = m_outPos.load(std::memory_order_acquire);
+    size_t n = min(avail, static_cast<size_t>(m_bufSize - outPos));
+
+    std::atomic_thread_fence(std::memory_order_acquire);
+
+    if (buffer) {
+        buffer = std::copy_n(std::make_move_iterator(m_buffer.get() + outPos), n, buffer);
+        avail -= n;
+        std::copy_n(std::make_move_iterator(m_buffer.get()), avail, buffer);
+    }
+
+    std::atomic_thread_fence(std::memory_order_release);
+
+    m_outPos.store((outPos + size) % m_bufSize, std::memory_order_release);
+    return size;
+}
+#endif
+
+template< typename T, typename ForEachArg >
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+void circular_queue<T, ForEachArg>::for_each(const Delegate<void(T&&), ForEachArg>& fun)
+#else
+void circular_queue<T, ForEachArg>::for_each(Delegate<void(T&&), ForEachArg> fun)
+#endif
+{
+    auto outPos = m_outPos.load(std::memory_order_acquire);
+    const auto inPos = m_inPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    while (outPos != inPos)
+    {
+        fun(std::move(m_buffer[outPos]));
+        std::atomic_thread_fence(std::memory_order_release);
+        outPos = (outPos + 1) % m_bufSize;
+        m_outPos.store(outPos, std::memory_order_release);
+    }
+}
+
+template< typename T, typename ForEachArg >
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+bool circular_queue<T, ForEachArg>::for_each_rev_requeue(const Delegate<bool(T&), ForEachArg>& fun)
+#else
+bool circular_queue<T, ForEachArg>::for_each_rev_requeue(Delegate<bool(T&), ForEachArg> fun)
+#endif
+{
+    auto inPos0 = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_acquire);
+    auto outPos = circular_queue<T, ForEachArg>::m_outPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    if (outPos == inPos0) return false;
+    auto pos = inPos0;
+    auto outPos1 = inPos0;
+    const auto posDecr = circular_queue<T, ForEachArg>::m_bufSize - 1;
+    do {
+        pos = (pos + posDecr) % circular_queue<T, ForEachArg>::m_bufSize;
+        T&& val = std::move(circular_queue<T, ForEachArg>::m_buffer[pos]);
+        if (fun(val))
+        {
+            outPos1 = (outPos1 + posDecr) % circular_queue<T, ForEachArg>::m_bufSize;
+            if (outPos1 != pos) circular_queue<T, ForEachArg>::m_buffer[outPos1] = std::move(val);
+        }
+    } while (pos != outPos);
+    circular_queue<T, ForEachArg>::m_outPos.store(outPos1, std::memory_order_release);
+    return true;
+}
+
+#endif // __circular_queue_h

ampel-firmware/src/lib/EspSoftwareSerial/circular_queue/circular_queue_mp.h

+/*
+circular_queue_mp.h - Implementation of a lock-free circular queue for EspSoftwareSerial.
+Copyright (c) 2019 Dirk O. Kaar. All rights 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 __circular_queue_mp_h
+#define __circular_queue_mp_h
+
+#include "circular_queue.h"
+
+#ifdef ESP8266
+#include "interrupts.h"
+#else
+#include <mutex>
+#endif
+
+/*!
+    @brief	Instance class for a multi-producer, single-consumer circular queue / ring buffer (FIFO).
+            This implementation is lock-free between producers and consumer for the available(), peek(),
+            pop(), and push() type functions, but is guarded to safely allow only a single producer
+            at any instant.
+*/
+template< typename T, typename ForEachArg = void >
+class circular_queue_mp : protected circular_queue<T, ForEachArg>
+{
+public:
+    circular_queue_mp() = default;
+    circular_queue_mp(const size_t capacity) : circular_queue<T, ForEachArg>(capacity)
+    {}
+    circular_queue_mp(circular_queue<T, ForEachArg>&& cq) : circular_queue<T, ForEachArg>(std::move(cq))
+    {}
+    using circular_queue<T, ForEachArg>::operator=;
+    using circular_queue<T, ForEachArg>::capacity;
+    using circular_queue<T, ForEachArg>::flush;
+    using circular_queue<T, ForEachArg>::available;
+    using circular_queue<T, ForEachArg>::available_for_push;
+    using circular_queue<T, ForEachArg>::peek;
+    using circular_queue<T, ForEachArg>::pop;
+    using circular_queue<T, ForEachArg>::pop_n;
+    using circular_queue<T, ForEachArg>::for_each;
+    using circular_queue<T, ForEachArg>::for_each_rev_requeue;
+
+    /*!
+        @brief	Resize the queue. The available elements in the queue are preserved.
+                This is not lock-free, but safe, concurrent producer or consumer access
+                is guarded.
+        @return True if the new capacity could accommodate the present elements in
+                the queue, otherwise nothing is done and false is returned.
+    */
+    bool capacity(const size_t cap)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::capacity(cap);
+    }
+
+    bool IRAM_ATTR push() = delete;
+
+    /*!
+        @brief	Move the rvalue parameter into the queue, guarded
+                for multiple concurrent producers.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    bool IRAM_ATTR push(T&& val)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::push(std::move(val));
+    }
+
+    /*!
+        @brief	Push a copy of the parameter into the queue, guarded
+                for multiple concurrent producers.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    bool IRAM_ATTR push(const T& val)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::push(val);
+    }
+
+    /*!
+        @brief	Push copies of multiple elements from a buffer into the queue,
+                in order, beginning at buffer's head. This is guarded for
+                multiple producers, push_n() is atomic.
+        @return The number of elements actually copied into the queue, counted
+                from the buffer head.
+    */
+    size_t push_n(const T* buffer, size_t size)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::push_n(buffer, size);
+    }
+
+    /*!
+        @brief	Pops the next available element from the queue, requeues
+                it immediately.
+        @return A reference to the just requeued element, or the default
+                value of type T if the queue is empty.
+    */
+    T& pop_requeue();
+
+    /*!
+        @brief	Iterate over, pop and optionally requeue each available element from the queue,
+                calling back fun with a reference of every single element.
+                Requeuing is dependent on the return boolean of the callback function. If it
+                returns true, the requeue occurs.
+    */
+    bool for_each_requeue(const Delegate<bool(T&), ForEachArg>& fun);
+
+#ifndef ESP8266
+protected:
+    std::mutex m_pushMtx;
+#endif
+};
+
+template< typename T, typename ForEachArg >
+T& circular_queue_mp<T, ForEachArg>::pop_requeue()
+{
+#ifdef ESP8266
+    esp8266::InterruptLock lock;
+#else
+    std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+    const auto outPos = circular_queue<T, ForEachArg>::m_outPos.load(std::memory_order_acquire);
+    const auto inPos = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    if (inPos == outPos) return circular_queue<T, ForEachArg>::defaultValue;
+    T& val = circular_queue<T, ForEachArg>::m_buffer[inPos] = std::move(circular_queue<T, ForEachArg>::m_buffer[outPos]);
+    const auto bufSize = circular_queue<T, ForEachArg>::m_bufSize;
+    std::atomic_thread_fence(std::memory_order_release);
+	circular_queue<T, ForEachArg>::m_outPos.store((outPos + 1) % bufSize, std::memory_order_relaxed);
+	circular_queue<T, ForEachArg>::m_inPos.store((inPos + 1) % bufSize, std::memory_order_release);
+    return val;
+}
+
+template< typename T, typename ForEachArg >
+bool circular_queue_mp<T, ForEachArg>::for_each_requeue(const Delegate<bool(T&), ForEachArg>& fun)
+{
+    auto inPos0 = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_acquire);
+    auto outPos = circular_queue<T, ForEachArg>::m_outPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    if (outPos == inPos0) return false;
+    do {
+        T&& val = std::move(circular_queue<T, ForEachArg>::m_buffer[outPos]);
+        if (fun(val))
+        {
+#ifdef ESP8266
+            esp8266::InterruptLock lock;
+#else
+            std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+            std::atomic_thread_fence(std::memory_order_release);
+            auto inPos = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_relaxed);
+            std::atomic_thread_fence(std::memory_order_acquire);
+			circular_queue<T, ForEachArg>::m_buffer[inPos] = std::move(val);
+            std::atomic_thread_fence(std::memory_order_release);
+			circular_queue<T, ForEachArg>::m_inPos.store((inPos + 1) % circular_queue<T, ForEachArg>::m_bufSize, std::memory_order_release);
+        }
+        else
+        {
+            std::atomic_thread_fence(std::memory_order_release);
+        }
+        outPos = (outPos + 1) % circular_queue<T, ForEachArg>::m_bufSize;
+		circular_queue<T, ForEachArg>::m_outPos.store(outPos, std::memory_order_release);
+    } while (outPos != inPos0);
+    return true;
+}
+
+#endif // __circular_queue_mp_h

ampel-firmware/src/lib/EspSoftwareSerial/circular_queue/ghostl.h

+/*
+ghostl.h - Implementation of a bare-bones, mostly no-op, C++ STL shell
+           that allows building some Arduino ESP8266/ESP32
+           libraries on Aruduino AVR.
+Copyright (c) 2019 Dirk O. Kaar. All rights 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 __ghostl_h
+#define __ghostl_h
+
+#if defined(ARDUINO_ARCH_SAMD)
+#include <atomic>
+#endif
+
+using size_t = decltype(sizeof(char));
+
+namespace std
+{
+#if !defined(ARDUINO_ARCH_SAMD)
+    typedef enum memory_order {
+        memory_order_relaxed,
+        memory_order_acquire,
+        memory_order_release,
+        memory_order_seq_cst
+    } memory_order;
+    template< typename T > class atomic {
+    private:
+        T value;
+    public:
+        atomic() {}
+        atomic(T desired) { value = desired; }
+        void store(T desired, std::memory_order = std::memory_order_seq_cst) volatile noexcept { value = desired; }
+        T load(std::memory_order = std::memory_order_seq_cst) const volatile noexcept { return value; }
+    };
+    inline void atomic_thread_fence(std::memory_order order) noexcept {}
+    template< typename T >	T&& move(T& t) noexcept { return static_cast<T&&>(t); }
+#endif
+
+    template< typename T, size_t long N > struct array
+    {
+        T _M_elems[N];
+        decltype(sizeof(0)) size() const { return N; }
+        T& operator[](decltype(sizeof(0)) i) { return _M_elems[i]; }
+        const T& operator[](decltype(sizeof(0)) i) const { return _M_elems[i]; }
+    };
+
+    template< typename T > class unique_ptr
+    {
+    public:
+        using pointer = T*;
+        unique_ptr() noexcept : ptr(nullptr) {}
+        unique_ptr(pointer p) : ptr(p) {}
+        pointer operator->() const noexcept { return ptr; }
+        T& operator[](decltype(sizeof(0)) i) const { return ptr[i]; }
+        void reset(pointer p = pointer()) noexcept
+        {
+            delete ptr;
+            ptr = p;
+        }
+        T& operator*() const { return *ptr; }
+    private:
+        pointer ptr;
+    };
+
+    template< typename T > using function = T*;
+    using nullptr_t = decltype(nullptr);
+
+    template<typename T>
+    struct identity {
+        typedef T type;
+    };
+
+    template <typename T>
+    inline T&& forward(typename identity<T>::type& t) noexcept
+    {
+        return static_cast<typename identity<T>::type&&>(t);
+    }
+}
+
+#endif // __ghostl_h