Einzelton ausgeben (Linux)

Hallo

Da ich auf Linux umgestiegen bin, hab ich jetzt ein wenig Probleme.....

Ich möchte für eine einfache Metronom-Anwendung zwei Töne ausgeben, die sich von einander unterscheiden.....also in der TonFrequenz.

Ich hab bisher keine Methode gefunden, die das ermöglicht. Habe auch schon versucht eine selbstgeschriebene Methode zu verwenden:

void sound(unsigned frequenz)  
{ 
    printf("\033[10;%d]", frequenz);
    printf("\007");         
    fflush(stdout); 
}

funtioniert nur leider nicht unter Linux.....

Habt ihr vielleicht ne Idee für die Umsetzung?

DrGreenthumb

schau dir den Quelltext zum Programm 'beep' an.

Ich weiß jetzt nicht genau, was Du meinst......welches Programm "beep" ?

DrGreenthumb

bei debian gibt es ein kleines Programm beep.

Geht wohl über einen ioctl-Aufruf. Ich poste einfach mal das ganze Programm:

/*  beep - just what it sounds like, makes the console beep - but with
 * precision control.  See the man page for details.
 *
 * Try beep -h for command line args
 *
 * This code is copyright (C) Johnathan Nightingale, 2000.
 *
 * This code may distributed only under the terms of the GNU Public License 
 * which can be found at http://www.gnu.org/copyleft or in the file COPYING 
 * supplied with this code.
 *
 * This code is not distributed with warranties of any kind, including implied
 * warranties of merchantability or fitness for a particular use or ability to 
 * breed pandas in captivity, it just can't be done.
 *
 * Bug me, I like it:  http://johnath.com/  or johnath@johnath.com
 */

#include <fcntl.h>
#include <getopt.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <linux/kd.h>

/* I don't know where this number comes from, I admit that freely.  A 
   wonderful human named Raine M. Ekman used it in a program that played
   a tune at the console, and apparently, it's how the kernel likes its
   sound requests to be phrased.  If you see Raine, thank him for me.  

   June 28, email from Peter Tirsek (peter at tirsek dot com):

   This number represents the fixed frequency of the original PC XT's
   timer chip (the 8254 AFAIR), which is approximately 1.193 MHz. This
   number is divided with the desired frequency to obtain a counter value,
   that is subsequently fed into the timer chip, tied to the PC speaker.
   The chip decreases this counter at every tick (1.193 MHz) and when it
   reaches zero, it toggles the state of the speaker (on/off, or in/out),
   resets the counter to the original value, and starts over. The end
   result of this is a tone at approximately the desired frequency. :)
*/
#ifndef CLOCK_TICK_RATE
#define CLOCK_TICK_RATE 1193180
#endif

#define VERSION_STRING "beep-1.2.2"
char *copyright = 
"Copyright (C) Johnathan Nightingale, 2002.  "
"Use and Distribution subject to GPL.  "
"For information: http://www.gnu.org/copyleft/.";

/* Meaningful Defaults */
#define DEFAULT_FREQ       440.0 /* Middle A */
#define DEFAULT_LENGTH     200   /* milliseconds */
#define DEFAULT_REPS       1
#define DEFAULT_DELAY      100   /* milliseconds */
#define DEFAULT_END_DELAY  NO_END_DELAY
#define DEFAULT_STDIN_BEEP NO_STDIN_BEEP

/* Other Constants */
#define NO_END_DELAY    0
#define YES_END_DELAY   1

#define NO_STDIN_BEEP   0
#define LINE_STDIN_BEEP 1
#define CHAR_STDIN_BEEP 2

typedef struct beep_parms_t {
  float freq;     /* tone frequency (Hz)      */
  int length;     /* tone length    (ms)      */
  int reps;       /* # of repetitions         */
  int delay;      /* delay between reps  (ms) */
  int end_delay;  /* do we delay after last rep? */
  int stdin_beep; /* are we using stdin triggers?  We have three options:
		     - just beep and terminate (default)
		     - beep after a line of input
		     - beep after a character of input
		     In the latter two cases, pass the text back out again,
		     so that beep can be tucked appropriately into a text-
		     processing pipe.
		  */
  struct beep_parms_t *next;  /* in case -n/--new is used. */
} beep_parms_t;

