Mpu6050 mit ATtiny817

[Nils K. (flying_nils)]

Hallo zusammen,
Ich möchte in eine Projekt den Sensor Mpu6050 verwenden und mit dem 
relativ neuen ATtiny817 auswerten. Allerdings gibt es keine fertige 
Library, wie bei Arduino. Ich habe ein I2C Programm aus einem anderen 
Forum gefunden und zu meinem Programm hinzugefügt 
(https://www.avrfreaks.net/comment/2294081).
Dieses Programm hat auch super mit einem angeschlossenen Arduino nano 
funktioniert. Ich habe auch ein Programm zum auslesen vom Mpu6050 
gefunden, das ohne I2C Library auskommt 
(https://www.avrfreaks.net/forum/mpu6050-pure-avr-c-328p-without-library-help-me-please). 
Allerdings musste ich einiges ändern, da I2C bei meinem ATtiny sehr 
verschieden zu benutzen ist. Wie es aussieht, kann ich auf dem Sensor 
schreiben, aber der "Read Interrupt Flag" wird beim Werte lesen nicht 
gesetzt und ich hab keine Ahnung warum. Laut Datenblatt ist meine 
Datenübertragung richtig.
Das ist mein "TWI_Master.c" File:

#include <avr/io.h>
#include "TWI_master.h"
#include "UART.h"
#include "General.h"
void TWI_init()
{
  TWI0.MBAUD = (uint8_t)TWI0_BAUD(100000);          // set MBAUD register for 100kHz
  TWI0.MCTRLA = 1 << TWI_ENABLE_bp      /* Enable TWI Master: enabled */
  | 0 << TWI_QCEN_bp          /* Quick Command Enable: disabled */
  | 0 << TWI_RIEN_bp          /* Read Interrupt Enable: disabled */
  | 1 << TWI_SMEN_bp          /* Smart Mode Enable: enabled */
  | TWI_TIMEOUT_DISABLED_gc        /* Bus Timeout Disabled */
  | 0 << TWI_WIEN_bp;          /* Write Interrupt Enable: disabled */

  TWI0.MCTRLB |= TWI_FLUSH_bm ;        /* Purge MADDR and MDATA */
  TWI0.MSTATUS |= TWI_BUSSTATE_IDLE_gc ;            //Force TWI state machine into IDLE state
  TWI0.MSTATUS |= (TWI_RIF_bm | TWI_WIF_bm) ;
}

uint8_t TWI_start(uint8_t deviceAddr)
{
  if ((TWI0.MSTATUS & TWI_BUSSTATE_gm) != TWI_BUSSTATE_BUSY_gc)    //Verify Bus is not busy
  {
    TWI0.MCTRLB &= ~(1 << TWI_ACKACT_bp);
    TWI0.MADDR = deviceAddr ;
    printString("bw");
    if (deviceAddr&0x01)  {while(!(TWI0.MSTATUS & TWI_RIF_bm));}  
    else      {while(!(TWI0.MSTATUS & TWI_WIF_bm));}  
    printString("aw");
    return 0;
  }
  else return 1;                                                          //Bus is busy
}

uint8_t TWI_read(uint8_t ACK)              // ACK=1 send ACK ; ACK=0 send NACK
{

  if ((TWI0.MSTATUS & TWI_BUSSTATE_gm) == TWI_BUSSTATE_OWNER_gc)    //Verify Master owns the bus
  {
    while(!(TWI0.MSTATUS & TWI_RIF_bm));        // Wait until RIF set
    uint8_t data=TWI0.MDATA;
    if  (ACK==1)  {TWI0.MCTRLB &= ~(1<<TWI_ACKACT_bp);}    
    else      {TWI0.MCTRLB |= (1<<TWI_ACKACT_bp);  }  
    USART_write((uint8_t)data);
    return data ;
  }
  else
  return 1;  //Master does not own the bus

}
uint8_t TWI_WRITE(uint8_t write_data)
{
  if ((TWI0.MSTATUS&TWI_BUSSTATE_gm) == TWI_BUSSTATE_OWNER_gc)                      //Verify Master owns the bus
  {
    TWI0.MDATA = write_data;
    while (!((TWI0.MSTATUS & TWI_WIF_bm) | (TWI0.MSTATUS & TWI_RXACK_bm))) ;    //Wait until WIF set and RXACK cleared
    return 0;
  }
  else
  return 1;  //Master does not own the bus
}
uint8_t TWI_RW(uint8_t reg, uint8_t addrW, uint8_t addrR)
{
  TWI_start(addrW, 0);
  TWI_WRITE(reg);
  TWI_start(addrR, 1);
  uint8_t result = TWI_read(1);
  TWI_STOP();
  return (result);
}
void TWI_STOP(void)
{
  TWI0.MCTRLB |= TWI_ACKACT_NACK_gc;
  TWI0.MCTRLB |= TWI_MCMD_STOP_gc;
}
int Mpu6050_Setup()
{
  //START i2c
  //startI2c();//Just rate of i2c

  //WRITE MPU6050
  Mpu6050_writeReg (0x19, 0b00000111);//WRITE Sample Rate Divider
  Mpu6050_writeReg (0x6b, 0b00000001);//WRITE Power Management 1
  Mpu6050_writeReg (0x1b, 0b10000000);//WRITE Gyroscope Configuration (1000°/s)
  return(0);
}
void Mpu6050_writeReg (const uint8_t ADDRESS, const uint8_t DATA)
{
  TWI_start(Sensor_Write, 0);
  TWI_WRITE(ADDRESS);
  TWI_WRITE(DATA);
  TWI_STOP();
}

Hier ist mein "main.c" File:

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "TWI_master.h"
#include "UART.h"
#include "General.h"

volatile uint32_t TCA_t_counter = 200; // Counter variable
volatile uint32_t Delay1_time = 200000; // Delay1 delay value
volatile uint32_t Delay1_old = 0; // Delay1 old counter value

void timerAInit(void);
void clkInit(void);

void clkInit(void){
  CPU_CCP = 0xD8;
  CLKCTRL.MCLKCTRLA |= (1<<7); // Enables CLKOUT
  CPU_CCP = 0xD8;
  CLKCTRL.MCLKCTRLA &= ~(1<<0) & ~(1<<1); //Selects OSC20M as main clock source
  CPU_CCP = 0xD8;
  CLKCTRL.MCLKCTRLB &= ~(1<<0); //Disables main clock prescaler
  CPU_CCP = 0xD8;
  CLKCTRL.OSC20MCTRLA |= (1<<1); //Lets OSC20M run in standby
}
void timerAInit(void)
{
  TCA0.SINGLE.PER = 96; // Set prescaler to 96
  TCA0.SINGLE.CTRLA |= (TCA_SINGLE_CLKSEL_DIV1_gc) | (TCA_SINGLE_ENABLE_bm); // Enable TCA0 and set CLKDIV to 8
  TCA0.SINGLE.INTCTRL |= (TCA_SINGLE_OVF_bm);  // Enable interrupt
}
ISR(TCA0_OVF_vect)
{
  //PORTC.OUTTGL |= (1<<0); //Test Signal
  TCA_t_counter ++; // Increases the TCA0 Counter
  TCA0.SINGLE.INTFLAGS = TCA_SINGLE_OVF_bm; //Clears the TCA0 interrupt
}

int main(void)
{
  PORTB.DIR |= (1<<0) | (1<<1) | (1<<5);
  PORTC.DIR |= (1<<0);
  TWI_init();
  clkInit();
  USART_init();
  timerAInit();
  sei(); // Enable global interrupts
  Mpu6050_Setup();
  
  while (1)
  {
    if(TCA_t_counter >= Delay1_old + Delay1_time){
      printString(" Hallo ");
      Delay1_old = TCA_t_counter;
      int rawGyroZ = TWI_RW (0x3f, Sensor_Write, Sensor_Read);
      PORTC.OUTTGL |= (1<<0); //Test Signal
      USART_write((int)rawGyroZ);
      
      //   int rawAccX = readI2c (0x43);
      //   int rawAccY = readI2c (0x45);
      //   int rawAccZ = readI2c (0x47);
      //  int rawGyroX = readI2c (0x3b);
      //   int rawGyroY = readI2c (0x3d);
      //   int rawGyroZ = readI2c (0x3f);
      //   int rawTemperature = readI2c (0x41);
      
    }
  }
}

Ich habe ertestet, dass der Chip bei der while-Schleife in der Funktion 
"TWI_start" hängenbleibt. Wenn man diese auskommentiert, hängt er in der 
while-Schleife in der Funktion "TWI_read" fest.
Hat jemand eine ahnung, warum der RIF nicht gesetzt wir, oder was ich 
falsch mache?
Danke für die Hilfe,
Nils