Emily Plunt: Planta Inteligente e conectada ao Twitter com Raspberry Pi

E se pudéssemos falar com nossas plantas e elas respondessem sobre como estão se sentindo, se querem alguma coisa quando voltarmos do trabalho para casa ou se simplesmente estão com saudade de ouvir aquela música preferida?

Bom, como coloquei no Manifesto  do blog, não há idéia ruim por aqui e assim iniciou-se a história de ‘Emily Plunt’ a primeira planta interativa celebridade das mídias sociais!

emilyplunt
Emily Plunt com sensores conectados e sendo monitorada 24×7

Assim que Emily nasceu para o mundo IoT (internet das coisas) começou a gritar por água… incrível como é pidona esta aí.

Signature:444b4d8866d2d398012f7c3377260df25da63882501d50038e77dc27a90f3259

Não vá confundir com sua quase xará britânica, aliás nem é uma das atrizes que ela gosta mais…kkkk!

Voltando ao nosso projeto, eu não queria apenas coletar alguns dados, queria que eles fossem a base de uma pseudo inteligência para Emily com o instinto básico de sobrevivência.

Este projeto então iria criar uma plataforma de sensoriamento e uma base de conhecimento para Emily Plunt, sendo:

  • Coletar e armazenar dados básicos do ambiente onde ela está:
    • Temperatura
    • Umidade do Ar
    • Umidade do Solo
    • Luminosidade
    • Localização Geográfica
  • Calcular alertas/avisos para situações de vida da Emily Plunt, como:
    • Solo em condições ruins
    • Calor + Umidade fora das condições adequadas
    • Luminosidade inadequada
    • Ciclo de irrigação inadequado
  • Interagir com pessoas provendo:
    • Informações sobre temperatura, humidade e luminosidade na região onde Emily está
    • Alertas sobre suas necessidades e condições para usuários específicos cadastrados (tipo assinantes de seu feed de notícias, hehe)
    • Algum tipo de interação mínima de chat para dar um toque mais humano na conversa
    • Envio de imagens ao vivo dela e de onde ela está
    • Envio de gráficos históricos e análises de suas condições passadas

Importante: Se você sabe tudo sobre plantas e quer colaborar com este projeto, entre em contato conosco pelo formulário abaixo:


Visão geral da solução

Os dados serão coletados dos sensores num intervalo de 5 em 5 minutos e armazenados num banco de dados.

solucao-iot
Principais componentes e fluxos da solução

A análise desta massa de dados para extrapolação de relacionamentos (analytics) será realizada pelo serviço chamado ‘ThingSpeak‘ da MathWorks, que provê gratuitamente um SAS (software as a service) onde podemos armazenar nossos dados e analisá-los posteriormente com a ferramenta MatLab. Tudo no próprio site e digo novamente – gratuito!

 

Portal ThingSpeak com os dados coletados da Emily Plunt:

picture1
Dashboard de Controle – Emily Plunt no ThingSpeak

Apesar de gravarmos uma base bem bacana da Emily no próprio Raspberry Pi, vamos enviar para a base do ThingSpeak de 20 em 20 minutos (devido a limitações do site ThingSpeak) ficando armazenada no site para utilização de suas ferramentas de análise.

Vamos detalhar daqui para frente cada etapa desta solução, que irá envolver os seguintes assuntos:

  • Conexão de Sensores analógicos variados
  • Uso de Banco de Dados SQLite3
  • Envio requisições HTTP (Post e Get)
  • Uso da API e do site ThingSpeak
  • Integração com Twitter
  • Uso de Análise de Dados com MatLab (via ThingSpeak)
  • Scripts Pyhton
  • Biblioteca GPIOZERO
  • Biblioteca Adafruit DHT
  • Biblioteca GPS
  • Agendamento de scripts Pyhton na CRON
  • Acesso do Raspberry Pi via SSH
  • Uso do Raspberry Pi com Raspbian

Em resumo: massa!


Coletando os Dados dos Sensores no Raspberry Pi

Todos os sensores que utilizaremos já estiveram presentes em algum momento deste blog, portanto logo abaixo do diagrama geral de conexões seguem os links para cada post se desejaram entender o motivo das conexões e como cada sensor funciona.

