Interrupt benutzen ?

[Max D. (maximax)]

Hallo

Mein Name ist Max und ich mache gerade Abitur mit dem Schwerpunkt 
Elektrotechnik. in Informatik arbeiten wir deswegen auch mit 
µControllern.
zurzeit arbeiten wir (und warscheinlich auch bis zum ende der 13) mit 
einem Phillips 80c552. unsere jetzige aufgabe besteht darin ein Programm 
zu schreiben mit denen wir Töne erzeugen können. momentan bin ich soweit 
dass ich eine Funktion ( beep(int frequenz, int länge) ) aufrufen kann 
bei der mann die Parameter für die Frequenz (Tonhöhe) und Dauer (in ms) 
angeben kann.

soweit so gut... leider ist mir beim Testen mit verschiedenen frequenzen 
aber der selben tondauer aufgefallen dass umso höher die Frequenz ist 
umso kürzer ist auch die Dauer. Natürlich liegt das am Aufbau meines 
Programms und ich könnte mir vorstellen wie man das Problem besser lösen 
könnte allerdings haben wir Interrupts noch nicht besprochen :(

Hier habt ihr erstmal meinen Programmcode

#include <REG552.H>

int TonAn=0;
void Beep(int f,int l);

void main (void)               
{  
  TMOD = 0x11;
  while(1) 
  {
   Beep(100,1000);
   Beep(200,1000);  
   Beep(300,1000);
   Beep(400,1000);
   Beep(500,1000);  
   Beep(600,1000);
   Beep(700,1000);
   Beep(800,1000);  
   Beep(900,1000);
   Beep(1000,1000);
   Beep(1100,1000);
   Beep(1200,1000);
   }
}

void Beep(int f,int l) 
{  
int x;

   for(x=0;x<l;x++)
   {
     TR1=0;  
      TH1=0xFC; 
  TL1=0x18; 
      TF1=0;    
      TR1=1;

  do
  {
        TR0=0;  
        TH0=(65536 - (1000000/(f*2)))>>8;
    TL0=(65536 - (1000000/(f*2))) & 0x00FF;
        TF0=0;    
        TR0=1;
        while (TF0 == 0);

        if (TonAn == 0) 
    {
           TonAn=1;
           P4=0xFF;
        }
    else 
    {
          TonAn=0;
          P4=0x00;
        }

  }while(TF1==0);
   }
}

Meine vermutung ist dass das Überlauf Flag TF1 schon auf 1 gesetzt wird 
bevor mein Programmcode überhaupt ans ende der "do-schleife" kommt. 
dadurch
sind niedrigere Frequenzen etwas länger und höhere genauer.

Am liebsten würde ich ja die do-schleifen bedingung (x<l) setzen und 
sobald das überlauf Flag von Timer1 auf 1 gesetzt ist ein x++ machen.

ich hoffe ihr versteht was ich meine.... ansonsten bin ich natürlich für 
alle vorschläge und jede Hilfe sehr dankbar

[Mitleser (Gast)]

Max Dirkschneider schrieb:
> 09.02.2015 12:00:
>     Bearbeitet durch Moderator

(Ist nicht an den Mod gerichtet)

Bitte keine Tabs in Sourcecode verwenden.
Einrückungen konsistent machen damit es lesbar(er) wird.

[Karl H. (kbuchegg)]

Max Dirkschneider schrieb:

> soweit so gut... leider ist mir beim Testen mit verschiedenen frequenzen
> aber der selben tondauer aufgefallen dass umso höher die Frequenz ist
> umso kürzer ist auch die Dauer. Natürlich liegt das am Aufbau meines
> Programms

Nicht wirklich. D.h. Ja, es liegt schon am Aufbau des Programms. Aber 
wenn wir den mal als so gegeben hinnehmen, ist das Problem leicht 
einzusehen.

Hz bedeutet Schwingungen pro Sekunde.
Wenn du also eine Schwingung mit 440Hz erzeugst, dann macht die in 1 
Sekunde 440 Schwingungen. Logisch?
Gut. Wenn du aber eine Schwingung mit 880Hz erzeugst, dann jast du 
logischerweise in 1 Sekunde 880 Schwingungen. Machst du hier ebenfalls 
nur 440 Schwingungen, dann ist der Ton nur eine halbe Sekunde lang.

Auf einen Nenner gebracht: Wenn du deine Funktion die 'Zeit' in der Form 
angibst, dass du der Funktion mitgibst wieviele Schwingungen sie 
erzeugen soll, dann musst du in dieser Anzahl auch die Frequenz 
einrechnen, damit du auf Zeiten kommst. Einfach immer nur 1000 
hinschreiben ist zu wenig.



Edit: Ich zieh den Einwand zurück.
Ein genauerer Blick zeigt, dass da 2 Timer im Spiel sind, von denen 
einer als echter Zeitzähler benutzt wird.

[Max D. (maximax)]

Karl Heinz


vielen vielen Dank für diese elegante Lösung dadurch brauche ich ja 
nicht einmal einen zweiten Timer.(wenn ich das richtig verstanden habe)

Ich versuche mich mal daran und melde mich wenn ich es geschaft habe 
oder noch am verzweifeln bin.

:)

Edit: wieso wurde jetzt die Antwort von Karl Heinz gelöscht !?

