F´ Flight Software - C/C++ Documentation  NASA-v2.0.0
A framework for building embedded system applications to NASA flight quality standards.
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 
14 #include "Fw/Logger/Logger.hpp"
15 #include "Fw/Types/Assert.hpp"
16 #include "Fw/Types/BasicTypes.hpp"
17 #include "string.h"
18 
19 // Required port serialization or the hub cannot work
21 
22 namespace Svc {
23 
24 // ----------------------------------------------------------------------
25 // Construction, initialization, and destruction
26 // ----------------------------------------------------------------------
27 
28 GenericHubComponentImpl ::GenericHubComponentImpl(const char* const compName) : GenericHubComponentBase(compName) {}
29 
31  GenericHubComponentBase::init(instance);
32 }
33 
35 
36 void GenericHubComponentImpl ::send_data(const HubType type,
37  const NATIVE_INT_TYPE port,
38  const U8* data,
39  const U32 size) {
40  FW_ASSERT(data != NULL);
41  Fw::SerializeStatus status;
42  // Buffer to send and a buffer used to write to it
43  Fw::Buffer outgoing = dataOutAllocate_out(0, size + sizeof(U32) + sizeof(U32) + sizeof(FwBuffSizeType));
44  Fw::SerializeBufferBase& serialize = outgoing.getSerializeRepr();
45  // Write data to our buffer
46  status = serialize.serialize(static_cast<U32>(type));
47  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
48  status = serialize.serialize(static_cast<U32>(port));
49  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
50  status = serialize.serialize(data, size);
51  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
52  outgoing.setSize(serialize.getBuffLength());
53  dataOut_out(0, outgoing);
54 
55 }
56 
57 // ----------------------------------------------------------------------
58 // Handler implementations for user-defined typed input ports
59 // ----------------------------------------------------------------------
60 
61 void GenericHubComponentImpl ::buffersIn_handler(const NATIVE_INT_TYPE portNum, Fw::Buffer& fwBuffer) {
62  send_data(HUB_TYPE_BUFFER, portNum, fwBuffer.getData(), fwBuffer.getSize());
63  bufferDeallocate_out(0, fwBuffer);
64 }
65 
66 void GenericHubComponentImpl ::dataIn_handler(const NATIVE_INT_TYPE portNum,
67  Fw::Buffer& fwBuffer) {
68  HubType type = HUB_TYPE_MAX;
69  U32 type_in = 0;
70  U32 port = 0;
71  FwBuffSizeType size = 0;
73 
74  // Representation of incoming data prepped for serialization
75  Fw::SerializeBufferBase& incoming = fwBuffer.getSerializeRepr();
76  FW_ASSERT(incoming.setBuffLen(fwBuffer.getSize()) == Fw::FW_SERIALIZE_OK);
77 
78  // Must inform buffer that there is *real* data in the buffer
79  status = incoming.setBuffLen(fwBuffer.getSize());
80  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
81  status = incoming.deserialize(type_in);
82  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
83  type = static_cast<HubType>(type_in);
84  FW_ASSERT(type < HUB_TYPE_MAX, type);
85  status = incoming.deserialize(port);
86  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
87  status = incoming.deserialize(size);
88  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
89 
90  // invokeSerial deserializes arguments before calling a normal invoke, this will return ownership immediately
91  U8* rawData = fwBuffer.getData() + sizeof(U32) + sizeof(U32) + sizeof(FwBuffSizeType);
92  U32 rawSize = fwBuffer.getSize() - sizeof(U32) - sizeof(U32) - sizeof(FwBuffSizeType);
93  FW_ASSERT(rawSize == static_cast<U32>(size));
94  if (type == HUB_TYPE_PORT) {
95  // Com buffer representations should be copied before the call returns, so we need not "allocate" new data
96  Fw::ExternalSerializeBuffer wrapper(rawData, rawSize);
97  status = wrapper.setBuffLen(rawSize);
98  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<NATIVE_INT_TYPE>(status));
99  portOut_out(port, wrapper);
100  dataInDeallocate_out(0, fwBuffer);
101  } else if (type == HUB_TYPE_BUFFER) {
102  fwBuffer.set(rawData, rawSize, fwBuffer.getContext());
103  buffersOut_out(port, fwBuffer);
104  }
105 }
106 
107 // ----------------------------------------------------------------------
108 // Handler implementations for user-defined serial input ports
109 // ----------------------------------------------------------------------
110 
111 void GenericHubComponentImpl ::portIn_handler(NATIVE_INT_TYPE portNum,
112  Fw::SerializeBufferBase& Buffer
113 ) {
114  send_data(HUB_TYPE_PORT, portNum, Buffer.getBuffAddr(), Buffer.getBuffLength());
115 }
116 
117 } // end namespace Svc
Fw::SerializeBufferBase
Definition: Serializable.hpp:43
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Fw::Buffer::getData
U8 * getData() const
Definition: Buffer.cpp:56
Fw::SerializeBufferBase::serialize
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
Definition: Serializable.cpp:67
GenericHubComponentImpl.hpp
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.hpp:76
Fw::Buffer::getContext
U32 getContext() const
Definition: Buffer.cpp:64
Svc::GenericHubComponentImpl::init
void init(const NATIVE_INT_TYPE instance=0)
Definition: GenericHubComponentImpl.cpp:30
Fw::Buffer
Definition: Buffer.hpp:43
Svc::GenericHubComponentImpl::~GenericHubComponentImpl
~GenericHubComponentImpl(void)
Definition: GenericHubComponentImpl.cpp:34
Assert.hpp
Fw::FW_SERIALIZE_OK
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Fw::Buffer::getSerializeRepr
SerializeBufferBase & getSerializeRepr()
Definition: Buffer.cpp:95
Fw::SerializeBufferBase::getBuffAddr
virtual U8 * getBuffAddr(void)=0
gets buffer address for data filling
Svc::GenericHubComponentImpl::HUB_TYPE_BUFFER
@ HUB_TYPE_BUFFER
Buffer type transmission.
Definition: GenericHubComponentImpl.hpp:29
Fw::Buffer::getSize
U32 getSize() const
Definition: Buffer.cpp:60
Fw::Buffer::setSize
void setSize(U32 size)
Definition: Buffer.cpp:75
Fw::Buffer::set
void set(U8 *data, U32 size, U32 context=NO_CONTEXT)
Definition: Buffer.cpp:86
Fw::SerializeBufferBase::setBuffLen
SerializeStatus setBuffLen(NATIVE_UINT_TYPE length)
sets buffer length manually after filling with data
Definition: Serializable.cpp:604
Svc::GenericHubComponentImpl::HubType
HubType
Definition: GenericHubComponentImpl.hpp:27
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:9
Fw::SerializeBufferBase::getBuffLength
NATIVE_UINT_TYPE getBuffLength() const
returns current buffer size
Definition: Serializable.cpp:587
Fw::ExternalSerializeBuffer
Definition: Serializable.hpp:156
Fw::SerializeBufferBase::deserialize
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
Definition: Serializable.cpp:290
Svc::GenericHubComponentImpl::HUB_TYPE_MAX
@ HUB_TYPE_MAX
Definition: GenericHubComponentImpl.hpp:30
FW_PORT_SERIALIZATION
#define FW_PORT_SERIALIZATION
Indicates whether there is code in ports to serialize the call (more code, but ability to serialize c...
Definition: FpConfig.hpp:135
Svc
Definition: ActiveRateGroupImplCfg.hpp:18
FW_STATIC_ASSERT
FW_STATIC_ASSERT(FW_PORT_SERIALIZATION)
Svc::GenericHubComponentImpl::HUB_TYPE_PORT
@ HUB_TYPE_PORT
Port type transmission.
Definition: GenericHubComponentImpl.hpp:28
BasicTypes.hpp
Declares ISF basic types.
Svc::GenericHubComponentImpl::GenericHubComponentImpl
GenericHubComponentImpl(const char *const compName)
Definition: GenericHubComponentImpl.cpp:28
FwBuffSizeType
#define FwBuffSizeType
Type representation for storing a buffer or string size.
Definition: FpConfig.hpp:79
NATIVE_INT_TYPE
int NATIVE_INT_TYPE
native integer type declaration
Definition: BasicTypes.hpp:29
NULL
#define NULL
NULL.
Definition: BasicTypes.hpp:100
Logger.hpp