CORDET Framework - C2 Implementation
CrFwOutStream.c
Go to the documentation of this file.
1 
19 #include <stdlib.h>
20 #include<string.h>
21 /* Include configuration files */
22 #include "CrFwOutStreamUserPar.h"
23 #include "CrFwCmpData.h"
24 /* Include framework files */
25 #include "CrFwConstants.h"
26 #include "CrFwRepErr.h"
27 #include "CrFwTime.h"
28 #include "BaseCmp/CrFwBaseCmp.h"
29 #include "CrFwOutStream.h"
30 #include "BaseCmp/CrFwInitProc.h"
31 #include "BaseCmp/CrFwResetProc.h"
33 #include "Pckt/CrFwPckt.h"
34 #include "Pckt/CrFwPcktQueue.h"
36 /* Include FW Profile files */
37 #include "FwSmConstants.h"
38 #include "FwSmDCreate.h"
39 #include "FwSmConfig.h"
40 #include "FwSmCore.h"
41 #include "FwPrConstants.h"
42 #include "FwPrDCreate.h"
43 #include "FwPrConfig.h"
44 #include "FwPrCore.h"
45 
47 static FwSmDesc_t baseOutStreamSmDesc = NULL;
48 
51 
54 
57 
60 
63 
66 
69 
72 
75 
78 
81 
84 
96 static void EnqueuePckt(FwSmDesc_t smDesc);
97 
104 static void FlushPcktQueue(FwSmDesc_t smDesc);
105 
112 static void ResetSeqCounter(FwSmDesc_t smDesc);
113 
120 static void SendOrEnqueue(FwSmDesc_t smDesc);
121 
128 static int IsPacketQueueEmpty(FwSmDesc_t smDesc);
129 
130 /*-----------------------------------------------------------------------------------------*/
132  const FwSmCounterS1_t nOfStates = 2; /* Number of states */
133  const FwSmCounterS1_t nOfChoicePseudoStates = 1; /* Number of choice pseudo-states */
134  const FwSmCounterS1_t nOfTrans = 6; /* Number of transitions */
135  const FwSmCounterS1_t nOfActions = 4; /* Number of actions */
136  const FwSmCounterS1_t nOfGuards = 1; /* Number of guards */
137  const FwSmCounterS1_t CPS_1 = 1; /* Identifier of first choice pseudo-state */
138  FwSmDesc_t esm;
139  FwPrDesc_t resetPr, execPr, initPr;
140 
141  if (i >= CR_FW_NOF_OUTSTREAM) {
143  return NULL;
144  }
145 
146  /* If not yet done, create the base OutStream SM */
147  if (baseOutStreamSmDesc == NULL) {
148  /* Extend the Base Component */
149  baseOutStreamSmDesc = FwSmCreateDer(CrFwBaseCmpMake());
150  /* Create the OutStream SM and then embed it in state CONFIGURED of the Base Component */
151  esm = FwSmCreate(nOfStates, nOfChoicePseudoStates, nOfTrans, nOfActions, nOfGuards);
152  FwSmAddState(esm, CR_FW_OUTSTREAM_STATE_READY, 1, NULL, NULL, NULL, NULL);
153  FwSmAddState(esm, CR_FW_OUTSTREAM_STATE_BUFFERING, 2, NULL, NULL, NULL, NULL);
154  FwSmAddChoicePseudoState(esm, CPS_1, 2);
155  FwSmAddTransIpsToSta(esm, CR_FW_OUTSTREAM_STATE_READY, &ResetSeqCounter);
156  FwSmAddTransStaToCps(esm, CR_FW_OUTSTREAM_TR_SEND, CR_FW_OUTSTREAM_STATE_READY, CPS_1,
157  &SendOrEnqueue, NULL);
158  FwSmAddTransCpsToSta(esm, CPS_1, CR_FW_OUTSTREAM_STATE_READY, NULL, &IsPacketQueueEmpty);
159  FwSmAddTransCpsToSta(esm, CPS_1, CR_FW_OUTSTREAM_STATE_BUFFERING, NULL, NULL); /* Else Transition */
161  CPS_1, &FlushPcktQueue, NULL);
162  FwSmAddTransStaToSta(esm, CR_FW_OUTSTREAM_TR_SEND, CR_FW_OUTSTREAM_STATE_BUFFERING,
165  }
166 
167  if (outStreamDesc[i] != NULL) {
168  return outStreamDesc[i]; /* The requested SM has already been created */
169  }
170 
171  /* Create the requested SM as an extension of the base OutStream SM */
172  outStreamDesc[i] = FwSmCreateDer(baseOutStreamSmDesc);
173 
174  /* Create the Reset Procedure for the OutStream Component */
175  resetPr = FwPrCreateDer(CrFwCmpGetResetProc());
176  FwPrOverrideAction(resetPr, &CrFwBaseCmpDefConfigCheck, outStreamConfigCheck[i]);
177  FwPrOverrideAction(resetPr, &CrFwBaseCmpDefConfigAction, outStreamConfigAction[i]);
178 
179  /* Create the Initialization Procedure for the OutStream Component */
180  initPr = FwPrCreateDer(CrFwCmpGetInitProc());
181  FwPrOverrideAction(initPr, &CrFwBaseCmpDefInitCheck, outStreamInitCheck[i]);
182  FwPrOverrideAction(initPr, &CrFwBaseCmpDefInitAction, outStreamInitAction[i]);
183 
184  /* Override the Shutdown Action for the OutStream Component */
186 
187  /* Get the Dummy Execution Procedure for the OutStream Component */
188  execPr = CrFwBaseCmpGetDummyExecProc();
189 
190  /* Initialize the data for the requested SM */
191  outStreamData[i].outcome = 1;
192  outStreamData[i].initProc = initPr;
193  outStreamData[i].resetProc = resetPr;
194  outStreamData[i].execProc = execPr;
195  outStreamData[i].instanceId = i;
196  outStreamData[i].typeId = CR_FW_OUTSTREAM_TYPE;
197  outStreamCmpSpecificData[i].dest = outStreamDest[i];
198  outStreamCmpSpecificData[i].handoverPckt = outStreamHandoverPckt[i];
199  outStreamData[i].cmpSpecificData = &outStreamCmpSpecificData[i];
200 
201  /* Attach the data to the OutStream state machine and to its procedures.
202  * The data is attached to the outer SM and to the SM embedded in state CONFIGURED
203  * and to the Initialization and Reset Procedures. */
204  FwSmSetData(outStreamDesc[i], &outStreamData[i]);
205  FwSmSetData(FwSmGetEmbSm(outStreamDesc[i], CR_FW_BASE_STATE_CONFIGURED), &outStreamData[i]);
206  FwPrSetData(outStreamData[i].initProc, &outStreamData[i]);
207  FwPrSetData(outStreamData[i].resetProc, &outStreamData[i]);
208 
209  /* Start the OutStream */
210  FwSmStart(outStreamDesc[i]);
211 
212  return outStreamDesc[i];
213 }
214 
215 /*-----------------------------------------------------------------------------------------*/
216 CrFwBool_t CrFwOutStreamIsInReady(FwSmDesc_t smDesc) {
217  return (FwSmGetCurStateEmb(smDesc) == CR_FW_OUTSTREAM_STATE_READY);
218 }
219 
220 /*-----------------------------------------------------------------------------------------*/
222  return (FwSmGetCurStateEmb(smDesc) == CR_FW_OUTSTREAM_STATE_BUFFERING);
223 }
224 
225 /*-----------------------------------------------------------------------------------------*/
228  for (i=0; i<CR_FW_NOF_OUTSTREAM; i++)
229  if (outStreamCmpSpecificData[i].dest == dest)
230  return outStreamDesc[i];
231 
233  return NULL;
234 }
235 
236 /*-----------------------------------------------------------------------------------------*/
237 void CrFwOutStreamSend(FwSmDesc_t smDesc, CrFwPckt_t pckt) {
238  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
239  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
240  cmpSpecificData->pckt = pckt;
241  FwSmMakeTrans(smDesc, CR_FW_OUTSTREAM_TR_SEND);
242 }
243 
244 /*-----------------------------------------------------------------------------------------*/
245 void CrFwOutStreamConnectionAvail(FwSmDesc_t smDesc) {
246  FwSmMakeTrans(smDesc, CR_FW_OUTSTREAM_TR_CONNECTION_AVAILABLE);
247 }
248 
249 /*-----------------------------------------------------------------------------------------*/
251  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
252  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
253  return cmpSpecificData->dest;
254 }
255 
256 /*-----------------------------------------------------------------------------------------*/
258  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
259  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
260  return cmpSpecificData->seqCnt[group];
261 }
262 
263 /*-----------------------------------------------------------------------------------------*/
264 void CrFwOutStreamSetSeqCnt(FwSmDesc_t smDesc, CrFwGroup_t group, CrFwSeqCnt_t seqCnt)
265 {
266  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
267  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
268  cmpSpecificData->seqCnt[group] = seqCnt;
269 }
270 
271 /*-----------------------------------------------------------------------------------------*/
273  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
274  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
275  return CrFwPcktQueueGetNOfPckts(&(cmpSpecificData->pcktQueue));
276 }
277 
278 /*-----------------------------------------------------------------------------------------*/
280  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
281  return outStreamNOfGroups[outStreamBaseData->instanceId];
282 }
283 
284 /*-----------------------------------------------------------------------------------------*/
286  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
287  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
288  return CrFwPcktQueueGetSize(&(cmpSpecificData->pcktQueue));
289 }
290 
291 /*-----------------------------------------------------------------------------------------*/
292 void CrFwOutStreamDefConfigAction(FwPrDesc_t prDesc) {
293  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwPrGetData(prDesc);
294  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
295 
296  CrFwPcktQueueReset(&(cmpSpecificData->pcktQueue));
297  cmpSpecificData->dest = outStreamDest[outStreamBaseData->instanceId];
298  cmpSpecificData->handoverPckt = outStreamHandoverPckt[outStreamBaseData->instanceId];
299  outStreamBaseData->outcome = 1;
300 }
301 
302 /*-----------------------------------------------------------------------------------------*/
303 void CrFwOutStreamDefShutdownAction(FwSmDesc_t smDesc) {
304  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
305  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
306  CrFwPcktQueueShutdown(&(cmpSpecificData->pcktQueue));
307  free(cmpSpecificData->seqCnt);
308  cmpSpecificData->seqCnt = NULL;
309 }
310 
311 /*-----------------------------------------------------------------------------------------*/
312 void CrFwOutStreamDefInitAction(FwPrDesc_t prDesc) {
313  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwPrGetData(prDesc);
314  CrFwInstanceId_t i = outStreamBaseData->instanceId;
315  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
316 
317  cmpSpecificData->seqCnt = malloc(sizeof(CrFwSeqCnt_t)*outStreamNOfGroups[i]);
318  CrFwPcktQueueInit(&(outStreamCmpSpecificData[i].pcktQueue),outStreamPcktQueueSize[i]);
319  outStreamBaseData->outcome = 1;
320 }
321 
322 /*-----------------------------------------------------------------------------------------*/
323 static void EnqueuePckt(FwSmDesc_t smDesc) {
324  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
325  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
326  CrFwPckt_t pckt = cmpSpecificData->pckt;
327  CrFwPckt_t pcktCopy;
328  CrFwPcktQueue_t pcktQueue = &(cmpSpecificData->pcktQueue);
330 
331  pcktCopy = CrFwPcktMake(CrFwPcktGetLength(pckt));
332  if (pcktCopy == NULL) {
333  CrFwRepErr(crOutStreamNoMorePckt, outStreamBaseData->typeId, outStreamBaseData->instanceId);
334  return;
335  }
336  memcpy(pcktCopy,pckt,len);
337  if (!CrFwPcktQueuePush(pcktQueue, pcktCopy)) {
338  CrFwRepErr(crOutStreamPQFull, outStreamBaseData->typeId, outStreamBaseData->instanceId);
339  CrFwPcktRelease(pcktCopy);
340  }
341 
342  return;
343 }
344 
345 /*-----------------------------------------------------------------------------------------*/
346 static void FlushPcktQueue(FwSmDesc_t smDesc) {
347  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
348  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
349  CrFwPckt_t oldestPckt;
350  CrFwPcktQueue_t pcktQueue = &(cmpSpecificData->pcktQueue);
351  CrFwGroup_t oldestPcktGroup = 0;
352  CrFwCrc_t crc;
353 
354  while (CrFwPcktQueueIsEmpty(pcktQueue)==0) {
355  oldestPckt = CrFwPcktQueueGetOldest(pcktQueue);
356  if (CrFwPcktGetSrc(oldestPckt) == CR_FW_HOST_APP_ID) { /* pckt originates from host application */
357  oldestPcktGroup = CrFwPcktGetGroup(oldestPckt);
358  if (oldestPcktGroup < outStreamNOfGroups[outStreamBaseData->instanceId]) {
359  CrFwPcktSetSeqCnt(oldestPckt, cmpSpecificData->seqCnt[oldestPcktGroup]);
360  crc = CrFwPcktComputeCrc(oldestPckt);
361  CrFwPcktSetCrc(oldestPckt, crc);
362  } else /* pckt belongs to a non-existent group */
363  CrFwRepErrGroup(crOutStreamIllGroup, outStreamBaseData->typeId,
364  outStreamBaseData->instanceId, oldestPcktGroup);
365  }
366  if (cmpSpecificData->handoverPckt(oldestPckt) != 1)
367  return;
368  if (CrFwPcktGetSrc(oldestPckt) == CR_FW_HOST_APP_ID)
369  if (oldestPcktGroup < outStreamNOfGroups[outStreamBaseData->instanceId])
370  cmpSpecificData->seqCnt[oldestPcktGroup]++;
371  CrFwPcktQueuePop(pcktQueue); /* remove packet from PQ */
372  CrFwPcktRelease(oldestPckt);
373  }
374  return;
375 }
376 
377 /*-----------------------------------------------------------------------------------------*/
378 static void ResetSeqCounter(FwSmDesc_t smDesc) {
379  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
380  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
381  CrFwGroup_t i;
382  for (i=0; i<outStreamNOfGroups[outStreamBaseData->instanceId]; i++)
383  cmpSpecificData->seqCnt[i] = 1;
384 }
385 
386 /*-----------------------------------------------------------------------------------------*/
387 static void SendOrEnqueue(FwSmDesc_t smDesc) {
388  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
389  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
390  CrFwPckt_t pckt = cmpSpecificData->pckt;
391  CrFwPckt_t pcktCopy;
392  CrFwPcktLength_t len;
393  CrFwPcktQueue_t pcktQueue;
395  CrFwCrc_t crc;
396 
397  if (CrFwPcktGetSrc(pckt) == CR_FW_HOST_APP_ID) { /* pckt originates from host application */
398  pcktGroup = CrFwPcktGetGroup(pckt);
399  if (pcktGroup < outStreamNOfGroups[outStreamBaseData->instanceId]) {
400  CrFwPcktSetSeqCnt(pckt, cmpSpecificData->seqCnt[pcktGroup]);
401  crc = CrFwPcktComputeCrc(pckt);
402  CrFwPcktSetCrc(pckt, crc);
403  } else /* pckt belongs to a non-existent group */
404  CrFwRepErrGroup(crOutStreamIllGroup, outStreamBaseData->typeId,
405  outStreamBaseData->instanceId, pcktGroup);
406  }
407  if (cmpSpecificData->handoverPckt(pckt) != 1) {
408  pcktQueue = &(cmpSpecificData->pcktQueue);
409  len = CrFwPcktGetLength(pckt);
410  pcktCopy = CrFwPcktMake(len);
411  if (pcktCopy == NULL) {
412  CrFwRepErr(crOutStreamNoMorePckt, outStreamBaseData->typeId, outStreamBaseData->instanceId);
413  return;
414  }
415  memcpy(pcktCopy,pckt,len);
416  CrFwPcktQueuePush(pcktQueue,pcktCopy); /* Enqueue packet, queue is empty at entry in READY */
417  } else {
418  if (CrFwPcktGetSrc(pckt) == CR_FW_HOST_APP_ID)
419  if (pcktGroup < outStreamNOfGroups[outStreamBaseData->instanceId])
420  cmpSpecificData->seqCnt[pcktGroup]++;
421  }
422 }
423 
424 /*-----------------------------------------------------------------------------------------*/
425 static int IsPacketQueueEmpty(FwSmDesc_t smDesc) {
426  CrFwCmpData_t* outStreamBaseData = (CrFwCmpData_t*)FwSmGetData(smDesc);
427  CrFwOutStreamData_t* cmpSpecificData = (CrFwOutStreamData_t*)outStreamBaseData->cmpSpecificData;
428  return CrFwPcktQueueIsEmpty(&(cmpSpecificData->pcktQueue));
429 }
430 
void CrFwOutStreamDefConfigAction(FwPrDesc_t prDesc)
Default configuration action for an OutStream.
unsigned char CrFwCounterU1_t
Type used for unsigned integers with a "short" range.
#define CR_FW_OUTSTREAM_DEST
The destinations of the OutStream components.
Type for the Framework Component Data (FCD).
Definition: CrFwCmpData.h:79
Interface through which framework components access the current time.
void CrFwRepErrGroup(CrFwRepErrCode_t errCode, CrFwTypeId_t typeId, CrFwInstanceId_t instanceId, CrFwGroup_t group)
Report an error which has one single parameter attached to it representing a command or report group...
Definition: CrFwRepErr.c:128
static CrFwCounterU1_t outStreamPcktQueueSize[CR_FW_NOF_OUTSTREAM]
The sizes of the packet queues in the OutStream components.
Definition: CrFwOutStream.c:50
void CrFwOutStreamSend(FwSmDesc_t smDesc, CrFwPckt_t pckt)
Send a packet to the OutStream.
void CrFwPcktQueueReset(CrFwPcktQueue_t pcktQueue)
Reset the packet queue.
Definition: CrFwPcktQueue.c:73
unsigned short CrFwInstanceId_t
Type used for instance identifiers.
CrFwOutcome_t outcome
The outcome of an action or check executed by a state machine or by one of its procedures.
Definition: CrFwCmpData.h:93
CrFwBool_t CrFwPcktQueueIsEmpty(CrFwPcktQueue_t pcktQueue)
Return 1 if the packet queue is empty and 0 otherwise.
Type for the data describing an OutStream.
CrFwPckt_t CrFwPcktQueuePop(CrFwPcktQueue_t pcktQueue)
Pop a packet from the packet queue.
Definition: CrFwPcktQueue.c:25
FwPrDesc_t CrFwCmpGetResetProc()
Retrieve the singleton instance of the CRP.
Definition: CrFwResetProc.c:45
static FwSmDesc_t baseOutStreamSmDesc
Base OutStream from which all other OutStreams are derived.
Definition: CrFwOutStream.c:47
Definition of the Framework Component Data (FCD) Type.
CrFwCounterU1_t CrFwOutStreamGetNOfPendingPckts(FwSmDesc_t smDesc)
Return the number of packets currently in the packet queue of an OutStream.
CrFwGroup_t CrFwOutStreamGetNOfGroups(FwSmDesc_t smDesc)
Return the number of groups associated to the OutStream.
#define CR_FW_NOF_OUTSTREAM
The number of OutStream components in the application.
void CrFwSetAppErrCode(CrFwAppErrCode_t errCode)
Set the value of the application error code (see CrFwGetAppErrCode).
#define CR_FW_HOST_APP_ID
The identifier of the host application.
CrFwPckt_t pckt
The packet to be sent out.
unsigned char * CrFwPckt_t
Type for packets (see CrFwPckt.h).
Definition: CrFwConstants.h:38
static FwPrAction_t outStreamConfigAction[CR_FW_NOF_OUTSTREAM]
The functions implementing the configuration actions for the InStream components. ...
Definition: CrFwOutStream.c:71
CrFwPckt_t CrFwPcktMake(CrFwPcktLength_t pcktLength)
Make function for command or report packets.
Definition: CrFwPckt.c:129
CrFwDestSrc_t CrFwPcktGetSrc(CrFwPckt_t pckt)
Return the source of the command or report encapsulated in a packet.
Definition: CrFwPckt.c:327
CrFwBool_t CrFwPcktQueuePush(CrFwPcktQueue_t pcktQueue, CrFwPckt_t pckt)
Push a packet onto the packet queue.
Definition: CrFwPcktQueue.c:52
void CrFwBaseCmpDefConfigCheck(FwPrDesc_t prDesc)
Function which performs the default Configuration Check of the CRP.
Definition: CrFwResetProc.c:33
#define CR_FW_OUTSTREAM_TR_CONNECTION_AVAILABLE
Identifier for transition command "Reset" in the OutStream State Machine.
CrFwSeqCnt_t * seqCnt
Array holding sequence counters for the groups associated to the OutStream.
#define CR_FW_OUTSTREAM_STATE_READY
State identifier for state READY in the OutStream State Machine.
Definition of the OutStream component.
void CrFwPcktQueueInit(CrFwPcktQueue_t pcktQueue, CrFwCounterU1_t size)
Initializes the packet queue.
Definition: CrFwPcktQueue.c:95
static CrFwPcktHandover_t outStreamHandoverPckt[CR_FW_NOF_OUTSTREAM]
The functions implementing the packet hand-over operations for the OutStream components.
Definition: CrFwOutStream.c:59
#define CR_FW_OUTSTREAM_TR_SEND
Identifier for transition command "Send" in the OutStream State Machine.
static FwSmDesc_t outStreamDesc[CR_FW_NOF_OUTSTREAM]
The descriptors of the OutStream State Machines.
Definition: CrFwOutStream.c:77
Interface for creating and accessing a report or command packet.
void CrFwBaseCmpDefShutdownAction(FwSmDesc_t smDesc)
Function which performs the Shutdown Action for the Base State Machine.
Definition: CrFwBaseCmp.c:217
int CrFwBool_t
Type used for boolean values (1 represent "true" and 0 represents "false").
Definition: CrFwConstants.h:32
FwPrDesc_t resetProc
The Component Reset Procedure (CRP) (see CrFwResetProc.h).
Definition: CrFwCmpData.h:97
Dummy Component Execution Procedure (CEP) for the Base Component.
unsigned char CrFwGroup_t
Type used for the destination or source group of a packet.
Descriptor for a Packet Queue (PQ) in an OutStream or InStream.
static void ResetSeqCounter(FwSmDesc_t smDesc)
Function which resets to 1 the sequence counter of an out-going packet.
CrFwCrc_t CrFwPcktComputeCrc(CrFwPckt_t pckt)
Compute the CRC in the command or report encapsulated in a packet.
Definition: CrFwPckt.c:247
#define CR_FW_OUTSTREAM_INITCHECK
The functions implementing the Initialization Check of the OutStream components.
static void SendOrEnqueue(FwSmDesc_t smDesc)
Function which first attempts to hand over a packet to the middleware and, if this fails...
Header file to define all invariant publicly available constants and types for the CORDET Framework...
CrFwPcktHandover_t handoverPckt
Function which hands over a packet from the OutStream to the middleware.
void CrFwPcktRelease(CrFwPckt_t pckt)
Release function for command or report packets.
Definition: CrFwPckt.c:156
CrFwPckt_t CrFwPcktQueueGetOldest(CrFwPcktQueue_t pcktQueue)
Return the oldest packet from the queue without removing it from the queue.
Definition: CrFwPcktQueue.c:44
void CrFwBaseCmpDefInitCheck(FwPrDesc_t prDesc)
Function which performs the default Initialization Check of the CIP.
Definition: CrFwInitProc.c:36
A framework function has been called with an illegal OutStream identifier.
CrFwCounterU1_t CrFwPcktQueueGetSize(CrFwPcktQueue_t pcktQueue)
Return the size of the packet queue.
unsigned char CrFwDestSrc_t
Type used for the command or report destination and source.
static void EnqueuePckt(FwSmDesc_t smDesc)
Function which enqueues a packet on the packet queue.
CrFwInstanceId_t instanceId
The instance identifier of the framework component.
Definition: CrFwCmpData.h:81
static FwSmAction_t outStreamShutdownAction[CR_FW_NOF_OUTSTREAM]
The functions implementing the shutdown actions for the InStream components.
Definition: CrFwOutStream.c:74
An OutComponent has an illegal group.
void CrFwBaseCmpDefInitAction(FwPrDesc_t prDesc)
Function which performs the default Initialization Action of the CIP.
Definition: CrFwInitProc.c:42
An OutStream cannot buffer an out-going packet because no more packets are available (see CrFwOutStre...
#define CR_FW_OUTSTREAM_CONFIGACTION
The functions implementing the Configuration Action of the OutStream components.
void CrFwOutStreamConnectionAvail(FwSmDesc_t smDesc)
Signal that the out-going middleware connection has become available.
Interface for reporting an error detected by a framework component.
#define CR_FW_OUTSTREAM_PQSIZE
The sizes of the packet queues in the OutStream component.
CrFwBool_t CrFwOutStreamIsInBuffering(FwSmDesc_t smDesc)
Return true if the argument OutStream is in state BUFFERING.
#define CR_FW_OUTSTREAM_PCKTHANDOVER
The functions implementing the packet hand-over operations of the OutStream components.
static int IsPacketQueueEmpty(FwSmDesc_t smDesc)
Function which checks if the packet queue is empty.
CrFwCounterU1_t CrFwOutStreamGetPcktQueueSize(FwSmDesc_t smDesc)
Return the size of the packet queue of the OutStream.
The packet queue of an OutStream is full (see CrFwOutStream.h)
CrFwSeqCnt_t CrFwOutStreamGetSeqCnt(FwSmDesc_t smDesc, CrFwGroup_t group)
Return the value of the sequence counter for one of the groups maintained by an OutStream.
CrFwCounterU1_t CrFwPcktQueueGetNOfPckts(CrFwPcktQueue_t pcktQueue)
Return the number of packets currently in the packet queue.
#define CR_FW_OUTSTREAM_INITACTION
The functions implementing the Initialization Action of the OutStream components. ...
Definition and management of packet queues.
void * cmpSpecificData
Derived data which are specific to each type of framework component.
Definition: CrFwCmpData.h:101
void CrFwBaseCmpDefConfigAction(FwPrDesc_t prDesc)
Function which performs the default Configuration Action of the CRP.
Definition: CrFwResetProc.c:39
static FwPrAction_t outStreamInitCheck[CR_FW_NOF_OUTSTREAM]
The functions implementing the initialization checks for the InStream components. ...
Definition: CrFwOutStream.c:62
Definition of the utility functions for the CORDET Framework.
FwSmDesc_t CrFwOutStreamGet(CrFwDestSrc_t dest)
Getter function for the OutStream corresponding to the argument destination.
void CrFwOutStreamDefShutdownAction(FwSmDesc_t smDesc)
Default shutdown action for an OutStream.
FwPrDesc_t execProc
The Component Execution Procedure (CEP) (see CrFwBaseCmp.h).
Definition: CrFwCmpData.h:99
FwSmDesc_t CrFwBaseCmpMake()
Retrieve the singleton instance of the Base State Machine.
Definition: CrFwBaseCmp.c:77
void CrFwOutStreamDefInitAction(FwPrDesc_t prDesc)
Default initialization action for an OutStream.
A framework function has been called with a destination attribute which is not associated to any OutS...
void CrFwOutStreamSetSeqCnt(FwSmDesc_t smDesc, CrFwGroup_t group, CrFwSeqCnt_t seqCnt)
Sets the value of the sequence counter for one of the groups maintained by an OutStream.
FwPrDesc_t CrFwBaseCmpGetDummyExecProc()
Retrieve the singleton instance of the Dummy CEP.
static FwPrAction_t outStreamConfigCheck[CR_FW_NOF_OUTSTREAM]
The functions implementing the configuration checks for the InStream components.
Definition: CrFwOutStream.c:68
static CrFwOutStreamData_t outStreamCmpSpecificData[CR_FW_NOF_OUTSTREAM]
The component-specific data for the OutStream State Machines and their Procedures.
Definition: CrFwOutStream.c:83
#define CR_FW_OUTSTREAM_SHUTDOWNACTION
The functions implementing the Shutdown Action of the OutStream components.
Definition of Base Component.
static CrFwDestSrc_t dest
Destination.
unsigned short CrFwCrc_t
Type used for the CRC field in a packet.
CrFwPcktLength_t CrFwPcktGetLength(CrFwPckt_t pckt)
Return the length (in number of bytes) of a packet.
Definition: CrFwPckt.c:206
static CrFwCmpData_t outStreamData[CR_FW_NOF_OUTSTREAM]
The base data structures for the OutStream State Machines and their Procedures.
Definition: CrFwOutStream.c:80
void CrFwRepErr(CrFwRepErrCode_t errCode, CrFwTypeId_t typeId, CrFwInstanceId_t instanceId)
Report an error which has no parameters attached to it.
Definition: CrFwRepErr.c:81
void CrFwPcktSetCrc(CrFwPckt_t pckt, CrFwCrc_t crc)
Set the CRC in the command or report encapsulated in a packet.
Definition: CrFwPckt.c:253
Component Initialization Procedure (CIP) for the Base Component.
CrFwGroup_t CrFwPcktGetGroup(CrFwPckt_t pckt)
Return the group of the command/report encapsulated in a packet.
Definition: CrFwPckt.c:398
unsigned short int CrFwPcktLength_t
Type for the packet length.
CrFwDestSrc_t CrFwOutStreamGetDest(FwSmDesc_t smDesc)
Get the destination for an OutStream.
CrFwDestSrc_t dest
Destination associated to the OutStream.
FwSmDesc_t CrFwOutStreamMake(CrFwInstanceId_t i)
Factory function to retrieve the i-th OutStream State Machine instance.
static CrFwGroup_t outStreamNOfGroups[CR_FW_NOF_OUTSTREAM]
The number of groups associated to the OutStream components.
Definition: CrFwOutStream.c:56
CrFwTypeId_t typeId
The type identifier of the framework component.
Definition: CrFwCmpData.h:83
static CrFwGroup_t pcktGroup
group
#define CR_FW_OUTSTREAM_STATE_BUFFERING
State identifier for state INITIALIZED in the OutStream State Machine.
CrFwBool_t CrFwOutStreamIsInReady(FwSmDesc_t smDesc)
Return true if the argument OutStream is in state READY.
CrFwBool_t(* CrFwPcktHandover_t)(CrFwPckt_t pckt)
Type for a pointer to a function implementing the Packet Hand-Over Operation of an OutStream...
void CrFwPcktSetSeqCnt(CrFwPckt_t pckt, CrFwSeqCnt_t seqCnt)
Set the sequence counter of the command or report encapsulated in a packet.
Definition: CrFwPckt.c:229
static FwPrAction_t outStreamInitAction[CR_FW_NOF_OUTSTREAM]
The functions implementing the initialization actions for the InStream components.
Definition: CrFwOutStream.c:65
#define CR_FW_BASE_STATE_CONFIGURED
State identifier for state CONFIGURED in the Base State Machine.
static CrFwDestSrc_t outStreamDest[CR_FW_NOF_OUTSTREAM]
The destinations associated to the OutStream components.
Definition: CrFwOutStream.c:53
#define CR_FW_OUTSTREAM_TYPE
Type identifier for the OutStream components.
User-modifiable parameters for the OutStream components (see CrFwOutStream.h).
static void FlushPcktQueue(FwSmDesc_t smDesc)
Function which flushes the packet queue.
FwPrDesc_t CrFwCmpGetInitProc()
Retrieve the singleton instance of the CIP.
Definition: CrFwInitProc.c:48
void CrFwPcktQueueShutdown(CrFwPcktQueue_t pcktQueue)
Shutdown the packet queue.
struct CrFwPcktQueue pcktQueue
Packet queue associated to the OutStream.
#define CR_FW_OUTSTREAM_NOF_GROUPS
The number of groups of the OutStream components.
unsigned int CrFwSeqCnt_t
Type used for the sequence counter of commands or reports.
Component Reset Procedure (CRP) for the Base Component.
FwPrDesc_t initProc
The Component Initialization Procedure (CIP) (see CrFwInitProc.h).
Definition: CrFwCmpData.h:95
#define CR_FW_OUTSTREAM_CONFIGCHECK
The functions implementing the Configuration Check of the OutStream components.
P&P Software GmbH, Copyright 2012-2013, All Rights Reserved