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            
 
// optional LIN debug output @ 115.2kBaud. 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. Comment out for none
  //#define LIN_SLAVE_DEBUG_SERIAL  NeoSerial   //!< serial interface used for debug output (required for AVR). Comment out for none
  //#include <NeoHWSerial.h>                    // comment in/out together with previous line
#endif
#if !defined(LIN_SLAVE_DEBUG_LEVEL)
  //#define LIN_SLAVE_DEBUG_LEVEL   2           //!< debug verbosity 0..3 (1=errors only, 3=chatty)
#endif
 
/*-----------------------------------------------------------------------------
  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 level 3)
      #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
        LIN_SLAVE_DEBUG_SERIAL.println("LIN_Slave_Base::_enableTransmitter()");
      #endif
 
      // enable tranmitter
      if (this->pinTxEN >= 0)
        digitalWrite(this->pinTxEN, HIGH);
    
    } // _enableTransmitter()
    
    inline void _disableTransmitter(void)
    { 
      // print debug message (debug level 3)
      #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
        LIN_SLAVE_DEBUG_SERIAL.println("LIN_Slave_Base::_disableTransmitter()");
      #endif
 
      // 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 level 3)
      #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
        LIN_SLAVE_DEBUG_SERIAL.println("LIN_Slave_Base::resetStateMachine()");
      #endif
 
      // reset state      
      this->state = LIN_Slave_Base::STATE_WAIT_FOR_BREAK;
      
    } // resetStateMachine()
 
    inline LIN_Slave_Base::state_t getState(void)
    {
      // print debug message (debug level 3)
      #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
        LIN_SLAVE_DEBUG_SERIAL.println("LIN_Slave_Base::getState()");
      #endif
 
      // return state
      return this->state;
 
    } // getState()
 
 
    inline void resetError(void) 
    {
      // print debug message (debug level 3)
      #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
        LIN_SLAVE_DEBUG_SERIAL.println("LIN_Slave_Base::resetError()");
      #endif
 
      // reset error
      this->error = LIN_Slave_Base::NO_ERROR;
 
    } // resetError()
    
    inline LIN_Slave_Base::error_t getError(void)
    {
      // print debug message (debug level 3)
      #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
        LIN_SLAVE_DEBUG_SERIAL.println("LIN_Slave_Base::getError()");
      #endif
 
      // 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 level 3)
      #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
        LIN_SLAVE_DEBUG_SERIAL.println("LIN_Slave_Base::getFrame()");
      #endif
 
      noInterrupts();                         // for data consistency temporarily disable ISRs
      Type    = this->type;                   // frame type 
      Id      = this->id;                     // 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
-----------------------------------------------------------------------------*/