Tutorial: Beep

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Dieses Tutorial handelt von der Beep Funktion.
    Ich möchte mich in diesem Tutorial mit der Windows-Funktion Beep beschäftigen.
    Diese Funktion lässt den SystemSpeaker einen Ton mit einer bestimmten Frequenz und für eine bestimmte Dauer erklingen.

    == Gerüst ==
    Hierzu ist

    Quellcode

    1. #include <windows.h>
    2. #include <iostream>
    3. using namespace std;

    erforderlich. Außerdem importiert ihr iostream und verwenden den namespace std für Ausgaben in der Konsole.
    Jetzt bestimmt ihr die Frequenz der Töne als const int, weil sie ja nicht verändert werden müssen.

    == Musiklehre ==
    Wichtig ist zu wissen, dass die Hälfte einer Frequenz, der gleiche Ton eine Oktave tiefer, und, dass das Doppelte der Frequenz eine Oktave höher ist.
    Wenn man die Frequenz selber berechnen möchte, muss man die 12. Wurzel aus 2 mit der Frequenz des Tones, der eine halbe Stufe unter dem gesuchten Ton liegt multiplizieren.

    Ein Beispiel:
    - Ton A = 440Hz (ein normal temperierte Klaviersaite des Tons A schwingt mit dieser Frequenz (es kann auch mit der Hälfte oder dem Doppelten gerechnet werden))
    - 12. Wurzel aus 2 * Frequenz des Tones = Halbton höher (Ais) = 466
    - beliebig oft wiederholen :)

    == Frequenzen ==
    Also, für diejenigen, die die Frequenzen nicht selber berechnen möchten:

    Quellcode

    1. const int C = 261;
    2. const int Cis = 277;
    3. const int D = 293;
    4. const int Dis = 311;
    5. const int E = 329;
    6. const int F = 349;
    7. const int Fis = 369;
    8. const int G = 391;
    9. const int Gis = 415;
    10. const int A = 440;
    11. const int Ais = 466;
    12. const int H = 493;
    13. const int Takt = 2000;
    Alles anzeigen


    Was die Variable Takt soll, könnt ihr euch sicherlich denken.
    Recht praktisch ist, jeden Beep so zu gestalten:
    So ertönt der Ton C1 als Viertelnote.

    Quellcode

    1. Beep(C * 1, Takt / 4);

    Wieder der Ton C, allerdings doppelt so lang und eine Oktave höher.

    Quellcode

    1. Beep(C * 2, Takt / 2);

    Und nochmal der Ton C, diesmal jedoch 4 Mal so lang und 2 Oktaven höher.

    Quellcode

    1. Beep(C * 4, Takt / 4);

    Um einen Ton eine Oktave niedriger erklingen zu lassen, einfach das * Zeichen mit / ersetzen.
    Eventuell ist es erforderlich, das ihr hinter einen jeden Beep Aufruf das Programm kurz mit Sleep(1); anhalten und danach weiterlaufen lassen, beispielsweise bei 16tel Noten.
    Ihr könnt ja mal Probieren "Alle meine Entchen" zu programmieren.

    == Beispiel Tetris ==
    Hier noch der Sourcecode von Tetris.

    Quellcode

    1. #include <windows.h>
    2. #include <iostream>
    3. using namespace std;
    4. const int C = 261;
    5. const int Cis = 277;
    6. const int D = 293;
    7. const int Dis = 311;
    8. const int E = 329;
    9. const int F = 349;
    10. const int Fis = 369;
    11. const int G = 391;
    12. const int Gis = 415;
    13. const int A = 440;
    14. const int Ais = 466;
    15. const int H = 493;
    16. const int Takt = 1700;
    17. int main() {
    18. cout << "Tetris" << endl << " (Enter dr" << (unsigned char)129 << "cken um fortzufahren)";
    19. getchar();
    20. while (1) {
    21. Sleep(Takt / 4);
    22. Beep(E * 2, Takt / 4);
    23. Beep(H * 1, Takt / 8);
    24. Beep(C * 2, Takt / 8);
    25. Beep(D * 2, Takt / 4);
    26. Beep(C * 2, Takt / 8);
    27. Beep(H * 1, Takt / 8);
    28. Beep(A * 1, Takt / 4);
    29. Beep(A * 1, Takt / 8);
    30. Beep(C * 2, Takt / 8);
    31. Beep(E * 2, Takt / 8);
    32. Beep(E * 2, Takt / 8);
    33. Beep(D * 2, Takt / 8);
    34. Beep(C * 2, Takt / 8);
    35. Beep(H * 1, Takt / 2.5);
    36. Beep(C * 2, Takt / 8);
    37. Beep(D * 2, Takt / 4);
    38. Beep(E * 2, Takt / 4);
    39. Beep(C * 2, Takt / 4);
    40. Beep(A * 1, Takt / 4);
    41. Beep(A * 1, Takt / 4);
    42. Sleep(Takt / (8 / 3));
    43. Beep(D * 2, Takt / 3.25);
    44. Beep(F * 2, Takt / 8);
    45. Beep(A * 2, Takt / 8);
    46. Beep(A * 2, Takt / 8);
    47. Beep(G * 2, Takt / 8);
    48. Beep(F * 2, Takt / 8);
    49. Beep(E * 2, Takt / 3);
    50. Beep(C * 2, Takt / 8);
    51. Beep(E * 2, Takt / 8);
    52. Beep(E * 2, Takt / 8);
    53. Beep(D * 2, Takt / 8);
    54. Beep(C * 2, Takt / 8);
    55. Beep(H * 1, Takt / 4);
    56. Beep(H * 1, Takt / 8);
    57. Beep(C * 2, Takt / 8);
    58. Beep(D * 2, Takt / 4);
    59. Beep(E * 2, Takt / 4);
    60. Beep(C * 2, Takt / 4);
    61. Beep(A * 1, Takt / 4);
    62. Beep(A * 1, Takt / 4);
    63. }
    64. return 0;
    65. }
    Alles anzeigen

    12.018 mal gelesen