LIN_slave_NeoHWSerial_AVR.cpp

Go to the documentation of this file.

 
// include files
#include <LIN_slave_NeoHWSerial_AVR.h>
 
// optional file, see LIN_slave_NeoHWSerial_AVR.h
#if defined(_LIN_SLAVE_NEOHWSERIAL_AVR_H_)
 
// definition of static class variables (see https://stackoverflow.com/a/51091696)
bool LIN_Slave_NeoHWSerial_AVR::flagBreak[];
 
 
/**************************
 * PRIVATE METHODS
**************************/
 
#if defined(HAVE_HWSERIAL0)
  bool LIN_Slave_NeoHWSerial_AVR::_onSerialReceive0(uint8_t byte, uint8_t status)
  {
    // optional debug output (debug level 3)
    #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
      LIN_SLAVE_DEBUG_SERIAL.print("LIN_Slave_NeoHWSerial_AVR::_onSerialReceive0()");
      LIN_SLAVE_DEBUG_SERIAL.print(": Rx = 0x");
      LIN_SLAVE_DEBUG_SERIAL.print(byte, HEX);
      if (status & (0x01<< FE0))
        LIN_SLAVE_DEBUG_SERIAL.println(", BREAK");
      else
        LIN_SLAVE_DEBUG_SERIAL.println();
    #endif
 
    // on BREAK (=0x00 with framing error) set class variable and don't store in queue (return false)
    if ((byte ==0x00) && (status & (0x01<< FE0)))
    {
      (LIN_Slave_NeoHWSerial_AVR::flagBreak)[0] = true;
      return false;
    }
 
    // return true -> byte is stored in Serial0 buffer
    return true;
 
  } // LIN_Slave_NeoHWSerial_AVR::_onSerialReceive0()
#endif
 
 
 
#if defined(HAVE_HWSERIAL1)
  bool LIN_Slave_NeoHWSerial_AVR::_onSerialReceive1(uint8_t byte, uint8_t status)
  { 
    // optional debug output (debug level 3)
    #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
      LIN_SLAVE_DEBUG_SERIAL.print("LIN_Slave_NeoHWSerial_AVR::_onSerialReceive1()");
      LIN_SLAVE_DEBUG_SERIAL.print(": Rx = 0x");
      LIN_SLAVE_DEBUG_SERIAL.print(byte, HEX);
      if (status & (0x01<< FE1))
        LIN_SLAVE_DEBUG_SERIAL.println(", BREAK");
      else
        LIN_SLAVE_DEBUG_SERIAL.println();
    #endif
 
    // on BREAK (=0x00 with framing error) set class variable and don't store in queue (return false)
    if ((byte ==0x00) && (status & (0x01<< FE1)))
    {
      (LIN_Slave_NeoHWSerial_AVR::flagBreak)[1] = true;
      return false;
    }
 
    // return true -> byte is stored in Serial1 buffer
    return true;
 
  } // LIN_Slave_NeoHWSerial_AVR::_onSerialReceive1()
#endif
 
 
 
#if defined(HAVE_HWSERIAL2)
  bool LIN_Slave_NeoHWSerial_AVR::_onSerialReceive2(uint8_t byte, uint8_t status)
  {
    // optional debug output (debug level 3)
    #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
      LIN_SLAVE_DEBUG_SERIAL.print("LIN_Slave_NeoHWSerial_AVR::_onSerialReceive2()");
      LIN_SLAVE_DEBUG_SERIAL.print(": Rx = 0x");
      LIN_SLAVE_DEBUG_SERIAL.print(byte, HEX);
      if (status & (0x01<< FE2))
        LIN_SLAVE_DEBUG_SERIAL.println(", BREAK");
      else
        LIN_SLAVE_DEBUG_SERIAL.println();
    #endif
 
    // on BREAK (=0x00 with framing error) set class variable and don't store in queue (return false)
    if ((byte ==0x00) && (status & (0x01<< FE2)))
    {
      (LIN_Slave_NeoHWSerial_AVR::flagBreak)[2] = true;
      return false;
    }
 
    // return true -> byte is stored in Serial2 buffer
    return true;
 
  } // LIN_Slave_NeoHWSerial_AVR::_onSerialReceive2()
#endif
 
 
 
#if defined(HAVE_HWSERIAL3)
  bool LIN_Slave_NeoHWSerial_AVR::_onSerialReceive3(uint8_t byte, uint8_t status)
  {
    // optional debug output (debug level 3)
    #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 3)
      LIN_SLAVE_DEBUG_SERIAL.print("LIN_Slave_NeoHWSerial_AVR::_onSerialReceive3()");
      LIN_SLAVE_DEBUG_SERIAL.print(": Rx = 0x");
      LIN_SLAVE_DEBUG_SERIAL.print(byte, HEX);
      if (status & (0x01<< FE3))
        LIN_SLAVE_DEBUG_SERIAL.println(", BREAK");
      else
        LIN_SLAVE_DEBUG_SERIAL.println();
    #endif
 
    // on BREAK (=0x00 with framing error) set class variable and don't store in queue (return false)
    if ((byte ==0x00) && (status & (0x01<< FE3)))
    {
      (LIN_Slave_NeoHWSerial_AVR::flagBreak)[3] = true;
      return false;
    }
 
    // return true -> byte is stored in Serial3 buffer
    return true;
 
  } // LIN_Slave_NeoHWSerial_AVR::_onSerialReceive3()
