DuvelBot - Robot do serwowania piwa ESP32-CAM: 4 kroki (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:28

Po ciężkim dniu pracy nic nie zbliża się do popijania ulubionego piwa na kanapie. W moim przypadku jest to belgijski blond ale „Duvel”. Jednak po tym wszystkim, poza upadkiem, stajemy przed najpoważniejszym problemem: lodówka, w której znajduje się mój Duvel, jest nie do pokonania 20 stóp od wspomnianej kanapy.

Podczas gdy trochę lekkiego przymusu z mojej strony może od czasu do czasu poruszyć nastoletniego wymiatacza lodówek, aby wylał mi tygodniową dietę Duvela, zadanie faktycznego dostarczenia go jego prawie wyczerpanemu protoplastowi jest oczywiście o krok za daleko.

Czas wydobyć lutownicę i klawiaturę…

DuvelBot to prosta kamera do jazdy oparta na AI-Thinker ESP32-CAM, którą możesz kontrolować za pomocą smartfona, przeglądarki lub tabletu.

Łatwo jest dostosować lub rozszerzyć tę platformę do zastosowań mniej alkoholowych (pomyśl o SpouseSpy, NeighbourWatch, KittyCam…).

Zbudowałem tego robota głównie po to, aby dowiedzieć się trochę o całym programowaniu internetowym i rzeczach IoT, o których nic nie wiedziałem. Tak więc na końcu tego Instructable znajduje się szczegółowe wyjaśnienie, jak to działa.

Wiele części tego Instructable opiera się na doskonałych wyjaśnieniach znalezionych w samouczkach Random Nerd, więc proszę, odwiedź ich!

Kieszonkowe dzieci

Czego potrzebujesz:

Lista części nie jest wyrzeźbiona w kamieniu, a wiele części można uzyskać w tonie różnych wersji i z wielu różnych miejsc. Kupiłem większość z Ali-Express. Jak powiedziała Machete: improwizuj.

Sprzęt komputerowy:

• Moduł AI Thinker ESP32-CAM. Prawdopodobnie mógłby współpracować z innymi modułami ESP32-CAM, ale tego właśnie użyłem
• Płytka sterownika silnika L298N,
• Tania 4-kołowa platforma robotyki,
• Obudowa o dużej płaskiej powierzchni np. Hammond Electronics 1599KGY,
• Konwerter USB-3.3V-TTL do programowania.
• Do oświetlenia: 3 białe diody LED, BC327 lub inny tranzystor ogólnego przeznaczenia NPN (Ic=500mA), rezystor 4k7k, 3 rezystory 82Ohm, płyta perforowana, kable (patrz schemat i zdjęcia).
• Przełącznik włącz/wyłącz i normalnie otwarty przycisk do programowania.

Opcjonalny:

• Kamera typu rybie oko o dłuższym flexie niż standardowa kamera OV2460 dostarczana z modułem ESP32-CAM,
• Antena WiFi z odpowiednio długim kablem i złączem Ultra Miniature Coax, taka jak ta. ESP32-CAM ma antenę na pokładzie, a obudowa jest plastikowa, więc antena nie jest potrzebna, ale pomyślałem, że wygląda fajnie, więc…
• Papier do naklejek do druku atramentowego na projekt górnej okładki.

Zwykłe narzędzia metalowe: lutownica, wiertarki, śrubokręty, szczypce…

Krok 1: Budowanie platformy robota

Schemat:

Schemat nie jest niczym specjalnym. Kamera ESP32 steruje silnikami za pośrednictwem płyty sterownika silnika L298N, która ma dwa kanały. Silniki lewej i prawej strony są umieszczone równolegle, a każda strona zajmuje jeden kanał. Cztery małe kondensatory ceramiczne 10..100nF w pobliżu styków silnika są jak zawsze wskazane, aby przeciwdziałać zakłóceniom RF. Również duża nasadka elektrolityczna (2200…4700uF) na zasilaniu płytki silnika, jak pokazano na schemacie, choć nie jest bezwzględnie potrzebna, może nieco ograniczyć tętnienie napięcia zasilania (jeśli chcesz zobaczyć horror, to sonda Vbat oscyloskopem, gdy silniki są aktywne).

Zauważ, że oba kanały silnika ENABLE są sterowane przez ten sam pin z modulacją szerokości impulsu (PWM) ESP32 (IO12). Dzieje się tak, ponieważ moduł ESP32-CAM nie ma tony GPIO (schemat modułu dołączony w celach informacyjnych). Diody LED robota są napędzane przez IO4, który steruje również diodą LED na płycie, więc usuń Q1, aby zapobiec zapaleniu się diody LED w zamkniętej obudowie.

Przycisk programowania, włącznik/wyłącznik, złącze ładowania i złącze programowania są dostępne pod robotem. Mógłbym zrobić znacznie lepszą robotę dla złącza do programowania (jack 3,5 mm?), ale piwo nie mogło dłużej czekać. Przydałyby się również aktualizacje OTA (over-the-air-updates).

Aby wprowadzić robota w tryb programowania, naciśnij przycisk programowania (to obniża IO0), a następnie włącz go.

Ważne: aby naładować akumulatory NiMH robota, użyj zestawu laboratoryjnego (nieobciążonego) do około 14V i prądu ograniczonego do 250mA. Napięcie dostosuje się do napięcia akumulatorów. Odłącz, jeśli robot jest gorący lub napięcie akumulatora osiągnie około 12,5 V. Oczywistym ulepszeniem byłoby zintegrowanie odpowiedniej ładowarki, ale to wykracza poza zakres tego Instruktażu.

Sprzęt:

Proszę również zapoznać się z uwagami na zdjęciach. Obudowa montowana jest na podstawie robota za pomocą 4 śrub M4 i nakrętek samozabezpieczających. Zwróć uwagę na gumowe rurki używane jako elementy dystansowe. Miejmy nadzieję, że to również da Duvelowi pewne zawieszenie, jeśli jazda okaże się wyboista. Moduł ESP32-CAM i płyta silnika L298N są montowane w obudowie za pomocą plastikowych nóżek samoprzylepnych (nie wiem, jaka jest prawidłowa nazwa w języku angielskim), aby zapobiec konieczności wiercenia dodatkowych otworów. Również ESP32 jest montowany na własnej płycie perfboard i wtykanych pinheaderach. Ułatwia to wymianę ESP32.

Nie zapomnij: jeśli zamierzasz używać zewnętrznej anteny WiFi zamiast wbudowanej, przylutuj również zworkę wyboru anteny na spodzie płyty ESP32-CAM.

Wydrukuj górne logo w pliku DuvelBot.svg na papierze do naklejek do drukarek atramentowych (lub zaprojektuj własne) i gotowe!

Krok 2: Zaprogramuj robota

Zaleca się zaprogramowanie robota przed jego zamknięciem, aby upewnić się, że wszystko działa i nie pojawia się magiczny dym.

Potrzebujesz następujących narzędzi programowych:

• IDE Arduino,
• Biblioteki ESP32, SPIFFS (serial peryferyjny system plików flash), biblioteka ESPAsync Webserver.

Ten ostatni można zainstalować, postępując zgodnie z tym samouczkiem randomnerd, aż do sekcji „Organizowanie plików”. Naprawdę nie potrafiłem tego lepiej wyjaśnić.

Kod:

Mój kod można znaleźć pod adresem:

• Szkic Arduino DuvelBot.ino,
• Podfolder danych, w którym znajdują się pliki, które mają zostać przesłane do pamięci flash ESP za pomocą SPIFFS. Ten folder zawiera stronę internetową, którą będzie obsługiwał ESP (index.html), obraz logo będący częścią strony internetowej (duvel.png) oraz kaskadowy arkusz stylów lub plik CSS (style.css).

Aby zaprogramować robota:

• Podłącz konwerter USB-TTL jak pokazano na schemacie,
• Plik -> Otwórz -> przejdź do folderu, w którym znajduje się DuvelBot.ino.
• Zmień poświadczenia sieciowe w szkicu:

const char* ssid = "TwojaSiećSSIDTutaj";const char* hasło = "TwojeHasłoTutaj";

• Narzędzia -> Płytka -> "AI-Thinker ESP-32 CAM" i wybierz odpowiedni port szeregowy dla swojego komputera (Narzędzia -> Port -> coś w stylu /dev/ttyUSB0 lub COM4),
• Otwórz monitor szeregowy w Arduino IDE, wciskając przycisk PROG (który obniża IO0) włącz robota,
• Sprawdź na monitorze szeregowym, czy ESP32 jest gotowy do pobrania,
• Zamknij monitor szeregowy (w przeciwnym razie przesyłanie SPIFFS nie powiedzie się),
• Narzędzia -> „Przesyłanie danych szkicu ESP32” i poczekaj na zakończenie,
• Wyłączyć i ponownie włączyć przytrzymując przycisk PROG, aby powrócić do trybu programowania,
• Naciśnij strzałkę „Prześlij”, aby zaprogramować szkic i poczekaj, aż się zakończy,
• Otwórz monitor szeregowy i zresetuj ESP32 poprzez wyłączenie/włączenie,
• Po uruchomieniu zanotuj adres IP (coś jak 192.168.0.121) i odłącz robota od konwertera USB-TTL,
• Otwórz przeglądarkę pod tym adresem IP. Powinieneś zobaczyć interfejs jak na zdjęciu.
• Opcjonalnie: ustaw adres mac ESP32 na stały adres IP w routerze (zależy od routera, jak to zrobić).

Otóż to! Czytaj dalej, jeśli chcesz wiedzieć, jak to działa…

Krok 3: Jak to działa

Teraz dochodzimy do interesującej części: jak to wszystko działa razem?

Postaram się wyjaśnić krok…po…kroku, ale pamiętaj, że Kajnjaps nie jest specjalistą od programowania stron internetowych. W rzeczywistości nauka programowania internetowego była całym założeniem budowania DuvelBota. Jeśli popełnię oczywiste błędy, zostaw komentarz!

Ok, po włączeniu ESP32, jak zwykle w konfiguracji, inicjuje GPIO, kojarzy je z zegarami PWM do sterowania silnikiem i diodami LED. Zobacz tutaj, aby uzyskać więcej informacji na temat sterowania silnikiem, jest to dość standardowe.

Następnie kamera jest konfigurowana. Celowo utrzymywałem dość niską rozdzielczość (VGA lub 640x480), aby uniknąć powolnej reakcji. Zwróć uwagę, że płyta AI-Thinker ESP32-CAM ma układ scalony pamięci RAM (PSRAM), którego używa do przechowywania ramek kamer o większej rozdzielczości:

if(psramFound()) { Serial.println("Znaleziono PSRAM."); config.frame_size = ROZMIAR RAMKI_VGA; config.jpg_quality = 12; config.fb_count = 2; //liczba buforów ramki zobacz: https://github.com/espressif/esp32-camera } else { Serial.println("nie znaleziono PSRAM."); config.frame_size = ROZMIAR RAMKI_QVGA; config.jpg_quality = 12; config.fb_count = 1; }

Następnie inicjowany jest system plików szeregowych urządzeń peryferyjnych (SPIFFS):

//inicjuj SPIFFS if(!SPIFFS.begin(true)) { Serial.println("Wystąpił błąd podczas montowania SPIFFS!"); powrót; }

SPIFFS działa na ESP32 jak mały system plików. Tutaj służy do przechowywania trzech plików: samej strony internetowej index.html, kaskadowego arkusza stylów style.css i logo obrazu-p.webp

Następnie ESP32 łączy się z routerem (nie zapomnij ustawić swoich danych uwierzytelniających przed przesłaniem):

//zmień dane uwierzytelniające routera hereconst char* ssid = "yourNetworkSSIDHere";const char* password = "yourPasswordHere"; … //połącz się z Wi-Fi Serial.print("Łączenie z Wi-Fi"); WiFi.begin(SSid, hasło); while (WiFi.status() != WL_CONNECTED) { Serial.print('.'); opóźnienie (500); } //teraz podłączony do routera: ESP32 ma teraz adres ip

Aby rzeczywiście zrobić coś pożytecznego, uruchamiamy asynchroniczny serwer WWW:

//utwórz obiekt AsyncWebServer na porcie 80AsyncWebServer server(80); … serwer.początek(); //zacznij nasłuchiwać połączeń

Teraz, jeśli wpiszesz adres IP, który został przypisany do ESP32 przez router w pasku adresu przeglądarki, ESP32 otrzyma żądanie. Oznacza to, że powinien odpowiedzieć klientowi (Tobie lub Twojej przeglądarce), udostępniając mu coś, na przykład stronę internetową.

ESP32 wie, jak odpowiedzieć, ponieważ w konfiguracji odpowiedzi na wszystkie możliwe dozwolone żądania zostały zarejestrowane za pomocą server.on(). Na przykład główna strona internetowa lub indeks (/) jest obsługiwany w następujący sposób:

server.on("/", HTTP_GET, (AsyncWebServerRequest *request){ Serial.println("/ żądanie odebrane!"); request->send(SPIFFS, "/index.html", String(), false, podmiot przetwarzający); });

Jeśli więc klient się łączy, ESP32 odpowiada, wysyłając plik index.html z systemu plików SPIFFS. Procesor parametrów to nazwa funkcji, która wstępnie przetwarza html i zastępuje wszelkie specjalne znaczniki:

// Zastępuje symbole zastępcze w html, takie jak %DATA%// zmiennymi, które chcesz pokazać//

Dane: %DANE%

Procesor ciągów(const String& var){ if(var == "DANE"){ //Serial.println("w procesorze!"); return String(dutyCycleNow); } return String();}

Teraz przeanalizujmy samą stronę index.html. Ogólnie zawsze są trzy części:

1. kod html: jakie elementy mają być pokazane (przyciski/tekst/suwaki/obrazki itp.),
2. kod stylu, albo w osobnym pliku.css, albo w sekcji …: jak powinny wyglądać elementy,
3. javascript a … sekcja: jak strona powinna działać.

Gdy index.html zostanie załadowany do przeglądarki (która wie, że jest to html z powodu wiersza DOCTYPE), wpada na ten wiersz:

To jest prośba o arkusz stylów css. Lokalizacja tego arkusza jest podana w href="…". Co więc robi Twoja przeglądarka? Tak, uruchamia kolejne żądanie do serwera, tym razem dla style.css. Serwer przechwytuje to żądanie, ponieważ zostało zarejestrowane:

server.on("/style.css", HTTP_GET, (AsyncWebServerRequest *request){ Serial.println("odebrano żądanie css"); request->send(SPIFFS, "/style.css", "text/css "); });

Schludny, co? Nawiasem mówiąc, mógł to być href="/some/file/on/the/other/side/of/the/moon", dla wszystkich Twoich przeglądarek. Poszedłby pobrać ten plik równie szczęśliwie. Nie będę wyjaśniał o arkuszu stylów, ponieważ kontroluje on tylko wygląd, więc nie jest tutaj zbyt interesujący, ale jeśli chcesz dowiedzieć się więcej, sprawdź ten samouczek.

Jak wygląda logo DuvelBot? W index.html mamy:

na które ESP32 odpowiada:

server.on("/duvel", HTTP_GET, (AsyncWebServerRequest *request){ Serial.println("Otrzymano żądanie logo duvel!"); request->send(SPIFFS, "/duvel.png", "image-p.webp

..inny plik SPIFFS, tym razem pełny obraz, zgodnie z oznaczeniem „image/png” w odpowiedzi.

Teraz dochodzimy do naprawdę interesującej części: kodu przycisków. Skupmy się na przycisku DO PRZODU:

NAPRZÓD

Nazwa klasy = „…” to tylko nazwa, która łączy ją z arkuszem stylów w celu dostosowania rozmiaru, koloru itp. Ważnymi elementami są onmousedown="toggleCheckbox('forward')" i onmouseup="toggleCheckbox('stop')”. Stanowią one akcje przycisku (tak samo dla ontouchstart/ontouchend, ale dla ekranów dotykowych/telefonów). Tutaj akcja przycisku wywołuje funkcję toggleCheckbox(x) w sekcji javascript:

function toggleCheckbox(x){ var xhr = new XMLHttpRequest(); xhr.open("GET", "/" + x, prawda); xhr.send(); //może coś zrobić z odpowiedzią, gdy będzie gotowy, ale nie }

Tak więc naciśnięcie przycisku do przodu powoduje natychmiastowe wywołanie toggleCheckbox('forward'). Ta funkcja następnie uruchamia XMLHttpRequest "GET" w lokalizacji "/forward", która działa tak, jakbyś wpisał 192.168.0.121/forward w pasku adresu przeglądarki. Gdy to żądanie dotrze do ESP32, jest obsługiwane przez:

server.on("/forward", HTTP_GET, (AsyncWebServerRequest *request){ Serial.println("otrzymano/przekaż"); actionNow = FORWARD; request->send(200, "text/plain", "OK forward"."); });

Teraz ESP32 po prostu odpowiada tekstem „OK dalej”. Zauważ, że toggleCheckBox() nie robi nic z tą odpowiedzią (ani czeka na nią), jednak może, jak pokazano w dalszej części kodu aparatu.

Sam podczas tej odpowiedzi program ustawia tylko zmienną actionNow = FORWARD, jako odpowiedź na naciśnięcie przycisku. Teraz w pętli głównej programu ta zmienna jest monitorowana w celu zwiększania/zmniejszania PWM silników. Logika jest następująca: tak długo, jak mamy akcję, która nie jest STOP, przyspieszaj silniki w tym kierunku, aż zostanie osiągnięta określona liczba (dutyCycleMax). Następnie utrzymuj tę prędkość, o ile akcja Teraz się nie zmieniła:

void loop(){ obecnyMillis = millis(); if (currentMillis - previousMillis >= dutyCycleStepDelay) { // zapisz czas ostatniego wykonania pętli previousMillis = currentMillis; //mainloop jest odpowiedzialny za przyspieszanie/zwalnianie silników if(actionNow != previousAction) { //zwalnianie, następnie zatrzymanie, zmiana działania i przyspieszenie dutyCycleNow = dutyCycleNow-dutyCycleStep; if (dutyCycleNow <= 0) { //jeśli po zmniejszeniu dc wynosi 0, ustaw nowy kierunek, rozpocznij od min cyklu pracy setDir(actionNow); poprzedniaAkcja = akcjaTeraz; dutyCycleNow = dutyCycleMin; } } else //actionNow == poprzednia akcja zwiększa się, z wyjątkiem sytuacji, gdy kierunek to STOP { if (actionNow != STOP) { dutyCycleNow = dutyCycleNow+dutyCycleStep; if (dutyCycleNow > dutyCycleMax) dutyCycleNow = dutyCycleMax; } w przeciwnym razie dutyCycleNow = 0; } ledcWrite(pwmChannel, dutyCycleNow); //dostosuj cykl pracy motocykla }}

To powoli zwiększa prędkość silników, zamiast po prostu uruchamiać się z pełną prędkością i rozlewać cenny Duvel. Oczywistym ulepszeniem byłoby przeniesienie tego kodu do podprogramu przerwań zegarowych, ale działa on tak, jak jest.

Teraz, jeśli zwolnimy przycisk do przodu, przeglądarka wywoła toggleCheckbox('stop'), co spowoduje żądanie GET /stop. ESP32 ustawia actionNow na STOP (i odpowiada "OK stop."), co powoduje, że pętla główna zwalnia silniki.

A co z diodami LED? Ten sam mechanizm, ale teraz mamy suwak:

W javascripcie monitorowane jest ustawienie suwaka tak, że przy każdej zmianie następuje wywołanie "/LED/xxx", gdzie xxx to wartość jasności, na jaką diody powinny być ustawione:

var slide = document.getElementById('slide'), sliderDiv = document.getElementById("sliderAmount"); slide.onchange = function() { var xhr = new XMLHttpRequest(); xhr.open("GET", "/LED/" + this.value, true); xhr.send(); sliderDiv.innerHTML = this.value; }

Zauważ, że użyliśmy document.getElementByID('slide'), aby pobrać sam obiekt suwaka, który został zadeklarowany with i że wartość jest wyprowadzana do elementu tekstowego z każdą zmianą.

Program obsługi w szkicu przechwytuje wszystkie żądania jasności za pomocą „/LED/*” w rejestracji programu obsługi. Następnie ostatnia część (liczba) jest dzielona i rzutowana na int:

server.on("/LED/*", HTTP_GET, (AsyncWebServerRequest *request){ Serial.println("odebrano żądanie led!"); setLedBrightness((request->url()).substring(5).toInt ()); request-> send(200, "text/plain", "LEDs OK."); });

Podobnie jak opisano powyżej, przyciski radiowe kontrolują zmienne, które ustawiają domyślne ustawienia PWM, takie, że DuvelBot może jechać powoli do ciebie z piwem, uważając, aby nie rozlać tego płynnego złota i szybko wrócić do kuchni po więcej.

…Więc w jaki sposób obraz z kamery jest aktualizowany bez konieczności odświeżania strony? W tym celu wykorzystujemy technikę o nazwie AJAX (Asynchronous JavaScript and XML). Problem polega na tym, że zwykle połączenie klient-serwer przebiega według ustalonej procedury: klient (przeglądarka) wysyła żądanie, serwer (ESP32) odpowiada, sprawa zostaje zamknięta. Gotowe. Nic się już nie dzieje. Gdybyśmy tylko w jakiś sposób mogli nakłonić przeglądarkę do regularnego żądania aktualizacji z ESP32… i to jest dokładnie to, co zrobimy z tym fragmentem javascriptu:

setInterval(function(){ var xhttp = new XMLHttpRequest(); xhttp.open("GET", "/CAMERA", true); xhttp.responseType = "blob"; xhttp.timeout = 500; xhttp.ontimeout = function(){}; xhttp.onload = function(e){ if (this.readyState == 4 && this.status == 200) { //patrz: https://stackoverflow.com/questions/7650587/używając… // https://www.html5rocks.com/en/tutorials/file/xhr2/ var urlCreator = window. URL || window.webkitURL; var imageUrl = urlCreator.createObjectURL(this.response); //utwórz obiekt z obiektu blob document.querySelector("#camimage").src = imageUrl; urlCreator.revokeObjectURL(imageurl) } }; xhttp.send(); }, 250);

setInterval przyjmuje jako parametr funkcję i wykonuje ją co jakiś czas (tutaj raz na 250ms, co daje 4 klatki na sekundę). Wykonywana funkcja wysyła żądanie binarnego „blobu” pod adresem /CAMERA. Jest to obsługiwane przez ESP32-CAM w szkicu jako (z Randomnerdtutorials):

server.on("/CAMERA", HTTP_GET, (AsyncWebServerRequest *request){ Serial.println("Odebrano żądanie kamery!"); camera_fb_t * fb = NULL; //esp_err_t res = ESP_OK; size_t _jpg_buf_len = 0; uint8_t * _jpg_buf = NULL; //przechwyć klatkę fb = esp_camera_fb_get(); if (!fb) {Serial.println("Nie można uzyskać bufora ramki");return;} if(fb->format != PIXFORMAT_JPEG)/ / już w tym formacie z config{ bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len); esp_camera_fb_return(fb); fb = NULL; if(!jpeg_converted){Serial.println("Kompresja JPEG nie powiodła się";return); } } else{ _jpg_buf_len = fb->len; _jpg_buf = fb->buf; } //Serial.println(_jpg_buf_len); //wyślij żądanie sformatowanego obrazu->send_P(200, "image/jpg", _jpg_buf, _jpg_buf_len); //cleanup if(fb){ esp_camera_fb_return(fb); fb = NULL; _jpg_buf = NULL; } else if(_jpg_buf){ free(_jpg_buf); _jpg_buf = NULL; } });

Ważnymi częściami są pobranie ramki fb = esp_camera_fb_get() przekonwertowanie jej na-j.webp

Następnie funkcja javascript czeka na przybycie tego obrazu. Następnie wystarczy trochę pracy, aby przekonwertować otrzymany „blob” na adres URL, który może być używany jako źródło do aktualizacji obrazu na stronie html.

Uff, gotowe!

Krok 4: Pomysły i resztki

Celem tego projektu było dla mnie nauczenie się programowania w sieci Web w ilości wystarczającej do połączenia sprzętu z siecią. Możliwych jest kilka rozszerzeń tego projektu. Oto kilka pomysłów:

• Zaimplementuj „prawdziwe” strumieniowanie z kamery, jak wyjaśniono tutaj i tutaj, i przenieś je na drugi serwer, jak wyjaśniono tutaj, na tym samym ESP32, ale na drugim rdzeniu procesora, a następnie zaimportuj strumień z kamery do html obsługiwanego przez pierwszy serwer za pomocą …. Powinno to skutkować szybszymi aktualizacjami aparatu.
• Użyj trybu punktu dostępu (AP), aby robot był bardziej samodzielny, jak wyjaśniono tutaj.
• Rozszerz o pomiar napięcia akumulatora, możliwości głębokiego uśpienia itp. Jest to obecnie nieco trudne, ponieważ AI-Thinker ESP32-CAM nie ma wielu GPIO; potrzebuje rozbudowy przez uart i np. arduino slave.
• Przekształć się w robota szukającego kota, który od czasu do czasu wyrzuca kocie smakołyki za naciśnięciem łapy dużego przycisku, przesyłaj strumieniowo mnóstwo fajnych zdjęć kotów w ciągu dnia…

Proszę o komentarz, jeśli podobało Ci się lub masz pytania i dziękuję za przeczytanie!