/* Momma taught me never to use globals, but we need something the signal 
   handlers can get at.*/
int console_fd = -1;

/* If we get interrupted, it would be nice to not leave the speaker beeping in
   perpetuity. */
void handle_signal(int signum) {
  switch(signum) {
  case SIGINT:
    if(console_fd >= 0) {
      /* Kill the sound, quit gracefully */
      ioctl(console_fd, KIOCSOUND, 0);
      close(console_fd);
      exit(signum);
    } else {
      /* Just quit gracefully */
      exit(signum);
    }
  }
}

/* print usage and exit */
void usage_bail(const char *executable_name) {
  printf("Usage:\n%s [-f freq] [-l length] [-r reps] [-d delay] "
	 "[-D delay] [-s] [-c]\n",
	 executable_name);
  printf("%s [Options...] [-n] [--new] [Options...] ... \n", executable_name);
  printf("%s [-h] [--help]\n", executable_name);
  printf("%s [-v] [-V] [--version]\n", executable_name);
  exit(1);
}

/* Parse the command line.  argv should be untampered, as passed to main.
 * Beep parameters returned in result, subsequent parameters in argv will over-
 * ride previous ones.
 * 
 * Currently valid parameters:
 *  "-f <frequency in Hz>"
 *  "-l <tone length in ms>"
 *  "-r <repetitions>"
 *  "-d <delay in ms>"
 *  "-D <delay in ms>" (similar to -d, but delay after last repetition as well)
 *  "-s" (beep after each line of input from stdin, echo line to stdout)
 *  "-c" (beep after each char of input from stdin, echo char to stdout)
 *  "-h/--help"
 *  "-v/-V/--version"
 *  "-n/--new"
 *
 * March 29, 2002 - Daniel Eisenbud points out that c should be int, not char,
 * for correctness on platforms with unsigned chars.
 */
void parse_command_line(int argc, char **argv, beep_parms_t *result) {
  int c;

  struct option opt_list[4] = {{"help", 0, NULL, 'h'},
			       {"version", 0, NULL, 'V'},
			       {"new", 0, NULL, 'n'},
			       {0,0,0,0}};
  while((c = getopt_long(argc, argv, "f:l:r:d:D:schvVn", opt_list, NULL))
	!= EOF) {
    int argval = -1;    /* handle parsed numbers for various arguments */
    float argfreq = -1; 
    switch(c) {      
    case 'f':  /* freq */
      if(!sscanf(optarg, "%f", &argfreq) || (argfreq >= 20000 /* ack! */) || 
	 (argfreq <= 0))
	usage_bail(argv[0]);
      else
	result->freq = argfreq;    
      break;
    case 'l' : /* length */
      if(!sscanf(optarg, "%d", &argval) || (argval < 0))
	usage_bail(argv[0]);
      else
	result->length = argval;
      break;
    case 'r' : /* repetitions */
      if(!sscanf(optarg, "%d", &argval) || (argval < 0))
	usage_bail(argv[0]);
      else
	result->reps = argval;
      break;
    case 'd' : /* delay between reps - WITHOUT delay after last beep*/
      if(!sscanf(optarg, "%d", &argval) || (argval < 0))
	usage_bail(argv[0]);
      else {
	result->delay = argval;
	result->end_delay = NO_END_DELAY;
      }
      break;
    case 'D' : /* delay between reps - WITH delay after last beep */
      if(!sscanf(optarg, "%d", &argval) || (argval < 0))
	usage_bail(argv[0]);
      else {
	result->delay = argval;
	result->end_delay = YES_END_DELAY;
      }
      break;
    case 's' :
      result->stdin_beep = LINE_STDIN_BEEP;
      break;
    case 'c' :
      result->stdin_beep = CHAR_STDIN_BEEP;
      break;
    case 'v' :
    case 'V' : /* also --version */
      printf("%s\n",VERSION_STRING);
      exit(0);
      break;
    case 'n' : /* also --new - create another beep */
      result->next = (beep_parms_t *)malloc(sizeof(beep_parms_t));
      result->next->freq       = DEFAULT_FREQ;
      result->next->length     = DEFAULT_LENGTH;
      result->next->reps       = DEFAULT_REPS;
      result->next->delay      = DEFAULT_DELAY;
      result->next->end_delay  = DEFAULT_END_DELAY;
      result->next->stdin_beep = DEFAULT_STDIN_BEEP;
      result->next->next       = NULL;
      result = result->next; /* yes, I meant to do that. */
      break;
    case 'h' : /* notice that this is also --help */
    default :
      usage_bail(argv[0]);
    }
  }
}  

