Bibliothèque Python pour jouer à fréquence fixe de son

Question

J'ai un moustique problème dans ma maison.Ce ne serait pas concernent généralement un des programmeurs de la communauté;Cependant, j'ai vu quelques dispositifs qui demande à dissuader ces vilaines créatures par la lecture d'un 17Khz ton.Je voudrais faire cela à l'aide de mon ordinateur portable.

Une méthode serait la création d'un MP3 avec un un unique, fixe la fréquence de la tonalité (Cela peut facilement fait par l'audace), en l'ouvrant avec une bibliothèque python et il joue à plusieurs reprises.

La deuxième serait de jouer un son à l'aide de l'ordinateur, haut-parleur intégré.Je suis à la recherche de quelque chose de semblable à QBasic Son:

SOUND 17000, 100

Est-il une bibliothèque python pour qui?

Answer 1

PyAudiere est une solution simple et multi-plateforme pour le problème:

>>> import audiere
>>> d = audiere.open_device()
>>> t = d.create_tone(17000) # 17 KHz
>>> t.play() # non-blocking call
>>> import time
>>> time.sleep(5)
>>> t.stop()

pyaudiere.org est parti. Le site et installateurs binaires pour Python 2 (debian, fenêtres ) sont disponibles via le par exemple la machine à remonter le temps, voici le code source pyaudiere-0.2.tar.gz .

Pour soutenir à la fois Python 2 et 3 sous Linux, Windows, Mac OS X, Module pyaudio pourrait être utilisé à la place:

#!/usr/bin/env python
"""Play a fixed frequency sound."""
from __future__ import division
import math

from pyaudio import PyAudio # sudo apt-get install python{,3}-pyaudio

try:
    from itertools import izip
except ImportError: # Python 3
    izip = zip
    xrange = range

def sine_tone(frequency, duration, volume=1, sample_rate=22050):
    n_samples = int(sample_rate * duration)
    restframes = n_samples % sample_rate

    p = PyAudio()
    stream = p.open(format=p.get_format_from_width(1), # 8bit
                    channels=1, # mono
                    rate=sample_rate,
                    output=True)
    s = lambda t: volume * math.sin(2 * math.pi * frequency * t / sample_rate)
    samples = (int(s(t) * 0x7f + 0x80) for t in xrange(n_samples))
    for buf in izip(*[samples]*sample_rate): # write several samples at a time
        stream.write(bytes(bytearray(buf)))

    # fill remainder of frameset with silence
    stream.write(b'\x80' * restframes)

    stream.stop_stream()
    stream.close()
    p.terminate()

Exemple:

sine_tone(
    # see http://www.phy.mtu.edu/~suits/notefreqs.html
    frequency=440.00, # Hz, waves per second A4
    duration=3.21, # seconds to play sound
    volume=.01, # 0..1 how loud it is
    # see http://en.wikipedia.org/wiki/Bit_rate#Audio
    sample_rate=22050 # number of samples per second
)

Il est une version modifiée (pour le support de Python 3) version de cette réponse AskUbuntu.

Answer 2

Le module winsound est fourni avec Python, il n'y a pas de bibliothèques externes à installer, et il doit faire ce que vous voulez (et pas grand chose d'autre).

 import winsound
 winsound.Beep(17000, 100)

C'est très simple et facile, mais n'est disponible que pour Windows.

Mais:
Une réponse complète à cette question doivent prendre note que bien que cette méthode va produire un son, il ne va pas dissuader les moustiques.Il a déjà été testé:voir ici et ici

Answer 3

Je suis en train de mon code ici une aide il un gain de programmeur clarté sur la façon dont fonctionne le code

explication est dans le code lui-même

#!/usr/bin/env python3
import pyaudio
import struct
import math

FORMAT = pyaudio.paInt16
CHANNELS = 2
RATE = 44100

p = pyaudio.PyAudio()


def data_for_freq(frequency: float, time: float = None):
    """get frames for a fixed frequency for a specified time or
    number of frames, if frame_count is specified, the specified
    time is ignored"""
    frame_count = int(RATE * time)

    remainder_frames = frame_count % RATE
    wavedata = []

    for i in range(frame_count):
        a = RATE / frequency  # number of frames per wave
        b = i / a
        # explanation for b
        # considering one wave, what part of the wave should this be
        # if we graph the sine wave in a
        # displacement vs i graph for the particle
        # where 0 is the beginning of the sine wave and
        # 1 the end of the sine wave
        # which part is "i" is denoted by b
        # for clarity you might use
        # though this is redundant since math.sin is a looping function
        # b = b - int(b)

        c = b * (2 * math.pi)
        # explanation for c
        # now we map b to between 0 and 2*math.PI
        # since 0 - 2*PI, 2*PI - 4*PI, ...
        # are the repeating domains of the sin wave (so the decimal values will
        # also be mapped accordingly,
        # and the integral values will be multiplied
        # by 2*PI and since sin(n*2*PI) is zero where n is an integer)
        d = math.sin(c) * 32767
        e = int(d)
        wavedata.append(e)

    for i in range(remainder_frames):
        wavedata.append(0)

    number_of_bytes = str(len(wavedata))  
    wavedata = struct.pack(number_of_bytes + 'h', *wavedata)

    return wavedata


def play(frequency: float, time: float):
    """
    play a frequency for a fixed time!
    """
    frames = data_for_freq(frequency, time)
    stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, output=True)
    stream.write(frames)
    stream.stop_stream()
    stream.close()


if __name__ == "__main__":
    play(400, 1)

Answer 4

Vous pouvez utiliser le binding Python du SDL ( simple direct Media Library).