GeMRTOS
grtosuserfunctions.c
Go to the documentation of this file.
1 
22 /******************************************************************************
23 * *
24 * License Agreement *
25 * Copyright (c) Ricardo L. Cayssials *
26 * All rights reserved. *
27 * *
28 ******************************************************************************/
29 
30 
31 #include <gemrtos_core.h>
32 #include <grtos.h>
33 #include <stdlib.h>
34 
35 OPTIMEZE_CODE(3)
36 
37 
59 /***********************************************************************************
60  * *********************************************************************************
61  * gRTOS Default Setting functions
62  * *********************************************************************************
63  ***********************************************************************************/
76 INT32 gu_Set_Default_Task_Type(unsigned int type)
77 {
78  G_TASK_TYPE_DEFAULT = type;
79  return G_TRUE;
80 }
81 
82 
91 INT32 gu_Get_Default_Task_Type(void)
92 {
93  return G_TASK_TYPE_DEFAULT;
94 }
95 
106 INT32 gu_Set_Default_Task_List(GS_LCB *list)
107 {
108  G_TASK_LCB_DEFAULT = list;
109  return G_TRUE;
110 }
111 
120 INT32 gu_Get_Default_Task_List(void)
121 {
122  return (INT32) G_TASK_LCB_DEFAULT;
123 }
124 
133 void gu_Set_Default_Task_Priority(INT32 level, INT32 priority)
134 {
135  TIMEPRIORITY pri_aux;
136  pri_aux.i32[0] = (INT32) priority;
137  pri_aux.i32[1] = (INT32) level;
138  G_TASK_PRIORITY_DEFAULT = (INT64) pri_aux.i64;
139 }
140 
141 
151 void gu_Set_Default_Task_Period(INT32 hours, INT32 minutes, INT32 seconds, INT32 ms)
152 {
153  /* Compute the total number of ticks required for the period */
154  INT64 ticks;
155 
156  ms = ms * (unsigned int) G_TICKS_PER_MSECOND;
157  seconds = seconds * (unsigned int) G_TICKS_PER_MSECOND * 1000;
158  minutes = minutes * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60;
159  hours = hours * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60 * 60;
160  ticks = (INT64) hours + (INT64) minutes + (INT64) seconds + (INT64) ms;
161 
162  G_TASK_PERIOD_DEFAULT = ticks;
163 }
164 
165 
166 
167 /***********************************************************************************
168 *********************** TASK SYSTEM CALLS ***************************
169 ***********************************************************************************/
170 
180 INT32 gu_SetTaskType(struct gs_tcb *ptcb, unsigned int type)
181 {
182  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
183  ptcb->TCBType = type;
184  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
185  return G_TRUE;
186 }
187 
198 INT32 gu_SetTaskList(struct gs_tcb *ptcb, struct gs_lcb *plcb)
199 {
200  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
201  ptcb->TCB_RDY_LCB_Index = plcb;
202  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
203  return G_TRUE;
204 }
205 
216 INT32 gu_SetTaskReadyPriority(struct gs_tcb *ptcb, long long priority)
217 {
218  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
219  ptcb->TCBReadyPriority = priority;
220  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
221  return G_TRUE;
222 }
223 
234 INT32 gu_SetTaskRunPriority(struct gs_tcb *ptcb, long long priority)
235 {
236  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
237  ptcb->TCBRunPriority = priority;
238  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
239  return G_TRUE;
240 }
241 
255 INT32 gu_SetTaskDeadline(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms)
256 {
257  /* Compute the total number of ticks required for the period */
258  INT64 ticks;
259  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
260  ms = ms * (unsigned int) G_TICKS_PER_MSECOND;
261  seconds = seconds * (unsigned int) G_TICKS_PER_MSECOND * 1000;
262  minutes = minutes * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60;
263  hours = hours * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60 * 60;
264  ticks = (INT64) hours + (INT64) minutes + (INT64) seconds + (INT64) ms;
265  ptcb->TCBDeadline = ticks;
266  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
267  return G_TRUE;
268 }
269 
283 INT32 gu_SetTaskPeriod(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms)
284 {
285  /* Compute the total number of ticks required for the period */
286  INT64 ticks;
287  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
288  ms = ms * (unsigned int) G_TICKS_PER_MSECOND;
289  seconds = seconds * (unsigned int) G_TICKS_PER_MSECOND * 1000;
290  minutes = minutes * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60;
291  hours = hours * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60 * 60;
292  ticks = (INT64) hours + (INT64) minutes + (INT64) seconds + (INT64) ms;
293  ptcb->TCBPeriod = ticks;
294  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
295  return G_TRUE;
296 }
297 
311 INT32 gu_StartTaskwithOffset(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms)
312 {
313  INT64 ticks;
314  GS_ECB *pevent;
315 
316  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
317  ms = ms * (unsigned int) G_TICKS_PER_MSECOND;
318  seconds = seconds * (unsigned int) G_TICKS_PER_MSECOND * 1000;
319  minutes = minutes * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60;
320  hours = hours * (unsigned int) G_TICKS_PER_MSECOND * 1000 * 60 * 60;
321  ticks = (INT64) hours + (INT64) minutes + (INT64) seconds + (INT64) ms;
322 
323  switch (ptcb->TCBType){
324  case G_TCBType_UCOS:
325  gk_TCBRDYL_Link(ptcb); /* Insert Task in Ready List */
326  break;
327  case G_TCBType_PERIODIC:
328  /* Get the starting time of the task depending whether the RTOS is running or not */
329  if (G_Running != G_FALSE) ticks = GRTOS_now + ticks;
330  // else time = GRTOS_now + ticks;
331 
332  if (ticks == (INT64) 0){
333  /* Task Ready and Set next Release in Period Time from start time */
334  gk_TCBRDYL_Link(ptcb); /* Insert Task in Ready List */
335  ticks = (INT64) ticks + ptcb->TCBPeriod;
336  }
337  else
338  {
339  gk_TCBWL_Link(ptcb, G_TCBState_WAITING_COMPLETED);
340  }
341  pevent = gk_ECB_GetFree();
342  pevent->ECBValue.i64 = (INT64) ticks;
343  pevent->ECBType = (INT32) G_ECBType_PERIODIC;
344  gk_TCBAEL_Link(pevent, ptcb);
345  gk_ECBTL_Link(pevent);
346  break;
347  // case G_TCBType_ISR:
348  // gk_TCBWL_Link(ptcb, G_TCBState_WAITING_COMPLETED);
349  // break;
350  // case G_TCBType_IDLE:
351  // gk_TCBRDYL_Link(ptcb); /* Insert Task in Ready List */
352  // break;
353  default:
354  G_DEBUG_WHILEFOREVER;
355  break;
356  }
357 
358  /* Si está ejecutandose el GRTOS, hago cambio de tarea si corresponde */
359  if (G_Running == G_TRUE) gk_KERNEL_TASK_SUSPEND_CURRENT();
360 
361  return G_TRUE;
362 }
363 
372 INT32 gu_SetTaskAbortwhenDeadline(struct gs_tcb *ptcb, unsigned int abort_when_deadline)
373 {
374  if ((abort_when_deadline != G_TRUE) && (abort_when_deadline != G_FALSE)) return G_FALSE;
375  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
376  ptcb->TCB_Abort_w_Deadline = abort_when_deadline;
377  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
378  return G_TRUE;
379 }
380 
381 
393 void *gu_GetTask(void *TaskCode,
394  void *p_arg,
395  void *StkBotton,
396  unsigned int StkSize)
397 {
398  GS_TCB *ptcb;
399  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_GET;
400 
401  ptcb = gk_CreateTask(TaskCode,
402  p_arg,
403  StkBotton,
404  StkSize,
405  G_TASK_TYPE_DEFAULT,
406  G_TASK_PRIORITY_DEFAULT,
407  G_TASK_PRIORITY_DEFAULT,
408  G_TASK_PERIOD_DEFAULT,
409  G_TASK_PERIOD_DEFAULT,
410  (GS_LCB *) G_TASK_LCB_DEFAULT,
411  G_TRUE,
412  G_TASK_PRIORITY_DEFAULT,
413  0);
414 
415  if (G_Running == G_TRUE) GRTOS_USER_CRITICAL_SECTION_RELEASE;
416  return ((void *) ptcb);
417 }
418 
419 
430 INT32 gu_TASK_Sleep(INT32 hours, INT32 minutes, INT32 seconds, INT32 ms)
431 {
432  /* Compute the total number of periods required */
433  INT64 ticks;
434 
435  ms = ms * (INT32) G_TICKS_PER_MSECOND;
436  seconds = seconds * (INT32) G_TICKS_PER_MSECOND * (INT32) 1000;
437  minutes = minutes * (INT32) G_TICKS_PER_MSECOND * (INT32) 1000 * (INT32) 60;
438  hours = hours * (INT32) G_TICKS_PER_MSECOND * (INT32) 1000 * (INT32) 60 * (INT32) 60;
439  ticks = (INT64) hours + (INT64) minutes + (INT64) seconds + (INT64) ms;
440 
441  if (ticks != 0){
442  gu_TASK_Sleep_Time((INT64) ticks);
443  }
444  return (G_TRUE);
445 }
446 
447 
457 INT32 gu_TASK_Sleep_Time(gt_time ticks)
458 {
459  GS_TCB *ptcbcurrent;
460  GS_ECB *pevent;
461 
462  GRTOS_USER_CRITICAL_SECTION_GET; /* Entro a la seccion critica del GRTOS Controller */
463 
464  ptcbcurrent = gk_PCB_GetCurrentTCB(); /* Get the current task */
465  pevent = gk_ECB_GetFree();
466 
467 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
468  if ((TCB_IsValid(ptcbcurrent) != G_TRUE) && (ptcbcurrent == (struct gs_tcb *) 0)) G_DEBUG_WHILEFOREVER;
469  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
470 #endif
471 
472  pevent->ECBValue.i64 = GRTOS_now + ticks;
473 
474  pevent->ECBType = (INT32) G_ECBType_OSTimeDly;
475  gk_TCBAEL_Link(pevent, ptcbcurrent);
476  gk_ECBTL_Link(pevent);
477 
478  gk_KERNEL_TASK_SUSPEND_CURRENT();
479 
480  /* Retorna fuera de la seccion critica */
481  // GRTOS_USER_CRITICAL_SECTION_GET;
482  //
483  // gk_TCBAEL_Unlink(pevent);
484  // gk_ECBFL_Link((GS_ECB *) pevent);
485  //
486  // GRTOS_CMD_CRITICAL_SECTION_RELEASE;
487  return G_TRUE;
488 }
489 
498 INT32 gu_TASK_Kill(GS_TCB *ptcb)
499 {
500  G_DEBUG_VERBOSE
501  GRTOS_USER_CRITICAL_SECTION_GET;
502  gk_TASK_Kill((GS_TCB *) ptcb);
503  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
504  return G_TRUE;
505 }
506 
515 INT32 gu_TASK_SUSPEND(GS_TCB *ptcb)
516 {
517  G_DEBUG_VERBOSE
518  GRTOS_USER_CRITICAL_SECTION_GET;
519  gk_KERNEL_TASK_SUSPEND((GS_TCB *) ptcb);
520  // GRTOS_CMD_CRITICAL_SECTION_RELEASE;
521  return G_TRUE;
522 }
523 
532 INT32 gu_TASK_IS_BLOCKED(GS_TCB *ptcb)
533 {
534  INT32 value;
535  G_DEBUG_VERBOSE
536  GRTOS_USER_CRITICAL_SECTION_GET;
537  value = gk_TASK_IS_BLOCKED((GS_TCB *) ptcb);
538  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
539  return value;
540 }
541 
550 INT32 gu_TASK_RESUME(GS_TCB *ptcb)
551 {
552  int return_value = G_FALSE;
553  GRTOS_USER_CRITICAL_SECTION_GET;
554  if (GRTOS_TASK_STATE_WAITING(ptcb)) {
555  gk_TCB_Unlink(ptcb); PRINT_DEBUG_LINE
556  gk_TCBRDYL_Link(ptcb); PRINT_DEBUG_LINE
557  return_value = G_TRUE;
558  }
559 
560  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
561  return return_value;
562 }
563 
564 
565 /***********************************************************************************
566 *********************** SIGNAL FUNCTIONS ***************************
567 ***********************************************************************************/
568 
583 GS_SCB *gu_signal_create(INT32 Type, INT32 Priority, void *pxcb, void *Signal_Code, void *Signal_Arg)
584 {
585  GRTOS_USER_CRITICAL_SECTION_GET;
586  GS_SCB *pscb = gk_SCB_GetFree();
587 
588  pscb->SCBPriority = Priority;
589  pscb->SCBType = Type;
590  pscb->SCB_TaskCode = Signal_Code;
591  pscb->SCB_TaskArg = (void *) Signal_Arg; //(void *) pscb;
592  pscb->SCB_NextSCBAPSL = (struct gs_scb *) 0;
593  pscb->SCB_AssocXCB = pxcb;
594  switch (Type){
595  // Types for KCB
596  case 1:
597  case 2:
598  gk_KCBASL_Link(pscb);
599  pscb->SCBState = G_SCBState_IN_KCB;
600  break;
601 
602  // Types for ECB
603  case 3:
604  gk_ECBASL_Link((GS_ECB *)pxcb, pscb);
605  pscb->SCBState = G_SCBState_IN_ECB;
606  break;
607 
608  // Types for TCB
609  case G_SCBType_TCB_ABORTED:
610  gk_TCBASL_Link((GS_TCB *)pxcb, pscb);
611  pscb->SCBState = G_SCBState_IN_TCB;
612  break;
613 
614  // Types for RCB
615  case 5:
616  gk_RCBASL_Link((G_RCB *)pxcb, pscb);
617  pscb->SCBState = G_SCBState_IN_RCB;
618  break;
619 
620  // Types for PCB
621  //case 6:
622  // pscb->SCBState = G_SCBState_IN_PCB;
623  // break;
624 
625  // Types for LCB
626  //case 7:
627  // pscb->SCBState = G_SCBState_IN_LCB;
628  // break;
629  }
630  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
631  return((GS_SCB *) pscb);
632 }
633 
642 INT32 gu_signal_destroy(GS_SCB *pscb)
643 {
644  GRTOS_USER_CRITICAL_SECTION_GET;
645  void *pxcb = (void *) pscb->SCB_AssocXCB;
646  GS_SCB *pscb_pending = pscb->SCB_NextSCBAPSL;
647  int result = G_TRUE;
648 
649  // Check if the signal is pending
650  while (result == G_TRUE && pscb_pending != (struct gs_scb *) 0)
651  {
652  result = gk_SCBAPSL_UnLink((GS_SCB *) pscb, pscb_pending);
653  gk_SCBFL_Link(pscb_pending);
654  pscb_pending = pscb->SCB_NextSCBAPSL;
655  }
656 
657  if (pscb->SCB_NextSCBAPSL == (struct gs_scb *) 0)
658  { // remove root becuase no pending are linked
659  switch (pscb->SCBType){
660  // Types for KCB
661  case 1:
662  case 2:
663  gk_KCBASL_Unlink((GS_SCB *) pscb);
664  pscb->SCBState = G_SCBState_UNLINKED;
665  break;
666 
667  // Types for ECB
668  case 3:
669  gk_ECBASL_Unlink((GS_ECB *)pxcb, (GS_SCB *) pscb);
670  pscb->SCBState = G_SCBState_UNLINKED;
671  break;
672 
673  // Types for TCB
674  case 4:
675  gk_TCBASL_Unlink((GS_TCB *)pxcb, (GS_SCB *) pscb);
676  pscb->SCBState = G_SCBState_UNLINKED;
677  break;
678 
679  // Types for RCB
680  case 5:
681  gk_RCBASL_Unlink((G_RCB *)pxcb, (GS_SCB *) pscb);
682  pscb->SCBState = G_SCBState_UNLINKED;
683  break;
684 
685  // Types for PCB
686  //case 6:
687  // pscb->SCBState = G_SCBState_UNLINKED;
688  // break;
689 
690  // Types for LCB
691  //case 7:
692  // pscb->SCBState = G_SCBState_UNLINKED;
693  // break;
694  }
695  gk_SCBFL_Link((GS_SCB *) pscb);
696  }
697  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
698  return(result);
699 }
700 
701 /***********************************************************************************
702 *********************** USER FUNCTIONS ***************************
703 ***********************************************************************************/
704 
717 gt_time gu_Convert_Time(INT32 days, INT32 hours, INT32 minutes, INT32 seconds, INT32 ms)
718 {
719  /* Compute the total number of periods required */
720  gt_time ticks = (gt_time) ((gt_time)days * (gt_time) 24);
721  ticks = (ticks + (gt_time) hours) * (gt_time) 60;
722  ticks = (ticks + (gt_time) minutes) * (gt_time) 60;
723  ticks = (ticks + (gt_time) seconds) * (gt_time) 1000;
724  ticks = (ticks + (gt_time) ms) * ((gt_time) G_TICKS_PER_MSECOND);
725  return ((gt_time) ticks);
726 }
727 
735 INT32 gu_get_irq_status(void)
736 {
737  INT32 status;
738  GRTOS_USER_CRITICAL_SECTION_GET;
739  status = GRTOS_CMD_IRQ_RQS;
740  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
741  return(status);
742 }
743 
751 gt_time gu_get_now(void)
752 {
753  gt_time status;
754  GRTOS_USER_CRITICAL_SECTION_GET;
755  G_DEBUG_VERBOSE
756  status = (gt_time) GRTOS_now;
757  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
758  return(status);
759 }
760 
770 gt_time gu_get_frozen_threshold(void)
771 {
772  gt_time status;
773  GRTOS_USER_CRITICAL_SECTION_GET;
774  G_DEBUG_VERBOSE
775  status = (gt_time) GRTOS_CMD_FRZ_TM_THR_GET;
776  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
777  return(status);
778 }
779 
785 gt_time gu_get_mutex_time(void)
786 {
787  gt_time status;
788  GRTOS_USER_CRITICAL_SECTION_GET;
789  G_DEBUG_VERBOSE
790  status = (gt_time) GRTOS_CMD_MTX_TM_GET;
791  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
792  return(status);
793 }
794 
803 gt_tm gu_Clock(gt_time ticks)
804 {
805  gt_tm return_time;
806 
807  lldiv_t division;
808  division = lldiv(ticks, (INT64)(G_TICKS_PER_MSECOND)*(INT64)1000*(INT64)60*(INT64)60*(INT64)24*(INT64)365);
809  return_time.tm_year = (int) division.quot;
810  division = lldiv((INT64) division.rem, (INT64)(G_TICKS_PER_MSECOND)*(INT64)1000*(INT64)60*(INT64)60*(INT64)24);
811  return_time.tm_day = (int) division.quot;
812  division = lldiv((INT64) division.rem, (INT64)(G_TICKS_PER_MSECOND)*(INT64)1000*(INT64)60*(INT64)60);
813  return_time.tm_hour = (int) division.quot;
814  division = lldiv((INT64) division.rem, (INT64)(G_TICKS_PER_MSECOND)*(INT64)1000*(INT64)60);
815  return_time.tm_min = (int) division.quot;
816  division = lldiv((INT64) division.rem, (INT64)(G_TICKS_PER_MSECOND)*(INT64)1000);
817  return_time.tm_sec = (int) division.quot;
818  return_time.tm_msec = (int) ((int)division.rem/(int) G_TICKS_PER_MSECOND);
819  return(return_time);
820 }
821 
829 void gk_TIME_CALLBACK(GS_ECB *pevent)
830 {
831  GS_TCB *ptcb = pevent->ECB_AssocTCB;;
832 
833  /* PROCESS ACCORDING TO THE TYPE OF THE EVENT */
834  switch (pevent->ECBType)
835  {
836  case G_ECBType_OSTimeDly: /* It is a Delay Event ****************************************************/
837  /* Task Should be inserted in REady List if it is not waiting more events */
838  if (gk_TASK_IS_BLOCKED(ptcb) == G_FALSE)
839  {
840  gk_TCBWL_Unlink(ptcb);
841  gk_TCBRDYL_Link(ptcb);
842  gk_TCBAEL_Unlink(pevent);
843  gk_ECBFL_Link((GS_ECB *) pevent);
844  }
845  else
846  {
847  /* No puede estar bloqueada pues no prodria haber ejecutar el Delay */
848  G_DEBUG_WHILEFOREVER;
849  }
850  break;
851 
852  case G_ECBType_PERIODIC: /* It is a Periodic Release of the task */
853 
854  gk_TCBAEL_Unlink(pevent); // Preserve the Periodic event to remove the rest of events for a clean release
855 
856  gk_TASK_RELEASE((GS_TCB *) ptcb);
857 
858  /* Set a new event in the future */
859  pevent->ECBValue.i64 = (INT64) pevent->ECBValue.i64 + ptcb->TCBPeriod;
860  gk_TCBAEL_Link(pevent, ptcb); // Link the periodic event back to the tcb
861  gk_ECBTL_Link(pevent);
862  break;
863 
864  case G_ECBType_TIMEOUT_SEM_WAITING:
865  /* It is the timeout of a waiting event *************************************/
866  gk_timeout_ECB_SEM_wait(pevent);
867  break;
868 
869  case G_ECBType_TIMEOUT_SEM_GRANTED:
870  gk_timeout_ECB_SEM_post(pevent);
871  break;
872 
873  case G_ECBType_MESSAGE_SEND_WAIT:
874  gk_timeout_ECB_MQ_send(pevent);
875  break;
876 
877  case G_ECBType_MESSAGE_CONSUME_WAIT:
878  gk_timeout_ECB_MQ_consume(pevent);
879  break;
880 
881  case G_ECBType_LASTEST_TIME:
882  /* The end of the times */
883  G_DEBUG_WHILEFOREVER;
884 
885  default:
886  G_DEBUG_WHILEFOREVER;
887  break;
888  }
889 }
890 
896 void gk_RESOURCE_ECB_KILL_CALLBACK(GS_ECB *pevent)
897 {
898  switch (pevent->ECBType)
899  {
900  case G_ECBType_SEM_GRANTED:
901  case G_ECBType_TIMEOUT_SEM_GRANTED:
902  gk_SEM_granted_kill((GS_ECB *) pevent);
903  break;
904 
905  case G_ECBType_SEM_WAITING:
906  case G_ECBType_TIMEOUT_SEM_WAITING:
907  gk_SEM_waiting_kill((GS_ECB *)pevent);
908  break;
909 
910  case G_ECBType_QUEUE_CONSUME:
911  gk_QUEUE_granted_kill((GS_ECB *) pevent);
912  break;
913  default:
914  gk_TCBAEL_Unlink(pevent);
915  gk_ECBFL_Link(pevent);
916  break;
917  }
918 }
919 
924 void gk_FROZEN_CALLBACK(void)
925 {
926  fprintf(stderr,"[ MESSAGE ] FROZEN REACHED . Proc: %d\n", GRTOS_CMD_PRC_ID);
927  // G_DEBUG_WHILEFOREVER; // Remove when frozen strategy is implemented
928 }
929 
930 OPTIMEZE_RESTORE
Resource::gk_timeout_ECB_MQ_send
INT32 gk_timeout_ECB_MQ_send(GS_ECB *peventime)
This function is called from the timed IRQ when a send timeout G_ECBType_MESSAGE_SEND_WAIT happens.
Definition: mq.c:371
INT32
unsigned INT32
Definition: gemrtos_core.h:62
ECB_IsValid
INT32 ECB_IsValid(GS_ECB *pevent)
Returns G_TRUE is pointer points to ECB.
Definition: monitor.c:109
Task::gu_TASK_Sleep
INT32 gu_TASK_Sleep(INT32 hours, INT32 minutes, INT32 seconds, INT32 ms)
Sleeps the current task the interval specified.
Definition: grtosuserfunctions.c:430
Task::gk_CreateTask
GS_TCB* gk_CreateTask(void *TaskCode, void *p_arg, void *StkBotton, unsigned int StkSize, unsigned int TCBType, INT64 TCBReadyPriority, INT64 TCBRunPriority, INT64 TCBDeadline, INT64 TCBPeriod, GS_LCB *TCB_RDY_LCB_Index, int TCB_Abort_w_Deadline, INT64 TCBInherPriority, int TCB_INTNumber)
Kernel Function: creates a new task initializing TCB features.
Definition: gemrtos_core.c:334
Resource::gk_timeout_ECB_MQ_consume
INT32 gk_timeout_ECB_MQ_consume(GS_ECB *peventime)
This function is called from the timed IRQ when a consume timeout G_ECBType_MESSAGE_CONSUME_WAIT happ...
Definition: mq.c:386
Task::gu_TASK_SUSPEND
INT32 gu_TASK_SUSPEND(GS_TCB *ptcb)
Change to waiting the state of a task.
Definition: grtosuserfunctions.c:515
Task::gu_SetTaskType
INT32 gu_SetTaskType(struct gs_tcb *ptcb, unsigned int type)
Set the type of a task.
Definition: grtosuserfunctions.c:180
Semaphore::gk_timeout_ECB_SEM_post
INT32 gk_timeout_ECB_SEM_post(GS_ECB *peventime)
Time routine for event G_ECBType_TIMEOUT_SEM_GRANTED. It is called from the time interrupt ISR.
Definition: sem.c:533
Task::gk_TCBASL_Link
INT32 gk_TCBASL_Link(GS_TCB *ptcb, GS_SCB *psignal)
Links SCB to TCB Associated Signal List.
Definition: listfunctions.c:1346
gk_KERNEL_TASK_SUSPEND
void gk_KERNEL_TASK_SUSPEND(GS_TCB *ptcb)
Suspends the execution of the task pointed by ptcb.
Definition: grtos_kernel.c:470
GS_TCB
struct gs_tcb GS_TCB
Definition: gemrtos_core.h:50
Task::gk_TCB_Unlink
INT32 gk_TCB_Unlink(GS_TCB *ptcb)
Unlinks the TCB according to the list it is linked.
Definition: listfunctions.c:2550
G_TASK_PRIORITY_DEFAULT
volatile INT64 G_TASK_PRIORITY_DEFAULT
Miscellaneous::gu_get_irq_status
INT32 gu_get_irq_status(void)
Return the status of the system IRQs.
Definition: grtosuserfunctions.c:735
Task::gk_TCBAEL_Link
INT32 gk_TCBAEL_Link(GS_ECB *pevent, GS_TCB *ptcb)
Links an ECB to the associated ECB list of TCB.
Definition: listfunctions.c:1284
Task::gu_SetTaskAbortwhenDeadline
INT32 gu_SetTaskAbortwhenDeadline(struct gs_tcb *ptcb, unsigned int abort_when_deadline)
Set if task should be aborted when misses a deadline.
Definition: grtosuserfunctions.c:372
Configuration::gu_Set_Default_Task_List
INT32 gu_Set_Default_Task_List(GS_LCB *list)
Set the default list number for task created afterwards.
Definition: grtosuserfunctions.c:106
Task::gu_TASK_Kill
INT32 gu_TASK_Kill(GS_TCB *ptcb)
The task is eliminated and all the structures involved are return to the free lists.
Definition: grtosuserfunctions.c:498
gs_tcb::TCB_RDY_LCB_Index
struct gs_lcb* TCB_RDY_LCB_Index
pointer to the ready list that should be inserted
Definition: gemrtos_core.h:463
gt_time
unsigned long long gt_time
Definition: gemrtos_core.h:65
Task::gu_TASK_IS_BLOCKED
INT32 gu_TASK_IS_BLOCKED(GS_TCB *ptcb)
Return G_TRUE if task is waiting for a resource, G_FALSE otherwise.
Definition: grtosuserfunctions.c:532
Task::OPTIMEZE_CODE
OPTIMEZE_CODE(3)
Creates a TCB and returns its pointer Returns a pointer to a Free TCB, NULL if it is not a TCB availa...
Definition: gemrtos_core.c:32
G_TASK_LCB_DEFAULT
volatile GS_LCB* G_TASK_LCB_DEFAULT
Time::GRTOS_now
GRTOS_now({ \ TIMEPRIORITY value64 \ do { \ value64.i32[1] = (unsigned) IORD(GRTOS_DRIVER_GRTOS_BASE, ADDR_TM_CNT_HGH) \ value64.i32[0] = (unsigned) IORD(GRTOS_DRIVER_GRTOS_BASE, ADDR_SMP) \ } while(0) \ value64.i64 \ })
GRTOS_now Return the current system time.
Definition: grtos_regs.h:97
Signal::gk_ECBASL_Link
void gk_ECBASL_Link(GS_ECB *pevent, GS_SCB *psignal)
Links a SCB to the ECB Associated Signal List.
Definition: listfunctions.c:139
Signal::gk_RCBASL_Link
INT32 gk_RCBASL_Link(G_RCB *presource, GS_SCB *psignal)
Links a signal SCB to the resource RCB Associated Signal List.
Definition: listfunctions.c:737
Configuration::gu_Set_Default_Task_Type
INT32 gu_Set_Default_Task_Type(unsigned int type)
gu_Set_Default_Task_Type(unsigned int type) Set the default type of the task created.
Event::gk_TCBAEL_Unlink
INT32 gk_TCBAEL_Unlink(GS_ECB *pevent)
Unlinks the ECB from the associated TCB.
Definition: listfunctions.c:1310
timepriority::i32
INT32 i32[2]
Definition: gemrtos_core.h:71
Task::gu_TASK_RESUME
INT32 gu_TASK_RESUME(GS_TCB *ptcb)
Resume a task that it is in waiting state.
Definition: grtosuserfunctions.c:550
Miscellaneous::gu_Convert_Time
gt_time gu_Convert_Time(INT32 days, INT32 hours, INT32 minutes, INT32 seconds, INT32 ms)
Convert days,hours, minutes, seconds and miliseconds to system time unit.
Definition: grtosuserfunctions.c:717
Signal::gk_KCBASL_Unlink
INT32 gk_KCBASL_Unlink(GS_SCB *psignal)
Unlinks a SCG from the Associated Signal list of KCB.
Definition: listfunctions.c:507
gt_tm
struct gs_tm gt_tm
Signal::gk_SCB_GetFree
GS_SCB* gk_SCB_GetFree(void)
Unlinks a SCB from free list and return its pointer.
Definition: gemrtos_core.c:194
gk_KERNEL_TASK_SUSPEND_CURRENT
void gk_KERNEL_TASK_SUSPEND_CURRENT(void)
Suspends the execution of the current task and switch to Highest Priority Task.
Definition: grtos_kernel.c:502
G_Running
volatile INT32 G_Running
Miscellaneous::gu_get_mutex_time
gt_time gu_get_mutex_time(void)
Return the time the mutex is granted in system time units.
Definition: grtosuserfunctions.c:785
Configuration::gu_Set_Default_Task_Period
void gu_Set_Default_Task_Period(INT32 hours, INT32 minutes, INT32 seconds, INT32 ms)
Set the default periodo for task created afterwards.
Definition: grtosuserfunctions.c:151
Task::gu_StartTaskwithOffset
INT32 gu_StartTaskwithOffset(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms)
Activates the execution of a task. An offset can be configured.
Definition: grtosuserfunctions.c:311
gs_lcb
GS_LCB List Control Block.
Definition: gemrtos_core.h:203
Task::gu_SetTaskReadyPriority
INT32 gu_SetTaskReadyPriority(struct gs_tcb *ptcb, long long priority)
Set the ready priority of a task.
Definition: grtosuserfunctions.c:216
Task::gk_TCBWL_Link
INT32 gk_TCBWL_Link(GS_TCB *ptcb, unsigned int state)
Links a TCB in the waiting list.
Definition: listfunctions.c:1990
gs_tcb
gs_tcb Task Control Block (TCB) structure
Definition: gemrtos_core.h:439
gs_scb
GS_SCB Signal Control Block structure.
Definition: gemrtos_core.h:393
GS_SCB
struct gs_scb GS_SCB
Definition: gemrtos_core.h:52
Event::gk_ECBASL_Unlink
INT32 gk_ECBASL_Unlink(GS_ECB *pevent, GS_SCB *psignal)
Unlinks a signal SCB from the ECB Associated Signal List of and event.
Definition: listfunctions.c:203
Semaphore::gk_SEM_granted_kill
INT32 gk_SEM_granted_kill(GS_ECB *pevent1)
Removes the ECBs from a the granted list of a semaphore resource.
Definition: sem.c:573
Time::gk_TIME_CALLBACK
void gk_TIME_CALLBACK(GS_ECB *pevent)
This function is called when a time event happened. It has to resolve according the event type.
Definition: grtosuserfunctions.c:829
Signal::gk_RCBASL_Unlink
INT32 gk_RCBASL_Unlink(G_RCB *presource, GS_SCB *psignal)
Unlinks a SCB of a signal from the RCB Associated Signal List of a resource.
Definition: listfunctions.c:802
Task::gk_TCBWL_Unlink
INT32 gk_TCBWL_Unlink(GS_TCB *ptcb)
Unlinks the TCB from the waiting list.
Definition: listfunctions.c:2020
G_TASK_PERIOD_DEFAULT
volatile INT64 G_TASK_PERIOD_DEFAULT
Task::gu_SetTaskDeadline
INT32 gu_SetTaskDeadline(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms)
Set the deadline of the task for the next invocation.
Definition: grtosuserfunctions.c:255
gk_QUEUE_granted_kill
INT32 gk_QUEUE_granted_kill(GS_ECB *pevent)
Definition: mq.c:396
Miscellaneous::GRTOS_CMD_MTX_TM_GET
GRTOS_CMD_MTX_TM_GET({ \ TIMEPRIORITY value64 \ do { \ value64.i32[1] = (unsigned) IORD(GRTOS_DRIVER_GRTOS_BASE, ADDR_SYS_MUTEX_TIME_HGH) \ value64.i32[0] = (unsigned) IORD(GRTOS_DRIVER_GRTOS_BASE, ADDR_SMP) \ } while(0) \ value64.i64 \ })
GRTOS_CMD_MTX_TM_GET Return the time the mutex is granted in system time units.
Definition: grtos_regs.h:110
grtos.h
Definition of GRTOS controller address.
gs_tcb::TCBDeadline
INT64 TCBDeadline
Deadline of the task.
Definition: gemrtos_core.h:450
Resource::gk_TASK_IS_BLOCKED
INT32 gk_TASK_IS_BLOCKED(GS_TCB *ptcb)
Returns G_TRUE when TCB is blocked waiting for a resource.
Definition: listfunctions.c:2046
Signal::gk_SCBAPSL_UnLink
INT32 gk_SCBAPSL_UnLink(GS_SCB *pscb_root, GS_SCB *pscb_pending)
Unlinks a pending signal from the root signal.
Definition: listfunctions.c:1244
TIMEPRIORITY
union timepriority TIMEPRIORITY
G_TASK_TYPE_DEFAULT
volatile INT32 G_TASK_TYPE_DEFAULT
Task::gk_TCBASL_Unlink
INT32 gk_TCBASL_Unlink(GS_TCB *ptcb, GS_SCB *psignal)
Unlinks SCB from a TCB Associated Signal List.
Definition: listfunctions.c:1411
GS_LCB
struct gs_lcb GS_LCB
Definition: gemrtos_core.h:49
Task::gu_SetTaskRunPriority
INT32 gu_SetTaskRunPriority(struct gs_tcb *ptcb, long long priority)
Set the run priority of a task.
Definition: grtosuserfunctions.c:234
Miscellaneous::gu_Clock
gt_tm gu_Clock(gt_time ticks)
Convert to gt_tm structure a time in gt_time format (time in system time units)
Definition: grtosuserfunctions.c:803
Event::gk_ECBTL_Link
INT32 gk_ECBTL_Link(GS_ECB *pevent)
Links the ECB from the Time Event List.
Definition: listfunctions.c:355
Task::gu_SetTaskPeriod
INT32 gu_SetTaskPeriod(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms)
Set the task period for the next invocation.
Definition: grtosuserfunctions.c:283
Task::gu_TASK_Sleep_Time
INT32 gu_TASK_Sleep_Time(gt_time ticks)
Set event to sleep the current task for a certain number of clock ticks.
Definition: grtosuserfunctions.c:457
Semaphore::gk_timeout_ECB_SEM_wait
INT32 gk_timeout_ECB_SEM_wait(GS_ECB *peventime)
Time routine for event G_ECBType_TIMEOUT_SEM_WAITING. It is called from the time interrupt ISR.
Definition: sem.c:512
INT64
unsigned long long INT64
Definition: gemrtos_core.h:61
Configuration::gu_Get_Default_Task_List
INT32 gu_Get_Default_Task_List(void)
Return the current default list number.
Definition: grtosuserfunctions.c:120
Task::gk_PCB_GetCurrentTCB
GS_TCB* gk_PCB_GetCurrentTCB(void)
Returns the task that the current processor was executing.
Definition: listfunctions.c:2262
Task::gu_SetTaskList
INT32 gu_SetTaskList(struct gs_tcb *ptcb, struct gs_lcb *plcb)
Set the list of a task.
Definition: grtosuserfunctions.c:198
gs_tcb::TCBReadyPriority
INT64 TCBReadyPriority
Priority of the Task when Ready.
Definition: gemrtos_core.h:445
GS_ECB
struct gs_ecb GS_ECB
Definition: gemrtos_core.h:51
Configuration::gu_Set_Default_Task_Priority
void gu_Set_Default_Task_Priority(INT32 level, INT32 priority)
Set the default priority for task created afterwards. Priority is assigned with an INT32 level and an...
Definition: grtosuserfunctions.c:133
Task::gk_TCBRDYL_Link
INT32 gk_TCBRDYL_Link(GS_TCB *ptcb)
Links the TCB in the Ready Task List sorted by its priority.
Definition: listfunctions.c:1653
Time::gk_FROZEN_CALLBACK
void gk_FROZEN_CALLBACK(void)
This function is called when a frozzen event happened.
Definition: grtosuserfunctions.c:924
gs_tcb::TCB_Abort_w_Deadline
int TCB_Abort_w_Deadline
True if task should be aborted when deadline, false otherwise.
Definition: gemrtos_core.h:464
Signal::gk_KCBASL_Link
INT32 gk_KCBASL_Link(GS_SCB *psignal)
Links a SCG to the Associated Signal list of KCB.
Definition: listfunctions.c:443
Task::gk_TASK_Kill
INT32 gk_TASK_Kill(GS_TCB *ptcb)
Destroys a task and return the data structure to the TCB free list.
Definition: listfunctions.c:2855
Time::gu_get_frozen_threshold
gt_time gu_get_frozen_threshold(void)
Returns the value in the frozen threshold register (R_FRZ_TM_THR)
Definition: grtosuserfunctions.c:770
Configuration::gu_Get_Default_Task_Type
INT32 gu_Get_Default_Task_Type(void)
Return the default type assigned to new tasks.
Definition: grtosuserfunctions.c:91
Semaphore::gk_SEM_waiting_kill
INT32 gk_SEM_waiting_kill(GS_ECB *pevent1)
Removes the ECBs from a the waiting list of a semaphore resource.
Definition: sem.c:590
gemrtos_core.h
GEmRTOS CORE definitions.
gs_tcb::TCBType
unsigned int TCBType
TYPE of the task.
Definition: gemrtos_core.h:443
Event::gk_ECBFL_Link
INT32 gk_ECBFL_Link(GS_ECB *pevent)
Link ECB to Free List. Removes the signals from ECB.
Definition: listfunctions.c:324
Task::gu_GetTask
void* gu_GetTask(void *TaskCode, void *p_arg, void *StkBotton, unsigned int StkSize)
Return a pointer to a TCB for a new task.
Definition: grtosuserfunctions.c:393
Signal::gu_signal_create
GS_SCB* gu_signal_create(INT32 Type, INT32 Priority, void *pxcb, void *Signal_Code, void *Signal_Arg)
Creates an associated SCB to a structure according to the Type.
Definition: grtosuserfunctions.c:583
gs_scb::SCB_NextSCBAPSL
struct gs_scb* SCB_NextSCBAPSL
Pointer to the next pending SCB lined.
Definition: gemrtos_core.h:402
gs_tcb::TCBPeriod
INT64 TCBPeriod
Period of the task.
Definition: gemrtos_core.h:449
Event::gk_ECB_GetFree
GS_ECB* gk_ECB_GetFree(void)
Returns a pointer to a Free ECB, NULL if there is not ECB available.
Definition: gemrtos_core.c:107
gs_tcb::TCBRunPriority
INT64 TCBRunPriority
Priority when it is executed.
Definition: gemrtos_core.h:447
TCB_IsValid
INT32 TCB_IsValid(GS_TCB *ptcb)
Definition: monitor.c:76
Miscellaneous::gu_get_now
gt_time gu_get_now(void)
Return the system time in system time units.
Definition: grtosuserfunctions.c:751
Time::GRTOS_CMD_FRZ_TM_THR_GET
GRTOS_CMD_FRZ_TM_THR_GET({ \ TIMEPRIORITY value64 \ value64.i32[1] = (unsigned) IORD(GRTOS_DRIVER_GRTOS_BASE, ADDR_FRZ_THR_HGH) \ value64.i32[0] = (unsigned) IORD(GRTOS_DRIVER_GRTOS_BASE, ADDR_SMP) \ value64.i64 \ })
GRTOS_CMD_FRZ_TM_THR_GET Returns the value of the Frozen Time Threshold (R_FRZ_TM_THR) register of th...
Definition: grtos_regs.h:152
G_RCB
struct g_rgb G_RCB
Definition: gemrtos_core.h:54
Task::gk_TASK_RELEASE
INT32 gk_TASK_RELEASE(GS_TCB *ptcb)
Release a new invocation of the task. Preserves the Associated signal list. If task is not completed,...
Definition: listfunctions.c:897
Signal::gk_SCBFL_Link
INT32 gk_SCBFL_Link(GS_SCB *psignal)
Links a SCB to the Free List.
Definition: listfunctions.c:1173
Resource::gk_RESOURCE_ECB_KILL_CALLBACK
void gk_RESOURCE_ECB_KILL_CALLBACK(GS_ECB *pevent)
This function is called when a resource event is kill. It has to resolve according the event type.
Definition: grtosuserfunctions.c:896
Signal::gu_signal_destroy
INT32 gu_signal_destroy(GS_SCB *pscb)
Unlink the signal associated to a control block.
Definition: grtosuserfunctions.c:642
Generated by   doxygen 1.8.17