BBQ Pi (med datavisualisering!): 4 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:21

Introduksjon

Grilling refererer vanligvis til den langsomme prosessen med å bruke indirekte varme til å lage favorittkjøttet ditt. Selv om denne metoden for matlaging er enormt populær-spesielt i USA-har den det som noen anser som en ganske alvorlig svakhet: den krever timer med halvklar oppmerksomhet for å overvåke temperaturen på gropen og maten. Skriv inn: Raspberry Pi.

Det opprinnelige prosjektet

Den opprinnelige kilden til dette prosjektet finner du her: https://old.reddit.com/r/raspberry_pi/comments/a0… Kjernen i det er at reddit -bruker Produkt var i stand til å videresende mat- og grovtemperaturdata fra relativt billige, kommersielt tilgjengelige trådløse termometre til en Raspberry Pi (som hadde festet en liten RF -modul til GPIO -pinnene). I det opprinnelige prosjektet (lenket ovenfor), hadde Produkt lagret dataene sine i en sqlite -database og vist på et lokalt hostet apache2 php -nettsted.

Denne løsningen løser allerede det opprinnelige problemet som ble berørt i introduksjonen av denne bloggen: du kan nå overvåke temperaturen på maten og gropen eksternt med en nettleser. Men hva om vi ønsket å utvide dette? Skriv inn: GridDB.

Rekvisita

Bringebær Pi4

SUNKEE 433Mhz Superheterodyne trådløs mottakermodul

Trinn 1: GridDB Web API og FluentD

Da jeg så dette prosjektet, var min første tanke - etter den første bølgen av spenning - å tenke på måter jeg kan utvide funksjonaliteten på. Ved å bruke GridDB og dets Grafana -plugin, søkte jeg å visualisere mat- og pitdataene mine. Utover det ønsket jeg å sette opp Grafana -merknader for å oppsøke uregelmessige datapunkter - kan ikke ha noe forkullet kjøtt!

For å komme i gang, måtte jeg bruke C -koden fra det opprinnelige prosjektet for å lese dataene som kom inn fra det trådløse termometeret og legge disse dataene inn på GridDB -serveren min. For å få dette i gang, spunnet jeg opp en GridDB -server på Azure ved hjelp av en virtuell CentOS -maskin. Den enkleste måten å dele data fra kantmaskinen vår (Raspberry Pi) til skyserveren vår var via GridDB Web API. Så på den vm konfigurerte jeg GridDB's WebAPI sammen med Fluentd og den medfølgende GridDB -kontakten.

Før jeg faktisk sendte data opp til skyen, trengte jeg å lage det grunnleggende skjemaet for min BBQ Pi -beholder. Datasettet som kommer inn er ekstremt enkelt: vi har to temperatursensorer, en kokk -ID og selvfølgelig tidsstempelet. Så skjemaet vårt ser slik ut:

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

For å lage denne tidsrekkebeholderen brukte jeg ganske enkelt WebAPI (port 8080):

curl -X POST --basic -u admin: admin -H "Innholdstype: applikasjon/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

Da beholderen ble opprettet, trengte jeg å bruke Fluentd (port 8888) for å legge faktiske data inn i beholderen vår. Her er en CURL -kommando som legger ut noen dummy -data:

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

Derfra trengte jeg å legge til den originale koden for å sende en HTTP POST -forespørsel når Pi -en vår leste data fra gropen vår (omtrent hver 12. sekund).

Som en sidebemerkning: å skrive denne koden lærte meg å sette pris på hvor omfattende C -språket kan være:

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

{CURL *curl; CURLcode res; / * I windows vil dette starte winsock -tingene */ curl_global_init (CURL_GLOBAL_ALL); char errbuf [CURL_ERROR_SIZE] = {0,}; røyeagent [1024] = {0,}; char json [1000]; snprintf (json, 200, "json = {" date / ": \"%s.112Z / ", \" cookid / ": \"%d / ", \" probe1 / ": \"%d / ", / "probe2 \": / "%d \"} ", tid, cookid, probe1, probe2); / * få et krøllehåndtak */ curl = curl_easy_init (); if (curl) { /* Angi først nettadressen som skal motta POST. Denne nettadressen kan like godt være en https:// URL hvis det er det som skal motta dataene. */ snprintf (agent, sizeof agent, "libcurl/%s", curl_version_info (CURLVERSION_NOW)-> versjon); agent [størrelse på agent - 1] = 0; curl_easy_setopt (curl, CURLOPT_USERAGENT, agent); 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); / * Utfør forespørselen, res vil få returkoden */ res = curl_easy_perform (curl); hvis (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)); gå til opprydding; } opprydding: curl_easy_cleanup (curl); curl_global_cleanup (); retur 0; }}

Med denne funksjonen skrevet, trengte jeg bare å kjøre den samtidig som sqlite -dataene ble lagt ut:

hvis (goodData == 1) {

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

For å sikre at dataene dine faktisk blir satt inn på serveren din, kan du kjøre følgende kommando for å spørre databasen din og se resultatene:

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

Trinn 2: Grafana

Med koden på plass, nå når vi bruker den originale webportalen til å starte en "kokk", lagrer vi samtidig temperaturdataene våre i vår GridDB -server.

Det neste trinnet vil være å visualisere dataene våre ved hjelp av Grafana. For å gjøre det fulgte vi informasjonen fra denne bloggen: her. Det fine med denne implementeringen er at det er ekstremt enkelt å se dataene våre kartlagt til en fin graf. Det legger også til merknader.

Kommentarene som diskuteres i bloggen gjør det ekstremt enkelt for oss å overvåke når noe går galt med enten maten eller selve gropen. I mitt tilfelle lagde jeg biff med korte ribber. Med dem ønsket jeg ikke at temperaturen i gropen skulle vokse utover 275 grader Fahrenheit. Hvis jeg så temperaturen gå utover det, kunne jeg slå av en brenner og la varmen synke igjen:

Jeg hadde en lignende regel for at sensoren faktisk holdt øye med selve maten: hvis maten fikk en indre temperatur på 203 grader fahrenheit, var ribbeina klare. Du kan se den eneste kommentaren på slutten av kokken her:

Alt i alt tok kokken meg bare ca 4 timer eller så, men denne typen oppsett ville virkelig utmerke seg hvis jeg lagde noe som ville ha krevd enda mer tid i grillen (tenk på en lav-sakte røyk som varer ~ 12 timer). Til tross for det, tror jeg verdien hvis dette verktøyet er lett synlig: å kunne logge resultatene til maten din og deretter sammenligne den med tidligere kokker betyr at grillingen din langsomt vil bli bedre etter hvert som du kan bruke data for å se hva som fungerer og hva som ikke fungerer 't.

Trinn 3: Maten

Dette var første gang jeg noen gang har laget biff korte ribber; Til krydder brukte jeg ganske enkelt salt, svart pepper og hvitløkspulver. Til tross for noen problemer med at brenneren ble for høy for en liten bit der i begynnelsen, kom ribbeina fantastisk ut. Vennligst ta en titt:

Trinn 4: Konklusjon

Til slutt kom maten kjempefint, sensorene, GridDB og Grafana fungerte vakkert sammen, og vi fikk noen verdifulle data om hvordan vi kan lage disse tingene igjen for neste gang vi vil imponere noen venner.