Täysin toimivan älykkään ovikellon luominen vaatii useita eri komponentteja, joista jokainen on oma kokonaisuutensa:

• ESP32-CAM-koodi: Tämän on otettava kuvia, yhdistettävä Wi-Fiin ja käynnistettävä konenäkö.
• Kuvien käsittely: Koodin on lähetettävä kuvat palvelimelle tai pilvipalveluun.
• Kasvojentunnistusmalli: Itse tekoälymalli on koulutettava tunnistamaan ystäväsi ja perheenjäsenesi.
• Ilmoitusjärjestelmä: Palvelimen on lähetettävä push-ilmoitus puhelimeesi, kun tunnistus on tehty.

Tämä on moniosainen kokonaisuus, jonka valmis koodi olisi satoja, ellei tuhansia rivejä pitkä. Siksi on paljon hyödyllisempää keskittyä ideaan ja työnkulkuun, jotta ymmärrät, miten tällainen projekti rakennetaan, etkä vain kopioi valmista koodia, jonka toimivuudesta et voi olla varma.

Voin kuitenkin antaa sinulle esimerkkikoodin, jolla pääset alkuun ja ymmärrät, miten ESP32-CAMin perustoiminnot toimivat. Tällä koodilla saat kamerasta otettua kuvan ja lähetettyä sen HTTP-palvelimelle, mikä on ensimmäinen ja tärkein askel kohti älykästä ovikelloa.

ESP32-CAM – Kuvan lähetys Wi-Fi-verkossa

Tämä koodi on kirjoitettu Arduino-ympäristöön, ja se toimii hyvänä perustana, jota voit laajentaa kohti monimutkaisempia toimintoja. Tässä on yksinkertainen koodi, joka ottaa kuvan ja lähettää sen HTTP POST -pyynnöllä palvelimelle.

Tarvittavat kirjastot:

• esp_camera.h

• WiFi.h

• WiFiClient.h

• ESPAsyncWebServer.h

• camera_pins.h (määrittelyt ESP32-CAMille)

#include "esp_camera.h"
#include <WiFi.h>
#include <HTTPClient.h>

// WiFi-asetukset
const char* ssid = "WIFI_VERKON_NIMI";
const char* password = "WIFI_SALASANA";

// Palvelin, jonne kuva lähetetään
const char* serverName = "http://OMA_PALVELIMEN_IP/upload";
HTTPClient http;

// Kameran asetukset
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22
#define D0_GPIO_NUM       -1 // Vain M5CAM
#define D1_GPIO_NUM       -1 // Vain M5CAM
#define D2_GPIO_NUM       -1 // Vain M5CAM
#define D3_GPIO_NUM       -1 // Vain M5CAM
#define D4_GPIO_NUM       -1 // Vain M5CAM
#define D5_GPIO_NUM       -1 // Vain M5CAM
#define D6_GPIO_NUM       -1 // Vain M5CAM
#define D7_GPIO_NUM       -1 // Vain M5CAM

void setup() {
    Serial.begin(115200);
    // Yhdistä Wi-Fi-verkkoon
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("");
    Serial.println("WiFi yhdistetty!");

    // Kameran käynnistys
    camera_config_t config;
    config.ledc_channel = LEDC_CHANNEL_0;
    config.ledc_timer = LEDC_TIMER_0;
    config.pin_d0 = 5;
    config.pin_d1 = 18;
    config.pin_d2 = 19;
    config.pin_d3 = 21;
    config.pin_d4 = 36;
    config.pin_d5 = 39;
    config.pin_d6 = 34;
    config.pin_d7 = 35;
    config.pin_xclk = 0;
    config.pin_pclk = 22;
    config.pin_vsync = 25;
    config.pin_href = 23;
    config.pin_sscb_sda = 26;
    config.pin_sscb_scl = 27;
    config.pin_pwdn = -1;
    config.pin_reset = -1;
    config.xclk_freq_hz = 20000000;
    config.pixel_format = PIXFORMAT_JPEG;

    // Kameran resoluutio
    config.frame_size = FRAMESIZE_VGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;

    esp_err_t err = esp_camera_init(&config);
    if (err != ESP_OK) {
        Serial.printf("Kameran käynnistys epäonnistui: %s\n", esp_err_to_name(err));
        return;
    }
}