void play_beep(beep_parms_t parms) {
  int i; /* loop counter */

  /* try to snag the console */
  if((console_fd = open("/dev/tty0", O_WRONLY)) == -1) {
    if((console_fd = open("/dev/vc/0", O_WRONLY)) == -1) {
      fprintf(stderr, "Could not open /dev/tty0 or /dev/vc/0 for writing.\n");
      printf("\a");  /* Output the only beep we can, in an effort to fall back on usefulness */
      perror("open");
      exit(1);
    }
  }

  /* Beep */
  for (i = 0; i < parms.reps; i++) {                    /* start beep */
    if(ioctl(console_fd, KIOCSOUND, (int)(CLOCK_TICK_RATE/parms.freq)) < 0) {
      printf("\a");  /* Output the only beep we can, in an effort to fall back on usefulness */
      perror("ioctl");
    }
    /* Look ma, I'm not ansi C compatible! */
    usleep(1000*parms.length);                          /* wait...    */
    ioctl(console_fd, KIOCSOUND, 0);                    /* stop beep  */
    if(parms.end_delay || (i+1 < parms.reps))
       usleep(1000*parms.delay);                        /* wait...    */
  }                                                     /* repeat.    */

  close(console_fd);
}

int main(int argc, char **argv) {
  char sin[4096], *ptr;

  beep_parms_t *parms = (beep_parms_t *)malloc(sizeof(beep_parms_t));
  parms->freq       = DEFAULT_FREQ;
  parms->length     = DEFAULT_LENGTH;
  parms->reps       = DEFAULT_REPS;
  parms->delay      = DEFAULT_DELAY;
  parms->end_delay  = DEFAULT_END_DELAY;
  parms->stdin_beep = DEFAULT_STDIN_BEEP;
  parms->next       = NULL;

  signal(SIGINT, handle_signal);
  parse_command_line(argc, argv, parms);

  /* this outermost while loop handles the possibility that -n/--new has been
     used, i.e. that we have multiple beeps specified. Each iteration will
     play, then free() one parms instance. */
  while(parms) {
    beep_parms_t *next = parms->next;

    if(parms->stdin_beep) {
      /* in this case, beep is probably part of a pipe, in which case POSIX 
	 says stdin and out should be fuly buffered.  This however means very 
	 laggy performance with beep just twiddling it's thumbs until a buffer
	 fills. Thus, kill the buffering.  In some situations, this too won't 
	 be enough, namely if we're in the middle of a long pipe, and the 
	 processes feeding us stdin are buffered, we'll have to wait for them,
	 not much to  be done about that. */
      setvbuf(stdin, NULL, _IONBF, 0);
      setvbuf(stdout, NULL, _IONBF, 0);
      while(fgets(sin, 4096, stdin)) {
	if(parms->stdin_beep==CHAR_STDIN_BEEP) {
	  for(ptr=sin;*ptr;ptr++) {
	    putchar(*ptr);
	    fflush(stdout);
	    play_beep(*parms);
	  }
	} else {
	  fputs(sin, stdout);
	  play_beep(*parms);
	}
      }
    } else {
      play_beep(*parms);
    }

    /* Junk each parms struct after playing it */
    free(parms);
    parms = next;
  }

  return EXIT_SUCCESS;
}

