Programming the core system

const PxCodeProtectSet_T _cpu0_sys_code_protection =
{
    /* Range 0 the complete text section */
    .cpr[0].s = {(PxUInt_t)__TEXT_BEGIN,
                 (PxUInt_t)__TEXT_END,},
    /* Range 1 the traptab section */
    .cpr[1].s = {(PxUInt_t)__TRAP_TAB_BEGIN,
                 (PxUInt_t)__TRAP_TAB_END,},
    /* Range 2 the inttab section */
    .cpr[2].s = {(PxUInt_t)__INT_TAB_BEGIN,
                 (PxUInt_t)__INT_TAB_END,},
    .cpmr.cpxe.bits = {
                        .dp0 = 1,   /* the CPXE 0..2 executable */
                        .dp1 = 1,
                        .dp2 = 1
                      }
};

const PxCodeProtectSet_T _cpu0_task_code_protection =
{
    /* Range 0 the complete text section */
    .cpr[0].s = {(PxUInt_t)__TEXT_BEGIN,
                 (PxUInt_t)__TEXT_END,},
    .cpmr.cpxe.bits = {
                        .dp0 = 1,   /* the CPXE 0 executable */
                      }
};

const PxDataProtectSetInit_T _cpu0_sys_data_protection =
{
    /* Range 0: read only data */
    .dpr[0].s = {(PxUInt_t)PxTricSystemRodataLowerBound,
                 (PxUInt_t)PxTricSystemRodataUpperBound,},
    /* Range 1: the CSA area of CPU0 */
    .dpr[1].s = {(PxUInt_t)__CSA_BEGIN_CPU0_,
                 (PxUInt_t)__CSA_END_CPU0_,},
    /* Range 2: the KERNEL data area of CPU0 including objects and stack */
    .dpr[2].s = {(PxUInt_t)PxTricSystemDataLowerBound_CPU0_,
                 (PxUInt_t)PxTricSystemDataUpperBound_CPU0_},
    /* Range 3: System/Kernel stack of CPU0 */
    .dpr[3].s = {(PxUInt_t)PXROS_SYSTEM_STACK_BEGIN_CPU0_,
                 (PxUInt_t)PXROS_SYSTEM_STACK_CPU0_,},
    /* Range 4: the SFR area */
    .dpr[4].s = {(PxUInt_t)PERIPHERAL_MEM_BASE,
                 (PxUInt_t)PERIPHERAL_MEM_END,},
    /* Range 5:  some area */
    .dpr[5].s = {0, 0},
    /* Range 6: the other area */
    .dpr[6].s = {0,0},
    /* Range 7: used dynamically by the kernel (TC2x)
                used to get access to memory before PXROS is started
                - especially used for copy and clear functions
                For TC3x this will be range 8 and range 7 can be used otherwise
    */
    .dpr[7].s = {0,0},
    /* the DPRE 0..4,7 readable by the kernel */
    .dpmr.kernel.dpre.bits = {
                        .dp0 = 1, .dp1 = 1, .dp2 = 1, .dp3 = 1,
                        .dp4 = 1, .dp5 = 0, .dp6 = 0, .dp7 = 1
                      },
    /* the DPWE 1..4,7 writable by the kernel */
    .dpmr.kernel.dpwe.bits = {
                        .dp0 = 0, .dp1 = 1, .dp2 = 1, .dp3 = 1,
                        .dp4 = 1, .dp5 = 0, .dp6 = 0, .dp7 = 1
                      },

    /* the DPRE 0,3,4 readable by the system (handlers running in supervisor mode) */
    .dpmr.system.dpre.bits = {
                        .dp0 = 1, .dp1 = 0, .dp2 = 0, .dp3 = 1,
                        .dp4 = 1, .dp5 = 0, .dp6 = 0, .dp7 = 0
                      },
    /* the DPWE 3,4 writable by the system (handlers running in supervisor mode) */
    .dpmr.system.dpwe.bits = {
                        .dp0 = 0, .dp1 = 0, .dp2 = 0, .dp3 = 1,
                        .dp4 = 1, .dp5 = 0, .dp6 = 0, .dp7 = 0
                      },
};

// for more information on this structure, see chapter
// "Layout and initialisation of a Task"
static const PxTaskSpec_T InitTaskSpec =
{
        .ts_name                     = "InitTask",
        .ts_fun                      = InitTask_Func,
        .ts_mc                       = PXMcTaskdefault,
        .ts_opool                    = PXOpoolSystemdefault,
        .ts_prio                     = 0,
        .ts_privileges               = PXUser1Privilege,
        .ts_context                  = &InitTaskContext,
        .ts_taskstack.stk_type       = PXStackAlloc,
        .ts_taskstack.stk_size       = INITTASK_STACKSIZE,
        .ts_taskstack.stk_src.mc     = PXMcTaskdefault,
        .ts_inttaskstack.stk_type    = PXStackDontCheck,
        .ts_inttaskstack.stk_size    = 0,
        .ts_inttaskstack.stk_src.stk = 0,
        .ts_abortstacksize           = 0
};

