fixed index bug in storing data to ring buffer

Author: gicking

.gitattributes

@@ -1,16 +1,15 @@
 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)
+  - updated library structure 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 for [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.
+This library can be installed via the library manager of the Arduino IDE.
+
 
 ### Usage
 

.gitignore

@@ -0,0 +1,63 @@
+/*
+  Simple LIN 2.x master to generate frames for the LIN sniffer
+  Create alternating frames of lengths 8 and 2.
+*/
+
+// include files                                                                       
+#include "LIN_master3.h"      // send LIN frames via Serial3
+
+// pause between LIN frames
+#define LIN_PAUSE     200
+
+
+void setup(void)
+{
+  // initialize LIN master (blocking operation)
+  LIN_master3.begin(19200, LIN_V2, false);
+
+} // setup()
+
+
+
+void loop(void)
+{
+  static uint32_t lastCall = LIN_PAUSE;
+  static uint8_t  count = 0;
+  static uint8_t  Tx[8] = {0,0,0,0,0,0,0,0};    // daty bytes
+  
+
+  // simple LIN scheduler
+  if (millis() - lastCall > LIN_PAUSE) {
+    lastCall = millis();
+
+    // send frame 1
+    if (count == 0)
+    {
+      // increase frame index
+      count++;
+
+      // send master request
+      LIN_master3.sendMasterRequest(0x07, 8, Tx);
+
+      // increase data_byte[0]
+      Tx[0]++;
+
+    }
+
+    // send frame 2
+    else
+    {
+      // revert frame index
+      count = 0;
+      
+      // send master request
+      LIN_master3.sendMasterRequest(0x04, 2, Tx);
+
+      // decrease data_byte[1]
+      Tx[1]--;
+
+    }
+      
+  } // scheduler
+    
+} // loop()

LICENSE

@@ -0,0 +1,212 @@
+////////////////
+// INCLUDE LIBRARIES
+////////////////
+
+#include <NeoHWSerial.h>
+
+
+////////////////
+// GLOBAL MACROS / DEFINES
+////////////////
+
+// LIN versions (required for checksum calculation)
+#define LIN_V1    1
+#define LIN_V2    2
+
+
+////////////////
+// GLOBAL STRUCTS / TYPEDEFS
+////////////////
+
+// frame type
+typedef struct
+{
+  int           numData;      // number of data bytes
+
+  union
+  {
+    uint8_t     bufRx[12];    // raw frame: BRK, SYNC, ID, DATA0..8, CHK
+
+    // access to individual bytes by name
+    struct
+    {
+      uint8_t   BRK;        // sync break (always 0x00)
+      uint8_t   SYNC;       // sync field (always 0x55)
+      uint8_t   ID;         // frame ID
+      uint8_t   DATA[8];    // data bytes (max. 8)
+      uint8_t   CHK;        // frame checksum
+    };
+    
+  };
+  
+} frame_t;
+
+
+////////////////
+// GLOBAL VARIABLES
+////////////////
+
+// global frame buffer
+frame_t   frame;
+
+// flag to indicate that frame was received. Set in Serial Rx-ISR on reception of next BRK
+bool      flagFrame = false;
+
+
+////////////////
+// GLOBAL FUNCTIONS
+////////////////
+
+/////////////////////
+// calculate the LIN frame checksum
+// note: checksum is different for v1.x and v2.x; exceptions are diagnostic frames which use v1.x checksum
+/////////////////////
+uint8_t LIN_checksum(uint8_t version, uint8_t id, uint8_t numData, uint8_t *data)
+{
+  uint16_t chk=0x00;
+
+  // LIN2.x uses extended checksum which includes protected ID, i.e. including parity bits
+  // LIN1.x uses classical checksum only over data bytes
+  // Diagnostic frames with ID 0x3C and 0x3D/0x7D always use classical checksum (see LIN spec "2.3.1.5 Checkum")
+  if (!((version == LIN_V1) || (id == 0x3C) || (id == 0x7D)))    // if version 2  & no diagnostic frames (0x3C=60 (PID=0x3C) or 0x3D=61 (PID=0x7D))
+    chk = (uint16_t) id;
+
+  // loop over data bytes
+  for (uint8_t i = 0; i < numData; i++)
+  {
+    chk += (uint16_t) (data[i]);
+    if (chk>255)
+      chk -= 255;
+  }
+  chk = (uint8_t)(0xFF - ((uint8_t) chk));   // bitwise invert
+
+  // return frame checksum
+  return chk;
+
+} // LIN_checksum()
+
+
+
+/////////////////////
+// custom Serial receive interrupt function
+/////////////////////
+static bool ISR_Rx( uint8_t rx, uint8_t UCSRA )
+{
+  static uint8_t idx = 0;     // byte index in frame
+  static uint8_t Rx[12];
+  
+  // check for LIN sync break (=0x00 with framing error)
+  if ((rx == 0x00) && (UCSRA & (1<<FE0)))
+  {
+    // previous frame complete -> set flag. Skip for first frame
+    if (frame.BRK != 0xFF)
+      flagFrame = true;
+
+    // copy previous frame to global variables to avoid conflict
+    frame.numData  = (int) idx - 3;
+    memcpy(frame.bufRx, Rx, 12);
+    frame.CHK = Rx[idx];
+    
+    // reset byte index in frame
+    idx=0;
+
+  } // sync break received
+
+  
+  // normal frame bytes -> just increase byte index in frame
+  else
+  {
+    // avoid buffer overrun
+    if (idx<11)
+      idx++;
+
+  } // normal frame bytes
+  
+
+  // copy received byte to local buffer
+  Rx[idx] = rx;
+
+  // do not store received data to Serial ring buffer
+  return false;
+  
+} // ISR_Rx()
+
+
+
+/////////////////////
+// initialization
+/////////////////////
+void setup()
+{
+  // initialize BRK to 0xFF to indicate 1st frame
+  frame.BRK = 0xFF;
+
+  // initilize PC connection
+  NeoSerial.begin(115200);
+  
+  // initialize LIN interface
+  NeoSerial2.begin(19200);
+
+  // attach protocol handler to used Serial
+  NeoSerial2.attachInterrupt( ISR_Rx );
+
+} // setup()
+
+
+
+/////////////////////
+// main loop
+/////////////////////
+void loop()
+{  
+  // a LIN frame was received --> handle it
+  if (flagFrame)
+  {
+    // handle each frame only once
+    flagFrame = false;
+
+    // check sync break (must be 0x00 w/ framing error)
+    if (frame.BRK != 0x00)
+    {
+      NeoSerial.print("error: wrong BRK, expect 0x00, read 0x");
+      NeoSerial.println((int) (frame.BRK), HEX);
+    }
+    
+    // check sync field (must be 0x55)
+    else if (frame.SYNC != 0x55)
+    {
+      NeoSerial.print("error: wrong SYNC, expect 0x55, read 0x");
+      NeoSerial.println((int) (frame.SYNC), HEX);
+    }
+    
+    // check frame checksum (different for LIN v1.x and v2.x!)
+    else if (frame.CHK != LIN_checksum(LIN_V2, frame.ID, frame.numData, frame.DATA))
+    {
+      NeoSerial.print("error: checksum error, expect 0x");
+      NeoSerial.print((int) (LIN_checksum(LIN_V2, frame.ID, frame.numData, frame.DATA)), HEX);
+      NeoSerial.print(", read 0x");
+      NeoSerial.println((int) (frame.CHK), HEX);
+    }
+
+    // no error -> handle frame (here only print)
+    else {
+
+      // print ID
+      NeoSerial.print("ID:");
+      NeoSerial.print((int) frame.ID, HEX);
+      NeoSerial.print(" ");
+
+      // print data bytes
+      NeoSerial.print("DATA:");
+      for (int i=0; i<frame.numData; i++)
+      {
+        NeoSerial.print((int) (frame.DATA[i]), HEX);
+        NeoSerial.print(" ");
+      }
+      NeoSerial.println();
+
+    } // no error
+  
+  } // handle previous LIN frame
+    
+} // loop()