Znalazłem jeszcze jedno zastosowanie PWM, dosyć rozrywkowe. Do wyjścia PWM można podłączyć głośniczek i odtwarzać proste melodie. Najpierw schemat:
Rezystor może być inny, ale nie mniejszy niż 110, 120 omów. Z wyjścia STM32F407 można pobierać tylko 25mA prądu. Biorąc pod uwagę rezystancję głośniczka mamy równanie: 3V/(8ohm + 120ohm) = 0,023A. Tak więc przy tej rezystancji zmieścimy się w zakresie.
Teraz wystarczy tylko poszukać jakie częstotliwości odpowiadają poszczególnym dźwiękom i można odtworzyć dźwięki gamy:
Teraz wystarczy tylko poszukać jakie częstotliwości odpowiadają poszczególnym dźwiękom i można odtworzyć dźwięki gamy:
//C, D, E, F, G, A, H, C
var scale = new[]{261.6, 293.7, 329.2, 349.6,
391.9, 440.0, 493.9, 523.2};
var pwm4 = new PWM(Cpu.PWMChannel.PWM_4, 50, 0, false);
pwm4.Start();
foreach (double note in scale)
{
pwm4.Frequency = note;
pwm4.DutyCycle = 0.5;
Thread.Sleep(1000);
}
pwm4.Stop();
Aby zagrać jakąś prostą melodię trzeba się nieźle nawpisywać tych częstotliwości. Z pomocą przychodzi format RTTL lub MML. Na internecie można znaleźć mnóstwo melodyjek zapisanych w tych formatach.
Konstrukcję odtwarzacza RTTL rozpoczynamy od zdefiniowania interfejsu ISpeaker. Interfejs da możliwość dowolnej implementacji urządzenia wyjściowego. Jak widać są tylko dwie metody Play i Pause. Czyli to co głośniczek najlepiej umie robić: albo milczeć albo grać.
public interface ISpeaker
{
void Pause();
void Play(double frequency);
}
Teraz implementacja tego interfejsu na wyjściu PWM z podłączonym głośniczkiem:
public class PwmSpeaker : ISpeaker
{
private readonly PWM _pwm;
public PwmSpeaker(PWM pwm)
{
_pwm = pwm;
_pwm.Frequency = 50;
_pwm.DutyCycle = 0;
_pwm.Start();
}
public void Play(double frequency)
{
_pwm.Frequency = frequency;
_pwm.DutyCycle = 0.5;
}
public void Pause()
{
_pwm.Frequency = 50;
_pwm.DutyCycle = 0;
}
}
Przechodzimy do odtwarzacza RTTL. Całe zadanie polega na zdekodowaniu napisu w formacie RTTL na poszczególne częstotliwości dźwięków i czas ich trwania. Później trzeba to wysłać do ISpeakera.
Do dekodowania formatu RTTL na bardziej przyjazne dane służy statyczna metoda Parse klasy Rttl:
public static Rttl Parse(string rttlData)
{
string[] sections = rttlData.Split(':');
string name = sections[0].Trim();
string[] tones = sections[2].Split(',');
int duration = 4;
int octave = 6;
int bpm = 63;
if (sections[1].Length > 0)
{
string[] controls = sections[1].Split(',');
foreach (string item in controls)
{
string control = item.Trim();
string valueStr = control.Substring(2, control.Length - 2);
int value = Int32.Parse(valueStr);
switch (control[0].ToLower())
{
case 'd':
duration = value;
break;
case 'o':
octave = value;
break;
case 'b':
bpm = value;
break;
}
}
}
var result = new Rttl
{
Name = name,
Tones = tones,
Duration = duration,
Octave = octave,
Bpm = bpm
};
return result;
}
Jak już mamy wszystkie potrzebne dane to trzeba znaleźć tylko odpowiednie częstotliwości. Klasa RttlPlayer ma zdefiniowane tablice z częstotliwościami poszczególnych dźwięków. Wartości wypełnione są tylko dla pierwszej oktawy. Pozostałe oktawy zostaną uzupełnione poprzez podwojenie częstotliwości z oktawy poprzedzającej w statycznym konstruktorze.
private static readonly double[][] Scales = new[]
{
new[]
{
//C, Cis, D, Dis, E, F, Fis, G, Gis, A, Ais, H
261.6, 277.2, 293.7, 311.2, 329.2,
349.6, 370, 391.9, 415.3, 440.0, 466.2, 493.9
},
new double[12],
new double[12],
new double[12]
};
static RttlPlayer()
{
for (int i = 1; i < Scales.Length; i++)
for (int j = 0; j < Scales[i].Length; j++)
Scales[i][j] = 2*Scales[i - 1][j];
}
No teraz to wystarczy wszystko połączyć w całość w metodzie Play RttlPlayera.
public void Play(string rttlData)
{
const int oneBpmWholeNote = 60*4*1000; //one bpm whole note in ms
Rttl rttl = Rttl.Parse(rttlData);
int wholeNote = oneBpmWholeNote/rttl.Bpm;
foreach (string tone in rttl.Tones)
{
bool specialDuration;
string durationStr, noteStr, scaleStr;
ParseCommand(tone, out durationStr, out noteStr, out scaleStr, out specialDuration);
int duration = rttl.Duration;
if (durationStr.Length > 0)
duration = Int32.Parse(durationStr);
duration = specialDuration ? (3*wholeNote)/(2*duration) : wholeNote/duration;
int freqIndex;
switch (noteStr[0].ToLower())
{
case 'c':
freqIndex = 0;
break;
case 'd':
freqIndex = 2;
break;
case 'e':
freqIndex = 4;
break;
case 'f':
freqIndex = 5;
break;
case 'g':
freqIndex = 7;
break;
case 'a':
freqIndex = 9;
break;
case 'b':
freqIndex = 11;
break;
default:
freqIndex = -1;
break;
}
if (noteStr.Length > 1)//#
freqIndex++;
int scale = rttl.Octave;
if (scaleStr.Length > 0)
scale = Int32.Parse(scaleStr);
if (freqIndex >= 0)
{
double freq = Scales[scale - 4][freqIndex];
Debug.Print("Playing: (" + tone + ")" + freq + " " + duration);
_speaker.Play(freq);
Thread.Sleep(duration);
_speaker.Pause();
}
else
{
Debug.Print("Pausing: (" + tone + ") " + duration);
_speaker.Pause();
Thread.Sleep(duration);
}
}
}
A tak można odtwarzać melodyjki:
var pwm = new PWM(Cpu.PWMChannel.PWM_4, 50, 0, false); var player = new RttlPlayer(new PwmSpeaker(pwm)); const string song = "Indiana:d=4,o=5,b=250:e,8p,8f,8g,8p,1c6,8p.,d,8p,8e,1f,p.,g,8p,8a,8b,8p,1f6,p,a,8p,8b,2c6,2d6,2e6,e,8p,8f,8g,8p,1c6,p,d6,8p,8e6,1f.6,g,8p,8g,e.6,8p,d6,8p,8g,e.6,8p,d6,8p,8g,f.6,8p,e6,8p,8d6,2c6"; player.Play(song);
Przykład odtwarzania formatu MTL można znaleźć w projekcie .NET Micro Framework Toolbox.