[Karl H. (kbuchegg)]

Max Dirkschneider schrieb:
> Karl Heinz
>
>
> vielen vielen Dank für diese elegante Lösung

Ich habs zurück gezogen.

Du benutzt offenbar 2 Timer, wobei einer die echte Zeit abzählt.
Im Moment denke ich, deine Analyse des Problems ist korrekt.
Was ich ändern würde: den Timer 1 10 mal so weit zählen lassen und dafür 
die Zeiten durch 10 dividieren.

Dann läufst du nicht so schnell Gefahr, dass dir der Timer 1 von 0xFC18 
bis zum Überlauf hochzählt, während der andere Schwingungen erzeugt, die 
du jeweils abwartest.

Du kannst natürlich auch einfach Schwingungen zählen. Geht auch.

Man könnte natürlich auch die beiden Schleifen ineinander schachteln und 
somit nur 1 Schleife haben, die sich an der Spieldauer orientiert und 
den 2-ten Timer nach dem Portumschalten jeweils wieder neu startet.

[Ulrich F. (Gast)]

> Edit: wieso wurde jetzt die Antwort von Karl Heinz gelöscht !?
Wer kann das wissen, warum er seine Antwort löscht....
Vielleicht war sie falsch, vielleicht hat er aus Versehen 
Urheberrechtlich geschützten Code publiziert, wer weiß .......
Er wird schon seinen Grund haben.

Edit: Zu spät....

[Karl H. (kbuchegg)]

Ulrich F. schrieb:
>> Edit: wieso wurde jetzt die Antwort von Karl Heinz gelöscht !?
> Wer kann das wissen, warum er seine Antwort löscht....
> Vielleicht war sie falsch

Sie war nicht angemessen. Aber ich war zu langsam und die Antwort wurde 
schon gelesen.

[Max D. (maximax)]

Hallo nochmal
Dank Karl Heinz habe ich mich dafür entschieden einen Timer wegzulassen
um dann einfach die Tondauer durch die Zyklenanzahl festzulegen.
Leider habe ich jetzt ein genau umgekehrtes Problem.
Aus irgendeinem Grund der mir verborgen bleibt sind jetzt höhere 
Frequenzen
wesentlich länger als tiefe. Dabei hatte ich zu Beginn genau das 
gegenteilige Problem.

Hatt jemand ne Ahnung was ich da wieder falsch gemacht habe ?

#include <REG552.H>

int TonAn=0;
void Beep(int f,int l);

void main (void)               
{  

  TMOD = 0x11;
  while(1) 
   {
    Beep(50,1000);
    Beep(200,1000);  
    Beep(600,1000);
    Beep(1200,1000);
   }
}

void Beep(int f,int l) 

{  
int x;
x = f*(l/1000);

  do
  {
      TR0=0;  
      TH0=((65536 - (1000000/(f*2))) & 0xFF00 ) >> 8;
      TL0=(65536 - (1000000/(f*2))) & 0x00FF;
      TF0=0;    
      TR0=1;
      while (TF0 == 0);

      if (TonAn == 0) 
      {
        TonAn=1;
        P4=0xFF;    
      }
     
      else 
      {
        TonAn=0;
        P4=0x00;
        x--;
      }

  
    
  }while(x != 0);
  
 }

[Andy (Gast)]

Hallo Max,

der Mikrocontroller braucht für jede Verarbeitung eines Befehls eine 
gewisse Anzahl von Zyklen. Deine Berechnung der Timer-Vorbelegung ist 
relativ rechenintensiv. Je höher die Frequenz wird, desto häufiger muss 
deine Schleife durchlaufen werden, um auf die theoretisch gleiche 
Ton-Dauer bei unterschiedlichen Frequenzen zu kommen. Durch die ständige 
Neuberechnung wird die Dauer der Schleifen also proportional länger. 
Daher werden die hohen Töne auch länger abgespielt. Darüber hinaus hören 
sich dich Töne auch nicht mehr korrekt an.
Pro Ton/Frequenz musst du die Timerbelegung nur einmal berechnen und 
zwar außerhalb der Schleife. Dann hören sich die Töne auch korrekt an.
Ich habe noch ein paar zusätzliche Optimierungen eingefügt, damit die 
Anzahl der Befehle innerhalb der Schleife möglichst gering ist (Weil 
jeder Befehl eine zusätzliche ungewollte Verzögerung bewirkt).

MfG
Andreas Wolff

#include <REG552.H>

void Beep(int f,int l);

void main (void)               
{  
  TMOD = 0x01;
  TR0=1;
  while(1) 
   {
    Beep(50,1000);
    Beep(200,1000);  
    Beep(600,1000);
    Beep(1200,1000);
   }
}

void Beep(int f,int l) 
{  
  int x=f/5*(l/100);  // Divisor 5, da 100ms als Basis gewählt wurde. l in ms
  unsigned char TimerHigh = ((65536 - (1000000/(f*2))) & 0xFF00 ) >> 8;
  unsigned char TimerLow  = (65536 - (1000000/(f*2))) & 0x00FF;
  do
  {
      TH0=TimerHigh;
      TL0=TimerLow;
      TF0=0;    
      while (TF0 == 0);
    P4=~P4;
    x--;    
  }while(x >0);  
 }