BBQ Pi (com visualização de dados!): 4 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Introdução

O churrasco geralmente se refere ao processo lento de uso do calor indireto para cozinhar suas carnes favoritas. Embora esse método de cozinhar seja extremamente popular - especialmente nos Estados Unidos - ele tem o que alguns podem considerar uma fraqueza bastante séria: requer horas de atenção semi-lúcida para monitorar a temperatura do seu caroço e da comida. Digite: Raspberry Pi.

O Projeto Original

A fonte original para este projeto pode ser encontrada aqui: https://old.reddit.com/r/raspberry_pi/comments/a0… A essência disso é que o usuário do reddit Produkt foi capaz de retransmitir alimentos e dados de temperatura do poço relativamente baratos, termômetros sem fio disponíveis comercialmente para um Raspberry Pi (que tinha anexado a seus pinos GPIO um pequeno módulo RF). No projeto original (link acima), Produkt tinha seus dados armazenados em um banco de dados sqlite e exibidos em um site apache2 php hospedado localmente.

Esta solução já resolve o problema original abordado na introdução deste blog: agora você pode monitorar sua comida e a temperatura do poço remotamente com um navegador da web. Mas e se quiséssemos expandir isso? Digite: GridDB.

Suprimentos

Raspberry Pi4

Módulo receptor sem fio SUNKEE 433Mhz superheterodyne

Etapa 1: GridDB Web API e FluentD

Ao ver este projeto, meu primeiro pensamento - após a onda inicial de entusiasmo - foi pensar em maneiras de estender a funcionalidade. Usando o GridDB e seu plugin Grafana, procurei visualizar meus dados de comida e cova. Além disso, eu gostaria de configurar anotações Grafana para buscar quaisquer pontos de dados anômalos - não pode haver nenhuma carne carbonizada!

Para começar, precisei usar o código C do projeto original para ler os dados vindos do termômetro sem fio e postar esses dados em meu servidor GridDB. Para colocá-lo em funcionamento, criei um GridDB Server no Azure usando uma máquina virtual CentOS. A maneira mais fácil de compartilhar dados de nossa máquina de borda (Raspberry Pi) com nosso servidor em nuvem era por meio da API da Web do GridDB. Então, nessa vm, configurei o WebAPI do GridDB junto com o Fluentd e o conector GridDB que o acompanha.

Antes de realmente enviar os dados para a nuvem, precisei criar o esquema básico para meu contêiner BBQ Pi. O conjunto de dados que chega é extremamente simples: temos dois sensores de temperatura, uma identificação de cozimento e, claro, o carimbo de data / hora. Portanto, nosso esquema se parece com este:

timeseries = gridstore.put_container ("bbqpi", [("time", griddb. GS_TYPE_TIMESTAMP), ("cookid", griddb. GS_TYPE_INT), ("probe1", griddb. GS_TYPE_INT), ("probe2", griddb. GS_TYPE_INT)], griddb. GS_CONTAINER_TIME_SERIES)

Para criar este contêiner de série temporal, simplesmente usei o WebAPI (porta 8080):

curl -X POST --basic -u admin: admin -H "Content-type: application / json" -d

'{"container_name": "bbqpi", "container_type": "TIME_SERIES", / "rowkey": true, "columns": [{"name": "time", "type": "TIMESTAMP"}, {"name": "cookid", "type": "INTEGER"}, {"name": "probe1", "type": "INTEGER"}, {"name": "probe2", "type": "INTEGER"}]} '\ https:// localhost: 8080 / griddb / v2 / defaultCluster / dbs / public / containers

Com o contêiner criado, precisei utilizar o Fluentd (porta 8888) para postar dados reais em nosso contêiner. Aqui está um comando CURL postando alguns dados fictícios:

curl -X POST -d 'json = {"date": "2020-01-01T12: 08: 21.112Z", "cookid": "1", "probe1": "150", "probe2": "140" } 'https:// localhost: 8888 / griddb

A partir daí, precisei anexar o código original para enviar uma solicitação HTTP POST sempre que nosso Pi estava lendo dados de nosso poço (cerca de uma vez a cada 12 segundos).

Como observação lateral: escrever este código me ensinou a apreciar o quão prolixo a linguagem C pode ser:

int postData (char time , int cookid, int probe1, int probe2, char url )

