API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 20th, 2018
141
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 21.59 KB | None | 0 0
raw download clone embed print report
  1. #include <stddef.h>
  2. #include "sys/alt_alarm.h"
  3. #include "alt_types.h"
  4. #include <io.h>
  5. #include "sys/alt_timestamp.h"
  6. #include "altera_avalon_pio_regs.h"
  7. #include "sys/alt_irq.h"
  8. #include <unistd.h>
  9. #include <stdio.h>
  10. #include <system.h>
  11. #include "includes.h"
  12. #define  SW0 0x00000001
  13. #define  SW1 0x00000002
  14. #define  SW2 0x00000004
  15. #define  SW3 0x00000008
  16. #define  SW4 0x00000010
  17. #define  SW5 0x00000020
  18. #define  SW6 0x00000040
  19. #define  SW7 0x00000080
  20. #define  SW8 0x00000100
  21. #define  SW9 0x00000200
  22. #define  LED0 0x00000001
  23. #define  LED1 0x00000002
  24. #define  LED2 0x00000004
  25. #define  LED3 0x00000008
  26. #define  LED4 0x00000010
  27. #define  LED5 0x00000020
  28. #define  LED6 0x00000040
  29. #define  LED7 0x00000080
  30. #define  LED8 0x00000100
  31. #define  LED9 0x00000200
  32.  
  33. //      hex
  34. #define  SEGA 0x00001
  35. #define  SEGB 0x00002
  36. #define  SEGC 0x00004
  37. #define  SEGD 0x00008
  38. #define  SEGE 0x00010
  39. #define  SEGF 0x00020
  40. #define  SEGG 0x00040
  41.  
  42. //     hex - numbers
  43. #define ZERO SEGA | SEGB | SEGC | SEGD |SEGE | SEGF
  44. #define ONE  SEGB | SEGC
  45. #define TWO  SEGA | SEGB | SEGG | SEGE | SEGD
  46. #define THREE SEGA | SEGB | SEGC | SEGD | SEGG
  47. #define FOUR SEGB | SEGC | SEGG | SEGF
  48. #define FIVE SEGA | SEGC | SEGD | SEGF | SEGG
  49. #define SIX SEGA | SEGC | SEGD | SEGE | SEGF | SEGG
  50. #define SEVEN  SEGA | SEGB | SEGC
  51. #define EIGHT SEGA | SEGB | SEGC | SEGD | SEGE | SEGF | SEGG
  52. #define NINE SEGA | SEGB | SEGC | SEGF | SEGG
  53. #define HEXE SEGA | SEGD | SEGE | SEGF | SEGG
  54. #define HEXL SEGD | SEGE | SEGF
  55. #define HEXP SEGE | SEGF | SEGG | SEGA | SEGB
  56.  
  57. #define HEX 0x81040
  58. #define LED 0x81080
  59. #define SW 0x81070
  60.  
  61.  
  62. typedef enum POZIOM_TEMP{
  63. POZIOM_0 = 0,
  64. POZIOM_1 = 2,
  65. POZIOM_2 = 4,
  66. POZIOM_3 = 8,
  67. POZIOM_4 = 16,
  68. POZIOM_5 = 32,
  69. POZIOM_6 = 64,
  70. POZIOM_7 = 128,
  71. POZIOM_8 = 256,
  72. POZIOM_9 = 512,
  73. POZIOM_10 = 1024,
  74.  
  75. }TEMP;
  76.  
  77. /* Definition of Task Stacks */
  78. #define TASK_STACKSIZE 2048
  79. OS_STK task1_stk[TASK_STACKSIZE];
  80. OS_STK task2_stk[TASK_STACKSIZE];
  81. OS_STK task3_stk[TASK_STACKSIZE];
  82. OS_STK task4_stk[TASK_STACKSIZE];
  83. OS_STK task5_stk[TASK_STACKSIZE];
  84. OS_STK task6_stk[TASK_STACKSIZE];
  85.  
  86.  
  87. OS_EVENT *SWBox1;
  88.  
  89.  
  90. /* Definition of Task Priorities */
  91.  
  92. #define TASK1_PRIORITY 1
  93. #define TASK2_PRIORITY 2
  94. #define TASK3_PRIORITY 3
  95. #define TASK4_PRIORITY 4
  96. #define TASK5_PRIORITY 5
  97. #define TASK6_PRIORITY 6
  98.  
  99.  
  100.  
  101. void ustawDiodeR(unsigned int dioda, int stan){
  102.     if(stan){
  103.         //zapal
  104.         IOWR(LED, 0, IORD(LED, 0) | dioda );
  105.     }else{
  106.         //zgaś
  107.         IOWR(LED, 0, IORD(LED, 0) & ~dioda );
  108.     }
  109. }
  110.  
  111. void zapalDiodeR(unsigned int dioda){
  112.     IOWR(LED, 0, IORD(LED, 0) | dioda );
  113. }
  114.  
  115. void zgasDiodeR(unsigned int dioda){
  116.     IOWR(LED, 0, IORD(LED, 0) & ~dioda );
  117. }
  118.  
  119. int stanDiody(unsigned int dioda){
  120.     if(IORD(LED, 0) & dioda)
  121.         return 1;
  122.     else
  123.         return 0;
  124. }
  125.  
  126. void przelaczNaDiode(unsigned int dioda){
  127.     IOWR(LED, 0, dioda);
  128. }
  129.  
  130. unsigned int getSwMask(int i){
  131.     switch(i){
  132.     case 0:
  133.         return SW0;
  134.     case 1:
  135.         return SW1;
  136.     case 2:
  137.         return SW2;
  138.     case 3:
  139.         return SW3;
  140.     case 4:
  141.         return SW4;
  142.     case 5:
  143.         return SW5;
  144.     case 6:
  145.         return SW6;
  146.     case 7:
  147.         return SW7;
  148.     case 8:
  149.         return SW8;
  150.     case 9:
  151.         return SW9;
  152.     }
  153. }
  154.  
  155. unsigned int getLedMask(int i){
  156.     switch(i){
  157.     case 0:
  158.         return LED0;
  159.     case 1:
  160.         return LED1;
  161.     case 2:
  162.         return LED2;
  163.     case 3:
  164.         return LED3;
  165.     case 4:
  166.         return LED4;
  167.     case 5:
  168.         return LED5;
  169.     case 6:
  170.         return LED6;
  171.     case 7:
  172.         return LED7;
  173.     case 8:
  174.         return LED8;
  175.     case 9:
  176.         return LED9;
  177.     }
  178. }
  179.  
  180. unsigned char getHexMask(int i){
  181.     switch(i){
  182.     case 0:
  183.         return ZERO;
  184.     case 1:
  185.         return ONE;
  186.     case 2:
  187.         return TWO;
  188.     case 3:
  189.         return THREE;
  190.     case 4:
  191.         return FOUR;
  192.     case 5:
  193.         return FIVE;
  194.     case 6:
  195.         return SIX;
  196.     case 7:
  197.         return SEVEN;
  198.     case 8:
  199.         return EIGHT;
  200.     case 9:
  201.         return NINE;
  202.     }
  203. }
  204.  
  205. unsigned int setHex(int hex, unsigned char znak){
  206.     unsigned int znak2 = znak;
  207.     IOWR(HEX, hex, znak2 );
  208. }
  209.  
  210. int glosnosc = 0;
  211. int state = 0;
  212. int substate = 0; //status kanalu (lewy/prawy/zaden)
  213. //unsigned int swstate = 0;
  214. unsigned int nieaktywneSw = 0; //maska sw wywołujących alarm
  215. //używaneSW = SW0 | SW1 | SW2 | SW3 | SW4 | SW8 | SW9;
  216. alt_u32 lastTimeLedOn[10]; //chwila czasowa kiedy ostatni raz dana dioda była aktywna
  217. alt_u32 lastTimeLedOff[10]; //kiedy ostatni raz byla nieaktywna
  218. int ledOn[10];
  219. float timeToOn[10];
  220. float timeToOff[10];
  221. int czekaNaZapalenie[10];
  222. int flag1 = 1;
  223. int flag2 = 1;
  224.  
  225. alt_u32 zaswiec(int context)
  226. {
  227.   /* This function is called once per second */
  228.     printf("zaswiec\n");
  229.     zapalDiodeR( getLedMask( context) );
  230.     flag1 = -1;
  231.     return 0;
  232. }
  233.  
  234. alt_u32 zgas(int context)
  235. {
  236.   /* This function is called once per second */
  237.     //zgasDiodeR( getLedMask( context) );
  238.     flag2 = -1;
  239.     return 0;
  240. }
  241.  
  242. void setLedAlarm(unsigned int dioda, int stan, float time){
  243.     static alt_alarm alarm1;
  244.     static alt_alarm alarm2;
  245.  
  246.     if(flag1==-1){
  247.         alt_alarm_stop (&alarm1);
  248.         flag1 = 1;
  249.     }
  250.     if(flag2==-1){
  251.         alt_alarm_stop (&alarm2);
  252.         flag2 = 1;
  253.     }
  254.  
  255.     if(stan && flag1==1){
  256.         flag1 = 0;
  257.         alt_alarm_start(&alarm1,alt_ticks_per_second()*time,zaswiec, dioda);
  258.     }else if(flag2==1){
  259.         flag2 = 0;
  260.         alt_alarm_start(&alarm2,alt_ticks_per_second()*time,zgas, dioda);
  261.     }
  262. }
  263.  
  264. void setLed(unsigned int dioda, int stan, float time){
  265.     ledOn[dioda] = stan;
  266.     if(stan){
  267.         setLedAlarm(dioda, stan, time);
  268.         //timeToOn[dioda] = time;
  269.         //czekaNaZapalenie[dioda] = 1;
  270.     }else{
  271.         timeToOff[dioda] = time;
  272.     }
  273. }
  274.  
  275. void setLedOSTime(unsigned int dioda, int stan, float time){
  276.     OSTimeDlyHMSM(0, 0, time, 0);
  277.     unsigned int mask = getLedMask(dioda);
  278.     if(stan)
  279.         zapalDiodeR(mask);
  280.     else
  281.         zgasDiodeR(mask);
  282. }
  283.  
  284. void aktualizujLedy(){ //timeout
  285.     int i = 0;
  286.     for(i = 0; i<10; i++){
  287.         if(ledOn[i]) lastTimeLedOn[i] = alt_nticks(); else lastTimeLedOff[i] = alt_nticks();
  288.  
  289.         unsigned int mask = getLedMask(i);
  290.  
  291.         //if(!czekaNaZapalenie[i]) continue;
  292.  
  293.  
  294.         if(ledOn[i] && !stanDiody(mask) && alt_nticks()-lastTimeLedOff[i] >= timeToOn[i]*alt_ticks_per_second()){
  295.             //zapalDiodeR(mask);
  296.             czekaNaZapalenie[i] = 0;
  297.         }
  298.         else if(!ledOn[i] && stanDiody(mask) && alt_nticks()-lastTimeLedOn[i] >= timeToOff[i]*alt_ticks_per_second())
  299.             zgasDiodeR(mask);
  300.  
  301.     }
  302. }
  303.  
  304. void zgasWszystkieDiody(float time){
  305.     //IOWR(LED, 0, 0);
  306.     int i = 0;
  307.     for(i = 0; i<10; i++){
  308.         setLed(i, 0, time);
  309.     }
  310. }
  311.  
  312. void displayFloat(float f){
  313.     int i1 = (int) f;
  314.     int i2 = (f-i1)*10;
  315.  
  316.     setHex(5, getHexMask(i1));
  317.     setHex(4, getHexMask(i2));
  318. }
  319.  
  320. void wait(alt_u32 start, float sec){
  321.     while(alt_nticks()-start < sec*alt_ticks_per_second());
  322.     return;
  323. }
  324.  
  325. void przejdzDoStanu(int stan){
  326.     //wyjscie z aktualnego stanu
  327.     switch(state){
  328.     case 0: //idle
  329.         break;
  330.     case 1: //przedni
  331.         setLed(0, 0, 2);
  332.         break;
  333.     case 2: //tylne
  334.         setLed(1, 0, 2);
  335.         break;
  336.     case 3: //centralny
  337.         setLed(2, 0, 2);
  338.         break;
  339.     case 4: //niskotonowy
  340.         setLed(3, 0, 2);
  341.         break;
  342.     case 5: //wszystko
  343.         setLed(4, 0, 2);
  344.         break;
  345.     case 6: //alarm
  346.         OSTimeDlyHMSM(0, 0, 2, 0);
  347.         setLed(9, 0, 2);
  348.         setHex(0, ZERO);
  349.         setHex(1, 0);
  350.         setHex(2, 0);
  351.         setHex(3, 0);
  352.         setHex(4, 0);
  353.         setHex(5, 0);
  354.         break;
  355.     }
  356.  
  357.     //przejscie do stanu docelowego
  358.     switch(stan){
  359.     case 0: //idle
  360.         state = 0;
  361.         nieaktywneSw = SW9 | SW8;
  362.         //zgasWszystkieDiody();
  363.         setHex(0, ZERO);
  364.         setHex(1, 0);
  365.         setHex(2, 0);
  366.         setHex(3, 0);
  367.         setHex(4, 0);
  368.         setHex(5, 0);
  369.         printf("Przelaczono na tryb 0 - idle!\n");
  370.         break;
  371.     case 1: //przedni
  372.         state = 1;
  373.         setLed(0, 1, 1);
  374.         nieaktywneSw = SW3 | SW4;
  375.         setHex(0, ONE);
  376.         setHex(1, SEGG);
  377.         setHex(2, getHexMask(glosnosc));
  378.         printf("Przelaczono na tryb 1 - przednie!\n");
  379.         break;
  380.     case 2: //tylne
  381.         state = 2;
  382.         setLed(1, 1, 1);
  383.         nieaktywneSw = SW0 | SW4;
  384.         setHex(0, TWO);
  385.         setHex(1, SEGG);
  386.         setHex(2, getHexMask(glosnosc));
  387.         printf("Przelaczono na tryb 2 - tylne!\n");
  388.         break;
  389.     case 3: //centralny
  390.         state = 3;
  391.         setLed(2, 1, 1);
  392.         nieaktywneSw = SW0 | SW1 | SW3 | SW4;
  393.         setHex(0, THREE);
  394.         setHex(2, getHexMask(glosnosc));
  395.         printf("Przelaczono na tryb 3 - centralny!\n");
  396.         break;
  397.     case 4: //niskotonowy
  398.         state = 4;
  399.         setLed(3, 1, 1);
  400.         nieaktywneSw = SW0 | SW1 | SW2 | SW4;
  401.         setHex(0, FOUR);
  402.         setHex(2, getHexMask(glosnosc));
  403.         printf("Przelaczono na tryb 4 - niskotonowy!\n");
  404.         break;
  405.     case 5: //wszystko
  406.         state = 5;
  407.         setLed(4, 1, 1);
  408.         nieaktywneSw = SW0 | SW1 | SW2 | SW3;
  409.         setHex(0, FIVE);
  410.         setHex(2, getHexMask(glosnosc));
  411.         printf("Przelaczono na tryb 5 - wszystko!\n");
  412.         break;
  413.     case 6: //alarm
  414.         OSTimeDlyHMSM(0, 0, 2, 0);
  415.         state = 6;
  416.         zgasWszystkieDiody(2);
  417.         setLed(9, 1, 3);
  418.         //nieaktywneSw = SW0 | SW1 | SW2 | SW3 | SW4 | SW8 | SW9;
  419.         printf("Alarm!\n");
  420.         setHex(0, HEXE);
  421.         setHex(1, HEXE);
  422.         setHex(2, HEXE);
  423.         setHex(3, HEXE);
  424.         setHex(4, HEXE);
  425.         setHex(5, HEXE);
  426.         break;
  427.     }
  428. }
  429.  
  430. void kanal(int sw, unsigned int swstate){
  431.     switch(substate){
  432.     case 0: //żaden
  433.         if(swstate & getSwMask(sw)){
  434.             substate = 1; //lewy
  435.             setLed(sw, 1, 1);
  436.             setHex(1, HEXL);
  437.             printf("Wybrano kanal lewy!\n");
  438.         }else if(swstate & getSwMask(sw+1)){
  439.             substate = 2; //prawy
  440.             setHex(1, HEXP);
  441.             setLed(sw+1, 1, 1);
  442.             printf("Wybrano kanal prawy!\n");
  443.         }
  444.         break;
  445.     case 1: //kanal lewy
  446.         if( !(swstate & getSwMask(sw)) ){
  447.             substate = 0;
  448.             setLed(sw, 0, 2);
  449.             setHex(1, SEGG);
  450.             printf("Wylaczono tryb kanalu lewego!\n");
  451.         }else if(swstate & getSwMask(sw+1)){
  452.             nieaktywneSw = nieaktywneSw | getSwMask(sw+1);
  453.             przejdzDoStanu(6); //alarm
  454.         }
  455.         break;
  456.     case 2: //kanal prawy
  457.         if( !(swstate & getSwMask(sw+1)) ){
  458.             substate = 0;
  459.             setLed(sw+1, 0, 2);
  460.             setHex(1, SEGG);
  461.             printf("Wylaczono tryb kanalu prawego!\n");
  462.         }else if(swstate & getSwMask(sw)){
  463.             nieaktywneSw = nieaktywneSw | getSwMask(sw);
  464.             przejdzDoStanu(6); //alarm
  465.         }
  466.         break;
  467.     }
  468. }
  469.  
  470. int sw9 = 0;
  471. int sw8 = 0;
  472. void glosnik(unsigned int swstate){
  473.     switch(sw9){
  474.     case 0:
  475.         if(swstate & SW9){
  476.             sw9 = 1;
  477.             setLed(9, 1, 1);
  478.             printf("Przelaczono na dodawanie!\n");
  479.         }
  480.         break;
  481.     case 1:
  482.         if( !(swstate & SW9) ){
  483.             sw9 = 0;
  484.             setLed(9, 0, 2);
  485.             printf("Przelaczono na odejmowanie!\n");
  486.         }
  487.         break;
  488.     }
  489.  
  490.     switch(sw8){
  491.     case 0:
  492.         if(swstate & SW8){
  493.             sw8 = 1;
  494.  
  495.             if(sw9)
  496.                 glosnosc += 1;
  497.             else
  498.                 glosnosc -= 1;
  499.  
  500.             printf("Nowa glosnosc: %d \n", glosnosc);
  501.  
  502.             if(glosnosc>=10 || glosnosc<0){
  503.                 nieaktywneSw = nieaktywneSw | SW8;
  504.                 przejdzDoStanu(6); //alarm
  505.             }else{
  506.                 setHex(2, getHexMask(glosnosc));
  507.                 setLed(8, 1, 1);
  508.             }
  509.         }
  510.         break;
  511.     case 1:
  512.         if( !(swstate & SW8) ){
  513.             sw8 = 0;
  514.             setLed(8, 0, 2);
  515.         }
  516.         break;
  517.     }
  518. }
  519.  
  520. /*void maszynaStanu(){
  521.     switch(state){
  522.     case 0: //idle
  523.         if(swstate & SW0){
  524.             przejdzDoStanu(1); //przedni
  525.         }else if(swstate & SW1){
  526.             przejdzDoStanu(2); //tylni
  527.         }else if(swstate & SW2){
  528.             przejdzDoStanu(3); //centralny
  529.         }else if(swstate & SW3){
  530.             przejdzDoStanu(4); //niskotonowy
  531.         }else if(swstate & SW4){
  532.             przejdzDoStanu(5); //wszystko
  533.         }else if(swstate & nieaktywneSw){
  534.             przejdzDoStanu(6); //alarm
  535.         }
  536.         break;
  537.     case 1: //przedni
  538.         if(!(swstate & SW0)){
  539.             przejdzDoStanu(0); //idle
  540.         }else if(swstate & nieaktywneSw){
  541.             przejdzDoStanu(6); //alarm
  542.         }else{
  543.             kanal(1);
  544.             glosnik();
  545.         }
  546.         break;
  547.     case 2: //tylne
  548.         if(!(swstate & SW1)){
  549.             przejdzDoStanu(0); //idle
  550.         }else if(swstate & nieaktywneSw){
  551.             przejdzDoStanu(6); //alarm
  552.         }else{
  553.             kanal(2);
  554.             glosnik();
  555.         }
  556.         break;
  557.     case 3: //centralny
  558.         if(!(swstate & SW2)){
  559.             przejdzDoStanu(0); //idle
  560.         }else if(swstate & nieaktywneSw){
  561.             przejdzDoStanu(6); //alarm
  562.         }else{
  563.             glosnik();
  564.         }
  565.         break;
  566.     case 4: //niskotonowy
  567.         if(!(swstate & SW3)){
  568.             przejdzDoStanu(0); //idle
  569.         }else if(swstate & nieaktywneSw){
  570.             przejdzDoStanu(6); //alarm
  571.         }else{
  572.             glosnik();
  573.         }
  574.         break;
  575.     case 5: //wszystko
  576.         if(!(swstate & SW4)){
  577.             przejdzDoStanu(0); //idle
  578.         }else if(swstate & nieaktywneSw){
  579.             przejdzDoStanu(6); //alarm
  580.         }else{
  581.             glosnik();
  582.         }
  583.         break;
  584.     case 6: //alarm
  585.         if( !(swstate & nieaktywneSw) ){
  586.             sw8 = 0;
  587.             sw9 = 0;
  588.             substate = 0;
  589.             glosnosc = 0;
  590.  
  591.             //wyjście z alarmu:
  592.             if(swstate & SW0){
  593.                 przejdzDoStanu(1); //przedni
  594.             }else if(swstate & SW1){
  595.                 przejdzDoStanu(2); //tylni
  596.             }else if(swstate & SW2){
  597.                 przejdzDoStanu(3); //centralny
  598.             }else if(swstate & SW3){
  599.                 przejdzDoStanu(4); //niskotonowy
  600.             }else if(swstate & SW4){
  601.                 przejdzDoStanu(5); //wszystko
  602.             }else{
  603.                 przejdzDoStanu(0); //idle
  604.             }
  605.         }
  606.         break;
  607.     }
  608. }*/
  609.  
  610. void task1(void* pdata)
  611. {
  612.     while(1){
  613.         aktualizujLedy();
  614.         printf("Hello from task1\n");
  615.         unsigned int swstate;
  616.         swstate = IORD(SW, 0);
  617.  
  618.         if(state==0){
  619.             if(swstate & SW0){
  620.                 przejdzDoStanu(1); //przedni
  621.             }else if(swstate & SW1){
  622.                 przejdzDoStanu(2); //tylni
  623.             }else if(swstate & SW2){
  624.                 przejdzDoStanu(3); //centralny
  625.             }else if(swstate & SW3){
  626.                 przejdzDoStanu(4); //niskotonowy
  627.             }else if(swstate & SW4){
  628.                 przejdzDoStanu(5); //wszystko
  629.             }else if(swstate & nieaktywneSw){
  630.                 przejdzDoStanu(6); //alarm
  631.             }
  632.         }
  633.  
  634.         printf("Slider = %d\n", swstate);
  635.         OSMboxPostOpt(SWBox1, &swstate, OS_POST_OPT_BROADCAST);
  636.  
  637.         OSTimeDlyHMSM(0, 0, 0, 120);
  638.     }
  639. }
  640.  
  641. void task2(void* pdata)
  642. {
  643.     while(1){
  644.         OSTimeDlyHMSM(0, 0, 0, 20);
  645.  
  646.         INT8U err;
  647.         printf("Hello from task2\n");
  648.         unsigned int *swstatep;
  649.         unsigned int swstate;
  650.  
  651.         swstatep = OSMboxPend(SWBox1, 0, &err);
  652.         swstate = *swstatep;
  653.  
  654.         if(state==1){
  655.             if(!(swstate & SW0)){
  656.                 przejdzDoStanu(0); //idle
  657.             }else if(swstate & nieaktywneSw){
  658.                 przejdzDoStanu(6); //alarm
  659.             }else{
  660.                 kanal(1, swstate);
  661.                 glosnik(swstate);
  662.             }
  663.         }
  664.  
  665.         OSMboxPostOpt(SWBox1, &swstate, OS_POST_OPT_BROADCAST);
  666.  
  667.         OSTimeDlyHMSM(0, 0, 0, 100);
  668.     }
  669. }
  670.  
  671. void task3(void* pdata)
  672. {
  673.     while(1){
  674.         OSTimeDlyHMSM(0, 0, 0, 40);
  675.  
  676.         INT8U err;
  677.         printf("Hello from task3\n");
  678.         unsigned int *swstatep;
  679.         unsigned int swstate;
  680.  
  681.         swstatep = OSMboxPend(SWBox1, 0, &err);
  682.         swstate = *swstatep;
  683.  
  684.         if(state==2){
  685.             if(!(swstate & SW1)){
  686.                 przejdzDoStanu(0); //idle
  687.             }else if(swstate & nieaktywneSw){
  688.                 przejdzDoStanu(6); //alarm
  689.             }else{
  690.                 kanal(2, swstate);
  691.                 glosnik(swstate);
  692.             }
  693.         }
  694.  
  695.         OSMboxPostOpt(SWBox1, &swstate, OS_POST_OPT_BROADCAST);
  696.  
  697.         OSTimeDlyHMSM(0, 0, 0, 120);
  698.     }
  699. }
  700.  
  701. void task4(void* pdata)
  702. {
  703.     while(1){
  704.         OSTimeDlyHMSM(0, 0, 0, 60);
  705.  
  706.         INT8U err;
  707.         printf("Hello from task4\n");
  708.         unsigned int *swstatep;
  709.         unsigned int swstate;
  710.  
  711.         swstatep = OSMboxPend(SWBox1, 0, &err);
  712.         swstate = *swstatep;
  713.  
  714.         if(state==3){
  715.             if(!(swstate & SW2)){
  716.                 przejdzDoStanu(0); //idle
  717.             }else if(swstate & nieaktywneSw){
  718.                 przejdzDoStanu(6); //alarm
  719.             }else{
  720.                 glosnik(swstate);
  721.             }
  722.         }
  723.  
  724.         OSMboxPostOpt(SWBox1, &swstate, OS_POST_OPT_BROADCAST);
  725.  
  726.         OSTimeDlyHMSM(0, 0, 0, 120);
  727.     }
  728. }
  729.  
  730. void task5(void* pdata)
  731. {
  732.     while(1){
  733.         OSTimeDlyHMSM(0, 0, 0, 80);
  734.  
  735.         INT8U err;
  736.         printf("Hello from task5\n");
  737.         unsigned int *swstatep;
  738.         unsigned int swstate;
  739.  
  740.         swstatep = OSMboxPend(SWBox1, 0, &err);
  741.         swstate = *swstatep;
  742.  
  743.         if(state==4){
  744.             if(!(swstate & SW3)){
  745.                 przejdzDoStanu(0); //idle
  746.             }else if(swstate & nieaktywneSw){
  747.                 przejdzDoStanu(6); //alarm
  748.             }else{
  749.                 glosnik(swstate);
  750.             }
  751.         }
  752.  
  753.         OSMboxPostOpt(SWBox1, &swstate, OS_POST_OPT_BROADCAST);
  754.  
  755.         OSTimeDlyHMSM(0, 0, 0, 120);
  756.     }
  757. }
  758.  
  759. void task6(void* pdata)
  760. {
  761.     while(1){
  762.         OSTimeDlyHMSM(0, 0, 0, 100);
  763.  
  764.         INT8U err;
  765.         printf("Hello from task6\n");
  766.         unsigned int *swstatep;
  767.         unsigned int swstate;
  768.  
  769.         swstatep = OSMboxPend(SWBox1, 0, &err);
  770.         swstate = *swstatep;
  771.  
  772.         if(state==5){
  773.             if(!(swstate & SW4)){
  774.                 przejdzDoStanu(0); //idle
  775.             }else if(swstate & nieaktywneSw){
  776.                 przejdzDoStanu(6); //alarm
  777.             }else{
  778.                 glosnik(swstate);
  779.             }
  780.         }else if(state==6){
  781.             if( !(swstate & nieaktywneSw) ){
  782.                 sw8 = 0;
  783.                 sw9 = 0;
  784.                 substate = 0;
  785.                 glosnosc = 0;
  786.  
  787.                 //wyjście z alarmu:
  788.                 if(swstate & SW0){
  789.                     przejdzDoStanu(1); //przedni
  790.                 }else if(swstate & SW1){
  791.                     przejdzDoStanu(2); //tylni
  792.                 }else if(swstate & SW2){
  793.                     przejdzDoStanu(3); //centralny
  794.                 }else if(swstate & SW3){
  795.                     przejdzDoStanu(4); //niskotonowy
  796.                 }else if(swstate & SW4){
  797.                     przejdzDoStanu(5); //wszystko
  798.                 }else{
  799.                     przejdzDoStanu(0); //idle
  800.                 }
  801.             }
  802.         }
  803.  
  804.         OSTimeDlyHMSM(0, 0, 0, 120);
  805.     }
  806. }
  807.  
  808.  
  809. /* The main function creates two task and starts multi-tasking */
  810. int main(void)
  811. {
  812.     printf("Hello from Nios II!\n");
  813.     przejdzDoStanu(0);
  814.     aktualizujLedy();
  815.  
  816.  
  817. SWBox1 =OSMboxCreate((void*)0);
  818.  
  819.  
  820.   OSTaskCreateExt(task1,
  821.                   NULL,
  822.                   (void *)&task1_stk[TASK_STACKSIZE-1],
  823.                   TASK1_PRIORITY,
  824.                   TASK1_PRIORITY,
  825.                   task1_stk,
  826.                   TASK_STACKSIZE,
  827.                   NULL,
  828.                   0);
  829.  
  830.  
  831.   OSTaskCreateExt(task2,
  832.                   NULL,
  833.                   (void *)&task2_stk[TASK_STACKSIZE-1],
  834.                   TASK2_PRIORITY,
  835.                   TASK2_PRIORITY,
  836.                   task2_stk,
  837.                   TASK_STACKSIZE,
  838.                   NULL,
  839.                   0);
  840.  
  841.   OSTaskCreateExt(task3,
  842.                     NULL,
  843.                     (void *)&task3_stk[TASK_STACKSIZE-1],
  844.                     TASK3_PRIORITY,
  845.                     TASK3_PRIORITY,
  846.                     task3_stk,
  847.                     TASK_STACKSIZE,
  848.                     NULL,
  849.                     0);
  850.  
  851.   OSTaskCreateExt(task4,
  852.                     NULL,
  853.                     (void *)&task4_stk[TASK_STACKSIZE-1],
  854.                     TASK4_PRIORITY,
  855.                     TASK4_PRIORITY,
  856.                     task4_stk,
  857.                     TASK_STACKSIZE,
  858.                     NULL,
  859.                     0);
  860.  
  861.   OSTaskCreateExt(task5,
  862.                     NULL,
  863.                     (void *)&task5_stk[TASK_STACKSIZE-1],
  864.                     TASK5_PRIORITY,
  865.                     TASK5_PRIORITY,
  866.                     task5_stk,
  867.                     TASK_STACKSIZE,
  868.                     NULL,
  869.                     0);
  870.  
  871.   OSTaskCreateExt(task6,
  872.                       NULL,
  873.                       (void *)&task6_stk[TASK_STACKSIZE-1],
  874.                       TASK6_PRIORITY,
  875.                       TASK6_PRIORITY,
  876.                       task6_stk,
  877.                       TASK_STACKSIZE,
  878.                       NULL,
  879.                       0);
  880.  
  881.   OSStart();
  882.   return 0;
  883.  
  884.     }
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!