AVR Freaks

Danke für den klaren Hinweis :-)

Mein I2C-Routine ist in Assembler geschrieben und will meine Befehle akzeptieren.

---------------------------------------

Thanks for the clear hint :-)

My I2C routine is written in assembler and wants to accept my commands.

void I2C_Init()
{
	asm("push r16");
	// Clock
	asm("ldi  r16, ((F_CPU / TWI_CLOCK)-16) / 2"); // <----- 
	asm("out  TWSR,R16");
	// TWI-Status-Register (Vorteiler)
	asm("ldi  r16,0");
	asm("ldi  r16,TWI_ADR");
	// Bus-Adresse
	asm("ldi  r16,TWI_ADR");
	asm("out  TWAR,r16");
	// Enable
	asm("ldi  r16,_TWINT | _TWEN"); // <-----
	asm("out  TWCR,r16");
	asm("pop  r16");
}

Ich schreibe das erstmal mit AVR Mikrocontroller mit C/C++. Vorher habe ich mit Bascom-AVR entwickelt.

Durch meinen Display kann ich mit BASCOM-AVR nicht weiter nutzen.

Also möchte ich mein Projekt in C/C++ schreiben.

Die Funktionen für I²C habe aus einen Einsteigerbuch und ist nur in Assembler geschrieben.

Um es zu testet habe ich den Original-Code von Buch abgeschrieben. Um Assembler-Routinen zu nutzen, muss ich ASM() Funktion nutzen.

Am ende wenn I²C läuft und funktioniert, hätte ich es in C/C++ umgeschrieben.

Die Fertigen Codes die ich gefunden für C/C++, gibt es kein I²C-Timeout und Rückgabe für Acknowledge-Status.

----------------------------- ENGLISH --------------------------------------------------------------

I write this first with AVR microcontroller with C/C++. Before I developed with Bascom-AVR.
Because of my display I can't use BASCOM-AVR any more.
So I want to write my project in C/C++.
The functions for I²C I got from a beginners book and is written only in assembler.
To test it I copied the original code from the book. To use assembler routines I have to use ASM() function.
At the end when I²C is running and working, I would have rewritten it in C/C++.
The ready made codes I found for C/C++, there is no I²C timeout and return for acknowledge status.

Hi guys,
I have rewritten my I2C routine in C.

This is my result:

I2C_Master.c

#include <avr/io.h>
#include <avr/iom32.h>
#include "../Clock.h"
#include "I2C_Master.h"

//------------------------------------------------------------------------
// I2C-Master initialisieren
//------------------------------------------------------------------------
void I2C_Init()
{
  // Clock
  TWBR=((F_CPU/TWI_CLOCK)-16)/2;
  // TWI-Status-Register (Vorteiler)
  TWSR=0;
  // Bus-Addr
  TWAR=TWI_ADR;
  // Enable
  TWCR=_TWINT|_TWEN;
}

//------------------------------------------------------------------------
// Start I2C (ohne Interrupt)
//------------------------------------------------------------------------
void I2C_Start()
{
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;         // nur Beibehalten von Enable und InterruptJ/N
  TWCR=x|_TWINT|_TWSTA;
  // warten bis fertig
  while( !(TWCR & _TWINT))
  {}
}

//------------------------------------------------------------------------
// Stop I2C (ohne Interrupt)
//------------------------------------------------------------------------
void I2C_Stop()
{
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;         // nur Beibehalten von Enable und InterruptJ/N
  TWCR=x|_TWINT|_TWSTO;
}

//------------------------------------------------------------------------
// Write Byte per TWI (ohne Interrupt)
// PE: val  = zu sendende Daten
//     ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt
//------------------------------------------------------------------------
uint8_t I2C_Write(uint8_t val, uint8_t ackn)
{
  TWDR=val;                // Daten bereitlegen
  // Befehl zusammenstellen
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;                //nur Beibehalten von Enable und InterruptJ/N
  x|=_TWINT;
  if(ackn)
  x|=_TWEA;        // evt. TWEA setzen, für Datenanforderung
  TWCR=x;                        // senden
  // warten bis fertig
  while( !(TWCR & _TWINT))
  {}
  return 0;
}

//------------------------------------------------------------------------
// Read Byte per TWI (ohne Interrupt)
// PE: ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt
// PA: Data
//------------------------------------------------------------------------
uint8_t I2C_Read(uint8_t ackn)
{
  // Befehl zusammenstellen
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;                //nur Beibehalten von Enable und InterruptJ/N
  x|=_TWINT;
  if(ackn)
  x|=_TWEA;        // evt. TWEA setzen, für Datenanforderung
  TWCR=x;                        // senden
  // warten bis fertig
  while( !(TWCR & _TWINT))
  {}
  return TWDR;
}

I2C_Master.h

#ifndef I2C_MASTER_H_
#define I2C_MASTER_H_
//-----------------------------------------------------------------------------
#define TWI_CLOCK 100000 // Geschwindigkeit des TWI-Busses
#define TWI_READ  0b00000001
#define TWI_WRITE 0b00000000
//-----------------------------------------------------------------------------
#define _TWINT    0b10000000
#define _TWEA     0b01000000
#define _TWSTA    0b00100000
#define _TWSTO    0b00010000
#define _TWWC     0b00001000
#define _TWEN     0b00000100
#define _TWIE     0b00000001
//-----------------------------------------------------------------------------
#define TWI_ADR   0x00

void I2C_Init(void);
void I2C_Start(void);
void I2C_Stop(void);
uint8_t I2C_Write(uint8_t val, uint8_t ackn);
uint8_t I2C_Read(uint8_t ackn);

#endif /* I2C_MASTER_H_ */

I have changed TWR_ADR from 0x00 to 0x80 (128).

I use I2C only as master, it doesn't really matter. Only when I change as slave.