struct task_structure                  //Es wird eine Struktur erstellt, die den count Wert enthält und die ID des Tasks
{
    int id;
    int rohmaterial;
    int produzierte_stueck;
    int status; // 1 = produktion ; 0 = service
};

void init_status(struct task_structure *pTask,int id);

//! Message Mailboxe - Parameters

OS_EVENT *CommMbox;
char CommRxBuf[100];


//! Message Queue -  Parameters

OS_EVENT *CommQ;
void *CommMsg[10];

//! Mutex - Paramters

OS_EVENT *mutex_sem;

//! Memoryblock

OS_MEM *pMemBuf;
INT32U CommBuf[16][32];
OS_STK        CommMemoryStk[8*sizeof(struct task_structure)];

int main(void)
{
    INT8U ErrVar;
#if 0
    BSP_IntDisAll();                       /* For an embedded target, disable all interrupts until we are ready to accept them */
#endif

    OSInit();                              /* Initialize "uC/OS-II, The Real-Time Kernel"                                      */

    //! Create Message Mailboxes

    CommMbox = OSMboxCreate((void *)0);

    //! Create Message Queue

    CommQ = OSQCreate(&CommMsg[0], 10);

    //! Create Mutex

    mutex_sem=OSMutexCreate(1, &ErrVar);
    if (ErrVar == OS_ERR_NONE)
        printf("\nMutex erfolgreich erstellt...\n");
    else
        printf("\nMutex erstellung failed...\n");

    if (ErrVar == OS_ERR_NONE)
        printf("\nMemoryblock erfolgreich erstellt...\n\n##################################################################\n\n\n");
    else
        printf("\nFlags erstellung failed...\n");

    //! Create Tasks

    ErrVar = OSTaskCreate(serviceTask, (void *) 0, &pAppStartTask1[0], 11);

    ErrVar = OSTaskCreate(genericTask, (void *) 1, &pAppStartTask2[0], 3);
    ErrVar = OSTaskCreate(genericTask, (void *) 2, &pAppStartTask3[0], 4);
    ErrVar = OSTaskCreate(genericTask, (void *) 3, &pAppStartTask4[0], 5);
    ErrVar = OSTaskCreate(genericTask, (void *) 4, &pAppStartTask5[0], 6);
    ErrVar = OSTaskCreate(genericTask, (void *) 5, &pAppStartTask6[0], 7);
    ErrVar = OSTaskCreate(genericTask, (void *) 6, &pAppStartTask7[0], 8);
    ErrVar = OSTaskCreate(genericTask, (void *) 7, &pAppStartTask8[0], 9);
    ErrVar = OSTaskCreate(genericTask, (void *) 8, &pAppStartTask9[0], 10);

    //! Create Memory

    pMemBuf = OSMemCreate(&CommMemoryStk[0], 8, sizeof(struct task_structure), &ErrVar);
    printf("%d Byte",sizeof(struct task_structure));

    //CommMemory = OSMemCreate(&CommMemoryStk[0], 8, sizeof(Production_Data), &ErrVar);

#if OS_TASK_NAME_SIZE > 11
    OSTaskNameSet(APP_TASK_START_PRIO, (INT8U *)"Start Task", &ErrVar);
#endif

#if OS_TASK_NAME_SIZE > 14
    OSTaskNameSet(OS_IDLE_PRIO, (INT8U *)"uC/OS-II Idle", &ErrVar);
#endif

#if (OS_TASK_NAME_SIZE > 14) && (OS_TASK_STAT_EN > 0)
    OSTaskNameSet(OS_STAT_PRIO, "uC/OS-II Stat", &ErrVar);
#endif

    OSStart();                             /* Start multitasking (i.e. give control to uC/OS-II)                               */
    return 0;                              /* should never be reached                                                          */
}

void genericTask(void *p_arg)
{
    int *pIdentification;
    INT8U ErrVar2;
    pIdentification=(int *)p_arg;
    char array[50];

    struct task_structure *pTask;

    pTask=OSMemGet(pMemBuf, &ErrVar2);
    if(pTask==NULL)
    {
        printf("Speicherallokation fuer Task %d fehlgeschlagen",pIdentification);
        return;
    }
    else
    {
        init_status(pTask,pIdentification);
    }

#if OS_TASK_STAT_EN > 0
    OSStatInit();                                /* Determine CPU capacity                                                     */
#endif

    while(1)                                 /* Task body, always written as an infinite loop.*/
    {
        if(pTask->status==1)
        {
            pTask->rohmaterial=pTask->rohmaterial-1;
            pTask->produzierte_stueck=pTask->produzierte_stueck+1;
        }
        else if(pTask->rohmaterial==0)
            pTask->status=0;
        printf("%d\n",pTask->id);
//        sprintf(array,"%d",5);

        //ErrVar2=OSQPost(CommQ,(void *)&array[0]);
        ErrVar2=OSQPost(CommQ,pTask);

        OSTimeDlyHMSM(0, 0, 1, 0);
    }
}

void serviceTask(void *p_arg)
{
    INT8U ErrVar3;
    p_arg = p_arg;

    struct task_structure *pPointer;

    while(1)                                 /* Task body, always written as an infinite loop.*/
    {
        pPointer=OSQPend(CommQ, 3, &ErrVar3);//!pPointer zeigt auf NULL -> WARUM??
        if(ErrVar3!=OS_ERR_NONE)
        {
            printf("Task %d Rohmaterial: %d",pPointer->id,pPointer->rohmaterial);
            OSMemPut(pMemBuf, pPointer);
        }
        else
            break;
        OSTimeDlyHMSM(0, 0, 1, 0);
    }
}