UART多机通讯模式

主机MEGA16L,代码如下

1. 
   
2. #include <iom16v.h>
   
3. #include <macros.h>
   
4. #define uchar unsigned char
   
5. 
   
6. unsigned char data;
   
7. unsigned char timerl;
   
8. unsigned char timerh;
   
9. unsigned char time,rr;
   
10. unsigned char sendbuf[10];
    
11. unsigned char recbuf[10];
    
12. uchar   addr,fun,message;
    
13. uchar   realaddr,realfun,keepaddr,alARM,realalarm;  //  for  &sup2;&brvbar;&Acirc;&euml;&iquest;&ordf;&sup1;&Oslash;
    
14. 
    
15. void delay(unsigned char i)
    
16. {
    
17.     for(timerl=0;timerl<i;);
    
18. }
    
19. void port_init(void)
    
20. {
    
21. PORTA = 0x3F;
    
22. DDRA = 0x00;
    
23. PORTB |= 0x08;  //  485
    
24. DDRB |= 0x08;
    
25. PORTC = 0x00; //m103 output only
    
26. DDRC  = 0xFF;
    
27. PORTD = 0xC0;
    
28. DDRD  = 0x30;
    
29. }
    
30. 
    
31. //TIMER0 initialize - prescale:64
    
32. // WGM: Normal
    
33. // desired value: 1mSec
    
34. // actual value:  1.000mSec (0.0%)
    
35. void timer0_init(void)
    
36. {
    
37. TCCR0 = 0x00; //stop
    
38. TCNT0 = 0x83; //set count  
    
39. TCCR0 = 0x03; //start timer
    
40. }
    
41. 
    
42. #pragma interrupt_handler timer0_ovf_isr:10
    
43. void timer0_ovf_isr(void)
    
44. {
    
45. TCNT0 = 0x83; //reload counter value
    
46. timerl++;
    
47. timerh++;
    
48. }
    
49. 
    
50. //TIMER1 initialize - prescale:1024
    
51. // WGM: 0) Normal, TOP=0xFFFF
    
52. // desired value: 1Sec
    
53. // actual value:  1.000Sec (0.0%)
    
54. void timer1_init(void)
    
55. {
    
56. TCCR1B = 0x00; //stop
    
57. TCNT1H = 0xE1; //setup
    
58. TCNT1L = 0x7C;
    
59. TCCR1A = 0x00;
    
60. TCCR1B = 0x05; //start Timer
    
61. }
    
62. 
    
63. #pragma interrupt_handler timer1_ovf_isr:9
    
64. void timer1_ovf_isr(void)
    
65. {
    
66. //TIMER1 has overflowed
    
67. TCNT1H = 0xE1; //reload counter high value
    
68. TCNT1L = 0x7C; //reload counter low value
    
69. time++;
    
70. }
    
71. 
    
72. //UART0 initialize
    
73. // desired baud rate: 19200
    
74. // actual: baud rate:19231 (0.2%)
    
75. // char size: 9 bit
    
76. // parity: Disabled
    
77. void uart0_init(void)
    
78. {
    
79. UCSRB = 0x00; //disable while setting baud rate
    
80. UCSRA = 0x00;
    
81. UCSRC = BIT(URSEL) | 0x06;
    
82. UBRRL = 0x19; //set baud rate lo
    
83. UBRRH = 0x00; //set baud rate hi
    
84. UCSRB = 0xDC;
    
85. }
    
86. 
    
87. #pragma interrupt_handler uart0_rx_isr:12
    
88. void uart0_rx_isr(void)
    
89. {
    
90. //uart has received a character in UDR
    
91. }
    
92. 
    
93. #pragma interrupt_handler uart0_tx_isr:14
    
94. void uart0_tx_isr(void)
    
95. {
    
96. unsigned char i;  
    
97. rr ++;
    
98. if(rr < 4){
    
99.     // for(i=0;i<100;i++);
    
100. UCSRB &= ~(1<<TXB8);//
     
101.      UDR = sendbuf[rr];   
     
102. }
     
103.   
     
104. }
     
105. 
     
106. //call this routine to initialize all peripherals
     
107. void init_devices(void)
     