const PxInitSpec_T InitSpec_CORE0 =
    {
        .is_sysmc_type      = PXMcVarsizedAligned,
        .is_sysmc_size      = 8,
        .is_sysmc_blk       = Sysmem0,
        .is_sysmc_blksize   = SYSMEMSIZE_CORE0,

        .is_obj_number      = NUM_OF_PXOBJS_CORE0,
        .is_obj_namelength  = PXROS_NAMESIZE,
        .is_inittask        = &InitTaskSpec,

        .is_objmc_type      = PXMcVarsizedAligned,
        .is_objlmc_size     = 8,
        .is_objmc_blk       = PxObjmem_CPU0_,
        .is_objmc_blksize   = (PxSize_t)PX_OBJMEMSIZE_CPU0_,

        .is_taskmc_type     = PXMcVarsizedAdjusted,
        .is_taskmc_size     = 8,
        .is_taskmc_blk      = Taskmem_Core0,
        .is_taskmc_blksize  = TASKMEMSIZE_CORE0,

        .is_core_start      = (unsigned int)_start,

         /* the system stack */
        .is_system_stack = PXROS_SYSTEM_STACK_BEGIN_CPU0_,
        .is_system_stack_size = (PxUInt_t)PXROS_SYSTEM_STACK_SIZE_CPU0_,

        /* all objects are global accessible */
        .is_global_obj_number = 0,

        /* the protection definition */
        .is_sys_code = &_cpu0_sys_code_protection,
        .is_sys_data = &_cpu0_sys_data_protection,
        .is_task_code = &_cpu0_task_code_protection,
    };

// Since a memory class for tasks is defined
// the inittask gets PXMcTaskdefault as the memory class

static const PxInitSpecsArray_t InitSpecsArray[] =
{
    &InitSpec_CORE0,
    0,
    ...
};


PxError_t error;

// the initialisation of PXROS-HR; if PxInit returns,
// the corresponding error code is logged in error

error = PxInit(InitSpecsArray, 1);

// Definition of the memory context of the Task; since the elements of
// protection[0] are set to 0, the memory area is inherited
// from the creator of the Task

static const PxTaskContext_T Task1_Context = {

        // data area, inherited from the creator of the Task
        .protection[0].lowerBound = 0,
        .protection[0].upperBound = 0,
        .protection[0].prot       = NoAccessProtection,

        // read-write data area
        .protection[1].lowerBound = (PxUInt_t)Task1_data_base,
        .protection[1].upperBound = (PxUInt_t)Task1_data_end,
        .protection[1].prot       = WRProtection
};

#define TASK1_STACKSIZE     100         // stacksize in 4-byte units

// Creating the Task specification
const PxTaskSpec_T Task1_Spec = {
        // Name of the Task
        .ts_name                        = "Task1",

        // Task function (see above)
        .ts_fun                         = Task1_Func,

        // Memory block of the Task
        .ts_mc                          = PXMcTaskdefault,

        // Objectpool of the Task
        .ts_opool                       = PXOpoolTaskdefault,

        // Start priority of the Task, this Parameter exists only
        // for compatibility; it is ignored
        .ts_prio                        = 0,

        // Privileges of the Task
        .ts_privileges                  = PXUser0Privilege,

        // A pointer to the memory context of the Task
        .ts_context                     = &Task1_Context,

        // Stack type, will be allocated
        .ts_taskstack.stk_type          = PXStackAlloc,

        // Stack size in 4-byte units to be checked;
        .ts_taskstack.stk_size          = TASK1_STACK_SIZE,

        // Stack will be allocated from PXMcTaskdefault
        .ts_taskstack.stk_src.mc       = PXMcTaskdefault,

        // Abort stack size; is ignored in this case
        .ts_abortstacksize              = 0
};

// Creates a Task with the predefined specification,
// priority TASK1_PRIO and the activation events TASK1_ACTIVATION_EVENTS.
// The return value is the ID of the created Task
Task1_Id = PxTaskCreate(opool, &Task1_Spec, TASK1_PRIO,  TASK1_ACTIVATION_EVENTS);

void InitTask_Func(PxTask_t myID,
                   PxMbx_t myMailbox,
                   PxEvents_t myActivationEvents)
{
  // Declarations and initialisations
    int foo = 0;
    int bar;

    if(myActivationEvents == EV_ACT_EV1)
    {
        bar = 1;
    }
    else
    {
        bar = 42;
    }

    // Main loop
    while(1)
    {
      // Parallel waiting for events and messages
        PxMsgEvent_t msgev;
        msgev = PxMsgReceive_EvWait(myMailbox,EV_EVENT_MASK);
        if(PxMsgIdIsValid(msgev.msg))
        {
          // message received
            do_sth_with_msg(msgev.msg);
        }

        if(msgev.events != 0)
        {
          // event received
            do_sth_with_events(msgev.events);
        }
    }
}

