Merge pull request #1 from E-Almqvist/speech

Added a module for speech commands.

hue_remote/hue_controller.py

@@ -13,140 +13,140 @@ LIGHTS = {} # dictionary of all the lights
 loop = asyncio.get_event_loop() # ASync loop
 
 def genUrl(params: str):
-    return "http://" + config.address + "/api/" + config.username + params
+	return "http://" + config.address + "/api/" + config.username + params
 
 class APIrequest:
-    # Get Req
+	# Get Req
-    async def get( dest: str="", payload: str="" ):
+	async def get( dest: str="", payload: str="" ):
-        try:
+		try:
-            apiReq = req.get( genUrl(dest), data = payload )
+			apiReq = req.get( genUrl(dest), data = payload )
 
-            if( apiReq.status_code != 200 ): # print out the error if the status code is not 200
+			if( apiReq.status_code != 200 ): # print out the error if the status code is not 200
-                print(apiReq)
+				print(apiReq)
-                print(apiReq.text)
+				print(apiReq.text)
 
-            return apiReq
+			return apiReq
 
-        except req.exceptions.RequestException as err:
+		except req.exceptions.RequestException as err:
-            print(err)
+			print(err)
 
-    # PUT Req
+	# PUT Req
-    async def put( dest: str="", payload: str="" ):
+	async def put( dest: str="", payload: str="" ):
-        try:
+		try:
-            apiReq = req.put( genUrl(dest), data = payload ) # send the payload
+			apiReq = req.put( genUrl(dest), data = payload ) # send the payload
 
-            if( apiReq.status_code != 200 ):
+			if( apiReq.status_code != 200 ):
-                print(apiReq)
+				print(apiReq)
-                print(apiReq.text)
+				print(apiReq.text)
 
-            return apiReq
+			return apiReq
 
-        except req.exceptions.RequestException as err:
+		except req.exceptions.RequestException as err:
-            print(err)
+			print(err)
 
 
 class controller:
 
