I2C meldet status 0x38

uint8_t TWIM_Write (uint8_t byte)

  {

  uint8_t   twst;

/*

** Send data to the previously addressed device

*/

  TWDR = byte;

  TWCR = (1<<TWINT)|(1<<TWEN);

/*

** Wait until transmission completed

*/

  while (!(TWCR & (1<<TWINT)));/*hier*/

/*

** Check value of TWI Status Register. Mask prescaler bits

*/

  twst = TWSR & 0xF8;

  printf("0x%02x\n",twst);

  if (twst != TWI_MTX_DATA_ACK) return 1;

  return 0;

  }

/*******************************************************

 Author:          Manfred Langemann

 mailto:          Manfred.Langemann ät t-online.de

 Begin of project:      04.01.2008

 Latest version generated:  04.01.2008

 Filename:          Main.c

 Description:          Main routine for testing

               TWI_Master_main.c

 ********************************************************/

#include <stdio.h>

#include <avr/interrupt.h>

#include "General.h"

#include "RS232.h"

#include "Delay.h"

#include "TWI_Master.h"

/*

** This main programm demonstrates how to use the 

** implemented TWI master functions. These are:

**  TWIM_Init

**  TWIM_ReadAck

**  TWIM_ReadNack

**  TWIM_Write

**  TWIM_Stop

**

** For testing this program, use the program

** TWI_Slave_main.c in the slave uC and connect the

** two TWI lines properly (don't forget to also

** connect GND between Master and Slave!)

**

** Used uC for Master is ATMega32

*/

int main (void)

  {

  uint8_t    i;

  uint8_t    j=0;

  //uint8_t    Data[8];

  uint8_t    SlaveAddress = 0;

/*

** Clear any interrupt

*/

  cli ();

/*

** Wait 1 second for POR

*/

  Delay_ms (1000);

/*

** Initiate RS232

*/

  RS232_Init ();

  printf ("Hello world...\n");

/*

** Initiate TWI Master Interface with bitrate of 100000 Hz

*/

  if (!TWIM_Init (100000))

    {

    printf ("Error in initiating TWI interface\n");

    while (1);

    }

/*

** Endless loop

*/

  while (1)

    {

/*

** Write byte(s) to the slave.

** It is implicitely assumed, that the slave will

** accepts 8 bytes

*/

      if (!TWIM_Start (SlaveAddress, TWIM_WRITE))

      {

      TWIM_Stop ();

      printf ("Could not start TWI Bus for WRITE\n");

        }

    else

      {

            TWIM_Write (j++);

        printf ("Byte sent: %d\n", j);

      TWIM_Stop ();

      Delay_ms (1000);

      }

    }

  return 0;

  }

#include <stdio.h>

#include <avr/interrupt.h>

#include "General.h"

#include "TWI_Master.h"

/****************************************************************************

  TWI State codes

****************************************************************************/

// General TWI Master staus codes                      

#define TWI_START          0x08  // START has been transmitted  

#define TWI_REP_START        0x10  // Repeated START has been transmitted

#define TWI_ARB_LOST        0x38  // Arbitration lost

// TWI Master Transmitter staus codes                      

#define TWI_MTX_ADR_ACK        0x18  // SLA+W has been tramsmitted and ACK received

#define TWI_MTX_ADR_NACK      0x20  // SLA+W has been tramsmitted and NACK received 

#define TWI_MTX_DATA_ACK      0x28  // Data byte has been tramsmitted and ACK received

#define TWI_MTX_DATA_NACK      0x30  // Data byte has been tramsmitted and NACK received 

// TWI Master Receiver staus codes  

#define TWI_MRX_ADR_ACK        0x40  // SLA+R has been tramsmitted and ACK received

#define TWI_MRX_ADR_NACK      0x48  // SLA+R has been tramsmitted and NACK received

#define TWI_MRX_DATA_ACK      0x50  // Data byte has been received and ACK tramsmitted

#define TWI_MRX_DATA_NACK      0x58  // Data byte has been received and NACK tramsmitted

// TWI Slave Transmitter staus codes