void loop() {
    // Ota kuva
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
        Serial.println("Kuvankaappaus epäonnistui");
        return;
    }

    // Lähetä kuva palvelimelle
    http.begin(serverName);
    http.addHeader("Content-Type", "image/jpeg");
    int httpResponseCode = http.POST(fb->buf, fb->len);

    if (httpResponseCode > 0) {
        Serial.printf("[HTTP] POST... koodi: %d\n", httpResponseCode);
        String response = http.getString();
        Serial.println(response);
    } else {
        Serial.printf("[HTTP] POST... epäonnistui, koodi: %d\n", httpResponseCode);
    }

    http.end();
    esp_camera_fb_return(fb);

    delay(5000); // Odota 5 sekuntia ennen seuraavaa kuvaa
}

Miten tästä eteenpäin?

1. Palvelinpuoli: Sinun on luotava palvelin (esim. Python Flask tai Node.js), joka ottaa vastaan ESP32-CAMin lähettämän kuvan ja tallentaa sen. Tämä palvelin toimisi linkkinä ovikellon ja tekoälymallin välillä.
2. Tekoälymalli: Seuraava askel on kouluttaa kasvojentunnistusmalli tietokoneellasi. Tähän voit hyödyntää OpenCV-kirjastoa, kuten koodinkutoja.com -sivustolla on esitetty. Kouluta malli useilla kuvilla ystävistäsi. Kun palvelin vastaanottaa kuvan ESP32:sta, se lähettää kuvan tälle tekoälymallille.
3. Ilmoitukset: Kun tekoäly tunnistaa jonkun, se lähettää ilmoituksen (esim. push-ilmoituksen tai sähköpostin) puhelimeesi.

Vinkki: Voit helpottaa projektin toteutusta hyödyntämällä TinyML– ja Edge Impulse -alustoja. Niiden avulla voit kouluttaa tekoälymallin (esim. liiketunnistuksen tai yksinkertaisen kasvojentunnistuksen) suoraan toimimaan ESP32-CAMissa, jolloin sinun ei tarvitse lähettää kuvaa erilliselle palvelimelle. Tämä tekee ovikellosta nopeamman ja itsenäisemmän.

Toivottavasti tämä antaa sinulle hyvän lähtökohdan tähän upeaan projektiin!

tässä projektissa hyödynnetään TinyML:n rajallista laskentaympäristöä, mikä tekee siitä sekä haastavan että erittäin palkitsevan. Vaikka ESP32-CAMin laskentateho ei riitä reaaliaikaiseen sormien tunnistukseen samalla tavalla kuin tietokone, se on täydellinen alusta yksinkertaisten käsimerkkien, kuten nyrkin tai avoimen kämmenen, tunnistamiseen ja luokitteluun. Tällaisen projektin ydin on Edge Impulse -alusta, joka tekee tekoälymallin kehittämisestä ja käyttöönotosta uskomattoman helppoa. Tämän projektin koodi keskittyy siis pitkälti Edge Impulsen luoman valmiin kirjaston hyödyntämiseen.

Käsieleillä ohjattava laite

Työnkulku:

1. Datan keräys: Kokoa ESP32-CAMilla useita kuvia jokaisesta eleestä, jonka haluat laitteen tunnistavan. Esimerkiksi 100-200 kuvaa puristetusta nyrkistä ja vastaava määrä avoimesta kämmenestä.
2. Mallin koulutus: Syötä keräämäsi kuvat Edge Impulse -alustalle. Alusta esikäsittelee kuvat, kouluttaa niistä pienen tekoälymallin ja optimoi sen toimimaan tehokkaasti ESP32:ssa.
3. Koodin luonti: Edge Impulse generoi valmiin C++-kirjaston, jonka voit tuoda Arduino-ympäristöön. Tämä kirjasto sisältää kaiken tarvittavan, jotta ESP32-CAM voi käyttää kouluttamaasi mallia.
4. Laitteen ohjaus: Koodissa määritellään, mitä ESP32 tekee, kun se tunnistaa tietyn eleen. Tässä esimerkissä lähetetään komento Wi-Fin yli.

Tässä on koodi, joka toimii tämän projektin perustana. Muista, että tämä on yleinen malli, ja sinun on korvattava “Edge Impulsen mallikirjasto” ja “Wi-Fi-tiedot” omillasi.