-    # Internal get functions
+	# Internal get functions
-    async def getLights():
+	async def getLights():
-        return await APIrequest.get("/lights")
+		return await APIrequest.get("/lights")
-
+
-    async def getLight(index: int=1):
+	async def getLight(index: int=1):
-        return await APIrequest.get( "/lights/" + str(index) )
+		return await APIrequest.get( "/lights/" + str(index) )
-
+
-    # Lower level light manipulation (async)
+	# Lower level light manipulation (async)
-    async def toggleLight(index: int=1, isOn: bool=True):
+	async def toggleLight(index: int=1, isOn: bool=True):
-        await APIrequest.put( "/lights/" + str(index) + "/state", '{"on":' + boolToString(isOn) + '}' )
+		await APIrequest.put( "/lights/" + str(index) + "/state", '{"on":' + boolToString(isOn) + '}' )
-
+
-    async def toggleLights(isOn: bool=True):
+	async def toggleLights(isOn: bool=True):
-        for key in LIGHTS:
+		for key in LIGHTS:
-            await controller.toggleLight(key, isOn)
+			await controller.toggleLight(key, isOn)
-
+
-    async def setLightRGB( index: int, r:int, g:int, b:int ):
+	async def setLightRGB( index: int, r:int, g:int, b:int ):
-        h, s, v = rgbToHsv(r, g, b)
+		h, s, v = rgbToHsv(r, g, b)
-        payload = '{"sat":' + str(s) + ', "bri":' + str(v) + ', "hue":' + str(h) + '}'
+		payload = '{"sat":' + str(s) + ', "bri":' + str(v) + ', "hue":' + str(h) + '}'
-
+
-        await APIrequest.put( "/lights/" + str(index) + "/state", payload )
+		await APIrequest.put( "/lights/" + str(index) + "/state", payload )
-
+
-    # Normal functions
+	# Normal functions
-    def switchLight( index: int=1 ):
+	def switchLight( index: int=1 ):
-        key = LIGHTS.get(str(index))
+		key = LIGHTS.get(str(index))
-        if(key):
+		if(key):
-            if( key.get("state") ):
+			if( key.get("state") ):
-                curPower = LIGHTS[str(index)]["state"]["on"]
+				curPower = LIGHTS[str(index)]["state"]["on"]
-                loop.run_until_complete( controller.toggleLight(index, not curPower))
+				loop.run_until_complete( controller.toggleLight(index, not curPower))
-        else:
+		else:
-            print("Error: Light index '" + str(index) + "' out of range")
+			print("Error: Light index '" + str(index) + "' out of range")
-
+
-    def switchLights():
+	def switchLights():
-        for key in LIGHTS:
+		for key in LIGHTS:
-            controller.switchLight(key)
+			controller.switchLight(key)
-
+
-    # Light control
+	# Light control
-    def setLightColor( index:int, r:int, g:int, b:int ):
+	def setLightColor( index:int, r:int, g:int, b:int ):
-        if( LIGHTS.get(str(index)) ):
+		if( LIGHTS.get(str(index)) ):
-            loop.run_until_complete( controller.setLightRGB(index, r, g, b) )
+			loop.run_until_complete( controller.setLightRGB(index, r, g, b) )
-        else:
+		else:
-            print("Error: Light index '" + str(index) + "' out of range")
+			print("Error: Light index '" + str(index) + "' out of range")
-
+
-    def setLightBrightness( index:int, b:int ):
+	def setLightBrightness( index:int, b:int ):
-        if( LIGHTS.get(str(index)) ):
+		if( LIGHTS.get(str(index)) ):
-            payload = '{"bri":' + str(b) + '}'
+			payload = '{"bri":' + str(b) + '}'
-            loop.run_until_complete( APIrequest.put( "/lights/" + str(index) + "/state", payload ) )
+			loop.run_until_complete( APIrequest.put( "/lights/" + str(index) + "/state", payload ) )
-        else:
+		else:
-            print("Error: Light index '" + str(index) + "' out of range")
+			print("Error: Light index '" + str(index) + "' out of range")
-
+
-    def setBrightness( b:int ):
+	def setBrightness( b:int ):
-        for key in LIGHTS:
+		for key in LIGHTS:
-            controller.setLightBrightness( key, b )
+			controller.setLightBrightness( key, b )
-
+
-    def setAllLightsColor( r:int, g:int, b:int ):
+	def setAllLightsColor( r:int, g:int, b:int ):
-        for key in LIGHTS:
+		for key in LIGHTS:
-            controller.setLightColor( key, r, g, b )
+			controller.setLightColor( key, r, g, b )
-
+
-    def Power(isOn:bool=True): # Controlling the power of the lights
+	def Power(isOn:bool=True): # Controlling the power of the lights
-        loop.run_until_complete( controller.toggleLights(isOn) )
+		loop.run_until_complete( controller.toggleLights(isOn) )
-
+
-    def powerLight( index:int, isOn:bool=True ):
+	def powerLight( index:int, isOn:bool=True ):
-        loop.run_until_complete( controller.toggleLight( index, isOn ) )
+		loop.run_until_complete( controller.toggleLight( index, isOn ) )
-
+
-    # Presets
+	# Presets
-    def setLightPreset( index:int, p:str ):
+	def setLightPreset( index:int, p:str ):
-        if( LIGHTS.get(str(index)) ):
+		if( LIGHTS.get(str(index)) ):
-            if( PRESETS.get(p) ):
+			if( PRESETS.get(p) ):
-                preset = PRESETS[p]
+				preset = PRESETS[p]
-                r, g, b = preset["color"]
+				r, g, b = preset["color"]
-                brightness = preset["brightness"]
+				brightness = preset["brightness"]
-
+
-                controller.setLightColor( index, r, g, b )
+				controller.setLightColor( index, r, g, b )
-                controller.setLightBrightness( index, brightness )
+				controller.setLightBrightness( index, brightness )
-            else:
+			else:
-                print("Error: Unknown preset '" + p + "'")
+				print("Error: Unknown preset '" + p + "'")
-        else:
+		else:
-            print("Error: Light index '" + str(index) + "' out of range")
+			print("Error: Light index '" + str(index) + "' out of range")
-
+
-    def setPreset( presetID:str, index:int=-1 ):
+	def setPreset( presetID:str, index:int=-1 ):
-        if( PRESETS.get(presetID) ):
+		if( PRESETS.get(presetID) ):
-            if( index == -1 ):
+			if( index == -1 ):
-                for key in LIGHTS:
+				for key in LIGHTS:
-                    controller.setLightPreset( key, presetID )
+					controller.setLightPreset( key, presetID )
-            else:
+			else:
-                controller.setLightPreset( index, presetID )
+				controller.setLightPreset( index, presetID )
-        else:
+		else:
-            print("Error: Unknown preset '" + presetID + "'")
+			print("Error: Unknown preset '" + presetID + "'")
-
+
-    def countLights():
+	def countLights():
-        return len(LIGHTS)
+		return len(LIGHTS)
-
+
-    # Controller "system" functions
+	# Controller "system" functions
-    def delay(n:int):
+	def delay(n:int):
-        time.sleep(n)
+		time.sleep(n)
-
+
-    def init():
+	def init():
-        jsonLights = loop.run_until_complete(APIrequest.get("/lights"))
+		jsonLights = loop.run_until_complete(APIrequest.get("/lights"))
-
+
-        global LIGHTS
+		global LIGHTS
-        LIGHTS = json.loads(jsonLights.text)
+		LIGHTS = json.loads(jsonLights.text)
-
+
-    def end():
+	def end():
-        loop.close()
+		loop.close()

