From c7cf26185e43c2270f6eb0d08a9807a32a621d9f Mon Sep 17 00:00:00 2001 From: August Quint <49277349+AugustQu@users.noreply.github.com> Date: Wed, 5 Feb 2020 16:40:15 +0100 Subject: [PATCH] Delete README.md --- EspSoftwareSerial/README.md | 124 ------------------------------------ 1 file changed, 124 deletions(-) delete mode 100644 EspSoftwareSerial/README.md diff --git a/EspSoftwareSerial/README.md b/EspSoftwareSerial/README.md deleted file mode 100644 index 2d14c9e6..00000000 --- a/EspSoftwareSerial/README.md +++ /dev/null @@ -1,124 +0,0 @@ -# EspSoftwareSerial - -## Implementation of the Arduino software serial library for the ESP8266 / ESP32 - -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. - -## 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 93 (91 characters net plus two tolerance). -The signal edge detection buffer capacity (``isrBufCapacity``) is 10, as each octet has -10 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 ``peekParityError()`` function. Note that parity -checking must be done before ``read()``, as the parity information is removed -from the buffer when reading the corresponding byte. - -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 -``peekParityError()`` function. To send a byte with the parity bit set, just add -``MARK`` as the second argument when writing, e.g. ``write(ch, MARK)``. - -## 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 -```