Alexa Voice Alarm Clock

#!/usr/bin/python

# ===========================================================================
# ClockLED
# ===========================================================================

import time
from Adafruit_LED_Backpack import SevenSegment
from threading import Thread

class LED_Clock(object):

    def __init__(self,):
        # Create display instance on default I2C address (0x70) and bus number.
        self.display = SevenSegment.SevenSegment()
        # Initialize the display. Must be called once before using the display.
        self.display.begin()
        self.brightness = 7
        self.display.set_brightness(self.brightness)
        self.colon = False
        self.alarm = False
        self.timeUpdateRunning = False
        self.timeFormat = "%l%M"

    def timeUpdateThread(self,):
        # print "started timeUpdateThread"
        while self.timeUpdateRunning:
            time.sleep(1.0)
            digitString = time.strftime(self.timeFormat)
            self.display.clear()
            self.display.print_number_str(digitString)
            self.display.set_colon(self.colon)
            if (self.colon):
                self.colon = False
            else:
                self.colon = True
            self.display.set_decimal(3, self.alarm)
            self.display.write_display()

    def setTime24(self,Time24=True):
        if Time24:
            self.timeFormat = "%I%M"
        else:
            self.timeFormat = "%l%M"

    def setAlarm(self,val):
        self.alarm = val

    def setBrightness(self,val):
        # print("set brightness="+str(val))
        self.brightness = val
        self.display.set_brightness(self.brightness)

    def increaseBrightness(self,):
        self.brightness = self.brightness + 1
        if self.brightness > 15:
            self.brightness = 15
        self.display.set_brightness(self.brightness)

    def decreaseBrightness(self,):
        self.brightness = self.brightness - 1
        if self.brightness < 0:
            self.brightness = 0
        self.display.set_brightness(self.brightness)

    def run(self):
        self.timeUpdateRunning = True
        self.tuThread = Thread(target=self.timeUpdateThread )
        self.tuThread.daemon = True
        self.tuThread.start()

if __name__ == '__main__':
    # print "ClockLED"
    clock = LED_Clock()
    clock.run()
    while True:
        # simple input driver
        choice = raw_input("> ")

        if choice == 'x' :
            print "exiting"
            clock.timeUpdateRunning = False
            time.sleep(2.0)
            break
        elif choice == 'a':
            if clock.alarm:
                clock.alarm = False
            else:
                clock.alarm = True
        elif choice == '+':
            clock.increaseBrightness()
            print "brightness=",clock.brightness
        elif choice == '-':
            clock.decreaseBrightness()
            print "brightness=",clock.brightness
        else:
            print ("e)xit or a)larm or + or -")

#!/usr/bin/python

# ===========================================================================
# DisplayOLED
# ===========================================================================

import time
import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306

from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw

import socket

hostname = socket.gethostname()
IP = socket.gethostbyname(hostname)

from threading import Thread

