Hi,

hat jemand von euch den Code für SRF02 über UART programmieren.

Ich habe einen Code geschrieben aber der hat leider nicht funktioniert. Ich verwendet ein ATmega128 mit 2 UART. Das erste habe ich zum Debug vervendet. An den zweite habe ich den Ultraschallsensor angeschloßen (selbstverständlich an TTL 5V). Die Funktionen zum Ansprechen des Sensor und Bearbeitung der Daten wurde in main(Ultraschallsensor.c) und in einer Schleife aufgerufen.
Code:
#include "Ultraschallsensor.h"
#include "uart1.h"
unsigned volatile char SioTmp1 = 0;

unsigned volatile char SendeBuffer1[MAX_SENDE_BUFF1];
unsigned volatile char RxdBuffer1[MAX_EMPFANGS_BUFF1];

unsigned volatile char NeuerDatensatzEmpfangen1 = 0;
unsigned volatile char AnzahlEmpfangsBytes1 = 0;
unsigned volatile int  wandabstand;
unsigned volatile char UebertragungAbgeschlossen1 = 1;

void Sensoranforderung(void);





unsigned volatile int test1=0;

//############################################################################
//INstallation der Seriellen Schnittstelle




void UART1_Init (void)
//############################################################################
{
    //Teiler wird gesetzt UBRR=UBRR0L Siehe Seite 174 von Atmega 644P wegen des Double Speed Modus
	
	uint8_t sreg = SREG;
	uint16_t ubrr = (unsigned int) ((unsigned long) F_CPU/(8 * BAUD_RATE1) - 1);
	cli();

	// disable RX-Interrupt
	UCSR1B &= ~(1 << RXCIE1);
	// disable TX-Interrupt
	UCSR1B &= ~(1 << TXCIE1);
	// disable DRE-Interrupt
	UCSR1B &= ~(1 << UDRIE1);

	// set direction of RXD1 and TXD1 pins
	// set RXD1 (PD2) as an input pin
	PORTD |= (1 << PORTD2);
	DDRD &= ~(1 << DDD2);
    
	// set TXD1 (PD3) as an output pin
	PORTD |= (1 << PORTD3);
	DDRD  |= (1 << DDD3);
    
	// USART0 Baud Rate Register
	// set clock divider
	UBRR1H = (uint8_t)(ubrr>>8);
	UBRR1L = (uint8_t)ubrr;

    // enable double speed operation
	// UCSR1A |= (1 << U2X1);
	// enable receiver and transmitter
	UCSR1B = (1 << TXEN1) | (1 << RXEN1);
	// set asynchronous mode
	UCSR1C &= ~(1 << UMSEL1);
	
	// no parity
	UCSR1C &= ~(1 << UPM11);
	UCSR1C &= ~(1 << UPM10);
	// 2 stop bit
	UCSR1C |= (1 << USBS1);
	//UCSR1C &= ~ (1 << USBS1);
	// 8-bit
	UCSR1B &= ~(1 << UCSZ12);
	UCSR1C |=  (1 << UCSZ11);
	UCSR1C |=  (1 << UCSZ10);

	// flush receive buffer explicit
	while ( UCSR1A & (1<<RXC1) ) UDR1;

	// enable interrupts at the end
	// enable RX-Interrupt
	UCSR1B |= (1 << RXCIE1);
	// enable TX-Interrupt
	UCSR1B |= (1 << TXCIE1);
	// enable DRE interrupt
	//UCSR1B |= (1 << UDRIE1);

	// restore global interrupt flags
    SREG = sreg;
	
	/*
	UCSR1B=(1 << TXEN1) | (1 << RXEN1);
    // UART Double Speed (U2X) USR=UCSR0A
	UCSR1A   |= (1<<U2X1);           
	// RX-Interrupt Freigabe
	UCSR1B |= (1<<RXCIE1);           
	// TX-Interrupt Freigabe
	UCSR1B |= (1<<TXCIE1);   
	UBRR1L=(F_CPU / (BAUD_RATE1 * 8L) - 1);
        
    */
	
	
 }

//---------------------*********--------------------------------//
// Weitere Befehl an Sensordaten senden 
 //ISR(SIG_USART1_DATA)
 ISR(SIG_USART1_TRANS)//USART1_TX_vect)

{
 static unsigned int ptr = 0;
 unsigned char tmp_tx;
 if(!UebertragungAbgeschlossen1)  
  {
   ptr++;                    // die [0] wurde schon gesendet
   tmp_tx = SendeBuffer1[ptr]; 
   
   if((tmp_tx == 84) || (ptr == MAX_SENDE_BUFF1))
    {
     ptr = 0;
     UebertragungAbgeschlossen1 = 1;
	 
    }
   UDR1 = tmp_tx; //Put data in the buffer ,sends the data
   uart_puts("In Sendenvorgang springen \n"); 
  } 
  else ptr = 0;

} 
 

//---------------------*********--------------------------------//
// Sensordaten empfangen
 ISR(SIG_USART1_RECV)     //USART1_RX_vect
 {
 static unsigned char buf_ptr;
 
  
 uart_puts("Empfangsvorgang springen \n"); 
 SioTmp1 = UDR1; 
// test1++;
//test1 = SioTmp1;

//  alte Daten schon verarbeitet
 if(!NeuerDatensatzEmpfangen1)
	  {
	   NeuerDatensatzEmpfangen1=1;
	  
	  }	
// Buffer voll 
 if  (buf_ptr==MAX_EMPFANGS_BUFF1)
      
      {
       buf_ptr=0;
	  }
// Datenbytes des Ultraschalls im Buffer speichern
 RxdBuffer1[buf_ptr++] = SioTmp1; 
	
//test1 = SioTmp1;  
 }




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

void Sensoranforderung(void)
{

// Packen Daten in Buffer, sendet Daten
  //Übertragungvorgang noch nicht abgeschlossen -> nichts weitere übertragen
  if(!UebertragungAbgeschlossen1) return;
  //Messen in centimeter
  SendeBuffer1[1]=84;
  //ID von Sensor aufrufen
  SendeBuffer1[0]=4;
  //erste Byte im Buffer senden, gleichzeitig wird ISR vom UART1 für Senden aktiviert
  UebertragungAbgeschlossen1=0;
  
  UDR1 = SendeBuffer1[0];
  
  uart_putc(SendeBuffer1[0]);

}  
 
 
 
 void BearbeiteRxDaten1(void)
{
 
 if(!NeuerDatensatzEmpfangen1) return;
  
  wandabstand =   RxdBuffer1[1];
  wandabstand =+ RxdBuffer1[0]<<8;
  NeuerDatensatzEmpfangen1 = 0;
  
 }
Ich habe den Mustercode im Bascom ausprobiert und es hat funktioniert. Das heißt, es Fehler bei meinem Code gibt. Ich habe ein paar Zeil über andere UART zum Debug übertragen und mit Terminalprogramm angeschaut. Die ISR Receive wird niemals hineingesprungen.Der Ultraschallsensor funktioniert unter UART Modus mit Baudrate 9600,8 Data Bit, 2 Stop Bit.

Kann jemand von euch mir helfen?

Viele Grüsse