A rewrite of the serial example to use interrupts in C

Code:

Code (Text):

1. /*************************************************************************
2. * int.c - A demonstration of how to write interrupt-driven code for an
3. *  8051 using the Keil C compiler.  The same techniques may work in other
4. *  8051 C compilers with little or no modifcation.  This program will
5. *  combine the functionality of both basic.c and serial.c to allow serial
6. *  communications to be entirely in the background, driven by the serial
7. *  interrupt.  This allows the main() function to count on Port 0 without
8. *  being aware of any ongoing serial communication.
9. */
10.  
11. /* included headers */
12.  
13. #include
14.  
15. /* function declarations */
16.  
17. char getCharacter (void);        /* read a character from the serial port */
18. void sendCharacter (char);        /* write a character to the serial port */
19.  
20. /*
21. * Interrupt handlers:
22. *  Here the code for the interrupt handler will be placed.  In this
23. *  example, a handler for the serial interrupt will be written.
24. *  Examination of the 8051 specs will show that the serial interrupt is
25. *  interrupt 4.  A single interrupt is generated for both transmit and
26. *  receive interrupts, so determination of the exact cause (and proper
27. *  response) must be made within the handler itself.
28. *  To write an interrupt handler in Keil, the function must be declared
29. *  void, with no parameters.  In addition, the function specification
30. *  must be followed by a specification of the interrupt source it is
31. *  attached to.  The "using" attribute specifies which register bank
32. *  to use for the interrupt handler.
33. */
34.  
35. void serial_int (void) interrupt 4
36. {
37.       static char        chr = '\0';        /* character buffer */
38.  
39.       /*
40.         * The interrupt was generated, but it is still unknown why.  First,
41.         * check the RI flag to see if it was because a new character was
42.         * received.
43.         */
44.  
45.       if (RI == 1)        /* it was a receive interrupt */
46.       {
47.               chr = SBUF;        /* read the character into our local buffer */
48.               RI = 0;        /* clear the received interrupt flag */
49.               TI = 1;        /* signal that there's a new character to send */
50.       }
51.       else if (TI == 1)        /* otherwise, assume it was a transmit interrupt */
52.       {
53.               TI = 0;        /* clear the transmit interrupt flag */
54.               if (chr != '\0')        /* if there's something in the local buffer... */
55.               {
56.                       if (chr == '\r') chr = '\n';        /* convert  to  */
57.                       SBUF = chr;        /* put the character into the transmit buffer */
58.                       chr = '\0';
59.               }
60.       }
61. }
62.  
63. /* functions */
64.  
65. /*************************************************************************
66. * main - Program entry point.  This program sets up the timers and
67. *  interrupts, then simply receives characters from the serial port and
68. *  sends them back.  Notice that nowhere in the main function is Port 0
69. *  incremented, nor does it call any other function that may do so.
70. *  main() is free to do solely serial communications.  Port 0 is handled
71. *  entirely by the interrupt handler (aside from initialization).
72. *
73. * INPUT: N/A
74. * RETURNS: N/A
75. */
76.  
77. main()
78. {
79.       /* Before the serial port may be used, it must be configured. */
80.  
81.       /* Set up Timer 0 for the serial port */
82.  
83.       SCON = 0x50;        /* mode 1, 8-bit uart, enable receiver */
84.       TMOD = 0x20;        /* timer 1, mode 2, 8-bit reload */
85.       TH1  = 0xFE;        /* reload value for 2400 baud */
86.       ET0  = 0;                /* we don't want this timer to make interrupts */
87.       TR1  = 1;                /* start the timer */
88.       TI  = 1;                /* clear the buffer */
89.  
90.       /*
91.         * The compiler automatically installs the interrupt handler, so
92.         * all that needs to be done to use it is enable interrupts.  First,
93.         * speficially enable the serial interrupt, then enable interrupts.
94.         */
95.      
96.       ES  = 1;                /* allow serial interrupts */
97.       EA  = 1;                /* enable interrupts */
98.  
99.       /* initialize Port 0 to 0, as in basic.c */
100.  
101.     P0 = 0;
102.  
103.       /*
104.         * Loop forever, increasing Port 0.  Again, note nothing is done
105.         * with the serial port in this loop.  Yet simulations will show
106.         * that the software is perfectly capable of maintaining serial
107.         * communications while this counting proceeds.
108.         */
109.  
110.       while (1==1)
111.     {
112.               unsigned int        i;
113.               for (i = 0; i < 60000; i++) {;}        /* delay */
114.               P0 = P0 + 1;        /* increment Port 0 */
115.       }
116. }