common/I2C/USI_TWI_Master.c

   1 /*****************************************************************************\r
   2 *\r
   3 * Atmel Corporation\r
   4 *\r
   5 * File              : USI_TWI_Master.c\r
   6 * Compiler          : AVRGCC Toolchain version 3.4.2\r
   7 * Revision          : $Revision: 992 $\r
   8 * Date              : $Date: 2013-11-07 $\r
   9 * Updated by        : $Author: Atmel $\r
  10 *\r
  11 * Support mail      : avr@atmel.com\r
  12 *\r
  13 * Supported devices : All device with USI module can be used.\r
  14 *                     The example is written for the ATmega169, ATtiny26 and ATtiny2313\r
  15 *\r
  16 * AppNote           : AVR310 - Using the USI module as a TWI Master\r
  17 *\r
  18 * Description       : This is an implementation of an TWI master using\r
  19 *                     the USI module as basis. The implementation assumes the AVR to\r
  20 *                     be the only TWI master in the system and can therefore not be\r
  21 *                     used in a multi-master system.\r
  22 * Usage             : Initialize the USI module by calling the USI_TWI_Master_Initialise() \r
  23 *                     function. Hence messages/data are transceived on the bus using\r
  24 *                     the USI_TWI_Transceive() function. The transceive function \r
  25 *                     returns a status byte, which can be used to evaluate the \r
  26 *                     success of the transmission.\r
  27 *\r
  28 ****************************************************************************/\r
  29 \r
  30 #ifdef  __4MHZ__\r
  31 #define F_CPU 4000000UL\r
  32 #else\r
  33 #define F_CPU 8000000UL\r
  34 #endif\r
  35 #include <avr/io.h>\r
  36 #include "TWI_Master.h"\r
  37 #include <util/delay.h>\r
  38 \r
  39 unsigned char USI_TWI_Master_Transfer( unsigned char );\r
  40 unsigned char USI_TWI_Master_Stop( void );\r
  41 \r
  42 union  USI_TWI_state\r
  43 {\r
  44   unsigned char errorState;         // Can reuse the TWI_state for error states due to that it will not be need if there exists an error.\r
  45   struct\r
  46   {\r
  47     unsigned char addressMode         : 1;\r
  48     unsigned char masterWriteDataMode : 1;\r
  49     unsigned char unused              : 6;\r
  50   }; \r
  51 }   USI_TWI_state;\r
  52 \r
  53 /*---------------------------------------------------------------\r
  54  USI TWI single master initialization function\r
  55 ---------------------------------------------------------------*/\r
  56 void USI_TWI_Master_Initialise( void )\r
  57 {\r
  58   PORT_USI |= (1<<PIN_USI_SDA);           // Enable pullup on SDA, to set high as released state.\r
  59   PORT_USI |= (1<<PIN_USI_SCL);           // Enable pullup on SCL, to set high as released state.\r
  60   \r
  61   DDR_USI  |= (1<<PIN_USI_SCL);           // Enable SCL as output.\r
  62   DDR_USI  |= (1<<PIN_USI_SDA);           // Enable SDA as output.\r
  63   \r
  64   USIDR    =  0xFF;                       // Preload dataregister with "released level" data.\r
  65   USICR    =  (0<<USISIE)|(0<<USIOIE)|                            // Disable Interrupts.\r
  66               (1<<USIWM1)|(0<<USIWM0)|                            // Set USI in Two-wire mode.\r
  67               (1<<USICS1)|(0<<USICS0)|(1<<USICLK)|                // Software stobe as counter clock source\r
  68               (0<<USITC);\r
  69   USISR   =   (1<<USISIF)|(1<<USIOIF)|(1<<USIPF)|(1<<USIDC)|      // Clear flags,\r
  70               (0x0<<USICNT0);                                     // and reset counter.\r
  71 }\r
  72 \r
  73 /*---------------------------------------------------------------\r
  74 Use this function to get hold of the error message from the last transmission\r
  75 ---------------------------------------------------------------*/\r
  76 unsigned char USI_TWI_Get_State_Info( void )\r
  77 {\r
  78   return ( USI_TWI_state.errorState );                            // Return error state.\r
  79 }\r
  80 \r
  81 /*---------------------------------------------------------------\r
  82  USI Transmit and receive function. LSB of first byte in data \r
  83  indicates if a read or write cycles is performed. If set a read\r
  84  operation is performed.\r
  85 \r
  86  Function generates (Repeated) Start Condition, sends address and\r
  87  R/W, Reads/Writes Data, and verifies/sends ACK.\r
  88  \r
  89  Success or error code is returned. Error codes are defined in \r
  90  USI_TWI_Master.h\r
  91 ---------------------------------------------------------------*/\r
  92 unsigned char USI_TWI_Start_Transceiver_With_Data( unsigned char *msg, unsigned char msgSize)\r
  93 {\r
  94   unsigned char tempUSISR_8bit = (1<<USISIF)|(1<<USIOIF)|(1<<USIPF)|(1<<USIDC)|      // Prepare register value to: Clear flags, and\r
  95                                  (0x0<<USICNT0);                                     // set USI to shift 8 bits i.e. count 16 clock edges.\r
  96   unsigned char tempUSISR_1bit = (1<<USISIF)|(1<<USIOIF)|(1<<USIPF)|(1<<USIDC)|      // Prepare register value to: Clear flags, and\r
  97                                  (0xE<<USICNT0);                                     // set USI to shift 1 bit i.e. count 2 clock edges.\r
  98 \r
  99   USI_TWI_state.errorState = 0;\r
 100   USI_TWI_state.addressMode = TRUE;\r
 101 \r
 102 #ifdef PARAM_VERIFICATION\r
 103   if(msg > (unsigned char*)RAMEND)                 // Test if address is outside SRAM space\r
 104   {\r
 105     USI_TWI_state.errorState = USI_TWI_DATA_OUT_OF_BOUND;\r
 106     return (FALSE);\r
 107   }\r
 108   if(msgSize <= 1)                                 // Test if the transmission buffer is empty\r
 109   {\r
 110     USI_TWI_state.errorState = USI_TWI_NO_DATA;\r
 111     return (FALSE);\r
 112   }\r
 113 #endif\r
 114 \r
 115 #ifdef NOISE_TESTING                                // Test if any unexpected conditions have arrived prior to this execution.\r
 116   if( USISR & (1<<USISIF) )\r
 117   {\r
 118     USI_TWI_state.errorState = USI_TWI_UE_START_CON;\r
 119     return (FALSE);\r
 120   }\r
 121   if( USISR & (1<<USIPF) )\r
 122   {\r
 123     USI_TWI_state.errorState = USI_TWI_UE_STOP_CON;\r
 124     return (FALSE);\r
 125   }\r
 126   if( USISR & (1<<USIDC) )\r
 127   {\r
 128     USI_TWI_state.errorState = USI_TWI_UE_DATA_COL;\r
 129     return (FALSE);\r
 130   }\r
 131 #endif\r
 132 \r
 133   if ( !(*msg & (1<<TWI_READ_BIT)) )                // The LSB in the address byte determines if is a masterRead or masterWrite operation.\r
 134   {\r
 135     USI_TWI_state.masterWriteDataMode = TRUE;\r
 136   }\r
 137 \r
 138 /* Release SCL to ensure that (repeated) Start can be performed */\r
 139   PORT_USI |= (1<<PIN_USI_SCL);                     // Release SCL.\r
 140   while( !(PIN_USI & (1<<PIN_USI_SCL)) );          // Verify that SCL becomes high.\r
 141 #ifdef TWI_FAST_MODE\r
 142   _delay_us( T4_TWI/4 );                         // Delay for T4TWI if TWI_FAST_MODE\r
 143 #else\r
 144   _delay_us( T2_TWI/4 );                         // Delay for T2TWI if TWI_STANDARD_MODE\r
 145 #endif\r
 146 \r
 147 /* Generate Start Condition */\r
 148   PORT_USI &= ~(1<<PIN_USI_SDA);                    // Force SDA LOW.\r
 149   _delay_us( T4_TWI/4 );                         \r
 150   PORT_USI &= ~(1<<PIN_USI_SCL);                    // Pull SCL LOW.\r
 151   PORT_USI |= (1<<PIN_USI_SDA);                     // Release SDA.\r
 152 \r
 153 #ifdef SIGNAL_VERIFY\r
 154   if( !(USISR & (1<<USISIF)) )\r
 155   {\r
 156     USI_TWI_state.errorState = USI_TWI_MISSING_START_CON;  \r
 157     return (FALSE);\r
 158   }\r
 159 #endif\r
 160 \r
 161 /*Write address and Read/Write data */\r
 162   do\r
 163   {\r
 164     /* If masterWrite cycle (or inital address tranmission)*/\r
 165     if (USI_TWI_state.addressMode || USI_TWI_state.masterWriteDataMode)\r
 166     {\r
 167       /* Write a byte */\r
 168       PORT_USI &= ~(1<<PIN_USI_SCL);                // Pull SCL LOW.\r
 169       USIDR     = *(msg++);                        // Setup data.\r
 170       USI_TWI_Master_Transfer( tempUSISR_8bit );    // Send 8 bits on bus.\r
 171       \r
 172       /* Clock and verify (N)ACK from slave */\r
 173       DDR_USI  &= ~(1<<PIN_USI_SDA);                // Enable SDA as input.\r
 174       if( USI_TWI_Master_Transfer( tempUSISR_1bit ) & (1<<TWI_NACK_BIT) ) \r
 175       {\r
 176         if ( USI_TWI_state.addressMode )\r
 177           USI_TWI_state.errorState = USI_TWI_NO_ACK_ON_ADDRESS;\r
 178         else\r
 179           USI_TWI_state.errorState = USI_TWI_NO_ACK_ON_DATA;\r
 180         return (FALSE);\r
 181       }\r
 182       USI_TWI_state.addressMode = FALSE;            // Only perform address transmission once.\r
 183     }\r
 184     /* Else masterRead cycle*/\r
 185     else\r
 186     {\r
 187       /* Read a data byte */\r
 188       DDR_USI   &= ~(1<<PIN_USI_SDA);               // Enable SDA as input.\r
 189       *(msg++)  = USI_TWI_Master_Transfer( tempUSISR_8bit );\r
 190 \r
 191       /* Prepare to generate ACK (or NACK in case of End Of Transmission) */\r
 192       if( msgSize == 1)                            // If transmission of last byte was performed.\r
 193       {\r
 194         USIDR = 0xFF;                              // Load NACK to confirm End Of Transmission.\r
 195       }\r
 196       else\r
 197       {\r
 198         USIDR = 0x00;                              // Load ACK. Set data register bit 7 (output for SDA) low.\r
 199       }\r
 200       USI_TWI_Master_Transfer( tempUSISR_1bit );   // Generate ACK/NACK.\r
 201     }\r
 202   }while( --msgSize) ;                             // Until all data sent/received.\r
 203   \r
 204   USI_TWI_Master_Stop();                           // Send a STOP condition on the TWI bus.\r
 205 \r
 206 /* Transmission successfully completed*/\r
 207   return (TRUE);\r
 208 }\r
 209 \r
 210 /*---------------------------------------------------------------\r
 211  Core function for shifting data in and out from the USI.\r
 212  Data to be sent has to be placed into the USIDR prior to calling\r
 213  this function. Data read, will be return'ed from the function.\r
 214 ---------------------------------------------------------------*/\r
 215 unsigned char USI_TWI_Master_Transfer( unsigned char temp )\r
 216 {\r
 217   USISR = temp;                                     // Set USISR according to temp.\r
 218                                                     // Prepare clocking.\r
 219   temp  =  (0<<USISIE)|(0<<USIOIE)|                 // Interrupts disabled\r
 220            (1<<USIWM1)|(0<<USIWM0)|                 // Set USI in Two-wire mode.\r
 221            (1<<USICS1)|(0<<USICS0)|(1<<USICLK)|     // Software clock strobe as source.\r
 222            (1<<USITC);                              // Toggle Clock Port.\r
 223   do\r
 224   {\r
 225     _delay_us( T2_TWI/4 );              \r
 226     USICR = temp;                          // Generate positve SCL edge.\r
 227     while( !(PIN_USI & (1<<PIN_USI_SCL)) );// Wait for SCL to go high.\r
 228     _delay_us( T4_TWI/4 );              \r
 229     USICR = temp;                          // Generate negative SCL edge.\r
 230   }while( !(USISR & (1<<USIOIF)) );        // Check for transfer complete.\r
 231   \r
 232   _delay_us( T2_TWI/4 );                \r
 233   temp  = USIDR;                           // Read out data.\r
 234   USIDR = 0xFF;                            // Release SDA.\r
 235   DDR_USI |= (1<<PIN_USI_SDA);             // Enable SDA as output.\r
 236 \r
 237   return temp;                             // Return the data from the USIDR\r
 238 }\r
 239 \r
 240 /*---------------------------------------------------------------\r
 241  Function for generating a TWI Stop Condition. Used to release \r
 242  the TWI bus.\r
 243 ---------------------------------------------------------------*/\r
 244 unsigned char USI_TWI_Master_Stop( void )\r
 245 {\r
 246   PORT_USI &= ~(1<<PIN_USI_SDA);           // Pull SDA low.\r
 247   PORT_USI |= (1<<PIN_USI_SCL);            // Release SCL.\r
 248   while( !(PIN_USI & (1<<PIN_USI_SCL)) );  // Wait for SCL to go high.\r
 249   _delay_us( T4_TWI/4 );               \r
 250   PORT_USI |= (1<<PIN_USI_SDA);            // Release SDA.\r
 251   _delay_us( T2_TWI/4 );                \r
 252   \r
 253 #ifdef SIGNAL_VERIFY\r
 254   if( !(USISR & (1<<USIPF)) )\r
 255   {\r
 256     USI_TWI_state.errorState = USI_TWI_MISSING_STOP_CON;    \r
 257     return (FALSE);\r
 258   }\r
 259 #endif\r
 260 \r
 261   return (TRUE);\r
 262 }\r
 263 \r
 264 \r
 265 \r
 266 unsigned char I2c_WriteByte(unsigned char msg) {\r
 267   unsigned char tempUSISR_8bit = (1<<USISIF)|(1<<USIOIF)|(1<<USIPF)|(1<<USIDC)|      // Prepare register value to: Clear flags, and\r
 268   (0x0<<USICNT0);                                     // set USI to shift 8 bits i.e. count 16 clock edges.\r
 269   unsigned char tempUSISR_1bit = (1<<USISIF)|(1<<USIOIF)|(1<<USIPF)|(1<<USIDC)|      // Prepare register value to: Clear flags, and\r
 270   (0xE<<USICNT0);                                     // set USI to shift 1 bit i.e. count 2 clock edges.\r
 271 \r
 272         /* Write a byte */\r
 273         PORT_USI &= ~(1<<PIN_USI_SCL);                // Pull SCL LOW.\r
 274         USIDR     = msg;                        // Setup data.\r
 275         USI_TWI_Master_Transfer( tempUSISR_8bit );    // Send 8 bits on bus.\r
 276         /* Clock and verify (N)ACK from slave */\r
 277         DDR_USI  &= ~(1<<PIN_USI_SDA);                // Enable SDA as input.\r
 278         if( USI_TWI_Master_Transfer( tempUSISR_1bit ) & (1<<TWI_NACK_BIT) ){\r
 279                 if ( USI_TWI_state.addressMode )\r
 280                         USI_TWI_state.errorState = USI_TWI_NO_ACK_ON_ADDRESS;\r
 281                 else\r
 282                         USI_TWI_state.errorState = USI_TWI_NO_ACK_ON_DATA;\r
 283                 return 2;\r
 284         }\r
 285         return 0;\r
 286 }\r
 287 unsigned char I2c_ReadByte(unsigned char ack_mode) {\r
 288   unsigned char tempUSISR_8bit = (1<<USISIF)|(1<<USIOIF)|(1<<USIPF)|(1<<USIDC)|      // Prepare register value to: Clear flags, and\r
 289   (0x0<<USICNT0);                                     // set USI to shift 8 bits i.e. count 16 clock edges.\r
 290   unsigned char tempUSISR_1bit = (1<<USISIF)|(1<<USIOIF)|(1<<USIPF)|(1<<USIDC)|      // Prepare register value to: Clear flags, and\r
 291   (0xE<<USICNT0);                                     // set USI to shift 1 bit i.e. count 2 clock edges.\r
 292         \r
 293         /* Read a data byte */\r
 294         DDR_USI   &= ~(1<<PIN_USI_SDA);               // Enable SDA as input.\r
 295     unsigned char msg = USI_TWI_Master_Transfer( tempUSISR_8bit );\r
 296 \r
 297     /* Prepare to generate ACK (or NACK in case of End Of Transmission) */\r
 298     if( ack_mode == NO_ACK) {                           // If transmission of last byte was performed.\r
 299                 USIDR = 0xFF;                              // Load NACK to confirm End Of Transmission.\r
 300     } else   {\r
 301                 USIDR = 0x00;                              // Load ACK. Set data register bit 7 (output for SDA) low.\r
 302     }\r
 303     USI_TWI_Master_Transfer( tempUSISR_1bit );   // Generate ACK/NACK.\r
 304         return msg;\r
 305 }\r
 306 \r
 307 void I2c_StartCondition(void) {\r
 308 /* Release SCL to ensure that (repeated) Start can be performed */\r
 309 PORT_USI |= (1<<PIN_USI_SCL);                     // Release SCL.\r
 310 while( !(PIN_USI & (1<<PIN_USI_SCL)) );          // Verify that SCL becomes high.\r
 311 #ifdef TWI_FAST_MODE\r
 312 _delay_us( T4_TWI/4 );                         // Delay for T4TWI if TWI_FAST_MODE\r
 313 #else\r
 314 _delay_us( T2_TWI/4 );                         // Delay for T2TWI if TWI_STANDARD_MODE\r
 315 #endif\r
 316 \r
 317 /* Generate Start Condition */\r
 318 PORT_USI &= ~(1<<PIN_USI_SDA);                    // Force SDA LOW.\r
 319 _delay_us( T4_TWI/4 );\r
 320 PORT_USI &= ~(1<<PIN_USI_SCL);                    // Pull SCL LOW.\r
 321 PORT_USI |= (1<<PIN_USI_SDA);                     // Release SDA.\r
 322         \r
 323         \r
 324 }\r
 325 void I2c_StopCondition(void) {\r
 326         USI_TWI_Master_Stop();\r
 327 }\r