Audio MSP430

Guten Abend Rainer, vielen Dank für deine Antwort.

Hab das jetzt mit der Auflösung soweit verstanden.



Rainer U. schrieb:
>> Der erforderte Speicher für beispielsweise 5 Sekunden auf der SD-Karte
>> wären dann doch: 128 kBit/s / 8 x 5 = 80 Byte
>> Ist das so korrekt?
>
> nein. Mach mal 'nen Überschlag mit dem Wert oben :-)


Ach total vertan, hab das kilo vergessen, bedeutet es wären dann 80.000 
Byte.


Ich hab eine erklärung gefunden wie man umgeht, wenn man den Speicher 
ausrechnen möchte miteinbezogen dem Takt der CPU und der PWM.

Bleiben wir bei dem Beispiel mit den 5 Sekunden Audiodatei.
Bei einer CPU Frequenz von 16 MHz, einer gewählten Auflösung von 16-Bit 
bekäme ich eine PWM Frequenz von 16 Mhz / 2^16 = 244 Hz und wenn ich das 
nun durch 2 teilen müsste, wegen dem Nyquist-Theorem, bekäme ich dann 
eine hörbare Frequenz von 122 Hz?! So und diese dann noch mal der 5 
Sekunden, bekäme ich 610 Byte.

Das scheint mir aber sehr wenig zu sein. Kann das soweit stimmen, oder 
hab ich wieder ein blöden Fehler gemacht?

Hallo,

hab da noch eine Frage.

Wenn ich statt PWM die DAC benutze und mittels DMA die Daten vom Flash 
raushole und dem DAC übergebe, brauch ich da unbedingt eine 
samplingrate?
Im Datasheet bspw. von dem msp430f2619 finde ich unter dem Kapitel DAC 
nichts zu einer conversion time, wie es der Fall bei dem ADC ist.

Und noch eine Frage bezüglich des Arrays, wie groß muss das Array mind. 
sein wenn ich eine .wav Datei da ablegen möchte?

Rufus Τ. F. schrieb:
> Florian schrieb:
>> brauch ich da unbedingt eine samplingrate
>
> Natürlich. Das ist die Geschwindigkeit, mit der die Daten dem
> D/A-Wandler übergeben werden.

Hallo Rufus, danke für die Antwort. Wenn ich einen Blick in das 
Datasheet von dem msp430f2619 werfe, finde ich aber in den Tabellen 
nichts dazu.

Kannst du mir einen Tipp geben, wo ich das finde?


Rufus Τ. F. schrieb:
> Wie groß ist eine .wav-Datei?

Nun ja, wie oben schon ausgerechnet mit den gleichen Parameter, müsste 
dass dann bei 5 Sekunden .wav Datei einer Größe von 80 kByte sein.


Aber was hat das dann mit der Rechnung mit der PWM zutun? Wo ich weiter 
oben eine Größe von 610 Byte herausbekomme.


Bin für jeden Tipp und Ratschlag sehr dankbar

> eine hörbare Frequenz von 122 Hz?! ... bekäme ich 610 Byte

16 Bit Auflösung gehen schlicht und einfach nicht mit deiner PWM.

Du musst umgekehrt rechnen. Du nimmst die PWM Frequenz und die 
gewünschte Audiofrequenz. Berechnest damit die mögliche Auflösung. Da 
werden so 12 Bit herauskommen.

Nächstes Problem. Dein MC muss die Daten von der Karte holen, in 12 Bit 
verschieben und die PWM-Register rechtzeitig füllen. Klappt nur, wenn du 
die Interrupts geschickt nutzt und auf den Overhead sauberer 
Programmierung verzichtest.

Danke für die Antworten Leute.

Noch einer schrieb:
> Du musst umgekehrt rechnen. Du nimmst die PWM Frequenz und die
> gewünschte Audiofrequenz. Berechnest damit die mögliche Auflösung. Da
> werden so 12 Bit herauskommen.

