/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CreateTestFile(char *Filename, int SizeInKs, boolean LeaveOpen)
{
int FileHandle;
int i;
FileHandle = OS_creat(Filename, OS_READ_WRITE);
if (FileHandle >= OS_SUCCESS)
{
if (FillBuffer[0] == 0)
{
CFE_PSP_MemSet(FillBuffer, 0xA5, sizeof(FillBuffer));
}
for (i = 0; i < SizeInKs; i++)
{
OS_write(FileHandle, FillBuffer, sizeof(FillBuffer));
}
if (LeaveOpen)
{
OpenFileHandle = FileHandle;
}
else
{
OS_close(FileHandle);
}
}
else
{
UTF_put_text("\nERROR CREATING TEST FILE %s\n", Filename);
}
return;
} /* End of CreateTestFile() */
/******************************************************************************
** Function: TBLMGR_Constructor
**
** Notes:
** 1. This must be called prior to any other functions
**
*/
void TBLMGR_Constructor(TBLMGR_Class* TblMgrPtr,
char* TblMgrFilePathName)
{
TblMgr = TblMgrPtr;
/*
** Set all data and flags to zero.
** AttrErrCnt - Incremented by XML parser
*/
CFE_PSP_MemSet(&(TblMgr->ExObjTbl), 0, sizeof(TBLMGR_ExObjTbl));
TblMgr->ExObjTbl.LoadActive = TRUE;
if (ParseXmlFile(TblMgrFilePathName, ExObjTblStartElement, ExObjTblEndElement) &&
TblMgr->ExObjTbl.AttrErrCnt == 0)
{
TblMgr->ExObjTbl.LastLoadValid = (EXOBJ_LoadTable(&(TblMgr->ExObjTbl.Local)) == TRUE);
} /* End if successful table parse */
TblMgr->ExObjTbl.LoadActive = FALSE;
} /* End TBLMGR_Constructor() */
void THRSIM_GetValveStates(void) {
/* Timestamp and send out our message */
if (THRSIM_ReadDeviceData(&THRSIM_AppData.thr_sim_msg) != CFE_SUCCESS) {
CFE_EVS_SendEvent(THRSIM_DEVICE_ERR_EID, CFE_EVS_ERROR, "Error reading from valves device");
CFE_PSP_MemSet(CFE_SB_GetUserData((CFE_SB_MsgPtr_t)&THRSIM_AppData.thr_sim_msg),
0,
CFE_SB_GetUserDataLength((CFE_SB_MsgPtr_t)&THRSIM_AppData.thr_sim_msg));
}
CFE_SB_TimeStampMsg((CFE_SB_MsgPtr_t) &THRSIM_AppData.thr_sim_msg);
CFE_SB_SendMsg((CFE_SB_MsgPtr_t) &THRSIM_AppData.thr_sim_msg);
}
/******************************************************************************
** Function: TBLMGR_LoadExObjTableCmd
**
*/
boolean TBLMGR_LoadExObjTableCmd(const CFE_SB_MsgPtr_t MsgPtr)
{
const TBLMGR_LoadTblCmd *LoadTblCmd = (const TBLMGR_LoadTblCmd *) MsgPtr;
int entry;
/*
** Set all data and flags to zero.
** AttrErrCnt - Incremented by XML parser
*/
CFE_PSP_MemSet(&TblMgr->ExObjTbl, 0, sizeof(TBLMGR_ExObjTbl));
TblMgr->ExObjTbl.LoadActive = TRUE;
TblEntryId = 0;
if (ParseXmlFile(LoadTblCmd->FileName, ExObjTblStartElement, ExObjTblEndElement) &&
TblMgr->ExObjTbl.AttrErrCnt == 0)
{
if (LoadTblCmd->LoadType == TBLMGR_LOAD_TBL_REPLACE)
{
TblMgr->ExObjTbl.LastLoadValid = (EXOBJ_LoadTable(&(TblMgr->ExObjTbl.Local)) == TRUE);
} /* End if replace entire table */
else if (LoadTblCmd->LoadType == TBLMGR_LOAD_TBL_UPDATE)
{
TblMgr->ExObjTbl.LastLoadValid = TRUE;
for (entry=0; entry < EXOBJ_TBL_MAX_ENTRY_ID; entry++)
{
if (TblMgr->ExObjTbl.Modified[entry])
{
if (!EXOBJ_LoadTableEntry(entry, &(TblMgr->ExObjTbl.Local.Entry[entry])))
TblMgr->ExObjTbl.LastLoadValid = FALSE;
}
} /* End pkt loop */
} /* End if update individual records */
else
{
CFE_EVS_SendEvent(TBLMGR_CMD_LOAD_TYPE_ERR_EID,CFE_EVS_ERROR,"TBLMGR: Invalid table command load type %d",LoadTblCmd->LoadType);
}
} /* End if successful parse */
else
{
CFE_EVS_SendEvent(TBLMGR_CMD_LOAD_PARSE_ERR_EID,CFE_EVS_ERROR,"TBLMGR: Table Parsing failure for file %s");
}
return TblMgr->ExObjTbl.LastLoadValid;
} /* End of TBLMGR_LoadExObjTableCmd() */
/******************************************************************************
** Function: CFE_SB_InitPipeTbl()
**
** Purpose:
** Initialize the Software Bus Pipe Table.
**
** Arguments:
**
** Notes:
** This function MUST be called before any SB API's are called.
**
** Return:
** none
*/
void CFE_SB_InitPipeTbl(void){
uint8 i;
for(i=0;i<CFE_SB_MAX_PIPES;i++){
CFE_SB.PipeTbl[i].InUse = CFE_SB_NOT_IN_USE;
CFE_SB.PipeTbl[i].SysQueueId = CFE_SB_UNUSED_QUEUE;
CFE_SB.PipeTbl[i].PipeId = CFE_SB_INVALID_PIPE;
CFE_SB.PipeTbl[i].CurrentBuff = NULL;
CFE_PSP_MemSet(&CFE_SB.PipeTbl[i].PipeName[0],0,OS_MAX_API_NAME);
}/* end for */
}/* end CFE_SB_InitPipeTbl */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int32 CFE_ES_ListTasks(int32 fd)
{
uint32 i;
char Line [128];
int32 Result = CFE_SUCCESS;
CFE_ES_TaskInfo_t TaskInfo;
/* Make sure we start at the beginning of the file */
Result = OS_lseek(fd, 0, OS_SEEK_SET);
if ( Result == 0 )
{
sprintf(Line,"---- ES Task List ----\n");
Result = OS_write(fd, Line, strlen(Line));
if (Result == strlen(Line))
{
Result = CFE_SUCCESS;
for ( i = 0; i < OS_MAX_TASKS; i++ )
{
if ((CFE_ES_Global.TaskTable[i].RecordUsed == TRUE) && (Result == CFE_SUCCESS))
{
/*
** zero out the local entry
*/
CFE_PSP_MemSet(&TaskInfo,0,sizeof(CFE_ES_TaskInfo_t));
/*
** Populate the AppInfo entry
*/
Result = CFE_ES_GetTaskInfo(&TaskInfo,i);
if ( Result == CFE_SUCCESS )
{
sprintf(Line,"Task ID: %08d, Task Name: %20s, Prnt App ID: %08d, Prnt App Name: %20s\n",
(int) TaskInfo.TaskId, TaskInfo.TaskName,
(int)TaskInfo.AppId, TaskInfo.AppName);
Result = OS_write(fd, Line, strlen(Line));
if (Result == strlen(Line))
{
Result = CFE_SUCCESS;
}
/* if not success, returns whatever OS_write failire was */
}
}
} /* end for */
} /* End if OS_write */
} /* End if OS_lseek */
return Result;
} /* end ES_ListTasks */
/*******************************************************************
** Function: LoadTestTable
**
** TODO - Move to unit test now that load table function available.
**
*/
static void LoadTestTable(void)
{
int i;
MSGTBL_Entry *Entry;
for (i=0; i < MSGTBL_MAX_ENTRY_ID; i++)
{
Entry = &(TstMsgTbl.Entry[i]);
CFE_PSP_MemSet(Entry, 0, sizeof(MSGTBL_Entry));
Entry->Buffer[0] = MSGTBL_UNUSED_MSG_ID;
} /* End Entry Loop */
TstMsgTbl.Entry[0].Buffer[0] = 1;
TstMsgTbl.Entry[0].Buffer[1] = 2;
TstMsgTbl.Entry[0].Buffer[MSGTBL_MAX_MSG_WORDS-2] = MSGTBL_MAX_MSG_WORDS-1;
TstMsgTbl.Entry[0].Buffer[MSGTBL_MAX_MSG_WORDS-1] = MSGTBL_MAX_MSG_WORDS;
TstMsgTbl.Entry[1].Buffer[0] = 11;
TstMsgTbl.Entry[1].Buffer[1] = 12;
TstMsgTbl.Entry[1].Buffer[MSGTBL_MAX_MSG_WORDS-2] = 10 + MSGTBL_MAX_MSG_WORDS-1;
TstMsgTbl.Entry[1].Buffer[MSGTBL_MAX_MSG_WORDS-1] = 10 + MSGTBL_MAX_MSG_WORDS;
/* Entry #7: TO HK */
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID/2].Buffer[0] = MSGTBL_MAX_ENTRY_ID/2 + 1;
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID/2].Buffer[1] = MSGTBL_MAX_ENTRY_ID/2 + 2;
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID/2].Buffer[MSGTBL_MAX_MSG_WORDS-2] = MSGTBL_MAX_ENTRY_ID/2 + MSGTBL_MAX_MSG_WORDS-1;
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID/2].Buffer[MSGTBL_MAX_MSG_WORDS-1] = MSGTBL_MAX_ENTRY_ID/2 + MSGTBL_MAX_MSG_WORDS;
/* Entry #7: TO HK */
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID-1].Buffer[0] = MSGTBL_MAX_ENTRY_ID-1 + 1;
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID-1].Buffer[1] = MSGTBL_MAX_ENTRY_ID-1 + 2;
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID-1].Buffer[MSGTBL_MAX_MSG_WORDS-2] = MSGTBL_MAX_ENTRY_ID-1 + MSGTBL_MAX_MSG_WORDS-1;
TstMsgTbl.Entry[MSGTBL_MAX_ENTRY_ID-1].Buffer[MSGTBL_MAX_MSG_WORDS-1] = MSGTBL_MAX_ENTRY_ID-1 + MSGTBL_MAX_MSG_WORDS;
} /* End LoadTestTable() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CFE_ES_PerfLogDump(void){
int32 WriteStat;
uint32 i;
uint32 FileSize;
CFE_FS_Header_t FileHdr;
CFE_ES_RegisterChildTask();
/* Zero cFE header, then fill in fields */
CFE_PSP_MemSet(&FileHdr, 0, sizeof(CFE_FS_Header_t));
strcpy(&FileHdr.Description[0], CFE_ES_PERF_LOG_DESC);
FileHdr.SubType = CFE_FS_ES_PERFDATA_SUBTYPE;
/* write the cFE header to the file */
WriteStat = CFE_FS_WriteHeader( CFE_ES_PerfLogDumpStatus.DataFileDescriptor, &FileHdr);
if(WriteStat != sizeof(CFE_FS_Header_t))
{
CFE_ES_FileWriteByteCntErr(&CFE_ES_PerfLogDumpStatus.DataFileName[0],
sizeof(CFE_FS_Header_t),WriteStat);
OS_close(CFE_ES_PerfLogDumpStatus.DataFileDescriptor);
CFE_ES_ExitChildTask();
}/* end if */
FileSize = WriteStat;
/* write the performance metadata to the file */
WriteStat = OS_write(CFE_ES_PerfLogDumpStatus.DataFileDescriptor,(uint8 *)&Perf->MetaData,sizeof(CFE_ES_PerfMetaData_t));
if(WriteStat != sizeof(CFE_ES_PerfMetaData_t))
{
CFE_ES_FileWriteByteCntErr(&CFE_ES_PerfLogDumpStatus.DataFileName[0],
sizeof(CFE_ES_PerfMetaData_t),WriteStat);
OS_close(CFE_ES_PerfLogDumpStatus.DataFileDescriptor);
CFE_ES_ExitChildTask();
}/* end if */
FileSize += WriteStat;
CFE_ES_PerfLogDumpStatus.DataToWrite = Perf->MetaData.DataCount;
/* write the collected data to the file */
for(i=0; i < Perf->MetaData.DataCount; i++){
WriteStat = OS_write (CFE_ES_PerfLogDumpStatus.DataFileDescriptor, &Perf->DataBuffer[i], sizeof(CFE_ES_PerfDataEntry_t));
if(WriteStat != sizeof(CFE_ES_PerfDataEntry_t))
{
CFE_ES_FileWriteByteCntErr(&CFE_ES_PerfLogDumpStatus.DataFileName[0],
sizeof(CFE_ES_PerfDataEntry_t),WriteStat);
OS_close(CFE_ES_PerfLogDumpStatus.DataFileDescriptor);
/* Reset the DataToWrite variable, so a new file can be written */
CFE_ES_PerfLogDumpStatus.DataToWrite = 0;
CFE_ES_ExitChildTask();
}/* end if */
FileSize += WriteStat;
CFE_ES_PerfLogDumpStatus.DataToWrite--;
if((i % CFE_ES_PERF_ENTRIES_BTWN_DLYS) == 0){
OS_TaskDelay(CFE_ES_PERF_CHILD_MS_DELAY);
}/* end if */
}/* end for */
OS_close(CFE_ES_PerfLogDumpStatus.DataFileDescriptor);
CFE_EVS_SendEvent(CFE_ES_PERF_DATAWRITTEN_EID,CFE_EVS_DEBUG,
"%s written:Size=%d,EntryCount=%d",
&CFE_ES_PerfLogDumpStatus.DataFileName[0],FileSize,
Perf->MetaData.DataCount);
CFE_ES_ExitChildTask();
}/* end CFE_ES_PerfLogDump */
/*-------------------------------------------------------------------------
**
** Functional Prolog
**
** Name: CFE_ES_CreateObjects
**
** Purpose: This function reads the es_object_table and performs all of the
** application layer initialization.
**----------------------------------------------------------------------------
*/
void CFE_ES_CreateObjects(void)
{
int32 ReturnCode;
boolean AppSlotFound;
int16 i;
int16 j;
CFE_ES_WriteToSysLog("ES Startup: Starting Object Creation calls.\n");
for ( i = 0; i < CFE_ES_OBJECT_TABLE_SIZE; i++ )
{
switch ( CFE_ES_ObjectTable[i].ObjectType )
{
case CFE_ES_DRIVER_TASK:
case CFE_ES_CORE_TASK:
/*
** Allocate an ES AppTable entry
*/
AppSlotFound = FALSE;
for ( j = 0; j < CFE_ES_MAX_APPLICATIONS; j++ )
{
if ( CFE_ES_Global.AppTable[j].RecordUsed == FALSE )
{
AppSlotFound = TRUE;
break;
}
}
/*
** If a slot was found, create the application
*/
if ( AppSlotFound == TRUE )
{
CFE_ES_LockSharedData(__func__,__LINE__);
/*
** Allocate and populate the ES_AppTable entry
*/
CFE_PSP_MemSet ( (void *)&(CFE_ES_Global.AppTable[j]), 0, sizeof(CFE_ES_AppRecord_t));
CFE_ES_Global.AppTable[j].RecordUsed = TRUE;
CFE_ES_Global.AppTable[j].Type = CFE_ES_APP_TYPE_CORE;
/*
** Fill out the parameters in the AppStartParams sub-structure
*/
strncpy((char *)CFE_ES_Global.AppTable[j].StartParams.Name, (char *)CFE_ES_ObjectTable[i].ObjectName, OS_MAX_API_NAME);
CFE_ES_Global.AppTable[j].StartParams.Name[OS_MAX_API_NAME - 1] = '\0';
/* EntryPoint field is not valid here for base apps */
/* FileName is not valid for base apps, either */
CFE_ES_Global.AppTable[j].StartParams.StackSize = CFE_ES_ObjectTable[i].ObjectSize;
CFE_ES_Global.AppTable[j].StartParams.StartAddress = (uint32)CFE_ES_ObjectTable[i].FuncPtrUnion.FunctionPtr;
CFE_ES_Global.AppTable[j].StartParams.ExceptionAction = CFE_ES_APP_EXCEPTION_PROC_RESTART;
CFE_ES_Global.AppTable[j].StartParams.Priority = CFE_ES_ObjectTable[i].ObjectPriority;
/*
** Fill out the Task Info
*/
strncpy((char *)CFE_ES_Global.AppTable[j].TaskInfo.MainTaskName, (char *)CFE_ES_ObjectTable[i].ObjectName, OS_MAX_API_NAME);
CFE_ES_Global.AppTable[j].TaskInfo.MainTaskName[OS_MAX_API_NAME - 1] = '\0';
CFE_ES_Global.AppTable[j].TaskInfo.NumOfChildTasks = 0;
/*
** Since this is a Core app, the AppStateRecord does not need to be filled out.
*/
/*
** Create the task
*/
ReturnCode = OS_TaskCreate(&CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId, /* task id */
CFE_ES_ObjectTable[i].ObjectName, /* task name */
CFE_ES_ObjectTable[i].FuncPtrUnion.VoidPtr, /* task function pointer */
NULL, /* stack pointer */
CFE_ES_ObjectTable[i].ObjectSize, /* stack size */
CFE_ES_ObjectTable[i].ObjectPriority, /* task priority */
OS_FP_ENABLED); /* task options */
if(ReturnCode != OS_SUCCESS)
{
CFE_ES_Global.AppTable[j].RecordUsed = FALSE;
CFE_ES_WriteToSysLog("ES Startup: OS_TaskCreate error creating core App: %s: EC = 0x%08X\n",
CFE_ES_ObjectTable[i].ObjectName, ReturnCode);
CFE_ES_UnlockSharedData(__func__,__LINE__);
/*
** Delay to allow the message to be read
*/
OS_TaskDelay(CFE_ES_PANIC_DELAY);
/*
** cFE Cannot continue to start up.
*/
CFE_PSP_Panic(CFE_PSP_PANIC_CORE_APP);
}
else
{
CFE_ES_ObjectTable[i].ObjectKey = CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId;
/*
** Allocate and populate the CFE_ES_Global.TaskTable entry
*/
if ( CFE_ES_Global.TaskTable[CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId].RecordUsed == TRUE )
{
CFE_ES_WriteToSysLog("ES Startup: CFE_ES_Global.TaskTable record used error for App: %s, continuing.\n",
CFE_ES_ObjectTable[i].ObjectName);
}
else
{
CFE_ES_Global.TaskTable[CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId].RecordUsed = TRUE;
}
CFE_ES_Global.TaskTable[CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId].AppId = j;
CFE_ES_Global.TaskTable[CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId].TaskId = CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId;
strncpy((char *)CFE_ES_Global.TaskTable[CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId].TaskName, (char *)CFE_ES_Global.AppTable[j].TaskInfo.MainTaskName, OS_MAX_API_NAME);
CFE_ES_Global.TaskTable[CFE_ES_Global.AppTable[j].TaskInfo.MainTaskId].TaskName[OS_MAX_API_NAME - 1] = '\0';
CFE_ES_WriteToSysLog("ES Startup: Core App: %s created. App ID: %d\n",
CFE_ES_ObjectTable[i].ObjectName,j);
/*
** Increment the registered App and Registered External Task variables.
*/
CFE_ES_Global.RegisteredTasks++;
CFE_ES_Global.RegisteredCoreApps++;
CFE_ES_UnlockSharedData(__func__,__LINE__);
}
}
else /* appSlot not found -- This should never happen!*/
{
CFE_ES_WriteToSysLog("ES Startup: Error, No free application slots available for CORE App!\n");
/*
** Delay to allow the message to be read
*/
OS_TaskDelay(CFE_ES_PANIC_DELAY);
/*
** cFE Cannot continue to start up.
*/
CFE_PSP_Panic(CFE_PSP_PANIC_CORE_APP);
}
break;
case CFE_ES_FUNCTION_CALL: /*----------------------------------------------------------*/
if ( CFE_ES_ObjectTable[i].FuncPtrUnion.FunctionPtr != NULL )
{
CFE_ES_WriteToSysLog("ES Startup: Calling %s\n",CFE_ES_ObjectTable[i].ObjectName);
/*
** Call the function
*/
ReturnCode = (*CFE_ES_ObjectTable[i].FuncPtrUnion.FunctionPtr)();
if(ReturnCode != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("ES Startup: Error returned when calling function: %s: EC = 0x%08X\n",
CFE_ES_ObjectTable[i].ObjectName, ReturnCode);
/*
** Delay to allow the message to be read
*/
OS_TaskDelay(CFE_ES_PANIC_DELAY);
/*
** cFE Cannot continue to start up.
*/
CFE_PSP_Panic(CFE_PSP_PANIC_CORE_APP);
} /* end if */
}
else
{
CFE_ES_WriteToSysLog("ES Startup: bad function pointer ( table entry = %d).\n",i);
}
break;
case CFE_ES_NULL_ENTRY: /*-------------------------------------------------------*/
break;
default:
break;
} /* end switch */
} /* end for */
CFE_ES_WriteToSysLog("ES Startup: Finished ES CreateObject table entries.\n");
}
int32 CFE_ES_InitializeCDS(uint32 CDSSize)
{
int32 Status = CFE_SUCCESS;
uint32 MemBlock[32];
uint32 NumWritten=0;
uint32 Uint32Zero=0;
/* Clear the CDS to ensure everything is gone */
/* Create a block of zeros to write to the CDS */
CFE_PSP_MemSet(MemBlock, 0, sizeof(MemBlock));
/* While there is space to write another block of zeros, then do so */
while (((NumWritten + sizeof(MemBlock)) < CDSSize) && (Status == OS_SUCCESS))
{
Status = CFE_PSP_WriteToCDS(MemBlock, NumWritten, sizeof(MemBlock));
if (Status == OS_SUCCESS)
{
NumWritten += sizeof(MemBlock);
}
}
/* While there is space to write a uint32 of zeros, then do so */
if ((Status == OS_SUCCESS) && (NumWritten < CDSSize))
{
while (((NumWritten + sizeof(uint32)) < CDSSize) && (Status == OS_SUCCESS))
{
Status = CFE_PSP_WriteToCDS(&Uint32Zero, NumWritten, sizeof(uint32));
if (Status == OS_SUCCESS)
{
NumWritten += sizeof(uint32);
}
}
}
if (Status != OS_SUCCESS)
{
CFE_ES_WriteToSysLog("CFE_CDS:Init-Clear CDS failed @ Offset=%d Status=0x%08X\n", NumWritten, Status);
}
else
{
/* Initialize the Validity Check strings */
Status = CFE_PSP_WriteToCDS("_CDSBeg_", 0, sizeof(CFE_ES_Global.CDSVars.ValidityField));
if (Status == OS_SUCCESS)
{
Status = CFE_PSP_WriteToCDS("_CDSEnd_",
(CDSSize-sizeof(CFE_ES_Global.CDSVars.ValidityField)),
sizeof(CFE_ES_Global.CDSVars.ValidityField));
if (Status != OS_SUCCESS)
{
CFE_ES_WriteToSysLog("CFE_CDS:Init-'_CDSEnd_' write failed. Status=0x%08X\n", Status);
}
else
{
/* Determine the amount of CDS memory is available for the CDS Memory Pool */
/* Total CDS Size minus the validity fields and the space for the registry and the registry size */
CFE_ES_Global.CDSVars.MemPoolSize = CDSSize - CDS_POOL_OFFSET - sizeof(CFE_ES_Global.CDSVars.ValidityField);
/* Initialize the variables for managing the CDS Memory Pool */
Status = CFE_ES_CreateCDSPool(CFE_ES_Global.CDSVars.MemPoolSize, CDS_POOL_OFFSET);
if (Status == CFE_SUCCESS)
{
Status = CFE_ES_InitCDSRegistry();
}
}
}
else /* BSP reported an error writing to CDS */
{
CFE_ES_WriteToSysLog("CFE_CDS:Init-'_CDSBeg_' write failed. Status=0x%08X\n", Status);
}
}
return Status;
} /* End of CFE_ES_InitializeCDS() */
void DS_FileUpdateHeader(int32 FileIndex)
{
#if (DS_FILE_HEADER_TYPE == DS_FILE_HEADER_CFE)
/*
** Update CFE specific header fields...
*/
DS_AppFileStatus_t *FileStatus = &DS_AppData.FileStatus[FileIndex];
CFE_TIME_SysTime_t CurrentTime = CFE_TIME_GetTime();
int32 Result;
Result = OS_lseek(FileStatus->FileHandle, sizeof(CFE_FS_Header_t), SEEK_SET);
if (Result == sizeof(CFE_FS_Header_t))
{
/* update file close time */
Result = OS_write(FileStatus->FileHandle, &CurrentTime, sizeof(CFE_TIME_SysTime_t));
if (Result == sizeof(CFE_TIME_SysTime_t))
{
DS_AppData.FileUpdateCounter++;
}
else
{
DS_AppData.FileUpdateErrCounter++;
}
}
else
{
DS_AppData.FileUpdateErrCounter++;
}
#elif (DS_FILE_HEADER_TYPE == DS_FILE_HEADER_GPM)
/*
** Update GPM specific header fields...
*/
DS_AppFileStatus_t *FileStatus = &DS_AppData.FileStatus[FileIndex];
char Buf8[8];
int32 Result;
Result = OS_lseek(FileStatus->FileHandle, 16, SEEK_SET);
if (Result == 16)
{
/* update last pkt time in file header */
Result = OS_write(FileStatus->FileHandle, &DS_AppData.LastPktTime[FileIndex], sizeof(uint32));
if (Result == sizeof(uint32))
{
/* update file size in file header */
CFE_PSP_MemSet(Buf8, ' ', sizeof(Buf8));
DS_FileConvertGPM(Buf8, FileStatus->FileSize);
Result = OS_write(FileStatus->FileHandle, Buf8, sizeof(Buf8));
if (Result == sizeof(Buf8))
{
DS_AppData.FileUpdateCounter++;
}
else
{
DS_AppData.FileUpdateErrCounter++;
}
}
else
{
DS_AppData.FileUpdateErrCounter++;
}
}
else
{
DS_AppData.FileUpdateErrCounter++;
}
#endif
return;
} /* End of DS_FileUpdateHeader() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void DS_FileCloseDest(int32 FileIndex)
{
DS_AppFileStatus_t *FileStatus = &DS_AppData.FileStatus[FileIndex];
#if (DS_MOVE_FILES == TRUE)
/*
** Move file from working directory to downlink directory...
*/
int32 OS_result;
int32 PathLength;
char *FileName;
char PathName[DS_TOTAL_FNAME_BUFSIZE];
/*
** First, close the file...
*/
OS_close(FileStatus->FileHandle);
/*
** Move file only if table has a downlink directory name...
*/
if (DS_AppData.DestFileTblPtr->File[FileIndex].Movename[0] != '\0')
{
/*
** Make sure directory name does not end with slash character...
*/
strcpy(PathName, DS_AppData.DestFileTblPtr->File[FileIndex].Movename);
PathLength = strlen(PathName);
if (PathName[PathLength - 1] == '/')
{
PathName[PathLength - 1] = '\0';
PathLength--;
}
/*
** Get a pointer to slash character before the filename...
*/
FileName = strrchr(FileStatus->FileName, '/');
/*
** Verify that directory name plus filename is not too large...
*/
if ((PathLength + strlen(FileName)) < DS_TOTAL_FNAME_BUFSIZE)
{
/*
** Append the filename (with slash) to the directory name...
*/
strcat(PathName, FileName);
/*
** Use OS function to move/rename the file...
*/
OS_result = OS_mv(FileStatus->FileName, PathName);
/* OS_result = OS_rename(FileStatus->FileName, PathName); */
if (OS_result != OS_SUCCESS)
{
/*
** Error - send event but leave destination enabled...
*/
CFE_EVS_SendEvent(DS_MOVE_FILE_ERR_EID, CFE_EVS_ERROR,
"FILE MOVE error: src = '%s', tgt = '%s', result = %d",
FileStatus->FileName, PathName, OS_result);
}
}
else
{
/*
** Error - send event but leave destination enabled...
*/
CFE_EVS_SendEvent(DS_MOVE_FILE_ERR_EID, CFE_EVS_ERROR,
"FILE MOVE error: dir name = '%s', filename = '%s'",
PathName, FileName);
}
}
#else
/*
** Close the file...
*/
OS_close(FileStatus->FileHandle);
#endif
/*
** Reset status for this destination file...
*/
FileStatus->FileHandle = DS_CLOSED_FILE_HANDLE;
FileStatus->FileAge = 0;
FileStatus->FileSize = 0;
/*
** Remove previous filename from status data...
*/
CFE_PSP_MemSet(FileStatus->FileName, 0, DS_TOTAL_FNAME_BUFSIZE);
return;
} /* End of DS_FileCloseDest() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void DS_FileCreateDest(uint32 FileIndex)
{
DS_DestFileEntry_t *DestFile = &DS_AppData.DestFileTblPtr->File[FileIndex];
DS_AppFileStatus_t *FileStatus = &DS_AppData.FileStatus[FileIndex];
int32 Result;
/*
** Create filename from "path + base + sequence count + extension"...
*/
DS_FileCreateName(FileIndex);
if (FileStatus->FileName[0] != DS_STRING_TERMINATOR)
{
/*
** Success - create a new destination file...
*/
Result = OS_creat(FileStatus->FileName, OS_READ_WRITE);
if (Result < 0)
{
/*
** Error - send event, disable destination and reset filename...
*/
DS_AppData.FileWriteErrCounter++;
CFE_EVS_SendEvent(DS_CREATE_FILE_ERR_EID, CFE_EVS_ERROR,
"FILE CREATE error: result = %d, dest = %d, name = '%s'",
Result, FileIndex, FileStatus->FileName);
CFE_PSP_MemSet(FileStatus->FileName, 0, DS_TOTAL_FNAME_BUFSIZE);
/*
** Something needs to get fixed before we try again...
*/
FileStatus->FileState = DS_DISABLED;
}
else
{
/*
** Success - store the file handle...
*/
DS_AppData.FileWriteCounter++;
FileStatus->FileHandle = Result;
/*
** Initialize and write config specific file header...
*/
DS_FileWriteHeader(FileIndex);
/*
** Update sequence count if have one and write successful...
*/
if ((FileStatus->FileHandle != DS_CLOSED_FILE_HANDLE) &&
(DestFile->FileNameType == DS_BY_COUNT))
{
FileStatus->FileCount++;
if (FileStatus->FileCount > DS_MAX_SEQUENCE_COUNT)
{
FileStatus->FileCount = 0;
}
/*
** Update Critical Data Store (CDS)...
*/
DS_TableUpdateCDS();
}
}
}
return;
} /* End of DS_FileCreateDest() */
void DS_FileWriteHeader(int32 FileIndex)
{
#if (DS_FILE_HEADER_TYPE == DS_FILE_HEADER_CFE)
DS_DestFileEntry_t *DestFile = &DS_AppData.DestFileTblPtr->File[FileIndex];
DS_AppFileStatus_t *FileStatus = &DS_AppData.FileStatus[FileIndex];
CFE_FS_Header_t CFE_FS_Header;
DS_FileHeader_t DS_FileHeader;
int32 Result;
/*
** Initialize selected parts of the cFE file header...
*/
CFE_PSP_MemSet(&CFE_FS_Header, 0, sizeof(CFE_FS_Header_t));
CFE_FS_Header.SubType = DS_FILE_HDR_SUBTYPE;
strcpy(CFE_FS_Header.Description, DS_FILE_HDR_DESCRIPTION);
/*
** Let cFE finish the init and write the primary header...
*/
Result = CFE_FS_WriteHeader(FileStatus->FileHandle, &CFE_FS_Header);
if (Result == sizeof(CFE_FS_Header_t))
{
/*
** Success - update file size and data rate counters...
*/
DS_AppData.FileWriteCounter++;
FileStatus->FileSize += sizeof(CFE_FS_Header_t);
FileStatus->FileGrowth += sizeof(CFE_FS_Header_t);
/*
** Initialize the DS file header...
*/
CFE_PSP_MemSet(&DS_FileHeader, 0, sizeof(DS_FileHeader_t));
DS_FileHeader.FileTableIndex = FileIndex;
DS_FileHeader.FileNameType = DestFile->FileNameType;
strcpy(DS_FileHeader.FileName, FileStatus->FileName);
/*
** Manually write the secondary header...
*/
Result = OS_write(FileStatus->FileHandle, &DS_FileHeader, sizeof(DS_FileHeader_t));
if (Result == sizeof(DS_FileHeader_t))
{
/*
** Success - update file size and data rate counters...
*/
DS_AppData.FileWriteCounter++;
FileStatus->FileSize += sizeof(DS_FileHeader_t);
FileStatus->FileGrowth += sizeof(DS_FileHeader_t);
}
else
{
/*
** Error - send event, close file and disable destination...
*/
DS_FileWriteError(FileIndex, sizeof(DS_FileHeader_t), Result);
}
}
else
{
/*
** Error - send event, close file and disable destination...
*/
DS_FileWriteError(FileIndex, sizeof(CFE_FS_Header_t), Result);
}
#elif (DS_FILE_HEADER_TYPE == DS_FILE_HEADER_GPM)
DS_AppFileStatus_t *FileStatus = &DS_AppData.FileStatus[FileIndex];
DS_FileHeaderGPM_t DS_FileHeaderGPM;
int32 Result;
/*
** Initialize GPM file header...
*/
CFE_PSP_MemSet(&DS_FileHeaderGPM, ' ', sizeof(DS_FileHeaderGPM_t));
DS_FileHeaderGPM.SourceID[0] = 'S';
DS_FileHeaderGPM.SourceID[1] = 'C';
DS_FileHeaderGPM.SourceID[2] = 'H';
DS_FileHeaderGPM.SourceID[3] = 'K';
DS_FileConvertGPM(DS_FileHeaderGPM.SequenceID, FileStatus->FileCount);
DS_FileHeaderGPM.StartTime = DS_AppData.CurrentPktTime;
/*
** Write GPM file header to the file...
*/
Result = OS_write(FileStatus->FileHandle, &DS_FileHeaderGPM, sizeof(DS_FileHeaderGPM_t));
if (Result == sizeof(DS_FileHeaderGPM_t))
{
/*
** Success - update file size and data rate counters...
*/
DS_AppData.FileWriteCounter++;
FileStatus->FileSize += sizeof(DS_FileHeaderGPM_t);
FileStatus->FileGrowth += sizeof(DS_FileHeaderGPM_t);
}
else
{
/*
** Error - send event, close file and disable destination...
*/
DS_FileWriteError(FileIndex, sizeof(DS_FileHeaderGPM_t), Result);
}
#endif
return;
} /* End of DS_FileWriteHeader() */
int32 SIMCI_TaskInit(void) {
int32 Status = CFE_SUCCESS;
CFE_ES_RegisterApp();
SIMCI_AppData.CommandPipe = 0;
SIMCI_AppData.MsgPtr = NULL;
SIMCI_AppData.UplinkSocketID = 0;
SIMCI_AppData.IngestSocketID = 0;
SIMCI_AppData.UplinkSocketConnected = FALSE;
SIMCI_AppData.IngestSocketConnected = FALSE;
/* Set up and register events */
SIMCI_AppData.EventFilters[0].EventID = SIMCI_COMMANDRST_INF_EID;
SIMCI_AppData.EventFilters[0].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[1].EventID = SIMCI_UPLINK_ERR_EID;
SIMCI_AppData.EventFilters[1].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[2].EventID = SIMCI_INGEST_ERR_EID;
SIMCI_AppData.EventFilters[2].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[3].EventID = SIMCI_CRCMDPIPE_ERR_EID;
SIMCI_AppData.EventFilters[3].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[4].EventID = SIMCI_SOCKETCREATE_ERR_EID;
SIMCI_AppData.EventFilters[4].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[5].EventID = SIMCI_SOCKETBIND_ERR_EID;
SIMCI_AppData.EventFilters[5].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[6].EventID = SIMCI_MSGID_ERR_EID;
SIMCI_AppData.EventFilters[6].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[7].EventID = SIMCI_CC1_ERR_EID;
SIMCI_AppData.EventFilters[7].Mask = CFE_EVS_NO_FILTER;
CFE_EVS_Register(SIMCI_AppData.EventFilters, SIMCI_FILTERED_EVT_COUNT, CFE_EVS_BINARY_FILTER);
if (Status != CFE_SUCCESS) {
CFE_ES_WriteToSysLog("SIMCI: Error registering events, RC = 0x%08X\n", Status);
return Status;
}
/* Initialize Housekeeping */
CFE_SB_InitMsg(&SIMCI_AppData.HkPacket, SIMCI_HK_TLM_MID, sizeof(SIMCI_HkPacket_t), TRUE);
SIMCI_ResetCounters();
SIMCI_AppData.HkPacket.ingest_socket_connected = FALSE;
SIMCI_AppData.HkPacket.uplink_socket_connected = FALSE;
/* Create a command pipe and subscribe to its messages */
Status = CFE_SB_CreatePipe(&SIMCI_AppData.CommandPipe, SIMCI_PIPE_DEPTH, "SIMCI_CMD_PIPE");
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_CRCMDPIPE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Can't create command pipe, RC=%08X", Status);
return Status;
}
Status = CFE_SB_Subscribe(SIMCI_CMD_MID, SIMCI_AppData.CommandPipe);
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_SUBSCRIBE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error subscribing to SIMCI_CMD_MID(0x%04X), RC=%08X", SIMCI_CMD_MID, Status);
return Status;
}
Status = CFE_SB_Subscribe(SIMCI_SEND_HK_MID, SIMCI_AppData.CommandPipe);
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_SUBSCRIBE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error subscribing to SIMCI_SEND_HK_MID(0x%04X), RC=%08X", SIMCI_SEND_HK_MID, Status);
return Status;
}
/* Set up Uplink socket */
SIMCI_AppData.UplinkSocketID = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (SIMCI_AppData.UplinkSocketID < 0) {
CFE_EVS_SendEvent(SIMCI_SOCKETCREATE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error creating uplink socket, errno=%08X", errno);
return ERROR;
} else {
struct sockaddr_in socket_address;
CFE_PSP_MemSet((void*)&socket_address, 0, sizeof(socket_address));
socket_address.sin_family = AF_INET;
socket_address.sin_addr.s_addr = htonl(INADDR_ANY);
socket_address.sin_port = htons(SIMCI_UPLINK_PORT);
Status = bind(SIMCI_AppData.UplinkSocketID, (struct sockaddr *)&socket_address, sizeof(socket_address));
if (Status == ERROR) {
CFE_EVS_SendEvent(SIMCI_SOCKETBIND_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error binding uplink socket, errno=%08X", errno);
return Status;
} else {
SIMCI_AppData.UplinkSocketConnected = TRUE;
}
}
/* Set up Ingest socket */
SIMCI_AppData.IngestSocketID = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (SIMCI_AppData.IngestSocketID < 0) {
CFE_EVS_SendEvent(SIMCI_SOCKETCREATE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error creating ingest socket, errno=%08X", errno);
return ERROR;
} else {
struct sockaddr_in socket_address;
CFE_PSP_MemSet((void*)&socket_address, 0, sizeof(socket_address));
socket_address.sin_family = AF_INET;
socket_address.sin_addr.s_addr = htonl(INADDR_ANY);
socket_address.sin_port = htons(SIMCI_INGEST_PORT);
Status = bind(SIMCI_AppData.IngestSocketID, (struct sockaddr *)&socket_address, sizeof(socket_address));
if (Status == ERROR) {
CFE_EVS_SendEvent(SIMCI_SOCKETBIND_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error binding ingest socket, errno=%08X", errno);
return Status;
} else {
SIMCI_AppData.IngestSocketConnected = TRUE;
}
}
Status = SIMCI_HWIF_Init();
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_HWIF_ERR_EID, CFE_EVS_ERROR, "Error initializing HWIF, RC=0x%08X", Status);
return Status;
}
/* Install the delete handler */
OS_TaskInstallDeleteHandler((void*)&SIMCI_DeleteCallback);
CFE_EVS_SendEvent(SIMCI_STARTUP_INF_EID, CFE_EVS_INFORMATION, "SIMCI App Initialized");
return CFE_SUCCESS;
}
int32 CFE_TBL_GetAddress_FunctionHook ( void **TblPtr,
CFE_TBL_Handle_t TblHandle )
/* To be used before control is turned over to input command file. */
/* Used in concert with CFE_TBL_Register_FunctionHook to set up test cases. */
/* Count 1: invalid table */
/* Count 2: valid table and unexpected return code */
/* Count 3: valid table with enabled field == TRUE */
/* Count 4: valid table and nominal return code */
{
static uint32 Count = 0;
Count++;
static MD_DwellTableLoad_t DwellTbl;
static int16 Num1 = 5;
int32 RetVal;
UTF_put_text("CALL #%d to GetAddress_FunctionHook\n", Count);
CFE_PSP_MemSet(&DwellTbl, 0, sizeof(MD_DwellTableLoad_t));
/********************************/
/* Set up Memory */
/********************************/
/* Calling CFE_PSP_MemRangeSet makes calls to CFE_PSP_MemValidateRange for this */
/* range return true. */
RetVal = CFE_PSP_MemRangeSet(1, CFE_PSP_MEM_RAM, (uint32)&Num1,
0x00000002, CFE_PSP_MEM_SIZE_BYTE, CFE_PSP_MEM_ATTR_READ);
if (RetVal != OS_SUCCESS)
{
UTF_put_text ("Error return %d from CFE_PSP_MemRangeSet\n", RetVal);
}
/* Recover invalid table w/invalid value for enable flag */
/* for dwell tables #1 and #4 */
if (Count == 1)
/* Use for first dwell table */
{
/* Set TblPtr to point to an invalid table */
DwellTbl.Enabled = 17; /* invalid value */
DwellTbl.Entry[0].Length = 2;
DwellTbl.Entry[0].Delay = 1;
DwellTbl.Entry[0].DwellAddress.Offset = (uint32)&Num1;
strcpy (DwellTbl.Entry[0].DwellAddress.SymName, "");
DwellTbl.Entry[1].Length = 0;
DwellTbl.Entry[1].Delay = 0;
DwellTbl.Entry[1].DwellAddress.Offset = 0;
/* strcpy (DwellTbl.Entry[1].DwellAddress.SymName, ""); */
DwellTbl.Entry[1].DwellAddress.SymName[0]='\0';
/* */
*TblPtr = (void *)&DwellTbl;
return (CFE_TBL_INFO_UPDATED);
}
else if (Count == 3)
{
DwellTbl.Enabled = 1;
DwellTbl.Entry[0].Length = 2;
DwellTbl.Entry[0].Delay = 1;
DwellTbl.Entry[0].DwellAddress.Offset = (uint32)&Num1;
strcpy (DwellTbl.Entry[0].DwellAddress.SymName, "");
DwellTbl.Entry[1].Length = 0;
DwellTbl.Entry[1].Delay = 0;
DwellTbl.Entry[1].DwellAddress.Offset = 0;
/* strcpy (DwellTbl.Entry[1].DwellAddress.SymName, ""); */
DwellTbl.Entry[1].DwellAddress.SymName[0]='\0';
/* */
*TblPtr = (void *)&DwellTbl;
return (CFE_TBL_INFO_UPDATED);
}
else if (Count == 2)
{
*TblPtr = (void *)0;
return (CFE_TBL_ERR_NO_ACCESS);
}
/* Recover valid tables */
else
/* this will cover 4th call on initialization, as well as any */
/* for any updates. */
{
/* Set TblPtr to point to a valid table */
DwellTbl.Enabled = MD_DWELL_STREAM_DISABLED;
DwellTbl.Entry[0].Length = 2;
DwellTbl.Entry[0].Delay = 1;
DwellTbl.Entry[0].DwellAddress.Offset = (uint32)&Num1;
strcpy (DwellTbl.Entry[0].DwellAddress.SymName, "");
DwellTbl.Entry[1].Length = 0;
DwellTbl.Entry[1].Delay = 0;
DwellTbl.Entry[1].DwellAddress.Offset = 0;
strcpy (DwellTbl.Entry[1].DwellAddress.SymName, "");
/* */
*TblPtr = (void *)&DwellTbl;
return (CFE_TBL_INFO_UPDATED);
}
}
int32 SC_AppInit(void)
{
int32 Result;
/* Clear global data structures */
CFE_PSP_MemSet(&SC_OperData, 0, sizeof(SC_OperData_t));
CFE_PSP_MemSet(&SC_AppData, 0, sizeof(SC_AppData_t));
/* Number of ATS and RTS commands already executed this second */
SC_OperData.NumCmdsSec = 0;
/* Continue ATS execution if ATS command checksum fails */
SC_AppData.ContinueAtsOnFailureFlag = SC_CONT_ON_FAILURE_START;
/* Make sure nothing is running */
SC_AppData.NextProcNumber = SC_NONE;
SC_AppData.NextCmdTime[SC_ATP] = SC_MAX_TIME;
SC_AppData.NextCmdTime[SC_RTP] = SC_MAX_TIME;
/* Initialize the SC housekeeping packet */
CFE_SB_InitMsg(&SC_OperData.HkPacket, SC_HK_TLM_MID, sizeof(SC_HkTlm_t), FALSE);
/* Select auto-exec RTS to start during first HK request */
if (CFE_ES_GetResetType(NULL) == CFE_ES_POWERON_RESET)
{
SC_AppData.AutoStartRTS = RTS_ID_AUTO_POWER_ON;
}
else
{
SC_AppData.AutoStartRTS = RTS_ID_AUTO_PROCESSOR;
}
/* Must be able to register for events */
Result = CFE_EVS_Register(NULL,0,CFE_EVS_NO_FILTER);
if (Result != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("Event Services Register returned: 0x%08X\n", Result);
return(Result);
}
/* Must be able to create Software Bus message pipe */
Result = CFE_SB_CreatePipe(&SC_OperData.CmdPipe, SC_PIPE_DEPTH, SC_CMD_PIPE_NAME);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_CREATE_ERR_EID, CFE_EVS_ERROR,
"Software Bus Create Pipe returned: 0x%08X", Result);
return(Result);
}
/* Must be able to subscribe to HK request command */
Result = CFE_SB_Subscribe(SC_SEND_HK_MID, SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_HK_ERR_EID, CFE_EVS_ERROR,
"Software Bus subscribe to housekeeping returned: 0x%08X", Result);
return(Result);
}
/* Must be able to subscribe to 1Hz wakeup command */
Result = CFE_SB_Subscribe(SC_1HZ_WAKEUP_MID, SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_1HZ_ERR_EID, CFE_EVS_ERROR,
"Software Bus subscribe to 1 Hz cycle returned: 0x%08X", Result);
return(Result);
}
/* Must be able to subscribe to SC commands */
Result = CFE_SB_Subscribe(SC_CMD_MID, SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_CMD_ERR_EID, CFE_EVS_ERROR,
"Software Bus subscribe to command returned: 0x%08X", Result);
return(Result);
}
/* Must be able to create and initialize tables */
Result = SC_InitTables();
if (Result != CFE_SUCCESS)
{
return(Result);
}
/* Send application startup event */
CFE_EVS_SendEvent(SC_INIT_INF_EID, CFE_EVS_INFORMATION,
"SC Initialized. Version %d.%d.%d.%d",
SC_MAJOR_VERSION, SC_MINOR_VERSION, SC_REVISION, SC_MISSION_REV);
return(CFE_SUCCESS);
} /* end SC_AppInit() */
void Create_Input_File0(void)
{
/* FILE *to; */
int8 values[4] = {5,10,15,20};
char tableName[30];
CFE_FS_Header_t StdFileHeader;
CFE_TBL_File_Hdr_t TblFileHeader;
int32 FileDescriptor;
int32 Status;
int32 EndianCheck = 0x01020304;
/* to = fopen("/tt_table_values0.dat", "wb");
if (to == 0)
{
UTF_error("Error opening file /tt_table_initial_values.dat to write\n");
UTF_exit();
}
fwrite(values, sizeof(int8), 4, to);
fclose(to); */
strcpy (tableName, "TT.FourNumbers");
/* Clear Header of any garbage before copying content */
CFE_PSP_MemSet(&StdFileHeader, 0, sizeof(CFE_FS_Header_t));
CFE_PSP_MemSet(&TblFileHeader, 0, sizeof(CFE_TBL_File_Hdr_t));
/* Create a new dump file, overwriting anything that may have existed previously */
FileDescriptor = OS_creat("/ram/tt_table_values0.dat", OS_WRITE_ONLY);
if (FileDescriptor >= OS_FS_SUCCESS)
{
/* Initialize the standard cFE File Header for the Dump File */
StdFileHeader.SubType = CFE_FS_TBL_IMG_SUBTYPE;
strcpy(&StdFileHeader.Description[0], "Table Load File");
/* Output the Standard cFE File Header to the Dump File */
Status = CFE_FS_WriteHeader(FileDescriptor, &StdFileHeader);
if (Status == sizeof(CFE_FS_Header_t))
{
/* Initialize the Table Image Header for the Dump File */
CFE_PSP_MemCpy(TblFileHeader.TableName, tableName, CFE_TBL_MAX_FULL_NAME_LEN);
TblFileHeader.Offset = 0;
TblFileHeader.NumBytes = 4;
TblFileHeader.Reserved = 0;
/* Determine if this is a little endian processor */
if ((*(char *)&EndianCheck) == 0x04)
{
CFE_TBL_ByteSwapTblHeader(&TblFileHeader);
}
/* Output the Table Image Header to the Dump File */
Status = OS_write(FileDescriptor, &TblFileHeader, sizeof(CFE_TBL_File_Hdr_t));
/* Make sure the header was output completely */
if (Status == sizeof(CFE_TBL_File_Hdr_t))
{
/* Output the requested data to the dump file */
/* Output the active table image data to the dump file */
Status = OS_write(FileDescriptor, values, 4);
}
}
/* We are done writing the load file. Close it. */
OS_close(FileDescriptor);
}
}
/******************************************************************************
** Function: TBLMGR_ResetStatus
**
*/
void TBLMGR_ResetStatus()
{
CFE_PSP_MemSet((void *)TblMgr, 0, sizeof(TBLMGR_Class));
} /* End TBLMGR_ResetStatus() */
