F´ Flight Software - C/C++ Documentation devel
A framework for building embedded system applications to NASA flight quality standards.
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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) {
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) {
152 Fw::ExternalSerializeBuffer serializer(buffer, sizeof(buffer));
153 serializer.resetSer();
154 status = serializer.serialize(id);
156 status = serializer.serialize(timeTag);
158 status = serializer.serialize(severity);
160 status = serializer.serialize(args);
162 U32 size = serializer.getBuffLength();
163 this->send_data(HubType::HUB_TYPE_EVENT, portNum, buffer, size);
164
165}
166
167void GenericHubComponentImpl ::TlmRecv_handler(const NATIVE_INT_TYPE portNum,
168 FwChanIdType id,
169 Fw::Time& timeTag,
170 Fw::TlmBuffer& val) {
173 Fw::ExternalSerializeBuffer serializer(buffer, sizeof(buffer));
174 serializer.resetSer();
175 status = serializer.serialize(id);
177 status = serializer.serialize(timeTag);
179 status = serializer.serialize(val);
181 U32 size = serializer.getBuffLength();
182 this->send_data(HubType::HUB_TYPE_CHANNEL, portNum, buffer, size);
183}
184
185// ----------------------------------------------------------------------
186// Handler implementations for user-defined serial input ports
187// ----------------------------------------------------------------------
188
189void GenericHubComponentImpl ::portIn_handler(NATIVE_INT_TYPE portNum,
191) {
192 send_data(HUB_TYPE_PORT, portNum, Buffer.getBuffAddr(), Buffer.getBuffLength());
193}
194
195} // end namespace Svc
#define FW_ASSERT(...)
Definition Assert.hpp:14
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:254
U32 FwEventIdType
Definition FpConfig.h:62
#define FW_PORT_SERIALIZATION
Definition FpConfig.h:136
#define FW_TLM_BUFFER_MAX_SIZE
Definition FpConfig.h:264
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
Enum representing event severity.
@ SERIALIZED_SIZE
The size of the serial representation.
void init()
Object initializer.
Definition ObjBase.cpp:27
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
Auto-generated base for GenericHub component.
SerializeStatus
forward declaration for string
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.