#endif
 
 
 
/**************************
 * PROTECTED METHODS
**************************/
 
bool LIN_Slave_NeoHWSerial_AVR::_getBreakFlag()
{
  // return BREAK detection flag of respective Serialx
  return (LIN_Slave_NeoHWSerial_AVR::flagBreak)[LIN_Slave_NeoHWSerial_AVR::idxSerial];
 
} // LIN_Slave_NeoHWSerial_AVR::_getBreakFlag()
 
 
 
void LIN_Slave_NeoHWSerial_AVR::_resetBreakFlag()
{
  // clear BREAK detection flag of respective Serialx
  (LIN_Slave_NeoHWSerial_AVR::flagBreak)[LIN_Slave_NeoHWSerial_AVR::idxSerial] = false;
 
} // LIN_Slave_NeoHWSerial_AVR::_resetBreakFlag()
 
 
 
/**************************
 * PUBLIC METHODS
**************************/
 
LIN_Slave_NeoHWSerial_AVR::LIN_Slave_NeoHWSerial_AVR(NeoHWSerial &Interface, 
  LIN_Slave_Base::version_t Version, const char NameLIN[], uint32_t TimeoutRx, const int8_t PinTxEN) : 
  LIN_Slave_Base::LIN_Slave_Base(Version, NameLIN, TimeoutRx, PinTxEN)
{  
  // Debug serial initialized in begin() -> no debug output here
 
  // store parameters in class variables
  this->pSerial    = &Interface;          // pointer to used HW serial
 
} // LIN_Slave_NeoHWSerial_AVR::LIN_Slave_NeoHWSerial_AVR()
 
 
 
void LIN_Slave_NeoHWSerial_AVR::begin(uint16_t Baudrate)
{
  // call base class method
  LIN_Slave_Base::begin(Baudrate);  
 
  // open serial interface incl. used pins
  pSerial->end();
  pSerial->begin(this->baudrate);
  while(!(*pSerial)) { }
 
  // Attach corresponding error callback to Serialx receive handler
  #if defined(HAVE_HWSERIAL0)
    if (pSerial == &NeoSerial)
    { 
      LIN_Slave_NeoHWSerial_AVR::idxSerial = 0;
      pSerial->attachInterrupt(LIN_Slave_NeoHWSerial_AVR::_onSerialReceive0);
    }
  #endif
  #if defined(HAVE_HWSERIAL1)
    if (pSerial == &NeoSerial1)
    { 
      LIN_Slave_NeoHWSerial_AVR::idxSerial = 1;
      pSerial->attachInterrupt(LIN_Slave_NeoHWSerial_AVR::_onSerialReceive1);
    }
  #endif
  #if defined(HAVE_HWSERIAL2)
    if (pSerial == &NeoSerial2)
    { 
      LIN_Slave_NeoHWSerial_AVR::idxSerial = 2;
      pSerial->attachInterrupt(LIN_Slave_NeoHWSerial_AVR::_onSerialReceive2);
    }
  #endif
  #if defined(HAVE_HWSERIAL3)
    if (pSerial == &NeoSerial3)
    { 
      LIN_Slave_NeoHWSerial_AVR::idxSerial = 3;
      pSerial->attachInterrupt(LIN_Slave_NeoHWSerial_AVR::_onSerialReceive3);
    }
  #endif
 
  // initialize variables
  this->_resetBreakFlag();
 
  // optional debug output (debug level 2)
  #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 2)
    LIN_SLAVE_DEBUG_SERIAL.print(this->nameLIN);
    LIN_SLAVE_DEBUG_SERIAL.println(": LIN_Slave_NeoHWSerial_AVR::begin()");
  #endif
 
} // LIN_Slave_NeoHWSerial_AVR::begin()
 
 
 
void LIN_Slave_NeoHWSerial_AVR::end()
{
  // call base class method
  LIN_Slave_Base::end();
    
  // close serial interface
  pSerial->end();
 
  // optional debug output (debug level 2)
  #if defined(LIN_SLAVE_DEBUG_SERIAL) && (LIN_SLAVE_DEBUG_LEVEL >= 2)
    LIN_SLAVE_DEBUG_SERIAL.print(this->nameLIN);
    LIN_SLAVE_DEBUG_SERIAL.println(": LIN_Slave_NeoHWSerial_AVR::end()");
  #endif
 
} // LIN_Slave_NeoHWSerial_AVR::end()
 
#endif // ARDUINO_ARCH_AVR
 
/*-----------------------------------------------------------------------------
    END OF FILE
-----------------------------------------------------------------------------*/