API tools faq
paste
Advertisement
Akihito759

uCos

Akihito759
Jan 11th, 2017
2,663
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C Intermediate Language 23.28 KB | None | 0 0
raw download clone embed print report
  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
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!