LIN_slave_Base.h

Go to the documentation of this file.

 
/*-----------------------------------------------------------------------------
  MODULE DEFINITION FOR MULTIPLE INCLUSION
-----------------------------------------------------------------------------*/
#ifndef _LIN_SLAVE_BASE_H_
#define _LIN_SLAVE_BASE_H_
 
 
/*-----------------------------------------------------------------------------
  GLOBAL DEFINES
-----------------------------------------------------------------------------*/
 
// misc parameters
#define LIN_SLAVE_BUFLEN_NAME           30            
#define LIN_SLAVE_LIN_PORT_TIMEOUT      3000          
 
// required for CI test environment. Call arduino-cli with "-DINCLUDE_NEOHWSERIAL"
#if defined(INCLUDE_NEOHWSERIAL)
  #include <NeoHWSerial.h>
#endif
 
// optional LIN debug output @ 115.2kBaud. Comment out for none. When using together with NeoHWSerial on AVR must use NeoSerialx to avoid linker conflict
#if !defined(LIN_SLAVE_DEBUG_SERIAL)
  //#define LIN_SLAVE_DEBUG_SERIAL      Serial          //!< serial interface used for debug output
  //#define LIN_SLAVE_DEBUG_SERIAL      NeoSerial       //!< serial interface used for debug output (optional on AVR, not together with HardwareSerial!)
  //#include <NeoHWSerial.h>                            // comment in/out together with previous line
  //#define LIN_SLAVE_DEBUG_SERIAL     SerialUSB        //!< serial interface used for debug output (optional on Due)
#endif
#if !defined(LIN_SLAVE_DEBUG_LEVEL)
  #define LIN_SLAVE_DEBUG_LEVEL         2             
#endif
#if !defined(LIN_SLAVE_DEBUG_PORT_TIMEOUT)
  #define LIN_SLAVE_DEBUG_PORT_TIMEOUT  3000          
#endif
#if !defined(LIN_SLAVE_DEBUG_BUFSIZE)
  #define LIN_SLAVE_DEBUG_BUFSIZE      128            
#endif
 
