Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include <avr/io.h>
  2. #include <avr/interrupt.h>
  3.  
  4. #include "mytypes.h"
  5. #include "rs232.h"
  6. #include "pins.h"
  7.  
  8. //if want Log than comment next string
  9. #undef LOGENABLE
  10. //#define LOGENABLE
  11.  
  12. #define FOSC 11059200// Clock Speed
  13. #define BAUD115200 115200
  14. #define UBRR115200 (((FOSC/16)/BAUD115200)-1)
  15.  
  16. //Registers for 16550 emulation:
  17.  
  18. //Divisor Latch LSB
  19. static UBYTE rs232_DLL;
  20. //Divisor Latch MSB
  21. static UBYTE rs232_DLM;
  22. //Interrupt Enable
  23. static UBYTE rs232_IER;
  24. //Interrupt Identification
  25. static UBYTE rs232_IIR;
  26. //FIFO Control
  27. static UBYTE rs232_FCR;
  28. //Line Control
  29. static UBYTE rs232_LCR;
  30. //Modem Control
  31. static UBYTE rs232_MCR;
  32. //Line Status
  33. static UBYTE rs232_LSR;
  34. //Modem Status
  35. static UBYTE rs232_MSR;
  36. //Scratch Pad
  37. static UBYTE rs232_SCR;
  38. //Fifo In
  39. static UBYTE rs232_FI[16];
  40. static UBYTE rs232_FI_start;
  41. static UBYTE rs232_FI_end;
  42. //Fifo Out
  43. static UBYTE rs232_FO[16];
  44. static UBYTE rs232_FO_start;
  45. static UBYTE rs232_FO_end;
  46.  
  47. void rs232_init(void)
  48. {
  49.         // Set baud rate
  50.         UBRR1H = (UBYTE)(UBRR115200>>8);
  51.         UBRR1L = (UBYTE)UBRR115200;
  52.         // Clear reg
  53.         UCSR1A = 0;
  54.         // Enable receiver and transmitter
  55.         UCSR1B = (1<<RXEN)|(1<<TXEN);
  56.         // Set frame format: 8data, 1stop bit
  57.         UCSR1C = (1<<USBS)|(1<<UCSZ0)|(1<<UCSZ1);
  58.         // Set TXD pin
  59.         //RS232TXD_DDR |= (1<<RS232TXD);
  60.  
  61.         //Set default values:
  62.         rs232_IER = 0;
  63.         rs232_FCR = 0;
  64.         rs232_IIR = 0x01;
  65.         rs232_LCR = 0;
  66.         rs232_MCR = 0;
  67.         rs232_LSR = 0x60;
  68.         rs232_MSR = 0;
  69.         rs232_SCR = 0xFF;
  70.         rs232_FI_start = rs232_FI_end = 0;
  71.         rs232_FO_start = rs232_FO_end = 0;
  72. }
  73.  
  74. void rs232_transmit( UBYTE data )
  75. {
  76.         // Wait for empty transmit buffer
  77.         while ( !( UCSR1A & (1<<UDRE)) );
  78.         // Put data into buffer, sends the data
  79.         UDR1 = data;
  80. }
  81.  
  82. #ifdef LOGENABLE
  83. void to_log(char* ptr)
  84. {
  85.         while( (*ptr)!=0 )
  86.         {
  87.                 rs232_transmit(*ptr);
  88.                 ptr++;
  89.         }
  90. }
  91. #endif
  92.  
  93.  
  94. //after DLL or DLM changing
  95. void rs232_set_baud(void)
  96. {
  97.         if ( rs232_DLM | rs232_DLL )
  98.         {
  99.                 ULONG i = BAUD115200/ ((((UWORD)rs232_DLM)<<8) + rs232_DLL);
  100.                 UWORD rate = ((FOSC/16)/i)-1;
  101.                 // Set baud rate
  102.                 UBRR1H = (UBYTE)(rate>>8);
  103.                 UBRR1L = (UBYTE)rate;
  104.         }
  105. }
  106.  
  107. void rs232_zx_write(UBYTE index, UBYTE data)
  108. {
  109.  #ifdef LOGENABLE
  110.         char log_write[] = "A..D..W\r\n";
  111.         log_write[1] = ((index >> 4) <= 9 )?'0'+(index >> 4):'A'+((index >> 4)-10);
  112.         log_write[2] = ((index & 0x0F) <= 9 )?'0'+(index & 0x0F):'A'+(index & 0x0F)-10;
  113.         log_write[4] = ((data >> 4) <= 9 )?'0'+(data >> 4):'A'+((data >> 4)-10);
  114.         log_write[5] = ((data & 0x0F) <= 9 )?'0'+(data & 0x0F):'A'+((data & 0x0F)-10);
  115.         to_log(log_write);
  116.  #endif
  117.  
  118.         switch( index )
  119.         {
  120.         case 0:
  121.                 rs232_transmit(data);
  122.                 if ( rs232_LCR & 0x80 )
  123.                 {
  124.                         rs232_DLL = data;
  125.                 }
  126.                 else
  127.                 {
  128.                         //place byte to fifo out
  129.                         //if ( rs232_FO_end )
  130.                         {
  131.                                 rs232_FO[rs232_FO_end] = data;
  132.                                 rs232_FO_end = (rs232_FO_end + 1) & 0x0F;
  133.                         }
  134.                 }
  135.                 break;
  136.  
  137.         case 1:
  138.    
  139.                 if ( rs232_LCR & 0x80 )
  140.                 {
  141.                         //write to DLM
  142.                         rs232_DLM = data;
  143.                 }
  144.                 else
  145.                 {
  146.                         //bit 7-4 not used and set to '0'
  147.                         rs232_IER = data & 0x0F;
  148.                 }
  149.                 break;
  150.  
  151.         case 2:
  152.                 rs232_FCR = data;
  153.                 break;
  154.  
  155.         case 3:
  156.                 rs232_LCR = data;
  157.                 break;
  158.  
  159.         case 4:
  160.                 //bit 7-5 not used and set to '0'
  161.                 rs232_MCR = data & 0x1F;
  162.                 break;
  163.  
  164.         case 5:
  165.                 rs232_LSR = data;
  166.                 break;
  167.  
  168.         case 6:
  169.                 rs232_MSR = data;
  170.                 break;
  171.  
  172.         case 7:
  173.                 rs232_SCR = data;
  174.                 break;
  175.         }
  176. }
  177.  
  178. UBYTE rs232_zx_read(UBYTE index)
  179. {
  180.         UBYTE data = 0;
  181.         switch( index )
  182.         {
  183.         case 0:
  184.                 if ( rs232_LCR & 0x80 )
  185.                 {
  186.                         data = rs232_DLL;
  187.                 }
  188.                 else
  189.                 {
  190.                         //get byte from fifo in
  191.                         if ( rs232_FI_start != rs232_FI_end )
  192.                         {
  193.                                 data = rs232_FI[rs232_FI_start];
  194.                                 rs232_FI_start = ( rs232_FI_start + 1 ) & 0x0F;
  195.                         }
  196.                 }
  197.                 data=UDR1;
  198.                 break;
  199.  
  200.         case 1:
  201.                 if ( rs232_LCR & 0x80 )
  202.                 {
  203.                         data = rs232_DLM;
  204.                 }
  205.                 else
  206.                 {
  207.                         data = rs232_IIR;
  208.                 }
  209.                 data=UCSR1A;
  210.                 break;
  211.  
  212.         case 2:
  213.                 data = rs232_FCR;
  214.                 break;
  215.  
  216.         case 3:
  217.                 data = rs232_LCR;
  218.                 break;
  219.  
  220.         case 4:
  221.                 data = rs232_MCR;
  222.                 break;
  223.  
  224.         case 5:
  225.                 data = rs232_LSR;
  226.                 break;
  227.  
  228.         case 6:
  229.                 data = rs232_MSR;
  230.                 break;
  231.  
  232.         case 7:
  233.                 data = rs232_SCR;
  234.                 break;
  235.         }
  236.  #ifdef LOGENABLE
  237.         static UBYTE last = 0;
  238.         if ( (last!=6) || (last!=index) )
  239.         {
  240.                 char log_read[] = "B..D..R\r\n";
  241.                 log_read[1] = ((index >> 4) <= 9 )?'0'+(index >> 4):'A'+((index >> 4)-10);
  242.                 log_read[2] = ((index & 0x0F) <= 9 )?'0'+(index & 0x0F):'A'+(index & 0x0F)-10;
  243.                 log_read[4] = ((data >> 4) <= 9 )?'0'+(data >> 4):'A'+((data >> 4)-10);
  244.                 log_read[5] = ((data & 0x0F) <= 9 )?'0'+(data & 0x0F):'A'+((data & 0x0F)-10);
  245.                 to_log(log_read);
  246.         }
  247.         last = index;
  248. #endif
  249.  
  250.         return data;
  251. }
  252.