LEMBRE-SE: caso você utilize portas GPIO diferentes das indicadas aqui, faça os ajustes no  código.

Vamos criar um diretório para nosso projeto e o arquivo do coletor de dados dos sensores.

sudo mkdir planta-iot
cd planta-iot
sudo nano coletor_sensores.py

Digite o código abaixo para efetuarmos a leitura dos sensores e imprimir na linha de comando para verificarmos se está tudo ok até este ponto.

#!/usr/bin/python
#*-* coding:utf-8 *-*

# Importar as bibliotecas
from datetime import datetime
from gpiozero import LED                # Sinal de leitura de mediçoes
from gpiozero import MCP3008     # AD: CH=0-Higrometro e CH=1-LDR analogicos
from gps import *                               # GPS
import Adafruit_DHT as DHT          # DHT: Umidade do ar e Temperatura
import sys
from time import sleep

# Setup dos Sensores
gpsd = gps(mode=WATCH_ENABLE)
higr = MCP3008(channel=0)
ldr = MCP3008(channel=1)
led = LED(23)

while True:
        # Liga o led indicando que as medições estão sendo realizadas
        led.on()

        # -- Temperatura e Umidade --
        # Tenta ler sensor DHT e se não for possível assume zero
        try:
            umid, temp = DHT.read_retry(22,24)
        except Exception:
            umid = 0.0
            temp = 0.0
        # converte a medida em percentual de 0-100% 
        higr_perc = (1 - higr.value) * 100   
        ldr_perc = (1 - ldr.value ) * 100

        # Tenta ler GPS e se não for possível assume zero
        try:
            # ler 10x dados de GPS para um sinal firme (se houver)
            for i in range(10):
                gpsd.next()

            lat = gpsd.fix.latitude
            lon = gpsd.fix.longitude
            alt = gpsd.fix.altitude

        except Exception:
            lat = 0
            lon = 0
            alt = 0

        print("\n\n========= Leitura ============")
        print("\n------ GPS")
        print("\nLat: {0:0.1f}%".format(lat))
        print("\nLon: {0:0.1f}%".format(lon))
        print("\nAlt: {0:0.1f}%".format(alt))
        print("\n\n------DHT")
        print("\nTemp: {0:0.1f}%".format(temp))
        print("\nUmid: {0:0.1f}%".format(umid))
        print("\n\n------LDR")
        print("\nLuz: {0:0.1f}%".format(ldr_perc))
        print("\n\n------Higrometro")
        print("\nHigr: {0:0.1f}%".format(higr_perc))

        sleep(5) # nova leitura a cada 5 segundos

Salve com CTRL-X e Yes (ou Sim) e execute com o comando

sudo python coletor_sensores.py

Se tudo deu certo, você deve receber dados parecidos com estes abaixo:

============= Leitura ================
------ GPS
Lat: -23.5%
Lon: -46.7%
Alt: 807.9%
------DHT
Temp: 23.7%
Umid: 62.9%
------LDR
Luz: 84.8%
------Higrometro
Higr: 73.2%

Sugestão: varia a luminosidade, coloque água no solo da planta e ande razoavelmente com o GPS para assegurar que os sensores estão captando corretamente e os valores estão coerentes.


Registrando tudo no Banco de Dados SQLite3

Com os dados sendo coletados, devemos registrar estas dados num banco de dados para que possamos utilizar estas coletas em futuras análises e para as demais ações que pretendemos para nossa ‘Emily Plunt’.

O sistema de banco de dados que iremos utilizar é o SQLite (versão 3), simples, leve, compacto e um dos mais utilizados do mundo. Super adequado para uma aplicação embarcada como esta rodando no Raspberry Pi. Para saber mais sobre o SQLite3 consulte a documentação oficial aqui.

Para instalá-lo:

sudo apt-get install sqlite3

…e pronto. Temos um sistema de banco de dados instalado, agora precisamos criar a base de dados e tabela na qual serão gravados os dados de nossas coletas.