#define TWI_STX_ADR_ACK        0xA8  // Own SLA+R has been received; ACK has been returned

#define TWI_STX_ADR_ACK_M_ARB_LOST  0xB0  // Arbitration lost in SLA+R/W as Master; own SLA+R has been received; ACK has been returned

#define TWI_STX_DATA_ACK      0xB8  // Data byte in TWDR has been transmitted; ACK has been received

#define TWI_STX_DATA_NACK      0xC0  // Data byte in TWDR has been transmitted; NOT ACK has been received

#define TWI_STX_DATA_ACK_LAST_BYTE  0xC8  // Last data byte in TWDR has been transmitted (TWEA = “0”); ACK has been received

// TWI Slave Receiver staus codes

#define TWI_SRX_ADR_ACK        0x60  // Own SLA+W has been received ACK has been returned

#define TWI_SRX_ADR_ACK_M_ARB_LOST  0x68  // Arbitration lost in SLA+R/W as Master; own SLA+W has been received; ACK has been returned

#define TWI_SRX_GEN_ACK        0x70  // General call address has been received; ACK has been returned

#define TWI_SRX_GEN_ACK_M_ARB_LOST  0x78  // Arbitration lost in SLA+R/W as Master; General call address has been received; ACK has been returned

#define TWI_SRX_ADR_DATA_ACK    0x80  // Previously addressed with own SLA+W; data has been received; ACK has been returned

#define TWI_SRX_ADR_DATA_NACK    0x88  // Previously addressed with own SLA+W; data has been received; NOT ACK has been returned

#define TWI_SRX_GEN_DATA_ACK    0x90  // Previously addressed with general call; data has been received; ACK has been returned

#define TWI_SRX_GEN_DATA_NACK    0x98  // Previously addressed with general call; data has been received; NOT ACK has been returned

#define TWI_SRX_STOP_RESTART    0xA0  // A STOP condition or repeated START condition has been received while still addressed as Slave

// TWI Miscellaneous status codes

#define TWI_NO_STATE        0xF8  // No relevant state information available; TWINT = “0”

#define TWI_BUS_ERROR        0x00  // Bus error due to an illegal START or STOP condition

/*******************************************************

 Public Function: TWIM_Init

 Purpose: Initialise the TWI Master Interface

 Input Parameter:

   - uint16_t  TWI_Bitrate (Hz)

 Return Value: uint8_t

   - FALSE:  Bitrate too high

   - TRUE:    Bitrate OK

*******************************************************/

uint8_t TWIM_Init (uint32_t TWI_Bitrate)

  {

/*

** Set TWI bitrate

** If bitrate is too high, then error return

*/

  TWBR = ((F_CPU/TWI_Bitrate)-16)/2;

  if (TWBR < 11) return FALSE;

  return TRUE;

  }

/*******************************************************

 Public Function: TWIM_Start

 Purpose: Start the TWI Master Interface

 Input Parameter:

   - uint8_t  Device address

   - uint8_t  Type of required Operation:

        TWIM_READ: Read data from the slave

        TWIM_WRITE: Write data to the slave

 Return Value: uint8_t

    - TRUE:    OK, TWI Master accessible

   - FALSE:  Error in starting TWI Master

*******************************************************/

uint8_t TWIM_Start (uint8_t Address, uint8_t TWIM_Type)

  {

  uint8_t    twst;

/*

** Send START condition

*/

  TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);

/*

** Wait until transmission completed

*/

  while (!(TWCR & (1<<TWINT)));

/*

** Check value of TWI Status Register. Mask prescaler bits.

*/

  twst = TWSR & 0xF8;

  printf("0x%02x\n",twst);

  if ((twst != TWI_START) && (twst != TWI_REP_START)) return FALSE;

/*

** Send device address

*/

  TWDR = (Address<<1) + TWIM_Type;

  TWCR = (1<<TWINT)|(1<<TWEN);

/*

** Wait until transmission completed and ACK/NACK has been received

*/

  while (!(TWCR & (1<<TWINT)));

/*

** Check value of TWI Status Register. Mask prescaler bits.

*/

  twst = TWSR & 0xF8;

  printf("0x%02x\n",twst);

  if ((twst != TWI_MTX_ADR_ACK) && (twst != TWI_MRX_ADR_ACK)) return FALSE;

  return TRUE;

  }

/*******************************************************

 Public Function: TWIM_Stop

 Purpose: Stop the TWI Master

 Input Parameter: None

 Return Value: None

*******************************************************/

void TWIM_Stop (void)

  {

/*

** Send stop condition

*/

  TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);

/*

** Wait until stop condition is executed and bus released

*/

  while (TWCR & (1<<TWINT));

  }

/*******************************************************

 Public Function: TWIM_Write

 Purpose: Write a byte to the slave

 Input Parameter:

   - uint8_t  Byte to be sent

 Return Value: uint8_t

    - TRUE:    OK, Byte sent

   - FALSE:  Error in byte transmission

*******************************************************/

uint8_t TWIM_Write (uint8_t byte)

  {

  uint8_t   twst;

/*

** Send data to the previously addressed device

*/

  TWDR = byte;

  TWCR = (1<<TWINT)|(1<<TWEN);

/*

** Wait until transmission completed

*/

  while (!(TWCR & (1<<TWINT)));

/*

** Check value of TWI Status Register. Mask prescaler bits

*/

  twst = TWSR & 0xF8;

  printf("0x%02x\n",twst);

  if (twst != TWI_MTX_DATA_ACK) return 1;

  return 0;

  }

/*******************************************************

 Public Function: TWIM_ReadAck

 Purpose: Read a byte from the slave and request next byte

 Input Parameter: None

 Return Value: uint8_t

    - uint8_t  Read byte

*******************************************************/

uint8_t TWIM_ReadAck (void)

  {

  TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);

  while (!(TWCR & (1<<TWINT)));    

  return TWDR;

  }

/*******************************************************

 Public Function: TWIM_ReadAck

 Purpose: Read the last byte from the slave

 Input Parameter: None

 Return Value: uint8_t

    - uint8_t  Read byte

*******************************************************/

uint8_t TWIM_ReadNack (void)

  {

  TWCR = (1<<TWINT)|(1<<TWEN);

  while(!(TWCR & (1<<TWINT)));

  return TWDR;

  }

#include <avr/interrupt.h>

#include <avr/io.h>

#include <util/twi.h>

//Motoradresse

#define MOTOR_ADR 0x70

//############################################################################

//Hauptprogramm

int main (void) 

//############################################################################

{

  unsigned char pwm = 10;

  //Watchdog off

  asm("wdr");

  MCUSR &= ~(1<<WDRF);

  //Write logical one to WDCE and WDE

  WDTCSR |= (1<<WDCE) | (1<<WDE);

  //Turn off WDT

  WDTCSR = 0x00;

  TWSR = 0;

  TWBR = ((12000000/200000)-16)/2; 

  DDRC |= (1<<5); //SCL Output

  DDRB |= (1<<0);

  PORTB |= (1<<0);

  while(1)

  {

      //Start I2C

      TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT);

      while (!(TWCR & (1<<TWINT)));

      //Write Motor Adresse

      TWSR = 0x00;

      TWDR = 0x40;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));  

      //Write PWM

      TWSR = 0x00;

      TWDR = pwm;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));

      //Stop I2C

      TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);

      for(unsigned long a = 0;a<10000;a++) asm("nop");

      //Start I2C

      TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT);

      while (!(TWCR & (1<<TWINT)));

      //Write Motor Adresse

      TWSR = 0x00;

      TWDR = 0x50;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));  

      //Write PWM

      TWSR = 0x00;

      TWDR = pwm;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));

      //Stop I2C

      TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);

      for(unsigned long a = 0;a<10000;a++) asm("nop");

      //Start I2C

      TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT);

      while (!(TWCR & (1<<TWINT)));

      //Write Motor Adresse

      TWSR = 0x00;

      TWDR = 0x60;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));  

      //Write PWM

      TWSR = 0x00;

      TWDR = pwm;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));

      //Stop I2C

      TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);

      for(unsigned long a = 0;a<10000;a++) asm("nop");

      //Start I2C

      TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT);

      while (!(TWCR & (1<<TWINT)));

      //Write Motor Adresse

      TWSR = 0x00;

      TWDR = 0x70;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));  

      //Write PWM

      TWSR = 0x00;

      TWDR = pwm;

      TWCR = (1<<TWINT) | (1<<TWEN);

      while (!(TWCR & (1<<TWINT)));

      //Stop I2C

      TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);

      for(unsigned long a = 0;a<10000;a++) asm("nop");

  }

}

