-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 12

Thema: i2c Probleme;

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    07.12.2004
    Ort
    Leverkusen
    Alter
    37
    Beiträge
    95

    i2c Probleme;

    Anzeige

    Hallo allerseits,

    ich möchte über den I2C Bus die Entfernung des SRF02 zur Wand messen
    und diese auf dem KeyLCD ausgeben.

    Ich benutze die Lib vom P. Fleury. Hab allerdings auch eigene I2C Methoden
    geschrieben. Beide gleicher Fehler.

    Mal vorweg: Muss ich auch beim RN-Control zwischen SDA und SCL
    4,7k Pullups löten oder nur die internen Pullups aktivieren ? Oder
    weder noch ?

    Hab erstmal alles einzeln angesteuert und dabei gabs folgende Probleme:
    Ich kann mit meinen I2C Methoden nur 2 Zeichen ans LCD senden.Weitere werden einfach nicht angezeigt. Mit der Lib von P. Fleury sogar nur eins.

    Beim SRF02 siehts so aus das mit der Lib von P. Fleury immer der gleiche
    Wert ausgegeben wird obwohl das i2c_write keinen error ausgibt.
    Quasi schreiben geht. Lesen nur Konstante.

    Hab in der i2cmaster.S die Ports angepasst (PORTC 0SCL 1SDA)sowie die delay routine auf
    80 zyklen erweitert da ich einen 16mhz quarz habe und mit 100khz senden will. Ist doch richtig so oder ?

    ich finde einfach nicht den fehler.

    Hier mal mein KOMPLETTER Code im nächsten Post:

    Danke für eure Hilfe !!

  2. #2
    Benutzer Stammmitglied
    Registriert seit
    07.12.2004
    Ort
    Leverkusen
    Alter
    37
    Beiträge
    95
    Erst die i2cmaster.S:
    Code:
    ;*************************************************************************
    ; Title	:    I2C (Single) Master Implementation
    ; Author:    Peter Fleury <pfleury@gmx.ch>  http://jump.to/fleury
    ;            based on Atmel Appl. Note AVR300
    ; File:      $Id: i2cmaster.S,v 1.11 2003/10/16 18:16:07 peter Exp $
    ; Software:  AVR-GCC 3.3
    ; Target:    any AVR device
    ;
    ; DESCRIPTION
    ; 	Basic routines for communicating with I2C slave devices. This
    ;	"single" master implementation is limited to one bus master on the
    ;	I2C bus. 
    ;  
    ;       Based on the Atmel Application Note AVR300, corrected and adapted 
    ;       to GNU assembler and AVR-GCC C call interface
    ;       Replaced the incorrect quarter period delays found in AVR300 with 
    ;       half period delays. 
    ;
    ; USAGE
    ;	These routines can be called from C, refere to file i2cmaster.h.
    ;       See example test_i2cmaster.c 
    ; 	Adapt the SCL and SDA port and pin definitions and eventually 
    ;	the delay routine to your target !
    ; 	Use 4.7k pull-up resistor on the SDA and SCL pin.
    ;
    ; NOTES
    ;	The I2C routines can be called either from non-interrupt or
    ;	interrupt routines, not both.
    ;
    ;*************************************************************************
    
    #if (__GNUC__ * 100 + __GNUC_MINOR__) < 303
    #error "This library requires AVR-GCC 3.3 or later, update to newer AVR-GCC compiler !"
    #endif
    
    
    #include <avr/io.h>
    
    
    
    ;***** Adapt these SCA and SCL port and pin definition to your target !!
    ;
    #define SDA     	1		// SDA Port D, Pin 4   
    #define SCL		0		// SCL Port D, Pin 5
    #define SDA_PORT        PORTC           // SDA Port D
    #define SCL_PORT        PORTC           // SCL Port D         
    
    ;******
    
    ;-- map the IO register back into the IO address space
    #define SDA_DDR		(_SFR_IO_ADDR(SDA_PORT) - 1)
    #define SCL_DDR		(_SFR_IO_ADDR(SCL_PORT) - 1)
    #define SDA_OUT		_SFR_IO_ADDR(SDA_PORT)
    #define SCL_OUT		_SFR_IO_ADDR(SCL_PORT)
    #define SDA_IN		(_SFR_IO_ADDR(SDA_PORT) - 2)
    #define SCL_IN		(_SFR_IO_ADDR(SCL_PORT) - 2)
    
    
    #ifndef __tmp_reg__
    #define __tmp_reg__ 0
    #endif
    
    
    	.section .text
    
    ;*************************************************************************
    ; 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 16 Mhz crystal	
    i2c_delay_T2:        ; 4 cycles
    	rjmp 1f      ; 2   "
    1:	rjmp 2f      ; 2   "
    2:	rjmp 3f      ; 2   " 10
    3:	rjmp 4f      ; 2   "
    4:	rjmp 5f      ; 2   "
    5:	rjmp 6f      ; 2   "
    6:	rjmp 7f      ; 2   "
    7:	rjmp 8f      ; 2   " 20
    8:	rjmp 9f      ; 2   "
    9:	rjmp 10f      ; 2   "
    10:	rjmp 11f      ; 2   "
    11:	rjmp 12f      ; 2   "
    12:	rjmp 13f      ; 2   " 30
    13:	rjmp 14f      ; 2   "
    14:	rjmp 15f      ; 2   "
    15:	rjmp 16f      ; 2   "
    16:	rjmp 17f      ; 2   "
    17:	rjmp 18f      ; 2   " 40
    18:	rjmp 19f      ; 2   "
    19:	rjmp 20f      ; 2   "
    20:	rjmp 21f      ; 2   "
    21:	rjmp 22f      ; 2   "
    22:	rjmp 23f      ; 2   " 50
    23:	rjmp 24f      ; 2   "
    24:	rjmp 25f      ; 2   "
    25:	rjmp 26f      ; 2   "
    26:	rjmp 27f      ; 2   "
    27:	rjmp 28f      ; 2   " 60
    28:	rjmp 29f      ; 2   "
    29:	rjmp 30f      ; 2   "
    30:	rjmp 31f      ; 2   "
    31:	rjmp 32f      ; 2   "
    32:	rjmp 33f      ; 2   " 70
    33:	rjmp 34f      ; 2   "
    34:	rjmp 35f      ; 2   "
    35:	rjmp 36f      ; 2   "
    36:	nop          ; 1   "
    	ret          ; 3   "
    	.endfunc     ; total 80 cyles = 5.0 microsec with 16 Mhz crystal 
    
    
    ;*************************************************************************
    ; Initialization of the I2C bus interface. Need to be called only once
    ; 
    ; extern void i2c_init(void)
    ;*************************************************************************
    	.global i2c_init
    	.func i2c_init
    i2c_init:
    	cbi SDA_DDR,SDA		;release SDA
    	cbi SCL_DDR,SCL		;release SCL
    	cbi SDA_OUT,SDA
    	cbi SCL_OUT,SCL
    	ret
    	.endfunc
    
    
    ;*************************************************************************	
    ; Issues a start condition and sends address and transfer direction.
    ; return 0 = device accessible, 1= failed to access device
    ;
    ; extern unsigned char i2c_start(unsigned char addr);
    ;	addr = r24, return = r25(=0):r24
    ;*************************************************************************
    
    	.global i2c_start
    	.func   i2c_start
    i2c_start:
    	sbi 	SDA_DDR,SDA	;force SDA low
    	rcall 	i2c_delay_T2	;delay T/2
    	
    	rcall 	i2c_write	;write address
    	ret
    	.endfunc		
    
    
    ;*************************************************************************
    ; Issues a repeated start condition and sends address and transfer direction.
    ; return 0 = device accessible, 1= failed to access device
    ;
    ; extern unsigned char i2c_rep_start(unsigned char addr);
    ;	addr = r24,  return = r25(=0):r24
    ;*************************************************************************
    
    	.global i2c_rep_start
    	.func	i2c_rep_start
    i2c_rep_start:
    	sbi	SCL_DDR,SCL	;force SCL low
    	rcall 	i2c_delay_T2	;delay  T/2
    	cbi	SDA_DDR,SDA	;release SDA
    	rcall	i2c_delay_T2	;delay T/2
    	cbi	SCL_DDR,SCL	;release SCL
    	rcall 	i2c_delay_T2	;delay  T/2
    	sbi 	SDA_DDR,SDA	;force SDA low
    	rcall 	i2c_delay_T2	;delay	T/2
    	
    	rcall	i2c_write	;write address
    	ret
    	.endfunc
    
    
    ;*************************************************************************	
    ; Issues a start condition and sends address and transfer direction.
    ; If device is busy, use ack polling to wait until device is ready
    ;
    ; extern void i2c_start_wait(unsigned char addr);
    ;	addr = r24
    ;*************************************************************************
    
    	.global i2c_start_wait
    	.func   i2c_start_wait
    i2c_start_wait:
    	mov	__tmp_reg__,r24
    i2c_start_wait1:
    	sbi 	SDA_DDR,SDA	;force SDA low
    	rcall 	i2c_delay_T2	;delay T/2
    	mov	r24,__tmp_reg__
    	rcall 	i2c_write	;write address
    	tst	r24		;if device not busy -> done
    	breq	i2c_start_wait_done
    	rcall	i2c_stop	;terminate write operation
    	rjmp	i2c_start_wait1	;device busy, poll ack again
    i2c_start_wait_done:
    	ret
    	.endfunc	
    
    
    ;*************************************************************************
    ; Terminates the data transfer and releases the I2C bus
    ;
    ; extern void i2c_stop(void)
    ;*************************************************************************
    
    	.global	i2c_stop
    	.func	i2c_stop
    i2c_stop:
    	sbi	SCL_DDR,SCL	;force SCL low
    	sbi	SDA_DDR,SDA	;force SDA low
    	rcall	i2c_delay_T2	;delay T/2
    	cbi	SCL_DDR,SCL	;release SCL
    	rcall	i2c_delay_T2	;delay T/2
    	cbi	SDA_DDR,SDA	;release SDA
    	rcall	i2c_delay_T2	;delay T/2
    	ret
    	.endfunc
    
    
    ;*************************************************************************
    ; Send one byte to I2C device
    ; return 0 = write successful, 1 = write failed
    ;
    ; extern unsigned char i2c_write( unsigned char data );
    ;	data = r24,  return = r25(=0):r24
    ;*************************************************************************
    	.global i2c_write
    	.func	i2c_write
    i2c_write:
    	sec			;set carry flag
    	rol 	r24		;shift in carry and out bit one
    	rjmp	i2c_write_first
    i2c_write_bit:
    	lsl	r24		;if transmit register empty
    i2c_write_first:
    	breq	i2c_get_ack
    	sbi	SCL_DDR,SCL	;force SCL low
    	brcc	i2c_write_low
    	nop
    	cbi	SDA_DDR,SDA	;release SDA
    	rjmp	i2c_write_high
    i2c_write_low:
    	sbi	SDA_DDR,SDA	;force SDA low
    	rjmp	i2c_write_high
    i2c_write_high:
    	rcall 	i2c_delay_T2	;delay T/2
    	cbi	SCL_DDR,SCL	;release SCL
    	rcall	i2c_delay_T2	;delay T/2
    	rjmp	i2c_write_bit
    	
    i2c_get_ack:
    	sbi	SCL_DDR,SCL	;force SCL low
    	cbi	SDA_DDR,SDA	;release SDA
    	rcall	i2c_delay_T2	;delay T/2
    	cbi	SCL_DDR,SCL	;release SCL
    i2c_ack_wait:
    	sbis	SCL_IN,SCL	;wait SCL high (in case wait states are inserted)
    	rjmp	i2c_ack_wait
    	
    	clr	r24		;return 0
    	sbic	SDA_IN,SDA	;if SDA high -> return 1
    	ldi	r24,1
    	rcall	i2c_delay_T2	;delay T/2
    	clr	r25
    	ret
    	.endfunc
    
    
    
    ;*************************************************************************
    ; read one byte from the I2C device, send ack or nak to device
    ; (ack=1, send ack, request more data from device 
    ;  ack=0, send nak, read is followed by a stop condition)
    ;
    ; extern unsigned char i2c_read(unsigned char ack);
    ;	ack = r24, return = r25(=0):r24
    ; extern unsigned char i2c_readAck(void);
    ; extern unsigned char i2c_readNak(void);
    ; 	return = r25(=0):r24
    ;*************************************************************************
    	.global i2c_readAck
    	.global i2c_readNak
    	.global i2c_read		
    	.func	i2c_read
    i2c_readNak:
    	clr	r24
    	rjmp	i2c_read
    i2c_readAck:
    	ldi	r24,0x01
    i2c_read:
    	ldi	r23,0x01	;data = 0x01
    i2c_read_bit:
    	sbi	SCL_DDR,SCL	;force SCL low
    	cbi	SDA_DDR,SDA	;release SDA (from previous ACK)
    	rcall	i2c_delay_T2	;delay T/2
    	
    	cbi	SCL_DDR,SCL	;release SCL
    	rcall	i2c_delay_T2	;delay T/2
    	
    	clc			;clear carry flag
    	sbic	SDA_IN,SDA	;if SDA is high
    	sec			;  set carry flag
    	
    	rol	r23		;store bit
    	brcc	i2c_read_bit	;while receive register not full
    	
    i2c_put_ack:
    	sbi	SCL_DDR,SCL	;force SCL low	
    	cpi	r24,1
    	breq	i2c_put_ack_low	;if (ack=0)
    	cbi	SDA_DDR,SDA	;      release SDA
    	rjmp	i2c_put_ack_high
    i2c_put_ack_low:                ;else
    	sbi	SDA_DDR,SDA	;      force SDA low
    i2c_put_ack_high:
    	rcall	i2c_delay_T2	;delay T/2
    	cbi	SCL_DDR,SCL	;release SCL
    i2c_put_ack_wait:
    	sbis	SCL_IN,SCL	;wait SCL high
    	rjmp	i2c_put_ack_wait
    	rcall	i2c_delay_T2	;delay T/2
    	mov	r24,r23
    	clr	r25
    	ret
    	.endfunc
    Hier Code nur für KeyLCD und SRF02 wegen bessere Lesbarkeit:
    Code:
    #include "i2cmaster.h"
    #include den anderen Kram ;-)
    
    //*********** Meine I2C Methoden ***************
    // PORTC0 = SCL ; PORTC1 = SDA
    
    void sda_ein(void){
    	PORTC |=  (1 << PC1);
    }
    
    void sda_aus(void){
    	PORTC &= ~(1 << PC1);
    }
    
    void scl_ein(void){
    	PORTC |=  (1 << PC0);
    }
    
    void scl_aus(void){
    	PORTC &= ~(1 << PC0);
    }
    
    void i2cstart(){
    	
    	sda_ein();
    	asm volatile("NOP");
    	scl_ein();
    	asm volatile("NOP");
    	sda_aus();
    	asm volatile("NOP");
    	scl_aus();
    	asm volatile("NOP");
    	
    }
    
    void i2cstop(){
    
    	sda_aus();
    	asm volatile("NOP");
    	scl_ein();
    	asm volatile("NOP");
    	sda_ein();
    	asm volatile("NOP");
    	
    }
    
    char i2c_byte_lesen(unsigned char ack){
    //---------------------------------------------------------------------------------
    // Liest ein Byte vom i2cbus und prueft das ACK
    
      	unsigned char i,wert=0;
    	DDRC &= ~(1 << DDC1);			//DATA Schreibrechte an Empfaenger uebergeben
    	//sda_ein();						//Aktiviert Pullup da Port als Eingang
      	for (i=0x80;i>0;i/=2)             //shift bit for masking
      	{ scl_ein();                          //bustakt
      	  
    	  if (PINC & (1<<PINC1)) 
    	  {	UART_transmit_string("1");
    		wert=(wert | i);        //read bit  
      	  }
    	  else UART_transmit_string("0");
    	  
    	  scl_aus();  					 
      	}
    	DDRC |= (1 << DDC1);			//DATA Schreibrechte an µC uebergeben
    	if(ack) sda_aus();
    	else sda_ein();
    	asm volatile("NOP");	
      	scl_ein();                            //clk #9 for ack
      	asm volatile("NOP");        			//Pulsbreite ca. 5 us  
    	asm volatile("NOP");		
    	asm volatile("NOP");
      	scl_aus();						    
    
      	DDRC &= ~(1 << DDC1);			//DATA Schreibrechte an Empfaenger uebergeben
    	return wert;
    }
    
    char i2c_byte_schreiben(unsigned char wert){
    //----------------------------------------------------------------------------------
    // Schreibt ein Byte auf den Sensirion 2-Wirebus und prüft das ACK
    
      	unsigned char i,error=0;  
    	DDRC |= (1 << DDC1);			//DATA Schreibrechte an µC uebergeben
      	for (i=0x80;i>0;i/=2)             //shift bit for masking
      	{ if (i & wert) {
    		sda_ein();          //masking value with i , write to i2cbus
    		UART_transmit_string("1");
    		}
      	  else {
    		sda_aus();                        
    		UART_transmit_string("0");
    		}
      	  scl_ein();                          //Takt fuer i2cBUS
      	  asm volatile("NOP");        			//Pulsbreite ca. 5 us  
    	  asm volatile("NOP");		
    	  asm volatile("NOP");         	
      	  scl_aus();
      	}
      	
    	DDRC &= ~(1 << DDC1);			//DATA Schreibrechte an Empfaenger uebergeben
    	//Hier eventuell auf ACK warten weil KeyLcd zu langsam ? waitms 100 oder so
    	//sda_ein();						//Aktiviert Pullup da Port als Eingang
      	scl_ein();                            //clk #9 for ack                        
      	
    	if(PINC & (1<<PINC1)) error=1;		//prueft ACK (PINC1 wird vom Empfaenger auf Low gezogen)
    	else error=0;
    	
    	scl_aus();
    	//sda_aus();						//Deaktiviert Pullup        
      	return error;                     //error=1 im Falle von keinem Acknowledge
    }
    
    int main (void)
    {
    unsigned char a[10];
    unsigned char b[10];
    unsigned char c[10];
    unsigned char d,e;
    unsigned int taste = 0;
    unsigned int sum = 0;
    
    value humi_val,temp_val;
    unsigned int tempo;
    unsigned int humi;
    unsigned int cm;
    float tau_punkt;
    unsigned char error,checksum,hib,lob;
    unsigned long i;
    error=2;
    
    
    DDRC = 0xFF;
    hib=0;
    DDRC &= ~(1 << DDC0);   // PIN als EINGANG
    DDRC &= ~(1 << DDC1); // PIN als EINGANG
    scl_ein(); // Interne Pullups aktivieren
    sda_ein(); // Interne Pullups aktivieren
    
    
    
    
    UART_init();  // UART-Init Funktion ausfhren
    i2c_init();  //P. Fleury i2cmaster init
    
    
    
    
    /* Hier USS Code mit Lib vom P. Fleury
    i2c_start_wait(0xE0);
    error=i2c_write(0x00);
    error=i2c_write(0x51);
    i2c_stop();
    
    for (i=0;i<100000000;i++); //Auf Messungende warten ca 65ms
    
    i2c_start_wait(0xE0);
    error=i2c_write(0x02);
    i2c_rep_start(0xE1);
    hib=i2c_readAck();
    lob=i2c_readNak();
    i2c_stop();
    
    cm= (hib*256)+lob;
    
    itoa(cm,a,10);
    UART_transmit_string(a);
    
    if(error==1) UART_transmit_string("Error beim schreiben");
    else UART_transmit_string("Kein Error beim schreiben");
    /*
    
    
    // Hier Code SRF02 mit meinen Methoden
    /*
    i2cstart();
    i2c_byte_schreiben(0xE0); //Standard Adresse vom USS
    UART_transmit_string(" ");
    i2c_byte_schreiben(0x00); //Register 0
    UART_transmit_string(" ");
    i2c_byte_schreiben(0x51); //Messbefehl in Zentimeter
    UART_transmit_string(" ");
    i2cstop();
    
    i2cstart();
    i2c_byte_schreiben(0xE0); //Standard Adresse vom USS
    UART_transmit_string(" ");
    i2c_byte_schreiben(0x02); //Register 2
    UART_transmit_string(" ");
    i2cstop();
    
    i2cstart();
    i2c_byte_schreiben(0xE1); //Slaveadresse + 1 da lesen wollen
    UART_transmit_string(" ");
    hib=i2c_byte_lesen(ACK);
    UART_transmit_string(" ");
    lob=i2c_byte_lesen(noACK);
    UART_transmit_string(" ");
    i2cstop();
    */
    
    
    //Hier Code KEYLCD mit Lib P. Fleury
    //So kann ich nur ein Zeichen ausgeben und dann error=1
    i2c_start_wait(0x40);
    error=i2c_write(0x68);
    error=i2c_write(0x61); //AB Hier error
    error=i2c_write(0x6C);
    error=i2c_write(0x6C);
    error=i2c_write(0x6F);
    i2c_stop();
    
    if(error==1) UART_transmit_string("Error beim schreiben");
    else UART_transmit_string("Kein Error beim schreiben");
    
    
    
    /* Hier nur KEYLCD Code mit meinen Methoden
    So kann ich 2 Zeichen nacheinander korrekt ausgeben, dritte dann fehler.
    
    i2cstart();
    i2c_byte_schreiben(ADD);
    
    error=i2c_byte_schreiben(0x5A);
    if(error==1) UART_transmit_string("Error1");
    
    error=i2c_byte_schreiben(0x4A);
    if(error==1) UART_transmit_string("Error2");
    
    error=i2c_byte_schreiben(0x57);
    if(error==1) UART_transmit_string("Error3");
    
    i2cstop();
    */
    
    
    }
    Ist doch voll komisch oder ?!

    Hey vielen Dank für eure Hilfe. Ehrlich !! Ich kann einfach keinen
    Fehler finden. Immerhin funktioniert die Kommunikation ja halbwegs.
    Daher ist es im Ansatz richtig.
    Makefile ist OK. Kompilieren klappt auch ohne Error. Ein paar Warnungen , aber die sind egal. Ist ja nur zum experimentieren.

    Viele Grüsse
    Thomas

  3. #3
    Benutzer Stammmitglied
    Registriert seit
    07.12.2004
    Ort
    Leverkusen
    Alter
    37
    Beiträge
    95
    Hallo,

    hab noch was ausprobiert (RN-KEYLCD):

    i2c_start_wait(0x40);
    error=i2c_write(0x6;
    error=i2c_write(0x61);
    error=i2c_write(0x6;
    error=i2c_write(0x61);
    i2c_stop();

    Klappt NICHT !! bzw das erste immer richtig der rest falsch
    also h . . . oder h . . . .

    Wenn ich jedoch es so umschreibe:

    i2c_start_wait(0x40);
    error=i2c_write(0x6;
    i2c_stop();
    i2c_start_wait(0x40);
    error=i2c_write(0x61);
    i2c_stop();
    i2c_start_wait(0x40);
    error=i2c_write(0x6;
    i2c_stop();
    i2c_start_wait(0x40);
    error=i2c_write(0x61);
    i2c_stop();

    Erscheint auf dem LCD wie gewünscht: haha

    Ist doch voll komisch.

    Freue mich über jede Hilfe !!

    Viele Grüsse
    Thomas

  4. #4
    Benutzer Stammmitglied
    Registriert seit
    30.01.2008
    Alter
    24
    Beiträge
    44
    Ich hab auch´n Problem mit dem srf02, die Programme sind zwar Logik- und Syntaxfehlerfrei, hängen sich aber beim Befehl I2C_Start(); auf => Fehler liegt beim Sensor. Ich vermute mal das es `n Problem mit dem Hochfahren des Sensors gibt, dass er erst nen BEfehl braucht, um in den I2C_Modus zu wechseln.
    Wenn ich mehr Weiss, schreib ich´s dir

    Gruß icon_cheesygrin.gif

  5. #5
    Benutzer Stammmitglied
    Registriert seit
    30.01.2008
    Alter
    24
    Beiträge
    44
    Nochmal zu oben; Du musst für den Srf02 einen Pull-up_widerstand haben(ich glaub1,8kO, schau einfach in der Anleitung nach, steht irgendwo drin...), ob du die internen Widerstände abschaltest und welche hinlötest oder einfach die internen aktivierst, ist eigendlich egal...

  6. #6
    Benutzer Stammmitglied
    Registriert seit
    15.02.2008
    Ort
    Fürth
    Alter
    33
    Beiträge
    46
    Hi, ich hab auch ein Problem mit dem SRF02 am I2C Bus:
    Sobald ich die SDA Leitung wie in der Anleitung beschrieben an Pin2 des Erweiterungsboards klemme, leuchtet die entsprechende Diode halb so hell wie die anderen. Das Programm läuft endlos in der Funktion I2C_Start() an der Zeile
    while(!(TWCR & (1<<TWINT)));

    Mein Controllerboard hat einen ATMega32 (ich glaub RN-Control) und ich benutze die I2C Bibliothek vom Peter Fleury. Ich hab keine Widerstäne gelötet sondern den Aufbau genauso wie im Datenblatt vom SRF02 (Seite 9).

    Was mach ich falsch?

    Danke!!!

  7. #7
    Benutzer Stammmitglied
    Registriert seit
    30.01.2008
    Alter
    24
    Beiträge
    44
    Bei I2C braucht man generell irgendwo pullups.....

  8. #8
    Benutzer Stammmitglied
    Registriert seit
    30.01.2008
    Alter
    24
    Beiträge
    44
    Beim srf02 1.8kO

  9. #9
    Benutzer Stammmitglied
    Registriert seit
    15.02.2008
    Ort
    Fürth
    Alter
    33
    Beiträge
    46
    Naja, laut BoardSpec sind ja die internen Pullups immer an, oder nicht? Und anscheinend sind die 10k schwer
    ...
    vlt hab ich wirklich den Sensor gebraten...
    Wenn es das Budget zuläßt, kommt ein neuer her... in der Zwischenzeit hab ich auch noch andre Baustellen
    ...
    trotzdem danke *schnief
    Miniaturansichten angehängter Grafiken Miniaturansichten angehängter Grafiken pullup.png  

  10. #10
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    14.01.2008
    Beiträge
    164
    Ich hab auch´n Problem mit dem srf02, die Programme sind zwar Logik- und Syntaxfehlerfrei, hängen sich aber beim Befehl I2C_Start(); auf => Fehler liegt beim Sensor. Ich vermute mal das es `n Problem mit dem Hochfahren des Sensors gibt, dass er erst nen BEfehl braucht, um in den I2C_Modus zu wechseln.
    das ist schmarren.
    ich progge den srf02 mit Bascom einmal im i2c-modus und einmal im seriellen modus. funktioniert super !!! da gibt es keine hänger...lol....

    mfg

Seite 1 von 2 12 LetzteLetzte

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •