예제 #1
0
	def postVmp(self,Vmp_Data):
			api = ApiClient(token='wseZ3mpbc7vPzM4tlANdLo5Tqngf48')
			Vmp_variable = api.get_variable('581b2f887625420434ecd29c')
			time.sleep(1)
			Vmp_response = Vmp_variable.save_value({"value": Vmp_Data})
			print Vmp_response		
			time.sleep(3)
예제 #2
0
	def postImp(self,Imp_Data):
			api = ApiClient(token='wseZ3mpbc7vPzM4tlANdLo5Tqngf48')
			Imp_variable = api.get_variable('581b2f957625420481362b11')
			time.sleep(1)
			Imp_response = Imp_variable.save_value({"value": Imp_Data})
			print Imp_response		
			time.sleep(3)
예제 #3
0
def setup():
    global api, bw, fw, buzzer, led_green, led_red, mqtt_distance, mqtt_speed, ua

    # 1. PiCar setup.
    picar.setup()
    ua = Ultrasonic_Avoidance.Ultrasonic_Avoidance(20)
    fw = front_wheels.Front_Wheels(db='config')
    bw = back_wheels.Back_Wheels(db='config')
    fw.turning_max = 45

    # 2. GPIO pins for buzzer and LED.
    GPIO.setmode(GPIO.BCM)  # GPIO.BCM mode.
    GPIO.setup(PIN_BUZZER, GPIO.OUT)  # Buzzer pin.
    GPIO.setup(PIN_LED, GPIO.OUT)  # LED pins.
    GPIO.output(PIN_LED, GPIO.LOW)  # Set LED pins to low to turn off LEDs.
    buzzer = GPIO.PWM(PIN_BUZZER, 440)  # Set buzzer frequency to 440Hz.
    led_red = GPIO.PWM(PIN_LED[0], 2000)  # Set LED frequencies to 2KHz.
    led_green = GPIO.PWM(PIN_LED[1], 2000)
    buzzer.start(0)
    led_red.start(0)
    led_green.start(0)

    # 3. Ubidots.
    api = ApiClient(token='A1E-priJupwmfAGtVeOjcslK9wAW16HJzO')
    mqtt_distance = api.get_variable('59e93a20c03f9748c6bc3d54')
    mqtt_speed = api.get_variable('5a092816c03f9706c0205e88')
예제 #4
0
파일: UBILog.py 프로젝트: jbirkj/BME280
def UBILog(dT, hP, rH, tC, TC1, TC2 ):

        try:

                api = ApiClient(ubiKEY)

                varTemperature = api.get_variable('57f814887625420821011130')
                varHumidity = api.get_variable('57f81f3f762542423c82b54a')
                varInterval = api.get_variable('57f89eb476254264592de214')
                varT_DS18b20_1 = api.get_variable('57f948e37625425f615546dc')
                varT_DS18b20_2 = api.get_variable('57f9492d7625426071c1d3ee')
        
                # save values to ubidots cloud
                response1 = varTemperature.save_value({'value':tC})
                response2 = varHumidity.save_value({'value':rH})
                response3 = varT_DS18b20_1.save_value({'value':TC1})
                response4 = varT_DS18b20_2.save_value({'value':TC2})

                #get value from ubidots cloud

                intInterval = int(varInterval.get_values(1)[0]['value'])
                
                return intInterval
        
                
        except UbidotsError400 as e:
                print("Code Exception: Error400 in UBILog.py", e.message, " and the details: ", e.detail)

        except UbidotsError404 as e:
                print("Code exception: Error404 in UBILog.py: ", e.message, " and the details: ", e.detail)

        except:
                print("generel exception ")
                return 30 #wait 30secs for next data upload
예제 #5
0
	def postStatus(self,Status_Data):
			api = ApiClient(token='wseZ3mpbc7vPzM4tlANdLo5Tqngf48')
			Status_variable = api.get_variable('58466a2e7625420ada1399c4')
			time.sleep(1)
			Status_response = Status_variable.save_value({"value": Status_Data})
			print Status_response		
			time.sleep(3)
