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()