//***************************************************************************** // // Writes a single byte to an address in the I2C-attached EEPROM device. // // \param ucAddr is the EEPROM address to write. // \param ucData is the data byte to write. // // This function writes a single byte to the I2C-attached EEPROM on the // daughter board. The location to write is passed in parameter \e ucAddr // where values 0 to 127 are valid (this is a 128 byte EEPROM). // // This is not used in this particular application but is included for // completeness. // // \return Returns \b true on success of \b false on failure. // //***************************************************************************** static tBoolean EEPROMWritePolled(unsigned char ucAddr, unsigned char ucData) { // // Start with a dummy write to get the address set in the EEPROM. // ROM_I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, ID_I2C_ADDR, false); // // Place the address to be written in the data register. // ROM_I2CMasterDataPut(I2C0_MASTER_BASE, ucAddr); // // Start a burst send, sending the device address as the first byte. // ROM_I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START); // // Wait until the current byte has been transferred. // if(!WaitI2CFinished()) { return(false); } // // Write the value to be written to the flash. // ROM_I2CMasterDataPut(I2C0_MASTER_BASE, ucData); // // Send the data byte. // ROM_I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH); // // Wait until the current byte has been transferred. // if(!WaitI2CFinished()) { return(false); } // // Delay 5mS to allow the write to complete. We should really poll the // device waiting for an ACK but this is easier (and this code is only // for testcase use so this should be safe). // SysCtlDelay(ROM_SysCtlClockGet() / (200 * 3)); // // Tell the caller we wrote the required data. // return(true); }
int I2CRead(unsigned char slave, unsigned char address, unsigned int len, unsigned char * readdata, unsigned int readcnt) { unsigned long ulToRead; // Start with a dummy write to get the address set in the EEPROM. ROM_I2CMasterSlaveAddrSet(I2C_MASTER_BASE, slave, false); // Place the address to be written in the data register. ROM_I2CMasterDataPut(I2C_MASTER_BASE, address); // Perform a single send, writing the address as the only byte. ROM_I2CMasterControl(I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START); // Wait until the current byte has been transferred. if(!WaitI2CFinished()) { return(false); } // Put the I2C master into receive mode. ROM_I2CMasterSlaveAddrSet(I2C_MASTER_BASE, slave, true); // Start the receive. ROM_I2CMasterControl(I2C_MASTER_BASE, ((readcnt > 1) ? I2C_MASTER_CMD_BURST_RECEIVE_START : I2C_MASTER_CMD_SINGLE_RECEIVE)); // Receive the required number of bytes. ulToRead = readcnt; while(ulToRead) { // Wait until the current byte has been read. while(ROM_I2CMasterIntStatus(I2C_MASTER_BASE, false) == 0){} // Fixes I2C transactions.. ? ROM_SysCtlDelay(1000); // Clear pending interrupt notification. ROM_I2CMasterIntClear(I2C_MASTER_BASE); // Read the received character. *readdata++ = ROM_I2CMasterDataGet(I2C_MASTER_BASE); ulToRead--; // Set up for the next byte if any more remain. if(ulToRead) { ROM_I2CMasterControl(I2C_MASTER_BASE, ((ulToRead == 1) ? I2C_MASTER_CMD_BURST_RECEIVE_FINISH : I2C_MASTER_CMD_BURST_RECEIVE_CONT)); } } return(readcnt - ulToRead); }
//***************************************************************************** // // Reads from the I2C-attached EEPROM device. // // \param pucData points to storage for the data read from the EEPROM. // \param ulOffset is the EEPROM address of the first byte to read. // \param ulCount is the number of bytes of data to read from the EEPROM. // // This function reads one or more bytes of data from a given address in the // ID EEPROM found on several of the development kit daughter boards. The // return code indicates whether the read was successful. // // \return Returns \b true on success of \b false on failure. // //***************************************************************************** static tBoolean EEPROMReadPolled(unsigned char *pucData, unsigned long ulOffset, unsigned long ulCount) { unsigned long ulToRead; // // Clear any previously signalled interrupts. // ROM_I2CMasterIntClear(I2C0_MASTER_BASE); // // Start with a dummy write to get the address set in the EEPROM. // ROM_I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, ID_I2C_ADDR, false); // // Place the address to be written in the data register. // ROM_I2CMasterDataPut(I2C0_MASTER_BASE, ulOffset); // // Perform a single send, writing the address as the only byte. // ROM_I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START); // // Wait until the current byte has been transferred. // if(!WaitI2CFinished()) { return(false); } // // Put the I2C master into receive mode. // ROM_I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, ID_I2C_ADDR, true); // // Start the receive. // ROM_I2CMasterControl(I2C0_MASTER_BASE, ((ulCount > 1) ? I2C_MASTER_CMD_BURST_RECEIVE_START : I2C_MASTER_CMD_SINGLE_RECEIVE)); // // Receive the required number of bytes. // ulToRead = ulCount; while(ulToRead) { // // Wait until the current byte has been read. // while(ROM_I2CMasterIntStatus(I2C0_MASTER_BASE, false) == 0) { } // // Clear pending interrupt notification. // ROM_I2CMasterIntClear(I2C0_MASTER_BASE); // // Read the received character. // *pucData++ = ROM_I2CMasterDataGet(I2C0_MASTER_BASE); ulToRead--; // // Set up for the next byte if any more remain. // if(ulToRead) { ROM_I2CMasterControl(I2C0_MASTER_BASE, ((ulToRead == 1) ? I2C_MASTER_CMD_BURST_RECEIVE_FINISH : I2C_MASTER_CMD_BURST_RECEIVE_CONT)); } } // // Tell the caller we read the required data. // return(true); }