Glockenschlag erzeugen

Zitat:

---

Die Steigerung wären dann Trommeln oder Klangschalen

---

@vajk,
Danke für den Tip, glaub mir, wenn ich irgendwann mal vielleicht mit der Glocke fertig bin, denke ich über Buschtrommeln nach :-)

Was die Sache mit den Interrupts angeht, naja, ich glaube, ich habe micht mit den Stochri schon bei dem Robotertreff unterhalten, natürlich hatte jeder seine Meinung :-)

Klar kann man in diesem Fall schön den Timer pollen aber ohne Interrupts würde ich kein Programm hinkriegen,
Vielleicht ist das ein Tip für Bascomer :-&
Bis der µC alle Register gepusht und wieder gepopt hat, wäre der nächste Interrupt schon an der Reihe :-s

Gruß Sebastian

Tjaja, ich weiß, die Interrupts sind ein harter Streitpunkt. Natürlich kann man nicht bei jedem Programm auf Interrupts verzichten, aber es geht doch in ziemlich vielen Fällen und wenn man sich mal an das Prinzip gewöhnt hat, dann ist es auch gar nicht so schlecht.

Beim Tonereugungsprogramm sieht das folgendermaßen aus

while(1)
{

Ausgabewert ausrechnen ( z.B. sin(freq1)*sin(freq2)*Hüllkurve );
warte auf PWM-timer;
schreibe Wert an timer;

}

Es gilt: die Berechungsroutine darf nur soviel Zeit verbrauchen, dass sie in die Zykluszeit der Ausgabe passt. Das ist übrigens das wesentliche Merkmal eines Echtzeitsystems.

Das Warten auf den Timer benötigt hier sogar weniger Zeit als das Anspringen einer Interruptroutine und es bleiben damit sogar ein paar mehr Zyklen für die Rechenroutine.

Gruss,
stochri

Nun, Dein Beispiel zeigt eine Verwendung, in der das möglich ist .. aber wie löst Du dasd Problem ohne Timer, wenn Du eine Zeitbasis brauchst? Durch eine externe Taktquelle?

Naaaja.

Moderne Programmierer fassen oft deshalb keine Interrupts an, weil
-- sie ein Echtzeit-OS verwenden, und sich nicht in Niederungen wie Zeitbasis, USB, MLI, DMA oder CAN begeben müssem
-- sie es nicht gepeilt bekommen und nicht wirklich wissen, was sie tun, mal eben globel IRQs sperren, weil die nerven und damit das System aushebeln, in einer ISR ne komplette FFT-Berechnung machen wollen, etc.
-- So viele Silicon-Bugs in den µC sind, daß die einzige Funktion, die tut was sie soll, ein NOP ist. Und daher möglichst wenig der HW angefasst wird.

@izaseba

Um Schwebungen zu machen lässt du einfach 2 Pointer durch das sin-Array laufen. Einer langsam, der andere schneller (hast du schon). Die Werte werden dann einfach multipliziert. Da die Werte im Array (bzw die daraus erhaltenen sin-Werte) mit 128 skaliert sind, musst du nur 2 Werte multiplizieren (als signed 16 bit) und dann 7 Bits nach rechts shiften (oder 8 nach rechts und 1 nach links). Dann hat das Produkt die gleiche Skalierung.

Mit der Hüllkurve ähnlich. Nur daß die Hüllkurve wohl direkt berechnet wird.

Zitat:

---

Nun, Dein Beispiel zeigt eine Verwendung, in der das möglich ist .. aber wie löst Du dasd Problem ohne Timer, wenn Du eine Zeitbasis brauchst? Durch eine externe Taktquelle?

---

Das gezeigte Beispiel hat eine Zeitbasis. Der Überlauf des PWM-Timers gibt eine sehr exakte Abtastrate vor.
Der Gag an dem Programm ist, dass wenn die Berechnungen durchgeführt sind, die restliche Zeit einfach gewartet wird bis der Timer übergelaufen ist. Das ganze eben ohne Interrupts.

Hallo,
@Sprinter,
so in etwa habe ich es Gestern versucht, allerdings am PC die Werte für mein Array berechnet und dann direkt auf dem AVR übernommen, irgendwie kam dabei Käse raus, das werde ich dann wohl oder übel am AVR "on the Fly"berechnen, mal schauen.
Es ist lustig so was zu versuchen.
Ich hab mir scilab besorgt um mir "ein Bild" von so einer Multiplikation zu machen, sieht echt lustig aus...
Ich werde mal weiterberichten.
Anbei ein Bild von 200 Hz und 4 Hz Multiplikation

Gruß Sebastian

Hallo Sebastian,

frisch aus der Glockenton Entwicklungsabteilung: Mein neuester Glockenton !

