update of https://github.com/SlashDevin/NeoHWSerial

Update of NeoHWSerial (https://github.com/SlashDevin/NeoHWSerial).
Changes:
  - add required files for Arduino IDE >=v1.5.6
  - renamed attachInterrupt()/detachInterrupt() to
attachRxInterrupt()/attachTxInterrupt()
  - add attachTxInterrupt()/detachTxInterrupt() for user function on
Tx-empty interrupt. Useful e.g. for sync break handling in LIN bus
  - call user Rx-ISR function with UART status byte. Useful e.g. for
sync break handling in LIN bus
  - enable optional default action in user function via return value

Author: gicking

1.0.5/NeoHWSerial.cpp

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 gicking
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

1.0.5/NeoHWSerial.h

@@ -1,26 +1,32 @@
-The **NeoHWSerial** class is a drop-in replacement for the Arduino built-in class `HardwareSerial`.  It adds the capability to handle received characters with a user-defined function *during* the RX interrupt.  This can improve performance significantly by eliminating all processing associated with storing and retrieving characters in the ring buffer **and** all polling code that constantly checked for new characters: `available` and `read` are unnecessary.
+The **NeoHWSerial** class is a drop-in replacement for the Arduino built-in class `HardwareSerial`. It adds the capability to handle received characters with a user-defined function *during* the RX interrupt. This can improve performance significantly by eliminating all processing associated with storing and retrieving characters in the ring buffer **and** all polling code that constantly checked for new characters: `available` and `read` are unnecessary.
+
+Note: This is a minor update of [NeoHWSerial by SlashDevin](https://github.com/SlashDevin/NeoHWSerial) for AVR. Changes:
+  - updated to Arduino IDE >=v1.5.6 library format (see [here](https://arduino.github.io/arduino-cli/latest/library-specification/))
+  - pass UART status byte to user receive function. Required e.g. for break detection in [LIN bus](https://en.wikipedia.org/wiki/Local_Interconnect_Network)
+  - support optional storing to ring buffer after return from user routine via return value
+
 
 ### Installation
 
 1. Download the NeoHWSerial master zip file.
 2. Extract all files into a tempory working directory.
-3. Create a `NeoHWSerial` subdirectory in your `Arduino/Libraries` directory.
-4. Copy all files from the version number subdirectory that corresponds to your IDE version into the `NeoHWSerial` subdirectory you created in step 1.  For example, if you are using Arduino IDE version 1.0.5, copy all files from the extracted `NeoHWSerial-master/1.0.5` subdirectory into your `Arduino/Libraries/NeoHWSerial` subdirectory.
+3. Create a `NeoHWSerial` subdirectory in your `Arduino/libraries` directory.
 
 ### Usage
 
 To handle all received characters with your function, you must register it with the specific `NeoSerial[n]` instance:
 
     #include <NeoHWSerial.h>
-    
+
     volatile uint32_t newlines = 0UL;
-    
-    static void handleRxChar( uint8_t c )
+
+    static bool handleRxChar( uint8_t c, uint8_t status )
     {
       if (c == '\n')
         newlines++;
+      return false;  // don't store c in ring buffer
     }
-    
+
     void setup()
     {
       NeoSerial1.attachInterrupt( handleRxChar );
@@ -29,14 +35,14 @@ To handle all received characters with your function, you must register it with
 
 Remember that the registered function is called from an interrupt context, and it should return as quickly as possible.  Taking too much time in the function will cause many unpredictable behaviors, including loss of received data.  See the similar warnings for the built-in [`attachInterrupt`](https://www.arduino.cc/en/Reference/AttachInterrupt) for digital pins.
 
-The registered function will be called from the ISR whenever a character is received.  The received character **will not** be stored in the `rx_buffer`, and it **will not** be returned from `read()`.  Any characters that were received and buffered before `attachInterrupt` was called remain in `rx_buffer`, and could be retrieved by calling `read()`.
+The registered function will be called from the ISR whenever a character is received.  The received character is stored in the `rx_buffer` after return from the user function, if the user function returns a _true_ value.  Characters that were received and buffered before `attachInterrupt` was called remain in `rx_buffer`, and could be retrieved by calling `read()`.
 
 If `attachInterrupt` is never called, or it is passed a `NULL` function, the normal buffering occurs, and all received characters must be obtained by calling `read()`.
 
 The original `HardwareSerial` files were modified to include two new methods, `attachInterrupt` and `detachInterrupt`, and one new data member, the private `_isr`:
 
 ```
-    typedef void (* isr_t)( uint8_t );
+    typedef void (* isr_t)( uint8_t, uint8_t );
     void attachInterrupt( isr_t fn );
     void detachInterrupt() { attachInterrupt( (isr_t) NULL ); };
 
@@ -48,9 +54,9 @@ The original `HardwareSerial` files were modified to include two new methods, `a
 
 To avoid name collisions, all `HardwareSerial` instances are prefixed with "Neo" in this replacement library.  All parts of your sketch, including other libraries, must use
 
-*  `NeoSerial` instead of `Serial`, 
+*  `NeoSerial` instead of `Serial`,
 *  `NeoSerial1` instead of `Serial1`,
-*  `NeoSerial2` instead of `Serial2`, and 
+*  `NeoSerial2` instead of `Serial2`, and
 *  `NeoSerial3` instead of `Serial3`.
 
 If there are any references to the original `HardwareSerial` instances, you will get one or more linker errors:

LICENSE

@@ -5,16 +5,17 @@
 //  interrupt with NeoHWSerial.
 //
 
-static volatile uint16_t count = 0;
+static volatile uint16_t ISR_count = 0;
 
-static void char_received( uint8_t c )
+static bool char_received( uint8_t c, uint8_t status )
 {
   // This is a little naughty, as it will try to block
   //   in this ISR if the tx_buffer is full.  For this example,
   //   we are only sending as many characters as we have received,
   //   and they arrive at the same rate we are sending them.
   NeoSerial.write( c );
-  count++;
+  ISR_count++;
+  return false;  // do not store received data to ring buffer
 }
 
 void setup()
@@ -28,17 +29,21 @@ void loop()
 {
   delay( 1000 );
 
-  uint8_t oldSREG = SREG;
+  // get number of calls to char_received()
   noInterrupts();
-    uint16_t old_count = count;
-    count = 0;
-  SREG = oldSREG;
-  
-  if (old_count) {
+  uint16_t echo_count = ISR_count;
+  ISR_count = 0;
+  interrupts();
+
+  if (echo_count)
+  {
     NeoSerial.print( '\n' );
-    NeoSerial.print( old_count );
+    NeoSerial.print( echo_count );
     NeoSerial.println( F(" characters echoed") );
-  } else
+  }
+  else
+  {
     NeoSerial.print( '.' );
+  }
   NeoSerial.flush();
-}
+}

README.md

@@ -0,0 +1,65 @@
+###############################################
+# Syntax coloring for NeoHWSerial library
+###############################################
+
+###################################
+# Classes and Datatypes (KEYWORD1)
+###################################
+
+NeoSerial	KEYWORD1
+NeoSerial0	KEYWORD1
+NeoSerial1	KEYWORD1
+NeoSerial2	KEYWORD1
+NeoSerial3	KEYWORD1
+
+###################################
+# Methods and Functions (KEYWORD2)
+###################################
+
+begin	KEYWORD2
+end	KEYWORD2
+available	KEYWORD2
+peek	KEYWORD2
+read	KEYWORD2
+availableForWrite	KEYWORD2
+flush	KEYWORD2
+write	KEYWORD2
+attachInterrupt	KEYWORD2
+detachInterrupt	KEYWORD2
+serialEventRun	KEYWORD2
+
+###################################
+# Constants (LITERAL1)
+###################################
+
+HAVE_HWSERIAL0	LITERAL1
+HAVE_HWSERIAL1	LITERAL1
+HAVE_HWSERIAL2	LITERAL1
+HAVE_HWSERIAL3	LITERAL1
+SERIAL_TX_BUFFER_SIZE	LITERAL1
+SERIAL_5N1  LITERAL1
+SERIAL_6N1  LITERAL1
+SERIAL_7N1  LITERAL1
+SERIAL_8N1  LITERAL1
+SERIAL_5N2  LITERAL1
+SERIAL_6N2  LITERAL1
+SERIAL_7N2  LITERAL1
+SERIAL_8N2  LITERAL1
+SERIAL_5E1  LITERAL1
+SERIAL_6E1  LITERAL1
+SERIAL_7E1  LITERAL1
+SERIAL_8E1  LITERAL1
+SERIAL_5E2  LITERAL1
+SERIAL_6E2  LITERAL1
+SERIAL_7E2  LITERAL1
+SERIAL_8E2  LITERAL1
+SERIAL_5O1  LITERAL1
+SERIAL_6O1  LITERAL1
+SERIAL_7O1  LITERAL1
+SERIAL_8O1  LITERAL1
+SERIAL_5O2  LITERAL1
+SERIAL_6O2  LITERAL1
+SERIAL_7O2  LITERAL1
+SERIAL_8O2  LITERAL1
+
+##################### END #####################

1.0.5/examples/echo/echo.ino renamed to examples/echo/echo.ino

@@ -0,0 +1,9 @@
+name=NeoHWSerial
+version=1.6.6
+author=Georg Icking-Konert
+maintainer=Georg Icking-Konert
+sentence=NeoHWSerial for AVR
+paragraph=Adaptation of NeoHWSerial by SlashDevin for AVR
+category=Communication
+url=https://github.com/gicking/NeoHWSerial
+architectures=avr