Ich hab das mal umgekehrt gerechnet, wie du mir das empfohlen hast.

Zum Verständnis: Die maximale PWM Frequenz ist ja die max. Clock 
Frequenz (hier wenn man den DCO verwendet wären das 16 MHz) geteilt 
durch 2, entspricht 8 MHz.

Diese 8 MHz teile ich nun durch meine gewünschte Audiofrequenz (ich nehm 
mal die max. Hörbare Frequenz, dass wären 20 kHz) multipliziere das mit 
2, wegen dem Gesetz nach Shannon für die Abtastrate und bekomme 40 kHz 
heraus.

Teile ich nun 8 MHz / 40 kHz bekomme ich = 200 dann zieh ich mittels 
logarithmus duales den exponenten und erhalte 7,6 Bit.




Rufus Τ. F. schrieb:
> Was aber hat das mit PWM zu tun? Wenn Du einen DAC verwendest, gibt es
> keine PWM; die PWM ist ein Trick, einen DAC nachzuahmen. Wenn Du aber
> einen hast (wie im 'F2619), dann musst Du keinen nachahmen.
>
> Du solltest Dir vielleicht nochmal genau überlegen, was Du eigentlich
> erreichen willst -- und womit.

Danke für den Tipp. Mein Vorhaben war, ehe ich mir einen neuen MCU 
kaufe, ich erstmal mittels PWM schauen bzw. hören wollte, wie die 
Qualität des zu wiedergebenen Audio ist.



Clemens L. schrieb:
> Der F2619 hat R2R-DACs. Die arbeiten theoretisch unendlich schnell,
> allerdings haben die Eingangs- und Ausgangs-Puffer Grenzen (siehe
> "settling time" und "slew rate" im Datenblatt), die du mit den
> DAC12AMP-Bits auch anpassen kannst.

Danke, werde ich mir behalten!

> Teile ich nun 8 MHz / 40 kHz

Anfangs warst du noch der Meinung, 4 kHz reichen dir. Und die Player mit 
PWM haben alle Tiefpassfilter mit 3-4 KHz.

10-12 Bit und 4-8 kHz wird da als bester Kompromiss angesehen. Mehr 
Qualität geht mit Mikrocontroller PWM nicht.

@noch einer

Danke nochmals für deine Antwort.


Vor ein paar Tagen bekam ich nun einen MSP mit integrierten DAC 
ausgeliehen.


Ich habe auch soweit erfolgreich ein Summen mittels Array bzw. Schleife 
wiedergeben können.


Da ich aber nun unterschiedliche Frequenzen wiedergeben muss, um eine 
gescheite Melodie zu hören, bedarf es mehr Hintergrundwissen. Das 
Internet habe ich auch schon nun seid paar Tagen durchfostert finde aber 
keine nützlcihe Literatur die schritt-für-schritt erklärt wie man 
mittels array verschiedene Melodien ausgibt.

Hier wollte ich mich nun an euch wieder wenden, ob ihr evtl ein paar 
nützlcihe LINKs kennt, auf denen ich noch nicht gestoßen bin.

Sowas geht ohne SD-Karte, mit nur 8 MHz (avr), R2R-DAC:

http://m.youtube.com/watch?v=_uU4BzSQQmY

http://www.linusakesson.net/hardware/chiptune.php

Sourcecode ist dabei, vielleicht inspiriert er dich :)

@Planlos:
Ja danke für die Internetseite.


Rainer U. schrieb:
> Schritt 1) lade Deine Daten in das Array (am einfachsten eine WAV-Datei)
> Schritt 2) lies das Array in einer Schleife aus und gib die Werte an den
> DAC

Hallo Rainer, vielen Dank für die Hilfe. Das hab ich schon getan kam 
leider nur unsinn heraus.

Hab dann nachdem ich hier wieder reingeschrieben habe, weiter das 
Internet  und das Forum hier durchforstet und stieß dann auf einen 
älteren Thread wo jemand das gleiche mal vorhatte. Werde von dort den 
Lösungsvorschlag mal ausprobieren, hoffe das es dann klappt.