class OLED_Display(object):

    def __init__(self,):
        # Raspberry Pi pin configuration:
        RST = 24
        # 128x64 display with hardware I2C:
        self.disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)
        self.disp.begin()
        self.disp.clear()
        self.disp.display()
        # Create image buffer. Make sure to create image with mode '1' for 1-bit color.
        self.image = Image.new('1', (self.disp.width, self.disp.height))
        self.font = ImageFont.truetype("/home/pi/Fonts/Tahoma.ttf",12)
        # self.font = ImageFont.load_default()
        # Alternatively load a TTF font.  Make sure the .ttf font file is in the same directory as this python script!
        # Some nice fonts to try: http://www.dafont.com/bitmap.php
        self.draw = ImageDraw.Draw( self.image )
        self.hostname = socket.gethostname()
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        #connect to any target website
        s.connect(('google.com', 0))
        self.ipAddress = s.getsockname()[0]
        s.close()
        self.oledUpdateRunning = False
        self.sleepingOled = False
        self.line3 = ""
        self.line4 = ""
        self.wakeUpImage = Image.open('/home/pi/Projects/wakeUpImage.jpg').convert('1')
        self.speakImage = Image.open('/home/pi/Projects/speakImage.jpg').convert('1')
        self.mode = 'text'

    def updateDisplay(self,):
        self.disp.clear()
        # Clear image buffer by drawing a black filled box.
        self.draw.rectangle((0,0,self.disp.width,self.disp.height), outline=0, fill=0)
        if not self.sleepingOled:
            if self.mode == 'speakImage':
                self.disp.image(self.speakImage)
            elif self.mode == 'wakeUpImage':
                self.disp.image(self.wakeUpImage)
            else:
                dayOfWeekString = time.strftime("%A %b %-d")
                self.draw.text((4,1), dayOfWeekString, font=self.font, fill=255)
                self.draw.text((2,16), self.ipAddress, font=self.font, fill=255)
                self.draw.text((2,32), self.line3, font=self.font, fill=255)
                self.draw.text((2,48), self.line4, font=self.font, fill=255)
                self.disp.image(self.image)
        self.disp.display()

    def oledUpdateThread(self,):
        # print "started oledeUpdateThread"
        while self.oledUpdateRunning:
            self.updateDisplay()
            time.sleep(0.5)

    def setImageMode(self,newMode='text'):
        self.mode = newMode
        self.updateDisplay()

    def setLine3(self,val=""):
        self.line3 = val
        self.updateDisplay()

    def setLine4(self,val=""):
        self.line4 = val
        self.updateDisplay()

    def setSleepMode(self,sleep):
        # print("set sleep mode="+str(sleep))
        self.sleepingOled = sleep
        self.updateDisplay()

    def run(self):
        self.oledUpdateRunning = True
        self.oThread = Thread(target=self.oledUpdateThread )
        self.oThread.daemon = True
        self.oThread.start()

if __name__ == '__main__':
    # print "DisplayOLED"
    oled = OLED_Display()
    oled.run()
    while True:
        time.sleep(5.0)
        oled.setImageMode('speakImage')
        time.sleep(5.0)
        oled.setImageMode('text')
        time.sleep(5.0)
        oled.setImageMode('wakeUpImage')
        time.sleep(5.0)
        oled.setImageMode('text')

#!/usr/bin/python

# ===========================================================================
# Alexa Voice Handler
# ===========================================================================

import time
from threading import Thread
from Queue import Queue
import subprocess

import os
#import random
import alsaaudio
import wave
from creds import *
import requests
import json
import re
from memcache import Client

servers = ["127.0.0.1:11211"]
mc = Client(servers, debug=1)
path = os.path.realpath(__file__).rstrip(os.path.basename(__file__))
device = "plughw:1" # Name of your microphone/soundcard in arecord -L

