iar avr twi 多从机源码

bootloader

iar avr twi 多从机源码 [复制链接]

来源于AVR网站

1. 
   
2. 
   
3. 
   
4. 
   
5. 
   
6. 
   
7. /*****************************************************************************
   
8. *
   
9. * Atmel Corporation
   
10. *
    
11. * File         : main.c
    
12. * Compiler       : IAR EWAAVR 2.28a/3.10c
    
13. * Revision       : $Revision: 2516 $
    
14. * Date         : $Date: 2007-09-27 10:41:15 +0200 (to, 27 sep 2007) $
    
15. * Updated by     : $Author: mlarsson $
    
16. *
    
17. * Support mail     : avr@atmel.com
    
18. *
    
19. * Supported devices : All devices with a TWI module the has a slave address mask
    
20. *               register. The example is written for the ATmega48.
    
21. *
    
22. * AppNote       : AVR311 - TWI Slave Implementation
    
23. *
    
24. * Description     : Example of how to use the driver for TWI slave
    
25. *               communication. This version utilises the address mask register
    
26. *               to enable response on several TWI slave addresses.
    
27. *
    
28. ****************************************************************************/
    
29. /*! \page MISRA
    
30. *
    
31. * General disabling of MISRA rules:
    
32. * * (MISRA C rule 1) compiler is configured to allow extensions
    
33. * * (MISRA C rule 111) bit fields shall only be defined to be of type unsigned int or signed int
    
34. * * (MISRA C rule 37) bitwise operations shall not be performed on signed integer types
    
35. * As it does not work well with 8bit architecture and/or IAR
    
36. 
    
37. * Other disabled MISRA rules
    
38. * * (MISRA C rule 109) use of union - overlapping storage shall not be used
    
39. * * (MISRA C rule 61) every non-empty case clause in a switch statement shall be terminated with a break statement
    
40. */
    
41. 
    
42. #include
    
43. #include
    
44. #include "TWI_Slave.h"
    
45. 
    
46. // Sample TWI transmission commands
    
47. #define TWI_CMD_MASTER_WRITE 0x10
    
48. #define TWI_CMD_MASTER_READ 0x20
    
49. 
    
50. // The AVR can be waken up by a TWI address match from all sleep modes,
    
51. // But it only wakes up from other TWI interrupts when in idle mode.
    
52. // If POWER_MANAGEMENT_ENABLED is defined the device will enter power-down
    
53. // mode when waiting for a new command and enter idle mode when waiting
    
54. // for TWI receives and transmits to finish.
    
55. #define POWER_MANAGEMENT_ENABLED
    
56. 
    
57. // When there has been an error, this function is run and takes care of it
    
58. unsigned char TWI_Act_On_Failure_In_Last_Transmission ( unsigned char TWIerrorMsg );
    
59. 
    
60. 
    
61. void main( void )
    