/*----------------------------------------------------------------------------

 Copyright:      Ulrich Radig (mail@ulrichradig.de)

 Author:         Ulrich Radig

 Remarks:        

 known Problems: none

 Version:        23.06.2011

 Description:    Brushless Motor Controller for ATmega48/88/168

 Dieses Programm ist freie Software. Sie können es unter den Bedingungen der 

 GNU General Public License, wie von der Free Software Foundation veröffentlicht, 

 weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder 

 (nach Ihrer Option) jeder späteren Version. 

 Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, 

 daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE, 

 sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT 

 FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License. 

 Sie sollten eine Kopie der GNU General Public License zusammen mit diesem 

 Programm erhalten haben. 

 Falls nicht, schreiben Sie an die Free Software Foundation, 

 Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. 

------------------------------------------------------------------------------*/

#include <avr/interrupt.h>

#include <avr/io.h>

#include <util/twi.h>

//Motoradresse

#define MOTOR_ADR 0x0C

//PHASE1 (U)

#define UH_DDR  DDRB |= (1<<3);

#define UH_ON  TCCR2A |= (1<<COM2A1);

#define UH_OFF  TCCR2A &= ~(1<<COM2A1);

//PHASE1 (U)

#define UL_DDR  DDRB |= (1<<1);

#define UL_ON  PORTB |= (1<<1);

#define UL_OFF  PORTB &= ~(1<<1);

//PHASE2 (V)

#define VH_DDR  DDRD |= (1<<5);

#define VH_ON  TCCR0A |= (1<<COM0B1);

#define VH_OFF  TCCR0A &= ~(1<<COM0B1);

//PHASE2 (V)

#define VL_DDR  DDRB |= (1<<2);

#define VL_ON  PORTB |= (1<<2);

#define VL_OFF  PORTB &= ~(1<<2);

//PHASE3 (W)

#define WH_DDR  DDRD |= (1<<3);

#define WH_ON  TCCR2A |= (1<<COM2B1);

#define WH_OFF  TCCR2A &= ~(1<<COM2B1);

//PHASE3 (W)

#define WL_DDR  DDRC |= (1<<3);

#define WL_ON  PORTC |= (1<<3);

#define WL_OFF  PORTC &= ~(1<<3);

#define PHASE_ALL_OFF  UH_OFF;UL_OFF;VH_OFF;VL_OFF;WH_OFF;WL_OFF;

#define SENSE_U    ADMUX = 0;

#define SENSE_V    ADMUX = 1;

#define SENSE_W    ADMUX = 2;

#define SENSE_H    (ACSR&(1<<ACO))

#define START_PWM   5

volatile unsigned long i2c_timeout = 0;

volatile unsigned char rx_pwm = 0;

volatile unsigned char rotor_state = 0;

volatile unsigned char rotor_run = 0;

//############################################################################

void next_commutate_state (unsigned char startup)

//############################################################################

