Bez tytułu

z k4be, 4 lata temu, napisane w C, wyświetlone 337 razy.
URL https://pastebin.k4be.pl/view/b4b0b0d0 Udostępnij
Pobierz wklejkę lub Pokaż surowy tekst
  1. #include <avr/io.h>
  2.  
  3. #define F_CPU        8000000
  4. #define CYCLES_PER_US ((F_CPU+500000)/1000000)
  5.  
  6.  
  7. void delay(unsigned int us)
  8. {
  9.     unsigned int delay_loops;
  10.     register unsigned int  i;
  11.     delay_loops = (us+3)/5*CYCLES_PER_US;
  12.     for (i=0; i < delay_loops; i++) {};
  13. }
  14. void delayms(unsigned int ms)
  15. {
  16.     unsigned int i;
  17.     for (i=0;i<ms;i++)
  18.        {
  19.        delay(999);
  20.        asm volatile (
  21.        "WDR"::);
  22.        }
  23. }
  24.  
  25. #define SEG_D 2
  26. #define SEG_KR 8
  27. #define SEG_P_D 4
  28. #define SEG_SR 32
  29. #define SEG_L_D 1
  30. #define SEG_L_G 128
  31. #define SEG_P_G 16
  32. #define SEG_G 64
  33.  
  34. unsigned int l[3];
  35.  
  36. unsigned int km=0,impkm=0,kll=0;
  37. unsigned char dlim=0,blok=0,t3=0;
  38.  
  39.  
  40. unsigned char cyfra(unsigned char wej){
  41.         unsigned char wyj=0;
  42.         switch(wej){
  43.                 case 0: wyj = SEG_G + SEG_L_G + SEG_P_G + SEG_L_D + SEG_P_D + SEG_D; break;
  44.                 case 1: wyj = SEG_P_G + SEG_P_D; break;
  45.                 case 2: wyj = SEG_G + SEG_P_G + SEG_SR + SEG_L_D + SEG_D; break;
  46.                 case 3: wyj = SEG_G + SEG_P_G + SEG_SR + SEG_P_D + SEG_D; break;
  47.                 case 4: wyj = SEG_P_G + SEG_L_G + SEG_SR + SEG_P_D; break;
  48.                 case 5: wyj = SEG_G + SEG_P_D + SEG_SR + SEG_L_G + SEG_D; break;
  49.                 case 6: wyj = SEG_G + SEG_L_G + SEG_SR + SEG_L_D + SEG_P_D + SEG_D; break;
  50.                 case 7: wyj = SEG_G + SEG_P_G + SEG_P_D; break;
  51.                 case 8: wyj = SEG_G + SEG_L_G + SEG_P_G + SEG_L_D + SEG_P_D + SEG_D + SEG_SR; break;
  52.                 case 9: wyj = SEG_G + SEG_P_G + SEG_L_G + SEG_P_D + SEG_D + SEG_SR; break;
  53.                 case 10: wyj += SEG_KR; break;
  54.                 case 12: wyj = SEG_D + SEG_L_D + SEG_L_G + SEG_SR; break;
  55.                 case 13: wyj = SEG_D + SEG_P_D + SEG_L_D + SEG_SR + SEG_P_G; break;
  56.                 case 14: wyj = SEG_L_D + SEG_L_G + SEG_SR + SEG_G + SEG_P_G; break;
  57.         }
  58.         return(~wyj);
  59. }
  60.  
  61.  
  62. unsigned int i;
  63. unsigned char alg=0,tryb=0;
  64.  
  65. void wyswietl(unsigned char dl){
  66.         PORTB |= 2;
  67.         PORTD = cyfra(l[0]);
  68.         for(i=0;i<dl;i++) asm volatile ( "NOP" );
  69.         if(blok>0){
  70.                 PORTD = ~SEG_KR;
  71.                 for(i=0;i<dl;i++) asm volatile ( "NOP" );
  72.         }
  73.         PORTD = 0xff;
  74.         PORTB &= ~2;
  75.         PORTB |= 1;
  76.         PORTD = cyfra(l[1]);
  77.         for(i=0;i<dl;i++) asm volatile ( "NOP" );
  78.         PORTD = 0xff;
  79.         PORTB &= ~1;
  80.         PORTB |= 4;
  81.         PORTD = cyfra(l[2]);
  82.         for(i=0;i<dl;i++) asm volatile ( "NOP" );
  83.         if((l[2]<12)&&((tryb==3&&t3==0)||tryb==1)){
  84.                 PORTD = ~SEG_KR;
  85.                 for(i=0;i<dl;i++) asm volatile ( "NOP" );
  86.         }
  87.         PORTD = 0xff;
  88.         PORTB &= ~4;
  89. }
  90.  
  91. unsigned int czas=1000,licznik_gl=0;
  92.  
  93.  
  94. unsigned char nw=1;
  95. unsigned int przyc=0;
  96.  
  97. signed char kmdp=-1;
  98.  
  99. unsigned char sprawdz_przyc(void){
  100.         unsigned char wyj=0;
  101.         nw=1;
  102.         if(~(PINC)%2){
  103.                 if(++przyc==550) wyj=1; else nw=0;
  104.         } else if(~(PINC>>1)%2){
  105.                 if(++przyc==550) wyj=2; else nw=0;
  106.         } else if(~(PINC>>2)%2){
  107.                 if(++przyc==550) wyj=4; else nw=0;
  108.         }
  109.         if(nw==1) przyc=0;
  110.         return(wyj);
  111. }
  112.  
  113. unsigned char losuj(void){
  114.         unsigned char przyc_wart, wyj=0;
  115.         for(;;){
  116.                 wyswietl(23);
  117.                 przyc_wart = sprawdz_przyc();
  118.                 switch(przyc_wart){
  119.                         case 2: if(wyj<9)wyj++; else wyj=0; break;
  120.                         case 1: return wyj; break;
  121.                 }
  122.                 l[0]=(wyj)%10;
  123.                 l[1]=100;
  124.                 l[2]=14;
  125.         }
  126. }
  127. /*      unsigned char wyj=0;
  128.         for(;;){
  129.                 if(++i>1000){
  130.                         if(++wyj>9)wyj=0;
  131.                         i=0;
  132.                 }
  133.                 PORTB |= 2;
  134.                 switch(wyj){
  135.  
  136.                         case 2: PORTD = ~SEG_G; break;
  137.                         case 3: PORTD = ~(SEG_G + SEG_P_G); break;
  138.                         case 4: PORTD = ~(SEG_P_G + SEG_P_D); break;
  139.                         case 5: PORTD = ~(SEG_P_D + SEG_D); break;
  140.                         case 6: PORTD = ~SEG_D;
  141.                 }
  142.                 delay(3);
  143.                 PORTD = 0xff;
  144.                 PORTB &= ~2;
  145.                 PORTB |= 1;
  146.                 switch(wyj){
  147.                         case 1: case 2: PORTD = ~(SEG_G); break;
  148.                         case 6: case 7: PORTD = ~SEG_D;
  149.                 }
  150.                 delay(3);
  151.                 PORTD = 0xff;
  152.                 PORTB &= ~1;
  153.                 PORTB |= 4;
  154.                 switch(wyj){
  155.                         case 0: PORTD = ~(SEG_L_G + SEG_G); break;
  156.                         case 1: PORTD = ~SEG_G; break;
  157.                         case 7: PORTD = ~SEG_D; break;
  158.                         case 8: PORTD = ~(SEG_D + SEG_L_D); break;
  159.                         case 9: PORTD = ~(SEG_L_D + SEG_L_G);
  160.                 }
  161.                 delay(3);
  162.                 PORTD = 0xff;
  163.                 PORTB &= ~4;
  164.                 if(PINC%2==0) return(wyj);
  165.         }*/
  166.  
  167.  
  168.  
  169. void ust_km(void){
  170.         unsigned char przyc_wart;
  171.         for(;;){
  172.                 wyswietl(23);
  173.                 przyc_wart = sprawdz_przyc();
  174.                 switch(przyc_wart){
  175.                         case 4: return; break;
  176.                         case 1: if(kmdp<99)kmdp++; break;
  177.                         case 2: if(kmdp>-1)kmdp--; break;
  178.                 }
  179.                 l[0]=(kmdp+1)%10;
  180.                 l[1]=((kmdp+1)/10)%10;
  181.                 l[2]=13;
  182.         }
  183. }
  184.  
  185. void konf(void){
  186.         unsigned char przyc_wart;
  187.         for(;;){
  188.                 wyswietl(23);
  189.                 przyc_wart = sprawdz_przyc();
  190.                 switch(przyc_wart){
  191.                         case 4: ust_km(); alg = losuj(); czas=75; return; break;
  192.                         case 1: if(tryb<1)tryb++; break;
  193.                         case 2: if(tryb>0)tryb--; break;
  194.                 }
  195.                 l[0]=tryb;
  196.                 l[1]=11;
  197.                 l[2]=12;
  198.         }
  199.  
  200. }
  201.  
  202. unsigned char tp=0;
  203.  
  204.  
  205. void ps(void){
  206.         if(tryb==0) {
  207.                 czas=1000;
  208.         } else if(tryb==1||(tryb==3&&t3==0)) {/* miasto */
  209.                 if(czas>155) czas=93;
  210.                 if(blok==0){
  211.                         if((impkm*(kll+3)*(alg/2))%9==2) blok=1;
  212.                         if(((impkm/2)*(kll+1)*alg*5)%7==0) {
  213.                                 if((czas+3)>116){
  214.                                         czas=116;
  215.                                         } else {
  216.                                         czas +=3;
  217.                                 }
  218.                         } else if(--czas<28)czas=28;
  219.                         if(czas==28){
  220.                                 if(impkm%24==0)czas=25;
  221.                                 if(impkm%24==10)czas=27;
  222.                                 if(dlim++>3){ czas=30; dlim=0; }
  223.                         } else dlim = 0;
  224.                 } else {
  225.                         if(++blok==(alg*5)%20)blok=0;
  226.                         if(((impkm/2)*(kll+1)*alg*5)%7==0) {
  227.                                 if(--czas<24)czas=26;
  228.                         } else if(((impkm/2)*(kll+1)*alg*5)%7==3) if(++czas>47)czas=45;
  229.                 }
  230.                        
  231.         }
  232. }
  233.  
  234. int main(void){
  235.         DDRD = 0xff;
  236.         DDRB = 0xff;
  237.         PORTD = 0xff;
  238.         PORTB = 0x00;
  239.         DDRC = 0x00;
  240.         PORTC = 0xff;
  241.         register unsigned char przyc_wart = 0;
  242.         register unsigned char przyc=0,nw=1;
  243.         for(;;){
  244.                 przyc_wart = 0;
  245.                 if(++licznik_gl>(2*czas)/*2*/){
  246.                         licznik_gl=0;
  247.                         PORTB &= ~8;
  248.                         if(++impkm>8380){
  249.                                 impkm=0;
  250.                                 if(++km>99)km=0;
  251.                                 if(kll%2==0) {
  252.                                         if(t3==0)t3=1;
  253.                                 } else t3=0;
  254.                                 if(kmdp!=-1) if(--kmdp==-1) tryb=0;
  255.                         }
  256.                         if((impkm%530)==0)ps();
  257.                         if(impkm%262==0&&czas>20)ps();
  258.                         if(impkm%130==0&&czas>40)ps();
  259.                         if(czas<8)czas=15;
  260.                         if(impkm%131==0) if(++kll>80)kll=0;
  261.                 }
  262.                 if(licznik_gl==czas/*1*/) PORTB |= 8;
  263.  
  264.  
  265.  
  266. ////////// PRZYC
  267.                 nw=1;
  268.                 przyc_wart = 0;
  269.  
  270.                 if(~(PINC)%2){
  271.                         if(++przyc==220) przyc_wart=1; else nw=0;
  272.                 } else if(~(PINC>>1)%2){
  273.                         if(++przyc==220) przyc_wart=2; else nw=0;
  274.                 } else if(~(PINC>>2)%2){
  275.                         if(++przyc==220) przyc_wart=4; else nw=0;
  276.                 }
  277.  
  278.                 if(nw==1) przyc=0;
  279. //////////////  /przyc
  280.  
  281.                 switch(przyc_wart){
  282.                         case 1: if(czas<70)czas++; break;
  283.                         case 2: if(czas>15)czas--; break;
  284.                         case 4: konf();
  285.                 }
  286.                 l[0] = km%10;
  287.                 l[1] = (km/10)%10;
  288.                 l[2] = 11;
  289.                 if(tryb!=0)wyswietl(5); else wyswietl(23);
  290.  
  291.         }
  292.        
  293. }

odpowiedź "Bez tytułu"

Tutaj możesz odpowiedzieć na wklejkę z góry

captcha