Was ich bis jetzt habe ist das hier:

1

#include <msp430f1611.h>

2

3

4

//    note  periode  frequency

5

#define c   3830    //261Hz     0.

6

#define d   3400    //294Hz     1.    

7

#define e   3038    //329Hz     2.

8

#define f   2864    //349Hz     3.

9

#define g   2550    //392Hz     4.

10

#define a   2272    //440Hz     5.

11

#define h   2028    //493Hz     6.

12

#define C   1912    //523Hz     7.

13

14

15

//Rest

16

#define R   0       //          8.

17

18

19

// Funktions-Prototypen

20

void setup();

21

void delay(unsigned int m_sec);

22

23

24

// globale Variablen

25

unsigned int i = 0, y=0, z=0;

26

27

int thisNote = 0;

28

29

30

// globale Arrays

31

int melody[]={c,d,e,f,g,g,a,a,a,g,a,a,a,g,f,f,f,f,e,e,d,d,d,d,c,R};

32

33

int noteDurations[] = {4,8,8,4,4,4,4,4,8,8,8,8,8,8,4,4,4,4,8,8,4,4,4,4,8};

34

35

36

// alle meine Entchen: c d e f g g a a a g a a a g f f f f e e d d d d c

37

38

39

40

41

// Hauptprogramm

42

int main(void)

43

{

44

  WDTCTL = WDTPW + WDTHOLD;

45

46

  ADC12CTL0 = REF2_5V + REFON;                          // interne Referenzspannung auf 2,5V

47

  DAC12_0CTL = DAC12IR + DAC12AMP_7 + DAC12ENC;         // DAC12 initialisieren

48

49

  // Clock einstellen

50

  BCSCTL1 &= ~XT2OFF;       // Quarz mit 8 MHz

51

  do

52

  {

53

    IFG1 &= ~OFIFG;

54

    for(z= 0xFFF; i > 0; i--) {}; //warte 512 us

55

  }

56

57

  while((IFG1 & OFIFG) != 0);   // bis Oszillator eingeschwungen

58

59

  BCSCTL1 |= XTS;

60

61

  // für MCLK: Wähle XT2 und Teiler 8

62

  // für SMCLK: Wähle XT2 und Teiler 8

63

  BCSCTL2 |= SELM_2 + DIVM_3 + SELS + DIVS_3;

64

65

66

  while(1)

67

  {

68

    setup();

69

70

    thisNote = 0;

71

72

    delay(1000);

73

  }

74

}

75

76

77

78

void tone(unsigned int Note, unsigned int Duration)

79

{

80

  DAC12_0DAT = Note*Duration;

81

}

82

83

84

85

void setup()

86

{

87

  for (thisNote = 0; thisNote < 7; thisNote++)

88

  {

89

    int noteDuration = 1000/noteDurations[thisNote];

90

91

92

93

    tone (melody[thisNote], noteDuration);

94

95

96

97

    int pauseBetweenNotes = noteDuration * 1.30;

98

99

    delay(pauseBetweenNotes);

100

  }

101

102

}

103

104

105

106

void delay(unsigned int m_sec)

107

{

108

  while(m_sec--)

109

        {

110

    __delay_cycles(800);

111

        }

112

}

Die Clock und die delay Funktion sind noch nciht richtig eingestellt, 
dass muss ich noch machen.
Und die Noten länge, habe ich erstmal willkürlich gewählt.

@Rainer:
Danke für den Tipp den werde ich gleich mal ausprobieren.

Rainer U.:
> Ach so, Du willst Töne einer Tonleiter ausgeben..

Naja fürs erste, da mein ersteres Vorhaben, in einem Array den Hexcode 
speichern und dann per DAC ausgeben, nicht funktioniert hat und ich dann 
den Tipp nachgehen wollte.