// define logging macros for optional debug output.
// Use with printf() format like: DEBUG_PRINT(2, "Text=%s, Value=%d", text, value);
#if defined(LIN_SLAVE_DEBUG_SERIAL)
  
  // debug output macro for normal class methods
  #define DEBUG_PRINT(level, fmt, ...) \
    do { \
      if (LIN_SLAVE_DEBUG_LEVEL >= level) { \
        LIN_SLAVE_DEBUG_SERIAL.print(this->nameLIN); \
        LIN_SLAVE_DEBUG_SERIAL.print(F(": ")); \
        LIN_SLAVE_DEBUG_SERIAL.print(__PRETTY_FUNCTION__); \
        LIN_SLAVE_DEBUG_SERIAL.print(F(": ")); \
        char debug_buf[LIN_SLAVE_DEBUG_BUFSIZE]; \
        snprintf(debug_buf, sizeof(debug_buf), (fmt), ##__VA_ARGS__); \
        LIN_SLAVE_DEBUG_SERIAL.println(debug_buf); \
      } \
    } while(0)
  
  // debug output macro for static class methods and functions
  #define DEBUG_PRINT_STATIC(level, fmt, ...) \
    do { \
      if (LIN_SLAVE_DEBUG_LEVEL >= level) { \
        LIN_SLAVE_DEBUG_SERIAL.print(__PRETTY_FUNCTION__); \
        LIN_SLAVE_DEBUG_SERIAL.print(F(": ")); \
        char debug_buf[LIN_SLAVE_DEBUG_BUFSIZE]; \
        snprintf(debug_buf, sizeof(debug_buf), (fmt), ##__VA_ARGS__); \
        LIN_SLAVE_DEBUG_SERIAL.println(debug_buf); \
      } \
    } while(0)
  
 
// no debug output -> omit logging macro
#else
 
  // do nothing. Use safe empty macros
  #define DEBUG_PRINT(level, fmt, ...) do {} while (0)
  #define DEBUG_PRINT_STATIC(level, fmt, ...) do {} while (0)
 
#endif // LIN_SLAVE_DEBUG_SERIAL
 
 
/*-----------------------------------------------------------------------------
  INCLUDE FILES
-----------------------------------------------------------------------------*/
 
// generic Arduino functions
#include <Arduino.h>
 
 
/*-----------------------------------------------------------------------------
  GLOBAL CLASS
-----------------------------------------------------------------------------*/
 
class LIN_Slave_Base
{
  // PUBLIC TYPEDEFS
  public:
 
    typedef enum : uint8_t
    {
      LIN_V1                = 1,                
      LIN_V2                = 2                 
    } version_t;
 
 
    typedef enum : uint8_t
    {
      MASTER_REQUEST        = 0x10,             
      SLAVE_RESPONSE        = 0x20              
    } frame_t;
 
 
    typedef enum : uint8_t
    { 
      STATE_OFF             = 0x01,             
      STATE_WAIT_FOR_BREAK  = 0x02,             
      STATE_WAIT_FOR_SYNC   = 0x04,             
      STATE_WAIT_FOR_PID    = 0x08,             
      STATE_RECEIVING_DATA  = 0x10,             
      STATE_RECEIVING_ECHO  = 0x20,             
      STATE_WAIT_FOR_CHK    = 0x40,             
      STATE_DONE            = 0x80              
    } state_t;
 
 
    typedef enum : uint8_t
    {
      NO_ERROR              = 0x00,             
      ERROR_STATE           = 0x01,             
      ERROR_ECHO            = 0x02,             
      ERROR_TIMEOUT         = 0x04,             
      ERROR_CHK             = 0x08,             
      ERROR_SYNC            = 0x10,             
      ERROR_PID             = 0x20,             
      ERROR_MISC            = 0x80              
    } error_t;
 
 
  // PROTECTED TYPEDEFS
  protected:
 
    typedef void (*LinMessageCallback)(uint8_t numData, uint8_t* data);
 
    typedef struct
    {
      uint8_t                 type_numData;     
      LinMessageCallback      fct;              
    } callback_t;
 
 
  // PROTECTED VARIABLES
  protected:
 
    // node properties
    int8_t                    pinTxEN;          
    uint16_t                  baudrate;         
    LIN_Slave_Base::version_t version;          
    LIN_Slave_Base::state_t   state;            
    LIN_Slave_Base::error_t   error;            
    bool                      flagBreak;        
    LIN_Slave_Base::callback_t  callback[64];   
 
    // latest frame properties
    uint8_t                   pid;              
    uint8_t                   id;               
    LIN_Slave_Base::frame_t   type;             
    uint8_t                   numData;          
    uint8_t                   bufData[9];       
    uint8_t                   idxData;          
    uint32_t                  timeoutRx;        
    uint32_t                  timeLastRx;       
 
 
  // PUBLIC VARIABLES
  public:
 
    char                      nameLIN[LIN_SLAVE_BUFLEN_NAME];   
 
 
  // PROTECTED METHODS
  protected:
  
    uint8_t _calculatePID(uint8_t ID);
  
    uint8_t _calculateChecksum(uint8_t NumData, uint8_t Data[]);
 
    virtual bool _getBreakFlag(void);
 
    virtual void _resetBreakFlag(void);
 
 
    virtual inline uint8_t _serialPeek(void) { return 0x00; }
 
    virtual inline uint8_t _serialRead(void) { return 0x00; }
 
    virtual inline void _serialWrite(uint8_t buf[], uint8_t num) { (void) buf; (void) num; }
    
 
    inline void _enableTransmitter(void)
    {   
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // enable tranmitter
      if (this->pinTxEN >= 0)
        digitalWrite(this->pinTxEN, HIGH);
    
    } // _enableTransmitter()
    
    inline void _disableTransmitter(void)
    { 
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // disable tranmitter
      if (this->pinTxEN >= 0)
        digitalWrite(this->pinTxEN, LOW);
            
    } // _disableTransmitter()
 
 
  // PUBLIC METHODS
  public:
  
    LIN_Slave_Base(LIN_Slave_Base::version_t Version = LIN_Slave_Base::LIN_V2, const char NameLIN[] = "Slave", 
      uint32_t TimeoutRx = 1500L, const int8_t PinTxEN = INT8_MIN);
 
    virtual ~LIN_Slave_Base(void) {};
 
 
    virtual void begin(uint16_t Baudrate = 19200);
    
    virtual void end(void);
    
    virtual inline bool available(void) { return false; }
 
    
    inline void resetStateMachine(void)
    {
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // reset state      
      this->state = LIN_Slave_Base::STATE_WAIT_FOR_BREAK;
      
    } // resetStateMachine()
 
    inline LIN_Slave_Base::state_t getState(void)
    {
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // return state
      return this->state;
 
    } // getState()
 
 
    inline void resetError(void) 
    {
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // reset error
      this->error = LIN_Slave_Base::NO_ERROR;
 
    } // resetError()
    
    inline LIN_Slave_Base::error_t getError(void)
    {
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // return error
      return this->error;
 
    } // getError()
 
    
    inline void getFrame(LIN_Slave_Base::frame_t &Type, uint8_t &Id, uint8_t &NumData, uint8_t Data[])
    { 
      // print debug message
      DEBUG_PRINT(3, " ");
 
      noInterrupts();                         // for data consistency temporarily disable ISRs
      Type    = this->type;                   // frame type 
      Id      = this->id;                     // received frame ID
      NumData = this->numData;                // number of data bytes (excl. BREAK, SYNC, ID, CHK)
      memcpy(Data, this->bufData, NumData);   // copy data bytes w/o checksum
      interrupts();                           // re-enable ISRs
 
    } // getFrame()
 
 
    void registerMasterRequestHandler(uint8_t ID, LIN_Slave_Base::LinMessageCallback Fct, uint8_t NumData);
 
    void registerSlaveResponseHandler(uint8_t ID, LIN_Slave_Base::LinMessageCallback Fct, uint8_t NumData);
 
 
    virtual void handler(void);
 
}; // class LIN_Slave_Base
 
/*-----------------------------------------------------------------------------
    END OF MODULE DEFINITION FOR MULTIPLE INLUSION
-----------------------------------------------------------------------------*/
#endif // _LIN_SLAVE_BASE_H_
 
/*-----------------------------------------------------------------------------
    END OF FILE
-----------------------------------------------------------------------------*/