hue_remote/hue_remote.py

@@ -8,100 +8,100 @@ import hue_controller as hue # Actual controller
 cmd = "hue"
 
 def help():
-    print("--Help page--")
+	print("--Help page--")
 
-    print( "'" + cmd + "' : Display this help page" )
+	print( "'" + cmd + "' : Display this help page" )
-    print( "'" + cmd + " light (index)' ... : Specify light target, from 1-" + str(hue.controller.countLights()) )
+	print( "'" + cmd + " light (index)' ... : Specify light target, from 1-" + str(hue.controller.countLights()) )
-    print( "'" + cmd + " lights' ... : Specify all lights\n" )
+	print( "'" + cmd + " lights' ... : Specify all lights\n" )
 
-    print("--Commands--")
+	print("--Commands--")
-    print( "'on'/'off' : Turn light(s) on/off" )
+	print( "'on'/'off' : Turn light(s) on/off" )
-    print( "'switch' : Switch the light(s) power" )
+	print( "'switch' : Switch the light(s) power" )
-    print( "'set ...'" )
+	print( "'set ...'" )
-    print( "    'preset (preset ID)' : Set the preset (from presets.py)" )
+	print( "	'preset (preset ID)' : Set the preset (from presets.py)" )
-    print( "    'color (red) (green) (blue)' : Set the color, from 0-255" )
+	print( "	'color (red) (green) (blue)' : Set the color, from 0-255" )
-    print( "    'brightness (brightness)' : Set the brightness, from 0-255" )
+	print( "	'brightness (brightness)' : Set the brightness, from 0-255" )
 
-    print("\nExamples:\n'hue light 2 on' : Turn on light 2\n'hue lights set color 255 255 255' : Set all lights colors to white")
+	print("\nExamples:\n'hue light 2 on' : Turn on light 2\n'hue lights set color 255 255 255' : Set all lights colors to white")
 
 boolConvert = {
-    "on": True,
+	"on": True,
-    "off": False
+	"off": False
 }
 
 # this is the most spaghetti-ish code I have ever written but it works
 
 def parseCommand( cmd:list, pos:int, i=-1 ):
-    index = int(i)
+	index = int(i)
-    try:
+	try:
-        if( cmd[pos] == "on" or cmd[pos] == "off" ):
+		if( cmd[pos] == "on" or cmd[pos] == "off" ):
-            if( index == -1 ):
+			if( index == -1 ):
-                hue.controller.Power( boolConvert[cmd[pos]] )
+				hue.controller.Power( boolConvert[cmd[pos]] )
-            else:
+			else:
-                hue.controller.powerLight( index, boolConvert[cmd[pos]] )
+				hue.controller.powerLight( index, boolConvert[cmd[pos]] )
 
-            return
+			return
 
-        elif( cmd[pos] == "switch" ):
+		elif( cmd[pos] == "switch" ):
-            if(index == -1):
+			if(index == -1):
-                hue.controller.switchLights()
+				hue.controller.switchLights()
-            else:
+			else:
-                hue.controller.switchLight(index)
+				hue.controller.switchLight(index)
 
-            return
+			return
 
