Software I2C

[Philipp (Gast)]

Hallo,

ich habe eine Software I2C auf einem Atmega32 angebunden. Jetzt habe ich 
da ein merkwürdiges Verhalten:

An PD1 SDA und PD0 SCL läuft der Bus auf ca. 100Khz (Oskar) und der 
angeschlossene SAA1064 arbeitet einwandfrei (blinkende  LED).

Wenn ich SDA und SCL hardwaremässig tausche und dann die Zuweisung 
ebenfalls tausche, also PD1 SCL und PD0 SDA dann liegt die Frequenz bei 
200KHz.... abgesehen davon kommt am SDA-Pin kein Rechtecksignal mehr 
raus eher schlechtes Dreieck mit 100Hz. Und Daten kommen auch keine 
sinigen mehr am SAA1064 an. Wenn ich dann die delay-Routinen verdopple 
gehts wiederum!?

Weiterhin auch der Anschluss an PD4 und PD5 und der entsprechenden 
Zuweisung geht nicht. Hier bringt dann auch keine Anpassung der Delays 
etwas.
Grundlegend nehme ich an, dass es an den Delay-Routinen also dem Timing 
liegt.

Die Frage die mich interessiert ist:
Warum verhalten sich die Pins an den Ports unterschiedlich oder übersehe 
ich etwas?

Sonderfunktionen sind bei PD2 und PD0 ja RX und TX. Bei PD4-5 ja 
Timerfunktionen, die sind aber alle deaktiviert.

Wer kann mir da mal auf die Sprünge helfen?

[Oliver (Gast)]

Der Fehler steckt in Zeile 42...

Die IO-Ports beim Mega32 verhalten sich nicht unterschiedlich, daran 
kann es also nicht liegen.

Oliver

[Philipp (Gast)]

Lustig,

42... Die Frage nur? :-)

Okay, das war also nur das Grundlegende was ich wissen wollte, alle 
Ports gleich.. dachte ich mir auch schon, da ich aber seit heute Morgen 
daran bastle... glaubt man ja an alles :-)

Im Prinzip ist es so, dass wirklich nur PD0 und PD1 funzen.
Werde später mal den Code posten.

Danke schon mal

[Philipp (Gast)]

Hallo,

also hier die Routinen die ich am Atmega32 mit 16MHz teste:
(GCC 3.4.6)
i2c_software_master.c:

#ifndef   F_CPU        
#define   F_CPU 16000000UL
#endif
////////////////////////////////////////////////////////////////////////////////////////////
#include <avr/io.h>
#include <util/delay.h>
////////////////////////////////////////////////////////////////////////////////////////////
#define I2C_DDR      DDRD          // Register für die I2C Kommunikation
#define I2C_DDR_REG_BIT  DDD5          //
#define I2C_PORT    PORTD          // I2C Port definition

#define SCL        PD4          // Port D
#define SDA        PD5            // Port D

#define SDA_LESE_PIN   PIND
#define SDA_LESE_BIT   SDA
////////////////////////////////////////////////////////////////////////////////////////////
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
void sda_low()
{
  I2C_PORT     &=  ~(1<<SDA);          // internen Pull-Up aus
  I2C_DDR     |=   (1<<I2C_DDR_REG_BIT);  // Pin von SDA als Ausgang

}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
void sda_high()
{
  I2C_DDR     &= ~(1<<I2C_DDR_REG_BIT);    // Pin von SDA als Eingang 
  I2C_PORT     |=  (1<<SDA);          // internen Pull-Up an 
} 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
////////////////////////////////////////////////////////////////////////////////////////////

#define I2C_SCL_LOW    I2C_PORT &= ~(1 << SCL)  // Clock Low Output
#define I2C_SCL_HIGH  I2C_PORT |=  (1 << SCL)  // Clock High Output

#define I2C_SDA_LOW    sda_low()        // Daten Leitung Low
#define I2C_SDA_HIGH  sda_high()        // Data Wire High

#define  ACK        0            // Ack empfangen
#define  NACK      1            // Ack nicht empfangen