Na linha de comando (imaginando que você ainda esteja no diretório ~/planta-iot:

sqlite3 planta-iot.db

Este comando irá criar o banco de dados “planta-iot.db” e abrir o shell para criarmos a nossa tabela dentro do banco de dados.

sqlite> 
sqlite> BEGIN;
sqlite> CREATE TABLE emily_data(timestamp DATETIME, lat NUMERIC, lon NUMERIC, alt NUMERIC, temperatura NUMERIC, humidade_ar NUMERIC, humidade_terra NUMERIC, luminosidade NUMERIC);
sqlite> COMMIT;

E agora para fazermos uso deste banco de dados vamos criar uma nova aplicação python que executa basicamente os mesmo comandos de antes, porém registra a série de medições em nossa tabela.

sudo nano registrador_sensores.py

E digitar o código abaixo:

#!/usr/bin/python
#*-* coding:utf-8 *-*

import sqlite3
from datetime import datetime
from gpiozero import LED     # Sinal de leitura de mediçoes
from gpiozero import MCP3008 # AD: CH=0-Higrometro e CH=1-LDR analogicos
from gps import *            # GPS
import Adafruit_DHT as DHT   # DHT: Umidade do ar e Temperatura
import sys

# Setup Sensors
gpsd = gps(mode=WATCH_ENABLE)
higr = MCP3008(channel=0)
ldr = MCP3008(channel=1)
led = LED(23)

# Indica a leitura e registro no Banco de Dados
led.on()

# Conexao com Banco de Dados
conn = sqlite3.connect('/home/pi/planta-iot/planta-iot.db')
cursor = conn.cursor()

# Leitura de Sensores
try:
    umid, temp = DHT.read_retry(22,24)
except Exception:
    umid = 0.0
    temp = 0.0

higr_emily = (1 - higr.value) * 100
ldr_emily = (1 - ldr.value ) * 100

# Leitura GPS
try:
    for i in range(10): 
        gpsd.next()
    lat = gpsd.fix.latitude
    lon = gpsd.fix.longitude
    alt = gpsd.fix.altitude
except Exception:
    lat = 0
    lon = 0
    alt = 0

# Registra as leituras
cursor.execute("INSERT INTO emily_data values(datetime('now','localtime'),?,?,?,?,?,?,?)",(lat,lon,alt,temp,hum,higr_emily,ldr_emily))
conn.commit()

CTRL-X e Y(es) ou S(im) para salvar o arquivo.

Precisamos dar a permissão para o nosso usuário ‘pi’, no momento em que rodarmos a aplicação  ‘registrado_sensores.py’ para que ele possa acessar o nosso banco de dados ‘planta-iot.db’. Para isso rodamos o comando abaixo:

sudo chown pi:pi /home/pi/planta-iot/planta-iot.db

Se você alterou o nome do usuário ao qual você se loga ao Raspberry Pi, o nome do usuário deverá substituir o usuário ‘pi’ no comando acima.

Ao executar a aplicação acima, precisamos destacar 2 pontos:

  1. Ela só rodará uma vez, pois não tem nenhum tipo de laço que execute a todo o momento a leitura e registro dos sensores.
  2. Caso o Raspberry Pi seja desligado e ligado novamente será necessário que rodemos a aplicação novamente de alguma forma.

Para que a aplicação não fique em memória e seja executada de 5 em 5 minutos (conforme planejamos no início) iremos fazer uso de um recurso de agendamento do Linux denominado CRON com a finalidade de a aplicação seja executada uma vez a cada intervalo de tempo estipulado

Agendamento de Execução de Scripts:CRON

Para executarmos o agendamento da nossa aplicação na CRON, é necessário abrirmos o arquivo e adicionarmos a linha para o agendamento, conforme abaixo:

sudo crontab -e

Este comando abrirá a CRON do usuário root e portanto tem permissão para executar qualquer aplicação sem necessidade de especificar qual o usuário.

O agendamento é feito com o seguinte modelo:

qnap_how_to_modify_crontab_to_add_edit_jobs_in_cron_1

Desta forma o arquivo da CRON, após editado, deverá ter as seguintes linhas:

# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
#
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').#
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
#
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
#
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h dom mon dow command
*/5 * * * * python /home/pi/planta-iot/registrador_sensores.py

Verificando se tudo está ok

Para verificar se o arquivo está sendo registrado corretamente, devemos abrir o nosso banco de dados e verificar se os registros estão sendo realizados a cada 5 minutos, desta forma:

sqlite3 planta-iot.db

E dentro do shell execute o comando para listar todos os registros da tabela de dados:

sqlite> SELECT * FROM emily_data

Deverá haver registros a cada 5 minutos, conforme o exemplo abaixo:

2017-01-18 23:55:05|-23.519845|-46.726946333|785.9|23.6000003814697|63.4000015258789|1.46627565982405|2.54154447702835
2017-01-19 00:00:05|-23.520112833|-46.726984833|786.7|23.6000003814697|63.5|1.17302052785924|2.44379276637341
2017-01-19 00:05:05|-23.520135667|-46.727270667|805.5|23.6000003814697|63.5|1.36852394916911|2.24828934506354
2017-01-19 00:10:05|-23.5204545|-46.726625|757.8|23.6000003814697|63.4000015258789|1.46627565982405|2.24828934506354

Caso isso não esteja acontecendo, habilite o log de erros da CRON, espere alguns minutos (para que seja executada a aplicação ao menos 1 vez) e abra o log em busca do que possa estar ocorrendo de erro.

Habilitando o log da CRONTAB

Edite o arquivo rsyslog.conf:

sudo nano /etc/rsyslog.conf

Encontre no arquivo o comentário da linha que habilita o log da cron e remova o ‘#’ da frente, descomentando o comando. O trecho  do arquivo ficará desta forma abaixo (linha em destaque):

###############
#### RULES ####
###############

#
# First some standard log files. Log by facility.
#
auth,authpriv.* /var/log/auth.log
*.*;auth,authpriv.none -/var/log/syslog
cron.* /var/log/cron.log
daemon.* -/var/log/daemon.log
kern.* -/var/log/kern.log
lpr.* -/var/log/lpr.log
mail.* -/var/log/mail.log
user.* -/var/log/user.log

Após habiltar o log é necessário restartar o rsyslog:

sudo /etc/init.d/rsyslog restart

Aguarde 5 ou 10 minutos e acesse o log de erros em:

sudo nano /var/log/cron.log

Se tudo estiver OK, é hora de registrarmos os dados de nossa planta na nuvem para o mundo!


ThingSpeak: Configurando a plataforma

O ThingSpeak é uma plataforma disponibilizada gratuitamente com o intuito de ser o centro de IoT (internet das coisas) do planeta, assim como o Google agrega toda a informação disponível da humanidade o ThingSpeak quer reunir toda a informação disponível das ‘coisas’.

É oferecido um serviço via requições HTTP (post e get) de coleta, análise de dados e ação frente a situações pré-programadas. Tudo isso com base na poderosa ferramenta MatLab, que aliás pode ser utilizada através do próprio site para análise dos dados coletados e armazenados nele.

Para saber mais acesse: https://thingspeak.com/

Para utilizarmos seus serviços é necessário antes criarmos uma conta no ThingSpeak conforme abaixo:

thingspeak_signup

Ao criar esta conta será requerido que também seja criado uma conta associada da MathWorks, sem problemas, vá em frente e crie – o site irá atrelar uma a outra automaticamente.

Dentro do site iremos criar um canal e configurá-lo, seguindo os passos abaixo:

1.Criar o canal clicando no menu em ‘My Channels’ e depois em ‘Nem Channel’

thingspeak_createchannel

2. Configurar o novo canal, preenchendo na aba ‘Channel Settings’ os dados destacados abaixo de acordo com o seu projeto.

Obs: o ThingSpeak não aceitará que seu projeto tenha o mesmo nome que o meu abaixo, por exemplo.

thingspeak_filldata

 

4. Complete com os dados de localização do seu IoT (caso deseje – esta parte é opcional) e salve todas as configurações do canal.

Obs: Para que seja disponibilizado publicamente os dados de sua planta não esqueça de marcar a opação ‘Make Public’ e no passo 7 (selecionar quais visualizações estarão disponíveis).

 

thingspeak_createchannel-2

5. Vá até a aba API KEYS e copie a chave de escrita ‘Write API Key’ para utilizarmos na nossa aplicação Python que rodará no Raspberry Pi. É com esta chave que o site irá permitir que enviemos os dados para o ThingSpeak e que este dados fiquem guardados para nossas análises.

Obs: esta chave abaixo foi uma antiga chave gerado no meu projeto, você deverá copiar a sua gerada no momento da criação do seu canal e não distribuí-la. Caso precise (por qualquer motivo) você pode gerar outra chave clicano no botão amarelo logo abaixo da chave denominada ‘Generate New Write API Key’.

thingspeak_update-1

6. Apenas para sua informação é na aba ‘Data Import/Export’ que encontra-se alguns modelos de como os métodos GET e POST podem ser utilizados para atualizar os dados no ThingSpeak.

thingspeak_update-2

Iremos utilizar o método POST para aprendermos como fazer requisições HTTP mais seguras (mais seguras que GET pelo menos onde os dados são enviados abertos na própria URL). Não há nenhum motivo especial para pensar em segurança, pois pense bem quem é que vai querer roubar informações de uma planta (?!?!) 😀

7. Por último e não menos importante, iremos já deixar configurar a visualização dos gráficos para que ao serem enviados já sejam apresentados – validando todo nosso trabalho até aqui – clique na aba ‘Private View’ e adicione as visualizações ‘Add Visualizations’ de cada métrica que enviarmos (temperatura, umidade do ar, umidade do solo, luminosidade).

Obs: Na aba ‘Public View’ selecione as visualizações gráficas que você queira tornar públicas para quem visitar o canal através do ThingSpeak – lembrando que elas só estarão habilitadas se no passo 4 você habilitou o ‘Make Public’.

thingspeak_view

E este é o fim da configuração do ThingSpeak. Desculpem, mas não irei entrar em mais detalhes sobre as funcionalidades fantásticas providas pelo MatLab de analytics sobre nossos dados neste projeto, fica para uma próxima idéia.

Caso queira aprender mais sobre tudo que é possível fazer com o ThingSpeak entre em contato e vamos trocar algumas idéias ou consulte a documentação.


Enviando os dados do Raspberry Pi para ThingSpeak

Tudo configurado no ThingSpeak e com a chave de escrita (Write API Key) em mãos, vamos elaborar a aplicação no Raspberry Pi que executará a leitura dos registros do Banco de dados e enviará ao ThingSpeak via requisição HTTP Post de 20 em 20 minutos (de acordo com as regras da plataforma).

Para criar a nossa aplicação faremos (caso você não esteja no diretório ‘planta-iot’):

cd  planta-iot
sudo nano envio_http.py

Aberto o arquivo, digite o código abaixo. Lembre-se de colocar a chave de escrita (API KEY) copiada do site, entre aspas simples, no local indicado no código.

#!/usr/bin/pythonRoot
#*-* coding:utf-8 *-*

# Importa as bibliotecas necessárias
import sqlite3
import urllib
import urllib2
import sys

# Conexão com Banco de Dados
def get_data():
    conn = sqlite3.connect('/home/pi/planta-iot/planta-iot.db')
    c = conn.cursor()
    rows = None
    c.execute("SELECT * FROM emily_data ORDER BY timestamp DESC LIMIT 1")
    rows = c.fetchall()
    conn.close()
    return rows

def send_thingspeak(rows):
    readings = { 'apikey' : 'Digite sua chave API aqui',
    'field1' : str(rows[0][4]),  # Temperatura
    'field2' : str(rows[0][5]),  # Umidade Ar
    'field3' : str(rows[0][6]),  # Umidade Solo
    'field4' : str(rows[0][7]) } # Luminosidade

    url = 'https://api.thingspeak.com/update.json'
    data = urllib.urlencode(readings)
    
    request = urllib2.Request(url, data)
    response = urllib2.urlopen(request).read()
    return(response)

def main():
    rows = get_data()
    ret = send_thingspeak(rows)

if __name__ == '__main__':
    main()

Aperte CTRL-X, aceite (Yes ou Sim) e salve o arquivo.

Veja que a aplicação escrita para o envio está utilizando uma estrutura um pouco mais complexa do que havíamos tido até agora para apresentar o uso de funções.

A última parte ‘__main__’ define qual será a função principal a ser chamada quando a aplicação é executada. O restante das atividades é desempenhada  cada uma por uma função distinta:

  • main() – chama a função de captura de dados e depois outra função para envio via POST para o ThingSpeak
  • send_thingspeak() – função que recebe as colunas (valores das medições) do último registro (mais atual) existente no banco de dados e realiza a requisição HTTP POST.
  • get_data() – função que abre o bando de dados e capta o registro mais atual existente passando todas as colunas (cada valor das medições realizadas)

Testando o Envio HTTP POST

Para testar se a requisição HTTP está sendo enviada corretamente para o site, vamos rodar uma vez a aplicação com o comando abaixo:

sudo python envio_http.py

Caso não haja nenhuma mensagem de erro na linha de comando, vamos consultar no site do ThingSpeak se está tudo ok.

Acesse sua conta e seu canal criado e na aba ‘Private View’ e verifique se um ponto vermelho com o valor respectivo apareceu no gráfico com os valores de horas de acordo com o momento em que você rodou a aplicação.

Obs: no momento do meu teste já havia 3 dados enviados e recebidos pelo ThingSpeak.

teste-conexao

Caso tudo ok temos os dados da Emily Plunt disponíveis para enviarmos mensagens via Twitter – exatamente a primeira interação dela será via mídias sociais!


Integrações do ThingSpeak: Twitter

O mais bacana do ThingSpeak são as várias integrações possíveis com outros canais, outras aplicações, com o próprio Raspberry Pi e a já nativa interface com Twitter chamada de ‘ThingTweet’.

Para integrarmos, acesse a sua conta e seu canal:

  1. Clique em ‘Apps’
  2. Clique em ‘ThingTweet’

thingtweet-1

3. Clicando em ‘ThingTweet’ vamos configurar uma conta do Twitter. Para este exemplo vou utilizar a conta do Robozera (@robozera) no Twitter para integrar a nossa conta do ThingSpeak e enviarmos posts da situação da Emily Plunt.

thingtweet-2

Após estarmos com a conta integrada do Twitter. Podemos através do próprio portal criar reações da Emily para que ela responda tweets mediando determinadas situações de controle.

Este será um exemplo simples, porém navegando um pouco mais no ThingSpeak você verá que poderá efetuar análises complexas para as reações da sua própria Emily Plunt.

4. Adicionaremos as simples reações da Emily através do ‘React’, clicando neste ‘App’

thingtweet-4

Dentro do ‘React’ iremos criar as reações  da Emily, para este tutorial vamos criar 3 simples: baixa umidade do solo, alta temperatura e falta de luminosidade.

5. Criar uma nova reação:

thingtweet-3

6. Configurar as 3 reações conforme abaixo:

react-1

 

react-2

 

react-3

Completa as 3 reações é só acompanhar o Twitter as indignações da Emily Plunt!!

tweet


Como e onde está a Emily Plunt agora?

Se quiser visitar a Emily e tudo de mais novo que acontece em sua vida, siga-a no Twitter:

https://twitter.com/robozera/

Ou acesse sua página pública do Thing Speak para ver as medições realizadas:

https://thingspeak.com/channels/216536


Mais por vir…??

Acredito que este é o primeiro de muitos projetos em torno de Emily Plunt, siga nosso blog, twitter e/ou Facebook para receber as atualizações sobre o projeto ou sobre a estrela do nosso show!

Próximos itens da minha lista são:

  1. Sensor de presença para saber se tem mais alguém junto a ela
  2. Interface para expressar ‘humor’
  3. Câmera para compartilhar selfies nas redes sociais
  4. Motores para se posicionar melhor no sol ou na sombra dependendo da situação
  5. Integração e canais diretos da Emily Plunt com Facebook
  6. Adicionar Inteligência Artificial para conversão com o API.AI
  7. Criar um canal de Telegram
  8. Criar mais regras de inferências (melhorar sua inteligência)
  9. Válvula para se auto regar (esse não acha tão engraçado… vai se sentir muito independente, rsrsrs!)

 

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s