Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : /**
       4             :  * Contains class AbstractCANTransceiver.
       5             :  * \file         AbstractCANTransceiver.h
       6             :  * \ingroup        transceiver
       7             :  */
       8             : #pragma once
       9             : 
      10             : #include "can/canframes/CANFrame.h"
      11             : #include "can/framemgmt/AbstractBitFieldFilteredCANFrameListener.h"
      12             : #include "can/framemgmt/AbstractIntervalFilteredCANFrameListener.h"
      13             : #include "can/framemgmt/IFilteredCANFrameSentListener.h"
      14             : #include "can/transceiver/ICANTransceiverStateListener.h"
      15             : #include "can/transceiver/ICanTransceiver.h"
      16             : 
      17             : #include <estd/forward_list.h>
      18             : #include <platform/estdint.h>
      19             : 
      20             : namespace can
      21             : {
      22             : class ICANFrameSentListener;
      23             : class IFilteredCANFrameSentListener;
      24             : class FrameDispatcher;
      25             : class CanTransportLayer;
      26             : 
      27             : /**
      28             :  * Cpp2CAN AbstractCANTransceiver
      29             :  * \class        AbstractCANTransceiver
      30             :  *
      31             :  *
      32             :  * An AbstractCANTransceiver is the common hardware independent base class for
      33             :  * CAN Transceiver classes. This base implementation or the ICanTransceiver interface
      34             :  * shall be used in all applications to avoid HW dependencies.
      35             :  *
      36             :  * This abstract class implements the HW independent methods.
      37             :  *
      38             :  * \section        Reception
      39             :  * An implementation of AbstractCANTransceiver has to fill a CANFrame object
      40             :  * with the data of the received can frame and then call
      41             :  * notifyListeners() with the received CANFrame which distributes it to all
      42             :  * listeners, i.e. to all listeners whose filter match the id of fRxFrame.
      43             :  *
      44             :  */
      45             : class AbstractCANTransceiver : public ICanTransceiver
      46             : {
      47             : public:
      48             :     /**
      49             :      * constructor
      50             :      * \param    busId    busId of MultiChannelCanTransceiver
      51             :      * \post    getState() == CLOSED
      52             :      */
      53             :     explicit AbstractCANTransceiver(uint8_t busId);
      54             : 
      55             :     /**
      56             :      * \return    internal state of transceiver
      57             :      * \see    State
      58             :      */
      59             :     State getState() const override;
      60             : 
      61             :     /**
      62             :      * adds an ICANFrameListener to listener list
      63             :      * \param    canFrameListener    listener to register
      64             :      *
      65             :      * This method contains a critical section and uses Suspend-/ResumeOSInterrupts.
      66             :      *
      67             :      * \attention
      68             :      * The filter of canFrameListener is merged into the transceivers rx-filter.
      69             :      * It must be configured before adding the listener!
      70             :      */
      71             :     void addCANFrameListener(ICANFrameListener& listener) override;
      72             : 
      73             :     /**
      74             :      * Adds a listener to the front of the receiver list.
      75             :      * \see    addCANFrameListener
      76             :      * Using this method makes sure that the added listener is notified first
      77             :      * of a incoming CANFrame.
      78             :      */
      79             :     void addVIPCANFrameListener(ICANFrameListener& listener) override;
      80             : 
      81             :     /**
      82             :      * removes an ICANFrameListener from listener list
      83             :      * \param    canFrameListener    listener to remove
      84             :      *
      85             :      * This method contains a critical section and uses Suspend-/ResumeOSInterrupts.
      86             :      *
      87             :      * \note
      88             :      * The elements of canFrameListeners filter will not be removed from
      89             :      * the transceivers rx-filter.
      90             :      */
      91             :     void removeCANFrameListener(ICANFrameListener& listener) override;
      92             : 
      93             :     /**
      94             :      * adds an addCANFrameSentListener to listener list
      95             :      * \param    listener    listener to register
      96             :      *
      97             :      * This method contains a critical section and uses Suspend-/ResumeOSInterrupts.
      98             :      *
      99             :      * \attention
     100             :      * The filter of listener is merged into the transceivers rx-filter.
     101             :      * It must be configured before adding the listener!
     102             :      */
     103             :     void addCANFrameSentListener(IFilteredCANFrameSentListener& listener) override;
     104             : 
     105             :     /**
     106             :      * removes an ICANFrameListener from listener list
     107             :      * \param    listener    listener to remove
     108             :      *
     109             :      * This method contains a critical section and uses Suspend-/ResumeOSInterrupts.
     110             :      *
     111             :      * \note
     112             :      * The elements of listener filter will not be removed from
     113             :      * the transceivers rx-filter.
     114             :      */
     115             :     void removeCANFrameSentListener(IFilteredCANFrameSentListener& listener) override;
     116             : 
     117             :     /**
     118             :      * \return    busId of transceiver
     119             :      */
     120           1 :     uint8_t getBusId() const override { return _busId; }
     121             : 
     122             :     /**
     123             :      * Get the hardware state of the CAN transceiver.
     124             :      * \return    state    hardware state of the CAN transceiver
     125             :      */
     126           1 :     ICANTransceiverStateListener::CANTransceiverState getCANTransceiverState() const override
     127             :     {
     128           1 :         return _transceiverState;
     129             :     }
     130             : 
     131             :     /**
     132             :      * Sets the transceivers ICANTransceiverStateListener.
     133             :      * \param    pListener    ICANTransceiverStateListener to notify when an error
     134             :      * occurs. 0L if no class needs to be notified.
     135             :      */
     136           1 :     void setStateListener(ICANTransceiverStateListener& listener) override
     137             :     {
     138           1 :         _stateListener = &listener;
     139           1 :     }
     140             : 
     141           1 :     void removeStateListener() override { _stateListener = nullptr; }
     142             : 
     143             : protected:
     144             :     void setState(State newState);
     145             : 
     146             :     bool isInState(State state) const;
     147             : 
     148             :     /**
     149             :      * Notifies all appropriate listeners about the reception of a CANFrame.
     150             :      * \param    frame    CANFrame that will be passed to all listeners
     151             :      */
     152             :     void notifyListeners(CANFrame const& frame);
     153             : 
     154             :     void notifySentListeners(can::CANFrame const& frame);
     155             : 
     156             :     /**
     157             :      * Notifies the attached ICANTransceiverStateListener that a phy error occurred
     158             :      */
     159           3 :     void notifyStateListenerWithPhyError()
     160             :     {
     161           3 :         if (_stateListener != nullptr)
     162             :         {
     163           1 :             _stateListener->phyErrorOccurred(*this);
     164             :         }
     165           3 :     }
     166             : 
     167             :     /**
     168             :      * Notifies the attached ICANTransceiverStateListener with a given
     169             :      * state
     170             :      * \param    state    new can transceiver state.
     171             :      */
     172             :     void notifyStateListenerWithState(ICANTransceiverStateListener::CANTransceiverState state);
     173             : 
     174             : protected:
     175             :     BitFieldFilter _filter;
     176             :     ::estd::forward_list<ICANFrameListener> _listeners;
     177             :     IFilteredCANFrameSentListener* _sentListener;
     178             :     ::estd::forward_list<IFilteredCANFrameSentListener> _sentListeners;
     179             :     /** baudrate of transceiver */
     180             :     uint32_t _baudrate;
     181             :     /** internal State */
     182             :     State _state;
     183             :     uint8_t _busId;
     184             :     ICANTransceiverStateListener* _stateListener;
     185             :     ICANTransceiverStateListener::CANTransceiverState _transceiverState;
     186             : };
     187             : 
     188           2 : inline ICanTransceiver::State AbstractCANTransceiver::getState() const { return _state; }
     189             : 
     190           2 : inline void AbstractCANTransceiver::setState(ICanTransceiver::State const newState)
     191             : {
     192           2 :     _state = newState;
     193             : }
     194             : 
     195           2 : inline bool AbstractCANTransceiver::isInState(ICanTransceiver::State const state) const
     196             : {
     197           2 :     return (_state == state);
     198             : }
     199             : 
     200           6 : inline void AbstractCANTransceiver::notifyStateListenerWithState(
     201             :     ICANTransceiverStateListener::CANTransceiverState const state)
     202             : {
     203           6 :     if (_stateListener != nullptr)
     204             :     {
     205           1 :         _stateListener->canTransceiverStateChanged(*this, state);
     206             :     }
     207           6 : }
     208             : 
     209             : } // namespace can