4180 Smart Aquarium

pip install flask-ask

import logging
from random import randint
from flask import Flask, render_template
from flask_ask import Ask, statement, question, session
import datetime
import time
import pymysql
import sys

HOSTNAME = "sensordata.cxvfjw9upbqk.us-east-1.rds.amazonaws.com"
USERNAME = 'root'
PASSWORD = 'password'
DB_NAME = 'sensorstuff'
connection = pymysql.connect(host=HOSTNAME,
                                 user=USERNAME,
                                 passwd=PASSWORD,
                                 db=DB_NAME,
                                 port=3306,
                                 autocommit=True,
                                 cursorclass=pymysql.cursors.DictCursor)
connection.autocommit(True)

app = Flask(__name__)
ask = Ask(app, "/")
logging.getLogger("flask_ask").setLevel(logging.DEBUG)

@ask.launch
def start_skill():
	msg = "Welcome to the fish tank app. Please say your command" 
	return question(msg).reprompt("Do you have another command?")
	# welcome_msg = "Would you like to know the external or internal temperature?"
	# return question(welcome_msg)

@ask.intent("InternalIntent")
def internal_temperature():
	with connection.cursor() as cursor:
		sql = "SELECT * FROM Temp ORDER BY ID desc LIMIT 1"
		cursor.execute(sql)
		result = cursor.fetchone()
	curTime = result['TS']
	month = curTime.strftime("%I %M")
	msg = "The current internal temperature is %.2f degrees fahrenheit recorded at %s . Is there something else you would like me to do?" % (result['V'],month)
	return question(msg).reprompt("Do you have another command?")

@ask.intent("LightsOnIntent")
def lights_on():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','1')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Turning on the lights. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("LightsOffIntent")
def lights_off():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','0')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Turning off the lights. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("RaiseBrightnessIntent")
def raise_brightness():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','+')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Raising the brightness. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("LowerBrightnessIntent")
def lower_brightness():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','-')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Lowering the brightness. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("PatternIntent")
def pattern():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','p')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Changing the pattern. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("AmbientModeIntent")
def ambient_mode():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','a')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Switching to ambient mode. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("ManualModeIntent")
def manual_mode():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','m')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Switching to manual mode. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("FeedIntent")
def feed():
	ts = time.time()
	timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
	with connection.cursor() as cursor:
		sql = "INSERT INTO Alexa (TS,Code) VALUE ('%s','=')" % (timestamp)
		cursor.execute(sql)
	msg = "Okay. Feeding the fish. Is there something else you would like me to do?"
	return question(msg).reprompt("Do you have another command?")

@ask.intent("NoIntent")
def no():
	return statement("Okay. Bye then.")

if __name__ == '__main__':
    app.run(debug=True)

python fishTank.py

{
  "intents": [
    {
      "intent": "ExternalIntent"
    },
    {
      "intent": "InternalIntent"
    },
    {
      "intent": "LightsOnIntent"
    },
    {
      "intent": "LightsOffIntent"
    },
    {
      "intent": "RaiseBrightnessIntent"
    },
    {
      "intent": "LowerBrightnessIntent"
    },
    {
      "intent": "PatternIntent"
    },
    {
      "intent": "AmbientModeIntent"
    },
    {
      "intent": "ManualModeIntent"
    },
    {
      "intent": "NoIntent"
    },
    {
      "intent": "FeedIntent"
    }
  ]
}

InternalIntent internal temperature
LightsOnIntent lights on
LightsOffIntent lights off
RaiseBrightnessIntent raise the brightness
LowerBrightnessIntent lower the brightness
PatternIntent change patterns
PatternIntent pattern
AmbientModeIntent ambient mode
AmbientModeIntent switch to ambient mode on
ManualModeIntent manual mode
ManualModeIntent switch to manual mode
NoIntent no
FeedIntent feed the fish
FeedIntent motor

import boto3
from time import sleep

# AWS KEYS
AWS_KEY="Your KEY"
AWS_SECRET="Your SECRET"
REGION="us-east-1"