//#define S_DELAY    _delay_loop_1(1);    // ca. 2.76µs H-Time Begrenzt auf 262.14 ms / F_CPU in MHz
#define M_DELAY      _delay_us(1);      // Begrenzt auf 768us/F_CPU in MHz also bei 16MHz 48us / 8MHz 96us
//#define DELAY      _delay_ms(1);      // Begrenzt auf 262.14 ms/F_CPU in MHz  also bei 16MHz 16,38ms / 8MHz 32,7675ms
#define S_DELAY         _delay_loop_1((F_CPU * 0.000001) / 3)   /**< 1 us delay */
//#define wait1ms       _delay_loop_2((F_CPU * 0.001) / 4)   /**< 1 ms delay */     

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
unsigned char i2c_try_scl(unsigned char start_trials)
{
  // 10 Mal kurz warten, wenn SCL auf LOW gehalten wird
  while((!SCL) && (start_trials <50))
  {
    start_trials++;
    S_DELAY;
  }
  if(!SCL) return 0 ; return 1;
}

void i2c_master_stop(void);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

////////////////////////////////////////////////////////////////////////////////////////////
// I2C-Master Interface Standard Routinen
////////////////////////////////////////////////////////////////////////////////////////////
void i2c_master_init(void)
{
  I2C_DDR |=  (1<<SCL);              // SCL Leitung als Ausgang definieren
    S_DELAY;
  I2C_SCL_HIGH;                // Cockleitung auf H setzen
  I2C_SDA_HIGH;                // Datenleitung auf H setzen
    S_DELAY;                // kurz warten
  i2c_master_stop();
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
void i2c_master_clk_toggle(void)
{
  i2c_try_scl(0x0A);

  I2C_SCL_HIGH;
    S_DELAY;
    S_DELAY;
  I2C_SCL_LOW;
     S_DELAY;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
void i2c_master_start(void)
{
  // Übergang von H->L auf SDA, wobei SCL H ist.
  i2c_try_scl(0x0A);

  I2C_SDA_HIGH;      // SDA vorsichtshalber auf HIGH ziehen
  //  S_DELAY;
  I2C_SCL_HIGH;      // SCL auf High  
    S_DELAY;
  I2C_SDA_LOW;      // SDA auf Low ziehen
    M_DELAY;
    M_DELAY;
    M_DELAY;
  I2C_SCL_LOW;      // SCL auf low
    S_DELAY;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
void i2c_master_stop(void)    
{
  // Übergang von L->H auf SDA, wobei SCL H ist.
  i2c_try_scl(0x0A);
    S_DELAY;
  I2C_SDA_LOW;      // SDA vorsichtshalber auf LOW ziehen
    S_DELAY;      // Kurz abwarten
  I2C_SCL_HIGH;      // SCL auf High setzen
    S_DELAY;    
  I2C_SDA_HIGH;      // SDA von L auf H ziehen
    S_DELAY;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
unsigned char i2c_master_write(unsigned char b)
{  
  char i=0;
  for(i=0;i<8;i++)
  {
    if (b & 0x80)  
    {
      I2C_SDA_HIGH;
    }
    else
    {
      I2C_SDA_LOW;
    }
    b=b<<1;
    S_DELAY;
    i2c_master_clk_toggle();
  }
  // Auf ACK vom Slave Prüfen   
  I2C_SDA_HIGH;
  i2c_master_clk_toggle();                                                                                                                       
  if(SDA==1)  
  {
    return 0;
  }
  else
  { 
    return 1;
  }  
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
unsigned char i2c_master_read(unsigned char a)
{  
  unsigned char i,c=0b00000000;
  I2C_SDA_HIGH;      

  for(i=0;i<8;i++)    
  {
    c=c<<1;        

    // Bitweise OR verknüpfen mit dem Eingang, MSB zuerst
    if(SDA_LESE_PIN & (1 << SDA_LESE_BIT)) c|=1;      
    i2c_master_clk_toggle();
  }

  // ACK oder NACK | ACK=0; NACK=1
  if(a==ACK)  {I2C_SDA_LOW;} else {I2C_SDA_HIGH;}  
  i2c_master_clk_toggle();
  return c;
}

i2c_software_master.h

void       i2c_master_init(void);
void      i2c_master_clk_toggle(void);
void        i2c_master_start(void);
void       i2c_master_stop(void);

unsigned char     i2c_try_scl(unsigned char start_trials);
unsigned char      i2c_master_write(unsigned char b);
unsigned char     i2c_master_read(unsigned char a);

Und die Main:

#include <avr/io.h>
#include <avr/interrupt.h>
#include "i2c_software_master.h"
#include <util/delay.h>


int main(void) 
{
  


// I2C Test

// Beispiel
/*
i2c.start (0x70); //Adresse 70 for writing
i2c.write (0x00); //Subaddress 01 for digit 1
i2c.write (0x47); //Control C6 bis C0
i2c.write (0x00); //Data bit 10 - 17
i2c.write (0x04); //Data bit 20 - 27
i2c.write (0x00); //Data bit 40 - 47
i2c.write (0x00); //Data bit 40 - 47
i2c.stop ();
*/


//TCCR1B   &= ~(1<<COM1A0)|(1<<COM1A1)|(1<<COM1B1)|(1<<COM1B0);
i2c_master_init();

  
  // Setzt beim SAA1064 alle Ausgänge auf High
while(1){
  i2c_master_start();
  i2c_master_write(0x70);
  i2c_master_write(0x07);
  i2c_master_write(0x47);
  i2c_master_write(0xff);
  i2c_master_write(0xff);
  i2c_master_write(0xff);
  i2c_master_write(0xff);
  i2c_master_stop();
  }

}

Dann noch mal zum Verständnis des Problems:

Wenn ich also SDA an PD1 und SCL an PD0 anschliesse (PullUps extern sind 
vorhanden und die interneen habe ich testweise mal ausgeschaltet... 
ändert nichts) und dann
#define I2C_DDR_REG_BIT          DDD1
#define SCL      PD0
#define SDA            PD1
setze funktioniert der I2C mit ca 100KHz an SCL gemäß dem Oskar.

Wenn ich aber
Wenn ich also SDA an PD5 und SCL an PD4 anschliesse und dann
#define I2C_DDR_REG_BIT          DDD5
#define SCL      PD4
#define SDA            PD5
setze funktioniert der I2C mit ca 178KHz an SCL gemäß dem Oskar.
SDA zeigt dabei nur Mist an ähnlich Enladekurve Kondi mit ca 100Hz.

Wie kann das sein?

[Niemand (Gast)]

Hi,
ist das wirklich eine gültige Abfrage des Portpinstatus ?:
"if(!SCL)"

[Niemand (Gast)]

Hi,
schau mal hier rein: Beitrag "LM75 mit Software TWI auslesen (Atmega 16, C)"
Dort wird ebenfalls das nicht-funktionieren des !SCL gezeigt.
Bei #define SCL PD0 ist SCL=0 --> if(!0) kann gehen, ist aber unsinn
Im Falle von #define SCL PD4 ist SCL=4 --> if(!4) geht auf jeden Fall 
schief.

[Philipp (Gast)]

Danke,

jetzt habe ich mal die Fleury-Routinen genommen.
Allerdings ist die ASM-Routine ja für Software I2C und die i2cmaster.c 
ja für TWI Hardware.
Also habe ich eine Main erstellt und die i2cmaster.h eingebunden.
Als Source im AVR Studio dann die i2cmaster.S hinzugefügt und dann das 
Projekt gebuildet.

Jetzt mault der Compiler an der i2c_master.S rum:

../source/i2cmaster.S:295: Error: missing ')'
../source/i2cmaster.S:295: Error: missing ')'
../source/i2cmaster.S:295: Error: missing ')'
../source/i2cmaster.S:295: Error: constant value required
../source/i2cmaster.S:295: Error: `,' required
../source/i2cmaster.S:295: Error: constant value required
../source/i2cmaster.S:295: Error: garbage at end of line
make: *** [i2cmaster.o] Error 1
Build failed with 1 errors and 5 warnings...

Wie bindet man die ASM richtig hinzu?

[spess53 (Gast)]

Hi

Und was steht in Zeile 295?

MfG Spess

[Philipp (Gast)]

Hallo,

In der Zeile steht wie in der ganzen Source Assembler-Code.
Also ich muss ja das Makefile anpassen damit der Compiler weiss das es 
eine Assembler-Datei ist... dachte eigentlich das kann AVR-Studio 
selbst erkennen!? Naja.

Also in dem Makefile dann ASRC = i2cmaster.S hinzufügen und dann...?
Da fehlen dann doch noch ein paar Infos...
Momentan behandelt AVR-Studio die ASM-Source als C-Source im Makefile...

[spess53 (Gast)]

Hi

>In der Zeile steht wie in der ganzen Source Assembler-Code.

Ach. Bist du nicht in der Lage die Fehlermeldungen zu verstehen?

MfG Spess

[Philipp (Gast)]

Hallo,

also die Fehlermeldung besagt das überall Klammern fehlen etc... ist 
aber Quatsch da es eine ASM-Library ist.
Es geht darum, da ich jetzt das Makefile angepasst habe, so dass er 
jetzt die ASM-Source richtig linkt!

Jetzt läuft mein Bus mit 297KHz. Im Normalmode...
Da ich nicht so der ASM-Freak bin müsste ich diese Routine ändern da ich 
nicht mit 4 sondern mit 16 MHz arbeite.

Also das Vierfache:

;*************************************************************************
; delay half period
; For I2C in normal mode (100kHz), use T/2 > 5us
; For I2C in fast mode (400kHz),   use T/2 > 1.3us
;*************************************************************************
  .stabs  "",100,0,0,i2c_delay_T2
  .stabs  "i2cmaster.S",100,0,0,i2c_delay_T2
  .func i2c_delay_T2  ; delay 5.0 microsec with 4 Mhz crystal  
i2c_delay_T2:        ; 4 cycles
  rjmp 1f      ; 2   "
1:  rjmp 2f      ; 2   "
2:  rjmp 3f      ; 2   "
3:  rjmp 4f      ; 2   "
4:  rjmp 5f      ; 2   "
5:   rjmp 6f      ; 2   "
6:  nop          ; 1   "
  ret          ; 3   "
  .endfunc     ; total 20 cyles = 5.0 microsec with 4 Mhz crystal

[Philipp (Gast)]

So das würde also so gehen...

Beitrag "Anpassung der Delay Routine (von 4 auf 6 MHz) in i2cmaster.S"

[Philipp (Gast)]

So nun,

gehts damit:

;*************************************************************************
; delay half period
; For I2C in normal mode (100kHz), use T/2 > 5us
; For I2C in fast mode (400kHz),   use T/2 > 1.3us
;cycle= 0.5 * FCPU / FI2C
;das heißt bei 100khz I2C Takt und 6MHz FCPU brauchst du
;0.5 * 16000000 / 100000 = 80 Zyklen.
;*************************************************************************
  .stabs  "",100,0,0,i2c_delay_T2
  .stabs  "i2cmaster.S",100,0,0,i2c_delay_T2
  .func i2c_delay_T2  ; delay 5.0 microsec with 4 Mhz crystal  
i2c_delay_T2:        ; 4 cycles
  rjmp 1f      ; 2   "
1:  rjmp 2f      ; 2   "
2:  rjmp 3f      ; 2   "
3:  rjmp 4f      ; 2   "
4:  rjmp 5f      ; 2   "
5:   rjmp 6f      ; 2   "
6:  rjmp 7f
7:  rjmp 8f
8:  rjmp 9f
9:  rjmp 10f
10: rjmp 11f
11: rjmp 12f
12: rjmp 13f
13: rjmp 14f
14: rjmp 15f
15: rjmp 16f
16: rjmp 17f
17: rjmp 18f
18: rjmp 19f
19: rjmp 20f
20: rjmp 21f
21: rjmp 22f
22: rjmp 23f
23: rjmp 24f
24: rjmp 25f
25: rjmp 26f
26: rjmp 27f
27: rjmp 28f
28: rjmp 29f
29: rjmp 30f
30: rjmp 31f
31: rjmp 32f
32: rjmp 33f
33: rjmp 34f
34: rjmp 35f
35: rjmp 36f
36: rjmp 37f
37: rjmp 38f
38: nop          ; 1   "
  ret          ; 3   "
  .endfunc     ; total 80 cyles = 5.0 microsec with 16 Mhz crystal

Allerdings immer noch kurios warum alle Pins gehen ausser der Pin PD5, 
an diesem kommt statt ein Rechteck ein Sägezahn heraus.
An dem zweiten Atmega32 dasselbe... was ist da mit dm PD5? Ob da am 
Fertig-Testboard ein Kondi dran klebt?
Merkwürdig...

[Philipp (Gast)]

Hallo,

und so siehst aus... da ist ein Kondi dran und ein PullUp, der da den 
einzigen Taster auf dem gesamten Board bedient. Im Schaltplan ist das so 
was von klein eingezeichent, das man nur die Pins an der Steckleiste 
sehen konnte. Da frage ich mich warum da die freien Ports an der 
Steckleiste liegen und dann ist einer doch belegt.. so ein Quatsch, da 
ist die Anleitung ja in sich falsch.

Da ich dann alles mit dem Oskar gemessen habe stellte ich fest, dass ich 
mit der Berechnung:

;cycle= 0.5 * FCPU / FI2C
;das heißt bei 100khz I2C Takt und 6MHz FCPU brauchst du
;0.5 * 16000000 / 100000 = 80 Zyklen.

doch ganz schön daneben liege...nur 88KHz

Für 100KHz mit dem Atmega32 bei 16MHz habe ich jetzt empirisch mit dem 
Oskar für saubere 100KHz 69 Zyklen herausbekommen. Also dann die 
Delay-Routine so umgesetzt:

;*************************************************************************
; delay half period
; For I2C in normal mode (100kHz), use T/2 > 5us
; For I2C in fast mode (400kHz),   use T/2 > 1.3us
;cycle= 0.5 * FCPU / FI2C
;das heißt bei 100khz I2C Takt und 6MHz FCPU brauchst du
;0.5 * 16000000 / 100000 = 80 Zyklen.
;*************************************************************************
  .stabs  "",100,0,0,i2c_delay_T2
  .stabs  "i2cmaster.S",100,0,0,i2c_delay_T2
  .func i2c_delay_T2  ; delay 5.0 microsec with 4 Mhz crystal  
i2c_delay_T2:        ; 4 cycles
  rjmp 1f      ; 2   "
1:  rjmp 2f      ; 2   "
2:  rjmp 3f      ; 2   "
3:  rjmp 4f      ; 2   "
4:  rjmp 5f      ; 2   "
5:   rjmp 6f      ; 2   "
6:  rjmp 7f      ; 2   "
7:  rjmp 8f      ; 2   "
8:  rjmp 9f      ; 2   "
9:  rjmp 10f      ; 2   "
10: rjmp 11f      ; 2   "
11: rjmp 12f      ; 2   "
12: rjmp 13f      ; 2   "
13: rjmp 14f      ; 2   "
14: rjmp 15f      ; 2   "
15: rjmp 16f      ; 2   "
16: rjmp 17f      ; 2   "
17: rjmp 18f      ; 2   "
18: rjmp 19f      ; 2   "
19: rjmp 20f      ; 2   "
20: rjmp 21f      ; 2   "
21: rjmp 22f      ; 2   "
22: rjmp 23f      ; 2   "
23: rjmp 24f      ; 2   "
24: rjmp 25f      ; 2   "
25: rjmp 26f      ; 2   "
26: rjmp 27f      ; 2   "
27: rjmp 28f      ; 2   "
28: rjmp 29f      ; 2   "
29: rjmp 30f      ; 2   "
30: rjmp 31f      ; 2   "
31: rjmp 32f      ; 2   "
32: rjmp 33f      ; 2   "
33: ret          ; 3   "
  .endfunc     ; total 69 cyles = 100KHz  with 16 Mhz crystal measured on Oszilloscope

[Philipp (Gast)]

Jetzt wäre noch die Frage an die ASM-Freaks ob der Aufruf der Funktion:

i2c_delay_T2:        ; 4 cycles

Auch tatsächlich 4 Zyklen dauert?
Dann wären es ja insgesamt 73 Zyklen für 100KHz?

Wer klärt mich auf?