MTE

Na, ich würde sagen mit beep und drei bis vier Zeilen Shell-Script hat man schon ein Metronom:

do while (true)
    beep -f 600 -r 1 -l 20 -D 80
    beep -f 440 -r 3 -l 20 -D 80
done

Ist jetzt syntaxtisch sicherlich nicht korrekt, dürfte aber den Sinn verdeutlichen. Dann noch ein bißchen mit den Zeiten rumgespielt und die Frequenz angepasst, dann dürfte das seinen Zweck erfüllen.
Natürlich ließe sich das Script auch erweitern, so dass man beim Starten ein Tempo und ein Taktmaß angibt und die nötigen Wiederholungen und Delays automatisch berechnet werden.

Gruß,
MTE.

[edit]Reihenfolge der beeps im code getauscht, macht mehr Sinn wenn der auffällige Ton auf der 1 kommt anstatt auf der 4 [/edit]

Windalf

double tonfrequenz(int t){return 440*pow(pow(2,1.0/12),t);}

hiermit kann man sich die frequenz eines tones ausrechnen lassen den man dann noch irgendwie abspielen muss (mit beep oder weiss was ich)... t ist dabei die anzahl an halbtonschritten über a
die musiker werden jetzt wahrscheinlich aufschreien *argh* gleichmäsige Stimmung wie furchtbar, aber für ein nicht geübtes musikergehör sollte es völlig ausreichen...

von dir idee her ists so auf eine oktave verdoppelt sich die frequenz...
ein oktave sind 12 halbtonschritte... ich muss also nur zwölfte wurzel aus zwei mit anzahl der halbtonschritte exponenzieren um den faktor zu bekommen mit dem ich die grundfreuqenz (in diesem fall a bei 440 Hz) multiplizieren muss und hab dann die frequenz des von mir gewünschten tons..

Richi

gibts auch ne wohl-temperierte Lösung ? (<<--- *musiker is*)

Windalf

gibts auch ne wohl-temperierte Lösung ? (<<--- *musiker is*)

wenn ich deine frage richtig interpretiere willst du ne Lösung wissen die deinem Gehör keine Schmerzen bereitet weil du z.b. 440 Hz von 440,5 Hz unterscheiden kannst?

Klar gibt es aber soweit ich weiss ist da (ich nenn es mal) kein "mathematisches schema" drin (zumindest nicht innerhalb einer oktave) das heisst du musst für jeden ton extra die frequenz definieren...
wenns einem auf rechnleistung ankommt wird mans ja eh machen da die kiste dann den ton nicht erst zur laufzeit ausrechnen muss sondern gleich den "richtigen "ton verwenden kann

Als das beep-Programm funzt bei mir nicht....

muss irgendwi hieran liegen:

/* Beep */
  for (i = 0; i < parms.reps; i++) {                    /* start beep */
    if(ioctl(console_fd, KIOCSOUND, (int)(CLOCK_TICK_RATE/parms.freq)) < 0) {
      printf("\a");  /* Output the only beep we can, in an effort to fall back on usefulness */
      perror("ioctl");
    }

bekomme eben immer "ioctl" als Fehler angezeigt....das wars

DrGreenthumb

eigentlich sollte perror ja eine etwas ausführlichere Meldung ausgeben (oder wenigstens 'Success').

Glaube du brauchst root-rechte. Sieht hier auch so aus:

-rwsr-xr--    1 root     audio        6328 2004-03-23 15:14 /usr/bin/beep

ich habs a unter root ausgeführt

DrGreenthumb

keine ahnung, bei mir gehts. Hast du zufällig einen 2.6er Kernel und vergessen den Speaker-Support zu aktivieren?