class AlexaVoice(object):

    def __init__(self,):
        # Create display instance on default I2C address (0x70) and bus number.
        self.commandQueue = Queue()
        self.running = False
        self.defaultCommand = "/home/pi/Voices/time.wav"

    def internetAvailable(self,):
        # print "Checking Internet Connection"
        try:
            r =requests.get('https://api.amazon.com/auth/o2/token')
            # print "Connection OK"
            return True
        except:
            # print "Connection Failed"
            return False
        
    def getAmazonToken(self,):
        # print "getAmazonToke"
        token = mc.get("access_token")
        refresh = refresh_token
        if token:
		    return token
        elif refresh:
		    payload = {"client_id" : Client_ID, "client_secret" : Client_Secret, "refresh_token" : refresh, "grant_type" : "refresh_token", }
		    url = "https://api.amazon.com/auth/o2/token"
		    r = requests.post(url, data = payload)
		    resp = json.loads(r.text)
		    mc.set("access_token", resp['access_token'], 3570)
		    return resp['access_token']
        else:
            return False
		    
    def getVerbalCommand(self,):
	    inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device)
	    inp.setchannels(1)
	    inp.setrate(16000)
	    inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
	    inp.setperiodsize(500)
	    audio = ""
	    t_end = time.time() + 5
	    while time.time() < t_end:
	        l, data = inp.read()
	        if l:
	            audio += data
	    rf = open('/home/pi/Recordings/recording.wav', 'w')
	    rf.write(audio)
	    rf.close()
	    inp = None
	    
    def startVerbalCommand(self,command='/home/pi/Recordings/recording.wav'):
        self.commandQueue.put(command)
        
    def startDialog(self,command='/home/pi/Voices/time.wav'):
       self.commandQueue.put(command)
    
    def alexaVoiceHandler(self,):
        while self.running:
            command = self.commandQueue.get(block=True)
            url = 'https://access-alexa-na.amazon.com/v1/avs/speechrecognizer/recognize'
            headers = {'Authorization' : 'Bearer %s' % self.getAmazonToken()}
            d = {
   	            "messageHeader": {
       		        "deviceContext": [
           		        {
               		        "name": "playbackState",
               		        "namespace": "AudioPlayer",
               		        "payload": {
                   		        "streamId": "",
        			   	        "offsetInMilliseconds": "0",
                                "playerActivity": "IDLE"
                            }
                        }
                    ]
                },
   	            "messageBody": {
                    "profile": "alexa-close-talk",
                    "locale": "en-us",
                    "format": "audio/L16; rate=16000; channels=1"
                }
            }

            with open(command) as inf:
                files = [
                        ('file', ('request', json.dumps(d), 'application/json; charset=UTF-8')),
                        ('file', ('audio', inf, 'audio/L16; rate=16000; channels=1'))
                        ]	
                r = requests.post(url, headers=headers, files=files)
            if r.status_code == 200:
                for v in r.headers['content-type'].split(";"):
                    if re.match('.*boundary.*', v):
                        boundary =  v.split("=")[1]
                data = r.content.split(boundary)
                for d in data:
                    if (len(d) >= 1024):
                        audio = d.split('\r\n\r\n')[1].rstrip('--')
                with open(path+"response.mp3", 'wb') as f:
                    f.write(audio)
                os.system('mpg123 -q {}1sec.mp3 {}response.mp3 {}1sec.mp3'.format(path, path, path))
            else:
                print "http status=",r.status_code
            
    def run(self,):
        while self.internetAvailable() == False:
		    print "."
        self.getAmazonToken()
        self.running = True
        self.tuThread = Thread(target=self.alexaVoiceHandler )
        self.tuThread.daemon = True
        self.tuThread.start()  

if __name__ == '__main__':
    # print "ClockLED"
    alexa = AlexaVoice()
    alexa.run()
    while True:
        # simple input driver
        choice = raw_input("> ")

        if choice == 'x' :
            print "exiting"
            alexa.running = False
            time.sleep(2.0)
            break
        elif choice == 't':
            alexa.startDialog("/home/pi/Voices/time.wav")
        
        elif choice == 'w':
            alexa.startDialog("/home/pi/Voices/weather.wav")
            
        else:
            print ("e)xit or a)larm or + or -")

#!/usr/bin/python

# ===========================================================================
# Rotating Logger Class
# ===========================================================================

import logging
from logging.handlers import RotatingFileHandler

class MyLogger(object):

  def __init__(self, fileName='logging.log', fileSize=1024*1024, fileCopies=5):
    self.logger = logging.getLogger(fileName)
    self.logger.setLevel(logging.INFO)
    self.handler = RotatingFileHandler(filename=fileName,maxBytes=fileSize,backupCount=fileCopies)
    self.formatter = logging.Formatter('%(asctime)s :  %(message)s')
    self.handler.setFormatter(self.formatter)
    self.logger.addHandler(self.handler)
    
  def write(self,msg):
    self.logger.info(msg)

if __name__ == '__main__':
  print "Logging from main"

#!/usr/bin/python
  
