Atividade Experimental - Precisao.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Guia para a aula experimental - Precisão\n",
    "\n",
    "Nesse guia, trataremos passo-a-passo a conexão do dispositivo PK2 com a plataforma Konker, aquisição de dados de temperatura e análise da precisão da medida.\n",
    "Para seguir esse roteiro, você precisará de uma conta na Konker, que pode ser criada em https://demo.konkerlabs.net/ e, para trabalhar com o kit disponibilizado para vocês, será necessário baixar a Arduino IDE e adicionar o suporte à placa de desenvolvimento **NodeMCU**, além de instalar as bibliotecas **PubSubClient** e **ArduinoJSON**. Um guia de instalação da placa pode ser visto na referência https://www.filipeflop.com/blog/programar-nodemcu-com-ide-arduino/, enquanto a instalação das bibliotecas pode ser feita buscando pelo nome das mesmas na caixa aberta ao selecionar o menu **Sketch** -> **Incluir Biblioteca** -> **Gerenciar Bibliotecas**.\n",
    "\n",
    "**Por favor, siga o procedimento desse guia (python notebook) e lembre-se sempre de salvar suas alterações (o atalho Ctrl+s funciona). Ao termina-la, por favor publique seus resultados no Classrom, como indicado na última célula.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos iniciar nosso notebook chamando todas as bibliotecas que usaremos. Nessa etapa, basta rodar a célula abaixo com o comando **Shift + Enter**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Caso você rode o notebook no Google Colab, é necessário primeiro instalar a biblioteca arrow:\n",
    "!pip install arrow\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from oauthlib.oauth2 import BackendApplicationClient\n",
    "from requests_oauthlib import OAuth2Session\n",
    "import pprint\n",
    "import numpy as np\n",
    "import arrow\n",
    "import requests                                                                                                                                                                                 \n",
    "import json                                                                                                                                                                                     \n",
    "from threading import Timer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O próximo passo é definir os endereços que serão usados para consultar e enviar os dados. Nessa etapa, ainda não é necessário fazer modificações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Url de publicacao dos dados\n",
    "pub_url = 'https://data.demo.konkerlabs.net/pub/'\n",
    "#Url da API\n",
    "base_api = 'https://api.demo.konkerlabs.net'\n",
    "#Application padrão\n",
    "application = 'default'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos colocar o seu usuário e senha da plataforma em duas variáveis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "username = ''\n",
    "password = ''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O próximo passo é criar (caso ele ainda não exista) o dispositivo **termometro** dentro de sua conta na Konker.\n",
    "Quando você criar o dispositivo, clique em **Connect** -> **Generate Password** e coloque as credenciais do dispositivo nas variáveis abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "termometro_name = \"termometro\"\n",
    "termometro_username = \"\"\n",
    "termometro_password = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usando o Kit de Hardware PK2\n",
    "Esse é o momento de você baixar o código do dispositivo disponível em nosso GitHub: https://github.com/KonkerLabs/arduino_examples/tree/master/Placa%20PK02/Termometro. Depois de baixar o código, abra no Arduino IDE e mude os parâmetros de rede Wifi, canal de publicação (minha sugestão é usar *temperatura*) e credenciais do dispositivo. Dica: você acabou de escrever essas credenciais nas variáveis acima como \"cola\" para esse momento, pois elas não serão usadas no notebook :-).\n",
    "\n",
    "Agora é hora de configurar o seu termômetro!\n",
    "Basta seguir a ilustração abaixo, colocando o jumper na posição T:\n",
    "\n",
    "![term](https://raw.githubusercontent.com/KonkerLabs/arduino_examples/master/Placa%20PK02/Termometro/PK2-Exp2.png \"Termômetro\")\n",
    "\n",
    "Com o dispositivo configurado, o próximo passo é compilar e gravar o Firmware. Lembre-se de mudar a board na Arduino IDE para **NodeMCU v1.0**.\n",
    "\n",
    "Caso tudo tenha dado certo até o momento, você começará a observar os dados sendo enviados para a plataforma. Entre na Guia de Devices e procure **Messages** do seu dispositivo **termometro**. \n",
    "Você deve ver os dados de temperatura chegando, então não mexa mais na placa, pois vamos fazer o experimento do dia. :-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usando a API\n",
    "Para iniciar esse trabalho, vamos primeiro conectar na API da Konker. A API usa OAuth2, então, primeiro vamos obter o token de acesso. Caso você tenha inserido o seu usuário e senha da plataforma no início desse guia, essa célula deve rodar sem necessidade de modificações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client = BackendApplicationClient(client_id=username)\n",
    "oauth = OAuth2Session(client=client)\n",
    "token = oauth.fetch_token(token_url='{}/v1/oauth/token'.format(base_api),\n",
    "                                       client_id=username,\n",
    "                                       client_secret=password)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ótimo! Agora nós podemos começar a usar a API. Caso você queira mais detalhes de sua utilização, pode encontrar a documentação em: https://api.demo.konkerlabs.net.\n",
    "\n",
    "Vamos começar listando os dispositivos registrados no seu usuário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "devices = oauth.get(\"https://api.demo.konkerlabs.net/v1/{}/devices/\".format(application)).json()['result']\n",
    "for dev in devices:\n",
    "    print(dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos procurar pelo dispositivo **termometro** na sua lista de dispositivos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "guid_term=\"\"\n",
    "for dev in devices:\n",
    "    if dev['name'] == termometro_name:\n",
    "        guid_term = dev['guid']\n",
    "\n",
    "print(\"O GUID do dispositivo Termômetro é: \"+ guid_term)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso você consiga ver o GUID do dispositivo, significa que está tudo funcionando bem. Caso o GUID não apareça, revise o nome do dispositivo no notebook e o nome escolhido na plataforma para garantir que eles possuam a mesma grafia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Agora é a hora de você tomar um café :-)**\n",
    "\n",
    "Cheque primeiramente se os dados estão chegando na plataforma. Caso afirmativo, deixe o dispositivo rodando sem intervenção por uns 60 minutos. Esse tempo é necessário para estabilizar a temperatura do termistor, que, por estar na placa, vai se aquecer com o uso do microcontrolador. \n",
    "\n",
    "Após aguardar esse tempo, vamos usar a API para pegar os dados enviados pelo dispositivo **termometro** na última hora. Caso você tenha escolhido outro canal para envio dos dados, por favor, modifique a variável **canal** na próxima célula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "canal = 'temperatura'\n",
    "dt_start = arrow.utcnow().to('America/Sao_Paulo').shift(hours=-1)\n",
    "stats = oauth.get(\"https://api.demo.konkerlabs.net/v1/{}/incomingEvents?q=device:{} channel:{} timestamp:>{}&sort=oldest&limit=10000\".format(application,guid_term,canal,dt_start.isoformat())).json()['result']\n",
    "print(stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso tudo tenha funcionado como esperado, você deve estar vendo seus dados de temperatura logo acima. Para facilitar a visualização e análise dos dados, podemos transformar em um formato tabular com o Pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas.io.json import json_normalize\n",
    "stats_df = json_normalize(stats).set_index('timestamp')\n",
    "stats_df = stats_df\n",
    "stats_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ótimo! Agora os dados estão em um formato mais fácil de ler. Mas podemos também fazer um gráfico bem simples!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(15,8))\n",
    "plt.rcParams.update({'font.size': 18})\n",
    "stats_df['payload.value'].plot()\n",
    "plt.xticks(rotation=45)\n",
    "plt.title('Gráfico da temperatura obtida com o termistor da placa PK02', size=24,y=1.02)\n",
    "plt.ylabel('Temperatura [C]', size=24)\n",
    "plt.xlabel('Data', size=24)\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste momento, começa a parte final desse trabalho. Vamos gerar um histograma com os valores obtidos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "minimo = np.min(stats_df['payload.value'])\n",
    "maximo = np.max(stats_df['payload.value'])\n",
    "bins=np.arange(minimo-0.5,maximo+1,0.5)\n",
    "hist, bin_edges = np.histogram(stats_df['payload.value'],bins=bins)\n",
    "x = (bin_edges[:-1]+bin_edges[1:])/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos visualizar o histograma calculado com os dados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,8))\n",
    "plt.step(x,hist,where='mid')\n",
    "plt.title('Histograma da temperatura obtida com o termistor da placa PK02', size=24,y=1.02)\n",
    "plt.ylabel('Número de contagens', size=24)\n",
    "plt.xlabel('Temperatura [C]', size=24)\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos tentar agora fazer um ajuste gaussiano nos dados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import curve_fit\n",
    "\n",
    "#Definindo a função que usaremos para o ajuste\n",
    "def gaus(x,a,x0,sigma):\n",
    "    return a*np.exp(-(x-x0)**2/(2*sigma**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "popt,pcov = curve_fit(gaus,x,hist,p0=[1,(minimo+maximo)/2,(maximo-minimo)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,8))\n",
    "plt.step(x,hist,where='mid', label='Dados')\n",
    "plt.plot(np.arange(minimo-0.5,maximo+0.5,0.01), gaus(np.arange(minimo-0.5,maximo+0.5,0.01), *popt), 'r-', label='Ajuste')\n",
    "plt.title('Histograma da temperatura obtida com o termistor da placa PK02', size=24,y=1.02)\n",
    "plt.ylabel('Número de contagens', size=24)\n",
    "plt.xlabel('Temperatura [C]', size=24)\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir do ajuste gaussiano, podemos obter o desvio padrão dos dados. Observe que esse número é influenciado não apenas pela precisão intrínseca do sensor, mas também pela escolha do \"passo\" (**bin**) escolhido para o histograma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Valor do desvio padrão obtido via ajuste Gaussiano: ' + str((popt[2]**2)**0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando esse valor, podemos dizer que, dentro de um nível de confiança de **3 sigmas, ou seja, aproximadamente 99%**, esse sensor tem a seguinte precisão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "precision = round((3*(popt[2]**2)**0.5),1)\n",
    "print('Precisão (nível de confiança de 3 sigma): ' + str(precision) + ' C')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe também que é possível obter o desvio padrão sem o uso de um histograma, tornando o resultado independente da escolha de \"passo\". Usando o resultado direto do desvio padrão, deve-se obter uma precisão um pouco melhor (embora não muito diferente) da observada na célula acima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "precision = round(3*(np.std(stats_df['payload.value'])),1)\n",
    "print('Precisão (nível de confiança de 3 sigma): ' + str(precision) + ' C')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Assim, finalizamos essa atividade! Se você conseguiu concluí-la, coloque seus resultados na atividade do Classroom \"Atividades Experimentais\", para trocarmos informações a respeito dos nossos sensores espalhados pelo Brasil!**\n",
    "\n",
    "**Caso não tenha conseguido colcluí-la, procure ajuda de seus colegas, monitor ou professor no Classrom. :-)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}