On the Raspberry Pi, I'm trying to play some sounds using pygame.mixer and am having a problem when playing them on any thread other than the main thread. For example, I have a keypad hooked up and when a key is pressed (for which the detection is threaded) it fires a callback and in that callback it tries to play the sound. But when it tries it, most of the time, fails with:
Fatal Python error: (pygame parachute) Segmentation Fault
If I run it on the main thread, it works fine. Is there a reason why separate threads doesn't work or a way to do it? See code below, the method being called on the thread is audio_handler.playTone()
import pygame.mixer as mixer
import glob
class audio_handler:
def __init__(self):
mixer.init(channels = 2)
mixer.set_num_channels(3)
self._chanTones = mixer.Channel(0)
self._chanMusic = mixer.Channel(1)
self._chanRinger = mixer.Channel(2)
self._dtmfTones = {}
self._songs = []
self._musicDir = "/home/pi/music/"
self.loadDTMF()
#self.loadSongs()
def cleanup(self):
mixer.quit()
def loadDTMF(self):
self._dtmfTones["0"] = mixer.Sound("./DTMF/0.ogg")
self._dtmfTones["1"] = mixer.Sound("./DTMF/1.ogg")
self._dtmfTones["2"] = mixer.Sound("./DTMF/2.ogg")
self._dtmfTones["3"] = mixer.Sound("./DTMF/3.ogg")
self._dtmfTones["4"] = mixer.Sound("./DTMF/4.ogg")
self._dtmfTones["5"] = mixer.Sound("./DTMF/5.ogg")
self._dtmfTones["6"] = mixer.Sound("./DTMF/6.ogg")
self._dtmfTones["7"] = mixer.Sound("./DTMF/7.ogg")
self._dtmfTones["8"] = mixer.Sound("./DTMF/8.ogg")
self._dtmfTones["9"] = mixer.Sound("./DTMF/9.ogg")
self._dtmfTones["*"] = mixer.Sound("./DTMF/star.ogg")
self._dtmfTones["#"] = mixer.Sound("./DTMF/pound.ogg")
def loadSongs(self):
for file in glob.glob(self._musicDir + "*.ogg"):
self._songs.append(file)
print str(len(self._songs)) + " songs loaded."
def playTone(self, tone):
if self._dtmfTones.has_key(str(tone)):
self._dtmfTones[str(tone)].play()
self._chanTones.set_volume(1.0, 0.0)
self._chanTones.play(self._dtmfTones[str(tone)])
Side Note: This seems to only happen with ogg files, not wav.
Matrix Keypad Handler:
#!/usr/bin/python
import RPi.GPIO as GPIO
import time
class keypad():
def __init__(self, callback):
GPIO.setmode(GPIO.BCM)
self._count = 0
self._inInterrupt = False
self._callback = callback
# CONSTANTS
self.KEYPAD = [
[1,2,3],
[4,5,6],
[7,8,9],
["*",0,"#"]
]
self.ROW = [18,23,24,25]
self.COLUMN = [4,17,22]
self.__setInterruptMode()
def __colInt(self, channel):
time.sleep(0.05) #give it a moment to settle
if GPIO.input(channel) > 0:
return
#remove interrupts temporarily
for c in range(len(self.COLUMN)):
GPIO.remove_event_detect(self.COLUMN[c])
#get column number
colVal = -1
for c in range(len(self.COLUMN)):
if channel == self.COLUMN[c]:
colVal = c
#continue if valid column (it should always be)
if colVal >=0 and colVal < len(self.COLUMN):
#set rows as intputs
for r in range(len(self.ROW)):
GPIO.setup(self.ROW[r], GPIO.IN, pull_up_down=GPIO.PUD_UP)
#set triggered column as low output
GPIO.setup(channel, GPIO.OUT, initial=GPIO.LOW)
# Scan rows for pushed key/button
rowVal = -1
for r in range(len(self.ROW)):
tmpRead = GPIO.input(self.ROW[r])
if tmpRead == 0:
rowVal = r
break
#continue if row is valid (possible that it might not be if the key was very quickly released)
if rowVal >= 0 and rowVal < len(self.ROW):
#send key info right away
self._callback(self.KEYPAD[rowVal][colVal])
#This avoids nasty boucning errors when the key is released
#By waiting for the rising edge before re-enabling interrupts it
#avoids interrupts fired due to bouncing on key release and
#any repeated interrupts that would otherwise fire.
try:
GPIO.wait_for_edge(self.ROW[rowVal], GPIO.RISING)
self.__setInterruptMode()
except RuntimeError:
pass
return
else:
print "Invalid Row!"
else:
print "Invalid Col!"
#re-enable interrupts
self.__setInterruptMode()
def __changeWrapper(self, channel):
#if there is already another interrupt going on (multiple key press or something)
#return right away to avoid collisions
if self._inInterrupt:
return;
self._inInterrupt = True
self.__colInt(channel) #handle the actual interrupt
self._inInterrupt = False
def __setInterruptMode(self):
#set the first row as output low
#only first one needed as it will ground to all columns
for r in range(len(self.ROW)):
GPIO.setup(self.ROW[r], GPIO.OUT, initial=GPIO.LOW)
#set columns as inputs and attach interrupt handlers on rising edge
for c in range(len(self.COLUMN)):
GPIO.setup(self.COLUMN[c], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(self.COLUMN[c], GPIO.FALLING, bouncetime=250, callback=self.__changeWrapper)
def cleanup(self):
GPIO.cleanup()
print "Cleanup done!"
import time
if __name__ == '__main__':
audio = audio_handler()
def keypadCallback(value):
audio.playTone(value)
print "Keypad: " + value
key = keypad(keypadCallback)
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
key.cleanup()
While a new thread is never spawned directly by me, keypadCallback() is called via the keypad() class in the context of it's own internal GPIO interrupt callback. So, I assume that means that keypadCallback() is, in fact, not on the main thread.