import sys
import smbus
from Queue import Queue
import threading 
import datetime
import time

import RPi.GPIO as GPIO
from Adafruit_I2C import Adafruit_I2C
import VCNL4010

# ===========================================================================
# AVAC HW Class
# =========================================================================== 
    
class AVAC_HW(object):
  
    def __init__(self):
        #define 3 queues - log entries, send and receive messages
        self.pirQueue = Queue()
        self.vcnlQueue = Queue()
        self.interruptQueue = Queue()
        self.vcnl4010 = VCNL4010.VCNL4010()
        self.vcnl4010.calibrate()
        self.ambient = 0
        self.newEvent = time.time()
        self.lastEvent = time.time()
        # setup the GPIO bus and 2 interrupts
        GPIO.setmode(GPIO.BCM) 
        GPIO.setup(24, GPIO.IN,pull_up_down=GPIO.PUD_UP)  # GPIO pin 24 is the PIR interrupt
        GPIO.setup(23, GPIO.IN)  # GPIO pin 23 is the VCNL4010 interrupt
        GPIO.add_event_detect(24, GPIO.FALLING, callback=self.pirInterruptHandler) 
        GPIO.add_event_detect(23, GPIO.FALLING, callback=self.vcnlInterruptHandler)
 
    def pirWorkAround(self,):
        self.newEvent = time.time()
        self.elapsed = self.newEvent - self.lastEvent
        # print "seconds=",self.elapsed
        self.lastEvent = self.newEvent
        
    def interruptHelper(self,iQ,pQ,vQ):
        # print "interruptHandler running"
        while True:
            event = self.interruptQueue.get()
            if event == "PIR":
                m = time.strftime("PIR %y-%m-%d %H:%M:%S")
                self.pirQueue.put(m)
                # print m
            else:
                m = time.strftime("VCNL %y-%m-%d %H:%M:%S")
                self.vcnlQueue.put(m)
                # print m
                
    # define threaded callback function for the atmega328pu interrupt 
    def pirInterruptHandler(self,channel):  
        self.interruptQueue.put("PIR")
        print "PIR INT"
    
     # define threaded callback function for the atmega328pu interrupt 
    def vcnlInterruptHandler(self,channel): 
        val = self.vcnl4010.getInterruptStatus()
        self.vcnl4010.setInterruptStatus(val)
        self.interruptQueue.put("VCNL")
        # print "VCNL INT"
        
    def pirWait(self,blocking):
        if blocking:
            print "1 pirWait: blocking"
            data = self.pirQueue.get(blocking)
            # print "2 pirWait: data=",data
            self.pirWorkAround()
            return data
        else:
            if self.pirQueue.empty():
                print "3 pirWait non block: EMPTY"
                return ""
            else:
                data = self.pirQueue.get(False)
                print "4 pirWait non block: data=",data
                self.pirWorkAround()
                return data
        
    def vcnlWait(self,blocking):
        if blocking:
            data = self.vcnlQueue.get(True)
            return data
        else:
            if self.vcnlQueue.empty():
                return ""
            else:
                data = self.vcnlQueue.get(False)
                return data

    def run(self,):
        hwThread = threading.Thread(target=self.interruptHelper,args=(self.interruptQueue,self.pirQueue,self.vcnlQueue))
        hwThread.start()
        
    def exitCleanUp(self):
        self.running = False
        GPIO.cleanup()           # clean up GPIO on normal exit  

if __name__ == '__main__':
  print "AVAC HW Main Running"
  hw = AVAC_HW()
  hw.run()
  while True:
    # time.sleep(0.5)
    m = hw.pirWait(True)
    print m
    if len(m) > 0:
        m = hw.pirWait(False)
        

# Alexa Voice Alarm Clock
# Dave Wilson
# MIT license
# Based on Adafruit exmaples and other great developers

# Derived from - Example of using the MQTT client class to subscribe to and publish feed values.
# Author: Tony DiCola

