Line data Source code
1 : // Copyright 2024 Accenture.
2 :
3 : /**
4 : * Contains Cpp2CAN CanFlex2Transceiver
5 : * \file CanFlex2Transceiver.h
6 : * \ingroup transceiver
7 : */
8 : #pragma once
9 :
10 : #include <async/Async.h>
11 : #include <async/util/Call.h>
12 : #include <bsp/can/canTransceiver/CanPhy.h>
13 : #include <bsp/power/IEcuPowerStateController.h>
14 : #include <bsp/timer/SystemTimer.h>
15 : #include <can/FlexCANDevice.h>
16 : #include <can/canframes/CANFrame.h>
17 : #include <can/canframes/ICANFrameSentListener.h>
18 : #include <can/framemgmt/IFilteredCANFrameSentListener.h>
19 : #include <can/transceiver/AbstractCANTransceiver.h>
20 : #include <etl/deque.h>
21 : #include <etl/uncopyable.h>
22 : #include <io/Io.h>
23 : #include <lifecycle/AsyncLifecycleComponent.h>
24 :
25 : #include <platform/estdint.h>
26 :
27 : namespace bios
28 : {
29 : /**
30 : * CAN transceiver.
31 : * \see AbstractCANTransceiver
32 : * \see FlexCANDevice
33 : * \see common::AbstractTimeout
34 : */
35 : class CanFlex2Transceiver
36 : : public ::can::AbstractCANTransceiver
37 : , public ::etl::uncopyable
38 : {
39 : public:
40 : CanFlex2Transceiver(
41 : ::async::ContextType context,
42 : uint8_t busId,
43 : FlexCANDevice::Config const& devConfig,
44 : CanPhy& Phy,
45 : IEcuPowerStateController& powerStateController);
46 :
47 : ::can::ICanTransceiver::ErrorCode init() override;
48 : ::can::ICanTransceiver::ErrorCode open(::can::CANFrame const& frame) override;
49 : ::can::ICanTransceiver::ErrorCode open() override;
50 :
51 : ::can::ICanTransceiver::ErrorCode close() override;
52 :
53 : void shutdown() override;
54 :
55 : ::can::ICanTransceiver::ErrorCode write(can::CANFrame const& frame) override;
56 :
57 : ::can::ICanTransceiver::ErrorCode
58 : write(can::CANFrame const& frame, can::ICANFrameSentListener& listener) override;
59 :
60 : ErrorCode mute() override;
61 :
62 : ErrorCode unmute() override;
63 :
64 : /**
65 : * Checks if the CAN device associated with the transceiver has woken up.
66 : */
67 2 : bool wokenUp() { return fFlexCANDevice.wokenUp(); }
68 :
69 1 : uint32_t getBaudrate() const override { return fFlexCANDevice.getBaudrate(); }
70 :
71 : /**
72 : * \return the Hardware Queue Timeout.
73 : */
74 : uint16_t getHwQueueTimeout() const override;
75 :
76 : /**
77 : * \return ID of first frame seen after open() or resetFirstFrame() or INVALID_FRAME_ID.
78 : */
79 : virtual uint16_t getFirstFrameId() const;
80 :
81 : /**
82 : * Resets information about the first frame, the next frame received will be the first frame
83 : */
84 : virtual void resetFirstFrame();
85 :
86 : /**
87 : * Checks if the CAN transceiver is receiving data.
88 : */
89 6 : virtual bool getRxAlive() const
90 : {
91 6 : if (_state == State::MUTED)
92 : {
93 3 : return ((fRxAlive) || (fFlexCANDevice.getFirstCanId() != 0));
94 : }
95 : else
96 : {
97 3 : return fRxAlive;
98 : }
99 : }
100 :
101 : /**
102 : * \return the count of overrun events that have occurred in the CAN transceiver.
103 : */
104 : uint32_t getOverrunCount() const { return fOverrunCount; }
105 :
106 : /**
107 : * cyclicTask()
108 : *
109 : * Called periodically.
110 : * Checks transceiver error pins and bus state.
111 : * Notifies state change and phy error listeners.
112 : */
113 : void cyclicTask();
114 :
115 : /**
116 : * Processes the receive queue of the CAN device.
117 : */
118 : void receiveTask();
119 :
120 : /**
121 : * Handles sending of further frames if the transmit queue is not yet empty.
122 : */
123 : void canFrameSentCallback();
124 : void canFrameSentAsyncCallback();
125 :
126 : /**
127 : * Calls the Receive ISR
128 : * \return the number of frames received
129 : */
130 1 : static uint8_t receiveInterrupt(uint8_t const transceiverIndex)
131 : {
132 1 : return fpCanTransceivers[transceiverIndex]->fFlexCANDevice.receiveISR(
133 2 : fpCanTransceivers[transceiverIndex]->_filter.getRawBitField());
134 : }
135 :
136 : /**
137 : * Calls the Transmit ISR
138 : */
139 1 : static void transmitInterrupt(uint8_t const transceiverIndex)
140 : {
141 1 : fpCanTransceivers[transceiverIndex]->fFlexCANDevice.transmitISR();
142 1 : }
143 :
144 : /**
145 : * \return a list of all CanFlex2Transceiver
146 : */
147 1 : static CanFlex2Transceiver** getAllCanFlex2Transceivers() { return fpCanTransceivers; }
148 :
149 : private:
150 : /** polling time */
151 : static uint32_t const ERROR_POLLING_TIMEOUT = 10;
152 :
153 : struct TxJobWithCallback
154 : {
155 18 : TxJobWithCallback(::can::ICANFrameSentListener& listener, ::can::CANFrame const& frame)
156 18 : : _listener(listener), _frame(frame)
157 18 : {}
158 :
159 : ::can::ICANFrameSentListener& _listener;
160 : ::can::CANFrame const& _frame;
161 : };
162 :
163 : using TxQueue = ::etl::deque<TxJobWithCallback, 3>;
164 :
165 : static CanFlex2Transceiver* fpCanTransceivers[8];
166 : FlexCANDevice::Config const& fdevConfig;
167 : FlexCANDevice fFlexCANDevice;
168 : bool fIsPhyErrorPresent;
169 :
170 : uint16_t fTxOfflineErrors;
171 : uint32_t fOverrunCount;
172 : uint32_t fFramesSentCount;
173 :
174 : TxQueue fTxQueue;
175 :
176 : bool fFirstFrameNotified;
177 : bool fRxAlive;
178 :
179 : ::async::ContextType const _context;
180 : ::async::Function _cyclicTask;
181 : ::async::TimeoutType _cyclicTaskTimeout;
182 : ::async::Function _canFrameSent;
183 :
184 : ::can::ICanTransceiver::ErrorCode
185 : write(::can::CANFrame const& frame, ::can::ICANFrameSentListener* pListener);
186 :
187 17 : void notifyRegisteredSentListener(::can::CANFrame const& frame) { notifySentListeners(frame); }
188 : };
189 :
190 : } // namespace bios
|