...

  PxMbx_t mpool;
  PxMsg_t msg;

  msgpool = PxMbxRequest(my_opool); // request mailbox object

  if(PxMbxIdIsValid(msgpool))       // check, if object valid
  {

    PxMsg_t tmpmsg;
    for(i=0;i<10;i++)               // request 10 messages
    {
      tmpmsg = PxMsgRequest(MSG_SIZE, my_memclass,my_opool);
      if(PxMsgIdIsValid(tmpmsg))
      {
        PxMsgInstallRelmbx(tmpmsg,msgpoool); // set release mailbox
        tmpmsg = PxMsgSend(tmpmsg,msgpool)   // send message to message pool
        if(PxMsgIdIsValid(tmpmsg))
                do_error_handling();
      }
      else
      {
        do_error_handling();
      }
    }
  }
  else
  {
    do_error_handling();
  }

 ...

 msg = PxMsgReceive(msgpool); // a message is requested from the
                              // message pool

 fill_msg_data();

 PxMsgSend(msg,targetmbx)    // the message is sent to the mailbox
                             // targetmbx
 ...

...

PxMsgEvent_t retval = PxMsgReceive_EvWait(mbx, EV_MASK);
if(PxMsgIdIsValid(retval.msg))
{
  // a message was received
  do_sth();
}

if(retval.events != 0)
{
  // one or more Events were received

  if(retval.event & EV1)
  {
    ...
  }

  if(retval.event & EV2)
  {
    ...
  }

  ...
}

// Task1
...

 struct comm_data data;
 PxMsg_t msg0, msg1;
 PxError_t error;

...

 // create message with data as data area of the message
 msg0 = PxMsgEnvelop(&data,sizeof(data),my_opool);

 if(!PxMsgIdIsValid(msg0))
 {
   do_error_handling();
   return;
 }

 error = PxMsgSetToAwaitRel(msg0);
 if(error != PXERR_NOERROR)
 {
   do_error_handling();
   return;
 }

 // Send the message; access to data and msg
 // is no longer permitted
 msg1 = PxMsgSend(msg0,mbx_task2);

 // if sending was successful, the message Handle
 // is invalid
 if(PxMsgIdIsValid(msg1))
 {
   do_error_handling();
   return;
 }

 // wait for recipient to release the message
 msg0 = PxMsgAwaitRel(msg0);

 if(!PxMsgIdIsValid(msg0))
 {
   do_error_handling();
   return;
 }

 ...

 // the message is finally released
 PxMsgRelease(msg0);

// Task2
...

 struct comm_data* pdata;
 PxMsg_t msg;

 // wait for message
 msg = PxMsgReceive(my_mbx);
 if(!PxMsgIdIsValid(msg))
 {
   do_error_handling();
   return;
 }

 // read data area of the message
 pdata = (struct comm_data*)PxMsgGetData(msg);

...

 // Release message; access to msg and pdata
 // is no longer permitted
 PxMsgRelease(msg);

...

...
struct foo
{
  int x;
  int y;
  struct bar b;
  int z;
} data;

...
// create message and pack data into message
msg = PxMsgEnvelop(&data,sizeof(data),defaultopool);
PxMsgSetToAwaitRel(msg);

// protect data area of the message; the recipient
// has only read rights to the buffer; he may not
// write into it
PxMsgSetProtection(msg, ReadProtection);

...
// send to Task2
PxMsgSend(msg,task2mbx);
...
// wait for release of message
msg = PxMsgAwaitRel(msg);

// reset to original data area
PxMsgSetData(msg,0);

// reset to original size of the data area
PxMsgSetSize(msg,sizeof(data));
...

...
struct foo* pData;
...
// receive message
msg = PxMsgReceive(task2mbx);
...
pData = PxMsgGetData(msg);
...
// restrict start address and size of the data area to Element b of
//  the structure foo
// Set start address to b
PxMsgSetData(msg,&pData->b);

// Set size to size of b, i.e. z is removed
PxMsgSetSize(msg,sizeof(pData->b));

// Note: If only the beginning of the data area is changed, the
// size of the remaining area is automatically adjusted

...
// send to Task3
PxMsgSend(msg,task3mbx);
...

...
struct bar* pData;
PxSize_t size;
...
// receive message
msg = PxMsgReceive(task3mbx);
...
// request data area and size of the area
pData = PxMsgGetData(msg);
size = PxMsgGetSize();
...
PxMsgRelease(msg);
...