# Import standard python modules.
import os
import random
import sys
import time
import subprocess
import threading
import alsaaudio

# Import Adafruit IO MQTT client.
from Adafruit_IO import MQTTClient

# Set to your Adafruit IO key & username below.
ADAFRUIT_IO_KEY      = '---'
ADAFRUIT_IO_USERNAME = '---'  # See https://accounts.adafruit.com

import AlexaVoice
import LED_Clock
import OLED_Display
import VCNL4010
import PIR_HW
import VCNL_HW
import MyLogger

global clock
clock = LED_Clock.LED_Clock()
clock.run()

global oled
oled = OLED_Display.OLED_Display()
oled.run()

global vcnl
vcnl = VCNL4010.VCNL4010()
vcnl.calibrate()

global vcnl_interrupt
vcnl_interrupt = VCNL_HW.VCNL_HW()

global pir_interrupt
pir_interrupt = PIR_HW.PIR_HW()

global myprocess
myprocess = None

global alarmTime
alarmTime = ""

global alarmOn
alarmOn = False

global lightOn
lightOn = False

global ID_WAKEUP
ID_WAKEUP = '600509'
global ID_MUSIC
ID_MUSIC = '600620'
global ID_ALARM_TIME
ID_ALARM_TIME = '601507'
global ID_LIGHT_STRIP
ID_LIGHT_STRIP = '601387'
global ID_SLEEP_MODE
ID_SLEEP_MODE = '601554'
global ID_MOTION
ID_MOTION = '600511'


#set up the status logger
global logger
logger = MyLogger.MyLogger(fileName="/home/pi/LogFiles/RotatingLog.log",fileSize=1024*1024)
logger.write("MQTT_AVAC STARTED")


# Define callback functions which will be called when certain events happen.
def connected(client):
    client.subscribe(ID_WAKEUP) # wake up alarm swith
    client.subscribe(ID_MUSIC) # music switch
    client.subscribe(ID_ALARM_TIME) # alarm time
    client.subscribe(ID_LIGHT_STRIP) # light strip
    client.subscribe(ID_SLEEP_MODE) # System sleep mode

def disconnected(client):
    sys.exit(1)

def message(client, feed_id, payload):
    global myprocess
    global alarmTime
    # wake up alarm switch
    if feed_id == ID_WAKEUP:
        alarmOn = False
        if payload == "ON":
            clock.alarm = True
            logger.write("WAKEUP ON")
        else:
            clock.alarm = False
            logger.write("WAKEUP OFF")
    # music switch
    elif feed_id == ID_MUSIC:
        if payload == "ON":
            dirStr = '/home/pi/Music/'
            fileStr = time.strftime("%A")
            pathStr = dirStr + fileStr + '.m4a'
            myprocess = subprocess.Popen(['omxplayer','-b',pathStr],
            stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            oled.setLine3("Music Player")
            logger.write("MUSIC ON")
        else:
            logger.write("MUSIC OFF")
            if myprocess != None:
                try:
                    myprocess.stdin.write('q')
                except IOError as e:
                    logger.write("BROKEN PIPE: OMXPLAYER")
                oled.setLine3("")
    # light switch
    elif feed_id == ID_LIGHT_STRIP:
        if payload == "ON":
            lightOn = True
            logger.write("LIGHT STRIP ON")
            oled.setLine3("Night Light: ON")
        else:
            lightOn = False
            logger.write("LIGHT STRIP OFF")
            oled.setLine3("Night Light: OFF")
    # brighthness controls during sleep
    elif feed_id == ID_SLEEP_MODE:
        if payload == "ON":
            logger.write("SLEEP ON")
            clock.setBrightness(0)
            oled.setSleepMode(True)
        else:
            logger.write("SLEEP OFF")
            clock.setBrightness(7)
            oled.setSleepMode(False)
    # wake up time
    elif feed_id == ID_ALARM_TIME: # alarm time
        logger.write("ALARM TIME: "+payload)
        alarmTime = payload
        oled.setLine4(alarmTime)
    else:
        logger.write("UNDEFINED MESSAGE")
        oled.setLine4("TILT")


### MAIN THREAD ###

global client
# Create an MQTT client instance.
client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY)