Mein erstes Ziel liegt noch darin, dass ich eine beliebe WAV Audio Datei 
mittels Programm in Hexadezimal umwandel, und das wiedergebe.

@Rainer:

Ich hab das jetzt nicht so ganz gemacht wie du es mir geschildert hast, 
funktioniert aber, auch wenn die Melodie etwas zu schnell abgespielt 
wird.

Und zwar dauert eine Melodie ca. 75ms, statt den gewünschten 15sek.
Kommt aber noch!

Hier mein Code bisher.
Die Notenlänge hab ich noch nicht implementiert.

1

#include <msp430f1611.h>

2

3

4

5

6

//#define c 261   // 0.

7

//#define d 294   // 1.

8

//#define e 329   // 2.

9

//#define f 349   // 3.

10

//#define g 391   // 4.

11

//#define a 440   // 5.

12

13

14

// Werte für das CCR0 Register

15

// Formel: CCR0 = Clock (8MHz) / anzahl Array (200) * gew. Frequenz

16

17

#define a 91    // 0. Herz: 440

18

#define c 153   // 1. Herz: 261

19

#define d 136   // 2. Herz: 294

20

#define e 122   // 3. Herz: 329

21

#define f 115   // 4. Herz: 349

22

#define g 102   // 5. Herz: 391

23

24

25

//Rest

26

#define R   0   // 6.

27

28

29

// globale Variable

30

int dieseNote = 0;

31

int z=0;

32

33

34

35

// Funktions-Prototypen

36

void setup();

37

void delay(unsigned int m_sec);

38

39

40

// globale Arrays -- alle meine Entchen: 

41

int melody[]     = {c,d,e,f,g,g,a,a,a,g,a,a,a,g,f,f,f,f,e,e,d,d,d,d,c};

42

short interval[] = {8,8,8,8,8,8,8,4,8,8,8,4,4,4,8,8,8,8,8,4,4,8,8,8,8};

43

44

//Sinus table values

45

int sin_vector[] = {2048, 2112, 2177, 2241, 2305, 2368, 2432, 2495, 2557, 2619, 

46

2681, 2741, 2802, 2861, 2920, 2977, 3034, 3090, 3145, 3199, 3251, 3303, 3353, 3402, 

47

3449, 3495, 3540, 3583, 3625, 3665, 3704, 3741, 3776, 3810, 3842, 3872, 3900, 3927, 

48

3951, 3974, 3995, 4014, 4031, 4046, 4059, 4070, 4079, 4086, 4091, 4094, 4095, 4094, 

49

4091, 4086, 4079, 4070, 4059, 4046, 4031, 4014, 3995, 3974, 3951, 3927, 3900, 3872, 

50

3842, 3810, 3776, 3741, 3704, 3665, 3625, 3583, 3540, 3495, 3449, 3402, 3353, 3303, 

51

3251, 3199, 3145, 3090, 3034, 2977, 2920, 2861, 2802, 2741, 2681, 2619, 2557, 2495, 

52

2432, 2368, 2305, 2241, 2177, 2112, 2048, 1984, 1919, 1855, 1791, 1728, 1664, 1601, 

53

1539, 1477, 1415, 1355, 1294, 1235, 1176, 1119, 1062, 1006, 951, 897, 845, 793, 743, 

54

694, 647, 601, 556, 513, 471, 431, 392, 355, 320, 286, 254, 224, 196, 169, 145, 122, 

55

101, 82, 65, 50, 37, 26, 17, 10, 5, 2, 1, 2, 5, 10, 17, 26, 37, 50, 65, 82, 101, 

56

122, 145, 169, 196, 224, 254, 286, 320, 355, 392, 431, 471, 513, 556, 601, 647, 694, 

57

743, 793, 845, 897, 951, 1006, 1062, 1119, 1176, 1235, 1294, 1355, 1415, 1477, 1539, 

58

1601, 1664, 1728, 1791, 1855, 1919, 1984};