Miten koodi toimii?

1. Määritykset: Koodin alussa määritellään Wi-Fi-yhteys ja kameran asetukset. Erityisen tärkeää on asettaa kuvan muoto (PIXFORMAT_GRAYSCALE) ja koko (FRAMESIZE_96X96) vastaamaan Edge Impulse -projektin asetuksia.
2. Kuvankäsittely: loop-funktio ottaa kuvan ja luokittelee sen suoraan ESP32:lla käyttäen Edge Impulsen generoidun kirjaston ei_image_classification_run_image_classifier -funktiota. Tämä toiminto on koko projektin ydin, sillä se hoitaa kaiken monimutkaisen logiikan puolestasi.
3. Toimintalogiikka: Tunnistuksen jälkeen koodi tarkistaa, mikä eleistä sai korkeimman luotettavuuden. Jos luotettavuus ylittää asetetun rajan (esim. 85%), ESP32 lähettää Wi-Fi-verkon yli HTTP GET -pyynnön. Tässä pyynnössä voidaan lähettää parametrina tunnistetun eleen nimi, jonka ulkoinen palvelin tai laite ottaa vastaan.
4. Laitteen ohjaus: Ulkoinen palvelin tai IoT-laite (esim. Raspberry Pi tai verkkopistorasia) kuuntelee näitä HTTP-pyyntöjä. Kun se saa pyynnön, jonka parametrina on esimerkiksi "nyrkki", se suorittaa sille annetun komennon, kuten kytkee valot päälle tai pois päältä.

Tämän koodin avulla pääset alkuun erinomaisella tavalla, ja sen avulla voit luoda todella mielenkiintoisia ja käytännöllisiä sovelluksia!

#include <WiFi.h>
#include <HTTPClient.h>

#include "ei_image_classification.h" // Sisältää Edge Impulsen luoman mallin

// WiFi-asetukset
const char* ssid = "WIFI_VERKON_NIMI";
const char* password = "WIFI_SALASANA";

// Palvelimen osoite, jota ohjataan
const char* serverUrl = "http://OMA_PALVELIMEN_IP/komento";

// Kameran asetukset (malli ESP32-CAM AI-Thinker)
#include "esp_camera.h"
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

camera_config_t config;

void setup() {
    Serial.begin(115200);
    // Yhdistä Wi-Fi-verkkoon
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("\nWiFi yhdistetty!");
    Serial.printf("IP-osoite: %s\n", WiFi.localIP().toString().c_str());

    // Kameran käynnistys
    config.ledc_channel = LEDC_CHANNEL_0;
    config.ledc_timer = LEDC_TIMER_0;
    config.pin_d0 = 5;
    config.pin_d1 = 18;
    config.pin_d2 = 19;
    config.pin_d3 = 21;
    config.pin_d4 = 36;
    config.pin_d5 = 39;
    config.pin_d6 = 34;
    config.pin_d7 = 35;
    config.pin_xclk = 0;
    config.pin_pclk = 22;
    config.pin_vsync = 25;
    config.pin_href = 23;
    config.pin_sscb_sda = 26;
    config.pin_sscb_scl = 27;
    config.pin_pwdn = -1;
    config.pin_reset = -1;
    config.xclk_freq_hz = 20000000;
    config.pixel_format = PIXFORMAT_GRAYSCALE; // Määritä pikselimuoto Edge Impulsen vaatimusten mukaisesti
    config.frame_size = FRAMESIZE_96X96; // Määritä kuvan koko Edge Impulsen vaatimusten mukaisesti
    config.jpeg_quality = 10;
    config.fb_count = 1;

    esp_err_t err = esp_camera_init(&config);
    if (err != ESP_OK) {
        Serial.printf("Kameran käynnistys epäonnistui: %s\n", esp_err_to_name(err));
        return;
    }
}