-        elif( cmd[pos] == "set" ):
+		elif( cmd[pos] == "set" ):
-            if( cmd[pos+1] == "preset" ):
+			if( cmd[pos+1] == "preset" ):
-                hue.controller.setPreset( cmd[pos+2], index )
+				hue.controller.setPreset( cmd[pos+2], index )
-                return
+				return
 
-            elif( cmd[pos+1] == "color" ):
+			elif( cmd[pos+1] == "color" ):
-                if( len(cmd) > pos+4 ):
+				if( len(cmd) > pos+4 ):
-                    r, g, b = int(cmd[pos+2]), int(cmd[pos+3]), int(cmd[pos+4])
+					r, g, b = int(cmd[pos+2]), int(cmd[pos+3]), int(cmd[pos+4])
 
-                    if( index == -1 ):
+					if( index == -1 ):
-                        hue.controller.setAllLightsColor( r, g, b ) # this code is bad
+						hue.controller.setAllLightsColor( r, g, b ) # this code is bad
-                    else:
+					else:
-                        hue.controller.setLightColor( index, r, g, b )
+						hue.controller.setLightColor( index, r, g, b )
 
-                    return
+					return
-                else:
+				else:
-                    print("Error: Missing parameters")
+					print("Error: Missing parameters")
-                    help()
+					help()
 
-            elif( cmd[pos+1] == "brightness" ):
+			elif( cmd[pos+1] == "brightness" ):
-                if( len(cmd) > pos+2 ):
+				if( len(cmd) > pos+2 ):
-                    bri = int(cmd[pos+2])
+					bri = int(cmd[pos+2])
 
-                    if( index == -1 ):
+					if( index == -1 ):
-                        hue.controller.setBrightness(bri)
+						hue.controller.setBrightness(bri)
-                    else:
+					else:
-                        hue.controller.setLightBrightness( index, bri )
+						hue.controller.setLightBrightness( index, bri )
 
-                    return
+					return
-        help() # display help if function did nothing
+		help() # display help if function did nothing
 
-    except (RuntimeError, TypeError, NameError, IndexError) as err:
+	except (RuntimeError, TypeError, NameError, IndexError) as err:
-        help() # display the help page if parameters are missing (it will give out an IndexError)
+		help() # display the help page if parameters are missing (it will give out an IndexError)
-        print( "\n\nError: " + str(err) )
+		print( "\n\nError: " + str(err) )
 
 
 def parseCommandline():
-    cmd = sys.argv
+	cmd = sys.argv
 
-    if( len(cmd) > 1 ):
+	if( len(cmd) > 1 ):
-        if( cmd[1] == "light" ):
+		if( cmd[1] == "light" ):
-            parseCommand( cmd, 3, cmd[2] )
+			parseCommand( cmd, 3, cmd[2] )
 
-        elif( cmd[1] == "lights" ):
+		elif( cmd[1] == "lights" ):
-            parseCommand( cmd, 2 )
+			parseCommand( cmd, 2 )
-    else:
+	else:
-        help()
+		help()
 
 
 def init():
-    hue.controller.init() # very important to initialize the controller
+	hue.controller.init() # very important to initialize the controller
-    parseCommandline()
+	parseCommandline()
-    hue.controller.end() # also to end it
+	hue.controller.end() # also to end it
 
 init() # actually call the init function

speech/speech.py

@@ -0,0 +1,36 @@
+import speech_recognition as sr
+
+class sr_microphone(object):
+	recognizer = sr.Recognizer()
+
+	muted = True
+
+	def getInput(self): # use the object as a generator
+		print("Awaiting input")
+		if( not self.muted ):
+			try:
+				with sr.Microphone() as src:
+					self.recognizer.adjust_for_ambient_noise( src, duration=0.2 ) # adjust for ambient noise
+
+					audio = self.recognizer.listen(src)
+
+					# Make audio -> text
+					return (self.recognizer.recognize_google( audio )).lower() # use googles recognizer and lower its output
+
+			except sr.RequestError as err:
+				print("Unable to request results: {0}".format(err))
+
+			except sr.UnknownValueError as err:
+				print("Unknown Error: {0}".format(err))
+
+	def setMuted( self, setm: bool=True ):
+		self.muted = setm
+
+	def switchMute( self ):
+		self.setMuted( not self.muted )
+
+
+# Small test
+voice = sr_microphone()
+voice.setMuted(False)
+print( voice.getInput() )