59

60

61

62

  int laenge_melody = (sizeof(melody) / sizeof(int));

63

  int laenge_array  = (sizeof(sin_vector) / sizeof(int));

64

65

66

67

//------------- Interrupt ---------------------

68

#pragma vector = TIMER0_A0_VECTOR

69

__interrupt void TIMERA0(void)

70

{

71

  DAC12_0DAT = sin_vector[z];

72

73

74

  if(z<(sizeof(sin_vector) / sizeof(int)))

75

  {

76

    z++;

77

  }

78

  else

79

  {

80

    z=0;

81

82

    dieseNote++;

83

84

    setup();

85

  }

86

87

88

  TACTL &= ~TAIFG;  

89

}

90

91

92

93

//------------------------------ main -------------------------------------------

94

int main( void )

95

{

96

  // Stop watchdog timer to prevent time out reset

97

  WDTCTL = WDTPW + WDTHOLD;

98

99

100

//--------------- DAC einstellen --------------------  

101

  ADC12CTL0 = REF2_5V + REFON; // interne Referenzspannung auf 2,5V

102

  DAC12_0CTL = DAC12SREF_0 + DAC12IR + DAC12AMP_7 + DAC12ENC;   // DAC12 initialisieren

103

//---------------------------------------------------  

104

105

//--------------- Clock einstellen --------------------

106

  BCSCTL1 &=  ~XT2OFF;                  // XT2 aktivieren

107

108

  do

109

  {

110

    IFG1 &= ~OFIFG;                     // Oscillator-Fault-Flag löschen

111

    for(int warte = 0xFF; warte > 0; warte--);  // warte 50 us

112

  }

113

  while((IFG1 & OFIFG) != 0);           // bis Oszillator eingeschwungen

114

115

116

//   für MCLK: Wähle XT2 und Teiler 1

117

//   für SMCLK: Wähle XT2 bzw. XT1 und Teiler 1

118

  BCSCTL2 |= SELM_2 + DIVM_0 + SELS + DIVS_0;

119

//------------------------------------------------------  

120

121

  setup();

122

123

//---------------- Timer konfig ------------------------

124

  TACTL |= TACLR;

125

126

  TACCTL0 = CCIE;                       // Cap/Comp-Interrupt aktivieren

127

128

  TACTL |= TASSEL_2 + MC_1 + ID_0;      // wähle SMCLK, DIV=1, Upmode

129

130

  TACTL |= TAIE;

131

//------------------------------------------------------

132

133

134

  __enable_interrupt();

135

136

137

  _BIS_SR(OSCOFF);         // schalte DCO aus

138

139

140

141

  while(1)

142

  {

143

144

  }

145

146

}

147

//-------------------------------------------------------------------------------

148

149

150

//-------- unter Funktionen ----------

151

152

// alle meine Entchen: c d e f g g a a a g a a a g f f f f e e d d d d c

153

154

155

void setup(void)

156

{

157

  if(dieseNote < laenge_melody)

158

  {

159

    switch(melody[dieseNote])

160

    {

161

      case a:       TACCR0 = a; break;

162

      case c:       TACCR0 = c; break;

163

      case d:       TACCR0 = d; break; 

164

      case e:       TACCR0 = e; break;

165

      case f:       TACCR0 = f; break;

166

      case g:       TACCR0 = g; break;

167

168

      default:      TACCR0 = R; break;

169

    }

170

  }

171

  else

172

    {

173

      dieseNote = 0;

174

      delay(10);

175

    }

176

}

177

178

179

void delay(unsigned int m_sec)

180

{

181

  while(m_sec--)

182

        {

183

    __delay_cycles(8000);  // 1000 for 1MHz

184

        }

185

}

Ich hab statt ein Rechteck, einen Sinus benutzt den ich wie man sieht in 
einem Array abgelegt habe.

