Advertisement
Akihito759

uCos

Jan 11th, 2017
1,221
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/OS-II
  4. *                                          The Real-Time Kernel
  5. *
  6. *                           (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL
  7. *                                           All Rights Reserved
  8. *
  9. *                                               EXAMPLE #1
  10. *********************************************************************************************************
  11. */
  12.  
  13. #include "includes.h"
  14. #include "string.h"
  15.  
  16. /*
  17. *********************************************************************************************************
  18. *                                               CONSTANTS
  19. *********************************************************************************************************
  20. */
  21.  
  22. #define  TASK_STK_SIZE                          512       /* Size of each task's stacks (# of WORDs)            */
  23. #define  N_TASKS                                        20     /* Number of identical tasks  */                  
  24. //kolejki do obsługi klawiatury,edycji i wyświetlania
  25. #define          MSG_QUEUE_SIZE1            20    
  26. #define          MSG_QUEUE_SIZE2                20
  27. //kolejki do zadania 3
  28. #define         MSG_QUEUE_SIZE3                 80
  29. #define         BUF_SIZE                                80
  30. #define         MEM_SIZE                                100
  31.  
  32.  
  33. /*
  34. *********************************************************************************************************
  35. *                                               VARIABLES
  36. *********************************************************************************************************
  37. */
  38.  
  39.  
  40. OS_STK         TaskStk[N_TASKS][TASK_STK_SIZE];        /* Tasks stacks                                  */
  41. OS_STK         TaskStartStk[TASK_STK_SIZE];
  42. INT8U          TaskData[N_TASKS];                      /* Parameters to pass to each task               */
  43. OS_EVENT       *RandomSem;
  44.  
  45. void           *MsgQueueTbl1[20];
  46. void           *MsgQueueTbl2[20];
  47.  
  48. OS_EVENT       *CommKey,*CommMessage,*CommTask; //Kolejki: Klawiatura -> Edycja, ZBIORCZA, Edycja -> TaskSendAll
  49. OS_EVENT       *TaskMBox[6],*SendMBox;
  50. OS_EVENT       *Semafor, *TaskMsgQueue; //Skrzynki,Semafor,Kolejke do LAB3
  51.  
  52. OS_MEM *MemoryPtr;
  53. INT8U Memory[MEM_SIZE][sizeof(INT32U)]; //Potrzebne do alkokacji pamięci
  54.  
  55. void           *MsgQueueTbl[MSG_QUEUE_SIZE3],*TaskMsgQueueStorage[MSG_QUEUE_SIZE3]; // storage for queues
  56.  
  57.  
  58. unsigned long int globalN ;
  59. unsigned long int startValue  = 1;
  60.  
  61.  
  62. typedef struct
  63. {
  64.     /*
  65.     numer zadania, wartość pętli obciążającej,licznik wejść;
  66.     */
  67.    
  68.     INT16U  ID; //numer zadania
  69.     char  load[BUF_SIZE]; //obciążenie
  70.     INT32U counter;
  71.     char entries[BUF_SIZE]; //wejscia
  72.     INT8U additional; // priorytet zadania
  73.    
  74. }TASKS_INFO;
  75.  
  76.  
  77. /*
  78. *********************************************************************************************************
  79. *                                           FUNCTION PROTOTYPES
  80. *********************************************************************************************************
  81. */
  82. void    Klawiatura(void *data);  
  83. void    Wyswietlanie(void *data);
  84. void    Edycja(void *data);
  85. void    TaskSendAll(void *data);
  86. void    Sem(void *pdata);
  87. void    Queue(void *pdata);
  88. void    MBox(void *pdata);
  89.  
  90.             void  Task(void *data);          /* Function prototypes of tasks                  */
  91.             void  TaskStart(void *data);      /* Function prototypes of Startup task           */
  92. static  void  TaskStartCreateTasks(void);
  93. static  void  TaskStartDispInit(void);
  94. static  void  TaskStartDisp(void);
  95.     //    void  UseQueue(void *data);
  96.  
  97. /*$PAGE*/
  98. /*
  99. *********************************************************************************************************
  100. *                                                MAIN
  101. *********************************************************************************************************
  102. */
  103.  
  104. void  main (void)
  105. {
  106.     int i,err=0;
  107.     PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);      /* Clear the screen                         */
  108.    
  109.     OSInit();                                              /* Initialize uC/OS-II                      */
  110.  
  111.     PC_DOSSaveReturn();                                    /* Save environment to return to DOS        */
  112.     PC_VectSet(uCOS, OSCtxSw);                             /* Install uC/OS-II's context switch vector */
  113.  
  114.     RandomSem   = OSSemCreate(1);                          /* Random number semaphore                  */
  115.  
  116.     OSTaskCreate(TaskStart, (void *)0, &TaskStartStk[TASK_STK_SIZE - 1], 0);
  117.    
  118.     MemoryPtr = OSMemCreate(Memory, MEM_SIZE, sizeof(INT32U),&err);
  119.    
  120.    
  121.     CommKey = OSQCreate(&MsgQueueTbl1[0], MSG_QUEUE_SIZE1);
  122.     CommMessage = OSQCreate(&TaskMsgQueueStorage[0], MSG_QUEUE_SIZE3); //kolejka globalna
  123.     TaskMsgQueue = OSQCreate(&MsgQueueTbl[0], MSG_QUEUE_SIZE3);
  124.     if(CommKey == NULL || CommMessage == NULL || TaskMsgQueue == NULL) err=1;
  125.        
  126.        
  127.        
  128.      for(i=0; i<6; ++i){        //inicjalizacja 6 skrzynek i semaforów
  129.         TaskMBox[i] = OSMboxCreate((void*)0);
  130.         if(TaskMBox[i] == NULL) err=2; // błąd utworzenia skrzynki
  131.      }
  132.      
  133.      SendMBox = OSMboxCreate((void*)0);
  134.      if(SendMBox == NULL) err = 2;
  135.      
  136.      Semafor = OSSemCreate(1); // 1 -> oznacza ilość chronionych źródeł
  137.      if(Semafor == NULL) err=3;
  138.      
  139.        
  140.     if(err==0) {
  141.     printf("Kolejki,Skrzynki i Semafor zostaly poprawie utworzone");
  142.     delay(800);
  143.     OSStart();
  144.     }
  145.     if(err==1){
  146.         printf("Kolejki nie zostaly utworzone");
  147.     }
  148.     if(err==2){
  149.         printf("Skrzynki nie zostaly utworzone");
  150.     }
  151.     if(err==3){
  152.         printf("Semafor nie zostal utworzony");
  153.     }
  154.     /* Start multitasking                       */
  155. }
  156.  
  157.  
  158. /*
  159. *********************************************************************************************************
  160. *                                              STARTUP TASK
  161. *********************************************************************************************************
  162. */
  163. void  TaskStart (void *pdata)
  164. {
  165. #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
  166.     OS_CPU_SR  cpu_sr;
  167. #endif
  168.     char       s[100];
  169.     INT8U        err,i;
  170.     INT16S     key;
  171.     TASKS_INFO info;
  172.  
  173.  pdata = pdata;                                         /* Prevent compiler warning                 */
  174.  
  175.  
  176.     OSSemPend(Semafor,0,&err); //nadanie początkowej wartości zmiennej globalnej globalN
  177.     globalN = startValue;
  178.     OSSemPost(Semafor);
  179.    
  180.     for(i=0; i < 6; ++i){ // wysylanie wartosci początkowej pentli obciązającej do skrzynek i kolejki
  181.         if(i<4)OSQPost(TaskMsgQueue,(void*)&startValue);
  182.         OSMboxPost(TaskMBox[i],(void*)&startValue);
  183.     }
  184.    
  185.    
  186.  
  187.    
  188.  
  189.     TaskStartDispInit();                                   /* Initialize the display                   */
  190.  
  191.     OS_ENTER_CRITICAL();
  192.     PC_VectSet(0x08, OSTickISR);                           /* Install uC/OS-II's clock tick ISR        */
  193.     PC_SetTickRate(OS_TICKS_PER_SEC);                      /* Reprogram tick rate                      */
  194.     OS_EXIT_CRITICAL();
  195.  
  196.     OSStatInit();                                          /* Initialize uC/OS-II's statistics         */
  197.    
  198.     TaskStartCreateTasks();                                /* Create all the application tasks         */
  199.  
  200.     for (;;) {
  201.         TaskStartDisp();                                  /* Update the display                       */
  202.         OSCtxSwCtr = 0;                                    /* Clear context switch counter             */
  203.         OSTimeDlyHMSM(0, 0, 1, 0);              /* Wait one second                          */
  204.  
  205.     }
  206. }
  207.  
  208. /*$PAGE*/
  209. /*
  210. *********************************************************************************************************
  211. *                                        INITIALIZE THE DISPLAY
  212. *********************************************************************************************************
  213. */
  214.  
  215. static  void  TaskStartDispInit (void)
  216. {
  217. /*                                1111111111222222222233333333334444444444555555555566666666667777777777 */
  218. /*                      01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
  219.     PC_DispStr( 0,  0, "Aktualna liczba:                                                                ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  220.     PC_DispStr( 0,  1, "                                                                                ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  221.     PC_DispStr( 0,  2, "Piorytet  ID    ilosc wejsc     Obciazenie     Delta     Error                                                  ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  222.     PC_DispStr( 0,  3, " 4  S                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  223.     PC_DispStr( 0,  4, " 5  S                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  224.     PC_DispStr( 0,  5, " 6  S                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  225.     PC_DispStr( 0,  6, " 7  S                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  226.     PC_DispStr( 0,  7, " 8  S                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  227.     PC_DispStr( 0,  8, " 9  S                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  228.     PC_DispStr( 0,  9, " 10 M                                                                    ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  229.     PC_DispStr( 0, 10, " 11 M                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  230.     PC_DispStr( 0, 11, " 12 M                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  231.     PC_DispStr( 0, 12, " 13 M                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  232.     PC_DispStr( 0, 13, " 14 M                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  233.     PC_DispStr( 0, 14, " 15 M                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  234.     PC_DispStr( 0, 15, " 16 Q                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  235.     PC_DispStr( 0, 16, " 17 Q                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  236.     PC_DispStr( 0, 17, " 18 Q                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  237.     PC_DispStr( 0, 18, " 19 Q                                                                        ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  238.     PC_DispStr( 0, 19, "                                                                       ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  239.     PC_DispStr( 0, 21, "                                                                                ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  240.     PC_DispStr( 0, 22, "#Tasks          :        CPU Usage:     %                                       ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  241.     PC_DispStr( 0, 23, "#Task switch/sec:                                                               ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  242.     PC_DispStr( 0, 24, "                            <-PRESS 'ESC' TO QUIT->                             ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY + DISP_BLINK);
  243. /*                                1111111111222222222233333333334444444444555555555566666666667777777777 */
  244. /*                      01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
  245. }
  246.  
  247. /*$PAGE*/
  248. /*
  249. *********************************************************************************************************
  250. *                                           UPDATE THE DISPLAY
  251. *********************************************************************************************************
  252. */
  253.  
  254. static  void  TaskStartDisp (void)
  255. {
  256.     char   s[80];
  257.  
  258.  
  259.     sprintf(s, "%5d", OSTaskCtr);                                  /* Display #tasks running               */
  260.     PC_DispStr(18, 22, s, DISP_FGND_YELLOW + DISP_BGND_BLUE);
  261.  
  262. #if OS_TASK_STAT_EN > 0
  263.     sprintf(s, "%3d", OSCPUUsage);                                 /* Display CPU usage in %               */
  264.     PC_DispStr(36, 22, s, DISP_FGND_YELLOW + DISP_BGND_BLUE);
  265. #endif
  266.  
  267.     sprintf(s, "%5d", OSCtxSwCtr);                                 /* Display #context switches per second */
  268.     PC_DispStr(18, 23, s, DISP_FGND_YELLOW + DISP_BGND_BLUE);
  269.  
  270.     sprintf(s, "V%1d.%02d", OSVersion() / 100, OSVersion() % 100); /* Display uC/OS-II's version number    */
  271.     PC_DispStr(75, 24, s, DISP_FGND_YELLOW + DISP_BGND_BLUE);
  272.  
  273.     switch (_8087) {                                               /* Display whether FPU present          */
  274.         case 0:
  275.              PC_DispStr(71, 22, " NO  FPU ", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  276.              break;
  277.  
  278.         case 1:
  279.              PC_DispStr(71, 22, " 8087 FPU", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  280.              break;
  281.  
  282.         case 2:
  283.              PC_DispStr(71, 22, "80287 FPU", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  284.              break;
  285.  
  286.         case 3:
  287.              PC_DispStr(71, 22, "80387 FPU", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  288.              break;
  289.     }
  290. }
  291.  
  292. /*$PAGE*/
  293. /*
  294. *********************************************************************************************************
  295. *                                             CREATE TASKS
  296. *********************************************************************************************************
  297. */
  298.  
  299. static  void  TaskStartCreateTasks (void)
  300. {
  301.     INT8U i;
  302.    
  303.         OSTaskCreate(Klawiatura, (void *)0, &TaskStk[0][TASK_STK_SIZE - 1],1);
  304.         OSTaskCreate(Edycja, (void *)0, &TaskStk[1][TASK_STK_SIZE - 1], 2);
  305.         OSTaskCreate(Wyswietlanie, (void *)0, &TaskStk[2][TASK_STK_SIZE - 1], 3);
  306.         OSTaskCreate(TaskSendAll, (void*)0, &TaskStk[3][TASK_STK_SIZE - 1], 4);
  307.  
  308.     for(i=0; i<6;++i){
  309.         TaskData[i] = i;
  310.         OSTaskCreate(Sem, (void *)&TaskData[i],  &TaskStk[i+4][TASK_STK_SIZE - 1], i + 5);
  311.        
  312.         TaskData[i+6] = i + 6;
  313.         OSTaskCreate(MBox, (void *)&TaskData[i+6],  &TaskStk[i+10][TASK_STK_SIZE - 1], i + 11);
  314.     }
  315.    
  316.     for(i=0; i<4 ;++i){
  317.         TaskData[i+12] = i +12;
  318.         OSTaskCreate(Queue, (void *)&TaskData[i+12],  &TaskStk[i+16][TASK_STK_SIZE - 1], i + 17);
  319.     }
  320.  
  321.  
  322. }
  323.  
  324. /*
  325. *********************************************************************************************************
  326. *                                                  TASKS
  327. *********************************************************************************************************
  328. */
  329.  
  330.  
  331. void  Klawiatura (void *pdata)
  332. {  
  333.     INT16S c;
  334.     pdata = pdata;
  335.    
  336.     for (;;)
  337.     {
  338.         if(PC_GetKey(&c) == TRUE)OSQPost(CommKey, (void *)&c);
  339.         OSTimeDly(13);                            /* Delay 1 clock tick                                 */
  340.     }
  341. }
  342.  
  343.  
  344.  
  345.  
  346. void  Wyswietlanie(void *pdata)
  347. {  
  348.    
  349.     TASKS_INFO *msg;
  350.     INT8U err1;
  351.     INT32U time[1][40];
  352.     INT32U T1[16],T2[16],T3[16];
  353.     INT32U temp2;
  354.     char delta[BUF_SIZE];
  355.     TASKS_INFO * info;
  356.     INT8U p,i;
  357.     INT32U intload;
  358.     char ID[BUF_SIZE],load[BUF_SIZE];
  359.     char entries[BUF_SIZE];
  360.     char s[20], s1[BUF_SIZE];
  361.     char T2Tab[BUF_SIZE],T1Tab[BUF_SIZE];
  362.     unsigned long int temp;
  363.     OS_MEM_DATA dane_pamiec;
  364.     pdata = pdata;
  365.    
  366.     for(i=0;i<16;i++) T1[i]=0;
  367.    
  368.  
  369.     for(;;)
  370.     {
  371.  
  372.            
  373.         info = (TASKS_INFO*)OSQPend(CommMessage, 0, &err1);
  374.         p = info->ID;
  375.             temp2 = info->counter;
  376.            
  377.         intload = info->load;
  378.         strncpy(entries, info->entries, BUF_SIZE);
  379.         strncpy(load,info->load,BUF_SIZE);
  380.         sprintf(ID,"%d",p);
  381.        
  382.         //sprintf(load,"%d",intload);
  383.         //ultoa(intload,load,10);
  384.        
  385.    
  386.            
  387.    
  388.         if(p < 100) // jesli p - 'priorytet' jest mniejszy od 100, to znaczy, ze otrzymana wiadomosc pochodzi od jednego z zadan 1-18
  389.         {
  390.             T2[p]=temp2;
  391.            
  392.             if(OSTimeGet()>=250){
  393.                 for(i=0;i<16;++i){
  394.             T3[i]=T2[i]-T1[i];
  395.             T1[i]=T2[i];
  396.         //  sprintf(delta,"%d",T3[i]);
  397.            
  398.             ultoa(T3[i],delta,10);
  399.                
  400.             //PC_DispStr(45, i+3,"                      ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  401.             //PC_DispStr(45, i+3, delta , DISP_FGND_YELLOW + DISP_BGND_BLUE);
  402.            
  403.             }
  404.             OSTimeSet(0);
  405.             }
  406.             PC_DispStr(48, p+3, "    ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  407.             PC_DispStr(48, p+3, delta, DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  408.             PC_DispStr(18, p+3, entries, DISP_FGND_YELLOW + DISP_BGND_BLUE);
  409.             PC_DispStr(10, p+3, ID , DISP_FGND_YELLOW + DISP_BGND_BLUE);
  410.             PC_DispStr(35, p+3,"         ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  411.             PC_DispStr(35, p+3, load , DISP_FGND_YELLOW + DISP_BGND_BLUE);
  412.         }
  413.         else
  414.             if(p == 100) // oznacza to, ze ta wiadomosc jest przeznaczona do wyswietlenia jako 'aktualna liczba'
  415.             {
  416.                 temp = atol(entries);
  417.                 sprintf(s, "%lu", temp);
  418.                 PC_DispStr( 0,  0, "Aktualna liczba:                                                                ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
  419.                 PC_DispStr(17, 0, s, DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY );
  420.             }
  421.             else
  422.                 if(p==101) // wyswietlenie tego, co aktualnie uzytkownik wpisal
  423.                 {
  424.                     PC_DispStr(0, 24, entries, DISP_FGND_YELLOW + DISP_BGND_BLUE)
  425.                 }
  426.        
  427.            
  428.        
  429.  
  430.  
  431.  
  432.        
  433.         //OSTimeDlyHMSM(0, 0, 0, 1);
  434.     }
  435. }
  436.  
  437.  void  Edycja (void *pdata)
  438. {
  439.    
  440.     INT16S c;
  441.    
  442.     INT8U  err1,err;
  443.     INT8U x=0,i;
  444.     INT8U flag=3;
  445.     INT32U number=0;
  446.     INT16S *msg;
  447.     TASKS_INFO info,info1;
  448.     char tab[BUF_SIZE]={0};
  449.     pdata = pdata;
  450.    
  451.     memset(tab,' ',BUF_SIZE-1);
  452.     tab[BUF_SIZE-1]='\0';
  453.    
  454.    
  455.    
  456.     for (;;) {
  457.        
  458.         msg = OSQPend(CommKey, 0, &err);
  459.         c=*msg;
  460.          
  461.          
  462.          
  463.          if (c == 0x1B)PC_DOSReturn(); //escape wyjście
  464.          else if (c == 0x08)flag=1; // użycie backspace
  465.          else if (c == 0x0D)flag=2; // użycie entera
  466.          else flag=0; //użycie zwykłego znaku
  467.          
  468.          if(flag == 1) //backspace
  469.          {
  470.              tab[x]=' ';
  471.              if(x>0)x--;
  472.         //   OSQPost(CommMessage, (void *)&tab[0]);
  473.              
  474.          }
  475.          
  476.         else if(flag == 2)//enter
  477.         {
  478.         //  tab[19]=c;
  479.             x=0;
  480.             number = atol(tab); // zamiana tablicy znaków na liczbe
  481.             OSMboxPost(SendMBox,(void *)&number);
  482.            
  483.             info1.ID = 100;
  484.             strncpy(info1.entries,tab,BUF_SIZE);
  485.             err1=OSQPost(CommMessage, (void *)&info1);
  486.             memset(tab,' ', BUF_SIZE-1);
  487.  
  488.            
  489.         }
  490.          
  491.         else if(flag == 0 )
  492.          {
  493.             tab[x]=c;
  494.             if(x < BUF_SIZE-1)x++;
  495.     //      OSQPost(CommMessage, (void *)&tab[0]);
  496.          }
  497.         info.ID= 101;
  498.         memcpy(info.entries, tab , BUF_SIZE);
  499.         err1 = OSQPost(CommMessage,(void*)&info);
  500.         OSTimeDly(1);                            /* Delay 1 clock tick                                 */
  501.     }
  502.    
  503. }
  504.  
  505. void TaskSendAll(void *data)
  506. {
  507.     INT32U i,j;
  508.     INT8U err;
  509.     TASKS_INFO info;
  510.     INT8U BoxRequestSend[6]={0,0,0,0,0,0};
  511.     INT32U number=0,previous=0,*msg,*MBoxPtr[6], *QueuePtr[4];
  512.    
  513.     data=data;
  514.     // spróbuję bez zarządzania pamięci zrobić to na stosie
  515.     // Potrzeba rozpatrzyć na przypadki, taki kiedy skrzynki nie nadążą z wysłaniem i taki gdy nadążą
  516.     for(;;){
  517.     msg=OSMboxPend(SendMBox,0,&err);
  518.     number=*(INT32U*)msg;
  519.    
  520.         if(1){
  521.        
  522.             OSSemPend(Semafor,0,&err);
  523.             globalN = number;
  524.             OSSemPost(Semafor);
  525.            
  526.             for(i=0 ; i< 4 ; ++i){
  527.                 err = OSQPost(TaskMsgQueue,(void*)&number);
  528.             }
  529.            
  530.             for(i=0 ; i<6 ; ++i){
  531.                 MBoxPtr[i]= OSMemGet(MemoryPtr, &err);
  532.                
  533.                 if(err != OS_NO_ERR)  PC_DispStr(0, 21, "blad przy przydzielaniu pamieci dla Mbox", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  534.                 if(MBoxPtr[i] != NULL) *MBoxPtr[i] = number;
  535.                
  536.                 err = OSMboxPost(TaskMBox[i],(void*)MBoxPtr[i]);
  537.                 if(err == OS_MBOX_FULL) BoxRequestSend[i] = 1;
  538.             }
  539.         previous = number;
  540.         }
  541.        
  542.         for(i=0 ; i<6 ; ++i){
  543.                 if(BoxRequestSend[i] == 1){
  544.                     err = OSMboxPost(TaskMBox[i],(void*)MBoxPtr[i]);
  545.                     if(err != OS_MBOX_FULL) BoxRequestSend[i] = 0;
  546.                 }
  547.                
  548.             }
  549.            
  550.        
  551.     //  OSTimeDly(1);
  552.     }
  553.    
  554.    
  555. }
  556.  
  557. void Queue(void * data)
  558. {
  559.     INT8U p = *(INT8U*)data;
  560.     unsigned long int counter = 0, i, entries = 0;
  561.     TASKS_INFO info;
  562.     unsigned long int *msg;
  563.     INT8U err;
  564.     unsigned long int n;
  565.     unsigned long int previous = 0;
  566.     char s[BUF_SIZE],s1[BUF_SIZE];
  567.  
  568.     info.ID = p;
  569.  
  570.     for(;;)
  571.     {
  572.    
  573.         msg = OSQAccept(TaskMsgQueue);
  574.         if(msg != (void*)0)
  575.         {
  576.             //n = *(unsigned long int*)msg;
  577.             n=*msg;
  578.         }  
  579.         else
  580.             n = previous;
  581.  
  582.         counter = 0;
  583.  
  584.        
  585.        
  586.         for(i = 0; i< n; ++i) // petla obciazajaca
  587.         {
  588.             counter++;
  589.         }
  590.        
  591.        
  592.        
  593.         info.counter=entries;
  594.         sprintf(s, "%lu", entries);
  595.         strncpy(info.entries, s, BUF_SIZE);
  596.         sprintf(s1, "%lu", n);
  597.         strncpy(info.load, s1, BUF_SIZE);
  598.         err = OSQPost(CommMessage, (void*)&info);
  599.  
  600.         if(err == OS_Q_FULL)
  601.         {
  602.             PC_DispStr(0, 21, "queue error", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  603.         }
  604.    
  605.         entries++;
  606.         previous = n;
  607.         OSTimeDly(1);
  608.        
  609.    
  610.        
  611.     }
  612. }
  613.  
  614.  
  615. /*
  616. *********************************************************************************************************
  617. *                                               UseMbox
  618. *
  619. * Opis: Odczytanie wartosci petli obciazajacej ze skrzynek, a nastepnie wykonanie petli obciazajacej
  620. *********************************************************************************************************
  621. */
  622.  
  623.  
  624.  
  625. void MBox(void * data)
  626. {
  627.     //char s[20];
  628.     unsigned long int n ;
  629.     unsigned long int previous = 0;
  630.     INT8U p = *(INT8U*)data;
  631.     unsigned long int *msg;
  632.     INT8U err;
  633.     TASKS_INFO info;
  634.     unsigned long int counter = 0, i, entries = 0;
  635.     char s[BUF_SIZE];
  636.     info.ID = p;
  637.    
  638.     for(;;)
  639.     {
  640.    
  641.         msg = OSMboxAccept(TaskMBox[p - 6]);
  642.  
  643.         if(msg != (void*)0)
  644.         {
  645.             n = *msg;
  646.             err = OSMemPut(MemoryPtr,(void*)msg); // zwolnienie pamięci zadeklarowanej w TaskSendAll
  647.         }
  648.         else
  649.             n = previous;
  650.  
  651.         counter = 0;
  652.  
  653.         for(i = 0; i< n; ++i)
  654.         {
  655.             counter++;
  656.         }
  657.  
  658.         info.counter=entries;
  659.         sprintf(s, "%lu", entries);
  660.         strncpy(info.entries, s, BUF_SIZE);
  661.         sprintf(s, "%lu", n);
  662.         strncpy(info.load, s, BUF_SIZE);
  663.         err = OSQPost(CommMessage, (void*)&info);
  664.  
  665.         if(err == OS_Q_FULL)
  666.         {
  667.             PC_DispStr(0, 21, "mbox error <- full", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  668.         }
  669.    
  670.         //info.load = n;
  671.         entries++;
  672.         previous= n;
  673.         OSTimeDly(1);
  674.        
  675.    
  676.     }
  677. }
  678.  
  679.  
  680. /*
  681. *********************************************************************************************************
  682. *                                               UseSem
  683. *
  684. * Opis: Odczytanie wartosci petli obciazajacej ze zmiennej globalnej chronionej semaforem, a nastepnie wykonanie petli obciazajacej
  685. *********************************************************************************************************
  686. */
  687.  
  688. void Sem(void * data)
  689. {
  690.     //char s[20];
  691.     unsigned long int n;
  692.     INT8U p = *(INT8U*)data;
  693.     INT8U err;
  694.     unsigned long int i, counter = 0, entries = 0;
  695.     char s[BUF_SIZE];
  696.     TASKS_INFO info;
  697.     info.ID = p;
  698.     for(;;)
  699.     {
  700.         OSSemPend(Semafor, 0, &err);
  701.         n = globalN;
  702.         OSSemPost(Semafor);
  703.         counter = 0;
  704.  
  705.         for(i = 0; i<n; i++)
  706.         {
  707.             counter++;
  708.         }
  709.         info.counter = entries;
  710.         sprintf(s, "%lu", entries);
  711.         strncpy(info.entries, s, BUF_SIZE);
  712.         sprintf(s, "%lu", n);
  713.         strncpy(info.load, s, BUF_SIZE);
  714.         err = OSQPost(CommMessage, (void*)&info);
  715.  
  716.         if(err == OS_Q_FULL)
  717.         {
  718.             PC_DispStr(0, 21, "sem error", DISP_FGND_YELLOW + DISP_BGND_BLUE);
  719.         }
  720.     //  info.load = n;
  721.         entries++;
  722.         OSTimeDly(1);
  723.  
  724.    
  725.     }
  726. }
Advertisement
RAW Paste Data Copied
Advertisement