BOOL I2C_startTransfer(I2C_MODULE I2C_ID, BOOL restart){ I2C_STATUS status; // Send the Start (or Restart) signal if(restart){ if(I2CRepeatStart(I2C_ID) != I2C_SUCCESS){ #ifdef DEBUG printf("Error: Bus collision during transfer Start at Read\n"); #endif return FALSE; } } else{ // Wait for the bus to be idle, then start the transfer while( !I2CBusIsIdle(I2C_ID) ); if(I2CStart(I2C_ID) != I2C_SUCCESS){ #ifdef DEBUG printf("Error: Bus collision during transfer Start at Write\n"); #endif return FALSE; } } // Wait for the signal to complete do{ status = I2CGetStatus(I2C_ID); } while (!(status & I2C_START) ); return TRUE; }
/****** I2C Driver implementation *******/ static bool StartTransfer(I2C_MODULE i2c_id, bool restart) { I2C_STATUS status; // Send the Start (or Restart) signal if (restart) { I2CRepeatStart(i2c_id); } else { // Wait for the bus to be idle, then start the transfer while (!I2CBusIsIdle(i2c_id)); if (I2CStart(i2c_id) != I2C_SUCCESS) { //DBPRINTF("Error: Bus collision during transfer Start\n"); return FALSE; } } // Wait for the signal to complete do { status = I2CGetStatus(i2c_id); } while (!(status & I2C_START)); return TRUE; }
/* Sends a start to begin i2c transaction (with no strings attached) */ void sendStart(I2C_MODULE i2c){ while( ! I2CBusIsIdle(i2c)); DelayMs(2); // timing for ADXL345 I2CStart(i2c); while( ! (I2CGetStatus(i2c) & I2C_START) ); I2CClearStatus(i2c, I2C_START); }
//============================================================================== BOOL i2c_Start(UINT8 restart ) { I2C_STATUS status; // Send the Start (or Restart) signal if(restart) { //I2CRepeatStart(EEPROM_I2C_BUS); I2C1CONbits.RSEN = 1; } else { // Wait for the bus to be idle, then start the transfer while( !I2CBusIsIdle(EEPROM_I2C_BUS) ); if(I2CStart(EEPROM_I2C_BUS) != I2C_SUCCESS) { DBPRINTF("Error: Bus collision during transfer Start\n"); return FALSE; } } // Wait for the signal to complete do { status = I2CGetStatus(EEPROM_I2C_BUS); } while ( !(status & I2C_START) ); return TRUE; }
int transfer_start(I2C_MODULE port, I2C_7_BIT_ADDRESS address, UINT8 rw) { I2C_STATUS status; int result = 0; while(!I2CBusIsIdle(port)); if(I2CStart(port) != I2C_SUCCESS) return -1; do { status = I2CGetStatus(port); } while(!(status & I2C_START)); /* Send address */ address.rw = rw; result = transmit_byte(port, address.byte); if(result < 0) return result; if(!I2CByteWasAcknowledged(port)) return -1; return result; }
/** * Invokes an I2C stop condition * */ void I2C_StopTransfer() { // Send the Stop signal I2CStop(I2C1); // Wait for the signal to complete while (!(I2CGetStatus(I2C1) & I2C_STOP)); }
static int transfer_stop(I2C_MODULE port) { I2C_STATUS status; I2CStop(port); do { status = I2CGetStatus(port); } while(!(status & I2C_STOP)); }
/************************************************************************************************** Function: void I2CShared_StopTransfer(const I2C_MODULE i2c) Author(s): mkobit Summary: Stops a transaction on the (i2c) module Description: Sends a stop signal and waits until the signal is complete Static function, used by internal library Preconditions: I2C module configured Parameters: const I2C_MODULE i2c - I2C module to be used for this transaction Returns: void Example: <code> I2CShared_StopTransfer(I2C1) </code> Conditions at Exit: I2C bus idle **************************************************************************************************/ static void I2CShared_StopTransfer(const I2C_MODULE i2c) { I2C_STATUS status; // Send the Stop signal I2CStop(i2c); // Wait for the signal to complete do { status = I2CGetStatus(i2c); } while (!(status & I2C_STOP)); }
void I2C_stopTransfer(I2C_MODULE I2C_ID){ I2C_STATUS status; // Send the Stop signal I2CStop(I2C_ID); // Wait for the signal to complete do{ status = I2CGetStatus(I2C_ID); } while (!(status & I2C_STOP)); }
void StopTransfer( void ) { I2C_STATUS status; // Send the Stop signal I2CStop(PIC24_I2C_BUS); // Wait for the signal to complete do { status = I2CGetStatus(PIC24_I2C_BUS); } while ( !(status & I2C_STOP) ); }
//============================================================================== void i2c_Stop( void ) { I2C_STATUS status; // Send the Stop signal I2CStop(EEPROM_I2C_BUS); // Wait for the signal to complete do { status = I2CGetStatus(EEPROM_I2C_BUS); } while ( !(status & I2C_STOP) ); }
/************************************************************************************************** Function: static void I2CShared_DebugStatus(const I2C_MODULE i2c) Author(s): mkobit Summary: Prints out statuses of the I2C module that is passed in Description: Useful for debugging when errors occur to see what the current state of the I2C module is Static function, used by internal library Preconditions: I2C module UART2 preconfigured as debugging output Parameters: const I2C_MODULE i2c - I2C module to print out status messages Returns: void Example: <code> I2CShared_DebugStatus(I2C1) </code> Conditions at Exit: None **************************************************************************************************/ static void I2CShared_DebugStatus(const I2C_MODULE i2c) { I2C_STATUS status; status = I2CGetStatus(i2c); if (I2C_TRANSMITTER_FULL & status) { //printf("I2CShared_DebugStatus: I2C_TRANSMITTER_FULL, 0x%x\n", I2C_TRANSMITTER_FULL & status); } if (I2C_DATA_AVAILABLE & status) { //printf("I2CShared_DebugStatus:) I2C_DATA_AVAILABLE, 0x%x\n", I2C_DATA_AVAILABLE & status); } if (I2C_SLAVE_READ & status) { //printf("I2CShared_DebugStatus:) I2C_SLAVE_READ, 0x%x\n", I2C_SLAVE_READ & status); } if (I2C_START & status) { //printf("I2CShared_DebugStatus: I2C_START, 0x%x\n", I2C_START & status); } if (I2C_STOP & status) { //printf("I2CShared_DebugStatus: I2C_STOP, 0x%x\n", I2C_STOP & status); } if (I2C_SLAVE_DATA & status) { //printf("I2CShared_DebugStatus: I2C_SLAVE_DATA, 0x%x\n", I2C_SLAVE_DATA & status); } if (I2C_RECEIVER_OVERFLOW & status) { //printf("I2CShared_DebugStatus: I2C_RECEIVER_OVERFLOW, 0x%x\n", I2C_RECEIVER_OVERFLOW & status); } if (I2C_TRANSMITTER_OVERFLOW & status) { //printf("I2CShared_DebugStatus: I2C_TRANSMITTER_OVERFLOW, 0x%x\n", I2C_TRANSMITTER_FULL & status); } if (I2C_10BIT_ADDRESS & status) { //printf("I2CShared_DebugStatus: I2C_10BIT_ADDRESS, 0x%x\n", I2C_10BIT_ADDRESS & status); } if (I2C_GENERAL_CALL & status) { //printf("I2CShared_DebugStatus: I2C_GENERAL_CALL, 0x%x\n", I2C_GENERAL_CALL & status); } if (I2C_ARBITRATION_LOSS & status) { //printf("I2CShared_DebugStatus: I2C_ARBITRATION_LOSS, 0x%x\n", I2C_ARBITRATION_LOSS & status); } if (I2C_TRANSMITTER_BUSY & status) { //printf("I2CShared_DebugStatus: I2C_TRANSMITTER_BUSY, 0x%x\n", I2C_TRANSMITTER_BUSY & status); } if (I2C_BYTE_ACKNOWLEDGED & status) { //printf("I2CShared_DebugStatus: I2C_BYTE_ACKNOWLEDGE, 0x%x\n", I2C_BYTE_ACKNOWLEDGED & status); } if (status == 0) { //printf("I2CShared_DebugStatus: no status\n"); } }
/** * Invokes an I2C start condition * * @param restart invoke a restart condition if true */ void I2C_StartTransfer(bool restart) { // Send the Start (or Restart) signal if (restart) { I2CRepeatStart(I2C1); } else { // Wait for the bus to be idle, then start the transfer while (!I2CBusIsIdle(I2C1)); if (I2CStart(I2C1) != I2C_SUCCESS) { //serialPrint("Error: Bus collision during transfer Start\r\n"); while (1); } } // Wait for the signal to complete while (!(I2CGetStatus(I2C1) & I2C_START)); }
/************************************************************************************************** Function: static BOOL I2CShared_StartTransfer(const I2C_MODULE i2c, const BOOL restart) Author(s): mkobit Summary: Starts or restarts a transaction Description: Blocks until transaction has been started, restarts the transaction if (restart) is TRUE Static function, used by internal library Preconditions: I2C module configured *Transaction started - *only if (restart) is TRUE Parameters: const I2C_MODULE i2c - I2C module to be used for this transaction const BOOL restart - restart transaction when TRUE, just start when FALSE Returns: TRUE - If successful FALSE - If unsuccessful Example: <code> I2CShared_StartTransfer(i2c, FALSE) </code> Conditions at Exit: Bus transaction started I2C waiting for next action **************************************************************************************************/ static BOOL I2CShared_StartTransfer(const I2C_MODULE i2c, const BOOL restart) { I2C_STATUS status; int fault_count = 0; // Send the start/restart signal if(restart) { I2CRepeatStart(i2c); } else { // Wait for the bus to be idle, then start the transfer while(!I2CBusIsIdle(i2c)){ if (fault_count++ == TIMEOUT) { //printf("I2CShared_StartTransfer: Timeout waiting for bus to be idle\n"); return FALSE; } } if(I2CStart(i2c) == I2C_ARBITRATION_LOSS) { //printf("I2CShared_StartTransfer: I2CStart experienced I2C_ARBITRATION_LOSS\n"); //I2CShared_DebugStatus(i2c); return FALSE; } } fault_count = 0; // Wait for the signal to complete do { status = I2CGetStatus(i2c); if (status & I2C_ARBITRATION_LOSS) { //printf("I2CShared_StartTransfer: lost arbitration on i2c bus\n"); return FALSE; } if (fault_count++ == TIMEOUT) { //printf("I2CShared_StartTransfer: Timeout waiting for bus to start\n"); return FALSE; } } while (!(status & I2C_START)); return TRUE; }
void MPU6050::StopTransfer( void ) { I2C_STATUS status; UINT8 count = 0; // Send the Stop signal I2CStop( this->i2cBusId ); // Wait for the signal to complete do { status = I2CGetStatus( this->i2cBusId ); count++; } while ( !(status & I2C_STOP) && count < 200); if ( count >= 200 ) { sprintf( filename, "Error: StopTransfer(). Loop timeout for I2CGetStatus().\n" ); putsUART1( filename ); } }
void i2c1_interrupt_handler(void) { unsigned long woken = FALSE; int status = I2CGetStatus(I2C1); if (state == I2C_STATE_START && !(status & I2C_TRANSMITTER_BUSY)) { } else if (state == I2C_STATE_TRANSMIT && !(status & I2C_TRANSMITTER_FULL)) { } else if (state == I2C_STATE_REPEATED_START && !(status & I2C_TRANSMITTER_BUSY)) { } else if (state == I2C_STATE_STOP && !(status & I2C_STOP)) { } else if (state == I2C_STATE_RECEIVE && !(status & I2C_DATA_AVAILABLE)) { } else if (state == I2C_STATE_ACKNOWLEDGE && !(status & I2C_TRANSMITTER_BUSY)) { } else { return; } semaphore_give_from_isr(bus_lock, &woken); }
BOOL StartTransfer( BOOL restart ) { I2C_STATUS status; // Send the Start (or Restart) signal if(restart) { I2CRepeatStart(PIC24_I2C_BUS); } else { // Wait for the bus to be idle, then start the transfer while( !I2CBusIsIdle(PIC24_I2C_BUS) ); if(I2CStart(PIC24_I2C_BUS) != I2C_SUCCESS) { DBPRINTF("Error: Bus collision during transfer Start\n"); printf("bus coll\n"); //Succ = FALSE; //goto RECOVER; } } // Wait for the signal to complete do { status = I2CGetStatus(PIC24_I2C_BUS); //printf("waiting for signal\n"); } while ( !(status & I2C_START) ); RECOVER: //if(!Succ) return FALSE; //else return TRUE; return TRUE; }
BOOL MPU6050::StartTransfer( BOOL restart ) { I2C_STATUS status = I2C_START; //UINT16 count = 0; //sprintf(filename, "Starting StartTransfer(), status = %d.\n", status); //putsUART1( filename ); // Send the Start (or Restart) signal if(restart) { I2C_RESULT res = I2C_SUCCESS; if((res = I2CRepeatStart( this->i2cBusId )) != I2C_SUCCESS) { sprintf(filename, "Repeat start, status = %d.\n",res); putsUART1( filename ); // Do not return, try to connect anyway and fail } } else { // Wait for the bus to be idle, then start the transfer //while( !I2CBusIsIdle(MPU6050_I2C_BUS) ); // Checks if the bus is idle, and starts the transfer if so if( I2CBusIsIdle( this->i2cBusId ) ) { if(I2CStart( this->i2cBusId ) != I2C_SUCCESS) { //DBPRINTF("Error: Bus collision during transfer Start\n"); sprintf( filename, "Error in I2CStart(). Bus collision on bus %u during transfer Start.\n", (unsigned)this->i2cBusId ); putsUART1( filename ); return FALSE; } } else { sprintf( filename, "Error in I2CBusIsIdle(). Bus %u is not idle.\n", (unsigned)this->i2cBusId ); putsUART1( filename ); return FALSE; } } //sprintf( filename, "StartTransfer(). Checking for Start response...\n" ); //putsUART1( filename ); UINT16 max_tries = 64000, count = 0; // Wait for the signal to complete or until tries are out do { status = I2CGetStatus( this->i2cBusId ); //sprintf( filename, "StartTransfer(). Status is %u \n", status & I2C_START ); //putsUART1( filename ); } while (!(status & I2C_START) && ++count < max_tries); if( count >= max_tries ) { sprintf( filename, "Error in StartTransfer(). Timeout!\n" ); putsUART1( filename ); return FALSE; } //sprintf( filename, "StartTransfer(). Function successfully completed!\n" ); //putsUART1( filename ); return TRUE; }
void i2cStart(I2C_MODULE id){ while( !I2CBusIsIdle(id) ); I2CStart(id); while ( !(I2CGetStatus(id) & I2C_START) ); }void i2cSendByte(I2C_MODULE id, BYTE data){
void i2cRepeatedStart(I2C_MODULE id){ I2CRepeatStart(id); while ( !(I2CGetStatus(id) & I2C_START) ); }
void i2cStop(I2C_MODULE id){ I2CStop(id); while ( !(I2CGetStatus(id) & I2C_STOP) ); }
/* Sends a start inside i2c transaction (with no strings attached) */ void repeatStart(I2C_MODULE I2C){ I2CRepeatStart(I2C); while( ! (I2CGetStatus(I2C) & I2C_START) ); I2CClearStatus(I2C, I2C_START); }
//************************************************************ // Synchronous READ - I2C API (visible externally) component //************************************************************ uint I2CSyncRead( uint I2Cx, byte DevAddr, byte Register, byte* Buffer, uint BufLen ) { if (!_I2C_Init) return I2CRC_NRDY; //========================================================= // Obtain references to proper Control Blocks and registers //--------------------------------------------------------- _I2C_CB* pCB; if ( NULL == (pCB = I2CpCB(I2Cx)) ) return I2CRC_NOTA; //--------------------------------------------------------- I2C_CONBITS* pCON = I2CpCON(pCB); I2C_STATBITS* pSTAT = I2CpSTAT(pCB); //========================================================= // Validate run-time conditions //--------------------------------------------------------- uint RC; BYTE CPU_IPL; uint RetryCount = 0; //--------------------------------------------------------- // Enter I2C (and related modules) CRITICAL SECTION //--------------------------------------------------------- Retry: RC = I2CRC_OK; //------------------------------------ SET_AND_SAVE_CPU_IPL(CPU_IPL, _I2C_IL); { if (I2CRC_OK == (RC=I2CGetStatus(pCB, pCON, pSTAT))) //--------------------------------------------------------- // Set Flag indicating Synchronous operation is in progress //--------------------------------------------------------- pCB->_I2C_SBSY = 1; // Should be cleared at exit } //--------------------------------------------------------- // Leave I2C CRITICAL SECTION //--------------------------------------------------------- RESTORE_CPU_IPL(CPU_IPL); //========================================================= switch (RC) { case I2CRC_OK: break; // Run-time conditions are OK //------------------------------------------- case I2CRC_ABSY: case I2CRC_SBSY: case I2CRC_BUSY: // Situation could be helped by delay/retry if (RetryCount < I2C_BUSYRetry) { TMRDelayTicks(1); // Small delay ~125 usec RetryCount++; goto Retry; // Attempt retry } else; // Fall through to "default" //------------------------------------------- default: return RC; // Run-time conditions are not met } //========================================================= //--------------------------------------------------------- // Event sequence to accomplish simple READ from the target // slave device in the MASTER mode: // 1. Assert a Start condition on SDAx and SCLx. // 2. Send the I2C device address byte to the slave with a // read indication ("1" in the LSB of address) // 3. Wait for and verify an Acknowledge from the slave. // 4. Assert receiving state (RCEN = 1). // 5. Receive byte and send ACK to the slave. // 6. Repeat steps 4 and 5 for every byte in a message, // except the last - after receiving last byte send NACK. // 7. Generate a Stop condition on SDAx and SCLx. //--------------------------------------------------------- // Prepare READ and WRITE forms of device address byte i2cAddrW = DevAddr & 0xFE; // Set WRITE cond. byte i2cAddrR = DevAddr | 0x01; // Set READ cond. //--------------------------------------------------------- RC = I2CRC_OK; //--------------------------------------------------------- I2CStart(pCB); // Signal START on SDA and SCL pins //--------------------------------------------------------- // Send Device WRITE address //--------------------------------------------------------- RC = I2CMasterWriteByte(pCB, i2cAddrW); if (RC != I2CRC_OK) goto Finally; //--------------------------------------------------------- // Send Register address (as data)) //--------------------------------------------------------- RC = I2CMasterWriteByte(pCB, Register); if (RC != I2CRC_OK) goto Finally; //--------------------------------------------------------- I2CReStart(pCB); // Signal Repeated-START on SDA and SCL pins //--------------------------------------------------------- // Send Device READ address //--------------------------------------------------------- RC = I2CMasterWriteByte(pCB, i2cAddrR); if (RC != I2CRC_OK) goto Finally; //--------------------------------------------------------- // Receive data //--------------------------------------------------------- pSTAT->I2COV = 0; // Clear receive OVERFLOW bit, if any //--------------------------------------------------------- uint BufPos; uint BufCnt = BufLen; //--------------------------------------------------------- for (BufPos = 0; BufPos < BufLen; BufPos++) { BufCnt--; // Used as a FLAG (BufCnt=0) to indicate last byte //--------------------------------------------------------- RC = I2CMasterReadByte(pCB, Buffer, BufCnt); if (RC != I2CRC_OK) break; // Error... Buffer++; } //--------------------------------------------------------- Finally: I2CStop(pCB); // Signal STOP on SDA and SCL pins //--------------------------------------------------------- pCB->_I2C_SBSY = 0; // Clear SYNC flag return RC; // Return last Error Code... }