def test_send_and_receive(self):
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
test_feed = io.create_feed(Feed(name="testfeed"))
response = io.send_data('testfeed', 'foo')
self.assertEqual(response.value, 'foo')
data = io.receive('testfeed')
self.assertEqual(data.value, 'foo')
def test_send_batch_data(self):
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
test_feed = io.create_feed(Feed(name="testfeed"))
data_list = [Data(value=42), Data(value=42)]
io.send_batch_data(test_feed.key, data_list)
data = io.receive(test_feed.key)
self.assertEqual(int(data.value), 42)
def test_create_data(self):
aio = self.get_client()
self.ensure_feed_deleted(aio, 'testfeed')
test_feed = aio.create_feed(Feed(name="testfeed"))
aio.send_data('testfeed', 1) # Make sure TestFeed exists.
data = Data(value=42)
result = aio.create_data('testfeed', data)
self.assertEqual(int(result.value), 42)
def initfeeds(feedname):
try:
feede = aio.feeds(feedname)
return feede
except RequestError:
feed = Feed(name=feedname)
feede = aio.create_feed(feed)
return feede
def test_data_on_feed_and_data_id_returns_data(self):
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
test_feed = io.create_feed(Feed(name="testfeed"))
data = io.send_data('testfeed', 1)
result = io.data('testfeed', data.id)
self.assertEqual(data.id, result.id)
self.assertEqual(int(data.value), int(result.value))
def test_receive_next(self):
"""receive_next
"""
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
test_feed = io.create_feed(Feed(name="testfeed"))
io.send_data('testfeed', 1)
data = io.receive_next('testfeed')
self.assertEqual(int(data.value), 1)
def test_feeds_returns_all_feeds(self):
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
feed = io.create_feed(Feed(name='testfeed'))
io.send_data('testfeed', 1) # Make sure TestFeed exists.
feeds = io.feeds()
self.assertGreaterEqual(len(feeds), 1)
names = set(map(lambda x: x.name, feeds))
self.assertTrue('testfeed' in names)
def test_location_data(self):
aio = self.get_client()
self.ensure_feed_deleted(aio, 'testlocfeed')
test_feed = aio.create_feed(Feed(name="testlocfeed"))
aio.send_location_data(test_feed.key, 0, 40, -74, 6)
data = aio.receive(test_feed.key)
self.assertEqual(int(data.value), 0)
self.assertEqual(float(data.lat), 40.0)
self.assertEqual(float(data.lon), -74.0)
self.assertEqual(float(data.ele), 6.0)
def test_data_on_feed_returns_all_data(self):
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
test_feed = io.create_feed(Feed(name="testfeed"))
io.send_data('testfeed', 1)
io.send_data('testfeed', 2)
result = io.data('testfeed')
self.assertEqual(len(result), 2)
self.assertEqual(int(result[0].value), 2)
self.assertEqual(int(result[1].value), 1)
def setup_io_feeds():
existing_feeds = aio.feeds()
existing_feeds_keys = list(map(lambda feed: feed.key, existing_feeds))
for feed_name, feed_values in FEEDS.items():
if feed_name not in existing_feeds_keys:
feed = Feed(name=feed_values['name'],
key=feed_values['name'],
unit_symbol=feed_values['unit_symbol'],
unit_type=feed_values['unit_type'])
aio.create_feed(feed)
def AdafruiIO(device_id, value, property):
feed_name=str(device_id.lower())+str(property.lower())
dprint("Processing data : Feed="+feed_name+",Value="+str(value))
try:
sensor = aio.feeds(feed_name)
except RequestError: # create a analog feed
dprint("Creating new feed")
feed = Feed(name=feed_name)
sensor = aio.create_feed(feed)
aio.send(sensor.key, value)
def generate_feeds(aio, feeds_name):
feeds = dict()
for name in feeds_name:
print('[AIO_REMOTE] generating ' + name + ' feed')
try:
feed = aio.feeds(name)
except RequestError:
feed = Feed(name=name)
feed = aio.create_feed(feed)
feeds[name] = feed
return feeds
def test_receive_previous(self):
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
test_feed = io.create_feed(Feed(name="testfeed"))
io.send_data(test_feed.key, 1)
io.receive_next(test_feed.key) # Receive 1
data = io.receive_previous(test_feed.key)
self.assertEqual(int(data.value), 1)
io.send_data(test_feed.key, 2)
io.receive_next(test_feed.key) # Receive 2
data = io.receive_previous(test_feed.key)
self.assertEqual(int(data.value), 2)
def initializeFeed(client, feedKey):
returnKey = ""
if USE_AIO:
try:
feed = client.feeds(feedKey.lower())
returnKey = feed.key
print(returnKey)
except RequestError:
feed = Feed(name=feedKey.lower())
feed = client.create_feed(feed)
returnKey = feed.key
return returnKey
def get_feed(self, metric_name):
# make request for feed if it hasn't been retrieved yet
if metric_name not in self.feed_cache:
try:
feed = self.client.feeds(metric_name)
except RequestError: # Doesn't exist, create a new feed
feed = self.client.create_feed(Feed(name=metric_name))
self.feed_cache[metric_name] = feed
return self.feed_cache[metric_name]
def receive_dht11():
feed_name = "bk-iot-temp-humid"
try:
temp = aio.feeds(feed_name)
except RequestError:
feed = Feed(name=feed_name)
temp = aio.create_feed(feed)
data_receive = aio.receive(temp.key)
data = eval(data_receive.value)
value = data["data"].split("-")
data_json = {
"time": data_receive.created_at,
"temp": value[0],
"humid": value[1],
"id": data_receive.id
}
temp_time = int((data_receive.created_at)[11] +
(data_receive.created_at)[12]) + 7
if temp_time > 23:
result_time = (data_receive.created_at)[0:11] + str(temp_time - 24) + (
data_receive.created_at)[13:]
else:
result_time = (data_receive.created_at)[0:11] + str(temp_time) + (
data_receive.created_at)[13:]
if int(value[0]) < 30:
status1 = "1" #nhiệt độ thấp
else:
status1 = "0" # nhiệt độ cao
if int(value[1]) < 70:
status2 = "0" # độ ẩm kk thấp
else:
status2 = "1" #độ ẩm kk cao
status = status1 + status2
mycursor = mydb.cursor()
sql_select_max = "SELECT MAX(dht_ID) FROM tbl_dht11"
mycursor.execute(sql_select_max)
max_id = mycursor.fetchone()
sql_select_check = "SELECT dht_IDcheck FROM tbl_dht11 WHERE dht_ID = %s"
mycursor.execute(sql_select_check, (max_id[0], ))
check = mycursor.fetchone()
if (check == None) or (check[0] != data_receive.id):
sql = "INSERT INTO tbl_dht11(dht_Time,dht_Temp,dht_Humid,dht_status,dht_GardenID,dht_IDcheck) VALUES (%s,%s,%s,%s,%s,%s)"
mycursor.execute(
sql, (result_time, value[0], value[1], status, 2, data_receive.id))
mydb.commit()
mycursor.close()
def switch_relay():
feed_name = "bk-iot-relay"
mycursor = mydb.cursor()
sql = "SELECT MAX(relay_ID) FROM tbl_relay"
mycursor.execute(sql)
r = mycursor.fetchone()
sql1 = "SELECT relay_Value FROM tbl_relay WHERE relay_ID = %s"
mycursor.execute(sql1, (r[0], ))
r1 = mycursor.fetchone()
mydb.commit()
#print(r1[0])
data_pulish = 0
if r1[0] == "1":
data_pulish = 0
else:
data_pulish = 1
try:
temp = aio1.feeds(feed_name)
except RequestError:
feed = Feed(name=feed_name)
temp = aio1.create_feed(feed)
data_send = '{"id":"11","name":"RELAY","data":"' + str(
data_pulish) + '","unit":""}'
#####thêm vao trong da
aio1.send_data(temp.key, data_send)
data_receive = aio1.receive(temp.key)
data = eval(data_receive.value)
data_json = {
"time": data_receive.created_at,
"value": data["data"],
"id": data_receive.id
}
temp_time = int((data_receive.created_at)[11] +
(data_receive.created_at)[12]) + 7
if temp_time > 23:
result_time = (data_receive.created_at)[0:11] + str(temp_time - 24) + (
data_receive.created_at)[13:]
else:
result_time = (data_receive.created_at)[0:11] + str(temp_time) + (
data_receive.created_at)[13:]
sql_insert = "INSERT INTO tbl_relay(relay_Time,relay_Value,relay_gardenID) VALUES (%s,%s,%s)"
mycursor.execute(sql_insert, (result_time, data["data"], 2))
mydb.commit()
mycursor.close()
return jsonify({"message": "pulish successfully"})
def test_create_feed_in_group(self):
"""Tests creating a feed within a group.
"""
io = self.get_client()
self.ensure_feed_deleted(io, 'testfeed')
self.ensure_group_deleted(io, 'testgroup')
group = io.create_group(Group(name='testgroup'))
feed = Feed(name='testfeed')
result = io.create_feed(feed, "testgroup")
self.assertEqual(result.key, "testgroup.testfeed")
io.delete_feed(result.key)
io.delete_group('testgroup')
def test_feeds_have_explicitly_set_values(self):
""" Let's make sure feeds are explicitly set from within the model:
Feed.__new__.__defaults__ = (None, None, None, None, None, 'ON', 'Private', None, None, None)
"""
feed = Feed(name='foo')
self.assertEqual(feed.name, 'foo')
self.assertIsNone(feed.key)
self.assertIsNone(feed.description)
self.assertIsNone(feed.unit_type)
self.assertIsNone(feed.unit_symbol)
self.assertEqual(feed.history, 'ON')
self.assertEqual(feed.visibility, 'Private')
self.assertIsNone(feed.license)
self.assertIsNone(feed.status_notify)
self.assertIsNone(feed.status_timeout)
def test_location_data(self):
"""receive_location
"""
aio = self.get_client()
self.ensure_feed_deleted(aio, 'testlocfeed')
test_feed = aio.create_feed(Feed(name='testlocfeed'))
metadata = {'lat': 40.726190,
'lon': -74.005334,
'ele': -6,
'created_at': None}
aio.send_data(test_feed.key, 40, metadata)
data = aio.receive(test_feed.key)
self.assertEqual(int(data.value), 40)
self.assertEqual(float(data.lat), 40.726190)
self.assertEqual(float(data.lon), -74.005334)
self.assertEqual(float(data.ele), -6.0)
def create_feed_connection(aio: Client, feed_name: str) -> None:
"""
Connects to a feed and creates it if it does not exists.
Arguments:
- aio: Adafruit IO Client object
- feed_name: A feed name to connect to
Returns: None
"""
try:
return aio.feeds(feed_name)
logging.info("[{0}] Connected to {1} feed".format(datetime.now(), feed_name))
except RequestError: # Doesn't exist, create a new feed
feed = Feed(name=feed_name)
logging.info("[{0}] Created {1} feed".format(datetime.now(), feed_name))
return aio.create_feed(feed)
def send(feed_no=args.feed_no,
onoff_lis=args.onoff_lis,
time=args.time,
device_states=dfm.initial_device_states):
try:
feed = aio.feeds(feed_no)
except RequestError:
new_feed = Feed(name=feed_no)
feed = aio.create_feed(new_feed)
onoff_string = ''
for elem in onoff_lis:
onoff_string = onoff_string + ',' + str(elem)
packet = args.time + ',' + onoff_string
aio.send_data(feed.key, packet)
#if(success)
dfm.write_files(initial_device_states=device_states)
def receive_soil():
feed_name = "bk-iot-soil"
try:
temp = aio.feeds(feed_name)
except RequestError:
feed = Feed(name=feed_name)
temp = aio.create_feed(feed)
data_receive = aio.receive(temp.key)
data = eval(data_receive.value)
data_json = {
"time": data_receive.created_at,
"value": data["data"],
"id": data_receive.id
}
temp_time = int((data_receive.created_at)[11] +
(data_receive.created_at)[12]) + 7
if temp_time > 23:
result_time = (data_receive.created_at)[0:11] + str(temp_time - 24) + (
data_receive.created_at)[13:]
else:
result_time = (data_receive.created_at)[0:11] + str(temp_time) + (
data_receive.created_at)[13:]
if int(data["data"]) < 100:
status = 0 # Đất khô
else:
status = 1 # Đất ẩm
mycursor = mydb.cursor()
sql_select_max = "SELECT MAX(amdat_ID) FROM tbl_amdat"
mycursor.execute(sql_select_max)
max_id = mycursor.fetchone()
sql_select_check = "SELECT amdat_IDcheck FROM tbl_amdat WHERE amdat_ID = %s"
mycursor.execute(sql_select_check, (max_id[0], ))
check = mycursor.fetchone()
if (check == None) or (check[0] != data_receive.id):
sql = "INSERT INTO tbl_amdat(amdat_Time,amdat_Value,amdat_GardenID,amdat_Status,amdat_IDcheck) VALUES (%s,%s,%s,%s,%s)"
mycursor.execute(
sql, (result_time, data["data"], 2, status, data_receive.id))
mydb.commit()
mycursor.close()
def test_adafruit_io_feed(self):
load_dotenv(verbose=True)
KEY = os.getenv("ADAFRUIT_IO_KEY")
USERNAME = os.getenv("ADAFRUIT_IO_USERNAME")
aio = Client(USERNAME, KEY)
try:
test = aio.feeds("test")
except RequestError: # Doesn't exist, create a new feed
feed = Feed(name="test")
test = aio.create_feed(feed)
for i in range(5):
value = randint(0, 50)
aio.send_data(test.key, value)
data = aio.receive(test.key)
self.assertIsNotNone(data.value)
def receive_relay():
feed_name = "bk-iot-relay"
try:
temp = aio1.feeds(feed_name)
except RequestError:
feed = Feed(name=feed_name)
temp = aio1.create_feed(feed)
data_receive = aio1.receive(temp.key)
data = eval(data_receive.value)
data_json = {
"time": data_receive.created_at,
"value": data["data"],
"id": data_receive.id
}
mycursor = mydb.cursor()
sql = "INSERT INTO tbl_relay(relay_Time,relay_Value,relay_gardenID) VALUES (%s,%s,%s)"
mycursor.execute(sql, (data_receive.created_at, data["data"], 2))
mydb.commit()
mycursor.close()
return jsonify({"relay": data_json})
def AdafruitUpload(self):
"""Upload observed values to Adafruit IO
"""
if self.config['ADAFRUIT_IO']['ENABLED'].upper() == 'Y':
if not self.adafruit_last_upload or \
datetime.datetime.now() >= self.adafruit_last_upload + \
datetime.timedelta(
minutes=int(self.config['ADAFRUIT_IO']['UPLOAD_INTERVAL'])):
values = self.GetValueDict()
for key in values:
if values[key]:
try:
feed = self.aio.feeds(feed=key)
except RequestError:
feed = Feed(name=key)
feed = self.aio.create_feed(feed)
self.aio.send_data(feed.key, values[key])
self.adafruit_last_upload = datetime.datetime.now()
def createRoomTopics(house: str, room: str, data: dict) -> None:
global client
response_keys = []
# Create all feeds of the room
for data_topic in data:
feed_name = house + '-' + room + '-' + data_topic
response = client.create_feed(Feed(name=feed_name, key=feed_name))
response_keys.append(response.key)
# Create a New Debugger to the new Room
stream = Block(name=house + '-' + room + ' Debugger',
visual_type='stream',
properties={
"fontSize": "12",
"fontColor": "#63de00",
"showGroupName": "no"
},
block_feeds=list([{
"group_id": MQTT_GROUP_KEY,
"feed_id": feed_key
} for feed_key in response_keys]))
stream = client.create_block(MQTT_DASHBOARD_KEY, stream)
# Update Layout to the new Debugger
client.update_layout(
MQTT_DASHBOARD_KEY,
Layout(lg=[{
'x': 0,
'y': 0,
'w': 7,
'h': 4,
'i': str(stream.id)
}]))
# Send the default values to the new Room Topics
for data_topic, key in zip(data, response_keys):
client.send_data(key, data[data_topic])
sleep(3)
from aoi_key import ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY
# Delay in-between sensor readings, in seconds.
READ_TIMEOUT = 5
# Name of the Adafruit IO feed
FEED_NAME = "tmp75"
# Create an instance of the REST client.
aio = Client(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY)
# Set up Adafruit IO Feeds.
try:
tmp75_feed = aio.feeds(FEED_NAME)
except errors.RequestError:
feed = Feed(name=FEED_NAME)
tmp75_feed = aio.create_feed(feed)
print("Created feed %s" % FEED_NAME)
# Set up TMP75 Sensor
tmp75_sensor = barbudor_tmp75.TMP75(board.I2C())
tmp75_error = False
while True:
try:
if tmp75_error: # if an error occured, re-write config register with 12 bits mode
# pylint: disable=protected-access
tmp75_sensor.config = barbudor_tmp75._CONFIG_CONVERTER_12BITS
# pylint: enable=protected-access
temp = '%.2f'%(tmp75_sensor.temperature_in_C)
print('Temp2=%sC'%(temp))
import logging
import os
from Adafruit_IO import Data
YOUR_AIO_USERNAME = os.getenv('YOUR_AIO_USERNAME') #ADAFRUIT_IO_USERNAME
YOUR_AIO_KEY = os.getenv('YOUR_AIO_KEY') #ADAFRUIT_IO_KEY
from Adafruit_IO import Client, Feed
aio = Client(YOUR_AIO_USERNAME, YOUR_AIO_KEY)
#create feed
new = Feed(name='chatbot1')
result = aio.create_feed(new)
#logging exception handler
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
import requests #Getting the data from the cloud
def ledoff(bot, update):
value = Data(value=0) #Sending a value to a feed
value_send = aio.create_data('chatbot1', value)
chat_id = bot.message.chat_id
update.bot.sendPhoto(
chat_id=chat_id,
photo=
"https://tse3.mm.bing.net/th?id=OIP.dTmDdvOWEO-0s7t0Z3Yr4gHaJ4&pid=Api&P=0&w=300&h=300",
!pip install adafruit-io
import os
x = os.getenv('x')
y = os.getenv('y') #Use your own Adafruit Active Key
from Adafruit_IO import Client, Feed
aio = Client(x,y)
new = Feed(name='bot123') #Creating a new feed
result = aio.create_feed(new)
result
from Adafruit_IO import Data
!pip install python-telegram-bot
from Adafruit_IO import Client,Data
from telegram.ext import Updater,CommandHandler
def on(bot,update):
chat_id = update.message.chat_id
aio.create_data('bot123',Data(value = 1))
bot.send_message(chat_id =chat_id,text ="Lights On")
def off(bot,update):
chat_id = update.message.chat_id
aio.create_data('bot123',Data(value = 0))
bot.send_message(chat_id =chat_id,text ="Lights Off")
updater = Updater('1314501154:AAFupk7zdBSYmGlY2cDaSUdYLO4RAfF3TXs') #Use Telegram Token HTTP API
dp =updater.dispatcher
dp.add_handler(CommandHandler('on',on))
dp.add_handler(CommandHandler('off',off))
updater.start_polling()
updater.idle()
