A estas alturas ya se debería tener la Raspberry completamente configurada, el circuito montado, las librerías necesarias descargadas y la conexión a Internet realizada. Si ves que te falta algún paso, puedes volver a visitar las respectivas entradas, aunque si lo que te falta es la librería se recuerda a continuación:
En este proyecto se va a trabajar con Python 2.7, por lo que habrá que descargar la librería correspondiente que permite trabajar con estos sensores. Se trata de Adafruit_Python_DHT. La forma más fácil de instalar esta librería es mediante el comando sudo pip install Adafruit_DHT. En caso de no reconocerse el comando pip, habrá que instalar pip mediante sudo apt-get install pip y volver a intentarlo.
Recordamos también cuáles eran los requerimientos que debía cumplir el proyecto:
- Creación automática del canal sin intervención del usuario.
- Muestreo cada 10 segundos.
Ya se vio en la entrada de la Sesión 03 y 04 cómo subir datos ThingSpeak mediante un programa escrito en Python. Puede ser conveniente repasar esa entrada, más simple, antes de meterse de lleno en esta.
A continuación, se va a ir explicando paso a paso cómo se ha montado el código. Si quieres saltarte toda la explicación y solo te interesa el código, puedes ir directamente al final de la entrada o incluso al repositorio de GitHub.
Lectura del sensor
Primero hay que preparar las variables y librerías necesarias para trabajar con el sensor.
import Adafruit_DHT
sensor = Adafruit_DHT.DHT11
pin= 23 #conectado al PIN GPIO23
Con esto se tiene importada la librería, definido el Pin por el cual va a entrar los datos y definido el tipo de sensor que se va a usar. El siguiente paso es la lectura del sensor. Para ello se cuenta con dos funciones: Adafruit_DHT.read_retry(sensor, pin) y Adafruit_DHT.read(sensor, pin). La diferencia entre ambas en que retry se ejecuta cada 2 segundos hasta que haya dato, o bien hasta que haya habido 15 intentos. Read lee el dato, pero no asegura que vaya a devolver algo porque no reintenta la lectura.
Como se quieren datos cada 10 segundos y retry no podría asegurarlo, solo se va a usar retry en la primera medida y a partir de ahí read. En caso de que read no encontrara dato, se copiaría el dato anterior.
Como la humedad y la temperatura de una estación meteorológica no son datos que vayan a sufrir variaciones muy rápidas, se considera que es una buena aproximación, aunque exista riesgo de que una variación se detecte diez segundos más tarde. Así, esa parte del código será algo parecido a lo siguiente (recuerda que al final de la entrada tendrás el código completo y preparado para copiar):
#LECTURA DEL SENSOR
if primerflag == 0:
hum, temp = Adafruit_DHT.read_retry(sensor, pin
if hum is not None and temp is not None:
print('Temperatura={0:0.1f}*C Humedad={1:0.1f}%'.format(temp, hum))
hum01 = hum
temp01 = temp
primerflag = 1 #ya se ha obtenido el primer dato
else:
# No se quiere perder el tiempo con reintento
# Temp y Hum varían lento, se acepta el margen de error
# La máxima diferencia con una medida real y una repetida serían 10 segundos
hum, temp = Adafruit_DHT.read(sensor, pin)
if hum is not None and temp is not None:
print('Temperatura={0:0.1f}*C Humedad={1:0.1f}%'.format(temp, hum))
hum01 = hum
temp01 = temp
else:
hum01 = hum02
temp01 = temp02
# FIN LECTURA DEL SENSOR
Creación de los canales
La plataforma de ThingSpeak solo permite la subida de datos cada 15 segundos. Por tanto, para “saltar” esa barrera y tener datos cada 10 segundos, se va a trabajar con dos canales. Los datos recogidos del sensor se irán subiendo de forma alterna a un canal y a otro. Por ello, cuando se quieran usar, habrá que montar toda la ristra de datos alternando entre un canal y otro.
La creación de los canales se hace de forma análoga a la entrada de la sesión 03 y 04: primero se crea la conexión TCP. Una vez se confirma se pasa a la creación del canal. La forma de crear los canales es idéntica.
#CREACIÓN DE CANAL 01
#petición HTTP y obtención de respuesta
print("Creando canal 01..."),
method = "POST"
uri = "/channels.json"
headers_01= {'Host': server,
'Content-Type': 'application/x-www-form-urlencoded'}
payload_01= {'api_key': USER_API_KEY,
'public_flag':'true',
'name' : 'Canal 01 automático.',
'field1' : 'Humedad [%RH]',
'field2' : 'Temperatura [ºC]'}
payload_01_encoded = urllib.urlencode(payload_01)
headers_01['Content-Length'] = len(payload_01_encoded)
print("\t Enviando petición para crear canal 01...")
connTCP.request(method, uri, body=payload_01_encoded, headers=headers_01)
respuesta_01= connTCP.getresponse()
status_01 = respuesta_01.status
print ("\t Petición de creación canal 01: " + str(status_01))
#Hay que coger los datos del canal para usar más adelante
contenido_01= respuesta_01.read()
# copiamos contenido en formato json a un dict
contenido_01_json = json.loads(contenido_01)
CHANNEL_ID_01 = contenido_01_json['id'
WRITE_API_KEY_01 = contenido_01_json['api_keys'][0]['api_key']
# FIN CREACIÓN DE CANAL 01
ACTUALIZACIÓN (14/02/19): ¡Muy importante! Desde esta misma semana ThingSpeak ha limitado el número de canales en las cuentas gratuitas a cuatro. Si intentas crear un canal teniendo ya los cuatro, recibirás un código 402.
En teoría ThingSpeak ha avisado a todos los usuarios, pero es posible que el email haya acabado en la bandeja de Spam.
Subida a los canales
De nuevo, este proceso es idéntico al explicado en entradas anteriores. La única diferencia radicará en que ahora, tras recibir la respuesta HTTP se usará el comando Respuesta.read() para asegurarnos de leer correctamente el contenido de la misma. Esto significa que el código será algo parecido a lo siguiente:
# SUBIR DATO AL CANAL 01
# se crea una petición HTTP que sube datos
method = "POST"
relativ_uri = "/update.json"
headers = {'Host' : server,
'Content-Type' : 'application/x-www-form-urlencoded'}
payload = {'api_key' : WRITE_API_KEY_01,
'field1' : hum01,
'field2' : temp01}
payload_encoded = urllib.urlencode(payload)
headers['Content-Length'] = len(payload_encoded)
# se envía la petición
print("Enviando petición HTTP para subir al canal 01...")
connTCP.request(method, relativ_uri, body=payload_encoded, headers=headers)
#print("Petición enviada!")
# se recibe la respuesta
print("Esperando respuesta HTTP...")
respuesta = connTCP.getresponse()
respuesta.read()
status = respuesta.status
print (str(status))
SubidaCanal01=time.time() #cuando se recibe el 200 se acaba de subir el dato
# FIN SUBIR DATO CANAL 01
Subida cada 10 segundos
Para realizar correctamente dicha subida deberá ocurrir en canales alternativos, y habrá que realizar un control del tiempo. Para ello se importará la librería time mediante el comando import time. Y se establece un timeout = 9.
Lo ideal para conseguir subir cada 10 segundos sería trabajar o bien con MQTT (ya que no se requiere de respuesta al trabajar en modo publisher/subscriber) o bien con real time. Debido a las limitaciones propias de ser novatos en esto, se va a usar TCP y se un valor de timeout menor para compensar el tiempo de ejecución el código.
Además de ello, en cuanto se reciba una respuesta 200 que indique que los datos se han subido correctamente, se usará el comando: SubidaCanal01=time.time(). De esta forma en la variable SubidaCanal01 se tendrá el momento en el que ha terminado la subida. A continuación, se iniciará un bucle que medirá el tiempo y permitirá avanzar al código cuando se lleguen a esos 10 segundos de espera. Se hará de forma análoga con el canal 02.
# ESPERAR PARA SUBIR
Medida01 = time.time()
DeltaTiempo2 = Medida01 - SubidaCanal02
while (DeltaTiempo2
DeltaTiempo2 = Medida01 - SubidaCanal02
# FIN ESPERAR PARA SUBIR
El resultado de la subida se puede visualizar como gráfica en la página de ThingSpeak. A continuación se muestra el del canal 01, pero el del canal 02 es similar:
