F´ Flight Software - C/C++ Documentation NASA-v1.6.0
A framework for building embedded system applications to NASA flight quality standards.
Loading...
Searching...
No Matches
GenericHubComponentImpl.cpp
Go to the documentation of this file.
1// ======================================================================
2// \title GenericHubComponentImpl.cpp
3// \author mstarch
4// \brief cpp file for GenericHub component implementation class
5//
6// \copyright
7// Copyright 2009-2015, by the California Institute of Technology.
8// ALL RIGHTS RESERVED. United States Government Sponsorship
9// acknowledged.
10//
11// ======================================================================
12
13#include <FpConfig.hpp>
15#include "Fw/Logger/Logger.hpp"
16#include "Fw/Types/Assert.hpp"
17
18// Required port serialization or the hub cannot work
19static_assert(FW_PORT_SERIALIZATION, "FW_PORT_SERIALIZATION must be enabled to use GenericHub");
20
21namespace Svc {
22
23// ----------------------------------------------------------------------
24// Construction, initialization, and destruction
25// ----------------------------------------------------------------------
26
27GenericHubComponentImpl ::GenericHubComponentImpl(const char* const compName) : GenericHubComponentBase(compName) {}
28
29void GenericHubComponentImpl ::init(const NATIVE_INT_TYPE instance) {
30 GenericHubComponentBase::init(instance);
31}
32
33GenericHubComponentImpl ::~GenericHubComponentImpl() {}
34
35void GenericHubComponentImpl ::send_data(const HubType type,
36 const NATIVE_INT_TYPE port,
37 const U8* data,
38 const U32 size) {
39 FW_ASSERT(data != nullptr);
41 // Buffer to send and a buffer used to write to it
42 Fw::Buffer outgoing = dataOutAllocate_out(0, size + sizeof(U32) + sizeof(U32) + sizeof(FwBuffSizeType));
43 Fw::SerializeBufferBase& serialize = outgoing.getSerializeRepr();
44 // Write data to our buffer
45 status = serialize.serialize(static_cast<U32>(type));
46 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
47 status = serialize.serialize(static_cast<U32>(port));
48 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
49 status = serialize.serialize(data, size);
50 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
51 outgoing.setSize(serialize.getBuffLength());
52 dataOut_out(0, outgoing);
53}
54
55// ----------------------------------------------------------------------
56// Handler implementations for user-defined typed input ports
57// ----------------------------------------------------------------------
58
59void GenericHubComponentImpl ::buffersIn_handler(const NATIVE_INT_TYPE portNum, Fw::Buffer& fwBuffer) {
60 send_data(HUB_TYPE_BUFFER, portNum, fwBuffer.getData(), fwBuffer.getSize());
61 bufferDeallocate_out(0, fwBuffer);
62}
63
64void GenericHubComponentImpl ::dataIn_handler(const NATIVE_INT_TYPE portNum, Fw::Buffer& fwBuffer) {
65 HubType type = HUB_TYPE_MAX;
66 U32 type_in = 0;
67 U32 port = 0;
68 FwBuffSizeType size = 0;
70
71 // Representation of incoming data prepped for serialization
72 Fw::SerializeBufferBase& incoming = fwBuffer.getSerializeRepr();
73 FW_ASSERT(incoming.setBuffLen(fwBuffer.getSize()) == Fw::FW_SERIALIZE_OK);
74
75 // Must inform buffer that there is *real* data in the buffer
76 status = incoming.setBuffLen(fwBuffer.getSize());
77 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
78 status = incoming.deserialize(type_in);
79 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
80 type = static_cast<HubType>(type_in);
81 FW_ASSERT(type < HUB_TYPE_MAX, type);
82 status = incoming.deserialize(port);
83 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
84 status = incoming.deserialize(size);
85 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
86
87 // invokeSerial deserializes arguments before calling a normal invoke, this will return ownership immediately
88 U8* rawData = fwBuffer.getData() + sizeof(U32) + sizeof(U32) + sizeof(FwBuffSizeType);
89 U32 rawSize = fwBuffer.getSize() - sizeof(U32) - sizeof(U32) - sizeof(FwBuffSizeType);
90 FW_ASSERT(rawSize == static_cast<U32>(size));
91 if (type == HUB_TYPE_PORT) {
92 // Com buffer representations should be copied before the call returns, so we need not "allocate" new data
93 Fw::ExternalSerializeBuffer wrapper(rawData, rawSize);
94 status = wrapper.setBuffLen(rawSize);
95 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
96 portOut_out(port, wrapper);
97 // Deallocate the existing buffer
98 dataInDeallocate_out(0, fwBuffer);
99 } else if (type == HUB_TYPE_BUFFER) {
100 // Fw::Buffers can reuse the existing data buffer as the storage type! No deallocation done.
101 fwBuffer.set(rawData, rawSize, fwBuffer.getContext());
102 buffersOut_out(port, fwBuffer);
103 } else if (type == HUB_TYPE_EVENT) {
104 FwEventIdType id;
105 Fw::Time timeTag;
106 Fw::LogSeverity severity;
107 Fw::LogBuffer args;
108
109 // Deserialize tokens for events
110 status = incoming.deserialize(id);
111 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
112 status = incoming.deserialize(timeTag);
113 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
114 status = incoming.deserialize(severity);
115 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
116 status = incoming.deserialize(args);
117 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
118
119 // Send it!
120 this->LogSend_out(port, id, timeTag, severity, args);
121
122 // Deallocate the existing buffer
123 dataInDeallocate_out(0, fwBuffer);
124 } else if (type == HUB_TYPE_CHANNEL) {
125 FwChanIdType id;
126 Fw::Time timeTag;
127 Fw::TlmBuffer val;
128
129 // Deserialize tokens for channels
130 status = incoming.deserialize(id);
131 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
132 status = incoming.deserialize(timeTag);
133 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
134 status = incoming.deserialize(val);
135 FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
136
137 // Send it!
138 this->TlmSend_out(port, id, timeTag, val);
139
140 // Deallocate the existing buffer
141 dataInDeallocate_out(0, fwBuffer);
142 }
143}
144
145void GenericHubComponentImpl ::LogRecv_handler(const NATIVE_INT_TYPE portNum,
146 FwEventIdType id,
147 Fw::Time& timeTag,
148 const Fw::LogSeverity& severity,
149 Fw::LogBuffer& args) {
150 U8 buffer[sizeof(FwEventIdType) + Fw::Time::SERIALIZED_SIZE + Fw::LogSeverity::SERIALIZED_SIZE + FW_LOG_BUFFER_MAX_SIZE];
151 Fw::ExternalSerializeBuffer serializer(buffer, sizeof(buffer));
152 serializer.resetSer();
153 FW_ASSERT(serializer.serialize(id) == Fw::SerializeStatus::FW_SERIALIZE_OK);;
154 FW_ASSERT(serializer.serialize(timeTag) == Fw::SerializeStatus::FW_SERIALIZE_OK);
155 FW_ASSERT(serializer.serialize(severity) == Fw::SerializeStatus::FW_SERIALIZE_OK);
156 FW_ASSERT(serializer.serialize(args) == Fw::SerializeStatus::FW_SERIALIZE_OK);
157 U32 size = serializer.getBuffLength();
158 this->send_data(HubType::HUB_TYPE_EVENT, portNum, buffer, size);
159
160}
161
162void GenericHubComponentImpl ::TlmRecv_handler(const NATIVE_INT_TYPE portNum,
163 FwChanIdType id,
164 Fw::Time& timeTag,
165 Fw::TlmBuffer& val) {
167 Fw::ExternalSerializeBuffer serializer(buffer, sizeof(buffer));
168 serializer.resetSer();
169 FW_ASSERT(serializer.serialize(id) == Fw::SerializeStatus::FW_SERIALIZE_OK);
170 FW_ASSERT(serializer.serialize(timeTag) == Fw::SerializeStatus::FW_SERIALIZE_OK);
171 FW_ASSERT(serializer.serialize(val) == Fw::SerializeStatus::FW_SERIALIZE_OK);
172 U32 size = serializer.getBuffLength();
173 this->send_data(HubType::HUB_TYPE_CHANNEL, portNum, buffer, size);
174}
175
176// ----------------------------------------------------------------------
177// Handler implementations for user-defined serial input ports
178// ----------------------------------------------------------------------
179
180void GenericHubComponentImpl ::portIn_handler(NATIVE_INT_TYPE portNum,
182) {
183 send_data(HUB_TYPE_PORT, portNum, Buffer.getBuffAddr(), Buffer.getBuffLength());
184}
185
186} // end namespace Svc
#define FW_ASSERT(...)
Definition Assert.hpp:7
PlatformIntType NATIVE_INT_TYPE
Definition BasicTypes.h:51
uint8_t U8
8-bit unsigned integer
Definition BasicTypes.h:26
U32 FwChanIdType
Definition FpConfig.h:59
#define FW_LOG_BUFFER_MAX_SIZE
Definition FpConfig.h:246
U32 FwEventIdType
Definition FpConfig.h:62
#define FW_PORT_SERIALIZATION
Definition FpConfig.h:130
#define FW_TLM_BUFFER_MAX_SIZE
Definition FpConfig.h:256
U16 FwBuffSizeType
Definition FpConfig.h:30
C++-compatible configuration header for fprime configuration.
U8 * getData() const
Definition Buffer.cpp:68
void set(U8 *data, U32 size, U32 context=NO_CONTEXT)
Definition Buffer.cpp:98
U32 getSize() const
Definition Buffer.cpp:72
void setSize(U32 size)
Definition Buffer.cpp:87
U32 getContext() const
Definition Buffer.cpp:76
SerializeBufferBase & getSerializeRepr()
Definition Buffer.cpp:107
SerializeStatus setBuffLen(NATIVE_UINT_TYPE length)
sets buffer length manually after filling with data
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
virtual U8 * getBuffAddr()=0
gets buffer address for data filling
NATIVE_UINT_TYPE getBuffLength() const
returns current buffer size
@ SERIALIZED_SIZE
Definition Time.hpp:13
SerializeStatus
forward declaration for string
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.