{CURL * curl; CURLcode res; / * No Windows, isso inicializará as coisas do winsock * / curl_global_init (CURL_GLOBAL_ALL); char errbuf [CURL_ERROR_SIZE] = {0,}; agente char [1024] = {0,}; char json [1000]; snprintf (json, 200, "json = {" date / ": \"% s.112Z / ", \" cookid / ": \"% d / ", \" probe1 / ": \"% d / ", / "probe2 \": / "% d \"} ", hora, cookid, probe1, probe2); / * obter um identificador curl * / curl = curl_easy_init (); if (curl) {/ * Primeiro defina o URL que está prestes a receber nosso POST. Este URL também pode ser um URL https:// se for o que deve receber os dados. * / snprintf (agente, agente sizeof, "libcurl /% s", curl_version_info (CURLVERSION_NOW) -> versão); agente [tamanho do agente - 1] = 0; curl_easy_setopt (curl, CURLOPT_USERAGENT, agente); curl_easy_setopt (curl, CURLOPT_URL, url); curl_easy_setopt (curl, CURLOPT_USERNAME, "admin"); curl_easy_setopt (curl, CURLOPT_PASSWORD, "admin"); curl_easy_setopt (curl, CURLOPT_VERBOSE, 1L); curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, errbuf); curl_easy_setopt (curl, CURLOPT_POSTFIELDS, json); / * Execute a solicitação, res obterá o código de retorno * / res = curl_easy_perform (curl); if (res! = CURLE_OK) {size_t len = strlen (errbuf); fprintf (stderr, "\ nlibcurl: (% d)", res); if (len) fprintf (stderr, "% s% s", errbuf, ((errbuf [len - 1]! = '\ n')? "\ n": "")); fprintf (stderr, "% s / n / n", curl_easy_strerror (res)); goto cleanup; } limpeza: curl_easy_cleanup (curl); curl_global_cleanup (); return 0; }}

Com esta função escrita, eu só precisava executá-la ao mesmo tempo em que os dados sqlite estavam sendo postados:

if (goodData == 1) {

if (last_db_write == 0 || (secs-last_db_write> = 10)) {snprintf (sql, 100, "INSERT INTO leituras (cookid, time, probe1, probe2) VALORES (% d, '% s',% d, % d); ", cookID, buff, probe1, probe2); printf ("% s / n", sql); rc = sqlite3_exec (db, sql, callback, 0, & zErrMsg); if (rc! = SQLITE_OK) {printf ("erro SQL:% s / n", zErrMsg); } else {last_db_write = secs; } char url = "https://xx.xx.xx.xx: 8888 / griddb"; postData (buff, cookID, probe1, probe2, url); }}

Para certificar-se de que seus dados estão realmente sendo inseridos em seu servidor, você pode executar o seguinte comando para consultar seu banco de dados e visualizar os resultados:

curl -X POST --basic -u admin: admin -H "Content-type: application / json" -d '{"limit": 1000}' https:// localhost: 8080 / griddb / v2 / defaultCluster / dbs / public / containers / bbqpi / rows

Etapa 2: Grafana

Com o código em vigor, agora que usamos o portal da web original para iniciar um “cozimento”, estaremos simultaneamente armazenando nossos dados de temperatura em nosso servidor GridDB.

O próximo passo será visualizar nossos dados usando o Grafana. Para isso, seguimos as informações deste blog: aqui. O bom dessa implementação é que é extremamente fácil ver nossos dados em um gráfico bonito. Ele também adiciona anotações.

As anotações discutidas no blog tornam extremamente fácil monitorarmos quando algo dá errado com nossa comida ou com a própria cova. No meu caso, eu cozinhava costeletas de boi. Com eles, eu não queria que a temperatura no poço crescesse além de 275 graus Fahrenheit. Se eu visse a temperatura ultrapassar isso, poderia desligar um queimador e permitir que o calor diminuísse novamente:

Eu tinha uma regra semelhante para o sensor realmente manter o controle sobre a comida em si: se a comida chegasse a uma temperatura interna de 203 graus Fahrenheit, as costelas estavam prontas. Você pode ver a única anotação no final do cozinheiro aqui:

Ao todo, o cozinheiro só me levou cerca de 4 horas ou mais, mas este tipo de configuração seria realmente excelente se eu estivesse cozinhando algo que exigiria ainda mais tempo na grelha (pense em uma fumaça lenta e lenta que dure ~ 12 horas). Apesar disso, acredito que o valor se esta ferramenta for facilmente aparente: ser capaz de registrar os resultados de seus alimentos e, em seguida, compará-los com os cozinheiros anteriores significa que seu churrasco ficará melhor lentamente com o tempo, pois você pode usar dados para ver o que funciona e o que não 't.

Etapa 3: a comida

Esta foi a primeira vez que fiz costeletas de boi; para temperar, usei apenas sal, pimenta-do-reino e alho em pó. Apesar de alguns problemas com o queimador ficar muito alto no começo, as costelas ficaram fantásticas. Por favor dê uma olhada:

Etapa 4: Conclusão

No final, a comida ficou ótima, os sensores, GridDB e Grafana funcionaram perfeitamente em conjunto e obtivemos alguns dados valiosos sobre como cozinhar essas coisas novamente para a próxima vez que quisermos impressionar alguns amigos.