repo_name
stringclasses 10
values | file_path
stringlengths 29
222
| content
stringlengths 24
926k
| extention
stringclasses 5
values |
|---|---|---|---|
fprime | data/projects/fprime/RPI/Main.cpp | #include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <getopt.h>
#include <signal.h>
#include <RPI/Top/RPITopologyAc.hpp>
RPI::TopologyState state;
// Enable the console logging provided by Os::Log
Os::Log logger;
void print_usage(const char* app) {
(void) printf("Usage: ./%s [options]\n-p\tport_number\n-a\thostname/IP address\n",app);
}
// Handle a signal, e.g. control-C
static void sighandler(int signum) {
// Call the teardown function
// This causes the Linux timer to quit
RPI::teardown(state);
}
int main(int argc, char* argv[]) {
I32 option = 0;
while ((option = getopt(argc, argv, "hp:a:")) != -1){
switch(option) {
case 'h':
print_usage(argv[0]);
return 0;
break;
case 'p':
state.portNumber = static_cast<U32>(atoi(optarg));
break;
case 'a':
state.hostName = optarg;
break;
case '?':
return 1;
default:
print_usage(argv[0]);
return 1;
}
}
(void) printf("Hit Ctrl-C to quit\n");
RPI::setup(state);
// register signal handlers to exit program
signal(SIGINT,sighandler);
signal(SIGTERM,sighandler);
// Start the Linux timer.
// The timer runs on the main thread until it quits
// in the teardown function, called from the signal
// handler.
RPI::linuxTimer.startTimer(100); //!< 10Hz
// Signal handler was called, and linuxTimer quit.
// Time to exit the program.
// Give time for threads to exit.
(void) printf("Waiting for threads...\n");
Os::Task::delay(1000);
(void) printf("Exiting...\n");
return 0;
}
| cpp |
fprime | data/projects/fprime/RPI/Top/RPITopologyDefs.hpp | #ifndef RPITopologyDefs_HPP
#define RPITopologyDefs_HPP
#include "Fw/Types/MallocAllocator.hpp"
#include "Os/Log.hpp"
#include "RPI/Top/FppConstantsAc.hpp"
#include "Svc/FramingProtocol/FprimeProtocol.hpp"
#include "Svc/LinuxTimer/LinuxTimer.hpp"
namespace RPI {
namespace Allocation {
// Malloc allocator for topology construction
extern Fw::MallocAllocator mallocator;
}
namespace Init {
// Initialization status
extern bool status;
}
// State for topology construction
struct TopologyState {
TopologyState() :
hostName(nullptr),
portNumber(0)
{
}
TopologyState(
const char *hostName,
U32 portNumber
) :
hostName(hostName),
portNumber(portNumber)
{
}
const char* hostName;
U32 portNumber;
};
// Health ping entries
namespace PingEntries {
namespace rateGroup10HzComp { enum { WARN = 3, FATAL = 5 }; }
namespace rateGroup1HzComp { enum { WARN = 3, FATAL = 5 }; }
namespace cmdDisp { enum { WARN = 3, FATAL = 5 }; }
namespace cmdSeq { enum { WARN = 3, FATAL = 5 }; }
namespace chanTlm { enum { WARN = 3, FATAL = 5 }; }
namespace eventLogger { enum { WARN = 3, FATAL = 5 }; }
namespace prmDb { enum { WARN = 3, FATAL = 5 }; }
namespace fileDownlink { enum { WARN = 3, FATAL = 5 }; }
namespace fileUplink { enum { WARN = 3, FATAL = 5 }; }
}
}
#endif
| hpp |
fprime | data/projects/fprime/RPI/Top/Topology.cpp | #include <Components.hpp>
#include <Fw/Types/Assert.hpp>
#include <Os/Task.hpp>
#include <Os/Log.hpp>
#include <Os/File.hpp>
#include <Os/TaskString.hpp>
#include <Fw/Types/MallocAllocator.hpp>
#include <RPI/Top/RpiSchedContexts.hpp>
#include <Svc/FramingProtocol/FprimeProtocol.hpp>
enum {
UPLINK_BUFFER_STORE_SIZE = 3000,
UPLINK_BUFFER_QUEUE_SIZE = 30,
UPLINK_BUFFER_MGR_ID = 200
};
Svc::FprimeDeframing deframing;
Svc::FprimeFraming framing;
// Component instances
// Rate Group Dividers for 10Hz and 1Hz
static NATIVE_INT_TYPE rgDivs[] = {1,10,0};
Svc::RateGroupDriverImpl rateGroupDriverComp("RGDRV",rgDivs,FW_NUM_ARRAY_ELEMENTS(rgDivs));
// Context array variables are passed to rate group members if needed to distinguish one call from another
// These context must match the rate group members connected in RPITopologyAi.xml
static NATIVE_UINT_TYPE rg10HzContext[] = {Rpi::CONTEXT_RPI_DEMO_10Hz,0,0,0,0,0,0,0,0,0};
Svc::ActiveRateGroupImpl rateGroup10HzComp("RG10Hz",rg10HzContext,FW_NUM_ARRAY_ELEMENTS(rg10HzContext));
static NATIVE_UINT_TYPE rg1HzContext[] = {0,0,Rpi::CONTEXT_RPI_DEMO_1Hz,0,0,0,0,0,0,0};
Svc::ActiveRateGroupImpl rateGroup1HzComp("RG1Hz",rg1HzContext,FW_NUM_ARRAY_ELEMENTS(rg1HzContext));
// Command Components
Drv::TcpClientComponentImpl comm(FW_OPTIONAL_NAME("Tcp"));
#if FW_ENABLE_TEXT_LOGGING
Svc::ConsoleTextLoggerImpl textLogger("TLOG");
#endif
Svc::ActiveLoggerImpl eventLogger("ELOG");
Svc::PosixTime posixTime("LTIME");
Svc::LinuxTimerComponentImpl linuxTimer("LTIMER");
Svc::TlmChanImpl chanTlm("TLM");
Svc::CommandDispatcherImpl cmdDisp("CMDDISP");
// This needs to be statically allocated
Fw::MallocAllocator mallocator;
Svc::CmdSequencerComponentImpl cmdSeq("CMDSEQ");
Svc::PrmDbImpl prmDb("PRM","PrmDb.dat");
Svc::FileUplink fileUplink("fileUplink");
Svc::FileDownlink fileDownlink ("fileDownlink");
Svc::BufferManagerComponentImpl fileUplinkBufferManager("fileUplinkBufferManager");
Svc::HealthImpl health("health");
Svc::StaticMemoryComponentImpl staticMemory(FW_OPTIONAL_NAME("staticMemory"));
Svc::FramerComponentImpl downlink(FW_OPTIONAL_NAME("downlink"));
Svc::DeframerComponentImpl uplink(FW_OPTIONAL_NAME("uplink"));
Svc::AssertFatalAdapterComponentImpl fatalAdapter("fatalAdapter");
Svc::FatalHandlerComponentImpl fatalHandler("fatalHandler");
Drv::LinuxSerialDriverComponentImpl uartDrv("uartDrv");
Drv::LinuxSpiDriverComponentImpl spiDrv("spiDrv");
Drv::LinuxGpioDriverComponentImpl ledDrv("ledDrv");
Drv::LinuxGpioDriverComponentImpl gpio23Drv("gpio23Drv");
Drv::LinuxGpioDriverComponentImpl gpio24Drv("gpio24Drv");
Drv::LinuxGpioDriverComponentImpl gpio25Drv("gpio25Drv");
Drv::LinuxGpioDriverComponentImpl gpio17Drv("gpio17Drv");
Rpi::RpiDemoComponentImpl rpiDemo("rpiDemo");
void constructApp(U32 port_number, char* hostname) {
staticMemory.init(0);
// Initialize rate group driver
rateGroupDriverComp.init();
// Initialize the rate groups
rateGroup10HzComp.init(10,0);
rateGroup1HzComp.init(10,1);
#if FW_ENABLE_TEXT_LOGGING
textLogger.init();
#endif
eventLogger.init(10,0);
posixTime.init(0);
linuxTimer.init(0);
chanTlm.init(10,0);
cmdDisp.init(20,0);
cmdSeq.init(10,0);
cmdSeq.allocateBuffer(0,mallocator,5*1024);
prmDb.init(10,0);
downlink.init(0);
uplink.init(0);
comm.init(0);
fileUplink.init(30, 0);
fileDownlink.configure(1000, 200, 100, 10);
fileDownlink.init(30, 0);
fileUplinkBufferManager.init(0);
fatalAdapter.init(0);
fatalHandler.init(0);
health.init(25,0);
uartDrv.init(0);
spiDrv.init(0);
ledDrv.init(0);
gpio23Drv.init(0);
gpio24Drv.init(0);
gpio25Drv.init(0);
gpio17Drv.init(0);
rpiDemo.init(10,0);
downlink.setup(framing);
uplink.setup(deframing);
constructRPIArchitecture();
/* Register commands */
cmdSeq.regCommands();
cmdDisp.regCommands();
eventLogger.regCommands();
prmDb.regCommands();
fileDownlink.regCommands();
health.regCommands();
rpiDemo.regCommands();
// set sequencer timeout
cmdSeq.setTimeout(30);
// read parameters
prmDb.readParamFile();
// set health ping entries
// This list has to match the connections in RPITopologyAppAi.xml
Svc::HealthImpl::PingEntry pingEntries[] = {
{3,5,rateGroup10HzComp.getObjName()}, // 0
{3,5,rateGroup1HzComp.getObjName()}, // 1
{3,5,cmdDisp.getObjName()}, // 2
{3,5,cmdSeq.getObjName()}, // 3
{3,5,chanTlm.getObjName()}, // 4
{3,5,eventLogger.getObjName()}, // 5
{3,5,prmDb.getObjName()}, // 6
{3,5,fileDownlink.getObjName()}, // 7
{3,5,fileUplink.getObjName()}, // 8
};
// register ping table
health.setPingEntries(pingEntries,FW_NUM_ARRAY_ELEMENTS(pingEntries),0x123);
// load parameters
rpiDemo.loadParameters();
// set up BufferManager instances
Svc::BufferManagerComponentImpl::BufferBins upBuffMgrBins;
memset(&upBuffMgrBins,0,sizeof(upBuffMgrBins));
upBuffMgrBins.bins[0].bufferSize = UPLINK_BUFFER_STORE_SIZE;
upBuffMgrBins.bins[0].numBuffers = UPLINK_BUFFER_QUEUE_SIZE;
fileUplinkBufferManager.setup(UPLINK_BUFFER_MGR_ID,0,mallocator,upBuffMgrBins);
// Active component startup
// start rate groups
rateGroup10HzComp.start();
rateGroup1HzComp.start();
// start dispatcher
cmdDisp.start();
// start sequencer
cmdSeq.start();
// start telemetry
eventLogger.start();
chanTlm.start();
prmDb.start();
fileDownlink.start();
fileUplink.start();
rpiDemo.start();
// Use the mini-UART for our serial connection
// https://www.raspberrypi.org/documentation/configuration/uart.md
if (not uartDrv.open("/dev/serial0",
Drv::LinuxSerialDriverComponentImpl::BAUD_19200,
Drv::LinuxSerialDriverComponentImpl::NO_FLOW,
Drv::LinuxSerialDriverComponentImpl::PARITY_NONE,
true)) {
return;
}
if (not spiDrv.open(0,0,Drv::SPI_FREQUENCY_1MHZ)) {
return;
}
if (not ledDrv.open(21,Drv::LinuxGpioDriverComponentImpl::GPIO_OUT)) {
return;
}
if (not gpio23Drv.open(23,Drv::LinuxGpioDriverComponentImpl::GPIO_OUT)) {
return;
}
if (not gpio24Drv.open(24,Drv::LinuxGpioDriverComponentImpl::GPIO_OUT)) {
return;
}
if (not gpio25Drv.open(25,Drv::LinuxGpioDriverComponentImpl::GPIO_IN)) {
return;
}
if (not gpio17Drv.open(17,Drv::LinuxGpioDriverComponentImpl::GPIO_IN)) {
return;
}
uartDrv.startReadThread();
// Initialize socket server if and only if there is a valid specification
if (hostname != nullptr && port_number != 0) {
Os::TaskString name("ReceiveTask");
// Uplink is configured for receive so a socket task is started
comm.configure(hostname, port_number);
comm.startSocketTask(name);
}
}
void exitTasks() {
uartDrv.quitReadThread();
linuxTimer.quit();
rateGroup1HzComp.exit();
rateGroup10HzComp.exit();
cmdDisp.exit();
eventLogger.exit();
chanTlm.exit();
prmDb.exit();
fileUplink.exit();
fileDownlink.exit();
cmdSeq.exit();
rpiDemo.exit();
comm.stopSocketTask();
(void) comm.joinSocketTask(nullptr);
cmdSeq.deallocateBuffer(mallocator);
fileUplinkBufferManager.cleanup();
}
| cpp |
fprime | data/projects/fprime/RPI/Top/RPITopologyDefs.cpp | #include "RPI/Top/RPITopologyDefs.hpp"
namespace RPI {
namespace Allocation {
Fw::MallocAllocator mallocator;
}
namespace Init {
bool status = true;
}
}
| cpp |
fprime | data/projects/fprime/RPI/Top/Components.hpp | #ifndef __RPI_COMPONENTS_HEADER__
#define __RPI_COMPONENTS_HEADER__
#include <Svc/ActiveRateGroup/ActiveRateGroupImpl.hpp>
#include <Svc/RateGroupDriver/RateGroupDriverImpl.hpp>
#include <Svc/CmdDispatcher/CommandDispatcherImpl.hpp>
#include <Svc/CmdSequencer/CmdSequencerImpl.hpp>
#include <Svc/PassiveConsoleTextLogger/ConsoleTextLoggerImpl.hpp>
#include <Svc/ActiveLogger/ActiveLoggerImpl.hpp>
#include <Svc/PosixTime/PosixTime.hpp>
#include <Svc/LinuxTimer/LinuxTimerComponentImpl.hpp>
#include <Svc/TlmChan/TlmChanImpl.hpp>
#include <Svc/PrmDb/PrmDbImpl.hpp>
#include <Fw/Obj/SimpleObjRegistry.hpp>
#include <Svc/FileUplink/FileUplink.hpp>
#include <Svc/FileDownlink/FileDownlink.hpp>
#include <Svc/BufferManager/BufferManagerComponentImpl.hpp>
#include <Svc/Health/HealthComponentImpl.hpp>
#include <Svc/StaticMemory/StaticMemoryComponentImpl.hpp>
#include <Svc/Framer/FramerComponentImpl.hpp>
#include <Svc/Deframer/DeframerComponentImpl.hpp>
#include <Drv/TcpClient/TcpClientComponentImpl.hpp>
#include <Svc/AssertFatalAdapter/AssertFatalAdapterComponentImpl.hpp>
#include <Svc/FatalHandler/FatalHandlerComponentImpl.hpp>
// Drivers
#include <Drv/LinuxSerialDriver/LinuxSerialDriverComponentImpl.hpp>
#include <Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.hpp>
#include <Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.hpp>
#include <Drv/TcpClient/TcpClientComponentImpl.hpp>
#include <Drv/Udp/UdpComponentImpl.hpp>
// Main app
#include <RPI/RpiDemo/RpiDemoComponentImpl.hpp>
void constructRPIArchitecture();
void exitTasks();
void constructApp(U32 port_number, char* hostname);
extern Svc::RateGroupDriverImpl rateGroupDriverComp;
extern Svc::ActiveRateGroupImpl rateGroup10HzComp;
extern Svc::ActiveRateGroupImpl rateGroup1HzComp;
extern Svc::CmdSequencerComponentImpl cmdSeq;
extern Svc::ConsoleTextLoggerImpl textLogger;
extern Svc::ActiveLoggerImpl eventLogger;
extern Svc::PosixTime posixTime;
extern Svc::LinuxTimerComponentImpl linuxTimer;
extern Svc::TlmChanImpl chanTlm;
extern Svc::CommandDispatcherImpl cmdDisp;
extern Svc::PrmDbImpl prmDb;
extern Svc::FileUplink fileUplink;
extern Svc::FileDownlink fileDownlink;
extern Svc::BufferManagerComponentImpl fileUplinkBufferManager;
extern Svc::AssertFatalAdapterComponentImpl fatalAdapter;
extern Svc::FatalHandlerComponentImpl fatalHandler;
extern Svc::HealthImpl health;
extern Drv::LinuxSerialDriverComponentImpl uartDrv;
extern Drv::LinuxSpiDriverComponentImpl spiDrv;
extern Drv::LinuxGpioDriverComponentImpl ledDrv;
extern Drv::LinuxGpioDriverComponentImpl gpio23Drv;
extern Drv::LinuxGpioDriverComponentImpl gpio24Drv;
extern Drv::LinuxGpioDriverComponentImpl gpio25Drv;
extern Drv::LinuxGpioDriverComponentImpl gpio17Drv;
extern Rpi::RpiDemoComponentImpl rpiDemo;
extern Svc::StaticMemoryComponentImpl staticMemory;
extern Drv::TcpClientComponentImpl comm;
extern Svc::FramerComponentImpl downlink;
extern Svc::DeframerComponentImpl uplink;
#endif
| hpp |
fprime | data/projects/fprime/RPI/RpiDemo/RpiDemoComponentImplCfg.hpp | /*
* RpiDemoComponentImplCfg.hpp
*
* Created on: Mar 5, 2018
* Author: tim
*/
#ifndef RPI_RPIDEMO_RPIDEMOCOMPONENTIMPLCFG_HPP_
#define RPI_RPIDEMO_RPIDEMOCOMPONENTIMPLCFG_HPP_
namespace RPI {
// configuration values
enum {
NUM_RPI_UART_BUFFERS = 5,
RPI_UART_READ_BUFF_SIZE = 40
};
}
#endif /* RPI_RPIDEMO_RPIDEMOCOMPONENTIMPLCFG_HPP_ */
| hpp |
fprime | data/projects/fprime/RPI/RpiDemo/RpiDemoComponentImpl.hpp | // ======================================================================
// \title RpiDemoImpl.hpp
// \author tcanham
// \brief hpp file for RpiDemo component implementation class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#ifndef RPI_RpiDemoComponentImpl_HPP
#define RPI_RpiDemoComponentImpl_HPP
#include "RPI/RpiDemo/RpiDemoComponentAc.hpp"
#include <RPI/RpiDemo/RpiDemoComponentImplCfg.hpp>
namespace RPI {
class RpiDemoComponentImpl :
public RpiDemoComponentBase
{
public:
// ----------------------------------------------------------------------
// Types
// ----------------------------------------------------------------------
// A list of contexts for the rate groups
enum {
RG_CONTEXT_1Hz = 10, // 1 Hz cycle
RG_CONTEXT_10Hz = 11 // 10 Hz cycle
};
public:
// ----------------------------------------------------------------------
// Construction, initialization, and destruction
// ----------------------------------------------------------------------
//! Construct object RpiDemo
//!
RpiDemoComponentImpl(
const char *const compName /*!< The component name*/
);
//! Initialize object RpiDemo
//!
void init(
const NATIVE_INT_TYPE queueDepth, /*!< The queue depth*/
const NATIVE_INT_TYPE instance = 0 /*!< The instance number*/
);
//! Destroy object RpiDemo
//!
~RpiDemoComponentImpl();
PRIVATE:
// ----------------------------------------------------------------------
// Handler implementations for user-defined typed input ports
// ----------------------------------------------------------------------
//! Handler implementation for Run
//!
void Run_handler(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
U32 context /*!< The call order*/
) override;
//! Handler implementation for UartRead
//!
void UartRead_handler(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
Fw::Buffer &serBuffer, /*!< Buffer containing data*/
const Drv::RecvStatus &status /*!< Status of read*/
) override;
PRIVATE:
// ----------------------------------------------------------------------
// Command handler implementations
// ----------------------------------------------------------------------
//! Implementation for RD_SendString command handler
//! Command to send a string to the UART
void RD_SendString_cmdHandler(
const FwOpcodeType opCode, /*!< The opcode*/
const U32 cmdSeq, /*!< The command sequence number*/
const Fw::CmdStringArg& text /*!< String to send*/
) override;
//! Implementation for RD_SetGpio command handler
//! Sets a GPIO port value
void RD_SetGpio_cmdHandler(
const FwOpcodeType opCode, /*!< The opcode*/
const U32 cmdSeq, /*!< The command sequence number*/
RpiDemo_GpioOutNum output, /*!< Output GPIO*/
Fw::Logic value /*!< GPIO value*/
) override;
//! Implementation for RD_GetGpio command handler
//! Gets a GPIO port value
void RD_GetGpio_cmdHandler(
const FwOpcodeType opCode, /*!< The opcode*/
const U32 cmdSeq, /*!< The command sequence number*/
RpiDemo_GpioInNum input /*!< Input GPIO*/
) override;
//! Implementation for RD_SendSpi command handler
//! Sends SPI data, prints read data
void RD_SendSpi_cmdHandler(
const FwOpcodeType opCode, /*!< The opcode*/
const U32 cmdSeq, /*!< The command sequence number*/
const Fw::CmdStringArg& data /*!< data to send*/
) override;
//! Implementation for RD_SetLed command handler
//! Sets LED state
void RD_SetLed_cmdHandler(
const FwOpcodeType opCode, /*!< The opcode*/
const U32 cmdSeq, /*!< The command sequence number*/
RpiDemo_LedState value /*!< GPIO value*/
) override;
//! Implementation for RD_SetLedDivider command handler
//! Sets the divided rate of the LED
void RD_SetLedDivider_cmdHandler(
const FwOpcodeType opCode, /*!< The opcode*/
const U32 cmdSeq, /*!< The command sequence number*/
U32 divider /*!< Divide 10Hz by this number*/
) override;
// This will be called once when task starts up
void preamble() override;
// telemetry values
U32 m_uartWriteBytes;
U32 m_uartReadBytes;
U32 m_spiBytes;
Fw::TlmString m_lastUartMsg;
Fw::Logic m_currLedVal;
// serial buffers
Fw::Buffer m_recvBuffers[NUM_RPI_UART_BUFFERS];
BYTE m_uartBuffers[NUM_RPI_UART_BUFFERS][RPI_UART_READ_BUFF_SIZE];
// LED enabled
bool m_ledOn;
// toggle LED divider
U32 m_ledDivider;
// 10Hz ticks
U32 m_1HzTicks;
// 10Hz ticks
U32 m_10HzTicks;
};
} // end namespace RPI
#endif
| hpp |
fprime | data/projects/fprime/RPI/RpiDemo/RpiDemo.hpp | // ======================================================================
// RpiDemo.hpp
// Standardization header for RpiDemo
// ======================================================================
#ifndef RPI_RpiDemo_HPP
#define RPI_RpiDemo_HPP
#include "RPI/RpiDemo/RpiDemoComponentImpl.hpp"
namespace RPI {
using RpiDemo = RpiDemoComponentImpl;
}
#endif
| hpp |
fprime | data/projects/fprime/RPI/RpiDemo/RpiDemoComponentImpl.cpp | // ======================================================================
// \title RpiDemoImpl.cpp
// \author tcanham
// \brief cpp file for RpiDemo component implementation class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <RPI/RpiDemo/RpiDemoComponentImpl.hpp>
#include <FpConfig.hpp>
#include <ctype.h>
namespace RPI {
// ----------------------------------------------------------------------
// Construction, initialization, and destruction
// ----------------------------------------------------------------------
RpiDemoComponentImpl ::
RpiDemoComponentImpl(
const char *const compName
) :
RpiDemoComponentBase(compName)
,m_uartWriteBytes(0)
,m_uartReadBytes(0)
,m_spiBytes(0)
,m_currLedVal(Fw::Logic::LOW)
,m_ledOn(true)
,m_ledDivider(10) // start at 1Hz
,m_1HzTicks(0)
,m_10HzTicks(0)
{
}
void RpiDemoComponentImpl ::
init(
const NATIVE_INT_TYPE queueDepth,
const NATIVE_INT_TYPE instance
)
{
RpiDemoComponentBase::init(queueDepth, instance);
}
RpiDemoComponentImpl ::
~RpiDemoComponentImpl()
{
}
void RpiDemoComponentImpl::preamble() {
// check initial state parameter
Fw::ParamValid valid;
RpiDemo_LedState initState = paramGet_RD_PrmLedInitState(valid);
// check status
switch (valid.e) {
// if default or valid, use stored value
case Fw::ParamValid::DEFAULT:
case Fw::ParamValid::VALID:
this->m_ledOn = (RpiDemo_LedState::BLINKING == initState.e);
this->log_ACTIVITY_HI_RD_LedBlinkState(
this->m_ledOn ?
RpiDemo_LedState::BLINKING : RpiDemo_LedState::OFF
);
break;
default:
// use constructor default
break;
}
}
// ----------------------------------------------------------------------
// Handler implementations for user-defined typed input ports
// ----------------------------------------------------------------------
void RpiDemoComponentImpl ::
Run_handler(
const NATIVE_INT_TYPE portNum,
U32 context
)
{
// check which rate group call it is
switch (context) {
case RG_CONTEXT_1Hz:
// write telemetry channels
this->tlmWrite_RD_LastMsg(this->m_lastUartMsg);
this->tlmWrite_RD_UartRecvBytes(this->m_uartReadBytes);
this->tlmWrite_RD_UartSentBytes(this->m_uartWriteBytes);
this->tlmWrite_RD_SpiBytes(this->m_spiBytes);
this->tlmWrite_RD_1HzTicks(this->m_1HzTicks);
this->tlmWrite_RD_10HzTicks(this->m_10HzTicks);
this->m_1HzTicks++;
break;
case RG_CONTEXT_10Hz:
// Toggle LED value
if ( (this->m_10HzTicks++%this->m_ledDivider == 0) and this->m_ledOn) {
this->GpioWrite_out(2, this->m_currLedVal);
this->m_currLedVal = (this->m_currLedVal == Fw::Logic::HIGH) ?
Fw::Logic::LOW : Fw::Logic::HIGH;
}
break;
default:
FW_ASSERT(0, context);
break; // for the code checkers
}
}
void RpiDemoComponentImpl ::
UartRead_handler(
const NATIVE_INT_TYPE portNum,
Fw::Buffer &serBuffer,
const Drv::RecvStatus &status
)
{
if (Drv::RecvStatus::RECV_OK == status.e) {
// convert incoming data to string. If it is not printable, set character to '*'
char uMsg[serBuffer.getSize() + 1];
char *bPtr = reinterpret_cast<char *>(serBuffer.getData());
for (NATIVE_UINT_TYPE byte = 0; byte < serBuffer.getSize(); byte++) {
uMsg[byte] = isalpha(bPtr[byte]) ? bPtr[byte] : '*';
}
uMsg[sizeof(uMsg) - 1] = 0;
Fw::LogStringArg evrMsg(uMsg);
this->log_ACTIVITY_HI_RD_UartMsgIn(evrMsg);
this->m_lastUartMsg = uMsg;
this->m_uartReadBytes += serBuffer.getSize();
}
// return buffer to buffer manager
this->UartBuffers_out(0, serBuffer);
}
// ----------------------------------------------------------------------
// Command handler implementations
// ----------------------------------------------------------------------
void RpiDemoComponentImpl ::
RD_SendString_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
const Fw::CmdStringArg& text
)
{
Fw::Buffer txt;
txt.setSize(text.length());
txt.setData(reinterpret_cast<U8*>(const_cast<char*>(text.toChar())));
Drv::SendStatus status = this->UartWrite_out(0, txt);
if (Drv::SendStatus::SEND_OK == status.e) {
this->m_uartWriteBytes += text.length();
Fw::LogStringArg arg = text;
this->log_ACTIVITY_HI_RD_UartMsgOut(arg);
}
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}
void RpiDemoComponentImpl ::
RD_SetGpio_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
RpiDemo_GpioOutNum output, /*!< Output GPIO*/
Fw::Logic value
)
{
NATIVE_INT_TYPE port;
// convert to connected ports
switch (output.e) {
case RpiDemo_GpioOutNum::PIN_23:
port = 0;
break;
case RpiDemo_GpioOutNum::PIN_24:
port = 1;
break; // good values
default: // bad values
this->log_WARNING_HI_RD_InvalidGpio(output.e);
this->cmdResponse_out(
opCode,
cmdSeq,
Fw::CmdResponse::VALIDATION_ERROR
);
return;
}
// set value of GPIO
this->GpioWrite_out(port, value);
this->log_ACTIVITY_HI_RD_GpioSetVal(output.e, value);
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}
void RpiDemoComponentImpl ::
RD_GetGpio_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
RpiDemo_GpioInNum input /*!< Input GPIO*/
)
{
NATIVE_INT_TYPE port;
// convert to connected ports
switch (input.e) {
case RpiDemo_GpioInNum::PIN_25:
port = 0;
break;
case RpiDemo_GpioInNum::PIN_17:
port = 1;
break; // good values
default: // bad values
this->log_WARNING_HI_RD_InvalidGpio(input.e);
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
return;
}
// get value of GPIO input
Fw::Logic val;
this->GpioRead_out(port, val);
this->log_ACTIVITY_HI_RD_GpioGetVal(input.e, val);
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}
void RpiDemoComponentImpl ::
RD_SendSpi_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
const Fw::CmdStringArg& data
)
{
// copy data from string to output buffer
char inBuf[data.length()+1];
Fw::Buffer in;
in.setData(reinterpret_cast<U8*>(inBuf));
in.setSize(sizeof(inBuf));
Fw::Buffer out;
out.setData(reinterpret_cast<U8*>(const_cast<char*>(data.toChar())));
out.setSize(data.length());
this->SpiReadWrite_out(0, out, in);
for (NATIVE_UINT_TYPE byte = 0; byte < sizeof(inBuf); byte++) {
inBuf[byte] = isalpha(inBuf[byte])?inBuf[byte]:'*';
}
inBuf[sizeof(inBuf)-1] = 0;
// write reply to event
Fw::LogStringArg arg = inBuf;
this->log_ACTIVITY_HI_RD_SpiMsgIn(arg);
this->m_spiBytes += data.length();
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}
void RpiDemoComponentImpl ::
RD_SetLed_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
RpiDemo_LedState value
)
{
this->m_ledOn = (RpiDemo_LedState::BLINKING == value.e);
this->log_ACTIVITY_HI_RD_LedBlinkState(
this->m_ledOn ? RpiDemo_LedState::BLINKING : RpiDemo_LedState::OFF);
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}
void RpiDemoComponentImpl ::
RD_SetLedDivider_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
U32 divider
)
{
if (divider < 1) {
this->log_WARNING_HI_RD_InvalidDivider(divider);
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
return;
}
this->m_ledDivider = divider;
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}
} // end namespace RPI
| cpp |
fprime | data/projects/fprime/Fw/Deprecate.hpp | // deprecate.hpp:
//
// A minor implementation of compile-time deprecation for the fprime framework.
#ifndef FW_DEPRECATE_HPP
#define FW_DEPRECATE_HPP
#ifndef DEPRECATED
#ifdef __GNUC__
#define DEPRECATED(func, message) func __attribute__ ((deprecated(message)))
#else
#warning "No implementation of DEPRECATED for given compiler. Please check for use of DEPRECATED() functions"
#define DEPRECATED(func) func
#endif
#endif
#endif // FW_DEPRECATE_HPP
| hpp |
fprime | data/projects/fprime/Fw/Obj/SimpleObjRegistry.cpp | #include <Fw/Logger/Logger.hpp>
#include <Fw/Obj/SimpleObjRegistry.hpp>
#include <FpConfig.hpp>
#include <Fw/Types/Assert.hpp>
#include <cstdio>
#include <cstring>
#if FW_OBJECT_REGISTRATION == 1
namespace Fw {
SimpleObjRegistry::SimpleObjRegistry() {
ObjBase::setObjRegistry(this);
this->m_numEntries = 0;
// Initialize pointer array
for (NATIVE_INT_TYPE entry = 0; entry < FW_OBJ_SIMPLE_REG_ENTRIES; entry++) {
this->m_objPtrArray[entry] = nullptr;
}
}
SimpleObjRegistry::~SimpleObjRegistry() {
ObjBase::setObjRegistry(nullptr);
}
void SimpleObjRegistry::dump() {
for (NATIVE_INT_TYPE obj = 0; obj < this->m_numEntries; obj++) {
#if FW_OBJECT_NAMES == 1
#if FW_OBJECT_TO_STRING == 1
char objDump[FW_OBJ_SIMPLE_REG_BUFF_SIZE];
this->m_objPtrArray[obj]->toString(objDump,sizeof(objDump));
Fw::Logger::logMsg("Entry: %d Ptr: %p Str: %s\n", obj,
reinterpret_cast<POINTER_CAST>(this->m_objPtrArray[obj]), reinterpret_cast<POINTER_CAST>(objDump));
#else
Fw::Logger::logMsg("Entry: %d Ptr: %p Name: %s\n",obj,
reinterpret_cast<POINTER_CAST>(this->m_objPtrArray[obj]),
reinterpret_cast<POINTER_CAST>(this->m_objPtrArray[obj]->getObjName()));
#endif // FW_OBJECT_TO_STRING
#else
Fw::Logger::logMsg("Entry: %d Ptr: %p Str:\n", obj, reinterpret_cast<POINTER_CAST>(this->m_objPtrArray[obj]));
#endif
}
}
#if FW_OBJECT_NAMES == 1
void SimpleObjRegistry::dump(const char* objName) {
for (NATIVE_INT_TYPE obj = 0; obj < this->m_numEntries; obj++) {
char objDump[FW_OBJ_SIMPLE_REG_BUFF_SIZE];
if (strncmp(objName,this->m_objPtrArray[obj]->getObjName(),sizeof(objDump)) == 0) {
#if FW_OBJECT_TO_STRING == 1
this->m_objPtrArray[obj]->toString(objDump,sizeof(objDump));
Fw::Logger::logMsg("Entry: %d Ptr: %p Str: %s\n", obj,
reinterpret_cast<POINTER_CAST>(this->m_objPtrArray[obj]), reinterpret_cast<POINTER_CAST>(objDump));
#else
Fw::Logger::logMsg("Entry: %d Ptr: %p Name: %s\n",obj,
reinterpret_cast<POINTER_CAST>(this->m_objPtrArray[obj]),
reinterpret_cast<POINTER_CAST>(this->m_objPtrArray[obj]->getObjName()));
#endif
}
}
}
#endif
void SimpleObjRegistry::regObject(ObjBase* obj) {
FW_ASSERT(this->m_numEntries < FW_OBJ_SIMPLE_REG_ENTRIES);
this->m_objPtrArray[this->m_numEntries++] = obj;
}
void SimpleObjRegistry::clear() {
this->m_numEntries = 0;
}
}
#endif
| cpp |
fprime | data/projects/fprime/Fw/Obj/ObjBase.hpp | /**
* \file
* \author T. Canham
* \brief Declarations for Fw::ObjBase and Fw::ObjRegistry
*
* \copyright
* Copyright 2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#ifndef FW_OBJ_BASE_HPP
#define FW_OBJ_BASE_HPP
#include <FpConfig.hpp>
#if FW_OBJECT_NAMES == 1
#include <Fw/Types/ObjectName.hpp>
#endif
namespace Fw {
#if FW_OBJECT_REGISTRATION == 1
class ObjRegistry; //!< forward declaration for object registry
#endif
//! \class ObjBase
//! \brief Brief class description
//!
//! This class is the base class of the ISF object class hierarchy.
//! Depending on which features of the architecture are enabled, this class:
//! 1) Stores an object name
//! 2) Provides for object registration
class ObjBase {
public:
#if FW_OBJECT_NAMES == 1
//! \brief Returns the object's name
//!
//! This function returns a pointer to the name of the object
//!
//! \return object name
const char* getObjName(); //!< Returns object name
//! \brief Sets the object name
//!
//! This function takes the provided string and copies it
//! to the private buffer containing the name of the object.
//!
//! \param name the name of the object
void setObjName(const char* name); //!< sets object name
#if FW_OBJECT_TO_STRING == 1
//! \brief Returns a string representation of the object
//!
//! A virtual function defined for all ObjBase types. It is
//! meant to be overridden by subclasses to return a description
//! of the object. The default implementation in this class
//! returns the name of the object.
//!
//! \param str destination buffer where string description is placed
//! \param size destination buffer size (including terminator). String should be terminated
virtual void toString(char* str, NATIVE_INT_TYPE size); //!< virtual method to get description of object
#endif // FW_OBJECT_TO_STRING
#endif // FW_OBJECT_NAMES
#if FW_OBJECT_REGISTRATION == 1
//! \brief static function to set object registry.
//!
//! This function registers an instance of an object registry class (see below).
//! After the registration call is made, any subsequent calls to ObjBase::init()
//! will call the regObject() method on the registry.
//! **NOTE** The call may not be reentrant or thread-safe. The provided
//! SimObjRegistry is not reentrant.
//!
//! \param reg Instance of registry to be stored.
static void setObjRegistry(ObjRegistry* reg); //!< sets the object registry, if desired
#endif
protected:
#if FW_OBJECT_NAMES == 1
Fw::ObjectName m_objName; //!< stores object name
#endif
//! \brief ObjBase constructor
//!
//! The constructor for the base class. Protected so it will only be called
//! by derived classes. Stores the object name (calls setObjName()).
//!
//! \param name Object name
ObjBase(const char* name);
//! \brief Destructor
//!
//! ObjBase destructor. Empty.
//!
virtual ~ObjBase(); //!< Destructor. Should only be called by derived classes
//! \brief Object initializer
//!
//! Initializes the object. For the base class, it calls
//! the object registry if registered by setObjRegistry()
//!
void init(); //!<initialization function that all objects need to implement. Allows static constructors.
private:
#if FW_OBJECT_REGISTRATION == 1
static ObjRegistry* s_objRegistry; //!< static pointer to object registry. Optionally populated.
#endif
}; // ObjBase
#if FW_OBJECT_REGISTRATION == 1
//! \class ObjRegistry
//! \brief Base class declaration for object registry.
//!
//! More detailed class description (Markdown supported)
//!
class ObjRegistry {
public:
//! \brief virtual function called when an object is registered
//!
//! This pure virtual is called through a static ObjRegistry
//! pointer set by a call to ObjBase::setObjRegistry(). It is passed
//! a pointer to the instance of the object. What is done with that
//! pointer is dependent on the derived class implementation.
//! See SimpleObjRegistry for a basic example of a registry.
//!
//! \param obj pointer to object
virtual void regObject(ObjBase* obj)=0;
//! \brief Object registry destructor
//!
//! Destructor. Base class is empty.
//!
virtual ~ObjRegistry();
}; // ObjRegistry
#endif // FW_OBJECT_REGISTRATION
}
#endif // FW_OBJ_BASE_HPP
| hpp |
fprime | data/projects/fprime/Fw/Obj/ObjBase.cpp | #include <FpConfig.hpp>
#include <Fw/Obj/ObjBase.hpp>
#include <cstring>
#include <cstdio>
#include <Fw/Types/Assert.hpp>
namespace Fw {
#if FW_OBJECT_REGISTRATION == 1
ObjRegistry* ObjBase::s_objRegistry = nullptr;
#endif
#if FW_OBJECT_NAMES == 1
ObjBase::ObjBase(const char* objName) {
if (nullptr == objName) {
this->setObjName("NoName");
} else {
this->setObjName(objName);
}
}
#else
ObjBase::ObjBase(const char* objName) {
}
#endif
void ObjBase::init() {
#if FW_OBJECT_REGISTRATION
if (ObjBase::s_objRegistry) {
ObjBase::s_objRegistry->regObject(this);
}
#endif
}
ObjBase::~ObjBase() {
}
#if FW_OBJECT_NAMES == 1
const char* ObjBase::getObjName() {
return this->m_objName.toChar();
}
void ObjBase::setObjName(const char* name) {
this->m_objName = name;
}
#if FW_OBJECT_TO_STRING == 1
void ObjBase::toString(char* str, NATIVE_INT_TYPE size) {
FW_ASSERT(size > 0);
FW_ASSERT(str != nullptr);
PlatformIntType status = snprintf(str, size, "Obj: %s", this->m_objName.toChar());
if (status < 0) {
str[0] = 0;
}
}
#endif
#endif
#if FW_OBJECT_REGISTRATION == 1
void ObjBase::setObjRegistry(ObjRegistry* reg) {
ObjBase::s_objRegistry = reg;
}
ObjRegistry::~ObjRegistry() {
}
#endif
} // Fw
| cpp |
fprime | data/projects/fprime/Fw/Obj/SimpleObjRegistry.hpp | /**
* \file
* \author T. Canham
* \brief Class declaration for a simple object registry
*
* The simple object registry is meant to give a default implementation
* and an example of an object registry. When the registry is instantiated,
* it registers itself with the object base class static function
* setObjRegistry(). Objects then register with the instance as they are
* instantiated. The object registry can then list the objects in its
* registry.
*
* \copyright
* Copyright 2013-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#ifndef FW_OBJ_SIMPLE_OBJ_REGISTRY_HPP
#define FW_OBJ_SIMPLE_OBJ_REGISTRY_HPP
#include <FpConfig.hpp>
#include <Fw/Obj/ObjBase.hpp>
#if FW_OBJECT_REGISTRATION == 1
namespace Fw {
class SimpleObjRegistry : public ObjRegistry {
public:
SimpleObjRegistry(); //!< constructor for registry
~SimpleObjRegistry(); //!< destructor for registry
void dump(); //!< dump contents of registry
void clear(); //!< clear registry entries
#if FW_OBJECT_NAMES == 1
void dump(const char* objName); //!< dump a particular object
#endif
private:
void regObject(ObjBase* obj); //!< register an object with the registry
ObjBase* m_objPtrArray[FW_OBJ_SIMPLE_REG_ENTRIES]; //!< array of objects
NATIVE_INT_TYPE m_numEntries; //!< number of entries in the registry
};
}
#endif // FW_OBJECT_REGISTRATION
#endif // FW_OBJ_SIMPLE_OBJ_REGISTRY_HPP
| hpp |
fprime | data/projects/fprime/Fw/FilePacket/Header.cpp | // ======================================================================
// \title Header.cpp
// \author bocchino
// \brief cpp file for FilePacket::Header
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
void FilePacket::Header ::
initialize(
const Type type,
const U32 sequenceIndex
)
{
this->m_type = type;
this->m_sequenceIndex = sequenceIndex;
}
U32 FilePacket::Header ::
bufferSize() const
{
return sizeof(U8) + sizeof(this->m_sequenceIndex);
}
SerializeStatus FilePacket::Header ::
fromSerialBuffer(SerialBuffer& serialBuffer)
{
U8 new_type;
SerializeStatus status;
status = serialBuffer.deserialize(new_type);
if (status != FW_SERIALIZE_OK) {
return status;
}
this->m_type = static_cast<Type>(new_type);
status = serialBuffer.deserialize(this->m_sequenceIndex);
return status;
}
SerializeStatus FilePacket::Header ::
toSerialBuffer(SerialBuffer& serialBuffer) const
{
const U8 type_casted = static_cast<U8>(this->m_type);
SerializeStatus status;
status = serialBuffer.serialize(type_casted);
if (status != FW_SERIALIZE_OK)
return status;
status = serialBuffer.serialize(this->m_sequenceIndex);
if (status != FW_SERIALIZE_OK)
return status;
return FW_SERIALIZE_OK;
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/FilePacket.cpp | // ======================================================================
// \title FilePacket.cpp
// \author bocchino
// \brief cpp file for FilePacket
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include "Fw/FilePacket/FilePacket.hpp"
#include "Fw/Types/Assert.hpp"
namespace Fw {
// ----------------------------------------------------------------------
// Public instance methods
// ----------------------------------------------------------------------
SerializeStatus FilePacket ::
fromBuffer(const Buffer& buffer)
{
SerialBuffer serialBuffer(
const_cast<Buffer&>(buffer).getData(),
const_cast<Buffer&>(buffer).getSize()
);
serialBuffer.fill();
const SerializeStatus status = this->fromSerialBuffer(serialBuffer);
return status;
}
const FilePacket::Header& FilePacket ::
asHeader() const
{
return this->m_header;
}
const FilePacket::StartPacket& FilePacket ::
asStartPacket() const
{
FW_ASSERT(this->m_header.m_type == T_START);
return this->m_startPacket;
}
const FilePacket::DataPacket& FilePacket ::
asDataPacket() const
{
FW_ASSERT(this->m_header.m_type == T_DATA);
return this->m_dataPacket;
}
const FilePacket::EndPacket& FilePacket ::
asEndPacket() const
{
FW_ASSERT(this->m_header.m_type == T_END);
return this->m_endPacket;
}
const FilePacket::CancelPacket& FilePacket ::
asCancelPacket() const
{
FW_ASSERT(this->m_header.m_type == T_CANCEL);
return this->m_cancelPacket;
}
void FilePacket ::
fromStartPacket(const StartPacket& startPacket)
{
this->m_startPacket = startPacket;
this->m_header.m_type = T_START;
}
void FilePacket ::
fromDataPacket(const DataPacket& dataPacket)
{
this->m_dataPacket = dataPacket;
this->m_header.m_type = T_DATA;
}
void FilePacket ::
fromEndPacket(const EndPacket& endPacket)
{
this->m_endPacket = endPacket;
this->m_header.m_type = T_END;
}
void FilePacket ::
fromCancelPacket(const CancelPacket& cancelPacket)
{
this->m_cancelPacket = cancelPacket;
this->m_header.m_type = T_CANCEL;
}
U32 FilePacket ::
bufferSize() const
{
switch (this->m_header.m_type) {
case T_START:
return this->m_startPacket.bufferSize();
case T_DATA:
return this->m_dataPacket.bufferSize();
case T_END:
return this->m_endPacket.bufferSize();
case T_CANCEL:
return this->m_cancelPacket.bufferSize();
case T_NONE:
return 0;
default:
FW_ASSERT(0);
return 0;
}
}
SerializeStatus FilePacket ::
toBuffer(Buffer& buffer) const
{
switch (this->m_header.m_type) {
case T_START:
return this->m_startPacket.toBuffer(buffer);
case T_DATA:
return this->m_dataPacket.toBuffer(buffer);
case T_END:
return this->m_endPacket.toBuffer(buffer);
case T_CANCEL:
return this->m_cancelPacket.toBuffer(buffer);
default:
FW_ASSERT(0);
return static_cast<SerializeStatus>(0);
}
}
// ----------------------------------------------------------------------
// Private instance methods
// ----------------------------------------------------------------------
SerializeStatus FilePacket ::
fromSerialBuffer(SerialBuffer& serialBuffer)
{
SerializeStatus status;
status = this->m_header.fromSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
switch (this->m_header.m_type) {
case T_START:
status = this->m_startPacket.fromSerialBuffer(serialBuffer);
break;
case T_DATA:
status = this->m_dataPacket.fromSerialBuffer(serialBuffer);
break;
case T_END:
status = this->m_endPacket.fromSerialBuffer(serialBuffer);
break;
case T_CANCEL:
status = this->m_cancelPacket.fromSerialBuffer(serialBuffer);
break;
case T_NONE:
status = FW_DESERIALIZE_TYPE_MISMATCH;
break;
default:
FW_ASSERT(0,status);
break;
}
return status;
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/PathName.cpp | // ======================================================================
// \title PathName.cpp
// \author bocchino
// \brief cpp file for FilePacket::PathName
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <cstring>
#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/Types/Assert.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
void FilePacket::PathName ::
initialize(const char *const value)
{
const U8 length = static_cast<U8>(StringUtils::string_length(value, MAX_LENGTH));
this->m_length = length;
this->m_value = value;
}
U32 FilePacket::PathName ::
bufferSize() const
{
return sizeof(this->m_length) + this->m_length;
}
SerializeStatus FilePacket::PathName ::
fromSerialBuffer(SerialBuffer& serialBuffer)
{
{
const SerializeStatus status =
serialBuffer.deserialize(this->m_length);
if (status != FW_SERIALIZE_OK)
return status;
}
{
const U8* addrLeft = serialBuffer.getBuffAddrLeft();
U8 bytes[MAX_LENGTH];
const SerializeStatus status =
serialBuffer.popBytes(bytes, this->m_length);
if (status != FW_SERIALIZE_OK)
return status;
this->m_value = reinterpret_cast<const char*>(addrLeft);
}
return FW_SERIALIZE_OK;
}
SerializeStatus FilePacket::PathName ::
toSerialBuffer(SerialBuffer& serialBuffer) const
{
{
const SerializeStatus status =
serialBuffer.serialize(this->m_length);
if (status != FW_SERIALIZE_OK)
return status;
}
{
const SerializeStatus status = serialBuffer.pushBytes(
reinterpret_cast<const U8 *>(this->m_value),
this->m_length
);
if (status != FW_SERIALIZE_OK)
return status;
}
return FW_SERIALIZE_OK;
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/CancelPacket.cpp | // ======================================================================
// \title CancelPacket.cpp
// \author bocchino
// \brief cpp file for FilePacket::CancelPacket
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
void FilePacket::CancelPacket ::
initialize(const U32 sequenceIndex)
{
this->m_header.initialize(FilePacket::T_CANCEL, sequenceIndex);
}
U32 FilePacket::CancelPacket ::
bufferSize() const
{
return this->m_header.bufferSize();
}
SerializeStatus FilePacket::CancelPacket ::
toBuffer(Buffer& buffer) const
{
SerialBuffer serialBuffer(
buffer.getData(),
buffer.getSize()
);
return this->m_header.toSerialBuffer(serialBuffer);
}
SerializeStatus FilePacket::CancelPacket ::
fromSerialBuffer(SerialBuffer& serialBuffer)
{
FW_ASSERT(this->m_header.m_type == T_CANCEL);
if (serialBuffer.getBuffLeft() != 0)
return FW_DESERIALIZE_SIZE_MISMATCH;
return FW_SERIALIZE_OK;
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/DataPacket.cpp | // ======================================================================
// \title DataPacket.cpp
// \author bocchino
// \brief cpp file for FilePacket::DataPacket
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
void FilePacket::DataPacket ::
initialize(
const U32 sequenceIndex,
const U32 byteOffset,
const U16 dataSize,
const U8 *const data
)
{
this->m_header.initialize(FilePacket::T_DATA, sequenceIndex);
this->m_byteOffset = byteOffset;
this->m_dataSize = dataSize;
this->m_data = data;
}
U32 FilePacket::DataPacket ::
bufferSize() const
{
return
this->m_header.bufferSize() +
sizeof(this->m_byteOffset) +
sizeof(this->m_dataSize) +
this->m_dataSize;
}
SerializeStatus FilePacket::DataPacket ::
toBuffer(Buffer& buffer) const
{
SerialBuffer serialBuffer(
buffer.getData(),
buffer.getSize()
);
return this->toSerialBuffer(serialBuffer);
}
SerializeStatus FilePacket::DataPacket ::
fromSerialBuffer(SerialBuffer& serialBuffer)
{
FW_ASSERT(this->m_header.m_type == T_DATA);
SerializeStatus status = serialBuffer.deserialize(this->m_byteOffset);
if (status != FW_SERIALIZE_OK)
return status;
status = serialBuffer.deserialize(this->m_dataSize);
if (status != FW_SERIALIZE_OK)
return status;
if (serialBuffer.getBuffLeft() != this->m_dataSize)
return FW_DESERIALIZE_SIZE_MISMATCH;
U8 *const addr = serialBuffer.getBuffAddr();
this->m_data = &addr[this->fixedLengthSize()];
return FW_SERIALIZE_OK;
}
U32 FilePacket::DataPacket ::
fixedLengthSize() const
{
return
this->m_header.bufferSize() +
sizeof(this->m_byteOffset) +
sizeof(this->m_dataSize);
}
SerializeStatus FilePacket::DataPacket ::
toSerialBuffer(SerialBuffer& serialBuffer) const
{
FW_ASSERT(this->m_header.m_type == T_DATA);
SerializeStatus status;
status = this->m_header.toSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
status = serialBuffer.serialize(this->m_byteOffset);
if (status != FW_SERIALIZE_OK)
return status;
status = serialBuffer.serialize(this->m_dataSize);
if (status != FW_SERIALIZE_OK)
return status;
status = serialBuffer.pushBytes(this->m_data, this->m_dataSize);
return status;
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/StartPacket.cpp | // ======================================================================
// \title StartPacket.cpp
// \author bocchino
// \brief cpp file for FilePacket::StartPacket
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
void FilePacket::StartPacket ::
initialize(
const U32 fileSize,
const char *const sourcePath,
const char *const destinationPath
)
{
this->m_header.initialize(FilePacket::T_START, 0);
this->m_fileSize = fileSize;
this->m_sourcePath.initialize(sourcePath);
this->m_destinationPath.initialize(destinationPath);
}
U32 FilePacket::StartPacket ::
bufferSize() const
{
return this->m_header.bufferSize() +
sizeof(this->m_fileSize) +
this->m_sourcePath.bufferSize() +
this->m_destinationPath.bufferSize();
}
SerializeStatus FilePacket::StartPacket ::
toBuffer(Buffer& buffer) const
{
SerialBuffer serialBuffer(
buffer.getData(),
buffer.getSize()
);
return this->toSerialBuffer(serialBuffer);
}
SerializeStatus FilePacket::StartPacket ::
fromSerialBuffer(SerialBuffer& serialBuffer)
{
FW_ASSERT(this->m_header.m_type == T_START);
{
const SerializeStatus status =
serialBuffer.deserialize(this->m_fileSize);
if (status != FW_SERIALIZE_OK)
return status;
}
{
const SerializeStatus status =
this->m_sourcePath.fromSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
}
{
const SerializeStatus status =
this->m_destinationPath.fromSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
}
return FW_SERIALIZE_OK;
}
SerializeStatus FilePacket::StartPacket ::
toSerialBuffer(SerialBuffer& serialBuffer) const
{
FW_ASSERT(this->m_header.m_type == T_START);
{
const SerializeStatus status =
this->m_header.toSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
}
{
const SerializeStatus status =
serialBuffer.serialize(this->m_fileSize);
if (status != FW_SERIALIZE_OK)
return status;
}
{
const SerializeStatus status =
this->m_sourcePath.toSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
}
{
const SerializeStatus status =
this->m_destinationPath.toSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
}
return FW_SERIALIZE_OK;
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/EndPacket.cpp | // ======================================================================
// \title EndPacket.cpp
// \author bocchino
// \brief cpp file for FilePacket::EndPacket
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <cstring>
#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
void FilePacket::EndPacket ::
initialize(
const U32 sequenceIndex,
const CFDP::Checksum& checksum
)
{
this->m_header.initialize(FilePacket::T_END, sequenceIndex);
this->setChecksum(checksum);
}
U32 FilePacket::EndPacket ::
bufferSize() const
{
return this->m_header.bufferSize() + sizeof(this->m_checksumValue);
}
SerializeStatus FilePacket::EndPacket ::
toBuffer(Buffer& buffer) const
{
SerialBuffer serialBuffer(
buffer.getData(),
buffer.getSize()
);
return this->toSerialBuffer(serialBuffer);
}
void FilePacket::EndPacket ::
setChecksum(const CFDP::Checksum& checksum)
{
this->m_checksumValue = checksum.getValue();
}
void FilePacket::EndPacket ::
getChecksum(CFDP::Checksum& checksum) const
{
CFDP::Checksum c(this->m_checksumValue);
checksum = c;
}
SerializeStatus FilePacket::EndPacket ::
fromSerialBuffer(SerialBuffer& serialBuffer)
{
FW_ASSERT(this->m_header.m_type == T_END);
const SerializeStatus status =
serialBuffer.deserialize(this->m_checksumValue);
return status;
}
SerializeStatus FilePacket::EndPacket ::
toSerialBuffer(SerialBuffer& serialBuffer) const
{
FW_ASSERT(this->m_header.m_type == T_END);
SerializeStatus status;
status = this->m_header.toSerialBuffer(serialBuffer);
if (status != FW_SERIALIZE_OK)
return status;
status = serialBuffer.serialize(this->m_checksumValue);
if (status != FW_SERIALIZE_OK)
return status;
return FW_SERIALIZE_OK;
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/FilePacket.hpp | // ======================================================================
// \title FilePacket.hpp
// \author bocchino
// \brief hpp file for FilePacket
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#ifndef Fw_FilePacket_HPP
#define Fw_FilePacket_HPP
#include <CFDP/Checksum/Checksum.hpp>
#include <Fw/Buffer/Buffer.hpp>
#include <FpConfig.hpp>
#include <Fw/Types/SerialBuffer.hpp>
#include <Fw/Types/Serializable.hpp>
namespace Fw {
//! \class FilePacket
//! \brief A file packet
//!
union FilePacket {
public:
// ----------------------------------------------------------------------
// Types
// ----------------------------------------------------------------------
//! Packet type
typedef enum {
T_START = 0,
T_DATA = 1,
T_END = 2,
T_CANCEL = 3,
T_NONE = 255
} Type;
//! The type of a path name
class PathName {
friend union FilePacket;
public:
//! The maximum length of a path name
enum { MAX_LENGTH = 255 };
PRIVATE:
//! The length
U8 m_length;
//! Pointer to the path value
const char *m_value;
public:
//! Initialize a PathName
void initialize(
const char *const value //! The path value
);
//! Compute the buffer size needed to hold this PathName
U32 bufferSize() const;
//! Get the length of the path name value
U32 getLength(void) const {
return this->m_length;
};
//! Get the path name value
const char* getValue(void) const {
return this->m_value;
};
PRIVATE:
//! Initialize this PathName from a SerialBuffer
SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
//! Write this PathName to a SerialBuffer
SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
};
//! The type of a packet header
class Header {
friend union FilePacket;
PRIVATE:
//! The packet type
Type m_type;
//! The sequence index
U32 m_sequenceIndex;
public:
//! Header size
enum { HEADERSIZE = sizeof(U8) + sizeof(U32) };
PRIVATE:
//! Initialize a file packet header
void initialize(
const Type type, //!< The packet type
const U32 sequenceIndex //!< The sequence index
);
//! Compute the buffer size needed to hold this Header
U32 bufferSize() const;
//! Initialize this Header from a SerialBuffer
SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
//! Write this Header to a SerialBuffer
SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
public:
Type getType(void) const {
return this->m_type;
};
U32 getSequenceIndex(void) const {
return this->m_sequenceIndex;
};
};
//! The type of a start packet
struct StartPacket {
friend union FilePacket;
PRIVATE:
//! The packet header
Header m_header;
//! The file size
U32 m_fileSize;
//! The source path
PathName m_sourcePath;
//! The destination path
PathName m_destinationPath;
public:
//! Initialize a StartPacket with sequence number 0
void initialize(
const U32 fileSize, //!< The file size
const char *const sourcePath, //!< The source path
const char *const destinationPath //!< The destination path
);
//! Compute the buffer size needed to hold this StartPacket
U32 bufferSize() const;
//! Convert this StartPacket to a Buffer
SerializeStatus toBuffer(Buffer& buffer) const;
//! Get the destination path
const PathName& getDestinationPath() const {
return this->m_destinationPath;
};
//! Get the source path
const PathName& getSourcePath() const {
return this->m_sourcePath;
};
//! Get the file size
U32 getFileSize() const {
return this->m_fileSize;
};
PRIVATE:
//! Initialize this StartPacket from a SerialBuffer
SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
//! Write this StartPacket to a SerialBuffer
SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
};
//! The type of a data packet
class DataPacket {
friend union FilePacket;
PRIVATE:
//! The packet header
Header m_header;
//! The byte offset of the packet data into the destination file
U32 m_byteOffset;
//! The size of the file data in the packet
U16 m_dataSize;
//! Pointer to the file data
const U8 *m_data;
public:
//! header size
enum { HEADERSIZE = Header::HEADERSIZE +
sizeof(U32) +
sizeof(U16) };
//! Initialize a data packet
void initialize(
const U32 sequenceIndex, //!< The sequence index
const U32 byteOffset, //!< The byte offset
const U16 dataSize, //!< The data size
const U8 *const data //!< The file data
);
//! Compute the buffer size needed to hold this DataPacket
U32 bufferSize() const;
//! Convert this DataPacket to a Buffer
SerializeStatus toBuffer(Buffer& buffer) const;
//! Get this as a Header
const FilePacket::Header& asHeader() const {
return this->m_header;
};
//! Get the byte offset
U32 getByteOffset() const {
return this->m_byteOffset;
};
//! Get the data size
U32 getDataSize() const {
return this->m_dataSize;
};
//! Get the data
const U8* getData() const {
return this->m_data;
};
PRIVATE:
//! Initialize this DataPacket from a SerialBuffer
SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
//! Compute the fixed-length data size of a StartPacket
U32 fixedLengthSize() const;
//! Write this DataPacket to a SerialBuffer
SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
};
//! The type of an end packet
class EndPacket {
friend union FilePacket;
PRIVATE:
//! The packet header
Header m_header;
public:
//! Set the checksum
void setChecksum(const CFDP::Checksum& checksum);
//! Get the checksum
void getChecksum(CFDP::Checksum& checksum) const;
//! Compute the buffer size needed to hold this EndPacket
U32 bufferSize() const;
//! Convert this EndPacket to a Buffer
SerializeStatus toBuffer(Buffer& buffer) const;
//! Get this as a Header
const FilePacket::Header& asHeader() const {
return this->m_header;
};
public:
//! Initialize an end packet
void initialize(
const U32 sequenceIndex, //!< The sequence index
const CFDP::Checksum& checksum //!< The checksum
);
PRIVATE:
//! The checksum
U32 m_checksumValue;
//! Initialize this EndPacket from a SerialBuffer
SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
//! Write this EndPacket to a SerialBuffer
SerializeStatus toSerialBuffer(SerialBuffer& serialBuffer) const;
};
//! The type of a cancel packet
class CancelPacket {
friend union FilePacket;
PRIVATE:
//! The packet header
Header m_header;
public:
//! Initialize a cancel packet
void initialize(
const U32 sequenceIndex //!< The sequence index
);
//! Compute the buffer size needed to hold this CancelPacket
U32 bufferSize() const;
//! Convert this CancelPacket to a Buffer
SerializeStatus toBuffer(Buffer& buffer) const;
//! Get this as a Header
const FilePacket::Header& asHeader() const {
return this->m_header;
};
PRIVATE:
//! Initialize this CancelPacket from a SerialBuffer
SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
};
public:
// ----------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------
FilePacket() { this->m_header.m_type = T_NONE; }
public:
// ----------------------------------------------------------------------
// Public instance methods
// ----------------------------------------------------------------------
//! Initialize this from a Buffer
//!
SerializeStatus fromBuffer(const Buffer& buffer);
//! Get this as a Header
//!
const Header& asHeader() const;
//! Get this as a StartPacket
//!
const StartPacket& asStartPacket() const;
//! Get this as a DataPacket
//!
const DataPacket& asDataPacket() const;
//! Get this as an EndPacket
//!
const EndPacket& asEndPacket() const;
//! Get this as a CancelPacket
//!
const CancelPacket& asCancelPacket() const;
//! Initialize this with a StartPacket
//!
void fromStartPacket(const StartPacket& startPacket);
//! Initialize this with a DataPacket
//!
void fromDataPacket(const DataPacket& dataPacket);
//! Initialize this with an EndPacket
//!
void fromEndPacket(const EndPacket& endPacket);
//! Initialize this with a CancelPacket
//!
void fromCancelPacket(const CancelPacket& cancelPacket);
//! Get the buffer size needed to hold this FilePacket
//!
U32 bufferSize() const;
//! Convert this FilePacket to a Buffer
//!
SerializeStatus toBuffer(Buffer& buffer) const;
PRIVATE:
// ----------------------------------------------------------------------
// Private methods
// ----------------------------------------------------------------------
//! Initialize this from a SerialBuffer
//!
SerializeStatus fromSerialBuffer(SerialBuffer& serialBuffer);
PRIVATE:
// ----------------------------------------------------------------------
// Private data
// ----------------------------------------------------------------------
//! this, seen as a header
//!
Header m_header;
//! this, seen as a Start packet
//!
StartPacket m_startPacket;
//! this, seen as a Data packet
//!
DataPacket m_dataPacket;
//! this, seen as an End packet
//!
EndPacket m_endPacket;
//! this, seen as a Cancel packet
//!
CancelPacket m_cancelPacket;
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/FilePacket/GTest/Header.cpp | // ======================================================================
// \title Fw/FilePacket/GTest/Header.cpp
// \author bocchino
// \brief Test utilities for file packet headers
//
// \copyright
// Copyright (C) 2016, California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/GTest/FilePackets.hpp>
namespace Fw {
namespace GTest {
void FilePackets::Header ::
compare(
const FilePacket::Header& expected,
const FilePacket::Header& actual
)
{
ASSERT_EQ(expected.m_type, actual.m_type);
ASSERT_EQ(expected.m_sequenceIndex, actual.m_sequenceIndex);
}
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/GTest/FilePackets.hpp | // ======================================================================
// \title Fw/FilePacket/GTest/FilePackets.hpp
// \author bocchino
// \brief hpp file for File Packet testing utilities
//
// \copyright
// Copyright (C) 2016 California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#ifndef Fw_GTest_FilePackets_HPP
#define Fw_GTest_FilePackets_HPP
#include <gtest/gtest.h>
#include <Fw/FilePacket/FilePacket.hpp>
namespace Fw {
namespace GTest {
//! Utilities for testing File Packet operations
//!
namespace FilePackets {
namespace PathName {
//! Compare two path names
void compare(
const FilePacket::PathName& expected,
const FilePacket::PathName& actual
);
}
namespace Header {
//! Compare two file packet headers
void compare(
const FilePacket::Header& expected,
const FilePacket::Header& actual
);
}
namespace StartPacket {
//! Compare two start packets
void compare(
const FilePacket::StartPacket& expected,
const FilePacket::StartPacket& actual
);
}
namespace DataPacket {
//! Compare two data packets
void compare(
const FilePacket::DataPacket& expected,
const FilePacket::DataPacket& actual
);
}
namespace EndPacket {
//! Compare two end packets
void compare(
const FilePacket::EndPacket& expected,
const FilePacket::EndPacket& actual
);
}
namespace CancelPacket {
//! Compare two cancel packets
void compare(
const FilePacket::CancelPacket& expected,
const FilePacket::CancelPacket& actual
);
}
}
}
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/FilePacket/GTest/PathName.cpp | // ======================================================================
// \title Fw/FilePacket/GTest/PathName.cpp
// \author bocchino
// \brief Test utilities for start file packets
//
// \copyright
// Copyright (C) 2016, California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/GTest/FilePackets.hpp>
#include <Fw/Types/GTest/Bytes.hpp>
namespace Fw {
namespace GTest {
void FilePackets::PathName ::
compare(
const FilePacket::PathName& expected,
const FilePacket::PathName& actual
)
{
ASSERT_EQ(expected.m_length, actual.m_length);
Bytes expectedPath(
reinterpret_cast<const U8*>(expected.m_value),
expected.m_length
);
Bytes actualPath(
reinterpret_cast<const U8*>(actual.m_value),
actual.m_length
);
Bytes::compare(expectedPath, actualPath);
}
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/GTest/CancelPacket.cpp | // ======================================================================
// \title Fw/FilePacket/GTest/CancelPacket.cpp
// \author bocchino
// \brief Test utilities for data file packets
//
// \copyright
// Copyright (C) 2016, California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/GTest/FilePackets.hpp>
namespace Fw {
namespace GTest {
void FilePackets::CancelPacket ::
compare(
const FilePacket::CancelPacket& expected,
const FilePacket::CancelPacket& actual
)
{
FilePackets::Header::compare(expected.m_header, actual.m_header);
}
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/GTest/DataPacket.cpp | // ======================================================================
// \title Fw/FilePacket/GTest/DataPacket.cpp
// \author bocchino
// \brief Test utilities for data file packets
//
// \copyright
// Copyright (C) 2016, California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/GTest/FilePackets.hpp>
#include <Fw/Types/GTest/Bytes.hpp>
namespace Fw {
namespace GTest {
void FilePackets::DataPacket ::
compare(
const FilePacket::DataPacket& expected,
const FilePacket::DataPacket& actual
)
{
FilePackets::Header::compare(expected.m_header, actual.m_header);
ASSERT_EQ(expected.m_byteOffset, actual.m_byteOffset);
Bytes expectedData(expected.m_data, expected.m_dataSize);
Bytes actualData(actual.m_data, actual.m_dataSize);
Bytes::compare(expectedData, actualData);
}
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/GTest/StartPacket.cpp | // ======================================================================
// \title Fw/FilePacket/GTest/StartPacket.cpp
// \author bocchino
// \brief Test utilities for start file packets
//
// \copyright
// Copyright (C) 2016, California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/GTest/FilePackets.hpp>
#include <Fw/Types/GTest/Bytes.hpp>
namespace Fw {
namespace GTest {
void FilePackets::StartPacket ::
compare(
const FilePacket::StartPacket& expected,
const FilePacket::StartPacket& actual
)
{
FilePackets::Header::compare(expected.m_header, actual.m_header);
ASSERT_EQ(expected.m_fileSize, actual.m_fileSize);
PathName::compare(expected.m_sourcePath, actual.m_sourcePath);
PathName::compare(expected.m_destinationPath, actual.m_destinationPath);
}
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/GTest/EndPacket.cpp | // ======================================================================
// \title Fw/FilePacket/GTest/EndPacket.cpp
// \author bocchino
// \brief Test utilities for data file packets
//
// \copyright
// Copyright (C) 2016, California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include <Fw/FilePacket/GTest/FilePackets.hpp>
#include <CFDP/Checksum/GTest/Checksums.hpp>
#include <Fw/Types/GTest/Bytes.hpp>
namespace Fw {
namespace GTest {
void FilePackets::EndPacket ::
compare(
const FilePacket::EndPacket& expected,
const FilePacket::EndPacket& actual
)
{
FilePackets::Header::compare(expected.m_header, actual.m_header);
CFDP::Checksum expectedChecksum;
CFDP::Checksum actualChecksum;
expected.getChecksum(expectedChecksum);
actual.getChecksum(actualChecksum);
CFDP::GTest::Checksums::compare(expectedChecksum, actualChecksum);
}
}
}
| cpp |
fprime | data/projects/fprime/Fw/FilePacket/test/ut/FilePacketMain.cpp | // ----------------------------------------------------------------------
// Main.cpp
// ----------------------------------------------------------------------
#include <gtest/gtest.h>
#include <Fw/Buffer/Buffer.hpp>
#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/FilePacket/GTest/FilePackets.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
// Serialize and deserialize a file packet header
TEST(FilePacket, Header) {
const FilePacket::Header expected = {
FilePacket::T_DATA, // Packet type
10 // Sequence number
};
const U32 size = expected.bufferSize();
U8 bytes[size];
SerialBuffer serialBuffer(bytes, size);
{
const SerializeStatus status =
expected.toSerialBuffer(serialBuffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
FilePacket::Header actual;
{
const SerializeStatus status =
actual.fromSerialBuffer(serialBuffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
GTest::FilePackets::Header::compare(
expected,
actual
);
}
// Serialize and deserialize a start packet
TEST(FilePacket, StartPacket) {
FilePacket::StartPacket expected;
expected.initialize(
10, // File size
"source", // Source path
"dest" // Destination path
);
const U32 size = expected.bufferSize();
U8 bytes[size];
Buffer buffer(bytes, size);
SerialBuffer serialBuffer(bytes, size);
{
const SerializeStatus status =
expected.toBuffer(buffer);
ASSERT_EQ(status, FW_SERIALIZE_OK);
}
FilePacket actual;
{
const SerializeStatus status =
actual.fromBuffer(buffer);
ASSERT_EQ(status, FW_SERIALIZE_OK);
}
const FilePacket::StartPacket& actualStartPacket =
actual.asStartPacket();
GTest::FilePackets::StartPacket::compare(
expected,
actualStartPacket
);
}
// Serialize and deserialize a data packet
TEST(FilePacket, DataPacket) {
FilePacket::DataPacket expected;
const U32 dataSize = 10;
U8 data[dataSize] = {}; // Initialize to appease valgrind
expected.initialize(
3, // Sequence index
42, // Byte offset
dataSize, // Data size
data // Data
);
const U32 size = expected.bufferSize();
U8 bytes[size];
Buffer buffer(bytes, size);
SerialBuffer serialBuffer(bytes, size);
{
const SerializeStatus status =
expected.toBuffer(buffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
FilePacket actual;
{
const SerializeStatus status =
actual.fromBuffer(buffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
const FilePacket::DataPacket& actualDataPacket =
actual.asDataPacket();
GTest::FilePackets::DataPacket::compare(
expected,
actualDataPacket
);
}
// Serialize and deserialize an end packet
TEST(FilePacket, EndPacket) {
FilePacket::EndPacket expected;
const CFDP::Checksum checksum(42);
expected.initialize(
15, // Sequence index
checksum // Checksum
);
const U32 size = expected.bufferSize();
U8 bytes[size];
Buffer buffer(bytes, size);
SerialBuffer serialBuffer(bytes, size);
{
const SerializeStatus status =
expected.toBuffer(buffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
FilePacket actual;
{
const SerializeStatus status =
actual.fromBuffer(buffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
const FilePacket::EndPacket& actualEndPacket =
actual.asEndPacket();
GTest::FilePackets::EndPacket::compare(
expected,
actualEndPacket
);
}
// Serialize and deserialize an end packet
TEST(FilePacket, CancelPacket) {
FilePacket::CancelPacket expected;
const CFDP::Checksum checksum(42);
expected.initialize(
10 // Sequence index
);
const U32 size = expected.bufferSize();
U8 bytes[size];
Buffer buffer(bytes, size);
SerialBuffer serialBuffer(bytes, size);
{
const SerializeStatus status =
expected.toBuffer(buffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
FilePacket actual;
{
const SerializeStatus status =
actual.fromBuffer(buffer);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
const FilePacket::CancelPacket& actualCancelPacket =
actual.asCancelPacket();
GTest::FilePackets::CancelPacket::compare(
expected,
actualCancelPacket
);
}
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| cpp |
fprime | data/projects/fprime/Fw/Com/ComPacket.cpp | /*
* ComPacket.cpp
*
* Created on: May 24, 2014
* Author: Timothy Canham
*/
#include <Fw/Com/ComPacket.hpp>
namespace Fw {
ComPacket::ComPacket() : m_type(FW_PACKET_UNKNOWN) {
}
ComPacket::~ComPacket() {
}
SerializeStatus ComPacket::serializeBase(SerializeBufferBase& buffer) const {
return buffer.serialize(static_cast<FwPacketDescriptorType>(this->m_type));
}
SerializeStatus ComPacket::deserializeBase(SerializeBufferBase& buffer) {
FwPacketDescriptorType serVal;
SerializeStatus stat = buffer.deserialize(serVal);
if (FW_SERIALIZE_OK == stat) {
this->m_type = static_cast<ComPacketType>(serVal);
}
return stat;
}
} /* namespace Fw */
| cpp |
fprime | data/projects/fprime/Fw/Com/ComBuffer.cpp | #include <Fw/Com/ComBuffer.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
ComBuffer::ComBuffer(const U8 *args, NATIVE_UINT_TYPE size) {
SerializeStatus stat = SerializeBufferBase::setBuff(args,size);
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
ComBuffer::ComBuffer() {
}
ComBuffer::~ComBuffer() {
}
ComBuffer::ComBuffer(const ComBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
ComBuffer& ComBuffer::operator=(const ComBuffer& other) {
if(this == &other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
return *this;
}
NATIVE_UINT_TYPE ComBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* ComBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* ComBuffer::getBuffAddr() {
return this->m_bufferData;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Com/ComBuffer.hpp | /*
* FwComBuffer.hpp
*
* Created on: May 24, 2014
* Author: tcanham
*/
/*
* Description:
* This object contains the ComBuffer type, used for sending and receiving packets from the ground
*/
#ifndef FW_COM_BUFFER_HPP
#define FW_COM_BUFFER_HPP
#include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp>
namespace Fw {
class ComBuffer : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = 1010,
SERIALIZED_SIZE = FW_COM_BUFFER_MAX_SIZE + sizeof(FwBuffSizeType) // size of buffer + storage of size word
};
ComBuffer(const U8 *args, NATIVE_UINT_TYPE size);
ComBuffer();
ComBuffer(const ComBuffer& other);
virtual ~ComBuffer();
ComBuffer& operator=(const ComBuffer& other);
NATIVE_UINT_TYPE getBuffCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;
private:
U8 m_bufferData[FW_COM_BUFFER_MAX_SIZE]; // packet data buffer
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Com/ComPacket.hpp | /*
* ComPacket.hpp
*
* Created on: May 24, 2014
* Author: Timothy Canham
*/
#ifndef COMPACKET_HPP_
#define COMPACKET_HPP_
#include <Fw/Types/Serializable.hpp>
// Packet format:
// |32-bit packet type|packet type-specific data|
namespace Fw {
class ComPacket: public Serializable {
public:
typedef enum {
FW_PACKET_COMMAND, // !< Command packet type - incoming
FW_PACKET_TELEM, // !< Telemetry packet type - outgoing
FW_PACKET_LOG, // !< Log type - outgoing
FW_PACKET_FILE, // !< File type - incoming and outgoing
FW_PACKET_PACKETIZED_TLM, // !< Packetized telemetry packet type
FW_PACKET_DP, //!< Data product packet
FW_PACKET_IDLE, // !< Idle packet
FW_PACKET_UNKNOWN = 0xFF // !< Unknown packet
} ComPacketType;
ComPacket();
virtual ~ComPacket();
protected:
ComPacketType m_type;
SerializeStatus serializeBase(SerializeBufferBase& buffer) const ; // called by derived classes to serialize common fields
SerializeStatus deserializeBase(SerializeBufferBase& buffer); // called by derived classes to deserialize common fields
};
} /* namespace Fw */
#endif /* COMPACKET_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Prm/ParamBuffer.hpp | // Work around inconsistent spelling
#include "PrmBuffer.hpp"
| hpp |
fprime | data/projects/fprime/Fw/Prm/PrmString.cpp | #include <Fw/Prm/PrmString.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
ParamString::ParamString(const char* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
ParamString::ParamString(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
ParamString::ParamString(const ParamString& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
ParamString::ParamString() : StringBase() {
this->m_buf[0] = 0;
}
ParamString& ParamString::operator=(const ParamString& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
ParamString& ParamString::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
ParamString& ParamString::operator=(const char* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
ParamString::~ParamString() {
}
const char* ParamString::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE ParamString::getCapacity() const {
return FW_PARAM_STRING_MAX_SIZE;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Prm/PrmBuffer.cpp | #include <Fw/Prm/PrmBuffer.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
ParamBuffer::ParamBuffer(const U8 *args, NATIVE_UINT_TYPE size) {
SerializeStatus stat = SerializeBufferBase::setBuff(args,size);
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
ParamBuffer::ParamBuffer() {
}
ParamBuffer::~ParamBuffer() {
}
ParamBuffer::ParamBuffer(const ParamBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
ParamBuffer& ParamBuffer::operator=(const ParamBuffer& other) {
if(this == &other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
return *this;
}
NATIVE_UINT_TYPE ParamBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* ParamBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* ParamBuffer::getBuffAddr() {
return this->m_bufferData;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Prm/PrmString.hpp | #ifndef FW_PRM_STRING_TYPE_HPP
#define FW_PRM_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class ParamString : public Fw::StringBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_PRM_STR,
SERIALIZED_SIZE = FW_PARAM_STRING_MAX_SIZE + sizeof(FwBuffSizeType) // size of buffer + storage of two size words
};
ParamString(const char* src);
ParamString(const StringBase& src);
ParamString(const ParamString& src);
ParamString();
ParamString& operator=(const ParamString& other);
ParamString& operator=(const StringBase& other);
ParamString& operator=(const char* other);
~ParamString();
const char* toChar() const;
NATIVE_UINT_TYPE getCapacity() const;
private:
char m_buf[FW_PARAM_STRING_MAX_SIZE];
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Prm/PrmBuffer.hpp | /*
* Cmd.hpp
*
* Created on: Sep 10, 2012
* Author: ppandian
*/
/*
* Description:
* This object contains the ParamBuffer type, used for storing parameters
*/
#ifndef FW_PRM_BUFFER_HPP
#define FW_PRM_BUFFER_HPP
#include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class ParamBuffer : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_PRM_BUFF,
SERIALIZED_SIZE = FW_PARAM_BUFFER_MAX_SIZE + sizeof(FwBuffSizeType)
};
ParamBuffer(const U8 *args, NATIVE_UINT_TYPE size);
ParamBuffer();
ParamBuffer(const ParamBuffer& other);
virtual ~ParamBuffer();
ParamBuffer& operator=(const ParamBuffer& other);
NATIVE_UINT_TYPE getBuffCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;
private:
U8 m_bufferData[FW_PARAM_BUFFER_MAX_SIZE]; // command argument buffer
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/SerializableFile/SerializableFile.hpp | // ======================================================================
// \title SerializableFile.hpp
// \author dinkel
// \brief hpp file for SerializableFile
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#ifndef Fw_SerializableFile_HPP
#define Fw_SerializableFile_HPP
#include <Fw/Types/Serializable.hpp>
#include <Fw/Types/MemAllocator.hpp>
#include <Fw/Types/SerialBuffer.hpp>
namespace Fw {
//! The type of a packet header
class SerializableFile {
public:
enum Status {
OP_OK,
FILE_OPEN_ERROR,
FILE_WRITE_ERROR,
FILE_READ_ERROR,
DESERIALIZATION_ERROR
};
// NOTE!: This should not be used with an allocator that can return a smaller buffer than requested
SerializableFile(MemAllocator* allocator, NATIVE_UINT_TYPE maxSerializedSize);
~SerializableFile();
Status load(const char* fileName, Serializable& serializable);
Status save(const char* fileName, Serializable& serializable);
PRIVATE:
void reset();
MemAllocator* m_allocator;
bool m_recoverable; // don't care; for allocator
NATIVE_UINT_TYPE m_actualSize; // for checking
SerialBuffer m_buffer;
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/SerializableFile/SerializableFile.cpp | // ======================================================================
// \title SerializableFile.cpp
// \author dinkel
// \brief cpp file for SerializableFile
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include "Fw/SerializableFile/SerializableFile.hpp"
#include "Fw/Types/Assert.hpp"
#include "Os/File.hpp"
namespace Fw {
SerializableFile::SerializableFile(MemAllocator* allocator, NATIVE_UINT_TYPE maxSerializedSize) :
m_allocator(allocator),
m_recoverable(false), // for compiler; not used
m_actualSize(maxSerializedSize),
m_buffer(static_cast<U8*>(this->m_allocator->allocate(0, m_actualSize, m_recoverable)), m_actualSize)
{
// assert if allocator returns smaller size
FW_ASSERT(maxSerializedSize == m_actualSize,maxSerializedSize,m_actualSize);
FW_ASSERT(nullptr != m_buffer.getBuffAddr());
}
SerializableFile::~SerializableFile() {
this->m_allocator->deallocate(0, this->m_buffer.getBuffAddr());
}
SerializableFile::Status SerializableFile::load(const char* fileName, Serializable& serializable) {
Os::File file;
Os::File::Status status;
status = file.open(fileName, Os::File::OPEN_READ);
if( Os::File::OP_OK != status ) {
return FILE_OPEN_ERROR;
}
FwSignedSizeType capacity = static_cast<FwSignedSizeType>(this->m_buffer.getBuffCapacity());
FwSignedSizeType length = static_cast<FwSignedSizeType>(capacity);
status = file.read(this->m_buffer.getBuffAddr(), length, Os::File::WaitType::NO_WAIT);
if( Os::File::OP_OK != status ) {
file.close();
return FILE_READ_ERROR;
}
file.close();
this->reset();
SerializeStatus serStatus;
serStatus = this->m_buffer.setBuffLen(static_cast<NATIVE_UINT_TYPE>(length));
FW_ASSERT(FW_SERIALIZE_OK == serStatus, serStatus);
serStatus = serializable.deserialize(this->m_buffer);
if(FW_SERIALIZE_OK != serStatus) {
return DESERIALIZATION_ERROR;
}
return SerializableFile::OP_OK;
}
SerializableFile::Status SerializableFile::save(const char* fileName, Serializable& serializable) {
this->reset();
SerializeStatus serStatus = serializable.serialize(this->m_buffer);
FW_ASSERT(FW_SERIALIZE_OK == serStatus, serStatus);
Os::File file;
Os::File::Status status;
status = file.open(fileName, Os::File::OPEN_WRITE);
if( Os::File::OP_OK != status ) {
return FILE_OPEN_ERROR;
}
FwSignedSizeType length = static_cast<FwSignedSizeType>(this->m_buffer.getBuffLength());
FwSignedSizeType size = length;
status = file.write(this->m_buffer.getBuffAddr(), length);
if( (Os::File::OP_OK != status) || (length != size)) {
file.close();
return FILE_WRITE_ERROR;
}
file.close();
return SerializableFile::OP_OK;
}
void SerializableFile::reset() {
this->m_buffer.resetSer(); //!< reset to beginning of buffer to reuse for serialization
this->m_buffer.resetDeser(); //!< reset deserialization to beginning
}
}
| cpp |
fprime | data/projects/fprime/Fw/SerializableFile/test/ut/Test.cpp | // ----------------------------------------------------------------------
// Main.cpp
// ----------------------------------------------------------------------
#include <cstring>
#include <cstdio>
#include <FpConfig.hpp>
#include <Fw/Types/Assert.hpp>
#include <Fw/Types/MallocAllocator.hpp>
#include <Fw/SerializableFile/SerializableFile.hpp>
#include <Fw/SerializableFile/test/TestSerializable/TestSerializableAc.hpp>
using namespace Fw;
int main(int argc, char **argv) {
// Create local serializable:
U32 element1 = 4294967284U;
I8 element2 = -18;
F64 element3 = 3.14159;
U32 size = Test::SERIALIZED_SIZE;
Test config(element1, element2, element3);
// Create the serializable file:
MallocAllocator theMallocator;
SerializableFile configFile(&theMallocator, size);
SerializableFile::Status status;
// Save the serializable to a file:
printf("Testing save... ");
status = configFile.save("test.ser", config);
FW_ASSERT(SerializableFile::OP_OK == status, status);
printf("Passed\n");
// Load the serializable from a file:
printf("Testing load... ");
Test config2;
status = configFile.load("test.ser", config2);
FW_ASSERT(SerializableFile::OP_OK == status, status);
printf("Passed\n");
// Compare the results:
printf("Testing compare... ");
FW_ASSERT(config == config2);
printf("Passed\n");
// Test saving to impossible file:
printf("Testing bad save... ");
status = configFile.save("this/file/does/not/exist", config);
FW_ASSERT(SerializableFile::FILE_OPEN_ERROR == status, status);
printf("Passed\n");
// Test reading from nonexistent file:
printf("Testing bad load... ");
Test config3;
status = configFile.load("thisfiledoesnotexist.ser", config3);
FW_ASSERT(SerializableFile::FILE_OPEN_ERROR == status, status);
printf("Passed\n");
return 0;
}
| cpp |
fprime | data/projects/fprime/Fw/Test/String.cpp | #include <Fw/Test/String.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Test {
String::String(const char* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
String::String(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
String::String(const String& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
String::String() : StringBase() {
this->m_buf[0] = 0;
}
String& String::operator=(const String& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
String& String::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
String& String::operator=(const char* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
String::~String() {
}
const char* String::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE String::getCapacity() const {
return STRING_SIZE;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Test/String.hpp | #ifndef TEST_STRING_TYPE_HPP
#define TEST_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Test {
//! A longer string for testing
class String : public Fw::StringBase {
public:
enum {
STRING_SIZE = 256, //!< Storage for string
SERIALIZED_SIZE = STRING_SIZE + sizeof(FwBuffSizeType) //!< Serialized size is size of buffer + size field
};
String(const char* src); //!< char* source constructor
String(const StringBase& src); //!< other string constructor
String(const String& src); //!< String string constructor
String(); //!< default constructor
String& operator=(const String& other); //!< assignment operator
String& operator=(const StringBase& other); //!< other string assignment operator
String& operator=(const char* other); //!< char* assignment operator
~String(); //!< destructor
const char* toChar() const; //!< gets char buffer
NATIVE_UINT_TYPE getCapacity() const ; //!< return buffer size
private:
char m_buf[STRING_SIZE]; //!< storage for string data
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Test/UnitTest.hpp | /**
* \file
* \author T. Canham
* \brief
*
* This contains macros used to document test cases and requirements in unit tests.
* Borrowed from Insight.
*
* \copyright
* Copyright 2009-2015, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
* <br /><br />
*/
#ifndef TEST_UNITTEST_HPP_
#define TEST_UNITTEST_HPP_
#define TEST_CASE(tc, desc) \
printf("\n***************************************\n"); \
printf("TESTCASE %s: " desc "\n", #tc); \
printf("***************************************\n")
#define REQUIREMENT(str) \
printf("\n***************************************\n"); \
printf("(RQ) %s\n", str); \
printf("***************************************\n")
#define COMMENT(str) \
printf("\n***************************************\n"); \
printf("%s\n", str); \
printf("***************************************\n")
#endif /* TEST_UNITTEST_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Test/UnitTestAssert.hpp | /*
* UnitTestAssert.hpp
*
* Created on: Feb 8, 2016
* Author: tcanham
* Revised July 2020
* Author: bocchino
*/
#ifndef TEST_UNITTESTASSERT_HPP_
#define TEST_UNITTESTASSERT_HPP_
#include <Fw/Test/String.hpp>
#include <Fw/Types/Assert.hpp>
namespace Test {
class UnitTestAssert: public Fw::AssertHook {
public:
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
typedef U32 File;
#else
typedef String File;
#endif
// initial value for File
static const File fileInit;
public:
UnitTestAssert();
virtual ~UnitTestAssert();
// function for hook
void doAssert();
void reportAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6
);
// retrieves assertion failure values
void retrieveAssert(
File& file,
NATIVE_UINT_TYPE& lineNo,
NATIVE_UINT_TYPE& numArgs,
FwAssertArgType& arg1,
FwAssertArgType& arg2,
FwAssertArgType& arg3,
FwAssertArgType& arg4,
FwAssertArgType& arg5,
FwAssertArgType& arg6
) const;
// check whether assertion failure occurred
bool assertFailed() const;
// clear assertion failure
void clearAssertFailure();
private:
File m_file;
NATIVE_UINT_TYPE m_lineNo;
NATIVE_INT_TYPE m_numArgs;
FwAssertArgType m_arg1;
FwAssertArgType m_arg2;
FwAssertArgType m_arg3;
FwAssertArgType m_arg4;
FwAssertArgType m_arg5;
FwAssertArgType m_arg6;
// Whether an assertion failed
bool m_assertFailed;
};
} /* namespace Test */
#endif /* TEST_UNITTESTASSERT_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Test/UnitTestAssert.cpp | /*
* UnitTestAssert.cpp
*
* Created on: Feb 8, 2016
* Author: tcanham
* Revised July 2020
* Author: bocchino
*/
#include <Fw/Test/UnitTestAssert.hpp>
#include <cstdio>
#include <cstring>
namespace Test {
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
const UnitTestAssert::File UnitTestAssert::fileInit = 0;
#else
const UnitTestAssert::File UnitTestAssert::fileInit = "";
#endif
UnitTestAssert::UnitTestAssert() :
m_file(fileInit),
m_lineNo(0),
m_numArgs(0),
m_arg1(0),
m_arg2(0),
m_arg3(0),
m_arg4(0),
m_arg5(0),
m_arg6(0),
m_assertFailed(false)
{
// register this hook
Fw::AssertHook::registerHook();
}
UnitTestAssert::~UnitTestAssert() {
// deregister the hook
Fw::AssertHook::deregisterHook();
}
void UnitTestAssert::doAssert() {
this->m_assertFailed = true;
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
(void)fprintf(stderr,"Assert: 0x%" PRIx32 ":%" PRI_PlatformUIntType "\n", this->m_file, this->m_lineNo);
#else
(void)fprintf(stderr,"Assert: %s:%" PRI_PlatformUIntType "\n", this->m_file.toChar(), this->m_lineNo);
#endif
}
void UnitTestAssert::reportAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6
) {
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
this->m_file = file;
#else
this->m_file = reinterpret_cast<const char*>(file);
#endif
this->m_lineNo = lineNo;
this->m_numArgs = numArgs;
this->m_arg1 = arg1;
this->m_arg2 = arg2;
this->m_arg3 = arg3;
this->m_arg4 = arg4;
this->m_arg5 = arg5;
this->m_arg6 = arg6;
}
void UnitTestAssert::retrieveAssert(
File& file,
NATIVE_UINT_TYPE& lineNo,
NATIVE_UINT_TYPE& numArgs,
FwAssertArgType& arg1,
FwAssertArgType& arg2,
FwAssertArgType& arg3,
FwAssertArgType& arg4,
FwAssertArgType& arg5,
FwAssertArgType& arg6
) const {
file = this->m_file;
lineNo = this->m_lineNo;
numArgs = this->m_numArgs;
arg1 = this->m_arg1;
arg2 = this->m_arg2;
arg3 = this->m_arg3;
arg4 = this->m_arg4;
arg5 = this->m_arg5;
arg6 = this->m_arg6;
}
bool UnitTestAssert::assertFailed() const {
return this->m_assertFailed;
}
void UnitTestAssert::clearAssertFailure() {
this->m_assertFailed = false;
}
} /* namespace Test */
| cpp |
fprime | data/projects/fprime/Fw/Cfg/ConfigCheck.cpp | /**
* \file
* \author T. Canham
* \brief Configuration checks for ISF configuration macros
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#include <FpConfig.hpp>
#include <limits>
// Check that command/telemetry strings are not larger than an argument buffer
static_assert(FW_CMD_STRING_MAX_SIZE <= FW_CMD_ARG_BUFFER_MAX_SIZE, "FW_CMD_STRING_MAX_SIZE cannot be larger than FW_CMD_ARG_BUFFER_MAX_SIZE");
static_assert(FW_LOG_STRING_MAX_SIZE <= FW_LOG_BUFFER_MAX_SIZE, "FW_LOG_STRING_MAX_SIZE cannot be larger than FW_LOG_BUFFER_MAX_SIZE");
static_assert(FW_TLM_STRING_MAX_SIZE <= FW_TLM_BUFFER_MAX_SIZE, "FW_TLM_STRING_MAX_SIZE cannot be larger than FW_TLM_BUFFER_MAX_SIZE");
static_assert(FW_PARAM_STRING_MAX_SIZE <= FW_PARAM_BUFFER_MAX_SIZE, "FW_PARAM_STRING_MAX_SIZE cannot be larger than FW_PARAM_BUFFER_MAX_SIZE");
// Text logging needs the code generator for serializables to generate a stringified version of the
// value.
static_assert((FW_ENABLE_TEXT_LOGGING == 0) || ( FW_SERIALIZABLE_TO_STRING == 1), "FW_SERIALIZABLE_TO_STRING must be enabled to enable FW_ENABLE_TEXT_LOGGING");
static_assert(std::numeric_limits<FwBuffSizeType>::max() == std::numeric_limits<FwSizeStoreType>::max() &&
std::numeric_limits<FwBuffSizeType>::min() == std::numeric_limits<FwSizeStoreType>::min(),
"FwBuffSizeType must be equivalent to FwExternalSizeType");
static_assert(std::numeric_limits<FwSizeType>::max() >= std::numeric_limits<FwSizeStoreType>::max() &&
std::numeric_limits<FwSizeType>::min() <= std::numeric_limits<FwSizeStoreType>::min(),
"FwSizeType cannot entirely store values of type FwExternalSizeType");
| cpp |
fprime | data/projects/fprime/Fw/Cfg/SerIds.hpp | /**
* \file
* \author T. Canham
* \brief Definitions for ISF type serial IDs
*
* NOTE: Not currently being used
*
* \copyright
* Copyright 2009-2015, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
* <br /><br />
*/
#ifndef _FW_SER_IDS_HPP_
#define _FW_SER_IDS_HPP_
// Definitions of provided types serialized IDs
// Should fit in 16 bits
namespace Fw {
enum {
// Built-in types
FW_TYPEID_U8 = 10, //!< U8 serialized type id
FW_TYPEID_18 = 11, //!< I8 serialized type id
FW_TYPEID_U16 = 12, //!< U16 serialized type id
FW_TYPEID_I16 = 13, //!< I16 serialized type id
FW_TYPEID_U32 = 14, //!< U32 serialized type id
FW_TYPEID_I32 = 15, //!< I32 serialized type id
FW_TYPEID_U64 = 16, //!< U64 serialized type id
FW_TYPEID_I64 = 17, //!< I64 serialized type id
FW_TYPEID_F32 = 18, //!< F32 serialized type id
FW_TYPEID_F64 = 19, //!< F64 serialized type id
FW_TYPEID_BOOL = 20, //!< boolean serialized type id
FW_TYPEID_PTR = 21, //!< pointer serialized type id
FW_TYPEID_BUFF = 22, //!< buffer serialized type id
// PolyType
FW_TYPEID_POLY = 30, //!< PolyType serialized type id
// Command/Telemetry types
FW_TYPEID_CMD_BUFF = 40, //!< Command Buffer type id
FW_TYPEID_CMD_STR = 41, //!< Command string type id
FW_TYPEID_TLM_BUFF = 42, //!< Telemetry Buffer type id
FW_TYPEID_TLM_STR = 43, //!< Telemetry string type id
FW_TYPEID_LOG_BUFF = 44, //!< Log Buffer type id
FW_TYPEID_LOG_STR = 45, //!< Log string type id
FW_TYPEID_PRM_BUFF = 46, //!< Parameter Buffer type id
FW_TYPEID_PRM_STR = 47, //!< Parameter string type id
FW_TYPEID_FILE_BUFF = 48, //!< File piece Buffer type id
// Other types
FW_TYPEID_EIGHTY_CHAR_STRING = 50, //!< 80 char string Buffer type id
FW_TYPEID_INTERNAL_INTERFACE_STRING = 51, //!< interface string Buffer type id
FW_TYPEID_FIXED_LENGTH_STRING = 52, //!< 256 char string Buffer type id
FW_TYPEID_OBJECT_NAME = 53, //!< ObjectName string Buffer type id
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Cmd/CmdPacket.cpp | /*
* CmdPacket.cpp
*
* Created on: May 24, 2014
* Author: Timothy Canham
*/
#include <Fw/Cmd/CmdPacket.hpp>
#include <Fw/Types/Assert.hpp>
#include <cstdio>
namespace Fw {
CmdPacket::CmdPacket() : m_opcode(0) {
this->m_type = FW_PACKET_COMMAND;
}
CmdPacket::~CmdPacket() {
}
SerializeStatus CmdPacket::serialize(SerializeBufferBase& buffer) const {
// Shouldn't be called
FW_ASSERT(0);
return FW_SERIALIZE_OK; // for compiler
}
SerializeStatus CmdPacket::deserialize(SerializeBufferBase& buffer) {
SerializeStatus stat = ComPacket::deserializeBase(buffer);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
// double check packet type
if (this->m_type != FW_PACKET_COMMAND) {
return FW_DESERIALIZE_TYPE_MISMATCH;
}
stat = buffer.deserialize(this->m_opcode);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
// if non-empty, copy data
if (buffer.getBuffLeft()) {
// copy the serialized arguments to the buffer
stat = buffer.copyRaw(this->m_argBuffer,buffer.getBuffLeft());
}
return stat;
}
FwOpcodeType CmdPacket::getOpCode() const {
return this->m_opcode;
}
CmdArgBuffer& CmdPacket::getArgBuffer() {
return this->m_argBuffer;
}
} /* namespace Fw */
| cpp |
fprime | data/projects/fprime/Fw/Cmd/CmdPacket.hpp | /*
* CmdPacket.hpp
*
* Created on: May 24, 2014
* Author: Timothy Canham
*/
#ifndef CMDPACKET_HPP_
#define CMDPACKET_HPP_
#include <Fw/Com/ComPacket.hpp>
#include <Fw/Cmd/CmdArgBuffer.hpp>
namespace Fw {
class CmdPacket : public ComPacket {
public:
CmdPacket();
virtual ~CmdPacket();
SerializeStatus serialize(SerializeBufferBase& buffer) const; //!< serialize contents
SerializeStatus deserialize(SerializeBufferBase& buffer);
FwOpcodeType getOpCode() const;
CmdArgBuffer& getArgBuffer();
protected:
FwOpcodeType m_opcode;
CmdArgBuffer m_argBuffer;
};
} /* namespace Fw */
#endif /* CMDPACKET_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Cmd/CmdString.cpp | #include <Fw/Cmd/CmdString.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
CmdStringArg::CmdStringArg(const char* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
CmdStringArg::CmdStringArg(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
CmdStringArg::CmdStringArg(const CmdStringArg& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
CmdStringArg::CmdStringArg() : StringBase() {
this->m_buf[0] = 0;
}
CmdStringArg& CmdStringArg::operator=(const CmdStringArg& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
CmdStringArg& CmdStringArg::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
CmdStringArg& CmdStringArg::operator=(const char* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
CmdStringArg::~CmdStringArg() {
}
const char* CmdStringArg::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE CmdStringArg::getCapacity() const {
return FW_CMD_STRING_MAX_SIZE;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Cmd/CmdString.hpp | #ifndef FW_CMD_STRING_TYPE_HPP
#define FW_CMD_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class CmdStringArg : public Fw::StringBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_CMD_STR,
SERIALIZED_SIZE = FW_CMD_STRING_MAX_SIZE + sizeof(FwBuffSizeType)
};
CmdStringArg(const char* src);
CmdStringArg(const StringBase& src);
CmdStringArg(const CmdStringArg& src);
CmdStringArg();
CmdStringArg& operator=(const CmdStringArg& other);
CmdStringArg& operator=(const StringBase& other);
CmdStringArg& operator=(const char* other);
~CmdStringArg();
const char* toChar() const;
NATIVE_UINT_TYPE getCapacity() const ; //!< return buffer size
private:
char m_buf[FW_CMD_STRING_MAX_SIZE];
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Cmd/CmdArgBuffer.hpp | /*
*
*
* Created on: March 1, 2014
* Author: T. Canham
*/
/*
* Description:
* This object contains the CmdARgBuffer type, used for holding the serialized arguments of commands
*/
#ifndef FW_CMD_ARG_BUFFER_HPP
#define FW_CMD_ARG_BUFFER_HPP
#include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class CmdArgBuffer : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_CMD_BUFF, //!< type id for CmdArgBuffer
SERIALIZED_SIZE = FW_CMD_ARG_BUFFER_MAX_SIZE + sizeof(I32) //!< size when serialized. Buffer + size of buffer
};
CmdArgBuffer(const U8 *args, NATIVE_UINT_TYPE size); //!< buffer source constructor
CmdArgBuffer(); //!< default constructor
CmdArgBuffer(const CmdArgBuffer& other); //!< other arg buffer constructor
virtual ~CmdArgBuffer(); //!< destructor
CmdArgBuffer& operator=(const CmdArgBuffer& other); //!< Equal operator
NATIVE_UINT_TYPE getBuffCapacity() const; //!< return capacity of buffer (how much it can hold)
U8* getBuffAddr(); //!< return address of buffer (non const version)
const U8* getBuffAddr() const; //!< return address of buffer (const version)
private:
U8 m_bufferData[FW_CMD_ARG_BUFFER_MAX_SIZE]; //!< command argument buffer
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Cmd/CmdArgBuffer.cpp | #include <Fw/Cmd/CmdArgBuffer.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
CmdArgBuffer::CmdArgBuffer(const U8 *args, NATIVE_UINT_TYPE size) {
SerializeStatus stat = this->setBuff(args,size);
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
CmdArgBuffer::CmdArgBuffer() {
}
CmdArgBuffer::~CmdArgBuffer() {
}
CmdArgBuffer::CmdArgBuffer(const CmdArgBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = this->setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
CmdArgBuffer& CmdArgBuffer::operator=(const CmdArgBuffer& other) {
if(this == &other) {
return *this;
}
SerializeStatus stat = this->setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
return *this;
}
NATIVE_UINT_TYPE CmdArgBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* CmdArgBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* CmdArgBuffer::getBuffAddr() {
return this->m_bufferData;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Logger/LogAssert.hpp | /*
* LogAssert.hpp
*
* Created on: Sep 9, 2016
* Author: tcanham
* Note: this file was originally a log assert file, under Fw::Types. It now made generic
* to log asserts to Fw::Logger
*/
#ifndef LOGGER_LOGASSERT_HPP_
#define LOGGER_LOGASSERT_HPP_
#include <Fw/Types/Assert.hpp>
namespace Fw {
class LogAssertHook: public Fw::AssertHook {
public:
LogAssertHook();
virtual ~LogAssertHook();
void reportAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6
);
void printAssert(const CHAR* msg);
void doAssert();
};
}
#endif /* VXWORKSLOGASSERT_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Logger/Logger.hpp | /**
* File: Logger.hpp
* Description: Framework logging support
* Author: mstarch
*
* This file adds in support to the core 'Fw' package, to separate it from Os and other loggers, and
* allow the architect of the system to select which core framework logging should be used.
*/
#ifndef _Fw_Logger_hpp_
#define _Fw_Logger_hpp_
#include <FpConfig.hpp>
namespace Fw {
class Logger {
public:
/**
* Function called on the logger to log a message. This is abstract virtual method and
* must be supplied by the subclass. This logger object should be registered with the
* Fw::Log::registerLogger function.
* \param fmt: format string in which to place arguments
* \param a0: zeroth argument. (Default: 0)
* \param a1: first argument. (Default: 0)
* \param a2: second argument. (Default: 0)
* \param a3: third argument. (Default: 0)
* \param a4: fourth argument. (Default: 0)
* \param a5: fifth argument. (Default: 0)
* \param a6: sixth argument. (Default: 0)
* \param a7: seventh argument. (Default: 0)
* \param a8: eighth argument. (Default: 0)
* \param a9: ninth argument. (Default: 0)
*/
virtual void log(
const char* fmt,
POINTER_CAST a0 = 0,
POINTER_CAST a1 = 0,
POINTER_CAST a2 = 0,
POINTER_CAST a3 = 0,
POINTER_CAST a4 = 0,
POINTER_CAST a5 = 0,
POINTER_CAST a6 = 0,
POINTER_CAST a7 = 0,
POINTER_CAST a8 = 0,
POINTER_CAST a9 = 0
) = 0;
/**
* Logs a message using the currently specified static logger. If a logger is not
* registered, then the log message is dropped.
* \param fmt: format string in which to place arguments
* \param a0: zeroth argument. (Default: 0)
* \param a1: first argument. (Default: 0)
* \param a2: second argument. (Default: 0)
* \param a3: third argument. (Default: 0)
* \param a4: fourth argument. (Default: 0)
* \param a5: fifth argument. (Default: 0)
* \param a6: sixth argument. (Default: 0)
* \param a7: seventh argument. (Default: 0)
* \param a8: eighth argument. (Default: 0)
* \param a9: ninth argument. (Default: 0)
*/
static void logMsg(
const char* fmt,
POINTER_CAST a0 = 0,
POINTER_CAST a1 = 0,
POINTER_CAST a2 = 0,
POINTER_CAST a3 = 0,
POINTER_CAST a4 = 0,
POINTER_CAST a5 = 0,
POINTER_CAST a6 = 0,
POINTER_CAST a7 = 0,
POINTER_CAST a8 = 0,
POINTER_CAST a9 = 0
);
/**
* Registers the static logger for use with the Fw::Log::logMsg function. This must be
* a subclass of Fw::Log.
* \param logger: logger to log to when Fw::Log::logMsg is called.
*/
static void registerLogger(Logger* logger);
//!< Static logger to use when calling the above 'logMsg' function
static Logger* s_current_logger;
virtual ~Logger();
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Logger/LogAssert.cpp | /*
* LogAssert.cpp
*
* Created on: Sep 9, 2016
* Author: tcanham
* Note: this file was originally a log assert file, under Fw::Types. It now made generic
* to log asserts to Fw::Logger
*/
#include <Fw/Logger/LogAssert.hpp>
#include <Fw/Logger/Logger.hpp>
#if FW_ASSERT_LEVEL == FW_NO_ASSERT
#else
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
#define fileIdFs "Assert: %d:%d"
#define ASSERT_CAST static_cast<POINTER_CAST>
#else
#define fileIdFs "Assert: \"%s:%d\""
#define ASSERT_CAST reinterpret_cast<POINTER_CAST>
#endif
namespace Fw {
LogAssertHook::LogAssertHook() {
}
LogAssertHook::~LogAssertHook() {
}
void LogAssertHook::reportAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6
) {
// Assumption is that file (when string) goes back to static macro in the code and will persist
switch (numArgs) {
case 0:
Fw::Logger::logMsg(fileIdFs,ASSERT_CAST(file),lineNo,0,0,0,0);
break;
case 1:
Fw::Logger::logMsg(fileIdFs " %d\n",ASSERT_CAST(file),lineNo,arg1,0,0,0);
break;
case 2:
Fw::Logger::logMsg(fileIdFs " %d %d\n",ASSERT_CAST(file),lineNo,arg1,arg2,0,0);
break;
case 3:
Fw::Logger::logMsg(fileIdFs " %d %d %d\n",ASSERT_CAST(file),lineNo,arg1,arg2,arg3,0);
break;
case 4:
Fw::Logger::logMsg(fileIdFs " %d %d %d %d\n",ASSERT_CAST(file),lineNo,arg1,arg2,arg3,arg4);
break;
default: // can't fit remainder of arguments in log message
Fw::Logger::logMsg(fileIdFs " %d %d %d %d +\n",ASSERT_CAST(file),lineNo,arg1,arg2,arg3,arg4);
break;
}
}
void LogAssertHook::printAssert(const CHAR* msg) {
// do nothing since reportAssert() sends message
}
void LogAssertHook::doAssert() {
}
} // namespace Fw
#endif
| cpp |
fprime | data/projects/fprime/Fw/Logger/Logger.cpp | /**
* File: Logger.cpp
* Description: Framework logging implementation
* Author: mstarch
*
* This file adds in support to the core 'Fw' package, to separate it from Os and other loggers, and
* allow the architect of the system to select which core framework logging should be used.
*/
#include <Fw/Logger/Logger.hpp>
namespace Fw {
//Initial logger is NULL
Logger* Logger::s_current_logger = nullptr;
// Basic log implementation
void Logger::logMsg(const char* fmt, POINTER_CAST a0, POINTER_CAST a1,
POINTER_CAST a2, POINTER_CAST a3, POINTER_CAST a4, POINTER_CAST a5,
POINTER_CAST a6, POINTER_CAST a7, POINTER_CAST a8, POINTER_CAST a9) {
// Log if capable, otherwise drop
if (Logger::s_current_logger != nullptr) {
Logger::s_current_logger->log(fmt, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
}
// Register the logger
void Logger::registerLogger(Logger* logger) {
Logger::s_current_logger = logger;
}
Logger::~Logger() {
}
} //End namespace Fw
| cpp |
fprime | data/projects/fprime/Fw/Logger/test/ut/LoggerMain.cpp | /**
* Main.cpp:
*
* Setup the GTests for rules-based testing of Fw::Logger and runs these tests.
*
* Created on: May 23, 2019
* Author: mstarch
*/
#include <STest/Scenario/Scenario.hpp>
#include <STest/Scenario/RandomScenario.hpp>
#include <STest/Scenario/BoundedScenario.hpp>
#include <Fw/Test/UnitTest.hpp>
#include <Fw/Logger/test/ut/LoggerRules.hpp>
#include <gtest/gtest.h>
#include <cstdio>
#define STEP_COUNT 10000
/**
* A random hopper for rules. Apply STEP_COUNT times.
*/
TEST(LoggerTests, RandomLoggerTests) {
MockLogging::FakeLogger logger;
// Create rules, and assign them into the array
LoggerRules::Register reg("Register");
LoggerRules::LogGood log("Log Successfully");
LoggerRules::LogBad nolog("Log unsuccessfully");
// Setup a list of rules to choose from
STest::Rule<MockLogging::FakeLogger>* rules[] = {
®,
&log,
&nolog
};
// Construct the random scenario and run it with the defined bounds
STest::RandomScenario<MockLogging::FakeLogger> random("Random Rules", rules,
FW_NUM_ARRAY_ELEMENTS(rules));
// Setup a bounded scenario to run rules a set number of times
STest::BoundedScenario<MockLogging::FakeLogger> bounded("Bounded Random Rules Scenario",
random, STEP_COUNT);
// Run!
const U32 numSteps = bounded.run(logger);
printf("Ran %u steps.\n", numSteps);
}
/**
* Test that the most basic logging function works.
*/
TEST(LoggerTests, BasicGoodLogger) {
// Setup and register logger
MockLogging::FakeLogger logger;
Fw::Logger::registerLogger(&logger);
logger.s_current = &logger;
// Basic logging
LoggerRules::LogGood log("Log Successfully");
log.apply(logger);
}
/**
* Test that null-logging function works.
*/
TEST(LoggerTests, BasicBadLogger) {
// Basic discard logging
MockLogging::FakeLogger logger;
Fw::Logger::registerLogger(nullptr);
logger.s_current = nullptr;
LoggerRules::LogBad log("Log Discarded");
log.apply(logger);
}
/**
* Test that registration works. Multiple times, as contains randomness.
*/
TEST(LoggerTests, BasicRegLogger) {
// Basic discard logging
MockLogging::FakeLogger logger;
LoggerRules::Register reg("Register");
reg.apply(logger);
reg.apply(logger);
reg.apply(logger);
reg.apply(logger);
reg.apply(logger);
reg.apply(logger);
reg.apply(logger);
}
int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
STest::Random::seed();
return RUN_ALL_TESTS();
}
| cpp |
fprime | data/projects/fprime/Fw/Logger/test/ut/FakeLogger.hpp | /**
* FakeLogger.hpp:
*
* Setup a fake logger for use with the testing. This allows for the capture of messages from the system and ensure that
* the proper log messages are coming through as expected.
*
* @author mstarch
*/
#include <FpConfig.hpp>
#include <Fw/Logger/Logger.hpp>
#ifndef FPRIME_FAKELOGGER_HPP
#define FPRIME_FAKELOGGER_HPP
namespace MockLogging {
/**
* LogMessage data type to map inputs too.
*/
struct LogMessage {
const char *fmt;
POINTER_CAST a0;
POINTER_CAST a1;
POINTER_CAST a2;
POINTER_CAST a3;
POINTER_CAST a4;
POINTER_CAST a5;
POINTER_CAST a6;
POINTER_CAST a7;
POINTER_CAST a8;
POINTER_CAST a9;
};
/**
* Fake logger used for two purposes:
* 1. it acts as logging truth for the test
* 2. it intercepts logging calls bound for the system
*/
class FakeLogger : public Fw::Logger {
public:
//!< Constructor
FakeLogger();
/**
* Fake implementation of the logger.
* @param fmt: format
* @param a0: arg0
* @param a1: arg1
* @param a2: arg2
* @param a3: arg3
* @param a4: arg4
* @param a5: arg5
* @param a6: arg6
* @param a7: arg7
* @param a8: arg8
* @param a9: arg9
*/
void log(
const char *fmt,
POINTER_CAST a0 = 0,
POINTER_CAST a1 = 0,
POINTER_CAST a2 = 0,
POINTER_CAST a3 = 0,
POINTER_CAST a4 = 0,
POINTER_CAST a5 = 0,
POINTER_CAST a6 = 0,
POINTER_CAST a7 = 0,
POINTER_CAST a8 = 0,
POINTER_CAST a9 = 0
);
/**
* Check last message.
* @param fmt: format
* @param a0: arg1
* @param a1: arg1
* @param a2: arg2
* @param a3: arg3
* @param a4: arg4
* @param a5: arg5
* @param a6: arg6
* @param a7: arg6
* @param a8: arg6
* @param a9: arg6
*/
virtual void check(
const char *fmt,
POINTER_CAST a0 = 0,
POINTER_CAST a1 = 0,
POINTER_CAST a2 = 0,
POINTER_CAST a3 = 0,
POINTER_CAST a4 = 0,
POINTER_CAST a5 = 0,
POINTER_CAST a6 = 0,
POINTER_CAST a7 = 0,
POINTER_CAST a8 = 0,
POINTER_CAST a9 = 0
);
//!< Reset this logger
void reset();
//!< Last message that came in
LogMessage m_last;
//!< Logger to use within the system
static Fw::Logger* s_current;
};
};
#endif //FPRIME_FAKELOGGER_HPP
| hpp |
fprime | data/projects/fprime/Fw/Logger/test/ut/LoggerRules.hpp | /**
* LoggerRules.hpp:
*
* This file specifies Rule classes for testing of the Fw::Logger. These rules can then be used by the main testing
* program to test the code.
*
* Logging rules:
*
* 1. a logger can be registered at any time.
* 2. NULL loggers discard log calls
* 3. if a valid logger is registered, the log message is called
*
* @author mstarch
*/
#ifndef FPRIME_LOGGERRULES_HPP
#define FPRIME_LOGGERRULES_HPP
#include <FpConfig.hpp>
#include <Fw/Types/String.hpp>
#include <Fw/Logger/test/ut/FakeLogger.hpp>
#include <STest/STest/Rule/Rule.hpp>
#include <STest/STest/Pick/Pick.hpp>
namespace LoggerRules {
/**
* Register:
*
* Rule to handle the registration of a logger to the global logger. It may also register a "NULL" logger and thus
* stop output logging.
*/
struct Register : public STest::Rule<MockLogging::FakeLogger> {
// Constructor
Register(const Fw::String& name);
// Check for registration, always allowed
bool precondition(const MockLogging::FakeLogger& truth);
// Register NULL or truth as the system logger
void action(MockLogging::FakeLogger& truth);
};
/**
* LogGood:
*
* As long as a non-NULL logger is set as the system logger, then valid log messages should be processed.
*/
struct LogGood : public STest::Rule<MockLogging::FakeLogger> {
// Constructor
LogGood(const Fw::String& name);
// Check for logging, only when not NULL
bool precondition(const MockLogging::FakeLogger& truth);
// Log valid messages
void action(MockLogging::FakeLogger& truth);
};
/**
* LogBad:
*
* As long as a non-NULL logger is set as the system logger, then valid log messages should be processed.
*/
struct LogBad : public STest::Rule<MockLogging::FakeLogger> {
// Constructor
LogBad(const Fw::String& name);
// Check for logging, only when not NULL
bool precondition(const MockLogging::FakeLogger& truth);
// Log valid messages
void action(MockLogging::FakeLogger& truth);
};
};
#endif //FPRIME_LOGGERRULES_HPP
| hpp |
fprime | data/projects/fprime/Fw/Logger/test/ut/LoggerRules.cpp | /**
* LoggerRules.cpp:
*
* This file specifies Rule classes for testing of the Fw::Logger. These rules can then be used by the main testing
* program to test the code.
*
* Logging rules:
*
* 1. a logger can be registered at any time.
* 2. NULL loggers discard log calls
* 3. if a valid logger is registered, the log message is called
*
* @author mstarch
*/
#include "Fw/Logger/test/ut/LoggerRules.hpp"
namespace LoggerRules {
// Constructor
Register::Register(const Fw::String& name) : STest::Rule<MockLogging::FakeLogger>(name.toChar()) {}
// Check for registration, always allowed
bool Register::precondition(const MockLogging::FakeLogger& truth) {
return true;
}
// Register NULL or truth as the system logger
void Register::action(MockLogging::FakeLogger& truth) {
// Select a registration value: 1 -> logger, 0 -> NULL
NATIVE_INT_TYPE random = STest::Pick::lowerUpper(0, 1);
if (random == 1) {
Fw::Logger::registerLogger(&truth);
truth.s_current = &truth;
}
else {
Fw::Logger::registerLogger(nullptr);
truth.s_current = nullptr;
}
ASSERT_EQ(truth.s_current, Fw::Logger::s_current_logger);
}
// Constructor
LogGood::LogGood(const Fw::String& name) : STest::Rule<MockLogging::FakeLogger>(name.toChar()) {}
// Check for logging, only when not NULL
bool LogGood::precondition(const MockLogging::FakeLogger& truth) {
return truth.s_current != nullptr;
}
// Log valid messages
void LogGood::action(MockLogging::FakeLogger& truth) {
NATIVE_INT_TYPE random = STest::Pick::lowerUpper(0, 10);
NATIVE_INT_TYPE ra[10];
for (int i = 0; i < 10; ++i) {
ra[i] = STest::Pick::lowerUpper(0, 0xffffffff);
}
switch (random) {
case 0:
Fw::Logger::logMsg("No args");
truth.check("No args");
break;
case 1:
Fw::Logger::logMsg("One arg: %lu", ra[0]);
truth.check("One arg: %lu", ra[0]);
break;
case 2:
Fw::Logger::logMsg("Two arg: %lu", ra[0], ra[1]);
truth.check("Two arg: %lu", ra[0], ra[1]);
break;
case 3:
Fw::Logger::logMsg("Three arg: %lu", ra[0], ra[1], ra[2]);
truth.check("Three arg: %lu", ra[0], ra[1], ra[2]);
break;
case 4:
Fw::Logger::logMsg("Four arg: %lu", ra[0], ra[1], ra[2], ra[3]);
truth.check("Four arg: %lu", ra[0], ra[1], ra[2], ra[3]);
break;
case 5:
Fw::Logger::logMsg("Five arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4]);
truth.check("Five arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4]);
break;
case 6:
Fw::Logger::logMsg("Six arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5]);
truth.check("Six arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5]);
break;
case 7:
Fw::Logger::logMsg("Seven arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6]);
truth.check("Seven arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6]);
break;
case 8:
Fw::Logger::logMsg("Eight arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7]);
truth.check("Eight arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7]);
break;
case 9:
Fw::Logger::logMsg("Nine arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7], ra[8]);
truth.check("Nine arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7], ra[8]);
break;
case 10:
Fw::Logger::logMsg("Ten arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7], ra[8], ra[9]);
truth.check("Ten arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7], ra[8], ra[9]);
break;
default:
ASSERT_EQ(0, 1);
}
truth.reset();
}
// Constructor
LogBad::LogBad(const Fw::String& name) : STest::Rule<MockLogging::FakeLogger>(name.toChar()) {}
// Check for logging, only when not NULL
bool LogBad::precondition(const MockLogging::FakeLogger& truth) {
return truth.s_current == nullptr;
}
// Log valid messages
void LogBad::action(MockLogging::FakeLogger& truth) {
NATIVE_INT_TYPE random = STest::Pick::lowerUpper(0, 10);
NATIVE_INT_TYPE ra[10];
for (int i = 0; i < 10; ++i) {
ra[i] = STest::Pick::lowerUpper(0, 0xffffffff);
}
switch (random) {
case 0:
Fw::Logger::logMsg("No args");
truth.check(nullptr);
break;
case 1:
Fw::Logger::logMsg("One arg: %lu", ra[0]);
truth.check(nullptr);
break;
case 2:
Fw::Logger::logMsg("Two arg: %lu", ra[0], ra[1]);
truth.check(nullptr);
break;
case 3:
Fw::Logger::logMsg("Three arg: %lu", ra[0], ra[1], ra[2]);
truth.check(nullptr);
break;
case 4:
Fw::Logger::logMsg("Four arg: %lu", ra[0], ra[1], ra[2], ra[3]);
truth.check(nullptr);
break;
case 5:
Fw::Logger::logMsg("Five arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4]);
truth.check(nullptr);
break;
case 6:
Fw::Logger::logMsg("Six arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5]);
truth.check(nullptr);
break;
case 7:
Fw::Logger::logMsg("Seven arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6]);
truth.check(nullptr);
break;
case 8:
Fw::Logger::logMsg("Eight arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7]);
truth.check(nullptr);
break;
case 9:
Fw::Logger::logMsg("Nine arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7], ra[8]);
truth.check(nullptr);
break;
case 10:
Fw::Logger::logMsg("Ten arg: %lu", ra[0], ra[1], ra[2], ra[3], ra[4], ra[5], ra[6], ra[7], ra[8], ra[9]);
truth.check(nullptr);
break;
default:
ASSERT_EQ(0, 1);
}
truth.reset();
}
};
| cpp |
fprime | data/projects/fprime/Fw/Logger/test/ut/FakeLogger.cpp | /**
* FakeLogger.cpp:
*
* Setup a fake logger for use with the testing. This allows for the capture of messages from the system and ensure that
* the proper log messages are coming through as expected.
*
* @author mstarch
*/
#include <gtest/gtest.h>
#include <Fw/Logger/test/ut/FakeLogger.hpp>
namespace MockLogging {
Fw::Logger* FakeLogger::s_current = nullptr;
FakeLogger::FakeLogger() {
memset(&m_last, 0, sizeof(m_last));
}
void FakeLogger::log(
const char *fmt,
POINTER_CAST a0,
POINTER_CAST a1,
POINTER_CAST a2,
POINTER_CAST a3,
POINTER_CAST a4,
POINTER_CAST a5,
POINTER_CAST a6,
POINTER_CAST a7,
POINTER_CAST a8,
POINTER_CAST a9
) {
m_last.fmt = fmt;
m_last.a0 = a0;
m_last.a1 = a1;
m_last.a2 = a2;
m_last.a3 = a3;
m_last.a4 = a4;
m_last.a5 = a5;
m_last.a6 = a6;
m_last.a7 = a7;
m_last.a8 = a8;
m_last.a9 = a9;
}
void FakeLogger::check(
const char *fmt,
POINTER_CAST a0,
POINTER_CAST a1,
POINTER_CAST a2,
POINTER_CAST a3,
POINTER_CAST a4,
POINTER_CAST a5,
POINTER_CAST a6,
POINTER_CAST a7,
POINTER_CAST a8,
POINTER_CAST a9
) {
ASSERT_EQ(m_last.fmt, fmt);
ASSERT_EQ(m_last.a0, a0);
ASSERT_EQ(m_last.a1, a1);
ASSERT_EQ(m_last.a2, a2);
ASSERT_EQ(m_last.a3, a3);
ASSERT_EQ(m_last.a4, a4);
ASSERT_EQ(m_last.a5, a5);
ASSERT_EQ(m_last.a6, a6);
ASSERT_EQ(m_last.a7, a7);
ASSERT_EQ(m_last.a8, a8);
ASSERT_EQ(m_last.a9, a9);
}
void FakeLogger::reset() {
m_last.fmt = nullptr;
m_last.a0 = 0;
m_last.a1 = 0;
m_last.a2 = 0;
m_last.a3 = 0;
m_last.a4 = 0;
m_last.a5 = 0;
m_last.a6 = 0;
m_last.a7 = 0;
m_last.a8 = 0;
m_last.a9 = 0;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Trap/TrapHandler.hpp | #ifndef FW_TRAP_HPP
#define FW_TRAP_HPP
#include <FpConfig.hpp>
namespace Fw {
/**
* TrapHandler:
* A framework class used to handle traps that occur during the execution of the
* the F' framework. Must be registered with a trap register. The user should
* inherit from this class and ensure that the doTrap function is implemented. The
* default implementation will be do-nothing.
*/
class TrapHandler {
public:
TrapHandler() {}; //!< constructor
virtual ~TrapHandler() {}; //!< destructor
/**
* Handles the incoming trap.
* Note: if user does not supply an implementer of this
* function, a do-nothing version will be run.
* \param trap: trap number
*/
virtual void doTrap(U32 trap) = 0;
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Dp/DpContainer.hpp | // ======================================================================
// \title DpContainer.hpp
// \author bocchino
// \brief hpp file for DpContainer
// ======================================================================
#ifndef Fw_DpContainer_HPP
#define Fw_DpContainer_HPP
#include "Fw/Buffer/Buffer.hpp"
#include "Fw/Dp/DpStateEnumAc.hpp"
#include "Fw/Time/Time.hpp"
#include "Fw/Types/SuccessEnumAc.hpp"
#include "Utils/Hash/Hash.hpp"
#include "config/FppConstantsAc.hpp"
#include "config/ProcTypeEnumAc.hpp"
namespace Fw {
//! A data product Container
class DpContainer {
public:
// ----------------------------------------------------------------------
// Constants and Types
// ----------------------------------------------------------------------
//! A DpContainer packet header
struct Header {
//! The type of user data
using UserData = U8[DpCfg::CONTAINER_USER_DATA_SIZE];
//! The offset for the packet descriptor field
static constexpr FwSizeType PACKET_DESCRIPTOR_OFFSET = 0;
//! The offset for the id field
static constexpr FwSizeType ID_OFFSET = PACKET_DESCRIPTOR_OFFSET + sizeof(FwPacketDescriptorType);
//! The offset for the priority field
static constexpr FwDpPriorityType PRIORITY_OFFSET = ID_OFFSET + sizeof(FwDpIdType);
//! The offset for the time tag field
static constexpr FwSizeType TIME_TAG_OFFSET = PRIORITY_OFFSET + sizeof(FwDpPriorityType);
//! The offset for the processing types field
static constexpr FwSizeType PROC_TYPES_OFFSET = TIME_TAG_OFFSET + Time::SERIALIZED_SIZE;
//! The offset for the user data field
static constexpr FwSizeType USER_DATA_OFFSET = PROC_TYPES_OFFSET + sizeof(DpCfg::ProcType::SerialType);
//! The offset of the data product state field
static constexpr FwSizeType DP_STATE_OFFSET = USER_DATA_OFFSET + DpCfg::CONTAINER_USER_DATA_SIZE;
//! The offset for the data size field
static constexpr FwSizeType DATA_SIZE_OFFSET = DP_STATE_OFFSET + DpState::SERIALIZED_SIZE;
//! The header size
static constexpr FwSizeType SIZE = DATA_SIZE_OFFSET + sizeof(FwSizeStoreType);
};
//! The header hash offset
static constexpr FwSizeType HEADER_HASH_OFFSET = Header::SIZE;
//! The data offset
static constexpr FwSizeType DATA_OFFSET = HEADER_HASH_OFFSET + HASH_DIGEST_LENGTH;
//! The minimum packet size
//! Reserve space for the header, the header hash, and the data hash
//! This is also the number of non-data bytes in the packet
static constexpr FwSizeType MIN_PACKET_SIZE = Header::SIZE + 2 * HASH_DIGEST_LENGTH;
public:
// ----------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------
//! Constructor for initialized container
DpContainer(FwDpIdType id, //!< The container id
const Fw::Buffer& buffer //!< The buffer
);
//! Constructor for container with default initialization
DpContainer();
public:
// ----------------------------------------------------------------------
// Public member functions
// ----------------------------------------------------------------------
//! Get the container id
//! \return The id
FwDpIdType getId() const { return this->m_id; }
//! Get the data size
//! \return The data size
FwSizeType getDataSize() const { return this->m_dataSize; }
//! Get the packet buffer
//! \return The buffer
Fw::Buffer getBuffer() const { return this->m_buffer; }
//! Get the packet size corresponding to the data size
FwSizeType getPacketSize() const { return getPacketSizeForDataSize(this->m_dataSize); }
//! Get the priority
//! \return The priority
FwDpPriorityType getPriority() const { return this->m_priority; }
//! Get the time tag
//! \return The time tag
Fw::Time getTimeTag() const { return this->m_timeTag; }
//! Get the processing types
//! \return The processing types
DpCfg::ProcType::SerialType getProcTypes() const { return this->m_procTypes; }
//! Get the data product state
DpState getDpState() const { return this->m_dpState; }
//! Deserialize the header from the packet buffer
//! Buffer must be valid, and its size must be at least MIN_PACKET_SIZE
//! Before calling this function, you should call checkHeaderHash() to
//! check the header hash
//! \return The serialize status
Fw::SerializeStatus deserializeHeader();
//! Serialize the header into the packet buffer and update the header hash
//! Buffer must be valid, and its size must be at least MIN_PACKET_SIZE
void serializeHeader();
//! Set the id
void setId(FwDpIdType id //!< The id
) {
this->m_id = id;
}
//! Set the priority
void setPriority(FwDpPriorityType priority //!< The priority
) {
this->m_priority = priority;
}
//! Set the time tag
void setTimeTag(Fw::Time timeTag //!< The time tag
) {
this->m_timeTag = timeTag;
}
//! Set the processing types bit mask
void setProcTypes(DpCfg::ProcType::SerialType procTypes //!< The processing types
) {
this->m_procTypes = procTypes;
}
//! Set the data product state
void setDpState(DpState dpState //!< The data product state
) {
this->m_dpState = dpState;
}
//! Set the data size
void setDataSize(FwSizeType dataSize //!< The data size
) {
this->m_dataSize = dataSize;
}
//! Set the packet buffer
void setBuffer(const Buffer& buffer //!< The packet buffer
);
//! Get the stored header hash
//! \return The hash
Utils::HashBuffer getHeaderHash() const;
//! Compute the header hash from the header data
//! \return The hash
Utils::HashBuffer computeHeaderHash() const;
//! Set the header hash
void setHeaderHash(const Utils::HashBuffer& hash //!< The hash
);
//! Compute and set the header hash
void updateHeaderHash();
//! Check the header hash
Success::T checkHeaderHash(Utils::HashBuffer& storedHash, //!< The stored hash (output)
Utils::HashBuffer& computedHash //!< The computed hash (output)
) const;
//! Get the data hash offset
FwSizeType getDataHashOffset() const {
// Data hash goes after the header, the header hash, and the data
return Header::SIZE + HASH_DIGEST_LENGTH + this->m_dataSize;
}
//! Get the stored data hash
//! \return The hash
Utils::HashBuffer getDataHash() const;
//! Compute the data hash from the data
//! \return The hash
Utils::HashBuffer computeDataHash() const;
//! Set the data hash
void setDataHash(Utils::HashBuffer hash //!< The hash
);
//! Update the data hash
void updateDataHash();
//! Check the data hash
Success::T checkDataHash(Utils::HashBuffer& storedHash, //!< The stored hash (output)
Utils::HashBuffer& computedHash //!< The computed hash (output)
) const;
public:
// ----------------------------------------------------------------------
// Public static functions
// ----------------------------------------------------------------------
//! Get the packet size for a given data size
static constexpr FwSizeType getPacketSizeForDataSize(FwSizeType dataSize //!< The data size
) {
return Header::SIZE + dataSize + 2 * HASH_DIGEST_LENGTH;
}
PRIVATE:
// ----------------------------------------------------------------------
// Private member functions
// ----------------------------------------------------------------------
//! Initialize the user data field
void initUserDataField();
public:
// ----------------------------------------------------------------------
// Public member variables
// ----------------------------------------------------------------------
//! The user data
Header::UserData m_userData;
PROTECTED:
// ----------------------------------------------------------------------
// Protected member variables
// ----------------------------------------------------------------------
//! The container id
//! This is a system-global id (component-local id + component base id)
FwDpIdType m_id;
//! The priority
FwDpPriorityType m_priority;
//! The time tag
Time m_timeTag;
//! The processing types
DpCfg::ProcType::SerialType m_procTypes;
//! The data product state
DpState m_dpState;
//! The data size
FwSizeType m_dataSize;
//! The packet buffer
Buffer m_buffer;
//! The data buffer
Fw::ExternalSerializeBuffer m_dataBuffer;
};
} // end namespace Fw
#endif
| hpp |
fprime | data/projects/fprime/Fw/Dp/DpContainer.cpp | // ======================================================================
// \title DpContainer.cpp
// \author bocchino
// \brief cpp file for DpContainer
// ======================================================================
#include <cstring>
#include "Fw/Com/ComPacket.hpp"
#include "Fw/Dp/DpContainer.hpp"
#include "Fw/Types/Assert.hpp"
namespace Fw {
// ----------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------
DpContainer::DpContainer(FwDpIdType id, const Fw::Buffer& buffer)
: m_id(id), m_priority(0), m_timeTag(), m_procTypes(0), m_dpState(), m_dataSize(0), m_buffer(), m_dataBuffer() {
// Initialize the user data field
this->initUserDataField();
// Set the packet buffer
// This action also updates the data buffer
this->setBuffer(buffer);
}
DpContainer::DpContainer()
: m_id(0), m_priority(0), m_timeTag(), m_procTypes(0), m_dataSize(0), m_buffer(), m_dataBuffer() {
// Initialize the user data field
this->initUserDataField();
}
// ----------------------------------------------------------------------
// Public member functions
// ----------------------------------------------------------------------
Fw::SerializeStatus DpContainer::deserializeHeader() {
FW_ASSERT(this->m_buffer.isValid());
Fw::SerializeBufferBase& serializeRepr = this->m_buffer.getSerializeRepr();
// Set buffer length
Fw::SerializeStatus status = serializeRepr.setBuffLen(this->m_buffer.getSize());
// Reset deserialization
if (status == Fw::FW_SERIALIZE_OK) {
status = serializeRepr.moveDeserToOffset(Header::PACKET_DESCRIPTOR_OFFSET);
}
// Deserialize the packet type
if (status == Fw::FW_SERIALIZE_OK) {
FwPacketDescriptorType packetDescriptor;
status = serializeRepr.deserialize(packetDescriptor);
if (packetDescriptor != Fw::ComPacket::FW_PACKET_DP) {
status = Fw::FW_SERIALIZE_FORMAT_ERROR;
}
}
// Deserialize the container id
if (status == Fw::FW_SERIALIZE_OK) {
status = serializeRepr.deserialize(this->m_id);
}
// Deserialize the priority
if (status == Fw::FW_SERIALIZE_OK) {
status = serializeRepr.deserialize(this->m_priority);
}
// Deserialize the time tag
if (status == Fw::FW_SERIALIZE_OK) {
status = serializeRepr.deserialize(this->m_timeTag);
}
// Deserialize the processing types
if (status == Fw::FW_SERIALIZE_OK) {
status = serializeRepr.deserialize(this->m_procTypes);
}
// Deserialize the user data
if (status == Fw::FW_SERIALIZE_OK) {
const FwSizeType requestedSize = sizeof this->m_userData;
FwSizeType receivedSize = requestedSize;
status = serializeRepr.deserialize(this->m_userData, receivedSize, Fw::Serialization::OMIT_LENGTH);
if (receivedSize != requestedSize) {
status = Fw::FW_DESERIALIZE_SIZE_MISMATCH;
}
}
// Deserialize the data product state
if (status == Fw::FW_SERIALIZE_OK) {
status = serializeRepr.deserialize(this->m_dpState);
}
// Deserialize the data size
if (status == Fw::FW_SERIALIZE_OK) {
status = serializeRepr.deserializeSize(this->m_dataSize);
}
return status;
}
void DpContainer::serializeHeader() {
FW_ASSERT(this->m_buffer.isValid());
Fw::SerializeBufferBase& serializeRepr = this->m_buffer.getSerializeRepr();
// Reset serialization
serializeRepr.resetSer();
// Serialize the packet type
Fw::SerializeStatus status =
serializeRepr.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_DP));
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Serialize the container id
status = serializeRepr.serialize(this->m_id);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Serialize the priority
status = serializeRepr.serialize(this->m_priority);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Serialize the time tag
status = serializeRepr.serialize(this->m_timeTag);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Serialize the processing types
status = serializeRepr.serialize(this->m_procTypes);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Serialize the user data
status = serializeRepr.serialize(this->m_userData, static_cast<FwSizeType>(sizeof this->m_userData),
Fw::Serialization::OMIT_LENGTH);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Serialize the data product state
status = serializeRepr.serialize(this->m_dpState);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Serialize the data size
status = serializeRepr.serializeSize(this->m_dataSize);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
// Update the header hash
this->updateHeaderHash();
}
void DpContainer::setBuffer(const Buffer& buffer) {
// Set the buffer
this->m_buffer = buffer;
// Check that the buffer is large enough to hold a data product packet with
// zero-size data
const FwSizeType bufferSize = buffer.getSize();
FW_ASSERT(bufferSize >= MIN_PACKET_SIZE, static_cast<FwAssertArgType>(bufferSize),
static_cast<FwAssertArgType>(MIN_PACKET_SIZE));
// Initialize the data buffer
U8* const buffAddr = buffer.getData();
const FwSizeType dataCapacity = buffer.getSize() - MIN_PACKET_SIZE;
// Check that data buffer is in bounds for packet buffer
const FwSizeType minBufferSize = DATA_OFFSET + dataCapacity;
FW_ASSERT(bufferSize >= minBufferSize, static_cast<FwAssertArgType>(bufferSize),
static_cast<FwAssertArgType>(minBufferSize));
U8* const dataAddr = &buffAddr[DATA_OFFSET];
this->m_dataBuffer.setExtBuffer(dataAddr, dataCapacity);
}
Utils::HashBuffer DpContainer::getHeaderHash() const {
const FwSizeType bufferSize = this->m_buffer.getSize();
const FwSizeType minBufferSize = HEADER_HASH_OFFSET + HASH_DIGEST_LENGTH;
FW_ASSERT(bufferSize >= minBufferSize, static_cast<FwAssertArgType>(bufferSize),
static_cast<FwAssertArgType>(minBufferSize));
const U8* const buffAddr = this->m_buffer.getData();
return Utils::HashBuffer(&buffAddr[HEADER_HASH_OFFSET], HASH_DIGEST_LENGTH);
}
Utils::HashBuffer DpContainer::computeHeaderHash() const {
const FwSizeType bufferSize = this->m_buffer.getSize();
FW_ASSERT(bufferSize >= Header::SIZE, static_cast<FwAssertArgType>(bufferSize),
static_cast<FwAssertArgType>(Header::SIZE));
U8* const buffAddr = this->m_buffer.getData();
Utils::HashBuffer computedHash;
Utils::Hash::hash(buffAddr, Header::SIZE, computedHash);
return computedHash;
}
void DpContainer::setHeaderHash(const Utils::HashBuffer& hash) {
const FwSizeType bufferSize = this->m_buffer.getSize();
const FwSizeType minBufferSize = HEADER_HASH_OFFSET + HASH_DIGEST_LENGTH;
FW_ASSERT(bufferSize >= minBufferSize, static_cast<FwAssertArgType>(bufferSize),
static_cast<FwAssertArgType>(minBufferSize));
U8* const buffAddr = this->m_buffer.getData();
(void)::memcpy(&buffAddr[HEADER_HASH_OFFSET], hash.getBuffAddr(), HASH_DIGEST_LENGTH);
}
void DpContainer::updateHeaderHash() {
this->setHeaderHash(this->computeHeaderHash());
}
Success::T DpContainer::checkHeaderHash(Utils::HashBuffer& storedHash, Utils::HashBuffer& computedHash) const {
storedHash = this->getHeaderHash();
computedHash = this->computeHeaderHash();
return (storedHash == computedHash) ? Success::SUCCESS : Success::FAILURE;
}
Utils::HashBuffer DpContainer::getDataHash() const {
const U8* const buffAddr = this->m_buffer.getData();
const FwSizeType dataHashOffset = this->getDataHashOffset();
const FwSizeType bufferSize = this->m_buffer.getSize();
FW_ASSERT(dataHashOffset + HASH_DIGEST_LENGTH <= bufferSize,
static_cast<FwAssertArgType>(dataHashOffset + HASH_DIGEST_LENGTH),
static_cast<FwAssertArgType>(bufferSize));
const U8* const dataHashAddr = &buffAddr[dataHashOffset];
return Utils::HashBuffer(dataHashAddr, HASH_DIGEST_LENGTH);
}
Utils::HashBuffer DpContainer::computeDataHash() const {
U8* const buffAddr = this->m_buffer.getData();
const U8* const dataAddr = &buffAddr[DATA_OFFSET];
const FwSizeType dataSize = this->getDataSize();
const FwSizeType bufferSize = this->m_buffer.getSize();
FW_ASSERT(DATA_OFFSET + dataSize <= bufferSize, static_cast<FwAssertArgType>(DATA_OFFSET + dataSize),
static_cast<FwAssertArgType>(bufferSize));
Utils::HashBuffer computedHash;
Utils::Hash::hash(dataAddr, dataSize, computedHash);
return computedHash;
}
void DpContainer::setDataHash(Utils::HashBuffer hash) {
U8* const buffAddr = this->m_buffer.getData();
const FwSizeType bufferSize = this->m_buffer.getSize();
const FwSizeType dataHashOffset = this->getDataHashOffset();
U8* const dataHashAddr = &buffAddr[dataHashOffset];
FW_ASSERT(dataHashOffset + HASH_DIGEST_LENGTH <= bufferSize,
static_cast<FwAssertArgType>(dataHashOffset + HASH_DIGEST_LENGTH),
static_cast<FwAssertArgType>(bufferSize));
ExternalSerializeBuffer serialBuffer(dataHashAddr, HASH_DIGEST_LENGTH);
hash.resetSer();
const Fw::SerializeStatus status = hash.copyRaw(serialBuffer, HASH_DIGEST_LENGTH);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
}
void DpContainer::updateDataHash() {
this->setDataHash(this->computeDataHash());
}
Success::T DpContainer::checkDataHash(Utils::HashBuffer& storedHash, Utils::HashBuffer& computedHash) const {
storedHash = this->getDataHash();
computedHash = this->computeDataHash();
return (computedHash == storedHash) ? Success::SUCCESS : Success::FAILURE;
}
// ----------------------------------------------------------------------
// Private member functions
// ----------------------------------------------------------------------
void DpContainer::initUserDataField() {
(void)::memset(this->m_userData, 0, sizeof this->m_userData);
}
} // namespace Fw
| cpp |
fprime | data/projects/fprime/Fw/Dp/test/util/DpContainerHeader.hpp | // ======================================================================
// \title DpContainerHeader.hpp
// \author bocchino
// \brief hpp file for DpContainer header test utility
// ======================================================================
#ifndef Fw_TestUtil_DpContainerHeader_HPP
#define Fw_TestUtil_DpContainerHeader_HPP
#include "gtest/gtest.h"
#include "FpConfig.hpp"
#include "Fw/Com/ComPacket.hpp"
#include "Fw/Dp/DpContainer.hpp"
#define DP_CONTAINER_HEADER_ASSERT_MSG(actual, expected) \
<< file << ":" << line << "\n" \
<< " Actual value is " << actual << "\n" \
<< " Expected value is " << expected
#define DP_CONTAINER_HEADER_ASSERT_EQ(actual, expected) \
ASSERT_EQ(actual, expected) DP_CONTAINER_HEADER_ASSERT_MSG(actual, expected)
#define DP_CONTAINER_HEADER_ASSERT_GE(actual, expected) \
ASSERT_GE(actual, expected) DP_CONTAINER_HEADER_ASSERT_MSG(actual, expected)
namespace Fw {
namespace TestUtil {
//! A container packet header for testing
struct DpContainerHeader {
DpContainerHeader() : m_id(0), m_priority(0), m_timeTag(), m_procTypes(0), m_dpState(), m_dataSize(0) {}
//! Move the buffer deserialization to the specified offset
static void moveDeserToOffset(const char* const file, //!< The call site file name
const U32 line, //!< The call site line number
Buffer& buffer, //!< The buffer
FwSizeType offset //!< The offset
) {
Fw::SerializeBufferBase& serializeRepr = buffer.getSerializeRepr();
// Reset deserialization
Fw::SerializeStatus status = serializeRepr.setBuffLen(buffer.getSize());
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
status = serializeRepr.moveDeserToOffset(offset);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
}
//! Deserialize a header from a packet buffer
//! Check that the serialization succeeded at every step
//! Check the header hash and the data hash
void deserialize(const char* const file, //!< The call site file name
const U32 line, //!< The call site line number
Fw::Buffer& buffer //!< The packet buffer
) {
Fw::SerializeBufferBase& serializeRepr = buffer.getSerializeRepr();
// Deserialize the packet descriptor
FwPacketDescriptorType packetDescriptor = Fw::ComPacket::FW_PACKET_UNKNOWN;
// Deserialize the packet descriptor
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::PACKET_DESCRIPTOR_OFFSET);
Fw::SerializeStatus status = serializeRepr.deserialize(packetDescriptor);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
DP_CONTAINER_HEADER_ASSERT_EQ(packetDescriptor, Fw::ComPacket::FW_PACKET_DP);
// Deserialize the container id
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::ID_OFFSET);
status = serializeRepr.deserialize(this->m_id);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
// Deserialize the priority
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::PRIORITY_OFFSET);
status = serializeRepr.deserialize(this->m_priority);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
// Deserialize the time tag
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::TIME_TAG_OFFSET);
status = serializeRepr.deserialize(this->m_timeTag);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
// Deserialize the processing type
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::PROC_TYPES_OFFSET);
status = serializeRepr.deserialize(this->m_procTypes);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
// Deserialize the user data
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::USER_DATA_OFFSET);
NATIVE_UINT_TYPE size = sizeof this->m_userData;
const bool omitLength = true;
status = serializeRepr.deserialize(this->m_userData, size, omitLength);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
DP_CONTAINER_HEADER_ASSERT_EQ(size, sizeof this->m_userData);
// Deserialize the data product state
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::DP_STATE_OFFSET);
status = serializeRepr.deserialize(this->m_dpState);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
// Deserialize the data size
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::Header::DATA_SIZE_OFFSET);
status = serializeRepr.deserializeSize(this->m_dataSize);
DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
// After deserializing time, the deserialization index should be at
// the header hash offset
checkDeserialAtOffset(serializeRepr, DpContainer::HEADER_HASH_OFFSET);
// Check the header hash
checkHeaderHash(file, line, buffer);
// Check the data hash
this->checkDataHash(file, line, buffer);
// Move the deserialization pointer to the data offset
DpContainerHeader::moveDeserToOffset(file, line, buffer, DpContainer::DATA_OFFSET);
}
//! Check the header hash
static void checkHeaderHash(const char* const file, //!< The call site file name
const U32 line, //!< The call site line number
Fw::Buffer& buffer //!< The packet buffer
) {
Utils::HashBuffer computedHashBuffer;
U8* const buffAddr = buffer.getData();
Utils::Hash::hash(buffAddr, DpContainer::Header::SIZE, computedHashBuffer);
Utils::HashBuffer storedHashBuffer(&buffAddr[DpContainer::HEADER_HASH_OFFSET], HASH_DIGEST_LENGTH);
DP_CONTAINER_HEADER_ASSERT_EQ(computedHashBuffer, storedHashBuffer);
}
//! Check the data hash
void checkDataHash(const char* const file, //!< The call site file name
const U32 line, //!< The call site line number
Fw::Buffer& buffer //!< The packet buffer
) {
Utils::HashBuffer computedHashBuffer;
U8* const buffAddrBase = buffer.getData();
U8* const dataAddr = &buffAddrBase[DpContainer::DATA_OFFSET];
Utils::Hash::hash(dataAddr, static_cast<U32>(this->m_dataSize), computedHashBuffer);
DpContainer container(this->m_id, buffer);
container.setDataSize(this->m_dataSize);
const FwSizeType dataHashOffset = container.getDataHashOffset();
Utils::HashBuffer storedHashBuffer(&buffAddrBase[dataHashOffset], HASH_DIGEST_LENGTH);
DP_CONTAINER_HEADER_ASSERT_EQ(computedHashBuffer, storedHashBuffer);
}
//! Check a packet header against a buffer
void check(const char* const file, //!< The call site file name
const U32 line, //!< The call site line number
const Fw::Buffer& buffer, //!< The buffer
FwDpIdType id, //!< The expected id
FwDpPriorityType priority, //!< The expected priority
const Fw::Time& timeTag, //!< The expected time tag
DpCfg::ProcType::SerialType procTypes, //!< The expected processing types
const DpContainer::Header::UserData& userData, //!< The expected user data
DpState dpState, //!< The expected dp state
FwSizeType dataSize //!< The expected data size
) const {
// Check the buffer size
const FwSizeType bufferSize = buffer.getSize();
const FwSizeType minBufferSize = Fw::DpContainer::MIN_PACKET_SIZE;
DP_CONTAINER_HEADER_ASSERT_GE(bufferSize, minBufferSize);
// Check the container id
DP_CONTAINER_HEADER_ASSERT_EQ(this->m_id, id);
// Check the priority
DP_CONTAINER_HEADER_ASSERT_EQ(this->m_priority, priority);
// Check the time tag
DP_CONTAINER_HEADER_ASSERT_EQ(this->m_timeTag, timeTag);
// Check the deserialized processing types
DP_CONTAINER_HEADER_ASSERT_EQ(this->m_procTypes, procTypes);
// Check the user data
for (FwSizeType i = 0; i < DpCfg::CONTAINER_USER_DATA_SIZE; ++i) {
DP_CONTAINER_HEADER_ASSERT_EQ(this->m_userData[i], userData[i]);
}
// Check the deserialized data product state
DP_CONTAINER_HEADER_ASSERT_EQ(this->m_dpState, dpState);
// Check the data size
DP_CONTAINER_HEADER_ASSERT_EQ(this->m_dataSize, dataSize);
}
//! Check that the serialize repr is at the specified deserialization offset
static void checkDeserialAtOffset(SerializeBufferBase& serialRepr, //!< The serialize repr
FwSizeType offset //!< The offset
) {
const U8* buffAddr = serialRepr.getBuffAddr();
const U8* buffAddrLeft = serialRepr.getBuffAddrLeft();
ASSERT_EQ(buffAddrLeft, &buffAddr[offset]);
}
//! The container id
FwDpIdType m_id;
//! The priority
FwDpPriorityType m_priority;
//! The time tag
Time m_timeTag;
//! The processing types
DpCfg::ProcType::SerialType m_procTypes;
//! The user data
U8 m_userData[DpCfg::CONTAINER_USER_DATA_SIZE];
//! The data product state
DpState m_dpState;
//! The data size
FwSizeType m_dataSize;
};
} // namespace TestUtil
} // end namespace Fw
#endif
| hpp |
fprime | data/projects/fprime/Fw/Dp/test/ut/TestMain.cpp | // ----------------------------------------------------------------------
// TestMain.cpp
// ----------------------------------------------------------------------
#include <cstring>
#include <limits>
#include "gtest/gtest.h"
#include "Fw/Dp/DpContainer.hpp"
#include "Fw/Dp/test/util/DpContainerHeader.hpp"
#include "Fw/Test/UnitTest.hpp"
#include "STest/Pick/Pick.hpp"
#include "STest/Random/Random.hpp"
using namespace Fw;
constexpr FwSizeType DATA_SIZE = 100;
constexpr FwSizeType PACKET_SIZE = DpContainer::getPacketSizeForDataSize(DATA_SIZE);
U8 bufferData[PACKET_SIZE];
DpContainer::Header::UserData userData;
void checkHeader(FwDpIdType id, Fw::Buffer& buffer, DpContainer& container) {
// Check the packet size
const FwSizeType expectedPacketSize = Fw::DpContainer::MIN_PACKET_SIZE;
ASSERT_EQ(container.getPacketSize(), expectedPacketSize);
// Set the priority
const FwDpPriorityType priority = STest::Pick::lowerUpper(0, std::numeric_limits<FwDpPriorityType>::max());
container.setPriority(priority);
// Set the time tag
const U32 seconds = STest::Pick::any();
const U32 useconds = STest::Pick::startLength(0, 1000000);
Fw::Time timeTag(seconds, useconds);
container.setTimeTag(timeTag);
// Set the processing types
const FwSizeType numProcTypeStates = 1 << DpCfg::ProcType::NUM_CONSTANTS;
const DpCfg::ProcType::SerialType procTypes = STest::Pick::startLength(0, numProcTypeStates);
container.setProcTypes(procTypes);
// Set the user data
for (U8& data : userData) {
data = static_cast<U8>(STest::Pick::any());
}
FW_ASSERT(sizeof userData == sizeof container.m_userData);
(void)::memcpy(container.m_userData, userData, sizeof container.m_userData);
// Set the DP state
const DpState dpState(static_cast<DpState::T>(STest::Pick::startLength(0, DpState::NUM_CONSTANTS)));
container.setDpState(dpState);
// Set the data size
container.setDataSize(DATA_SIZE);
// Test serialization: Serialize the header
container.serializeHeader();
TestUtil::DpContainerHeader header;
// Update the data hash
container.updateDataHash();
// Deserialize the header and check the hashes
header.deserialize(__FILE__, __LINE__, buffer);
// Check the deserialized header fields
header.check(__FILE__, __LINE__, buffer, id, priority, timeTag, procTypes, userData, dpState, DATA_SIZE);
// Test deserialization: Deserialize the header into a new container
DpContainer deserContainer;
deserContainer.setBuffer(container.getBuffer());
const Fw::SerializeStatus serialStatus = deserContainer.deserializeHeader();
ASSERT_EQ(serialStatus, Fw::FW_SERIALIZE_OK);
// Clear out the header in the buffer
FW_ASSERT(buffer.isValid());
::memset(buffer.getData(), 0, DpContainer::Header::SIZE);
// Serialize the header from the new container
deserContainer.serializeHeader();
// Deserialize and check the header
header.deserialize(__FILE__, __LINE__, buffer);
header.check(__FILE__, __LINE__, buffer, id, priority, timeTag, procTypes, userData, dpState, DATA_SIZE);
// Test the flight code that checks the hashes
Utils::HashBuffer storedHash;
Utils::HashBuffer computedHash;
Fw::Success status = deserContainer.checkHeaderHash(storedHash, computedHash);
ASSERT_EQ(status, Fw::Success::SUCCESS);
ASSERT_EQ(storedHash, computedHash);
status = deserContainer.checkDataHash(storedHash, computedHash);
ASSERT_EQ(status, Fw::Success::SUCCESS);
ASSERT_EQ(storedHash, computedHash);
}
void checkBuffers(DpContainer& container, FwSizeType bufferSize) {
// Check the packet buffer
ASSERT_EQ(container.m_buffer.getSize(), bufferSize);
// Check the data buffer
U8* const buffPtr = container.m_buffer.getData();
U8* const dataPtr = &buffPtr[Fw::DpContainer::DATA_OFFSET];
const FwSizeType dataCapacity = container.m_buffer.getSize() - Fw::DpContainer::MIN_PACKET_SIZE;
ASSERT_EQ(container.m_dataBuffer.getBuffAddr(), dataPtr);
ASSERT_EQ(container.m_dataBuffer.getBuffCapacity(), dataCapacity);
}
void fillWithData(Fw::Buffer& buffer) {
U8* const buffAddrBase = buffer.getData();
U8* const dataAddr = &buffAddrBase[DpContainer::DATA_OFFSET];
for (FwSizeType i = 0; i < DATA_SIZE; i++) {
dataAddr[i] = static_cast<U8>(STest::Pick::any());
}
}
TEST(Header, BufferInConstructor) {
COMMENT("Test header serialization with buffer in constructor");
// Create a buffer
Fw::Buffer buffer(bufferData, sizeof bufferData);
// Fill with data
fillWithData(buffer);
// Use the buffer to create a container
const FwDpIdType id = STest::Pick::lowerUpper(0, std::numeric_limits<FwDpIdType>::max());
DpContainer container(id, buffer);
// Check the header
checkHeader(id, buffer, container);
// Check the buffers
checkBuffers(container, sizeof bufferData);
// Perturb the header hash
Utils::HashBuffer goodHash = container.getHeaderHash();
Utils::HashBuffer badHash = goodHash;
++(badHash.getBuffAddr()[0]);
container.setHeaderHash(badHash);
// Check that the hashes don't match
Utils::HashBuffer storedHash;
Utils::HashBuffer computedHash;
Fw::Success status = container.checkHeaderHash(storedHash, computedHash);
ASSERT_EQ(status, Fw::Success::FAILURE);
ASSERT_EQ(storedHash, badHash);
ASSERT_EQ(computedHash, goodHash);
// Perturb the data hash
goodHash = container.getDataHash();
badHash = goodHash;
++(badHash.getBuffAddr()[0]);
container.setDataHash(badHash);
// Check that the hashes don't match
status = container.checkDataHash(storedHash, computedHash);
ASSERT_EQ(status, Fw::Success::FAILURE);
ASSERT_EQ(storedHash, badHash);
ASSERT_EQ(computedHash, goodHash);
}
TEST(Header, BufferSet) {
COMMENT("Test header serialization with buffer set");
// Create a buffer
Fw::Buffer buffer(bufferData, sizeof bufferData);
// Fill with data
fillWithData(buffer);
// Use the buffer to create a container
const FwDpIdType id = STest::Pick::lowerUpper(0, std::numeric_limits<FwDpIdType>::max());
DpContainer container;
container.setId(id);
container.setBuffer(buffer);
// Check the header
checkHeader(id, buffer, container);
// Check the buffers
checkBuffers(container, sizeof bufferData);
}
TEST(Header, BadPacketDescriptor) {
COMMENT("Test header serialization with bad packet descriptor");
// Create a buffer
Fw::Buffer buffer(bufferData, sizeof bufferData);
// Set the packet descriptor to a bad value
Fw::SerializeBufferBase& serialRepr = buffer.getSerializeRepr();
const FwPacketDescriptorType badPacketDescriptor = Fw::ComPacket::FW_PACKET_DP + 1;
Fw::SerializeStatus status = serialRepr.serialize(badPacketDescriptor);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
// Use the buffer to create a container
DpContainer container;
container.setBuffer(buffer);
// Deserialize the header
const Fw::SerializeStatus serialStatus = container.deserializeHeader();
// Check the error
ASSERT_EQ(serialStatus, Fw::FW_SERIALIZE_FORMAT_ERROR);
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
STest::Random::seed();
return RUN_ALL_TESTS();
}
| cpp |
fprime | data/projects/fprime/Fw/Tlm/TlmString.cpp | #include <Fw/Tlm/TlmString.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
TlmString::TlmString(const char* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
TlmString::TlmString(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
TlmString::TlmString(const TlmString& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
TlmString::TlmString() : StringBase() {
this->m_buf[0] = 0;
}
TlmString& TlmString::operator=(const TlmString& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
TlmString& TlmString::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
TlmString& TlmString::operator=(const char* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
TlmString::~TlmString() {
}
const char* TlmString::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE TlmString::getCapacity() const {
return FW_TLM_STRING_MAX_SIZE;
}
SerializeStatus TlmString::serialize(SerializeBufferBase& buffer) const {
return this->serialize(buffer, this->length());
}
SerializeStatus TlmString::serialize(SerializeBufferBase& buffer, NATIVE_UINT_TYPE maxLength) const {
NATIVE_INT_TYPE len = FW_MIN(maxLength,this->length());
#if FW_AMPCS_COMPATIBLE
// serialize 8-bit size with null terminator removed
U8 strSize = len - 1;
SerializeStatus stat = buffer.serialize(strSize);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
return buffer.serialize(reinterpret_cast<const U8*>(this->toChar()),strSize, true);
#else
return buffer.serialize(reinterpret_cast<const U8*>(this->toChar()),len);
#endif
}
SerializeStatus TlmString::deserialize(SerializeBufferBase& buffer) {
NATIVE_UINT_TYPE maxSize = this->getCapacity() - 1;
CHAR* raw = const_cast<CHAR*>(this->toChar());
#if FW_AMPCS_COMPATIBLE
// AMPCS encodes 8-bit string size
U8 strSize;
SerializeStatus stat = buffer.deserialize(strSize);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
strSize = FW_MIN(maxSize,strSize);
stat = buffer.deserialize(reinterpret_cast<U8*>(raw),strSize,true);
// AMPCS Strings not null terminated
if(strSize < maxSize) {
raw[strSize] = 0;
}
#else
SerializeStatus stat = buffer.deserialize(reinterpret_cast<U8*>(raw),maxSize);
#endif
// Null terminate deserialized string
raw[maxSize] = 0;
return stat;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Tlm/TlmBuffer.cpp | #include <Fw/Tlm/TlmBuffer.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
TlmBuffer::TlmBuffer(const U8 *args, NATIVE_UINT_TYPE size) {
SerializeStatus stat = SerializeBufferBase::setBuff(args,size);
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
TlmBuffer::TlmBuffer() {
}
TlmBuffer::~TlmBuffer() {
}
TlmBuffer::TlmBuffer(const TlmBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
}
TlmBuffer& TlmBuffer::operator=(const TlmBuffer& other) {
if(this == &other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
return *this;
}
NATIVE_UINT_TYPE TlmBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* TlmBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* TlmBuffer::getBuffAddr() {
return this->m_bufferData;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Tlm/TlmPacket.cpp | /*
* TlmPacket.cpp
*
* Created on: May 24, 2014
* Author: Timothy Canham
*/
#include <Fw/Types/Serializable.hpp>
#include <Fw/Tlm/TlmPacket.hpp>
#include <Fw/Types/Assert.hpp>
namespace Fw {
TlmPacket::TlmPacket() : m_numEntries(0) {
this->m_type = FW_PACKET_TELEM;
this->m_tlmBuffer.resetSer();
}
TlmPacket::~TlmPacket() {
}
SerializeStatus TlmPacket::resetPktSer() {
this->m_tlmBuffer.resetSer();
// reset packet count
this->m_numEntries = 0;
// make sure packet type is correct before serializing. It should
// never be anything but FW_PACKET_TELEM, so assert.
FW_ASSERT(FW_PACKET_TELEM == this->m_type,this->m_type);
// serialize descriptor
// The function serializeBase inherited from ComPacket converts this->m_type
// to type FwPacketDescriptorType and serializes the result into this->m_tlmBuffer.
return this->serializeBase(this->m_tlmBuffer);
}
SerializeStatus TlmPacket::resetPktDeser() {
this->m_tlmBuffer.resetDeser();
// deserialize descriptor
// The function deserializeBase inherited from ComPacket deserializes a
// value of type FwPacketDescriptorType from this->m_tlmBuffer and stores it
// into this->m_type.
Fw::SerializeStatus stat = this->deserializeBase(this->m_tlmBuffer);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// make sure that this->m_tlmBuffer stores a telemetry packet
if (this->m_type != FW_PACKET_TELEM) {
return Fw::FW_DESERIALIZE_TYPE_MISMATCH;
}
return Fw::FW_SERIALIZE_OK;
}
NATIVE_UINT_TYPE TlmPacket::getNumEntries() {
return this->m_numEntries;
}
Fw::ComBuffer& TlmPacket::getBuffer() {
return this->m_tlmBuffer;
}
void TlmPacket::setBuffer(Fw::ComBuffer& buffer) {
this->m_tlmBuffer = buffer;
}
SerializeStatus TlmPacket::addValue(FwChanIdType id, Time& timeTag, TlmBuffer& buffer) {
// check to make sure there is room for all the fields
NATIVE_UINT_TYPE left = this->m_tlmBuffer.getBuffCapacity()-this->m_tlmBuffer.getBuffLength();
if (
(sizeof(FwChanIdType) + Time::SERIALIZED_SIZE + buffer.getBuffLength()) > left
) {
return Fw::FW_SERIALIZE_NO_ROOM_LEFT;
}
// serialize items into buffer
// id
SerializeStatus stat = this->m_tlmBuffer.serialize(id);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// time tag
stat = this->m_tlmBuffer.serialize(timeTag);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// telemetry buffer
stat = this->m_tlmBuffer.serialize(buffer.getBuffAddr(),buffer.getBuffLength(),true);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// increment number of packets
this->m_numEntries++;
return Fw::FW_SERIALIZE_OK;
}
// extract telemetry value
SerializeStatus TlmPacket::extractValue(FwChanIdType &id, Time& timeTag, TlmBuffer& buffer, NATIVE_UINT_TYPE bufferSize) {
// deserialize items out of buffer
// id
SerializeStatus stat = this->m_tlmBuffer.deserialize(id);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// time tag
stat = this->m_tlmBuffer.deserialize(timeTag);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// telemetry buffer
stat = this->m_tlmBuffer.deserialize(buffer.getBuffAddr(),bufferSize,true);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// set buffer size
stat = buffer.setBuffLen(bufferSize);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
return Fw::FW_SERIALIZE_OK;
}
SerializeStatus TlmPacket::serialize(SerializeBufferBase& buffer) const {
// serialize the number of packets
SerializeStatus stat = buffer.serialize(this->m_numEntries);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// Serialize the ComBuffer
return buffer.serialize(this->m_tlmBuffer.getBuffAddr(),m_tlmBuffer.getBuffLength(),true);
}
SerializeStatus TlmPacket::deserialize(SerializeBufferBase& buffer) {
// deserialize the number of packets
SerializeStatus stat = buffer.deserialize(this->m_numEntries);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// deserialize the channel value entry buffers
NATIVE_UINT_TYPE size = buffer.getBuffLeft();
stat = buffer.deserialize(this->m_tlmBuffer.getBuffAddr(),size,true);
if (stat == FW_SERIALIZE_OK) {
// Shouldn't fail
stat = this->m_tlmBuffer.setBuffLen(size);
FW_ASSERT(stat == FW_SERIALIZE_OK,static_cast<NATIVE_INT_TYPE>(stat));
}
return stat;
}
} /* namespace Fw */
| cpp |
fprime | data/projects/fprime/Fw/Tlm/TlmPacket.hpp | /*
* TlmPacket.hpp
*
* Created on: May 24, 2014
* Author: Timothy Canham
*/
#ifndef TLMPACKET_HPP_
#define TLMPACKET_HPP_
#include <Fw/Com/ComPacket.hpp>
#include <Fw/Tlm/TlmBuffer.hpp>
#include <Fw/Com/ComBuffer.hpp>
#include <Fw/Time/Time.hpp>
namespace Fw {
class TlmPacket : public ComPacket {
public:
//! Constructor
TlmPacket();
//! Destructor
virtual ~TlmPacket();
//! Serialize the packet before sending. For use internally in software. To send to the ground, use getBuffer() below.
SerializeStatus serialize(SerializeBufferBase& buffer) const; //!< serialize contents
//! Deserialize the packet. For use internally in software. To extract channels, use setBuffer() and extractValue() below. This is NOT typically used.
SerializeStatus deserialize(SerializeBufferBase& buffer);
//! Add telemetry value to buffer.
SerializeStatus addValue(FwChanIdType id, Time& timeTag, TlmBuffer& buffer);
//! extract telemetry value - since there are potentially multiple channel values in the packet,
//! the size of the entry must be known
SerializeStatus extractValue(FwChanIdType &id, Time& timeTag, TlmBuffer& buffer, NATIVE_UINT_TYPE bufferSize);
//! Reset serialization of values. This should be done when starting to accumulate a new set of values.
SerializeStatus resetPktSer();
//! Reset deserialization. This should be done before extracting values.
SerializeStatus resetPktDeser();
//! get buffer to send to the ground
Fw::ComBuffer& getBuffer();
//! set the internal buffer for deserializing values
void setBuffer(Fw::ComBuffer& buffer);
//! get the number of packets added via addValue()
NATIVE_UINT_TYPE getNumEntries();
PRIVATE:
ComBuffer m_tlmBuffer; //!< serialized data
NATIVE_UINT_TYPE m_numEntries; //!< number of entries stored during addValue()
};
} /* namespace Fw */
#endif /* TLMPACKET_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Tlm/TlmString.hpp | #ifndef FW_TLM_STRING_TYPE_HPP
#define FW_TLM_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class TlmString : public Fw::StringBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_TLM_STR,
SERIALIZED_SIZE = FW_TLM_STRING_MAX_SIZE + sizeof(FwBuffSizeType) // size of buffer + storage of size word
};
TlmString();
TlmString(const TlmString& src); //!< TlmString string constructor
TlmString(const StringBase& src); //!< other string constructor
TlmString(const char* src); //!< char* source constructor
TlmString& operator=(const TlmString& other); //!< assignment operator
TlmString& operator=(const StringBase& other); //!< other string assignment operator
TlmString& operator=(const char* other); //!< char* assignment operator
~TlmString();
const char* toChar() const override;
NATIVE_UINT_TYPE getCapacity() const override;
SerializeStatus serialize(SerializeBufferBase& buffer) const override; //!< serialization function
SerializeStatus serialize(SerializeBufferBase& buffer, NATIVE_UINT_TYPE maxLen) const override; //!< serialization function
SerializeStatus deserialize(SerializeBufferBase& buffer) override; //!< deserialization function
private:
char m_buf[FW_TLM_STRING_MAX_SIZE];
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Tlm/TlmBuffer.hpp | /*
* TlmBuffer.hpp
*
* Author: tcanham
*/
/*
* Description:
* This object contains the TlmBuffer type, used for storing telemetry
*/
#ifndef FW_TLM_BUFFER_HPP
#define FW_TLM_BUFFER_HPP
#include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class TlmBuffer : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_TLM_BUFF,
SERIALIZED_SIZE = FW_TLM_BUFFER_MAX_SIZE + sizeof(FwBuffSizeType)
};
TlmBuffer(const U8 *args, NATIVE_UINT_TYPE size);
TlmBuffer();
TlmBuffer(const TlmBuffer& other);
virtual ~TlmBuffer();
TlmBuffer& operator=(const TlmBuffer& other);
NATIVE_UINT_TYPE getBuffCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;
PRIVATE:
U8 m_bufferData[FW_TLM_BUFFER_MAX_SIZE]; // command argument buffer
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Tlm/test/ut/TlmTest.cpp | #include <gtest/gtest.h>
#include <Fw/Tlm/TlmPacket.hpp>
#include <Fw/Com/ComBuffer.hpp>
TEST(FwTlmTest,TlmPacketSerializeSingle) {
// Serialize data
Fw::TlmPacket pktIn;
Fw::TlmBuffer buffIn;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,buffIn.serialize(static_cast<U32>(12)));
Fw::Time timeIn(TB_WORKSTATION_TIME,10,11);
U32 id = 10;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktIn.resetPktSer());
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktIn.addValue(id,timeIn,buffIn));
Fw::ComBuffer comBuff = pktIn.getBuffer();
// Deserialize data
Fw::TlmPacket pktOut;
Fw::TlmBuffer buffOut;
Fw::Time timeOut(TB_WORKSTATION_TIME,10,11);
pktOut.setBuffer(comBuff);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktOut.resetPktDeser());
// extract values
id = 0;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktOut.extractValue(id,timeOut,buffOut,sizeof(U32)));
ASSERT_EQ(10u,id);
U32 valOut = 0;
buffOut.resetDeser();
ASSERT_EQ(Fw::FW_SERIALIZE_OK,buffOut.deserialize(valOut));
ASSERT_EQ(valOut,12u);
}
TEST(FwTlmTest,TlmPacketSerializeFill) {
// compute a single entry size assuming for the test that the value of the telemetry channel
// is a U32
static const NATIVE_UINT_TYPE SIZE_OF_ENTRY = sizeof(FwChanIdType) + Fw::Time::SERIALIZED_SIZE + sizeof(U32);
// compute the number of entries that should fit - will equal rounded down value of
// ComBuffer size - size of telemetry packet id / size of an entry
static const NATIVE_UINT_TYPE NUM_ENTRIES = (FW_COM_BUFFER_MAX_SIZE - sizeof(FwPacketDescriptorType))/SIZE_OF_ENTRY;
Fw::TlmPacket pktIn;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktIn.resetPktSer());
// fill a telemetry packet
for (NATIVE_UINT_TYPE entry = 0; entry < NUM_ENTRIES; entry++) {
// Serialize data
Fw::TlmBuffer buffIn;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,buffIn.serialize(static_cast<U32>(entry)));
Fw::Time timeIn(TB_WORKSTATION_TIME,entry+1,entry+2);
U32 id = NUM_ENTRIES-entry;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktIn.addValue(id,timeIn,buffIn));
}
// Next one should fail because it's full
{
Fw::TlmBuffer buffIn;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,buffIn.serialize(static_cast<U32>(12)));
Fw::Time timeIn(TB_WORKSTATION_TIME,10,11);
U32 id = 10;
ASSERT_EQ(Fw::FW_SERIALIZE_NO_ROOM_LEFT,pktIn.addValue(id,timeIn,buffIn));
}
// Create a new packet from the ComBuffer
Fw::ComBuffer comBuff = pktIn.getBuffer();
Fw::TlmPacket pktOut;
pktOut.setBuffer(comBuff);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktOut.resetPktDeser());
// empty the packet of entries
for (NATIVE_UINT_TYPE entry = 0; entry < NUM_ENTRIES; entry++) {
// Deserialize data
Fw::TlmBuffer buffOut;
Fw::Time timeOut;
U32 id = 0;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,pktOut.extractValue(id,timeOut,buffOut,sizeof(U32)));
ASSERT_EQ(NUM_ENTRIES-entry,id);
Fw::Time expTime(TB_WORKSTATION_TIME,entry+1,entry+2);
ASSERT_EQ(expTime,timeOut);
U32 val = 0;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,buffOut.deserialize(val));
ASSERT_EQ(entry,val);
}
// try to extract one more, should fail
{
Fw::TlmBuffer buffOut;
Fw::Time timeOut;
U32 id = 0;
ASSERT_EQ(Fw::FW_DESERIALIZE_BUFFER_EMPTY,pktOut.extractValue(id,timeOut,buffOut,sizeof(U32)));
}
}
int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| cpp |
fprime | data/projects/fprime/Fw/Types/MemAllocator.cpp | /**
* \file
* \author
* \brief
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#include <Fw/Types/MemAllocator.hpp>
namespace Fw {
MemAllocator::MemAllocator() {
}
MemAllocator::~MemAllocator() {
}
} /* namespace Fw */
| cpp |
fprime | data/projects/fprime/Fw/Types/ObjectName.hpp | #ifndef FW_OBJECT_NAME_TYPE_HPP
#define FW_OBJECT_NAME_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class ObjectName : public Fw::StringBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_OBJECT_NAME, //!< typeid for string type
STRING_SIZE = FW_OBJ_NAME_MAX_SIZE, //!< Storage for string
SERIALIZED_SIZE = STRING_SIZE + sizeof(FwBuffSizeType) //!< Serialized size is size of buffer + size field
};
explicit ObjectName(const CHAR* src); //!< char* source constructor
explicit ObjectName(const StringBase& src); //!< StringBase string constructor
ObjectName(const ObjectName& src); //!< ObjectName string constructor
ObjectName(); //!< default constructor
ObjectName& operator=(const ObjectName& other); //!< assignment operator
ObjectName& operator=(const StringBase& other); //!< StringBase string assignment operator
ObjectName& operator=(const CHAR* other); //!< char* assignment operator
~ObjectName(); //!< destructor
const CHAR* toChar() const; //!< gets char buffer
NATIVE_UINT_TYPE getCapacity() const; //!< return buffer size
private:
CHAR m_buf[STRING_SIZE]; //!< storage for string data
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Types/CAssert.h | /*
* FwCAssert.hpp
*
* Created on: Jun 8, 2014
* Author: tcanham
*/
#ifndef FWCASSERT_HPP_
#define FWCASSERT_HPP_
#include <FpConfig.h>
#if FW_ASSERT_LEVEL == FW_NO_ASSERT
#define FW_CASSERT(...)
#else // ASSERT is defined
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
#define FILE_NAME_ARG NATIVE_UINT_TYPE
#define FW_CASSERT(cond) ((void)((cond) ? (0) : (CAssert0(ASSERT_FILE_ID, __LINE__))))
#else
#define FILE_NAME_ARG const CHAR*
#define FW_CASSERT(cond) ((void)((cond) ? (0) : (CAssert0((FILE_NAME_ARG)(__FILE__), __LINE__))))
#endif
I32 CAssert0(FILE_NAME_ARG file, U32 lineNo); //!< C assert function
I32 CAssert1(FILE_NAME_ARG file, U32 lineNo, NATIVE_INT_TYPE arg1); //!< C assert function 1
#endif // ASSERT is defined
#endif /* FWCASSERT_HPP_ */
| h |
fprime | data/projects/fprime/Fw/Types/BasicTypes.hpp | /**
* \file: BasicTypes.hpp
* \author mstarch
* \brief C++ header for working with basic fprime types
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*/
#include <limits>
// Use C linkage for the basic items
extern "C" {
#include "BasicTypes.h"
}
#ifndef FW_BASIC_TYPES_HPP
#define FW_BASIC_TYPES_HPP
// IEEE compliance checks must occur in C++ code
#if !defined(SKIP_FLOAT_IEEE_754_COMPLIANCE) || !SKIP_FLOAT_IEEE_754_COMPLIANCE
static_assert((std::numeric_limits<float>::is_iec559 == true) && (std::numeric_limits<float>::radix == 2) &&
(std::numeric_limits<float>::digits == 24) && (std::numeric_limits<float>::max_exponent == 128),
"The 32-bit floating point type does not conform to the IEEE-754 standard.");
#if FW_HAS_F64
static_assert((std::numeric_limits<double>::is_iec559 == true) && (std::numeric_limits<double>::radix == 2) &&
(std::numeric_limits<double>::digits == 53) && (std::numeric_limits<double>::max_exponent == 1024),
"The 64-bit floating point type does not conform to the IEEE-754 standard.");
#endif
#endif
#endif // End FW_BASIC_TYPES_HPP
| hpp |
fprime | data/projects/fprime/Fw/Types/ConstByteArray.hpp | // ======================================================================
// \title ConstByteArray.hpp
// \author bocchino
// \brief hpp file for ConstByteArray type
//
// \copyright
// Copyright (C) 2016 California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#ifndef Fw_ConstByteArray_HPP
#define Fw_ConstByteArray_HPP
#include <FpConfig.hpp>
namespace Fw {
//! \class ConstByteArray
//! \brief A variable-length byte array with constant access
//!
struct ConstByteArray {
// ----------------------------------------------------------------------
// Construction
// ----------------------------------------------------------------------
//! Construct a ConstByteArray
//!
ConstByteArray(
const U8 *const bytes, //!< Pointer to the bytes
const U32 size //!< The array size
) :
bytes(bytes),
size(size)
{
}
// ----------------------------------------------------------------------
// Data
// ----------------------------------------------------------------------
//! The bytes
const U8 *const bytes;
//! The size
const U32 size;
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Types/String.cpp | #include <Fw/Types/String.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
String::String(const char* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
String::String(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
String::String(const String& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
String::String() : StringBase() {
this->m_buf[0] = 0;
}
String& String::operator=(const String& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
String& String::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
String& String::operator=(const char* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
String::~String() {
}
const char* String::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE String::getCapacity() const {
return STRING_SIZE;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Types/EightyCharString.cpp | #include <Fw/Types/EightyCharString.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
EightyCharString::EightyCharString(const char* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
EightyCharString::EightyCharString(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
EightyCharString::EightyCharString(const EightyCharString& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
EightyCharString::EightyCharString() : StringBase() {
this->m_buf[0] = 0;
}
EightyCharString& EightyCharString::operator=(const EightyCharString& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
EightyCharString& EightyCharString::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
EightyCharString& EightyCharString::operator=(const char* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
EightyCharString::~EightyCharString() {
}
const char* EightyCharString::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE EightyCharString::getCapacity() const {
return STRING_SIZE;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Types/Assert.cpp | #include <FpConfig.hpp>
#include <Fw/Types/Assert.hpp>
#include <cassert>
#include <cstdio>
#define FW_ASSERT_DFL_MSG_LEN 256
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
#define fileIdFs "Assert: 0x%08" PRIx32 ":%" PRI_PlatformUIntType
#else
#define fileIdFs "Assert: \"%s:%" PRI_PlatformUIntType "\""
#endif
namespace Fw {
void defaultPrintAssert(const CHAR* msg) {
(void)fprintf(stderr,"%s\n", msg);
}
void defaultReportAssert
(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6,
CHAR* destBuffer,
NATIVE_INT_TYPE buffSize
) {
switch (numArgs) {
case 0:
(void) snprintf(destBuffer, buffSize, fileIdFs, file, lineNo);
break;
case 1:
(void) snprintf(
destBuffer,
buffSize,
fileIdFs " %" PRI_FwAssertArgType,
file,
lineNo,
arg1
);
break;
case 2:
(void) snprintf(
destBuffer,
buffSize,
fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType,
file,
lineNo,
arg1, arg2
);
break;
case 3:
(void) snprintf(
destBuffer,
buffSize,
fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
" %" PRI_FwAssertArgType,
file,
lineNo,
arg1, arg2, arg3
);
break;
case 4:
(void) snprintf(
destBuffer,
buffSize,
fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
" %" PRI_FwAssertArgType " %" PRI_FwAssertArgType,
file,
lineNo,
arg1, arg2, arg3, arg4);
break;
case 5:
(void) snprintf(
destBuffer,
buffSize,
fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
" %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
" %" PRI_FwAssertArgType,
file,
lineNo,
arg1, arg2, arg3, arg4, arg5
);
break;
case 6:
(void) snprintf(
destBuffer,
buffSize,
fileIdFs " %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
" %" PRI_FwAssertArgType " %" PRI_FwAssertArgType
" %" PRI_FwAssertArgType " %" PRI_FwAssertArgType,
file,
lineNo,
arg1, arg2, arg3, arg4, arg5, arg6
);
break;
default: // in an assert already, what can we do?
break;
}
// null terminate
destBuffer[buffSize-1] = 0;
}
void AssertHook::printAssert(const CHAR* msg) {
defaultPrintAssert(msg);
}
void AssertHook::reportAssert
(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6
)
{
CHAR destBuffer[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert
(
file,
lineNo,
numArgs,
arg1,
arg2,
arg3,
arg4,
arg5,
arg6,
destBuffer,
sizeof(destBuffer)
);
// print message
this->printAssert(destBuffer);
}
void AssertHook::doAssert() {
assert(0);
}
STATIC AssertHook* s_assertHook = nullptr;
void AssertHook::registerHook() {
this->previousHook = s_assertHook;
s_assertHook = this;
}
void AssertHook::deregisterHook() {
s_assertHook = this->previousHook;
}
// Default handler of SwAssert functions
NATIVE_INT_TYPE defaultSwAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6) {
if (nullptr == s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert(
file,
lineNo,
numArgs,
arg1,arg2,arg3,arg4,arg5,arg6,
assertMsg,sizeof(assertMsg));
defaultPrintAssert(assertMsg);
assert(0);
}
else {
s_assertHook->reportAssert(
file,
lineNo,
numArgs,
arg1,arg2,arg3,arg4,arg5,arg6);
s_assertHook->doAssert();
}
return 0;
}
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo) {
return defaultSwAssert(file, lineNo, 0, 0, 0, 0, 0, 0, 0);
}
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
NATIVE_UINT_TYPE lineNo) {
return defaultSwAssert(file, lineNo, 1, arg1, 0, 0, 0, 0, 0);
}
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
NATIVE_UINT_TYPE lineNo) {
return defaultSwAssert(file, lineNo, 2, arg1, arg2, 0, 0, 0, 0);
}
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
NATIVE_UINT_TYPE lineNo) {
return defaultSwAssert(file, lineNo, 3, arg1, arg2, arg3, 0, 0, 0);
}
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
NATIVE_UINT_TYPE lineNo) {
return defaultSwAssert(file, lineNo, 4, arg1, arg2, arg3, arg4, 0, 0);
}
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
NATIVE_UINT_TYPE lineNo) {
return defaultSwAssert(file, lineNo, 5, arg1, arg2, arg3, arg4, arg5, 0);
}
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6,
NATIVE_UINT_TYPE lineNo) {
return defaultSwAssert(file, lineNo, 6, arg1, arg2, arg3, arg4, arg5, arg6);
}
}
// define C asserts.
extern "C" {
NATIVE_INT_TYPE CAssert0(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo);
}
NATIVE_INT_TYPE CAssert0(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo) {
if (nullptr == Fw::s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
Fw::defaultReportAssert(
file,
lineNo,
0,
0,0,0,0,0,0,
assertMsg,sizeof(assertMsg));
}
else {
Fw::s_assertHook->reportAssert(
file,
lineNo,
0,
0,0,0,0,0,0);
Fw::s_assertHook->doAssert();
}
return 0;
}
| cpp |
fprime | data/projects/fprime/Fw/Types/InternalInterfaceString.cpp | #include <Fw/Types/InternalInterfaceString.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
InternalInterfaceString::InternalInterfaceString(const char* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
InternalInterfaceString::InternalInterfaceString(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
InternalInterfaceString::InternalInterfaceString(const InternalInterfaceString& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
InternalInterfaceString::InternalInterfaceString() : StringBase() {
this->m_buf[0] = 0;
}
InternalInterfaceString& InternalInterfaceString::operator=(const InternalInterfaceString& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
InternalInterfaceString& InternalInterfaceString::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
InternalInterfaceString& InternalInterfaceString::operator=(const char* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
InternalInterfaceString::~InternalInterfaceString() {
}
const char* InternalInterfaceString::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE InternalInterfaceString::getCapacity() const {
return FW_INTERNAL_INTERFACE_STRING_MAX_SIZE;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Types/MallocAllocator.hpp | /**
* \file
* \author T. Canham
* \brief A MemAllocator implementation class that uses malloc.
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#ifndef TYPES_MALLOCALLOCATOR_HPP_
#define TYPES_MALLOCALLOCATOR_HPP_
#include <Fw/Types/MemAllocator.hpp>
namespace Fw {
/*!
*
* This class is an implementation of the MemAllocator base class.
* It uses the heap as the memory source.
*
* Since it is heap space, the identifier is unused, and memory is never recoverable.
*
*/
class MallocAllocator: public MemAllocator {
public:
MallocAllocator();
virtual ~MallocAllocator();
//! Allocate memory
/*!
* \param identifier the memory segment identifier (not used)
* \param size the requested size (not changed)
* \param recoverable - flag to indicate the memory could be recoverable (always set to false)
* \return the pointer to memory. Zero if unable to allocate.
*/
void *allocate(
const NATIVE_UINT_TYPE identifier,
NATIVE_UINT_TYPE &size,
bool& recoverable);
//! Deallocate memory
/*!
* \param identifier the memory segment identifier (not used)
* \param ptr the pointer to memory returned by allocate()
*/
void deallocate(
const NATIVE_UINT_TYPE identifier,
void* ptr);
};
} /* namespace Fw */
#endif /* TYPES_MALLOCALLOCATOR_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Types/MmapAllocator.cpp | /**
* \file
* \author Gene Merewether
* \brief Implementation of mmap based allocator
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#include <Fw/Types/MmapAllocator.hpp>
#include <cstdlib>
#include <sys/mman.h>
#include <Fw/Types/Assert.hpp>
namespace Fw {
MmapAllocator::MmapAllocator() : m_length(0) {
}
MmapAllocator::~MmapAllocator() {
}
void *MmapAllocator::allocate(const NATIVE_UINT_TYPE identifier, NATIVE_UINT_TYPE &size, bool& recoverable) {
void* addr = mmap(nullptr, size, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (addr == MAP_FAILED) {
size = 0;
return nullptr;
}
this->m_length = size;
// mmap memory is never recoverable
recoverable = false;
return addr;
}
void MmapAllocator::deallocate(const NATIVE_UINT_TYPE identifier, void* ptr) {
if (this->m_length) {
int stat = munmap(ptr, this->m_length);
FW_ASSERT(stat == 0, stat);
}
}
} /* namespace Fw */
| cpp |
fprime | data/projects/fprime/Fw/Types/EightyCharString.hpp | #ifndef FW_EIGHTY_CHAR_STRING_TYPE_HPP
#define FW_EIGHTY_CHAR_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class EightyCharString : public Fw::StringBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_EIGHTY_CHAR_STRING, //!< typeid for string type
STRING_SIZE = 80, //!< Storage for string
SERIALIZED_SIZE = STRING_SIZE + sizeof(FwBuffSizeType) //!< Serialized size is size of buffer + size field
};
EightyCharString(const char* src); //!< char* source constructor
EightyCharString(const StringBase& src); //!< other string constructor
EightyCharString(const EightyCharString& src); //!< EightyCharString string constructor
EightyCharString(); //!< default constructor
EightyCharString& operator=(const EightyCharString& other); //!< assignment operator
EightyCharString& operator=(const StringBase& other); //!< other string assignment operator
EightyCharString& operator=(const char* other); //!< char* assignment operator
~EightyCharString(); //!< destructor
const char* toChar() const; //!< gets char buffer
NATIVE_UINT_TYPE getCapacity() const; //!< return buffer size
private:
char m_buf[STRING_SIZE]; //!< storage for string data
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Types/StringType.cpp | /**
* \file
* \author T. Canham
* \brief Implements ISF string base class
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#include <Fw/Types/StringType.hpp>
#include <Fw/Types/Assert.hpp>
#include <Fw/Types/StringUtils.hpp>
#include <cstring>
#include <cstdio>
#include <cstdarg>
namespace Fw {
StringBase::StringBase() {
}
StringBase::~StringBase() {
}
const CHAR* StringBase::operator+=(const CHAR* src) {
this->appendBuff(src, StringUtils::string_length(src, this->getCapacity()));
return this->toChar();
}
const StringBase& StringBase::operator+=(const StringBase& src) {
this->appendBuff(src.toChar(), src.length());
return *this;
}
bool StringBase::operator==(const StringBase& other) const {
SizeType len = this->length();
if (len != other.length()) {
return false;
} else {
return this->operator==(other.toChar());
}
}
bool StringBase::operator==(const CHAR* other) const {
const CHAR *const us = this->toChar();
if ((us == nullptr) or (other == nullptr)) {
return false;
}
const SizeType capacity = this->getCapacity();
const size_t result = strncmp(us, other, capacity);
return (result == 0);
}
void StringBase::format(const CHAR* formatString, ...) {
CHAR* us = const_cast<CHAR*>(this->toChar());
SizeType cap = this->getCapacity();
FW_ASSERT(us);
va_list args;
va_start(args, formatString);
(void) vsnprintf(us, cap, formatString, args);
va_end(args);
// null terminate
us[cap - 1] = 0;
}
bool StringBase::operator!=(const StringBase& other) const {
return !operator==(other);
}
bool StringBase::operator!=(const CHAR* other) const {
return !operator==(other);
}
#if FW_SERIALIZABLE_TO_STRING || BUILD_UT
void StringBase::toString(StringBase& text) const {
text = *this;
}
#endif
#ifdef BUILD_UT
std::ostream& operator<<(std::ostream& os, const StringBase& str)
{
os << str.toChar();
return os;
}
#endif
StringBase& StringBase::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(const_cast<char *>(this->toChar()), other.toChar(), this->getCapacity());
return *this;
}
// Copy constructor doesn't make sense in this virtual class as there is nothing to copy. Derived classes should
// call the empty constructor and then call their own copy function
StringBase& StringBase::operator=(const CHAR* other) { // lgtm[cpp/rule-of-two]
(void) Fw::StringUtils::string_copy(const_cast<char *>(this->toChar()), other, this->getCapacity());
return *this;
}
void StringBase::appendBuff(const CHAR* buff, SizeType size) {
const SizeType capacity = this->getCapacity();
const SizeType length = this->length();
FW_ASSERT(capacity > length, capacity, length);
// Subtract 1 to leave space for null terminator
SizeType remaining = capacity - length - 1;
if(size < remaining) {
remaining = size;
}
FW_ASSERT(remaining < capacity, remaining, capacity);
(void) strncat(const_cast<CHAR*>(this->toChar()), buff, remaining);
}
StringBase::SizeType StringBase::length() const {
return static_cast<SizeType>(StringUtils::string_length(this->toChar(),this->getCapacity()));
}
SerializeStatus StringBase::serialize(SerializeBufferBase& buffer) const {
return buffer.serialize(reinterpret_cast<const U8*>(this->toChar()),this->length());
}
SerializeStatus StringBase::serialize(SerializeBufferBase& buffer, SizeType maxLength) const {
SizeType len = FW_MIN(maxLength,this->length());
return buffer.serialize(reinterpret_cast<const U8*>(this->toChar()), len);
}
SerializeStatus StringBase::deserialize(SerializeBufferBase& buffer) {
SizeType maxSize = this->getCapacity() - 1;
CHAR* raw = const_cast<CHAR*>(this->toChar());
SerializeStatus stat = buffer.deserialize(reinterpret_cast<U8*>(raw),maxSize);
// Null terminate deserialized string
raw[maxSize] = 0;
return stat;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Types/InternalInterfaceString.hpp | #ifndef FW_INTERNAL_INTERFACE_STRING_TYPE_HPP
#define FW_INTERNAL_INTERFACE_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class InternalInterfaceString : public Fw::StringBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_INTERNAL_INTERFACE_STRING, //!< typeid for string type
SERIALIZED_SIZE = FW_INTERNAL_INTERFACE_STRING_MAX_SIZE + sizeof(FwBuffSizeType) //!< Serialized size is size of buffer + size field
};
InternalInterfaceString(const char* src); //!< char* source constructor
InternalInterfaceString(const StringBase& src); //!< other string constructor
InternalInterfaceString(const InternalInterfaceString& src); //!< other string constructor
InternalInterfaceString(); //!< default constructor
InternalInterfaceString& operator=(const InternalInterfaceString& other); //!< assignment operator
InternalInterfaceString& operator=(const StringBase& other); //!< other string assignment operator
InternalInterfaceString& operator=(const char* other); //!< char* assignment operator
~InternalInterfaceString(); //!< destructor
const char* toChar() const; //!< gets char buffer
NATIVE_UINT_TYPE getCapacity() const; //!< return buffer size
private:
char m_buf[FW_INTERNAL_INTERFACE_STRING_MAX_SIZE]; //!< storage for string data
};
}
#endif // FW_INTERNAL_INTERFACE_STRING_TYPE_HPP
| hpp |
fprime | data/projects/fprime/Fw/Types/MallocAllocator.cpp | /**
* \file
* \author T. Canham
* \brief Implementation of malloc based allocator
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#include <Fw/Types/MallocAllocator.hpp>
#include <cstdlib>
namespace Fw {
MallocAllocator::MallocAllocator() {
}
MallocAllocator::~MallocAllocator() {
}
void *MallocAllocator::allocate(const NATIVE_UINT_TYPE identifier, NATIVE_UINT_TYPE &size, bool& recoverable) {
// don't use identifier
// heap memory is never recoverable
recoverable = false;
void *mem = ::malloc(size);
if (nullptr == mem) {
size = 0; // set to zero if can't get memory
}
return mem;
}
void MallocAllocator::deallocate(const NATIVE_UINT_TYPE identifier, void* ptr) {
::free(ptr);
}
} /* namespace Fw */
| cpp |
fprime | data/projects/fprime/Fw/Types/MmapAllocator.hpp | /**
* \file
* \author Gene Merewether
* \brief A MemAllocator implementation class that uses mmap.
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#ifndef TYPES_MMAPALLOCATOR_HPP_
#define TYPES_MMAPALLOCATOR_HPP_
#include <Fw/Types/MemAllocator.hpp>
namespace Fw {
//! Fw::MmapAllocator is an implementation of the Fw::MemAllocator interface that back memory with a read and write
//! capable anonymous memory mapped region. This class is currently not useful for mapping to a file.
class MmapAllocator: public MemAllocator {
public:
//! Constructor with no arguments
//!
MmapAllocator();
//! Destructor with no arguments
virtual ~MmapAllocator();
//! Allocate memory using the mmap allocator
//! \param identifier: identifier to use with allocation
//! \param size: size of memory to be allocated
//! \param recoverable: (output) is this memory recoverable after a reset. Always false for mmap.
void *allocate(const NATIVE_UINT_TYPE identifier, NATIVE_UINT_TYPE &size, bool& recoverable);
//! Deallocation of memory using the mmap allocator
//! \param identifier: identifier used at allocation
//! \param ptr: pointer to memory being deallocated
void deallocate(const NATIVE_UINT_TYPE identifier, void* ptr);
private:
NATIVE_UINT_TYPE m_length;
};
} /* namespace Fw */
#endif /* TYPES_MMAPALLOCATOR_HPP_ */
| hpp |
fprime | data/projects/fprime/Fw/Types/StringUtils.hpp | #ifndef FW_STRINGUTILS_HPP
#define FW_STRINGUTILS_HPP
#include <FpConfig.hpp>
namespace Fw {
namespace StringUtils {
/**
* \brief copy string with null-termination guaranteed
*
* Standard implementations of strncpy fail to guarantee the termination of a
* string with the null terminator. This implementation guarantees the string is
* properly null-terminated at the possible expense of the last character of the
* copied string being lost. The user is responsible for providing a destination
* large enough for the content and a null-character. Other behavior retains the
* behavior of strncpy.
*
* \param destination: destination buffer to hold copied contents
* \param source: source buffer to read content to copy
* \param num: length of destination buffer
* \return destination buffer
*/
char* string_copy(char* destination, const char* source, U32 num);
/**
* \brief get the length of the source string or max_len if the string is
* longer than max_len.
*
* \param source: string to calculate the length
* \param max_len: the maximum length of the source string
* \return length of the source string or max_len
*/
U32 string_length(const CHAR* source, U32 max_len);
} // namespace StringUtils
} // namespace Fw
#endif // FW_STRINGUTILS_HPP
| hpp |
fprime | data/projects/fprime/Fw/Types/StringType.hpp | /**
* \file
* \author T. Canham
* \brief Declares ISF string base class
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#ifndef FW_STRING_TYPE_HPP
#define FW_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp>
#ifdef BUILD_UT
#include <iostream>
#endif
namespace Fw {
class StringBase : public Serializable {
public:
using SizeType = NATIVE_UINT_TYPE;
virtual const CHAR* toChar() const = 0; //<! Convert to a C-style char*
virtual SizeType getCapacity() const = 0; //!< return size of buffer
SizeType length() const; //!< Get length of string
const CHAR* operator+=(const CHAR* src); //!< Concatenate a CHAR*
const StringBase& operator+=(const StringBase& src); //!< Concatenate a StringBase
bool operator==(const StringBase& other) const; //!< Check for equality with StringBase
bool operator==(const CHAR* other) const; //!< Check for equality with CHAR*
bool operator!=(const StringBase& other) const; //!< Inequality with StringBase
bool operator!=(const CHAR* other) const; //!< Inequality with CHAR*
StringBase& operator=(const CHAR* src); //!< Assign CHAR*
StringBase& operator=(const StringBase& src); //!< Assign another StringBase
void format(const CHAR* formatString, ...); //!< write formatted string to buffer
virtual SerializeStatus serialize(SerializeBufferBase& buffer) const; //!< serialization function
virtual SerializeStatus serialize(SerializeBufferBase& buffer, SizeType maxLen) const; //!< serialization function
virtual SerializeStatus deserialize(SerializeBufferBase& buffer); //!< deserialization function
#ifdef BUILD_UT
// to support GoogleTest framework in unit tests
friend std::ostream& operator<<(std::ostream& os, const StringBase& str);
#endif
#if FW_SERIALIZABLE_TO_STRING || BUILD_UT
void toString(StringBase& text) const; //!< write string with contents
#endif
protected:
StringBase();
virtual ~StringBase();
void appendBuff(const CHAR* buff, SizeType size);
private:
// A no-implementation copy constructor here will prevent the default copy constructor from being called
// accidentally, and without an implementation it will create an error for the developer instead.
StringBase(const StringBase &src); //!< constructor with buffer as source
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Types/SerialBuffer.cpp | // ======================================================================
// \title SerialBuffer.cpp
// \author bocchino
// \brief cpp file for SerialBuffer type
//
// \copyright
// Copyright (C) 2016 California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#include "Fw/Types/SerialBuffer.hpp"
#include "Fw/Types/Assert.hpp"
namespace Fw {
SerialBuffer ::
SerialBuffer(
U8 *const data,
const U32 capacity
) :
m_data(data),
m_capacity(capacity)
{
}
NATIVE_UINT_TYPE SerialBuffer ::
getBuffCapacity() const
{
return m_capacity;
}
U8* SerialBuffer ::
getBuffAddr()
{
return m_data;
}
const U8* SerialBuffer ::
getBuffAddr() const
{
return m_data;
}
void SerialBuffer ::
fill()
{
const SerializeStatus status = this->setBuffLen(this->m_capacity);
FW_ASSERT(status == FW_SERIALIZE_OK);
}
SerializeStatus SerialBuffer ::
pushBytes(const U8 *const addr, const NATIVE_UINT_TYPE n)
{
// "true" means "just push the bytes"
return this->serialize(const_cast<U8*>(addr), n, true);
}
SerializeStatus SerialBuffer ::
popBytes(U8 *const addr, NATIVE_UINT_TYPE n)
{
// "true" means "just pop the bytes"
return this->deserialize(addr, n, true);
}
}
| cpp |
fprime | data/projects/fprime/Fw/Types/ObjectName.cpp | #include <Fw/Types/ObjectName.hpp>
#include <Fw/Types/StringUtils.hpp>
namespace Fw {
ObjectName::ObjectName(const CHAR* src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}
ObjectName::ObjectName(const StringBase& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
ObjectName::ObjectName(const ObjectName& src) : StringBase() {
(void) Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}
ObjectName::ObjectName() : StringBase() {
this->m_buf[0] = 0;
}
ObjectName& ObjectName::operator=(const ObjectName& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
ObjectName& ObjectName::operator=(const StringBase& other) {
if(this == &other) {
return *this;
}
(void) Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
return *this;
}
ObjectName& ObjectName::operator=(const CHAR* other) {
(void) Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
return *this;
}
ObjectName::~ObjectName() {
}
const CHAR* ObjectName::toChar() const {
return this->m_buf;
}
NATIVE_UINT_TYPE ObjectName::getCapacity() const {
return STRING_SIZE;
}
}
| cpp |
fprime | data/projects/fprime/Fw/Types/String.hpp | #ifndef FW_FIXED_LENGTH_STRING_TYPE_HPP
#define FW_FIXED_LENGTH_STRING_TYPE_HPP
#include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp>
namespace Fw {
class String : public Fw::StringBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_FIXED_LENGTH_STRING, //!< typeid for string type
STRING_SIZE = FW_FIXED_LENGTH_STRING_SIZE, //!< Storage for string
SERIALIZED_SIZE = STRING_SIZE + sizeof(FwBuffSizeType) //!< Serialized size is size of buffer + size field
};
String(const char* src); //!< char* source constructor
String(const StringBase& src); //!< other string constructor
String(const String& src); //!< String string constructor
String(); //!< default constructor
String& operator=(const String& other); //!< assignment operator
String& operator=(const StringBase& other); //!< other string assignment operator
String& operator=(const char* other); //!< char* assignment operator
~String(); //!< destructor
const char* toChar() const; //!< gets char buffer
NATIVE_UINT_TYPE getCapacity() const ; //!< return buffer size
private:
char m_buf[STRING_SIZE]; //!< storage for string data
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Types/Serializable.hpp | #ifndef SERIALIZABLE_HPP
#define SERIALIZABLE_HPP
#ifdef BUILD_UT
#include <iostream>
#endif
#include <FpConfig.hpp>
#include "Fw/Deprecate.hpp"
namespace Fw {
class StringBase; //!< forward declaration for string
typedef enum {
FW_SERIALIZE_OK, //!< Serialization/Deserialization operation was successful
FW_SERIALIZE_FORMAT_ERROR, //!< Data was the wrong format (e.g. wrong packet type)
FW_SERIALIZE_NO_ROOM_LEFT, //!< No room left in the buffer to serialize data
FW_DESERIALIZE_BUFFER_EMPTY, //!< Deserialization buffer was empty when trying to read more data
FW_DESERIALIZE_FORMAT_ERROR, //!< Deserialization data had incorrect values (unexpected data types)
FW_DESERIALIZE_SIZE_MISMATCH, //!< Data was left in the buffer, but not enough to deserialize
FW_DESERIALIZE_TYPE_MISMATCH //!< Deserialized type ID didn't match
} SerializeStatus;
class SerializeBufferBase; //!< forward declaration
class Serializable {
public:
// Size type for backwards compatibility
using SizeType = NATIVE_UINT_TYPE;
public:
virtual SerializeStatus serialize(SerializeBufferBase& buffer) const = 0; //!< serialize contents
virtual SerializeStatus deserialize(SerializeBufferBase& buffer) = 0; //!< deserialize to contents
#if FW_SERIALIZABLE_TO_STRING || FW_ENABLE_TEXT_LOGGING || BUILD_UT
virtual void toString(StringBase& text) const; //!< generate text from serializable
#endif
#ifdef BUILD_UT
friend std::ostream& operator<<(std::ostream& os, const Serializable& val);
#endif
protected:
Serializable(); //!< Default constructor
virtual ~Serializable(); //!< destructor
};
class Serialization {
public:
enum t {
INCLUDE_LENGTH, //!< Include length as first token in serialization
OMIT_LENGTH //!< Omit length from serialization
};
};
class SerializeBufferBase {
public:
SerializeBufferBase& operator=(const SerializeBufferBase &src); //!< equal operator
virtual ~SerializeBufferBase(); //!< destructor
// Serialization for built-in types
SerializeStatus serialize(U8 val); //!< serialize 8-bit unsigned int
SerializeStatus serialize(I8 val); //!< serialize 8-bit signed int
#if FW_HAS_16_BIT==1
SerializeStatus serialize(U16 val); //!< serialize 16-bit unsigned int
SerializeStatus serialize(I16 val); //!< serialize 16-bit signed int
#endif
#if FW_HAS_32_BIT==1
SerializeStatus serialize(U32 val); //!< serialize 32-bit unsigned int
SerializeStatus serialize(I32 val); //!< serialize 32-bit signed int
#endif
#if FW_HAS_64_BIT==1
SerializeStatus serialize(U64 val); //!< serialize 64-bit unsigned int
SerializeStatus serialize(I64 val); //!< serialize 64-bit signed int
#endif
SerializeStatus serialize(F32 val); //!< serialize 32-bit floating point
#if FW_HAS_F64
SerializeStatus serialize(F64 val); //!< serialize 64-bit floating point
#endif
SerializeStatus serialize(bool val); //!< serialize boolean
SerializeStatus serialize(const void* val); //!< serialize pointer (careful, only pointer value, not contents are serialized)
//! serialize data buffer
SerializeStatus serialize(const U8* buff, NATIVE_UINT_TYPE length, bool noLength);
//! serialize data buffer
SerializeStatus serialize(const U8* buff, NATIVE_UINT_TYPE length);
//! \brief serialize a byte buffer of a given length
//!
//! Serialize bytes from `buff` up to `length`. If `serializationMode` is set to `INCLUDE_LENGTH` then the
//! length is included as the first token. Length may be omitted with `OMIT_LENGTH`.
//!
//! \param buff: buffer to serialize
//! \param length: length of data to serialize
//! \param mode: serialization type
//! \return status of serialization
SerializeStatus serialize(const U8* buff, FwSizeType length, Serialization::t mode);
SerializeStatus serialize(const SerializeBufferBase& val); //!< serialize a serialized buffer
SerializeStatus serialize(const Serializable &val); //!< serialize an object derived from serializable base class
SerializeStatus serializeSize(const FwSizeType size); //!< serialize a size value
// Deserialization for built-in types
SerializeStatus deserialize(U8 &val); //!< deserialize 8-bit unsigned int
SerializeStatus deserialize(I8 &val); //!< deserialize 8-bit signed int
#if FW_HAS_16_BIT==1
SerializeStatus deserialize(U16 &val); //!< deserialize 16-bit unsigned int
SerializeStatus deserialize(I16 &val); //!< deserialize 16-bit signed int
#endif
#if FW_HAS_32_BIT==1
SerializeStatus deserialize(U32 &val); //!< deserialize 32-bit unsigned int
SerializeStatus deserialize(I32 &val); //!< deserialize 32-bit signed int
#endif
#if FW_HAS_64_BIT==1
SerializeStatus deserialize(U64 &val); //!< deserialize 64-bit unsigned int
SerializeStatus deserialize(I64 &val); //!< deserialize 64-bit signed int
#endif
SerializeStatus deserialize(F32 &val); //!< deserialize 32-bit floating point
#if FW_HAS_F64
SerializeStatus deserialize(F64 &val); //!< deserialize 64-bit floating point
#endif
SerializeStatus deserialize(bool &val); //!< deserialize boolean
SerializeStatus deserialize(void*& val); //!< deserialize point value (careful, pointer value only, not contents)
//! deserialize data buffer
SerializeStatus deserialize(U8* buff, NATIVE_UINT_TYPE& length, bool noLength);
//! deserialize data buffer
SerializeStatus deserialize(U8* buff, NATIVE_UINT_TYPE& length);
//! \brief deserialize a byte buffer of a given length
//!
//! Deserialize bytes into `buff` of `length` bytes. If `serializationMode` is set to `INCLUDE_LENGTH` then
//! the length is deserialized first followed by the bytes. Length may be omitted with `OMIT_LENGTH` and
//! in this case `length` bytes will be deserialized. `length` will be filled with the amount of data
//! deserialized.
//!
//! \param buff: buffer to hold deserialized data
//! \param length: length of data to deserialize length is filled with deserialized length
//! \param mode: deserialization type
//! \return status of serialization
SerializeStatus deserialize(U8* buff, FwSizeType& length, Serialization::t mode);
SerializeStatus deserialize(Serializable &val); //!< deserialize an object derived from serializable base class
SerializeStatus deserialize(SerializeBufferBase& val); //!< serialize a serialized buffer
SerializeStatus deserializeSize(FwSizeType& size); //!< deserialize a size value
void resetSer(); //!< reset to beginning of buffer to reuse for serialization
void resetDeser(); //!< reset deserialization to beginning
SerializeStatus moveSerToOffset(FwSizeType offset); //!< Moves serialization to the specified offset
SerializeStatus moveDeserToOffset(FwSizeType offset); //!< Moves deserialization to the specified offset
SerializeStatus serializeSkip(FwSizeType numBytesToSkip); //!< Skips the number of specified bytes for serialization
SerializeStatus deserializeSkip(FwSizeType numBytesToSkip); //!< Skips the number of specified bytes for deserialization
virtual Serializable::SizeType getBuffCapacity() const = 0; //!< returns capacity, not current size, of buffer
Serializable::SizeType getBuffLength() const; //!< returns current buffer size
Serializable::SizeType getBuffLeft() const; //!< returns how much deserialization buffer is left
virtual U8* getBuffAddr() = 0; //!< gets buffer address for data filling
virtual const U8* getBuffAddr() const = 0; //!< gets buffer address for data reading, const version
const U8* getBuffAddrLeft() const; //!< gets address of remaining non-deserialized data.
U8* getBuffAddrSer(); //!< gets address of end of serialization. DANGEROUS! Need to know max buffer size and adjust when done
SerializeStatus setBuff(const U8* src, Serializable::SizeType length); //!< sets buffer contents and size
SerializeStatus setBuffLen(Serializable::SizeType length); //!< sets buffer length manually after filling with data
SerializeStatus copyRaw(SerializeBufferBase& dest, Serializable::SizeType size); //!< directly copies buffer without looking for a size in the stream.
// Will increment deserialization pointer
SerializeStatus copyRawOffset(SerializeBufferBase& dest, Serializable::SizeType size); //!< directly copies buffer without looking for a size in the stream.
// Will increment deserialization pointer
#ifdef BUILD_UT
bool operator==(const SerializeBufferBase& other) const;
friend std::ostream& operator<<(std::ostream& os, const SerializeBufferBase& buff);
#endif
PROTECTED:
SerializeBufferBase(); //!< default constructor
PRIVATE:
// A no-implementation copy constructor here will prevent the default copy constructor from being called
// accidentally, and without an implementation it will create an error for the developer instead.
SerializeBufferBase(const SerializeBufferBase &src); //!< constructor with buffer as source
void copyFrom(const SerializeBufferBase& src); //!< copy data from source buffer
Serializable::SizeType m_serLoc; //!< current offset in buffer of serialized data
Serializable::SizeType m_deserLoc; //!< current offset for deserialization
};
// Helper class for building buffers with external storage
class ExternalSerializeBuffer : public SerializeBufferBase {
public:
ExternalSerializeBuffer(U8* buffPtr, Serializable::SizeType size); //!< construct with external buffer
ExternalSerializeBuffer(); //!< default constructor
void setExtBuffer(U8* buffPtr, Serializable::SizeType size); //!< Set the external buffer
void clear(); //!< clear external buffer
// pure virtual functions
Serializable::SizeType getBuffCapacity() const;
U8* getBuffAddr();
const U8* getBuffAddr() const ;
PRIVATE:
// no copying
ExternalSerializeBuffer(ExternalSerializeBuffer& other);
ExternalSerializeBuffer(ExternalSerializeBuffer* other);
// private data
U8* m_buff; //!< pointer to external buffer
Serializable::SizeType m_buffSize; //!< size of external buffer
};
}
#endif
| hpp |
fprime | data/projects/fprime/Fw/Types/Assert.hpp | #ifndef FW_ASSERT_HPP
#define FW_ASSERT_HPP
#include <FpConfig.hpp>
// Return only the first argument passed to the macro.
#define FW_ASSERT_FIRST_ARG(ARG_0, ...) ARG_0
// Return all the arguments of the macro, but the first one
#define FW_ASSERT_NO_FIRST_ARG(ARG_0, ...) __VA_ARGS__
#if FW_ASSERT_LEVEL == FW_NO_ASSERT
// Users may override the NO_ASSERT case should they choose
#ifndef FW_ASSERT
#define FW_ASSERT(...) ((void)(FW_ASSERT_FIRST_ARG(__VA_ARGS__)))
#endif
#define FILE_NAME_ARG const CHAR*
#else // ASSERT is defined
// Passing the __LINE__ argument at the end of the function ensures that
// the FW_ASSERT_NO_FIRST_ARG macro will never have an empty variadic variable
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
#define FILE_NAME_ARG U32
#define FW_ASSERT(...) \
((void) ((FW_ASSERT_FIRST_ARG(__VA_ARGS__, 0)) ? (0) : \
(Fw::SwAssert(ASSERT_FILE_ID, FW_ASSERT_NO_FIRST_ARG(__VA_ARGS__, __LINE__)))))
#elif FW_ASSERT_LEVEL == FW_RELATIVE_PATH_ASSERT
#define FILE_NAME_ARG const CHAR*
#define FW_ASSERT(...) \
((void) ((FW_ASSERT_FIRST_ARG(__VA_ARGS__, 0)) ? (0) : \
(Fw::SwAssert(ASSERT_RELATIVE_PATH, FW_ASSERT_NO_FIRST_ARG(__VA_ARGS__, __LINE__)))))
#else
#define FILE_NAME_ARG const CHAR*
#define FW_ASSERT(...) \
((void) ((FW_ASSERT_FIRST_ARG(__VA_ARGS__, 0)) ? (0) : \
(Fw::SwAssert(__FILE__, FW_ASSERT_NO_FIRST_ARG(__VA_ARGS__, __LINE__)))))
#endif
#endif // if ASSERT is defined
// F' Assertion functions can technically return even though the intention is for the assertion to terminate the program.
// This breaks static analysis depending on assertions, since the analyzer has to assume the assertion will return.
// When supported, annotate assertion functions as noreturn when statically analyzing.
#ifndef CLANG_ANALYZER_NORETURN
#ifndef __has_feature
#define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif
#if __has_feature(attribute_analyzer_noreturn)
#define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))
#else
#define CLANG_ANALYZER_NORETURN
#endif
#endif
namespace Fw {
//! Assert with no arguments
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN;
//! Assert with one argument
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN;
//! Assert with two arguments
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN;
//! Assert with three arguments
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN;
//! Assert with four arguments
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN;
//! Assert with five arguments
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN;
//! Assert with six arguments
NATIVE_INT_TYPE SwAssert(
FILE_NAME_ARG file,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6,
NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN;
}
// Base class for declaring an assert hook
// Each of the base class functions can be overridden
// or used by derived classes.
namespace Fw {
// Base class for declaring an assert hook
class AssertHook {
public:
AssertHook() : previousHook(nullptr) {}; //!< constructor
virtual ~AssertHook() {}; //!< destructor
// override this function to intercept asserts
virtual void reportAssert(
FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs,
FwAssertArgType arg1,
FwAssertArgType arg2,
FwAssertArgType arg3,
FwAssertArgType arg4,
FwAssertArgType arg5,
FwAssertArgType arg6
);
// default reportAssert() will call this when the message is built
// override it to do another kind of print. printf by default
virtual void printAssert(const CHAR* msg);
// do assert action. By default, calls assert.
// Called after reportAssert()
virtual void doAssert();
// register the hook
void registerHook();
// deregister the hook
void deregisterHook();
protected:
private:
// the previous assert hook
AssertHook *previousHook;
};
}
#endif // FW_ASSERT_HPP
| hpp |
fprime | data/projects/fprime/Fw/Types/BasicTypes.h | /**
* \file: BasicType.h
* \author mstarch
* \brief Declares fprime basic types for usage within C language files
*
* \copyright
* Copyright 2009-2016, by the California Institute of Technology.
* ALL RIGHTS RESERVED. United States Government Sponsorship
* acknowledged.
*
*/
#include <PlatformTypes.h>
#ifndef FW_BASIC_TYPES_H
#define FW_BASIC_TYPES_H
// Compiler checks
#if defined(__GNUC__) || defined(__llvm__) || defined(PLATFORM_OVERRIDE_GCC_CLANG_CHECK)
#else
#error Unsupported compiler!
#endif
/*----------------------------------------------------------------------------*/
/* Type definitions: I8, U8, I16, U16, ..., I64, U64, F32, and F64 */
/*----------------------------------------------------------------------------*/
typedef int8_t I8; //!< 8-bit signed integer
typedef uint8_t U8; //!< 8-bit unsigned integer
typedef U8 BYTE; //!< byte type
typedef char CHAR;
#if FW_HAS_16_BIT
typedef int16_t I16; //!< 16-bit signed integer
typedef uint16_t U16; //!< 16-bit unsigned integer
#endif
#if FW_HAS_32_BIT
typedef int32_t I32; //!< 32-bit signed integer
typedef uint32_t U32; //!< 32-bit unsigned integer
#endif
#if FW_HAS_64_BIT
typedef int64_t I64; //!< 64-bit signed integer
typedef uint64_t U64; //!< 64-bit unsigned integer
#endif
typedef float F32; //!< 32-bit floating point
#if FW_HAS_F64
typedef double F64; //!< 64-bit floating point
#endif
// Backwards-compatibility definitions
typedef PlatformIntType NATIVE_INT_TYPE;
typedef PlatformUIntType NATIVE_UINT_TYPE;
typedef PlatformPointerCastType POINTER_CAST;
/*----------------------------------------------------------------------------*/
/* Useful macro definitions */
/*----------------------------------------------------------------------------*/
#define FW_NO_ASSERT 1 //!< Asserts turned off
#define FW_FILEID_ASSERT \
2 //!< File ID used - requires -DASSERT_FILE_ID=somevalue to be set on the compile command line
#define FW_FILENAME_ASSERT 3 //!< Uses the file path in the assert - image stores filenames
#define FW_RELATIVE_PATH_ASSERT \
4 //!< Uses a relative file path (within fprime/fprime library) for assert. - requires -DASSERT_RELATIVE_PATH=path
//!< to be set on the compile command line
#define FW_NUM_ARRAY_ELEMENTS(a) (sizeof(a) / sizeof((a)[0])) //!< number of elements in an array
#define FW_MAX(a, b) (((a) > (b)) ? (a) : (b)) //!< MAX macro
#define FW_MIN(a, b) (((a) < (b)) ? (a) : (b)) //!< MIN macro
#ifndef STATIC
#define STATIC static //!< static for non unit-test code
#endif
#ifndef PROTECTED
#define PROTECTED protected //!< overridable protected for unit testing
#endif
#ifndef PRIVATE
#define PRIVATE private //!< overridable private for unit testing
#endif
#endif // FW_BASIC_TYPES_H
| h |