void loop() {
    // Ota kuva
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
        Serial.println("Kuvankaappaus epäonnistui");
        return;
    }

    // Luokittele kuva Edge Impulse -mallilla
    signal_t signal;
    ei::error_t err = ei_image_classification_run_image_classifier(&signal, fb->buf);
    
    if (err != EI_IMPULSE_OK) {
        Serial.printf("Luokittelu epäonnistui, virhe: %d\n", err);
        esp_camera_fb_return(fb);
        return;
    }
    
    // Tarkista tulokset
    String recognizedGesture = "tuntematon";
    float maxConfidence = 0.0;
    for (size_t i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
        if (ei_classifier_results.classification[i].confidence > maxConfidence) {
            maxConfidence = ei_classifier_results.classification[i].confidence;
            recognizedGesture = ei_classifier_results.classification[i].label;
        }
    }

    // Jos luotettavuus on riittävän suuri, lähetä komento
    if (maxConfidence > 0.85) { // Säädä luotettavuusrajaa tarpeen mukaan
        Serial.printf("Tunnistettu ele: %s (luottamus: %.2f)\n", recognizedGesture.c_str(), maxConfidence);
        
        // Lähetä HTTP-pyyntö riippuen tunnistetusta eleestä
        HTTPClient http;
        String url = String(serverUrl) + "?ele=" + recognizedGesture;
        http.begin(url);
        int httpCode = http.GET();
        
        if (httpCode > 0) {
            Serial.printf("[HTTP] GET... koodi: %d\n", httpCode);
            String payload = http.getString();
            Serial.println(payload);
        } else {
            Serial.printf("[HTTP] GET... epäonnistui, koodi: %d\n", httpCode);
        }
        http.end();
    } else {
        Serial.println("Eleen tunnistus ei riittävän luotettava.");
    }

    esp_camera_fb_return(fb);
    delay(100); // Lyhyt viive, jotta prosessori ei käy jatkuvasti täydellä teholla
}

Automaattinen lemmikintunnistin ja syöttölaite on täydellinen esimerkki siitä, miten tekoälyä voidaan hyödyntää arkipäiväisissä sovelluksissa kotona. Avain on tässäkin projektissa Edge Impulse -alustassa, joka yksinkertaistaa tekoälymallin kehitystä huomattavasti.

Tässä koodissa keskitytään siihen, miten otetaan kuva, luokitellaan se ja toimitaan sen perusteella – tässä tapauksessa servomoottorin ohjaamiseen. Tämän koodin avulla pääset alkuun. Muista, että tämä on yleinen malli, joka sinun on sovitettava omaan Edge Impulse -projektiisi.

Projekti 3: Automaattinen lemmikkien tunnistin ja syöttölaite

Työnkulku:

1. Datan keräys: Kuten ovikelloprojektissa, aloita keräämällä kuvadataa. Ota kuvia lemmikistäsi eri kulmista ja valaistuksissa, merkitse ne luokkaan “lemmikki“. Kerää kuvia myös silloin, kun lemmikkiä ei ole paikalla, ja merkitse ne luokkaan “ei-lemmikki“.
2. Mallin koulutus: Lataa kuvat Edge Impulse -alustalle. Alusta esikäsittelee ne ja kouluttaa luokittelumallin, joka erottaa lemmikin muusta ympäristöstä. Voit valita koulutukseen esimerkiksi kuvien tunnistamiseen soveltuvan mallin, kuten FOMO (Faster Objects, More Objects), joka on erinomainen pienten kohteiden havaitsemiseen rajallisella teholla.
3. Koodin luonti ja lataus: Kun malli on valmis, Edge Impulse luo sinulle valmiin kirjaston, jonka voit ladata Arduino-ympäristöön. Tämä kirjasto sisältää koko mallin, valmiina ajettavaksi ESP32-CAMilla.

Tässä on C++-koodi, joka yhdistää kameran, tekoälymallin ja servomoottorin ohjauksen.

Miten koodi toimii?

1. Alustus: setup()-funktiossa alustetaan sekä ESP32-CAM että servomoottori. Servomoottori asetetaan oletusarvoisesti suljettuun tilaan (CLOSE_POSITION).
2. Kameran käynnistys: Kameran asetuksissa on määritetty pikselimuoto (PIXFORMAT_GRAYSCALE) ja kuvan koko (FRAMESIZE_96X96) vastaamaan Edge Impulse -projektin vaatimuksia. Tämä on kriittinen askel, jotta malli toimii oikein.
3. Tunnistus ja toiminta: loop()-funktio on projektin moottori. Se ottaa jatkuvasti kuvia ja lähettää ne Edge Impulsen luokittelijan ei_object_detection_run_classifier()-funktioon.
4. Servon ohjaus: Koodi käy läpi tunnistustulokset. Jos se löytää luokan “lemmikki” ja luotettavuus (confidence) on riittävän korkea (esim. yli 85%), se lähettää komennon servomoottorille (servoMotor.write(OPEN_POSITION)), joka avaa annostelijan. Se myös sulkee luukun tietyn viiveen jälkeen.
5. Energiansäästö: Tämän toteutuksen voi optimoida energiatehokkaaksi lisäämällä liiketunnistimen, joka herättää laitteen lepotilasta. Tässä koodissa käytetty delay()-funktio tekee sen, että laite on koko ajan hereillä, mutta tällaisessa projektissa lepotilan käyttö onnistuu vaivattomasti.

