API tools faq
paste
Advertisement
milanmetal

[RSDMK] Poceli testeru

milanmetal
Mar 18th, 2018
156
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.24 KB | None | 0 0
raw download clone embed print report
  1. #include <REGX52.H> //biblioteka sa definicijama registara
  2.  
  3. #define F_CLK 18432000
  4. #define F_INT 1000
  5.  
  6. typedef unsigned char byte;
  7.  
  8. unsigned char xdata CRV_PREK    _at_ 0x8000;
  9. unsigned char xdata ZELENE      _at_ 0x8001;
  10. unsigned char xdata ZUTE        _at_ 0x8002;
  11. unsigned char xdata PLAVE       _at_ 0x8003;
  12.  
  13. unsigned long sys_time = 0;
  14.  
  15. byte slika_ispisa = 0x7f;    /* promenjiva koju funkcija ping pong manipulise.
  16.                                 pocetno stanje je skroz desna diodica.
  17.                               */
  18.   byte prek_smer;
  19.   byte prek_vreme;
  20.   byte koeficijent;     /* ovim cu skalirati trajanje od 0.5 sekunde
  21.                            da dobijem sve ostale --> 1, 2, 4 sekunde.
  22.                          */
  23.   byte smer = 0; // 1 - levo, 0 - desno
  24.  
  25.   byte nivo = 1;
  26.  
  27.  
  28.  
  29.  
  30. void timer0_ISR() interrupt 1
  31. {
  32.     sys_time++;
  33.  
  34.  
  35.     TR0 = 0;            //tajmer 0 OFF
  36.     TH0 = 0xFA;         //ucitavanje pocetne vrednosti
  37.     TL0 = 0x00;
  38.     TR0 = 1;            //tajmer 0 ON
  39. }
  40.  
  41. unsigned long millis()
  42. {
  43.     unsigned long tmp;
  44.  
  45.     EA = 0;             //zabrana prekida
  46.     tmp = sys_time;     //ocitavanje vremena
  47.     EA = 1;             //dozvola prekida
  48.  
  49.     return tmp;
  50. }
  51.  
  52. void delay_ms(unsigned long d)
  53. {
  54.   unsigned long t0 = millis();
  55.   while(millis() - t0 < d);
  56. }
  57.  
  58.  
  59. byte prek_old = 0;
  60. void podesi_smer(byte *smer, byte prekidaci) {
  61.     switch(prekidaci){
  62.         case 0:
  63.              if(prek_old != prekidaci) {
  64.                  *smer = 1;
  65.                  prek_old = 0;
  66.              }
  67.         break;
  68.  
  69.         case 1:
  70.              if(prek_old != prekidaci) {
  71.                  *smer = 0;
  72.                  prek_old = 1;
  73.              }
  74.         break;
  75.     }
  76. }
  77.  
  78. void podesi_ispis(byte nivo, byte slika_ispisa){
  79.      switch(nivo){
  80.          case 1:
  81.           CRV_PREK  = slika_ispisa;
  82.           ZUTE      = 0xff;
  83.           ZELENE    = 0xff;
  84.           PLAVE     = 0xff;
  85.         break;
  86.         case 2:
  87.           CRV_PREK  = 0xff;
  88.           ZUTE      = slika_ispisa;
  89.           ZELENE    = 0xff;
  90.           PLAVE     = 0xff;
  91.         break;
  92.         case 3:
  93.           CRV_PREK  = 0xff;
  94.           ZUTE      = 0xff;
  95.           ZELENE    = slika_ispisa;
  96.           PLAVE     = 0xff;
  97.         break;
  98.         case 4:
  99.           CRV_PREK  = 0xff;
  100.           ZUTE      = 0xff;
  101.           ZELENE    = 0xff;
  102.           PLAVE     = slika_ispisa;
  103.         break;
  104.     }
  105. }
  106.  
  107.  
  108.  
  109. void podesi_trajanje(byte prekidaci, byte *koeficijent) {
  110.     switch(prekidaci) {
  111.       case 0x00:
  112.         // najmanji interval  je 50ms
  113.         *koeficijent = 1;
  114.       break;
  115.       case 0x01:
  116.       // onda u 100ms imam takva dva
  117.         *koeficijent = 2;
  118.       break;
  119.       case 0x02:
  120.       // u 200ms imam takva 4
  121.         *koeficijent = 4;
  122.       break;
  123.       case 0x03:
  124.       // u 500 mili sekunde imam 10 takvih
  125.         *koeficijent = 10;
  126.       break;
  127.     }
  128. }
  129.  
  130.  
  131.  
  132. void rotiraj(byte *nivo, byte *smer, byte koef_v, byte *slika_ispisa){
  133.     switch(*smer) {
  134.         case 0:
  135.             *slika_ispisa = *slika_ispisa >> 1;
  136.             *slika_ispisa |= 0x80;
  137.             //*slika_ispisa = ~(*slika_ispisa);
  138.             if(*slika_ispisa == 0xFF) {
  139.                 //*nivo++;
  140.                 if((*nivo) < 5) {
  141.                     (*nivo)++;
  142.                     *slika_ispisa = 0x7f;
  143.                 } else {
  144.                     *smer = 1;
  145.                     *slika_ispisa = 0x7f;  
  146.                 }
  147.            
  148.             }
  149.         break;
  150.  
  151.         case 1:
  152.             *slika_ispisa = *slika_ispisa << 1;
  153.             *slika_ispisa |= 0x01;
  154.             if(*slika_ispisa == 0xff) {
  155.                 if((*nivo) > 0) {
  156.                     (*nivo)--;
  157.                     *slika_ispisa = 0xfe;
  158.                 } else {
  159.                     *smer = 0;
  160.                     *slika_ispisa = 0xfe;  
  161.                 }
  162.             }
  163.         break;
  164.     }
  165.  
  166.     delay_ms(koef_v * 50);
  167. }
  168.  
  169. void main()
  170. {
  171.   //inicijalizacija tajmera 0:
  172.     TMOD = 0x01;            //tajmer 2 -> 16-bitni mod
  173.     ET0 = 1;                //dozvola prekida tajmera 0
  174.     TR0 = 1;                //tajmer 0 ON
  175.  
  176.     EA = 1;                 //dozvola prekida
  177.  
  178.     while(1){
  179.        
  180.         prek_smer   = (~CRV_PREK & 0x80) >> 7;
  181.         // ovde je maska 0000 0011 pa ne moram nista da shiftujem
  182.         prek_vreme = ~CRV_PREK & 0x03;
  183.    
  184.         //CRV_PREK = 0xAA;
  185.         podesi_trajanje(prek_vreme, &koeficijent);
  186.    
  187.         podesi_smer(&smer, prek_smer);
  188.  
  189.         rotiraj(&nivo, &smer, koeficijent, &slika_ispisa);
  190.  
  191.         podesi_ispis(nivo, slika_ispisa);  
  192.     }
  193. }
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207.  
  208.  
  209. #include <REGX52.H> //biblioteka sa definicijama registara
  210.  
  211. #define F_CLK 18432000
  212. #define F_INT 1000
  213.  
  214. typedef unsigned char byte;
  215.  
  216. unsigned char xdata CRV_PREK    _at_ 0x8000;
  217. unsigned char xdata ZELENE      _at_ 0x8001;
  218. unsigned char xdata ZUTE        _at_ 0x8002;
  219. unsigned char xdata PLAVE       _at_ 0x8003;
  220.  
  221. unsigned long sys_time = 0;
  222.  
  223. byte slika_ispisa = 0x7f;    /* promenjiva koju funkcija ping pong manipulise.
  224.                                 pocetno stanje je skroz desna diodica.
  225.                               */
  226.   byte prek_smer;
  227.   byte prek_vreme;
  228.   byte koeficijent;     /* ovim cu skalirati trajanje od 0.5 sekunde
  229.                            da dobijem sve ostale --> 1, 2, 4 sekunde.
  230.                          */
  231.   byte smer = 0; // 1 - levo, 0 - desno
  232.  
  233.   byte nivo = 1;
  234.  
  235.  
  236.  
  237.  
  238. void timer0_ISR() interrupt 1
  239. {
  240.     sys_time++;
  241.  
  242.  
  243.     TR0 = 0;            //tajmer 0 OFF
  244.     TH0 = 0xFA;         //ucitavanje pocetne vrednosti
  245.     TL0 = 0x00;
  246.     TR0 = 1;            //tajmer 0 ON
  247. }
  248.  
  249. unsigned long millis()
  250. {
  251.     unsigned long tmp;
  252.  
  253.     EA = 0;             //zabrana prekida
  254.     tmp = sys_time;     //ocitavanje vremena
  255.     EA = 1;             //dozvola prekida
  256.  
  257.     return tmp;
  258. }
  259.  
  260. void delay_ms(unsigned long d)
  261. {
  262.   unsigned long t0 = millis();
  263.   while(millis() - t0 < d);
  264. }
  265.  
  266.  
  267. byte prek_old = 0;
  268. void podesi_smer(byte *smer, byte prekidaci) {
  269.     switch(prekidaci){
  270.         case 0:
  271.              if(prek_old != prekidaci) {
  272.                  *smer = 1;
  273.                  prek_old = 0;
  274.              }
  275.         break;
  276.  
  277.         case 1:
  278.              if(prek_old != prekidaci) {
  279.                  *smer = 0;
  280.                  prek_old = 1;
  281.              }
  282.         break;
  283.     }
  284. }
  285.  
  286. void podesi_ispis(byte nivo, byte slika_ispisa){
  287.      switch(nivo){
  288.          case 1:
  289.           CRV_PREK  = slika_ispisa;
  290.           ZUTE      = 0xff;
  291.           ZELENE    = 0xff;
  292.           PLAVE     = 0xff;
  293.         break;
  294.         case 2:
  295.           CRV_PREK  = 0xff;
  296.           ZUTE      = slika_ispisa;
  297.           ZELENE    = 0xff;
  298.           PLAVE     = 0xff;
  299.         break;
  300.         case 3:
  301.           CRV_PREK  = 0xff;
  302.           ZUTE      = 0xff;
  303.           ZELENE    = slika_ispisa;
  304.           PLAVE     = 0xff;
  305.         break;
  306.         case 4:
  307.           CRV_PREK  = 0xff;
  308.           ZUTE      = 0xff;
  309.           ZELENE    = 0xff;
  310.           PLAVE     = slika_ispisa;
  311.         break;
  312.     }
  313. }
  314.  
  315.  
  316.  
  317. void podesi_trajanje(byte prekidaci, byte *koeficijent) {
  318.     switch(prekidaci) {
  319.       case 0x00:
  320.         // najmanji interval  je 50ms
  321.         *koeficijent = 1;
  322.       break;
  323.       case 0x01:
  324.       // onda u 100ms imam takva dva
  325.         *koeficijent = 2;
  326.       break;
  327.       case 0x02:
  328.       // u 200ms imam takva 4
  329.         *koeficijent = 4;
  330.       break;
  331.       case 0x03:
  332.       // u 500 mili sekunde imam 10 takvih
  333.         *koeficijent = 10;
  334.       break;
  335.     }
  336. }
  337.  
  338.  
  339.  
  340. void rotiraj(byte *nivo, byte *smer, byte koef_v, byte *slika_ispisa){
  341.     switch(*smer) {
  342.         case 0:
  343.            
  344.             //*slika_ispisa = ~(*slika_ispisa);
  345.             //if(*slika_ispisa == 0xFF) {
  346.                 //*nivo++;
  347.                 if((*nivo) == 1) {
  348.                     *slika_ispisa = *slika_ispisa >> 1;
  349.                     *slika_ispisa |= 0x80;
  350.                     if((*slika_ispisa) == 0xff){
  351.                         (*nivo)++;
  352.                         *slika_ispisa = 0xfe;
  353.                     }
  354.                 } else if((*nivo) == 2) {
  355.                     (*nivo)++;
  356.                     *slika_ispisa = 0xfe;
  357.                 } else if((*nivo) == 3) {
  358.                     (*nivo)++;
  359.                     *slika_ispisa = 0xfe;
  360.                 } else if((*nivo) == 4) {
  361.                     *slika_ispisa = *slika_ispisa << 1;
  362.                     *slika_ispisa |= 0x01;
  363.                     if((*slika_ispisa) == 0x7f) {
  364.                         *smer = 1;
  365.                     }
  366.                 }
  367.            
  368.             //}
  369.         break;
  370.  
  371.         case 1:
  372.            
  373.                 if((*nivo) == 3) {
  374.                     (*nivo)--;
  375.                     *slika_ispisa = 0x7f;
  376.                 } else if((*nivo) == 2) {
  377.                     (*nivo)--;
  378.                     *slika_ispisa = 0x7f;
  379.                 } else if((*nivo) == 4) {
  380.                    
  381.                     /**slika_ispisa = *slika_ispisa << 1;
  382.                     *slika_ispisa |= 0x01;*/
  383.                     //if((*slika_ispisa) == 0x7f) {
  384.                         //*smer = 0;
  385.                         (*nivo)--;
  386.                     //}
  387.                 } else if((*nivo)==1){
  388.                     *smer = 0;
  389.                 }
  390.         break;
  391.     }
  392.  
  393.     delay_ms(koef_v * 50);
  394. }
  395.  
  396. void main()
  397. {
  398.   //inicijalizacija tajmera 0:
  399.     TMOD = 0x01;            //tajmer 2 -> 16-bitni mod
  400.     ET0 = 1;                //dozvola prekida tajmera 0
  401.     TR0 = 1;                //tajmer 0 ON
  402.  
  403.     EA = 1;                 //dozvola prekida
  404.  
  405.     while(1){
  406.        
  407.         prek_smer   = (~CRV_PREK & 0x80) >> 7;
  408.         // ovde je maska 0000 0011 pa ne moram nista da shiftujem
  409.         prek_vreme = ~CRV_PREK & 0x03;
  410.    
  411.         //CRV_PREK = 0xAA;
  412.         podesi_trajanje(prek_vreme, &koeficijent);
  413.    
  414.         podesi_smer(&smer, prek_smer);
  415.  
  416.         rotiraj(&nivo, &smer, koeficijent, &slika_ispisa);
  417.  
  418.         podesi_ispis(nivo, slika_ispisa);  
  419.     }
  420. }
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!