{

  switch (rotor_state)

  {

    case (0):

      if(!SENSE_H || startup)

      {

        WH_OFF;

        UH_ON;

        SENSE_W;

        rotor_state = 1;

        TCNT1 = 1;

      }

      break;

    case (1):

      if(SENSE_H || startup)

      {

        VL_OFF;

        WL_ON;

        SENSE_V;

        rotor_state = 2;

        TCNT1 = 1;

      }

      break;

    case (2):

      if(!SENSE_H || startup)

      {

        UH_OFF;

        VH_ON;

        SENSE_U;

        rotor_state = 3;

        TCNT1 = 1;

      }

      break;

    case (3):

      if(SENSE_H || startup)

      {

        WL_OFF;

        UL_ON;

        SENSE_W;

        rotor_state = 4;

        TCNT1 = 1;

      }

      break;

    case (4):

      if(!SENSE_H || startup)

      {

        VH_OFF;

        WH_ON;

        SENSE_V;

        rotor_state = 5;

        TCNT1 = 1;

      }

      break;

    case (5):

      if(SENSE_H || startup)

      {

        UL_OFF;

        VL_ON;

        SENSE_U;

        rotor_state = 0;

        TCNT1 = 1;

      }

      break;

  }

}

//############################################################################

//back EMF zero crossing detection

ISR (ANALOG_COMP_vect) 

//############################################################################

{

  if(rotor_run == 200) next_commutate_state (0);

  rotor_run++;

  if(rotor_run > 200)

  {

    rotor_run = 200;

  }

}

//############################################################################

ISR (TIMER1_OVF_vect)

//############################################################################

{  

  next_commutate_state (1);

  rotor_run = 0;

  OCR2A = START_PWM;

  OCR2B = START_PWM;

  OCR0B = START_PWM;

}

//############################################################################

ISR (TWI_vect)

//############################################################################

{  

  switch (TWSR & 0xF8) //TW_STATUS 

  {  

    //Adresse empfangen

    case TW_SR_SLA_ACK:  

      TWCR |= (1<<TWINT);

      return;

    //Daten empfangen

    case TW_SR_DATA_ACK:

      rx_pwm = TWDR;

      TWCR |= (1<<TWINT);

      i2c_timeout = 0;

      return;

    //Bus-Fehler zurücksetzen 

    case TW_NO_INFO:

      TWCR |=(1<<TWSTO) | (1<<TWINT); 

    //Bus-Fehler zurücksetzen   

    case TW_BUS_ERROR:

      TWCR |=(1<<TWSTO) | (1<<TWINT); 

  }

  //Reset TW

  TWCR =(1<<TWEA) | (1<<TWINT) | (1<<TWEN) | (1<<TWIE);

}

//############################################################################

//Hauptprogramm

int main (void) 

//############################################################################

{

  //Watchdog on

  WDTCSR = (1<<WDCE) | (1<<WDE);

  //Motordriver output

  UH_DDR;

  VH_DDR;

  WH_DDR;

  UL_DDR;

  VL_DDR;

  WL_DDR;

  //PWM for UH, VH and WH (>32KHz)

  TCCR0A |= (1<<COM0B1|1<<WGM01|1<<WGM00);

  TCCR0B |= (1<<CS00);

  TCCR2A |= (1<<COM2A1|1<<COM2B1|1<<WGM21|1<<WGM20);

  TCCR2B |= (1<<CS20);

  //TIMER1 for start commutation or Back EMF lost

  TCCR1B |= (1<<CS11);

  TIMSK1 |= (1<<TOIE1);

  PHASE_ALL_OFF;

  //Comperator init for back EMF

  ADCSRB  |= (1<<ACME);

  DIDR1  |= (1<<AIN0D);

  ACSR  |= (1<<ACIE);

  //I2C Init

  TWAR = MOTOR_ADR & 0xFE;

    TWCR = (1<<TWINT)|(1<<TWEA)|(1<<TWEN)|(1<<TWIE);

  //Interrupts enabel

  sei();

  while(1)

  {  

    asm("wdr");

    if(rx_pwm > START_PWM)

    {

      ACSR |= (1<<ACIE);

      TIMSK1 |= (1<<TOIE1);

      if(rotor_run == 200)

      {

        OCR2A = rx_pwm;

        OCR2B = rx_pwm;

        OCR0B = rx_pwm;

      }

      i2c_timeout++;

      if(i2c_timeout>100000)

      {

        rx_pwm = 0;

      }

    }

    else

    {

      PHASE_ALL_OFF;

      ACSR&=~(1<<ACIE);

      TIMSK1 &= ~(1<<TOIE1);

    }

  }

}