Dank dem Post von Sprinter ist mir aufgefallen, dass man ja gewaltig Rechenzeit durch das weglassen der Multiplikation spart. Anstatt Ton(250Hz)*Ton(6Hz) kann man ja auch (Ton(250Hz)+Ton(256Hz))/2 verwenden. So erreicht man die Schwebungsfrequenz von 6 Hz.

Beim obigen Ton habe ich allerdings 3 Frequenzen verwendet: (Ton(250Hz)/4+Ton(252Hz)/4+Ton(256Hz)/4)*Hüllkurve

Klingt ganz interessant, oder?

Übrigens: Diesmal mit einem Attiny13 produziert !

Mit Scilab kannst Du Deine Kurve auch gleich anhören:

Beispiel:

t=1:10000;
y=sin(t/10);
sound(y)

Stochri, Du bist der Größte!
Super Sache, prost ! Hört sich an als ob Du zwischendurch ein Bierchen aufmachst :-)

Ich muß mich jetzt auch damit weiter auseinandersetzen :roll: ein Tiny ist natürlich perfekt mit zwei Leitungen könnte man die Anzahl der Schläge reinschieben und gut ist.

Danke erstmal

Gruß Sebastian

Hallo,

Ich glaube, ich bin doch zu blöd dafür ](*,)

Habe seit Gestern folgendes Programm stehen ( Heute mal aus Spaß ohne ISR) womit ich mir einen schönen Sinus mit knapp 900Hz erzeuge...

Code:

---

#include<avr/io.h>




int8_t sinwerte[]= {64,76,88,99,109,117,123,126,
                    128,126,123,117,109,99,88,76,
                    64,51,39,28,19,11,5,1,
                    0,1,5,11,19,28,39,51
};


int main(void) {
  uint8_t wert,x=0;
 
  TCCR2 = (1<<WGM20)|(1<<COM21)|(1<<CS20);
  OCR2 = 0;
  /*Timer 0 im Overflowinterrupt*/
  //  TIMSK = (1<<TOIE2);
  DDRB = (1<<PB3);
  PORTB = 0;
 
    while (1) {
      wert = sinwerte[x];
      while(!(TIFR & 1<<TOV2));
      OCR2 = wert;
      TIFR |=(1<<TOV2);
      x++;
      if (x == 33)
        x = 0;
    }
  return 0;
}

---

Nur wie stelle ich das mit der Multiplikation an :-k
Soll man z.B wie der Sprinter schon sagte 2 Zeiger durch die Tabelle durcheiern lassen und bei jedem Überlauf von Timer 2 dann auslesen multiplizieren, schieben und OCR2 damit füttern ?
dazu bräuchte ich wieder einen weiteren Takt, der dann die Zeiger bewegt oder besser gesagt 2 verschiede Takte, weil sie ja unterschiedlich laufen müssen.
Das heißt dann wieder den gemeinsamen Nenner suchen, 2. Timer damit laufen lassen usw. usw.
Ist das so gedacht ?
Ich versuche es jetzt so, vielleicht bin ich wieder auf dem Holzweg...
Gruß Sebastian

EDIT:
Naja, ich glabe ich brauche doch keinen 2. Takt, ich könnte den Timer 2 benutzen ....

Ey Sebastian, du bekommst gleich nen Watschen von mir! ;-)

Code:

---

while (!(TIFR & (1<<TOV2))); // ()
TIFR =  1<<TOV2; // sonst löschen wir alles (TOV2 ist eh gesetzt)

---

Wie schon gesagt kann die Multiplikation zweier Sinüsse durch Summe ersetzt werden (andere Frequenzen und Amplituden). Das Zauberwort ist "Additionstheorem".

Zeit bei der Multiplikation spart man eigentlich nur dann, wenn der AVR keine MUL-Befehle hat. Zwei Sinüsse zu addieren, deren Frequenzen dicht beisammen sind, dürfte schwerer sein, als zu Multiplizieren, wenn sich die Frequqnzen teilen:

Code:

---

{
        uint8_t x1 = 0;
        uint8_t x2 = 0;
        uint8_t f = 0;
        const uint8_t fak = 7; // Teilungsverhältnis der Frequenzen.
       
        uint8_t wert1, wert2 = 0, wert;
       
          while (1)
          {
                      wert1 = sinwerte[x1++];
                      if (0 == f)
                              wert2 = sinwerte[x2++];
                     
                      if (++f == fak)
                          f = 0;
                     
                      wert = (uint16_t) (wert1 * wert2) >> 7;
                     
                      while (!(TIFR & (1 << TOV2)));
                OCR2 = wert;
                TIFR |= (1<<TOV2);

                if (x1 == sizeof(sinwerte) / sizeof(sinwerte[0]))
                        x1 = 0;
                       
                if (x2 == sizeof(sinwerte) / sizeof(sinwerte[0]))
                        x2 = 0;
        }
}

---