# GLOBAL VARIABLES
EC2_INSTANCE_ID = "<enter-here>" # INSERT EC2 INSTANCE ID
INSTANCE_TYPE = "db.t2.micro" # TYPE OF INSTANCE (FREE TIER)
ID = "" # DATABASE UNIQUE IDENTIFIER
USERNAME = '' # DATABASE USERNAME
PASSWORD = '' # DATABASE PASSWORD
DB_PORT = 3306 # DATABASE PORT
DB_SIZE = 5 # SIZE OF THE DATABSE (5GB)
DB_ENGINE = 'mysql' # TYPE OF DATABASE
DB_NAME = '' # NAME OF DATABASE TO USE (DEFAULT)
SECGROUP_ID = "" # SECURITY GROUP ID (USED BY THE EC2 INSTANCE)

print "Connecting to RDS"

ec2 = boto3.client('ec2',   aws_access_key_id = AWS_KEY,
                            aws_secret_access_key = AWS_SECRET,
                            region_name = REGION)
rds = boto3.client('rds',   aws_access_key_id = AWS_KEY,
                            aws_secret_access_key = AWS_SECRET,
                            region_name = REGION)

# GET THE SECURITY GROUP OF THE INSTANCE ALREADY CREATED
SECGROUP_ID = ec2.describe_instances(InstanceIds = [EC2_INSTANCE_ID])['Reservations'][0]['Instances'][0]['SecurityGroups'][0]['GroupId']


print "Creating an RDS instance"

response = rds.create_db_instance(  DBName = DB_NAME, 
                                    DBInstanceIdentifier = ID, 
                                    AllocatedStorage = DB_SIZE,
                                    DBInstanceClass = INSTANCE_TYPE, 
                                    Engine = DB_ENGINE,
                                    MasterUsername = USERNAME,
                                    MasterUserPassword = PASSWORD,
                                    VpcSecurityGroupIds = [
                                        SECGROUP_ID,
                                    ],
                                    Port = DB_PORT)
    
print "Waiting for instance to be up and running\n"

sleep(30)
response = rds.describe_db_instances(DBInstanceIdentifier = ID)
status = response['DBInstances'][0]['DBInstanceStatus']
    
while not status == 'available':
    sleep(10)
    response = rds.describe_db_instances(DBInstanceIdentifier = ID)
    status = response['DBInstances'][0]['DBInstanceStatus']
    print "Status: "+str(status)

if status == 'available':
    response = rds.describe_db_instances(DBInstanceIdentifier = ID)
    print "\nRDS Instance is now running. Instance details are:"
    print "Intance ID: " + str(response['DBInstances'][0]['DBInstanceIdentifier'])
    print "Intance State: " + str(response['DBInstances'][0]['DBInstanceStatus'])
    print "Instance Type: " + str(response['DBInstances'][0]['DBInstanceClass'])
    print "Engine: " + str(response['DBInstances'][0]['Engine'])
    print "Allocated Storage: " + str(response['DBInstances'][0]['AllocatedStorage'])
    print "Endpoint: " + str(response['DBInstances'][0]['Endpoint'])

CREATE TABLE `Alexa` (
  `TS` timestamp NOT NULL,
  `Code` char(1) DEFAULT NULL,
  PRIMARY KEY (`TS`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

CREATE TABLE `Temp` (
  `ID` int(11) NOT NULL AUTO_INCREMENT,
  `TS` timestamp NOT NULL,
  `V` decimal(5,2) DEFAULT NULL,
  PRIMARY KEY (`ID`)
) ENGINE=InnoDB AUTO_INCREMENT=1993 DEFAULT CHARSET=latin1;

        response = client.publish(
                TargetArn="arn:aws:sns:us-east-1:426036099940:FakeEnding",
                Message="Watch Out: " + str(x),
                MessageStructure='string',
                Subject='Fish Alert'
        )

pip install boto3

pip install PyMySql

import pymysql
import sys
HOSTNAME = 'Your End Point '
USERNAME = 'Your Username '
PASSWORD = 'Your Password'
DB_NAME = 'Your created Database Name'
connection = None
def get_connection():
    global connection
    if connection is not None:
        return connection
    connection = pymysql.connect(host=HOSTNAME,
                                 user=USERNAME,
                                 passwd=PASSWORD,
                                 db=DB_NAME,
                                 port=3306,
                                 autocommit=True,
                                 cursorclass=pymysql.cursors.DictCursor)
    connection.autocommit(True)
    return connection

ACCESS_KEY="YourAccessKey"
SECRET_KEY="YourSecretKey"
REGION="us-east-1"
#get sns
client = boto3.client('sns', aws_access_key_id=ACCESS_KEY,
                            aws_secret_access_key=SECRET_KEY,
                            region_name=REGION)