Bin für Jedermann's Vorschläge dankbar, wie ich nun sinnvollerweise die 
Notenlänge programmiere, damit da auch was vernünftiges heraus kommt.

Ok habs hinbekommen, endlich höre ich was gescheites!

Hab einfach den zweiten array mit eingebunden, damit ich pro Note nicht 
nur eine Periode bekomme, sondern bezüglich der Notenlänge X-viele 
Perioden ich ausgebe.

Wenn jemand weitere Anregungen hat, wie man den letzten Schritt evtl 
eleganter gestaltet hätte bzw. andere Stellen, bin ich für jeden 
Dankbar.

Kannst du bitte einmal erklären, wie das Ganze funktioniert? DAC, Timer, 
Interrupt, ..., Sinustabelle, ...

Rainer U. schrieb:
> Der Rhythmus sieht etwas schräg für mich aus, und der Text hat
> Migrationshintergrund? ("Alle Meine Entchen schwimmem auf See") ? :-)

Danke Rainer, hab ich verbessert :)

Nach einer längeren Pause, da ich noch an anderen Sachen beschäftigt 
war, wollte ich ab heute weiter machen.

So mein Vorhaben ist nun der, dass ich gern eine wav Datei die ich 
vorher in Hex umgewandelt habe, abzuspielen. Hab mich auch ein bisschen 
über die Struktur des wave Dateiformat eingelesen.

Und ich mein Rainer du hast mir ja schon geschildert, dass es kein 
großer Akt ist, eine wav Datei abzuspielen. Einfach die Werte in ein 
Array speichern und per DAC ausgeben.



Die ? ? ? schrieb:
> Kannst du bitte einmal erklären, wie das Ganze funktioniert? DAC, Timer,
> Interrupt, ..., Sinustabelle, ...

Nun ja, ich gebe dank Interrupt die Freq aus, die gerade im 
Array(melody) dran ist.
Und das geschiet mittels eines Sinus, den ich aus dem Array abspiele.
Da aber der Sinus nicht nur einmal durchlaufen wird, sonst wäre ja der 
Ton paar ms lang, habe ich die Notenperiode mit eingefügt. Im Array 
'interval'.
So und da schaut das Programm, wie oft nun Sinuse abgespielt werden 
sollen!

Das Herzstück ist natürlich der Timer. Der definiert, wie schnell das 
Prog in das Interrupt reinspringt. Und das wie oft der reinspringt, ist 
abhängig von der jeweiligen Freq, die gerade dran ist.

Florian schrieb:
> Nun ja, ich
...
habe nicht das programmiert, was ich beschrieben habe.

In der Timer ISR wird immer eine vollständige Periode durchlaufen. Dann 
wird die nächste Frequenz eingestellt, wieder für eine Periode, usw.

Deine Töne sind alle unter 500Hz. Was für ein Audio Stück soll das 
werden?

Mein Tipp:
1. Töne von 1kHz bis mind. 7kHz auswählen
2. Sinustabelle verkleinern
3. Tastung (Timer Intervall) an höchsten Ton anpassen
4. Notenlänge berücksichtigen. Immer als vielfaches der aktuellen 
Periode/2.

Die ? ? ? schrieb:
> habe nicht das programmiert, was ich beschrieben habe.

Jain. Ich hab nachdem ich den Beitrag mit dem Code gepostet habe, 
geschrieben, dass ich es danach hinbekommen habe.

Und im neuen Code habe ich das Array 'Interval', was einfach so da steht 
berücksichtigt.

Meine Beschreibung belief sich auf die neueste Version meines Programms.


Die ? ? ? schrieb:
> In der Timer ISR wird immer eine vollständige Periode durchlaufen. Dann
> wird die nächste Frequenz eingestellt, wieder für eine Periode, usw.

Das stimmt, halt für die Version des Programmcodes den ich da gepostet 
habe.


Die ? ? ? schrieb:
> Deine Töne sind alle unter 500Hz. Was für ein Audio Stück soll das
> werden?

