Advertisement
Guest User

Untitled

a guest
Dec 16th, 2019
118
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 4.26 KB | None | 0 0
  1. #include <ioavr.h>
  2. #include <inavr.h>
  3.  
  4.  
  5.  
  6. #define SPI_SCK 0
  7. #define SPI_CS  1
  8. #define SPI_DI  2
  9.  
  10. #define SPI_PORT PORTB
  11. #define SPI_DIR  DDRB
  12. __flash unsigned char toDOT[] = {
  13.   0x3E, 0x45, 0x49, 0x51, 0x3E, /* 0 */
  14.   0x00, 0x40, 0x7F, 0x42, 0x00, /* 1 */
  15.   0x46, 0x49, 0x49, 0x51, 0x62,  /* 2 */
  16.   0x36, 0x49,   0x49,   0x41,   0x22,
  17.   0x7F  ,0x08   ,0x08   ,0x08,  0x07,
  18.   0x39, 0x45,   0x45,   0x45,   0x47,
  19.   0x32, 0x49,   0x49,   0x49,   0x3E,
  20.   0x07, 0x09,   0x11,   0x21,   0x41,
  21.   0x36, 0x49,   0x49,   0x49,   0x36,
  22.   0x3E, 0x49,   0x49,   0x49,   0x46,
  23.   0x00, 0x00    ,0x24   ,0x00,  0x00,
  24.   0x00, 0x00    ,0x12   ,0x00,  0x00
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32. };
  33.  
  34. #define SECOND  7372800
  35. #define ms  73728
  36. unsigned char disp [32];
  37.  
  38. void printDgt(char pos, char val)
  39. {
  40. unsigned char __flash * src;
  41. unsigned char * dst;
  42.   src = toDOT + (5 * val);
  43.   dst = disp + (6 * pos) + 1;
  44.   for(char i = 5; i; --i, ++src, ++dst)  
  45.     *dst = *src;
  46.   dst = 0x00;  
  47. }
  48.  
  49. void spiSend(unsigned char d)
  50. {
  51. unsigned char cnt;  
  52.     for(cnt = 8; cnt; --cnt)
  53.     {
  54.       if(d & 0x80)
  55.         SPI_PORT = (1 << SPI_DI);
  56.       else
  57.         SPI_PORT = 0;
  58.       d = d << 1;
  59.       __delay_cycles(3);
  60.       SPI_PORT = SPI_PORT ^ (1 << SPI_SCK);
  61.       __delay_cycles(3);
  62.       SPI_PORT = SPI_PORT ^ (1 << SPI_SCK);
  63.     }        
  64. }
  65.  
  66. void maxPaint()
  67. {
  68.   unsigned char mask;
  69.   unsigned char row;
  70.   unsigned char data;
  71.   unsigned char col;
  72.   unsigned char bit_cnt;
  73.   for(row = 1, mask = 0x01; row < 9; ++row, mask = mask << 1)
  74.   {    
  75.     SPI_PORT &= ~(1 << SPI_CS);
  76.     for(col = 31, bit_cnt = 8; col != 255; --col)
  77.     {
  78.       data <<= 1;
  79.       data |= (disp[col] & mask) ?  0x01 : 0x00;      
  80.       if((--bit_cnt) == 0)
  81.       {
  82.         spiSend(row);
  83.         spiSend(data);
  84.         bit_cnt = 8;                
  85.       }      
  86.     }
  87.     SPI_PORT |= (1 << SPI_CS);
  88.   }
  89. }
  90.  
  91. void maxToAll(char a, char d)
  92. {
  93. unsigned char cnt;  
  94.     SPI_PORT &= ~(1 << SPI_CS);
  95.     cnt = 4;
  96.     do {
  97.       spiSend(a);
  98.       spiSend(d);
  99.     } while(--cnt);
  100.     SPI_PORT |= (1 << SPI_CS);
  101. }
  102.  
  103. void initDevices()
  104. {
  105.   SPI_DIR = 0x07;
  106.   SPI_PORT = (1 << SPI_CS);
  107. }
  108.  
  109. void sendMAX(unsigned char a, unsigned char d)
  110. {
  111.    SPI_PORT = 0;
  112.    spiSend(a);
  113.    spiSend(d);  
  114.    SPI_PORT = (1 << SPI_CS);
  115. }
  116.  
  117. void dotTest()
  118. {
  119.    sendMAX(0x09, 0x00);
  120.    sendMAX(0x0B, 0x07);
  121.    sendMAX(0x0C, 0x01);
  122.    sendMAX(0x0A, 0x0F);
  123.    sendMAX(0x09, 0x00);
  124.    sendMAX(0x01, 0x01);
  125.    sendMAX(0x02, 0x02);
  126.    sendMAX(0x03, 0x04);  
  127.    sendMAX(0x04, 0x08);
  128.    sendMAX(0x05, 0x10);
  129.    sendMAX(0x06, 0x20);
  130.    sendMAX(0x07, 0x40);
  131.    sendMAX(0x08, 0x80);      
  132. }
  133.  
  134. void maxInit()
  135. {
  136.   maxToAll(0x0F, 0x00);
  137.   maxToAll(0x0B, 0x07);
  138.   maxToAll(0x0C, 0x01);
  139.   maxToAll(0x0A, 0x0F);
  140.   maxToAll(0x09, 0x00);
  141. }
  142.  
  143. void printTime(int minutes, int seconds, int miliseconds, int print)
  144. {
  145.  
  146.   printDgt(4,minutes/10);
  147.   printDgt(3,minutes%10);
  148.   printDgt(2,10);
  149.   printDgt(1,seconds/10);
  150.   printDgt(0,seconds%10);
  151.   //maxPaint();
  152.    __delay_cycles(7372800);
  153.   printDgt(4,seconds/10);
  154.   printDgt(3,seconds%10);
  155.   printDgt(2,10);
  156.   printDgt(1,miliseconds/10);
  157.   printDgt(0,miliseconds%10);
  158.   maxPaint();
  159.   if(print == 0)
  160.       return;
  161.   __delay_cycles(7372800);
  162.   printDgt(4,miliseconds/10);
  163.   printDgt(3,seconds%10);
  164.   printDgt(2,10);
  165.   printDgt(1,0);
  166.   printDgt(0,0);
  167.   maxPaint();
  168. }
  169.  
  170. void countdown(int TRYB_WIELKIEJ_PREDKOSCI_PRAWIE_JAK_KOSMICZNA_RAKIETA_UUUUU_WOOOSH){
  171.   int seconds = 0;
  172.   int minutes = 0;
  173.   int miliseconds = 0;
  174.   for(;;){
  175.     if (TRYB_WIELKIEJ_PREDKOSCI_PRAWIE_JAK_KOSMICZNA_RAKIETA_UUUUU_WOOOSH == 1)
  176.       __delay_cycles(5000);
  177.     else
  178.       __delay_cycles(ms);
  179.     miliseconds +=1;
  180.     if (miliseconds == 60)
  181.     {
  182.       miliseconds = 0;
  183.       seconds += 1;
  184.     }
  185.     if (seconds == 60)
  186.     {
  187.       seconds = 0;
  188.       minutes += 1;
  189.     }
  190.     if (minutes == 99)
  191.     {
  192.        printTime(minutes,seconds,miliseconds, 1);
  193.        return;
  194.     }
  195.     printTime(minutes,seconds,miliseconds, 0);
  196.   }
  197.  
  198. }
  199. int main( void )
  200. {
  201.   initDevices();
  202.   dotTest();
  203.   maxInit();
  204.   //printDgt(0,7);
  205.   //printDgt(1,8);
  206.   //printDgt(2,10);
  207.   //printDgt(3,0);
  208.   //printDgt(4,3);
  209.   countdown(TRYB_WIELKIEJ_PREDKOSCI_PRAWIE_JAK_KOSMICZNA_RAKIETA_UUUUU_WOOOSH = 1);
  210.   //maxPaint();
  211.   for(;;){
  212.     //spiSend(0x00,0x7E);
  213.   }
  214. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement