LIN_master_Base.h

Go to the documentation of this file.

 
/*-----------------------------------------------------------------------------
  MODULE DEFINITION FOR MULTIPLE INCLUSION
-----------------------------------------------------------------------------*/
#ifndef _LIN_MASTER_BASE_H_
#define _LIN_MASTER_BASE_H_
 
 
/*-----------------------------------------------------------------------------
  GLOBAL DEFINES
-----------------------------------------------------------------------------*/
 
// misc parameters
#define LIN_MASTER_BUFLEN_NAME          30            
#define LIN_MASTER_LIN_PORT_TIMEOUT     3000          
 
// required for CI test environment. Call arduino-cli with "-DINCLUDE_NEOHWSERIAL"
#if defined(INCLUDE_NEOHWSERIAL)
  #include <NeoHWSerial.h>
#endif
 
// optional 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_MASTER_DEBUG_SERIAL)
  //#define LIN_MASTER_DEBUG_SERIAL       Serial        //!< serial interface used for debug output
  //#define LIN_MASTER_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_MASTER_DEBUG_SERIAL       SerialUSB     //!< serial interface used for debug output (optional on Due)
#endif
#if !defined(LIN_MASTER_DEBUG_LEVEL)
  #define LIN_MASTER_DEBUG_LEVEL        2             
#endif
#if !defined(LIN_MASTER_DEBUG_PORT_TIMEOUT)
  #define LIN_MASTER_DEBUG_PORT_TIMEOUT 3000          