Tämä koodi tarjoaa vankan perustan, jonka avulla voit rakentaa älykkään ja itsenäisen ruoka-annostelijan lemmikillesi!

#include "esp_camera.h"
#include <Servo.h>
#include "ei_object_detection.h" // Edge Impulsen generoi tämän tiedoston

// Servomoottorin nastan numero
#define SERVO_PIN 13

// Servomoottorin asennot
#define CLOSE_POSITION 0
#define OPEN_POSITION 90

Servo servoMotor;

// WiFi-asetukset (vaikka tätä projektia voi käyttää offline-tilassa)
const char* ssid = "WIFI_VERKON_NIMI";
const char* password = "WIFI_SALASANA";

// Kameran asetukset (malli ESP32-CAM AI-Thinker)
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

camera_config_t config;

void setup() {
    Serial.begin(115200);

    // Servomoottorin alustus
    servoMotor.attach(SERVO_PIN);
    servoMotor.write(CLOSE_POSITION);
    Serial.println("Servomoottori alustettu suljettuun tilaan.");

    // Kameran alustus
    config.ledc_channel = LEDC_CHANNEL_0;
    config.ledc_timer = LEDC_TIMER_0;
    config.pin_d0 = 5;
    config.pin_d1 = 18;
    config.pin_d2 = 19;
    config.pin_d3 = 21;
    config.pin_d4 = 36;
    config.pin_d5 = 39;
    config.pin_d6 = 34;
    config.pin_d7 = 35;
    config.pin_xclk = 0;
    config.pin_pclk = 22;
    config.pin_vsync = 25;
    config.pin_href = 23;
    config.pin_sscb_sda = 26;
    config.pin_sscb_scl = 27;
    config.pin_pwdn = -1;
    config.pin_reset = -1;
    config.xclk_freq_hz = 20000000;
    config.pixel_format = PIXFORMAT_GRAYSCALE;
    config.frame_size = FRAMESIZE_96X96;
    config.jpeg_quality = 10;
    config.fb_count = 1;

    esp_err_t err = esp_camera_init(&config);
    if (err != ESP_OK) {
        Serial.printf("Kameran käynnistys epäonnistui: %s\n", esp_err_to_name(err));
        return;
    }
}

void loop() {
    // Ota kuva
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
        Serial.println("Kuvankaappaus epäonnistui");
        return;
    }

    // Aja kuva tekoälymallin läpi
    signal_t signal;
    ei::error_t err = ei_object_detection_run_classifier(&signal, fb->buf);
    
    if (err != EI_IMPULSE_OK) {
        Serial.printf("Luokittelu epäonnistui, virhe: %d\n", err);
        esp_camera_fb_return(fb);
        return;
    }

    // Tarkista tunnistustulokset
    for (size_t i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
        if (strcmp(ei_classifier_results.classification[i].label, "lemmikki") == 0 && ei_classifier_results.classification[i].confidence > 0.85) {
            Serial.printf("Lemmikki tunnistettu! Luottamus: %.2f\n", ei_classifier_results.classification[i].confidence);
            
            // Avaa ruoka-annostelija
            servoMotor.write(OPEN_POSITION);
            Serial.println("Ruoka-annostelija avattu!");
            
            // Odota hetki, jotta lemmikki ehtii syödä
            delay(10000); // Odota 10 sekuntia
            
            // Sulje ruoka-annostelija
            servoMotor.write(CLOSE_POSITION);
            Serial.println("Ruoka-annostelija suljettu.");
            
            break; // Poistu silmukasta, kun lemmikki on tunnistettu ja toiminto suoritettu
        }
    }

    esp_camera_fb_return(fb);
    delay(500); // Lyhyt viive
}