62. {
    
63. unsigned char messageBuf[TWI_BUFFER_SIZE];
    
64. unsigned char TWI_slaveAddress, TWI_slaveAddress2, TWI_slaveAddressMask;
    
65. 
    
66. // LED feedback port - connect port B to the STK500 LEDS
    
67. DDRB = 0xFF; // Set to ouput
    
68. PORTB = 0x55; // Startup pattern
    
69. 
    
70. // Own TWI slave address
    
71. TWI_slaveAddress   = (0x10<
72. TWI_slaveAddress2   = (0x11<
73. TWI_slaveAddressMask = TWI_slaveAddress ^ TWI_slaveAddress2; // XOR the addresses to get the address mask.
    
74. 
    
75. // Initialise TWI module for slave operation. Include address and/or enable General Call.
    
76. TWI_Slave_Initialise( (unsigned char)(TWI_slaveAddress | (TRUE<
77.               
    
78. __enable_interrupt();
    
79. 
    
80. // Start the TWI transceiver to enable reseption of the first command from the TWI Master.
    
81. TWI_Start_Transceiver();
    
82. 
    
83. // This example is made to work together with the AVR315 TWI Master application note. In adition to connecting the TWI
    
84. // pins, also connect PORTB to the LEDS. The code reads a message as a TWI slave and acts according to if it is a
    
85. // general call, or an address call. If it is an address call, then the first byte is considered a command byte and
    
86. // it then responds differently according to the commands.
    
87. 
    
88. // This loop runs forever. If the TWI is busy the execution will just continue doing other operations.
    
89. for(;;)
    
90. {
    
91.   #ifdef POWER_MANAGEMENT_ENABLED
    
92.     // Sleep while waiting for TWI transceiver to complete or waiting for new commands.
    
93.     // If we have data in the buffer, we can't enter sleep because we have to take care
    
94.     // of it first.
    
95.     // If the transceiver is busy, we enter idle mode because it will wake up by all TWI
    
96.     // interrupts.
    
97.     // If the transceiver not is busy, we can enter power-down mode because next receive
    
98.     // should be a TWI address match and it wakes the device up from all sleep modes.
    
99.     if( ! TWI_statusReg.RxDataInBuf ) {
    
100.     if(TWI_Transceiver_Busy()) {
     
101.       MCUCR = (1<
102.     } else {
     
103.       MCUCR = (1<
104.     }
     
105.     __sleep();
     
106.     } else {
     
107.     __no_operation(); // There is data in the buffer, code below takes care of it.
     
108.     }
     
109.   #else // No power management
     
110.     // Here you can add your own code that should be run while waiting for the TWI to finish   
     
111.     __no_operation(); // Put own code here.
     
112.   #endif
     
113.    
     
114.   
     
115.   // Check if the TWI Transceiver has completed an operation.
     
116.   if ( ! TWI_Transceiver_Busy() )                     
     
117.   {
     
118.     // Check if the last operation was successful
     
119.     if ( TWI_statusReg.lastTransOK )
     
120.     {
     
121.     // Check if the last operation was a reception
     
122.     if ( TWI_statusReg.RxDataInBuf )
     
123.     {
     
124.       TWI_Get_Data_From_Transceiver(messageBuf, 2);      
     
125.       // Check if the last operation was a reception as General Call     
     
126.       if ( TWI_statusReg.genAddressCall )
     
127.       {
     
128.         // Put data received out to PORTB as an example.     
     
129.         PORTB = messageBuf[0];
     
130.       }           
     
131.       else // Ends up here if the last operation was a reception as Slave Address Match   
     
132.       {
     
133.         // Example of how to interpret a command and respond.
     
134.         
     
135.         // TWI_CMD_MASTER_WRITE stores the data to PORTB
     
136.         if (messageBuf[0] == TWI_CMD_MASTER_WRITE)
     
137.         {
     
138.         PORTB = messageBuf[1];                  
     
139.         }
     
140.         // TWI_CMD_MASTER_READ prepares the data from PINB in the transceiver buffer for the TWI master to fetch.
     
141.         if (messageBuf[0] == TWI_CMD_MASTER_READ)
     
142.         {
     
143.         messageBuf[0] = PINB;
     
144.         TWI_Start_Transceiver_With_Data( messageBuf, 1 );
     
145.         }
     
146.       }
     
147.     }           
     
148.     else // Ends up here if the last operation was a transmission
     
149.     {
     
150.         __no_operation(); // Put own code here.
     
151.     }
     
152.     // Check if the TWI Transceiver has already been started.
     
153.     // If not then restart it to prepare it for new receptions.         
     
154.     if ( ! TWI_Transceiver_Busy() )
     
155.     {
     
156.       TWI_Start_Transceiver();
     
157.     }
     
158.     }
     
159.     else // Ends up here if the last operation completed unsuccessfully
     
160.     {
     
161.     TWI_Act_On_Failure_In_Last_Transmission( TWI_Get_State_Info() );
     
162.     }
     
163.   }
     
164. }
     
165. }
     
166. 
     
167. 
     
168. unsigned char TWI_Act_On_Failure_In_Last_Transmission ( unsigned char TWIerrorMsg )
     
169. {
     
170.             // A failure has occurred, use TWIerrorMsg to determine the nature of the failure
     
171.             // and take appropriate actions.
     
172.             // Se header file for a list of possible failures messages.
     
173. 
     
174.             // This very simple example puts the error code on PORTB and restarts the transceiver with
     
175.             // all the same data in the transmission buffers.
     
176. PORTB = TWIerrorMsg;
     
177. TWI_Start_Transceiver();
     
178.             
     
179. return TWIerrorMsg;
     
180. }
     
181. 
     
182. /*
     
183. // A simplified example.
     
184. // This will store data received on PORTB, and increment it before sending it back.
     
185. 
     
186. TWI_Start_Transceiver( );   
     
187.       
     
188. for(;;)
     
189. {
     
190.   if ( ! TWI_Transceiver_Busy() )                     
     
191.   {
     
192.     if ( TWI_statusReg.RxDataInBuf )
     
193.     {
     
194.     TWI_Get_Data_From_Transceiver(&temp, 1);
     
195.     PORTB = temp;
     
196.     }
     
197.     temp = PORTB + 1;
     
198.     TWI_Start_Transceiver_With_Data(&temp, 1);
     
199.   }
     
200.   __no_operation();   // Do something else while waiting
     
201. }
     
202. }
     
203. 
     
204. */
     
205. 
     

复制代码

bootloader

1. #include "ioavr.h"
   
2. #include "inavr.h"
   
3. #include "TWI_slave.h"
   
4. 
   
5. static unsigned char TWI_buf[TWI_BUFFER_SIZE]; // Transceiver buffer. Set the size in the header file
   
6. static unsigned char TWI_msgSize = 0; // Number of bytes to be transmitted.
   
7. static unsigned char TWI_state = TWI_NO_STATE; // State byte. Default set to TWI_NO_STATE.
   
8. 
   
9. // This is true when the TWI is in the middle of a transfer
   
10. // and set to false when all bytes have been transmitted/received
    
11. // Also used to determine how deep we can sleep.
    
12. static unsigned char TWI_busy = 0;
    
13. 
    
14. union TWI_statusReg_t TWI_statusReg = {0}; // TWI_statusReg is defined in TWI_Slave.h
    
15. 
    
16. /****************************************************************************
    
17. Call this function to set up the TWI slave to its initial standby state.
    
18. Remember to enable interrupts from the main application after initializing the TWI.
    
19. Pass both the slave address and the requrements for triggering on a general call in the
    
20. same byte. Use e.g. this notation when calling this function:
    
21. TWI_Slave_Initialise( (TWI_slaveAddress<
22. The TWI module is configured to NACK on any requests. Use a TWI_Start_Transceiver function to
    
23. start the TWI.
    
24. ****************************************************************************/
    
25. void TWI_Slave_Initialise( unsigned char TWI_ownAddress, unsigned char TWI_ownAddressMask )
    
26. {
    
27. TWAR = TWI_ownAddress; // Set own TWI slave address. Accept TWI General Calls.
    
28. TWAMR= TWI_ownAddressMask; // Set own TWI slave address mask to enable respons on several addresses.
    
29. TWCR = (1<
30. (0<
31. (0<
32. (0<
33. TWI_busy = 0;
    
34. }
    
35. 
    
36. /****************************************************************************
    
37. Call this function to test if the TWI_ISR is busy transmitting.
    
38. ****************************************************************************/
    
39. unsigned char TWI_Transceiver_Busy( void )
    
40. {
    
41. return TWI_busy;
    
42. }
    
43. 
    
44. /****************************************************************************
    
45. Call this function to fetch the state information of the previous operation. The function will hold execution (loop)
    
46. until the TWI_ISR has completed with the previous operation. If there was an error, then the function
    
47. will return the TWI State code.
    
48. ****************************************************************************/
    
49. unsigned char TWI_Get_State_Info( void )
    
50. {
    
51. while ( TWI_Transceiver_Busy() ) {} // Wait until TWI has completed the transmission.
    
52. return ( TWI_state ); // Return error state.
    
53. }
    
54. 
    
55. /****************************************************************************
    
56. Call this function to send a prepared message, or start the Transceiver for reception. Include
    
57. a pointer to the data to be sent if a SLA+W is received. The data will be copied to the TWI buffer.
    
58. Also include how many bytes that should be sent. Note that unlike the similar Master function, the
    
59. Address byte is not included in the message buffers.
    
60. The function will hold execution (loop) until the TWI_ISR has completed with the previous operation,
    
61. then initialize the next operation and return.
    
62. ****************************************************************************/
    
63. void TWI_Start_Transceiver_With_Data( unsigned char *msg, unsigned char msgSize )
    
64. {
    
65. unsigned char temp;
    
66. 
    
67. while ( TWI_Transceiver_Busy() ) {} // Wait until TWI is ready for next transmission.
    
68. 
    
69. TWI_msgSize = msgSize; // Number of data to transmit.
    
70. for ( temp = 0; temp < msgSize; temp++ ) // Copy data that may be transmitted if the TWI Master requests data.
    
71. {
    
72. TWI_buf[ temp ] = msg[ temp ];
    
73. }
    
74. TWI_statusReg.all = 0;
    
75. TWI_state = TWI_NO_STATE ;
    
76. TWCR = (1<
77. (1<
78. (1<
79. (0<
80. TWI_busy = 1;
    
81. }
    
82. 
    
83. /****************************************************************************
    
84. Call this function to start the Transceiver without specifing new transmission data. Useful for restarting
    
85. a transmission, or just starting the transceiver for reception. The driver will reuse the data previously put
    
86. in the transceiver buffers. The function will hold execution (loop) until the TWI_ISR has completed with the
    
87. previous operation, then initialize the next operation and return.
    
88. ****************************************************************************/
    
89. void TWI_Start_Transceiver( void )
    
90. {
    
91. while ( TWI_Transceiver_Busy() ) {} // Wait until TWI is ready for next transmission.
    
92. TWI_statusReg.all = 0;
    
93. TWI_state = TWI_NO_STATE ;
    
94. TWCR = (1<
95. (1<
96. (1<
97. (0<
98. TWI_busy = 0;
    
99. }
    
100. /****************************************************************************
     
101. Call this function to read out the received data from the TWI transceiver buffer. I.e. first call
     
102. TWI_Start_Transceiver to get the TWI Transceiver to fetch data. Then Run this function to collect the
     
103. data when they have arrived. Include a pointer to where to place the data and the number of bytes
     
104. to fetch in the function call. The function will hold execution (loop) until the TWI_ISR has completed
     
105. with the previous operation, before reading out the data and returning.
     
106. If there was an error in the previous transmission the function will return the TWI State code.
     
107. ****************************************************************************/

复制代码

bootloader

1. unsigned char TWI_Get_Data_From_Transceiver( unsigned char *msg, unsigned char msgSize )
   
2. {
   
3. unsigned char i;
   
4. 
   
5. while ( TWI_Transceiver_Busy() ) {} // Wait until TWI is ready for next transmission.
   
6. 
   
7. if( TWI_statusReg.lastTransOK ) // Last transmission completed successfully.
   
8. {
   
9. for ( i=0; i
10. {
    
11. msg[ i ] = TWI_buf[ i ];
    
12. }
    
13. TWI_statusReg.RxDataInBuf = FALSE; // Slave Receive data has been read from buffer.
    
14. }
    
15. return( TWI_statusReg.lastTransOK );
    
16. }
    
17. 
    
18. 
    
19. // ********** Interrupt Handlers ********** //
    
20. /****************************************************************************
    
21. This function is the Interrupt Service Routine (ISR), and called when the TWI interrupt is triggered;
    
22. that is whenever a TWI event has occurred. This function should not be called directly from the main
    
23. application.
    
24. ****************************************************************************/
    
25. #pragma vector=TWI_vect
    
26. __interrupt void TWI_ISR( void )
    
27. {
    
28. static unsigned char TWI_bufPtr;
    
29. 
    
30. switch (TWSR)
    
31. {
    
32. case TWI_STX_ADR_ACK: // Own SLA+R has been received; ACK has been returned
    
33. // case TWI_STX_ADR_ACK_M_ARB_LOST: // Arbitration lost in SLA+R/W as Master; own SLA+R has been received; ACK has been returned
    
34. TWI_bufPtr = 0; // Set buffer pointer to first data location
    
35. case TWI_STX_DATA_ACK: // Data byte in TWDR has been transmitted; ACK has been received
    
36. TWDR = TWI_buf[TWI_bufPtr++];
    
37. TWCR = (1<
38. (1<
39. (1<
40. (0<
41. TWI_busy = 1;
    
42. break;
    
43. case TWI_STX_DATA_NACK: // Data byte in TWDR has been transmitted; NACK has been received.
    
44. // I.e. this could be the end of the transmission.
    
45. if (TWI_bufPtr == TWI_msgSize) // Have we transceived all expected data?
    
46. {
    
47. TWI_statusReg.lastTransOK = TRUE; // Set status bits to completed successfully.
    
48. }
    
49. else // Master has sent a NACK before all data where sent.
    
50. {
    
51. TWI_state = TWSR; // Store TWI State as errormessage.
    
52. }
    
53. 
    
54. TWCR = (1<
55. (1<
56. (1<
57. (0<
58. 
    
59. TWI_busy = 0; // Transmit is finished, we are not busy anymore
    
60. break;
    
61. case TWI_SRX_GEN_ACK: // General call address has been received; ACK has been returned
    
62. // case TWI_SRX_GEN_ACK_M_ARB_LOST: // Arbitration lost in SLA+R/W as Master; General call address has been received; ACK has been returned
    
63. TWI_statusReg.genAddressCall = TRUE;
    
64. case TWI_SRX_ADR_ACK: // Own SLA+W has been received ACK has been returned
    
65. // case TWI_SRX_ADR_ACK_M_ARB_LOST: // Arbitration lost in SLA+R/W as Master; own SLA+W has been received; ACK has been returned
    
66. // Dont need to clear TWI_S_statusRegister.generalAddressCall due to that it is the default state.
    
67. TWI_statusReg.RxDataInBuf = TRUE;
    
68. TWI_bufPtr = 0; // Set buffer pointer to first data location
    
69. 
    
70. // Reset the TWI Interupt to wait for a new event.
    
71. TWCR = (1<
72. (1<
73. (1<
74. (0<
75. TWI_busy = 1;
    
76. 
    
77. break;
    
78. case TWI_SRX_ADR_DATA_ACK: // Previously addressed with own SLA+W; data has been received; ACK has been returned
    
79. case TWI_SRX_GEN_DATA_ACK: // Previously addressed with general call; data has been received; ACK has been returned
    
80. TWI_buf[TWI_bufPtr++] = TWDR;
    
81. TWI_statusReg.lastTransOK = TRUE; // Set flag transmission successfull.
    
82. // Reset the TWI Interupt to wait for a new event.
    
83. TWCR = (1<
84. (1<
85. (1<
86. (0<
87. TWI_busy = 1;
    
88. break;
    
89. case TWI_SRX_STOP_RESTART: // A STOP condition or repeated START condition has been received while still addressed as Slave
    
90. // Enter not addressed mode and listen to address match
    
91. TWCR = (1<
92. (1<
93. (1<
94. (0<
95. 
    
96. TWI_busy = 0; // We are waiting for a new address match, so we are not busy
    
97. 
    
98. break;
    
99. case TWI_SRX_ADR_DATA_NACK: // Previously addressed with own SLA+W; data has been received; NOT ACK has been returned
    
100. case TWI_SRX_GEN_DATA_NACK: // Previously addressed with general call; data has been received; NOT ACK has been returned
     
101. case TWI_STX_DATA_ACK_LAST_BYTE: // Last data byte in TWDR has been transmitted (TWEA = ??; ACK has been received
     
102. // case TWI_NO_STATE // No relevant state information available; TWINT = ??
     
103. case TWI_BUS_ERROR: // Bus error due to an illegal START or STOP condition
     
104. TWI_state = TWSR; //Store TWI State as errormessage, operation also clears noErrors bit
     
105. TWCR = (1<
106. break;
     
107. default:
     
108. TWI_state = TWSR; // Store TWI State as errormessage, operation also clears the Success bit.
     
109. TWCR = (1<
110. (1<
111. (1<
112. (0<
113. 
     
114. TWI_busy = 0; // Unknown status, so we wait for a new address match that might be something we can handle
     
115. }
     
116. }
     

复制代码

sdgf

好资料啊  收下了 歇息