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 |
End of preview. Expand
in Dataset Viewer.
Summary
This dataset is a collection of codes used in embedded C/C++ software.
The purpose of this dataset is code infilling, but it can be used in other ways as well.
The libraries used for code collection are 7 each: fprime, boost-asio, TinyXML, inifile-cpp, RTI-DDS, OneAPI, and PROJ.
# of extention(file)
| extention | content |
|---|---|
| c | 199 |
| cpp | 2495 |
| cxx | 505 |
| h | 5015 |
| hpp | 1994 |
Repo file count
| repo_name | content |
|---|---|
| PROJ | 306 |
| asio | 1150 |
| fprime | 1091 |
| inifile-cpp | 8 |
| oneAPI-samples | 2456 |
| rticonnextdds-examples | 778 |
| rticonnextdds-getting-started | 33 |
| rticonnextdds-robot-helpers | 53 |
| rticonnextdds-usecases | 4329 |
| tinyxml2 | 4 |
License
| repo_name | License |
|---|---|
| PROJ | MIT |
| asio | boost license |
| fprime | Apache-2.0 |
| inifile-cpp | MIT |
| oneAPI-samples | MIT |
| rticonnextdds-examples | rti license |
| rticonnextdds-getting-started | rti license |
| rticonnextdds-robot-helpers | rti license |
| rticonnextdds-usecases | rti license |
| tinyxml2 | Zlib |
# data generate script
see data_generate.py
- Downloads last month
- 40