UTMF dekoder mega8

[Fabian (Gast)]

Hi,

habe mir fest vorgenommen die Heizung meines Autos uber die UTMF - 
Signale meines Handys zu steuern.

... eigentlich alles kein Probllem.

Bisher benutze ich zu Testzwecken folgendes Programm:

#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <inttypes.h>
//#include <stdlib.h>

//#include <util/delay.h> //wartefunktion _delay_ms(50) // max. 262.1 ms / F_CPU in MHz
#include <avr/iom8.h> 


//Usart definitionen
#define F_CPU 4000000L
#define BAUD 9600L

#define UBRR_VAL ((F_CPU+BAUD * 8)/(BAUD*16)-1)      //clever runde
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))         //reale Baudrate

#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)      //Fehler in Promille

#if ((BAUD_ERROR>10)||(BAUD_ERROR<-10))
#error Systematischer Fehler in der Baudrate größer 1% und damit zu hoch!
#endif

volatile int8_t gFrequenz;


int uart_putc(unsigned char c)
{
    while (!(UCSRA & (1<<UDRE)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR = c;                      /* sende Zeichen */
    return 0;
}


/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
        uart_putc(*s);
        s++;
    }
}

void init_usart()
{
   UBRRH = UBRR_VAL >> 8;
   UBRRL = UBRR_VAL & 0xFF;
   
   
   UCSRB = (1<<RXEN)|(1<<TXEN);      //UART TX einschalten
   UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);      //Asynchron 8N1
}




ISR(TIMER1_OVF_vect) // veraltet: SIGNAL(SIG_OVERFLOW0) 
{
    // Interrupt Code
  cli(); 
  //uart_putc("x");
  TCNT0=0xF0;
  sei();
}

ISR(TIMER0_OVF_vect) // veraltet: SIGNAL(SIG_OVERFLOW0) 
{
  int8_t izaehl_wert=TCNT1L;
  int8_t izaehl_wert2=TCNT1H;

  TCNT1H=0x00;
  TCNT1L=0x00;

  gFrequenz=izaehl_wert;
  //uart_puts("test");
    TCNT0=0xF0;
}




int main (void)
{
  char s[7];
  gFrequenz="";
  int8_t gizaehl_wert="";
  init_usart();
  DDRC = 0xff;
  DDRD = 0x00;
  sei();

  /*Timer1 ansteuern*/
  TCCR1A=0x00;
  TCCR1B=0x01;


  /*Timer0 eingagssignal T0 zählen*/
  //TCCR0 |= (1<<CS00);
  TCCR0 |= (1<<CS01)|(1<<CS02);
  TIMSK=0x05;
  //TCNT0=0x00;
  TCNT0=0xF0;


  while(1)
  {

    if(gFrequenz!="")
    {
      //itoa( gFrequenz, s, 10 );
      //uart_puts("Frequenz:");
      uart_putc(gFrequenz);
      //uart_puts("\n");
      gFrequenz="";
    }


    //PORTD =PORTD;

  }

}

Kurz zur erklärung:

Am eingang des Timers T0 liegt mein DTMF - Signal. Wenn Timer T0 
überläuft wird der Zählerstand des Timers T1 an die Usart übergeben.

Somit entspricht der übergebene Zählerstand der Frequenz des UTMF - 
Signals und brächte zur Entschhlüsselung der übertragenen Zahlen nur 
noch eingegrentzt werden.

... Funktioniert auch alles ABER!

Ich bekomme keine Stabielen werte. Ein kleines Schwanken der Frequenz 
währe ja OK aber die übergebenen Werte sind selten im gleichen Bereich.

Zum testen habe ich ein konstantes Signal über die PC - Lautsprecher 
ausgegen.


Also meine Frage ist eigentlich was kann ich tun um das Signal genauer 
zu analysieren?

Kommen die Störungen vielleicht von meiner Schaltung am eingant T0? Kann 
ich hier etwas verändern?

[Roland P. (pram)]

(Was ist UTMF? ich denke du meinst DTMF)

Ein DTMF-Signal besteht immer aus 2 Frequenzen: DT = DualTone

Somit kannst du das nicht mit einem einfachen Zähler dekodieren, du 
musst da erheblich mehr Aufwand rein stecken. (z.B. mit dem 
Goertzel-Algorithmus, oder Analyse der Interferenzmuster)

z.B. hier
http://www.franzis.de/elo-das-magazin/mikrocontroller-und-programmierung/avr-anwendungen/dtmf-decoder

oder sowas wie hier
Beitrag "Goertzel-Algorithmus"

Gruß
Roland

[Gast2 (Gast)]

> ... eigentlich alles kein Probllem.

ROFL... Ja eben.