108. {
     
109. //stop errant interrupts until set up
     
110. CLI(); //disable all interrupts
     
111. port_init();
     
112. timer0_init();
     
113. timer1_init();
     
114. uart0_init();
     
115. 
     
116. MCUCR = 0x00;
     
117. GICR  = 0x00;
     
118. TIMSK = 0x05; //timer interrupt sources
     
119. SEI(); //re-enable interrupts
     
120. //all peripherals are now initialized
     
121. }
     
122. 
     
123. void  ReadSwitch(){
     
124.     unsigned char    i;
     
125.     realaddr = 0;
     
126.     realfun = 0;
     
127.     PORTB &= 0xF8;
     
128.     DDRB &= 0xF8;
     
129.     DDRB |= 0x01;
     
130.     for(i=0; i<40; i++);
     
131.     if(!(PINA & 0x20))  realaddr |= 0x01;
     
132.     if(!(PINA & 0x10))  realaddr |= 0x02;
     
133.     if(!(PINA & 0x08))  realaddr |= 0x04;
     
134.     if(!(PINA & 0x04))  realaddr |= 0x08;
     
135.     if(!(PINA & 0x02))  realaddr |= 0x10;
     
136.     if(!(PINA & 0x01))  realaddr |= 0x20;
     
137. 
     
138.     DDRB &= 0xF8;
     
139.     DDRB |= 0x02;
     
140.     for(i=0; i<40; i++);
     
141.     if(!(PINA & 0x01))  realaddr |= 0x40;
     
142.     if(!(PINA & 0x02))  realaddr |= 0x80;
     
143.     if(!(PINA & 0x04))  realfun |= 0x01;
     
144.     if(!(PINA & 0x08))  realfun |= 0x02;
     
145.     if(!(PINA & 0x10))  realfun |= 0x04;
     
146.     if(!(PINA & 0x20))  realfun |= 0x08;
     
147. 
     
148.     DDRB &= 0xF8;
     
149.     DDRB |= 0x04;
     
150.     for(i=0; i<40; i++);
     
151.     if(!(PINA & 0x08))  realfun |= 0x40;
     
152.     if(!(PINA & 0x10))  realfun |= 0x20;
     
153.     if(!(PINA & 0x20))  realfun |= 0x10;
     
154. 
     
155.     PORTB |= 0x01;           
     
156.     DDRB &= 0xF8;
     
157.     DDRB |= 0x01;
     
158. }
     
159. 
     
160. 
     
161. unsigned char  checksum()
     
162. {
     
163.    return (sendbuf[0]+sendbuf[1]+sendbuf[2]);
     
164. }
     
165. 
     
166. void main(void)
     
167. {
     
168. unsigned char i;
     
169. init_devices();
     
170. timerl = 0;
     
171. timerh = 0;
     
172. time   = 0;  
     
173. for(;;){
     
174.        if(timerl > 200){
     
175.        PORTB ^= 0x01;
     
176.        timerl = 0;
     
177.    ReadSwitch();
     
178.    if(realfun & 0x01){
     
179.        sendbuf[0]=realaddr;         
     
180.                sendbuf[1]=0x77;
     
181.                sendbuf[2]='1';
     
182.                sendbuf[3]= checksum();
     
183.        rr = 0;
     
184.            UCSRB |= (1<<TXB8);        
     
185.        UDR = realaddr;
     
186.         
     
187.    }
     
188.    if(realfun & 0x02){
     
189.        sendbuf[0]=realaddr;
     
190.        sendbuf[1]=0x77;
     
191.                sendbuf[2]='2';
     
192.                sendbuf[3]= checksum();
     
193.        rr = 0;
     
194.            UCSRB |= (1<<TXB8);   
     
195.        UDR = realaddr;
     
196.    }
     
197.    if(realfun & 0x04){
     
198.        sendbuf[0]=realaddr;
     
199.        sendbuf[1]=0x77;
     
200.                sendbuf[2]='3';
     
201.                sendbuf[3]= checksum();
     
202.        rr = 0;
     
203.            UCSRB |= (1<<TXB8);
     
204.        UDR = realaddr;
     
205.    }
     
206.    if(realfun & 0x08){
     
207.        sendbuf[0]=realaddr;
     
208.        sendbuf[1]=0x77;
     
209.                sendbuf[2]='4';
     
210.                sendbuf[3]= checksum();
     
211.        rr = 0;
     
212.            UCSRB |= (1<<TXB8);
     
213.        UDR = realaddr;
     
214.    }
     
215.    if(realfun & 0x10){
     
216.        sendbuf[0]= realaddr;
     
217.        sendbuf[1]= 0x77;
     
218.                sendbuf[2]= 'F';
     
219.                sendbuf[3]= checksum();
     
220.        rr = 0;
     
221.            UCSRB |= (1<<TXB8);
     
222.        UDR = realaddr;
     
223.    }     
     
224.    if(realfun & 0x40){
     
225.        sendbuf[0]=realaddr;
     
226.        sendbuf[1]=0x77;
     
227.                             sendbuf[2]=0x88;                                                                                                                                                                                                          sendbuf[3]= checksum();
     
228.        rr = 0;
     
229.            UCSRB |= (1<<TXB8);
     
230.        UDR = realaddr;
     
231.    }
     
232.    if(realfun & 0x20){
     
233.        sendbuf[0]=realaddr;
     
234.        sendbuf[1]=0x88;
     
235.                sendbuf[2]='8';
     
236.                sendbuf[3]= checksum();
     
237.        rr = 0;
     
238.            UCSRB |= (1<<TXB8);
     
239.        UDR = realaddr;
     
240.    }   
     
241.    }
     
242. }  
     
243. }
     
244. 
     

复制代码

多机通讯与普通的USART通讯差不多,只不过注意几点:  
1,需在复位时将UCSRA寄存器中的MPCM位置1  
2,上位机发送地址数据时将第九位置1,这样一来,所有的从机都能通过中断接收到此数据啦各个从机判断接收到的数据是否与自己的地址相符,不符的返回,符合的(只能有1台符合)将MPCM位置0,以便正常的接收发给自己的数据.这些数据的第九位必须为0.其他的从机不会对这些数据产生中断.从而实现多机通讯.
上位机发送 UCSRB |= (1<<TXB8);及第九位数据是1的时候，从机能够能够产生中断，如果第九位0，则从机将数据忽略。如果你发的数据帧：
地址＋数据1＋数据2＋...   
你可以在从机接收到地址数据后，与本机的地址比较，如果相同。说明是发给本机的指令，你可以在中断中将本设置普通的数据模式，用以接收后面的数据。

上面的MEGA16程序是完整的程序，能够在ICCAVR上运行通过的。

下位机是MEGA8

1. void uart0_init_mulmodel(void)
   
2. {
   
3. UCSRB = 0x00; //disable while setting baud rate
   
4. UCSRA = 0x01; //mul. processor
   
5. UCSRC = BIT(URSEL) | 0x06;
   
6. UBRRL = 0x19; //set baud rate lo
   
7. UBRRH = 0x00; //set baud rate hi
   
8. UCSRB = 0x94; //9 bit data
   
9. }
   
10. void uart0_init_normodel(void)
    
11. {
    
12. UCSRB = 0x00; //disable while setting baud rate
    
13. UCSRA = 0x00; //normal model
    
14. UCSRC = BIT(URSEL) | 0x06;
    
15. UBRRL = 0x19; //set baud rate lo
    
16. UBRRH = 0x00; //set baud rate hi
    
17. UCSRB = 0x94; //9 bit data
    
18. }
    
19. 
    
20. #pragma interrupt_handler uart0_rx_isr:12
    
21. void uart0_rx_isr(void)
    
22. {
    
23. //uart has received a character in UDR
    
24. rrr[rr] = UDR;
    
25. rr++;
    
26. receivetask();
    
27. }
    
28. //数据接收处理函数
    
29. void R_KeLi(void)
    
30. {
    
31. kelitimer = 0;
    
32. switch(rr){
    
33. case 1:
    
34. if(rrr[0] == addr){//判断地址是否与本机地址相等
    
35. uart0_init_normodel();//如果相等，将本设置位普通模式来接收后面的数据，如果没有这句，后面的数据（第九位为0）将被忽略
    
36. }
    
37. else{
    
38. rr = 0;
    
39. }
    
40. break;
    
41. }
    
42. 
    
43. }
    

复制代码