/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 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() */