예제 #6
0
def setup():
    global people
    global peoplecounter
    global PEOPLECOUNT_ID
    global TEMPCOUNT_ID
    global HUMIDITYCOUNT_ID
    global templevel
    global humiditylevel

    API_KEY = "BBFF-b324f9278c9dd3b78728cd92f16ac5e527e"
    PEOPLECOUNT_ID = "6068cc8a1d847201e0d016f9"
    TEMPCOUNT_ID = "60a990d81d84723522cb7ba4"
    HUMIDITYCOUNT_ID = "60a990de1d847235aae670aa"

    try:
        api = ApiClient(apikey=API_KEY)
        people = api.get_variable(PEOPLECOUNT_ID)
        templevel= api.get_variable(TEMPCOUNT_ID)
        humiditylevel = api.get_variable(HUMIDITYCOUNT_ID)

        peoplecounter = people.get_values()[0]['value']
    except:
        print("Couldn't connect to the API, check your Internet connection")
        print (error)
        exit()
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(ENTER_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
    GPIO.setup(EXIT_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
    tm.number(int(peoplecounter))
예제 #7
0
	def postPower(self,Power_Data):
			api = ApiClient(token='wseZ3mpbc7vPzM4tlANdLo5Tqngf48')
			Power_variable = api.get_variable('58466a2e7625420ada1399c4')
			time.sleep(1)
			Power_response = Power_variable.save_value({"value": Power_Data})
			print Power_response		
			time.sleep(3)	
예제 #8
0
	def postIrr(self,Irr_Data):
			api = ApiClient(token='wseZ3mpbc7vPzM4tlANdLo5Tqngf48')
			Irr_variable = api.get_variable('58466add7625420de33bedcd')
			time.sleep(1)
			Irr_response = Irr_variable.save_value({"value": Irr_Data})
			print Irr_response		
			time.sleep(3)
예제 #9
0
def reconnectUbidots():
    clarityAPI = ApiClient("2331f6fb5568a0de255024aa024b2ec20f2e6e1d")
    c101 = clarityAPI.get_variable("56a00b1976254252dfa19fa8")
    c102 = clarityAPI.get_variable("56a00b5776254254a47b1bbc")
    c103 = clarityAPI.get_variable("56a00b6276254253988bc701")
    c104 = clarityAPI.get_variable("56a00b6d7625425626da050e")
    c105 = clarityAPI.get_variable("56a00b7876254254a47b1c1a")
    connTimer = time.time()
예제 #10
0
파일: server.py 프로젝트: RushabShah/FINAL
def create():
		name=request.args['name']
		tag1=request.args['tag1']
		tag2=request.args['tag2']
		desc=request.args['desc']
		tags=[tag1,tag2]
		api=ApiClient(token=tok)
		new=api.create_datasource({"name":name,"tags":tags,"description":desc})
		return render_template('index.html',msg="success datasource creation")
예제 #11
0
	def postTemp(self,Temp_Data):
			api = ApiClient(token='wseZ3mpbc7vPzM4tlANdLo5Tqngf48')
			# Get a Ubidots Variable
			Temp_variable = api.get_variable('581b254f76254250326a2d51')
			time.sleep(1)
			# Here is where you usually put the code to capture the data, either through your GPIO pins or as a calculation. We'll simply put an artificial signal here:
			Temp_response = Temp_variable.save_value({"value": Temp_Data})
			print (Temp_response)		
			time.sleep(3)
def save_count_ubidots(count, startTime):
    api = ApiClient(token='A1E-CxwT7tKlYBQD5tbTOWpVAOzOxjbIha')
    ubidotsCount = api.get_variable('5d074d92c03f970688cf8483')
    while True:
        currentTime = time.time()
        if currentTime - startTime.value > 120:
            startTime.value = time.time()
            savedValue = ubidotsCount.save_value({'value': count.value})
            print("Saved count in ubidots: ", savedValue)
예제 #13
0
    def Update_Average(self):

        f = open('Ubidots_APIkey.txt', 'r')
        apikey = f.readline().strip()
        f.close()
        api = ApiClient(token=apikey)

        try:
            temp = api.get_variable("58d76383762542260cf36d8f")
            cloud_cover = api.get_variable("58d76394762542260a851a05")
            batt = api.get_variable("58d763aa762542260cf36f24")
        except ValueError:
            print('Unable to obtain variable')

        f = open('DS_APIkey.txt', 'r')
        apikey = f.read()
        f.close()

        Bangalore = [12.9716, 77.5946]

        fio = ForecastIO.ForecastIO(
            apikey,
            units=ForecastIO.ForecastIO.UNITS_SI,
            lang=ForecastIO.ForecastIO.LANG_ENGLISH,
            latitude=Bangalore[0],
            longitude=Bangalore[1],
        )
        tempc = 0
        clouds = 0
        if fio.has_hourly() is True:
            hourly = FIOHourly.FIOHourly(fio)
            for hour in range(0, 48):
                tempc = tempc + float(str(
                    hourly.get_hour(hour)['temperature']))
                clouds = clouds + float(
                    str(hourly.get_hour(hour)['cloudCover']))
        else:
            print('No Hourly data')

        self.t = round(tempc / 48, 2)
        self.c = round(clouds / 48, 2)
        self.b = 40

        try:
            temp.save_value({'value': self.t})
            cloud_cover.save_value({'value': self.c})
            batt.save_value({'value': self.b})
            time.sleep(1)
        except:
            print('Value not sent')

        self.avg_temp.setText('{:0.01f}°'.format(self.t))
        self.avg_cc.setText('{}%'.format(int(self.c * 100)))
        self.avg_batt.setText('{}%'.format(self.b))

        self.done1 = True
예제 #14
0
def ubidots_send(hum_value, temp_value):
    api = ApiClient(token=UBIDOTS_API_KEY_TOKEN)
    post_data_ubi = [{
        'variable': UBIDOTS_VARIABLE_TEMP,
        'value': temp_value
    }, {
        'variable': UBIDOTS_VARIABLE_HUM,
        'value': hum_value
    }]
    api.save_collection(post_data_ubi)
예제 #15
0
파일: server.py 프로젝트: RushabShah/FINAL
def insert():
		vname=request.args['vname']
		val1=request.args['val1']
		val2=request.args['val2']
		unit=request.args['unit']
		values=[val1,val2]
		api=ApiClient(token=tok)
		newvar=api.get_datasources()[0].create_variable({"name":vname,"unit":unit})
		newvar.save_values([{"timestamp":12345,"value":values[0]},{"timestamp":12346,"value":values[1]}])
		return render_template('index.html',msg="variable created")
예제 #16
0
def ubidots_get_value(api_key='A1E-09d8db204cf11e8edbbe3e71e0eedfd61b6f',
                      variable_key='5a46431e76254254b5ae38dd'):
    try:
        api = ApiClient(api_key)
        output2_control = api.get_variable(variable_key)
        lastValue2 = output2_control.get_values(1)
        temp = lastValue2[0]['value']
        print temp
        return temp
    except:
        print "No internet connection"
예제 #17
0
 def __init__(self, interval=2):
     self.logger = logging.getLogger(__name__)
     # Ubidots Create an "API" object and variable object
     try:
         api = ApiClient(keys.ubidots_api_key)
         self.test_variable = api.get_variable(
             keys.ubidots_bench_variable_key)
         self.logger.info('Ubidots initialised.')
     except:
         self.logger.error('Ubidots failed to initialise.')
     self.ubidots_interval = datetime.timedelta(minutes=interval)
     self.last_time = datetime.datetime.now()
예제 #18
0
	def postGPS(self,GPS_Data):
			api = ApiClient(token='wseZ3mpbc7vPzM4tlANdLo5Tqngf48')
			GPS_variable = api.get_variable('582288d27625427f1c7f729b')
			time.sleep(1)
			GPS_response = GPS_variable.save_value({"value":21,
			"context":
			{
			"lat": GPS_Data[0],
			"lng": GPS_Data[1]}
			})
			print GPS_response
			time.sleep(3)
예제 #19
0
def getvalues():
		
		api=ApiClient(token=tok)

		datasource=api.get_datasources()[0]
		variable=datasource.get_variables()[0]
		value=variable.get_values()[0]['value']
	
		#print api.get_datasources()[0].get_variables()[0].get_values()[0]['value']
		print datasource
		print variable
		print value
		return render_template('index.html',msg="got values "+str(value))
예제 #20
0
def ubi_connect():
    print('ubi_connect()')
    api = ApiClient(token="BBFF-PF7xbbrjhnRpBGjLioQXEhGPWlLtiV")
    # user values
    userHumidity = api.get_variable('5bdfc9511d8472353149343c')
    #	humidity = userHumidity.get_values(1)
    userLight = api.get_variable('5bdfc5db1d84723057db692f')
    #	light = userLight.get_values(1)
    userLightColor = api.get_variable('5bdfc98d1d847234fe29e864')
    #	lightColor = userLightColor.get_values(1)
    userTemperature = api.get_variable('5bdfc9441d84723531493427')
    #	temperature = userTemperature.get_values(1)
    userSleepTime = api.get_variable('5be171331d8472057999d414')
    #	sleepTime = userSleepTime.get_values(1)
    userId = api.get_variable('5bdfc97c1d8472353149348d')
    #	id = userId.get_values(1)
    # onOff = api.get_variable('5be2bb631d84723ffefdcb97')

    # datas dictionary
    ubi_datas = {
        'userId': userId,
        'userHumidity': userHumidity,
        'userLight': userLight,
        'userLightColor': userLightColor,
        'userTemperature': userTemperature,
        'userSleepTime': userSleepTime,
    }
    return ubi_datas
예제 #21
0
def loadApi():
    global api, tempVar, humidVar
    try:
        #Create an "API" object
        api = ApiClient("xxxxxxxxxxxxxxxxxxxxxxxxxx")

        #Create a "Variable" object
        tempVar = api.get_variable("xxxxxxxxxxxxxxxxxxxxxxx")
        humidVar = api.get_variable("xxxxxxxxxxxxxxxxxxxxxxx")
    except:
        e = sys.exc_info()[0]
        print("Loading ubidots api failed with exception", e,
              "... will retry later")
        api = 0
예제 #22
0
    def __init__(self):
        Thread.__init__(self)
        api = ApiClient(token='BBFF-YTny7Ru968fIz6EHhT3P8mRgLDiIXp')

        # Get cloud variables
        self.tempact = api.get_variable('5e8d31b51d84726d64f4a1e7')
        self.presact = api.get_variable('5e8d31cc1d84726e869ab59e')
        self.humact = api.get_variable('5e8d31c21d84726e88d71d66')
        self.getData()  # Get data from variables

        # Check the timestamp
        if self.tLast is not None: self.tstamp = self.tLast[0]['timestamp']
        if self.pLast is not None: self.pstamp = self.pLast[0]['timestamp']
        if self.hLast is not None: self.hstamp = self.hLast[0]['timestamp']
예제 #23
0
def process_data(raw):
	print 'entrou'
	# Search for start and end of frame and slice, discard incomplete
	if "\r\n" in raw:
		raw = raw.split("\r\n")
		print 'raw: '
		print raw[0]
		try:
			api = ApiClient(token='TOKEN') # Replace with your Ubidots Token here
			api.save_collection([{'variable': 'VARIABLE_ID','value':raw[0]}])
			print 'sent to ubidots'
		except:
			print 'problem in ubidots'
			return
예제 #24
0
파일: server.py 프로젝트: RushabShah/FINAL
def getvalues():
		api=ApiClient(token='3tC3qYIDnOh4eNqOoGXZMzBUsAnjfH')
		all_datasources=api.get_datasources()
		variables=all_datasources[0].get_variables()
		var=[]
		count=0
		length=[]
		for i in variables:
			val=[]
			c=i.get_values()
			for i in range(2):
				val.append(c[i]['value'])
			length.append(count)
			count+=1
			var.append(val)
		print var
		return render_template('var.html',name=all_datasources[0],variables=variables,values=var,length=length)
예제 #25
0
 def ubidotsConfig(self):
   while(True):
       try:
           self.api = ApiClient(self.api_key)
           self._ubidotsRegisterSensors()
           return True
       except requests.exceptions.ConnectionError:
           print "Failed to connect to UbiDots"
           time.sleep(5)
예제 #26
0
def create_datasource():
    name=request.form['name']
    tags=[request.form['tag1'],request.form['tag2']]
    description=request.form['description']
    print name,str(tags),description

    already_present=''
    api = ApiClient(token='4L4TakYO3sro5gmwWS5KDPztF8WTRq')
    all_datasources = api.get_datasources()
    print type(all_datasources)
    for i in all_datasources:
        if str(i) == name:
            print name+' is there'
            already_present='yes'
    if not already_present:
        new_datasource = api.create_datasource({"name": name, "tags": tags, "description": description}) 	#create new datasource
        print "datasource created\n"
    return render_template('datasource.html',name=name,tags=str(tags),description=description,already_present=already_present)
예제 #27
0
    def __init__(self):
        super(UbidotsRenderer, self).__init__()

        self.api = ApiClient(token=master_incubator_token)

        self.incubator_endpoint = self.api.get_datasource(
            '5a224554c03f9721f59934ff')
        self.variables = self.incubator_endpoint.get_variables()

        self.temperature_1 = self._get_variable('temperature-1')
        self.temperature_2 = self._get_variable('temperature-2')
        self.humidity_1 = self._get_variable('humidity-1')
        self.humidity_2 = self._get_variable('humidity-2')
        self.heater_1 = self._get_variable('heater-1')
        self.heater_2 = self._get_variable('heater-2')
        self.uptime = self._get_variable('uptime')
        self.error = self._get_variable('error')

        self.backlogged_data = []
예제 #28
0
def main(): 
  # Create an "API" object
  api = ApiClient("569f9980ce8645bad6b1074aaca5b031a26de7d6")
  # Create a "Variable" object
  temperatureVariable = api.get_variable("5689b7577625423d12706ebd")
  pressureVariable = api.get_variable("5689b79b7625423fc1724bb4")
  
  # create a socket object
  serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  # get local machine name
  host = "localhost"
  port = 9999
  # bind to the port
  serversocket.bind((host, port))
  # queue up to 5 requests
  serversocket.listen(1)

  #Creation de l'instance et connection sur le BLEShield 
  bleshield = BLEShield(ble_addr)
  
  while True:
    # establish a connection
    clientsocket,addr = serversocket.accept()
    print("Got a connection from %s" % str(addr))

    #Recuperation de la temperature infra rouge
    tmpIR = bleshield.get_Data()
    print "tmpIR: ", vars(tmpIR) 
    
    #Transmission des donnees
    data = {
      'ambT' : tmpIR.ambT,
      'pres' : tmpIR.pres,
      'time' : time.time()
    }
    json_str = json.dumps(data)
    clientsocket.send(json_str.encode('ascii'))
    clientsocket.close()

    # Write the value to your variable in Ubidots
    temperatureVariable.save_value({'value' : tmpIR.ambT})
    pressureVariable.save_value({'value' : tmpIR.pres})
예제 #29
0
def obtener_instancias():
    global api, token
    global diccionario_valores
    global instancias_ubidots, nombre_dispositivos

    if token is "":
        token = crear_token()

    if api is None:
        api = ApiClient(token=token, base_url="http://industrial.api.ubidots.com/api/v1.6/")

    try:
        nombre_dispositivos = get_nombre_dispositivos()
        if len(instancias_ubidots) > 0:
            return
        for nombre_dispositivo in nombre_dispositivos:
            instancias_ubidots.append(api.get_variable(get_ids().get(nombre_dispositivo)))

    except Exception as e:
        error = "Hubo un error obteniendo las instancias de ubidots."
        return redirect(url_for("error", error=error))
예제 #30
0
def get_value_variable():
    api = ApiClient(token='4L4TakYO3sro5gmwWS5KDPztF8WTRq')
    all_datasources = api.get_datasources()
    print all_datasources 
    name=all_datasources[0]
    variables=all_datasources[0].get_variables()	#all values
    print variables
    values_all=[]
    length=[]
    count=0
    for i in variables:
        values=[]
    	c=i.get_values()
        for k in range(3):
            values.append(c[k]['value'])
        length.append(count)
        count+=1
        values_all.append(values)
    print values_all

    return render_template('get_variables.html',name=name,variables=variables,values=values_all,length=length)    
예제 #31
0
def get_value_variable():
    api = ApiClient(token='s4d6ZNJZ7snnwpQhm4EGlscRJwtPvG')
    all_datasources = api.get_datasources()
    print all_datasources 
    name=all_datasources[0]
    variables=all_datasources[0].get_variables()	#all values
    print variables
    values_all=[]
    length=[]
    count=0
    for i in variables:
        values=[]
    	c=i.get_values()
        for k in range(3):
            values.append(c[k]['value'])
        length.append(count)
        count+=1
        values_all.append(values)
    print values_all

    return render_template('get_variables.html',name=name,variables=variables,values=values_all,length=length)    
예제 #32
0
def main():
    # Create an "API" object
    api = ApiClient("569f9980ce8645bad6b1074aaca5b031a26de7d6")
    # Create a "Variable" object
    temperatureVariable = api.get_variable("5689b7577625423d12706ebd")
    pressureVariable = api.get_variable("5689b79b7625423fc1724bb4")

    # create a socket object
    serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # get local machine name
    host = "localhost"
    port = 9999
    # bind to the port
    serversocket.bind((host, port))
    # queue up to 5 requests
    serversocket.listen(1)

    #Creation de l'instance et connection sur le BLEShield
    bleshield = BLEShield(ble_addr)

    while True:
        # establish a connection
        clientsocket, addr = serversocket.accept()
        print("Got a connection from %s" % str(addr))

        #Recuperation de la temperature infra rouge
        tmpIR = bleshield.get_Data()
        print "tmpIR: ", vars(tmpIR)

        #Transmission des donnees
        data = {'ambT': tmpIR.ambT, 'pres': tmpIR.pres, 'time': time.time()}
        json_str = json.dumps(data)
        clientsocket.send(json_str.encode('ascii'))
        clientsocket.close()

        # Write the value to your variable in Ubidots
        temperatureVariable.save_value({'value': tmpIR.ambT})
        pressureVariable.save_value({'value': tmpIR.pres})
예제 #33
0
def insert_variable():
    vname=request.form['vname']
    unit=request.form['unit']
    v1=request.form['value1']
    v2=request.form['value2']
    v3=request.form['value3']
    values=[ v1,v2,v3 ]

    api = ApiClient(token='4L4TakYO3sro5gmwWS5KDPztF8WTRq')
    all_datasources = api.get_datasources()
    print all_datasources 
    name=all_datasources[0]

    new_variable = all_datasources[0].create_variable({"name": vname, "unit": unit})					#create a new variable in the datasource
    print "variable0 created\n"

    new_variable.save_values([												#saving multiple values
    {'timestamp': 1380558972614, 'value': values[0]},
    {'timestamp': 1380558972915, 'value': values[1]},
    {'timestamp': 1380558973516, 'value': values[2]},])
    print "value saved to variable"

    return render_template('create_variable.html',name=name    ,variable=vname,unit=unit,values=values)
예제 #34
0
class CloudUpload(object):
  def __init__(self, configuration_file, database_file='jonnyboards.db'):
    self.config = {}
    self.api_key, self.sensors = util.loadConfig(configuration_file)
    self.database = database.Database(database_file)
    self.ubidotsConfig()

  def ubidotsConfig(self):
    while(True):
        try:
            self.api = ApiClient(self.api_key)
            self._ubidotsRegisterSensors()
            return True
        except requests.exceptions.ConnectionError:
            print "Failed to connect to UbiDots"
            time.sleep(5)

  def _ubidotsRegisterSensors(self):
      for sensor_name, sensor_config in self.sensors.iteritems():
          self.sensors[sensor_name]['ref'] = self.api.get_variable(sensor_config['id'])

  def RecordEvent(self, sensor_name, value, timestamp, count, duration, note):
    context = {'count': count, 'duration': duration}
    ref = self.sensors[sensor_name]['ref']
    if note:
      context['note'] = note

    ref.save_value({'value':value, 'timestamp': timestamp, 'context':context})


  def uploadLatestEvents(self):
    records = self.database.RetrieveNotUploadedRows()
    for record in records:
      print record
      record_id, timestamp, sensor, value, count, duration, note, uploaded_at = record
      self.RecordEvent(sensor, value, timestamp, count, duration, note)
      self.database.MarkRecordAsUploaded(record_id)

  def monitor(self):
    while(True):
      try:
        self.uploadLatestEvents()
        time.sleep(5)
      except requests.exceptions.ConnectionError:
        print "attempting to reconnect"
        self.ubidotsConfig()
예제 #35
0
파일: sensor_set.py 프로젝트: ysl/ubidots
from ubidots import ApiClient
import random
import time

# Create an ApiClient object
api = ApiClient(token='BQVCK7vEK1t59qPNFGVgCdyZ8HRogc')

# Get a Ubidots Variable
try:
    tempVar = api.get_variable("573fb3c576254202abeb4d89")
except ValueError:
    print "It is not possible to obtain the variable"

while(1):
    try:
        # Random generate the temperature.
        v = random.randint(10, 30)
        tempVar.save_value({'value': v})
        print "Sent value %d to server" % v

        time.sleep(5)
    except ValueError:
        print "Value not sent"
예제 #36
0
from ubidots import ApiClient

api = ApiClient(token='RBgwxE0fSTaFS7IH7EqIya2Nl6yVek')
ctrlVarFloraBox=api.create_datasource({"name":"Ctrl floraBox"})
ctrlActFloraBox=api.create_datasource({"name":"Ctrl Actuators floraBox"})
varFloraBox=api.create_datasource({"name":"Variables floraBox"})

#Ctrl Actuadores

ctrlActFloraBox.create_variable({"description":"CAACR 1","unit":"bool","name":"Ctrl Air Circulation"})
ctrlActFloraBox.create_variable({"description":"CAAHE 1","unit":"bool","name":"Ctrl Air Heater"})
ctrlActFloraBox.create_variable({"description":"CAAHU 1","unit":"bool","name":"Ctrl Air Humidifier"}) 
ctrlActFloraBox.create_variable({"description":"CAAVE 1","unit":"bool","name":"Ctrl Air Ventilation"}) 
ctrlActFloraBox.create_variable({"description":"CALMI 1","unit":"bool","name":"Ctrl Light Mother"}) 
ctrlActFloraBox.create_variable({"description":"CALPN 1","unit":"bool","name":"Ctrl Light Panel 1"})
ctrlActFloraBox.create_variable({"description":"CALPN 2","unit":"bool","name":"Ctrl Light Panel 2"})

#Ctrl Variables

ctrlVarFloraBox.create_variable({"description":"CSACO 1","unit":"ppp","name":"Ctrl CO2"})
ctrlVarFloraBox.create_variable({"description":"CSAHU 1","unit":"%","name":"Ctrl Air Humidity"})
ctrlVarFloraBox.create_variable({"description":"CSATM 1","unit":"°C","name":"Ctrl Air Temp"})
ctrlVarFloraBox.create_variable({"description":"CSWEC 1","unit":"mS/cm","name":"Ctrl Water EC"})
ctrlVarFloraBox.create_variable({"description":"CSWPH 1","unit":"PH","name":"Ctrl Water PH"})

#Variables

varFloraBox.create_variable({"description":"AACR 1","unit":"bool","name":"Air Circulation"})
varFloraBox.create_variable({"description":"AAHE 1","unit":"bool","name":"Air Heater"})
varFloraBox.create_variable({"description":"AAHU 1","unit":"bool","name":"Air Humidifier"}) 
varFloraBox.create_variable({"description":"AAVE 1","unit":"bool","name":"Air Ventilation"}) 
from ubidots import ApiClient
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.IN)
try:
    api =ApiClient("e62234c8846318b2962b69c29b62a0b7bbd5ed18")
    people = api.get_variable("578cc74b7625422c4e939b61")
except:
        print("Couldn't connect to the API, check your Internet connection")
counter = 0
peoplecount = 0
while(1):
    presence = GPIO.input(17)
    if(presence):
        peoplecount += 1
        presence = 0
        time.sleep(1.5)
        time.sleep(1)
        counter += 1
if(counter==10):
    print(peoplecount)
people.save_value({'value':peoplecount})
counter = 0
peoplecount = 0
예제 #38
0
from ubidots import ApiClient
import os
import glob
import time
import RPi.GPIO as GPIO
import time
api = ApiClient("181bfdacd408f5d2dcff6ebdb655b2a68387606e")
test_variable1 = api.get_variable("5669a22d7625422c9c7345aa")
test_variable = api.get_variable("56699131762542086a2f3480")
GPIO.setmode(GPIO.BOARD)
GPIO.setup(13,GPIO.OUT)
GPIO.setup(11,GPIO.IN)
os.system('moderate w1-therm')
base_dir='/sys/bus/w1/devices/'
device_folder=glob.glob(base_dir + '28-0314566612ff')[0]
#g from 28*
device_file = device_folder + '/w1_slave'
def read_temp_raw():
        f=open(device_file,'r')
        lines=f.readlines()
        f.close()
        return lines 
def read_temp():
        lines=read_temp_raw()
        while lines[0].strip()[-3:]!='YES':
                time.sleep(0.2)
                lines=read_temp_raw()
equals_pos=lines[1].find('t=')
        if equals_pos!=-1:
                temp_string = lines[1][equals_pos+2:]
                temp_c=float(temp_string)/1000.0
예제 #39
0
from ubidots import ApiClient
import Rpi.GPIO as GPIO
import time
import picamera
from time import sleep

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(11,GPIO.IN)

api=ApiClient("2355dc90c5e93fc697295b33f9a6ed4e5003c2e1")

#create a "Variable" object

test_variable=api.get_variable("566993407625420e4e82690a")

while True:
	i=GPIO.input(11)
	i=0
	if i==1
		test_variable.save_value({'value':1})
		camera=picamera.PiCamera()
		camera.capture('suyash.jpg')

		camera.start_preview()
		camera.vflip=True
		camera.hflip=True
		camera.brightness=60
		
		sleep(10)
예제 #40
0
from ubidots import ApiClient
import random
import time

#Create an "API" object

api = ApiClient("88a38af294d0281ee1153b650ad13ce8314833f4")

#Create a "Variable" object

test_variable = api.get_variable("56b047d67625425379ae8359")

#Here is where you usually put the code to capture the data, either through your GPIO pins or as a calculation. We'll simply put a random value here:

while True:
	test_value = random.randint(1,100)
	#Write the value to your variable in Ubidots
	test_variable.save_value({'value':test_value})
	print('Random value is %d' %test_value)
	time.sleep(1)
import RPi.GPIO as GPIO
import dht11
import time
from ubidots import ApiClient

# initialize GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.cleanup()
GPIO.setup(19,GPIO.IN)
GPIO.setup(7,GPIO.IN)
GPIO.setup(8,GPIO.IN)
#Create an "API" object

api = ApiClient("f0aee71e9c7d1ca8e792c1b39cb90448d734d76c")

#Create a "Variable" object

test_variable = api.get_variable("5669177d76254278e8150f21")
test1_variable = api.get_variable("56695d66762542112ed97c2b")
test2_variable = api.get_variable("56695d56762542128eb5dbfb")
test3_variable = api.get_variable("566973c876254243f3602899")


# read data using pin 8
instance = dht11.DHT11(pin = 8)
result = instance.read()
result1= GPIO.input(19)
time.sleep(0.1)
current_state = GPIO.input(7)
예제 #42
0
from ubidots import ApiClient
import requests,time
from math import *


#Connect to Ubidots

api = ApiClient('a21ebaf64e14d195c0044fcc3b9f6dab9d653af3')

#Instantiate local variable from Ubidots

boston_distance = api.get_variable('525c7e69f91b2858265d746a')

#Get variables

while(1):
   req_iss = requests.get('http://api.open-notify.org/iss-now.json')
   dict = req_iss.json()
   latlong = dict['iss_position'];
   lat = latlong['latitude']
   long = latlong['longitude']

   #Calculate Distance to Boston

   my_lat = 42.3581
   my_long = 71.0636
   
   a = sin((my_lat-lat)/2)**2 + cos(lat)*cos(my_lat)*sin((my_long-long)/2)**2
   c = 2*atan2(sqrt(a),sqrt(1-a))
   d = 6378.1*c
   d = round(d,1)
예제 #43
0
    config.get('ubisoftAPI', 'air_pressure_api_key')
air_humidity_ubi_api_key = \
    config.get('ubisoftAPI', 'air_humidity_api_key')
air_temperature_ubi_api_key = \
    config.get('ubisoftAPI', 'air_temperature_api_key')

print 'ubisoft_api_token:', ubisoft_api_token

# Open SPI bus
spi = spidev.SpiDev()
spi.open(spi_bus, mcp3008_spi_device)


if is_ubisoft_requested:
    # Create an ApiClient object
    ubi_api = ApiClient(ubisoft_api_token)


    # Get a Ubidots Variable
    soil_sensor_level_ubi = \
        ubi_api.get_variable(soil_level_ubi_api_key)
    soil_sensor_volt_ubi = \
        ubi_api.get_variable(soil_volt_ubi_api_key)
    light_sensor_level_ubi = \
        ubi_api.get_variable(light_level_ubi_api_key)
    light_sensor_volt_ubi = \
        ubi_api.get_variable(light_volt_ubi_api_key)
    air_pressure_sensor_ubi = \
        ubi_api.get_variable(air_pressure_ubi_api_key)
    air_humidity_sensor_ubi = \
        ubi_api.get_variable(air_humidity_ubi_api_key)
예제 #44
0
파일: led_control.py 프로젝트: ysl/ubidots
import RPi.GPIO as GPIO
from ubidots import ApiClient
import time


# Init GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(11, GPIO.OUT)

# Create an ApiClient object
api = ApiClient(token='BQVCK7vEK1t59qPNFGVgCdyZ8HRogc')

# Get a Ubidots Variable
try:
    stateVar = api.get_variable("573fbb1f7625423b1d1c0523")
except ValueError:
    print "It is not possible to obtain the variable"

while(1):
    try:
        # Get the latest value.
        state = stateVar.get_values(1)
        v = state[0]['value']
        print "Got state %d at %s" % (v, state[0]['created_at'])
        if v == 1:
            GPIO.output(11, GPIO.HIGH)
        else:
            GPIO.output(11, GPIO.LOW)

        time.sleep(5)
    except ValueError:
예제 #45
0
import RPi.GPIO as GPIO 
from ubidots import ApiClient 
import time 
GPIO.setmode(GPIO.BCM)
GPIO.setup(7, GPIO.IN)

try:
   api = ApiClient("327bca13e8edac388ea42f35275783cfb10ae56d")
   people = api.get_variable("56dcf38876254249b9922f60")
except:
   print "cant connect"
while(1):
    presence = GPIO.input(7)
    if (presence == 0):
        people.save_value({'value':presence})
        time.sleep(0.01)
        print "Sent: 0"
    if (presence):
        people.save_value({'value':presence})
        time.sleep(0.01)
        print "Sent: 1"
GPIO.cleanup()
예제 #46
0
        except (ConnectionError, SerialException):
            logging.exception('Failed to init Groduino, retrying in 3 seconds')
        time.sleep(3)

message_count = 0

# Main Code
if __name__ == "__main__":
	
	cmdargs_dict = commandLineInit()
	
	serial_params = SerialParameters()
	groduino = hwInit(port=cmdargs_dict['port'], serial_parameters=serial_params)
	# TODO just init the server inside bot. Bot should take ip of server to connect to
	
	api = ApiClient(token='RBgwxE0fSTaFS7IH7EqIya2Nl6yVek') #TODO leer desde txt
	
	#Create a "Variable" object

	datas= api.get_datasources ()      

        dic={datas[0].name:datas[0],datas[1].name:datas[1],datas[2].name:datas[2]} # learning not to use Switchs fking Py...

        ctrlActFloraBox=dic['Ctrl Actuators floraBox']
        ctrlVarFloraBox=dic['Ctrl floraBox']
        varFloraBox=dic['Variables floraBox']
        
	while 1:
		message = groduino.receive(blocking=True)
		if not message:
			print ("No message")
예제 #47
0
from ubidots import ApiClient

setup_run = False

bus = smbus.SMBus(1)
calibration_h = []
calibration_p = []
calibration_t = []

t_fine = 0.0

Data = namedtuple('Data', ['humidity', 'pressure', 'temperature'])

Address = 0x76

api = ApiClient('xxxxa418e305976dc39c9df80d000f07abc7ea72')
T_cloud = api.get_variable('xxxx815576254215ac04bece')
RH_cloud = api.get_variable('xxxx8172762542167b4f4df4')
hPA_cloud = api.get_variable('xxxx818576254216ee23103a')
Moist_cloud = api.get_variable('xxxxaae57625425f49102a8f')

def reset_calibration():
    global calibration_h, calibration_p, calibration_t, t_fine
    calibration_h = []
    calibration_p = []
    calibration_t = []
    t_fine = 0.0


def populate_calibration_data():
    raw_data = []
from ubidots import ApiClient

import RPi.GPIO as GPIO 

import time

GPIO.setmode(GPIO.BCM)

GPIO.setup(17, GPIO.IN)

try: 

    api =ApiClient("from ubidots import ApiClient")

    import RPi.GPIO as GPIO 

    import time

    GPIO.setmode(GPIO.BCM)

    GPIO.setup(7, GPIO.IN)

    try: 

        api =ApiClient("e62234c8846318b2962b69c29b62a0b7bbd5ed18")

        people = api.get_variable("wY36NjEfLRQ3Y1OlTmGLcm9zHKAVQk") 

    except: print "Couldn't connect to the API, check your Internet connection"

    counter = 0
예제 #49
0
#Trivadis (C) 2016 
#RMI 09.06.2016

from ubidots import ApiClient
import math
import time

# Create an ApiClient object

api = ApiClient(token='Bx2jZVG7VAlsoxsLjnbJewKcj8qfiZ')

# Get a Ubidots Variable

variable = api.get_variable('575958367625426ead141395')

# Place for code to capture data from the sensor

cnt = 0
while (cnt < 10):
    # value to my variable in Ubidots
    response = variable.save_value({"value": 20*math.sin(cnt)})
    print (response)
    cnt += 1
    time.sleep(10)

예제 #50
0
import RPi.GPIO as GPIO
import dht11
import time
from ubidots import ApiClient

# initialize GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.cleanup()
GPIO.setup(11,GPIO.IN)
#GPIO.setup(7,GPIO.IN)
GPIO.setup(21,GPIO.IN)

#Create an "API" object
#pin 11 for vibration ,8 for temperature,21 for  moisture
api = ApiClient("46e1a0d7f656a8cbfbbdba47f6f0362e757d4acc")

#Create a "Variable" object
#temperature
test_variable = api.get_variable("5669cafa762542094821a3da")
#humidity
test1_variable = api.get_variable("5669cae676254205debec9d4")
#vibration
test2_variable = api.get_variable("563851ed76254254e37bafb7")
#moisture
test3_variable = api.get_variable("5669cb13762542067f4dfe82")

# read data using pin 8
instance = dht11.DHT11(pin = 8)
result = instance.read()
#result1 has vibration values
from ubidots import ApiClient
import random

#Create an "API" object

api = ApiClient("YOUR API KEY")

#Create a "Variable" object

test_variable = api.get_variable("YOUR VARIABLE ID")

#Here is where you usually put the code to capture the data, either through your GPIO pins or as a calculation. We'll simply put a random value here:

for x in xrange(1,200):
	test_value = random.randint(1,100)
	#Write the value to your variable in Ubidots
	test_variable.save_value({'value':test_value})
예제 #52
0
파일: run.py 프로젝트: kachok/battle-royale
from ubidots import ApiClient
import random

from config import config

from speedtest import speedtest

#test speed
result = speedtest()

#get name of local host
import socket
hostname=socket.gethostname()

#create an "API" object
api = ApiClient(config["key"])

print(result)

#upload results
provider = api.get_variable(config["hosts"][hostname]["provider"])
provider.save_value({'value':0, 'context':{'Internet Provider':result["provider"]}})

upload = api.get_variable(config["hosts"][hostname]["upload"])
upload.save_value({'value':result["upload"][0]})

download = api.get_variable(config["hosts"][hostname]["download"])
download.save_value({'value':result["download"][0]})
# Bind socket to local host and port
try:
    s.bind((HOST, PORT))
except socket.error , msg:
    print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
    sys.exit()
print 'Socket bind complete' 
s.settimeout(0.001)
car_moving = False;
car_out_button = mraa.Gpio(4)
car_out_button.dir(mraa.DIR_IN)
data_json = {}
for i in range(0,5):
    try:
        print "Requesting Ubidots token"
        api = ApiClient('a1cc77700e5a0696bc8f9480fe78df55c73e982e')
        break
    except:
        print "No internet connection, retrying..."
        time.sleep(1)

def deleteContent(pfile):
    pfile.seek(0)
    pfile.truncate()

def write_date_in_file():
    deleteContent(data_file)
    #data_file.write("CarStatus: " + str(car_parked) + "\n")
    #data_file.write("GroceryList: " + str(grocery_list) + "\n")
    #data_file.write("Temperature: " + str(temperature) + "\n")
    #data_file.write("HomeLocked: " + str(homeLocked) + "\n")
예제 #54
0
파일: airpi.py 프로젝트: johnnieb63/AirPi
        # read in one empty bit, one null bit and 10 ADC bits
        for i in range(12):
                GPIO.output(clockpin, True)
                GPIO.output(clockpin, False)
                adcout <<= 1
                if (GPIO.input(misopin)):
                        adcout |= 0x1
        GPIO.output(cspin, True)
        
        adcout >>= 1       					# first bit is 'null' so drop it
        return adcout
 
# Code to connect a Ubidots
 
try:
   api = ApiClient("75617caf2933588b7fd0da531155d16035138535") # Connect to Ubidots. Don't forget to put your own apikey
   
   for curDs in api.get_datasources():						# Check if there's any Data Source with the name AirPi
	if curDs.name == "AirPi":
		dS = curDs
		break
   if dS is None:
   	  dS = api.create_datasource({"name":"AirPi"})			# If doesn't exist it'll create a Data Source with the name Airpi
  
   lightValue = getVarbyNames("Light_level",dS)
   if lightValue is None:
	  lightValue = dS.create_variable({"name": "Light_level","unit": "lux"}) # Create a new Variable for light
 
   nitrogen = getVarbyNames("Nitrogen_dioxide_concentration",dS)
   if nitrogen is None:
	  nitrogen = dS.create_variable({"name": "Nitrogen_dioxide_concentration", "unit": "ppm"}) # Create a new Variable for NO2 level
import tornado.web
import tornado.websocket
import tornado.httpserver
import tornado.ioloop
import tornado.options
import json
from uuid import uuid4
import time
import threading
import random
from ubidots import ApiClient

# crear api

api = ApiClient(token= 'SCJeJGv3tVyyiR9RjzBQXL9XgzCCxt')

#creamos las api y los id

humedad = api.get_variable("5763b2ab7625421ca1a7d82a")
temperatura = api.get_variable("5763ac2376254249a1fa9eba")


#libreria para usar el puerto GPIO
import RPi.GPIO as GPIO

#configurando GPIO
#pines por el numero impreso en la tarjeta,numeracion distribucion fisica 
#GPIO.setmode(GPIO.BOARD)    
#pines por el numero canal de las etiquetas.
GPIO.setmode(GPIO.BCM)    	
예제 #56
0
from ubidots import ApiClient
import random
import time

# Create an "API" object
api = ApiClient("569f9980ce8645bad6b1074aaca5b031a26de7d6")

# Create a "Variable" object
test_variable = api.get_variable("5689b21076254235161ada87")

# Here is where you usually put the code to capture the data, either through your GPIO pins or as a calculation. We'll simply put a random value here:
for index in range(10):
  test_value = random.randint(1,100)

  # Write the value to your variable in Ubidots
  test_variable.save_value({'value':test_value})
  time.sleep(1)
예제 #57
0
from time import sleep
from grove_i2c_barometric_sensor import BMP085
import grovepi

lum_pin = 0
DHT_pin = 3
pir_pin = 8
relay_pin = 2

bmp = BMP085(0x77, 1)

grovepi.pinMode(pir_pin, "INPUT")
grovepi.pinMode(relay_pin, "OUTPUT")
#Create an "API" object

api = ApiClient("Your api client")

#Create a "Variable" object

lum = api.get_variable("variable id")
temp = api.get_variable("variable id")
hum = api.get_variable("variable id")
pres = api.get_variable("variable id")

while True:
    try:
        # Retrieve data
        [T,H] = grovepi.dht(DHT_pin, 1)
        P = bmp.readPressure()
        L = grovepi.analogRead(lum_pin)
예제 #58
0
from ubidots import ApiClient
import random
import time

api = ApiClient("92c3631d495bfff93d3d3cf043772d46003d9e5b")
test_variable = api.get_variable("565c48007625425dd74d15c7")


def main():
    licznik = 0
    while True:
        test_value = random.randint(1, 100)
        try:
            test_variable.save_value({"value": test_value})
            licznik = licznik + 1
            print "success nr %s" % licznik
        except:
            print "error"
            time.sleep(40)
            print "one more time"
            test_variable.save_value({"value": test_value})

        time.sleep(5)


main()