#endif
#if !defined(LIN_MASTER_DEBUG_BUFSIZE)
  #define LIN_MASTER_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_MASTER_DEBUG_SERIAL)
  
  // debug output macro for normal class methods
  #define DEBUG_PRINT(level, fmt, ...) \
  do { \
    if (LIN_MASTER_DEBUG_LEVEL >= level) { \
      LIN_MASTER_DEBUG_SERIAL.print(this->nameLIN); \
      LIN_MASTER_DEBUG_SERIAL.print(F(": ")); \
      LIN_MASTER_DEBUG_SERIAL.print(__PRETTY_FUNCTION__); \
      LIN_MASTER_DEBUG_SERIAL.print(F(": ")); \
      char debug_buf[LIN_MASTER_DEBUG_BUFSIZE]; \
      snprintf(debug_buf, sizeof(debug_buf), (fmt), ##__VA_ARGS__); \
      LIN_MASTER_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_MASTER_DEBUG_LEVEL >= level) { \
      LIN_MASTER_DEBUG_SERIAL.print(__PRETTY_FUNCTION__); \
      LIN_MASTER_DEBUG_SERIAL.print(F(": ")); \
      char debug_buf[LIN_MASTER_DEBUG_BUFSIZE]; \
      snprintf(debug_buf, sizeof(debug_buf), (fmt), ##__VA_ARGS__); \
      LIN_MASTER_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_MASTER_DEBUG_SERIAL
 
 
/*-----------------------------------------------------------------------------
  INCLUDE FILES
-----------------------------------------------------------------------------*/
 
// generic Arduino functions
#include <Arduino.h>
 
 
/*-----------------------------------------------------------------------------
  GLOBAL CLASS
-----------------------------------------------------------------------------*/
 
class LIN_Master_Base
{
  // PUBLIC TYPEDEFS
  public:
 
    typedef enum : uint8_t
    {
      LIN_V1                = 1,                
      LIN_V2                = 2                 
    } version_t;
 
 
    typedef enum : uint8_t
    {
      MASTER_REQUEST        = 0x01,             
      SLAVE_RESPONSE        = 0x02              
    } frame_t;
 
 
    typedef enum : uint8_t
    {
      STATE_OFF             = 0x01,             
      STATE_IDLE            = 0x02,             
      STATE_BREAK           = 0x04,             
      STATE_BODY            = 0x08,             
      STATE_DONE            = 0x10              
    } state_t;
 
 
    typedef enum : uint8_t
    {
      NO_ERROR              = 0x00,             
      ERROR_STATE           = 0x01,             
      ERROR_ECHO            = 0x02,             
      ERROR_TIMEOUT         = 0x04,             
      ERROR_CHK             = 0x08,             
      ERROR_MISC            = 0x80              
    } error_t;
 
 
  // PROTECTED VARIABLES
  protected:
 
    // node properties
    int8_t                  pinTxEN;            
    uint16_t                baudrate;           
    LIN_Master_Base::state_t  state;            
    LIN_Master_Base::error_t  error;            
    uint32_t                timePerByte;        
    uint32_t                timeoutFrame;       
 
    // frame properties
    LIN_Master_Base::version_t  version;        
    LIN_Master_Base::frame_t    type;           
    uint8_t                 id;                 
    uint8_t                 lenTx;              
    uint8_t                 bufTx[12];          
    uint8_t                 lenRx;              
    uint8_t                 bufRx[12];          
    uint32_t                timeStart;          
 
 
  // PUBLIC VARIABLES
  public:
 
    char                    nameLIN[LIN_MASTER_BUFLEN_NAME];  
 
 
  // PROTECTED METHODS
  protected:
  
    uint8_t _calculatePID(void);
 
    uint8_t _calculateChecksum(uint8_t NumData, uint8_t Data[]);
 
    LIN_Master_Base::error_t _checkFrame(void);
 
    
    virtual LIN_Master_Base::state_t _sendBreak(void);
 
    virtual LIN_Master_Base::state_t _sendFrame(void);
 
    virtual LIN_Master_Base::state_t _receiveFrame(void);
    
 
    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_Master_Base(const char NameLIN[] = "Master", const int8_t PinTxEN = INT8_MIN);
 
    virtual ~LIN_Master_Base(void) { }
 
 
    virtual void begin(uint16_t Baudrate = 19200);
    
    virtual void end(void);
    
    
    inline void resetStateMachine(void)
    {
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // reset state
      this->state = LIN_Master_Base::STATE_IDLE;
 
    } // resetStateMachine()
    
    inline LIN_Master_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_Master_Base::NO_ERROR;
 
    } // resetError()
    
    inline LIN_Master_Base::error_t getError(void)
    {
      // print debug message
      DEBUG_PRINT(3, " ");
 
      // return error
      return this->error;
 
    } // getError()
    
 
    inline void getFrame(LIN_Master_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;                     // frame ID
      NumData = this->lenRx - 4;              // number of data bytes (excl. BREAK, SYNC, ID, CHK)
      memcpy(Data, this->bufRx+3, NumData);   // copy data bytes
      interrupts();                           // re-enable ISRs
 
    } // getFrame()
 
    
    LIN_Master_Base::state_t sendMasterRequest(LIN_Master_Base::version_t Version = LIN_Master_Base::LIN_V2, 
      uint8_t Id = 0x00, uint8_t NumData = 0, uint8_t Data[] = NULL);
    
    LIN_Master_Base::error_t sendMasterRequestBlocking(LIN_Master_Base::version_t Version = LIN_Master_Base::LIN_V2, 
      uint8_t Id = 0x00, uint8_t NumData = 0, uint8_t Data[] = NULL);
 
    LIN_Master_Base::state_t receiveSlaveResponse(LIN_Master_Base::version_t Version = LIN_Master_Base::LIN_V2, 
      uint8_t Id = 0x00, uint8_t NumData = 0);
    
    LIN_Master_Base::error_t receiveSlaveResponseBlocking(LIN_Master_Base::version_t Version = LIN_Master_Base::LIN_V2,
      uint8_t Id = 0x00, uint8_t NumData = 0, uint8_t *Data = NULL);
 
    LIN_Master_Base::state_t handler(void);
 
}; // class LIN_Master_Base
 
/*-----------------------------------------------------------------------------
    END OF MODULE DEFINITION FOR MULTIPLE INLUSION
-----------------------------------------------------------------------------*/
#endif // _LIN_MASTER_BASE_H_
 
/*-----------------------------------------------------------------------------
    END OF FILE
-----------------------------------------------------------------------------*/