Ich wollte Beispielsweise 'Alle meine Entchen' spielen. Und da hab ich 
halt die Noten im Internet für die Melodie gefunden. Gesucht, welche 
Frequenzen die Noten ergeben und dann im Programm übernommen.


Die ? ? ? schrieb:
> Mein Tipp:
> 1. Töne von 1kHz bis mind. 7kHz auswählen

Kannst du mir den Schritt etwas genauer erklären, wieso das sinnvoller 
ist?


Die ? ? ? schrieb:
> 2. Sinustabelle verkleinern

Ich hab geplant, einen viertelsinus zu implementieren, dass ist noch 
besser als Werte vom Array zu lesen.


Die ? ? ? schrieb:
> 4. Notenlänge berücksichtigen. Immer als vielfaches der aktuellen
> Periode/2.

Meinst du hier mit Periode/2 eine achtelperiode? Wie die in dem Array 
'interval' zu finden ist?
Das hab ich dann in der neuen Version, wenn ich dich so verstanden habe, 
schon eingebaut.

So sieht meine neue Unterfunktion 'setup' aus:

1

void setup(void)

2

{

3

  if(dieseNote < laenge_melody)

4

  {

5

        TACCR0 = (unsigned long int)(8000000 / ((double)laenge_array * (double)melody[dieseNote]));

6

7

        switch(interval[dieseInterval])

8

        {

9

            case 4:          anzahl = melody[dieseNote]; break;

10

            case 8:          anzahl = (int)((double)melody[dieseNote] / 2); break;

11

12

            default:         anzahl = 10; break;

13

        }

14

  }

15

  else

16

  {

17

        dieseNote = 0;

18

        dieseInterval = 0;

19

        delay(200);

20

  }

21

}

Ich hab nun mittels eines wav to c converter, ein sehr großes Array 
erstellt.

Ein Teil des Arrays in meinem Programm kopiert, dass widerum die 
einzelnen Werte ans DAC übermittelt.

Hab die .wav Datei auf 8000Hz Sampling Rate und 8Bit Auflösung mittels 
Audacity gewandelt.

Hab ebenfalls im Programm den Timer so eingestellt, dass er nach 125us - 
was 8000Hz entspricht - in die ISR reinspringt und von dort einen Wert 
im Array an den DAC weiter gibt.

Das Programm ist sehr simpel und hat keine Sinusfunktion, wie das 
Programm davor.

Meine Frage nun, wie berückstichtige ich die 8Bit Auflösung bzw. 
allgemein die Auflösung einer Musikdatei, wenn ich mit uC programmiere 
wo ich Audiodateien ausgeben möchte.

Und ist das Vorgehen so richtig, was ich bis jetzt geschildert habe?

Leider kann ich noch nicht viel hören, da der Flash-Speicher einfach zu 
klein auf dem uC ist.
Mein nächstes Vorhaben wird sein, eine SD-Karte dran zu schließen.

Du musst dich mal entscheiden, was du willst. Erst hast du einzelne 
Noten hintereinander gehängt und jetzt geht es mehrfach überlagerte Töne 
(nix mehr einfacher Sinus).

Die ? ? ? schrieb:
> Du musst dich mal entscheiden, was du willst. Erst hast du einzelne
> Noten hintereinander gehängt und jetzt geht es mehrfach überlagerte Töne
> (nix mehr einfacher Sinus).

Hi, danke für deine einzelnen Beiträge. Entschieden habe ich mich schon. 
Und zwar habe ich ja in meinem allerersten Beitrag ja geschrieben, dass 
ich gern eine .wav Datei ausgeben möchte.

Da mir aber noch das Wissen zu fehlte, wie ich mit Sampling Rate, 
Auflösung und generell mit Frequenzen arbeite, wurde mir hier im Forum 
empfohlen, Töne anhand einer Notentabelle mittels einer Sinustabelle 
auszugeben. Und die Idee gefiel mir halt, dass ich dies auch tat.