通过寄存器 avr c Atmega328p 正确配置 I2C

Question

To expand my understanding and current knowledge of programming the Atmega series I've started my own little project. I've decided to program the MPU6050 I2C sensor by directly addressing it's registers. To test the sensor's working and connections I used this pre-written program first (using the Wire library provided by the Arduino platform):

#include<Wire.h>
const int MPU=0x68; 
int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;

void setup(){
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B); 
  Wire.write(0);    
  Wire.endTransmission(true);
  Serial.begin(9600);
}
void loop(){
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);  
  Wire.endTransmission(false);
  Wire.requestFrom(MPU,12,true);  
  AcX=Wire.read()<<8|Wire.read();    
  AcY=Wire.read()<<8|Wire.read();  
  AcZ=Wire.read()<<8|Wire.read();  
  GyX=Wire.read()<<8|Wire.read();  
  GyY=Wire.read()<<8|Wire.read();  
  GyZ=Wire.read()<<8|Wire.read();  

  Serial.print("Accelerometer: ");
  Serial.print("X = "); Serial.print(AcX);
  Serial.print(" | Y = "); Serial.print(AcY);
  Serial.print(" | Z = "); Serial.println(AcZ); 

  Serial.print("Gyroscope: ");
  Serial.print("X = "); Serial.print(GyX);
  Serial.print(" | Y = "); Serial.print(GyY);
  Serial.print(" | Z = "); Serial.println(GyZ);
  Serial.println(" ");
  delay(333);
}

The serial monitor displays correct readings from the sensor, stating the sensor is connected properly and working as it should. Simultaneously I've connected my bus pirate which sniffs the I2C bus and displays the hex values which are sent between the sensor and atmega chip (Atmega328p-pu). Although I can't translate them to their exact meaning, the communication looks normal.

After I've uploaded my own code, created using the datasheet of both the sensor and the Atmega328p, the I2C bus displays almost nothing. This is my code:

#include <Arduino.h>

#define DEBUG_LED_PIN PB5
#define DEBUG_LED_BANK DDRB

#define MPU6050_ADDR_WRITE 0x68
#define MPU6050_ADDR_READ 0x69


const uint8_t led_on = 0x01;
const uint8_t led_off = 0x00;

const uint8_t twi_write = 0x00;
const uint8_t twi_read = 0x01;

const uint8_t twi_start_transmitted = 0x08;
const uint8_t twi_repeated_start_transmitted = 0x10;
const uint8_t twi_ack_received_addr = 0x18;
const uint8_t twi_not_ack_received_addr = 0x20;
const uint8_t twi_ack_received_data = 0x28;
const uint8_t twi_not_ack_received_data = 0x30;
const uint8_t twi_arbitration_lost = 0x38;


void setup_debug_led();
void setup_twi();
void setup_mpu6050();

void control_debug_led(uint8_t status);

void send_data_to_device(uint8_t device_address, uint8_t* data, uint8_t data_length);
void send_start_signal();
void send_device_address(uint8_t device_address);
void send_data(uint8_t data);
void send_stop_signal();

void send_test_data_complete_sequence();


void setup() {
  setup_debug_led();
  control_debug_led(led_off);

  setup_twi(); // Setup i2c protocol
}

void loop() {
  // Test stuff
  send_test_data_complete_sequence();
}

void setup_twi()
{
  TWSR = 0;
  TWCR = 0;

  TWBR = 0x0C; // Set SCL to 400kHz
}

void send_test_data_complete_sequence()
{
  // 1.
  TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); // Write start condition

  // 2.
  while(!(TWCR & (1 << TWINT))); // Wait for TWINT flag set. Indicates START has been transmitted

  // 3.
  if((TWSR & 0xF8) != twi_start_transmitted) // Check value TWI status register, if equals 0x08 continue
  {
    // Handle exception call
  }

  // 4.
  TWDR = 0b11010000; // Load slave address including r/w bit

  // 5.
  TWCR = (1 << TWINT) | (1 << TWEN); // Clear TWINT bit to start tranmission

  // 6.
  while(!(TWCR & (1 << TWINT))); // Wait for TWINT flag set. Inidicates SLA+W has been transmitted

  // 7.
  if((TWSR & 0xF8) != twi_ack_received_addr) // Check for 0x18 (SLA+W ACK has been received)
  {
    // Handle exception call
  }

  // 8.
  TWDR = 0x6B; // Load data into TWDR

  // 9.
  TWCR = (1 << TWINT) | (1 << TWEN); // Clear TWINT bit to start data tranmission

  // 10.
  while(!(TWCR & (1 << TWINT))); // Wait for TWINT flag set. Inidicates data has been transmitted

  // 11.
  if((TWSR & 0xF8) != twi_ack_received_data) // Check for 0x28 (data ACK has been received)
  {
    // Handle exception
  }

  // 12.
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); // Write stop condition
}

The bus pirate shows the following communication data on the general bus: [][[][][[[]] It's nothing like the data I transfer into the buffer. And if I wait long enough I'll spot some incidental 0x0 or 0x00's.

I've tried changing the slave's address and the first data byte which is written to the sensor. The exceptions at steps 3, 7 and 11 are never triggered.

The pins A4 and A5 (SCL and SDA) are not touched in this code. I've tried configuring them as input with pull-up resistors enabled, which didn't give the desired results either.

The sensor is connected to the arduino as stated in the scheme below:

(Arduino)   (MPU6050)
A4 (SDA) -> SDA
A5 (SCL) -> SCL
VCC      -> VCC
GND      -> GND
GND      -> AD0

The bus pirate is connected in parallel with the SDA and SCL connections to intercept its data.

The Atmega328p's datasheet has a minor summary of all the steps needed to be taken to complete an I2C transfer. I've tried to correctly copy these steps (Section 21.6 'Using the TWI', table 21-2).

I was hoping you guys could spot my mistake or missing code. Thanks so much in advance!

Answer 1

It looks like you have not enabled TWI in your setup_twi() function.

You need to switch it on by setting the TWEN bit in the TWCR register as written in the datasheet:

The TWEN bit enables TWI operation and activates the TWI interface. When TWEN is written to one, the TWI takes control over the I/O pins connected to the SCL and SDA pins, enabling the slew-rate limiters and spike filters. If this bit is written to zero, the TWI is switched off and all TWI transmissions are terminated, regardless of any ongoing operation.

Answer 2

I decided to simulate the sensor using another Arduino configured as a I2C slave. And apparently the Arduino datasheet example code in table 21-2 'Assembly code example' is incorrect. Executing TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO); breaks the code execution. The TWINT must not be reset when transmitting the STOP signal. Changing this line to TWCR=(1<<TWEN)|(1<<TWSTO); did the trick.