# Setup the callback functions defined above.
client.on_connect    = connected
client.on_disconnect = disconnected
client.on_message    = message

# Connect to the Adafruit IO server.
client.connect()

client.loop_background()

# check for proximity user command
def userMonitor():
    global alarmOn
    global alarmWait
    global vcnl_interrupt
    global logger
    global alexa
    global oled
    logger.write("USER MONITOR THREAD STARTED")
    while True:
        switch = vcnl_interrupt.wait(True)
        while len(switch) > 0:
            switch = vcnl_interrupt.wait(False)
            # time.sleep(0.1)
        if alarmOn:
            alarmOn = False
            logger.write("STOP ALARM PROCESS")
        else:
            oled.setImageMode('speakImage')
            alexa.getVerbalCommand()
            oled.setImageMode('text')
            alexa.startVerbalCommand()


# check for pir movement
def motionMonitor():
    global pir_interrupt
    global logger
    global alexa
    global client
    logger.write("MOTION MONITOR THREAD STARTED")
    # print "motionMonitor"
    lastMotion = 0
    currentMotion = 0
    waitForMotion = True
    #client.publish(ID_MOTION,currentMotion)
    while True:
        time.sleep(0.1)
        motion = pir_interrupt.wait(waitForMotion)
        # logger.write(motion)
        if len(motion) > 0:
            waitForMotion = False
            while len(motion) > 0:
                # logger.write(motion)
                motion = pir_interrupt.wait(waitForMotion)
            currentMotion = 1
            logger.write("MOTION DETECTED")
        else:
            currentMotion = 0
            waitForMotion = True
            logger.write("MOTION NOT DETECTED")
        if not (lastMotion == currentMotion):
            lastMotion = currentMotion
            #client.publish(ID_MOTION,currentMotion)

alexa = AlexaVoice.AlexaVoice()
alexa.run()

# initialize the clock

time.sleep(5.0)
client.publish(ID_SLEEP_MODE, "OFF")
client.publish(ID_LIGHT_STRIP, "OFF")
client.publish(ID_WAKEUP, "OFF")
client.publish(ID_MUSIC, "OFF")
client.publish(ID_ALARM_TIME, "05:00")
time.sleep(5.0)

userThread = threading.Thread(target=userMonitor)
userThread.start()

#motionThread = threading.Thread(target=motionMonitor)
#motionThread.start()

frame = 0

### Loop forever checking for the alarm

alarmOn = False

while True:
    time.sleep(0.1)
    frame = frame + 1

    if clock.alarm:
        digitString = time.strftime("%H:%M")
        if str(alarmTime) == str(digitString):
            alarmOn = True
            logger.write("START ALARM PROCESS")
            oled.setImageMode('wakeUpMode')
            os.system('mpg123 -q /home/pi/Voices/AVAC-Hello-Time-To-Get-Up.mp3')
            time.sleep(5.0)
            if alarmOn:
                alexa.startDialog("/home/pi/Voices/time.wav")
                time.sleep(5.0)
            if alarmOn:
                alexa.startDialog("/home/pi/Voices/weather.wav")
                time.sleep(5.0)
            if alarmOn:
                client.publish(ID_MUSIC, "ON")
                time.sleep(5.0)
            if not alarmOn:
                client.publish(ID_MUSIC, "OFF")
            client.publish(ID_LIGHT_STRIP, "ON")
            alarmOn = False
        while str(alarmTime) == str(digitString):
            time.sleep(10.0)
            digitString = time.strftime("%H:%M")
            oled.setImageMode('text')
            frame = 6

    if frame >= 40:
        value = vcnl.getAmbientOnDemand()
        vcnl.calibrate()
        client.publish(600510, value)
        frame = 1