Aktywny System Monitorujący

[Szern]

1 minutę temu, _LM_ napisał:

Cóż, te najtańsze modele tak mają, nie są zbyt pewne. Przepraszam jeśli to już było poruszane, czy przy każdym pir jest kamera? Można wykorzystać kamerkę jako czujnik ruchu skoro i tak tam jest 

Z PiR'ów zrezygnowałem. Nie sprawdziły się. W tej chwili jest to bardzo prymitywne rozpoznawanie ruchu z kamer na serwerku. Działa jako-tako.

$image0 = new imagick($imagesr[0]);
$image1 = new imagick($imagesr[1]);

$image0->setOption('fuzz', '8%');
$image1->setOption('fuzz', '8%');

$image0->setImageType(Imagick::IMGTYPE_GRAYSCALEMATTE);
$image1->setImageType(Imagick::IMGTYPE_GRAYSCALEMATTE);

$result = $image0->compareImages($image1, Imagick::METRIC_MEANSQUAREERROR);

$roznica = $result[1]*10000;

Co do czujnika, to jest to. Na aplikacji widać, że działa, ale na pinie mam niezmiennie stan wysoki. Inna sprawa, że nie miałem czasu aby poważnie to obwąchać.

 

[_LM_]

18 minut temu, Szern napisał:

Co do czujnika, to jest to

Fajny! 

Ja chcę kiedyś przetestować esp w tej roli, rozumiem że u ciebie nie spełni oczekiwań bo wątpię aby zadziałało na zewnątrz https://github.com/espressif/esp-csi EOT 

Edytowano Sierpień 12, 2025 przez _LM_

[Szern]

16 minut temu, _LM_ napisał:

Fajny! 

Ja chcę kiedyś przetestować esp w tej roli, rozumiem że u ciebie nie spełni oczekiwań bo wątpię aby zadziałało na zewnątrz https://github.com/espressif/esp-csi EOT 

Dzięki za podrzucenie tematu. Interesujące! Przegryzę się przez to z przyjemnością. Jeszcze nie doczytałem, czy to analizuje używany sygnał, czy zawłaszcza połączenie WiFi. Moje urządzenia komunikują się poprzez MQTT (na WiFi), więc w drugim przypadku nie byłoby to dla mnie przydatne. Ale jeśli w pierwszym, to z ciekawości wypróbuję. 

[_LM_]

Z szybkiego przeglądu: ten komponent korzysta z RSSI wynika z tego że działa równolegle a nie przejmuje sygnału. W starszych wersjach użytkownicy zgłaszali problemy z mqtt ale zdaje się że espressif już to naprawił.

Edytowano Sierpień 12, 2025 przez _LM_

[_LM_]

Ok zmontowałem na szybko kod aby sprawdzić czy ta metoda działa, jeśli jesteś zainteresowany to mogę podrzucić tutaj source. Ciekawa rzecz, można faktycznie wykryć obecność za pomocą tylko wifi

[Szern]

8 godzin temu, _LM_ napisał:

Ok zmontowałem na szybko kod aby sprawdzić czy ta metoda działa, jeśli jesteś zainteresowany to mogę podrzucić tutaj source. Ciekawa rzecz, można faktycznie wykryć obecność za pomocą tylko wifi

Jak najbardziej jestem zainteresowany. Tylko muszę trochę się wczytać w temat, a później spróbować to zaimplementować. Z tego co widzę, to Platformio jeszcze tego nie wspiera, więc będę musiał również zaznajomić się z esp-idf.

Wygląda to tak obiecująco, że aż niewiarygodnie. 

[_LM_]

No, działa aczkolwiek ja wgrałem możliwie najprostszy przykład, co więcej wygenerowany przez gemini bo aktualnie nad czymś innym siedzę. Ok później będę miał chwilę to podam to tutaj z opisem jak uruchomić 

[_LM_]

Obiecany program, niema tego dużo to wrzucam cały source

#include <stdio.h>
#include <string.h>
#include <math.h>
#include "nvs_flash.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/event_groups.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#include "mqtt_client.h"

// --- KONFIGURACJA UŻYTKOWNIKA ---
#define ESP_WIFI_SSID         ""
#define ESP_WIFI_PASS         ""
#define ESP_MQTT_BROKER_URL   "mqtt://broker.hivemq.com"
#define ESP_MQTT_TOPIC_PRESENCE "/esp32/presence"

// --- PARAMETRY SYSTEMOWE I DETEKCJI ---
#define ESP_MAXIMUM_RETRY     5
#define MOTION_THRESHOLD      3.0  // <<< USTAW NISKI PRÓG NA POCZĄTEK!
#define PRESENCE_TIMEOUT_S    30

// --- Tagi do logowania ---
static const char *TAG_WIFI = "WIFI_STATION";
static const char *TAG_MQTT = "MQTT_CLIENT";
static const char *TAG_CSI  = "CSI_PRESENCE";

// --- Zmienne globalne ---
static EventGroupHandle_t s_wifi_event_group;
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1

static int s_retry_num = 0;
static esp_mqtt_client_handle_t mqtt_client;
static bool mqtt_connected = false;
static bool g_is_present = false;
static int64_t g_last_motion_timestamp = 0;

// (Handler zdarzeń Wi-Fi - bez zmian)
static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) {
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (s_retry_num < ESP_MAXIMUM_RETRY) {
            esp_wifi_connect(); s_retry_num++; ESP_LOGI(TAG_WIFI, "ponowna próba połączenia z AP");
        } else {
            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
        }
        ESP_LOGI(TAG_WIFI, "nie udało się połączyć z AP");
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG_WIFI, "uzyskano IP: " IPSTR, IP2STR(&event->ip_info.ip));
        s_retry_num = 0;
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

// (Inicjalizacja Wi-Fi - bez zmian)
void wifi_init_sta(void) {
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    esp_event_handler_instance_t instance_any_id, instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL, &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL, &instance_got_ip));
    wifi_config_t wifi_config = { .sta = { .ssid = ESP_WIFI_SSID, .password = ESP_WIFI_PASS }, };
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_start());
}

// (Handler MQTT - bez zmian)
static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
    switch ((esp_mqtt_event_id_t)event_id) {
        case MQTT_EVENT_CONNECTED: ESP_LOGI(TAG_MQTT, "Połączono z brokerem MQTT"); mqtt_connected = true; break;
        case MQTT_EVENT_DISCONNECTED: ESP_LOGI(TAG_MQTT, "Rozłączono z brokerem MQTT"); mqtt_connected = false; break;
        default: break;
    }
}

// (Start MQTT - bez zmian)
void mqtt_app_start(void) {
    esp_mqtt_client_config_t mqtt_cfg = { .broker.address.uri = ESP_MQTT_BROKER_URL, };
    mqtt_client = esp_mqtt_client_init(&mqtt_cfg);
    esp_mqtt_client_register_event(mqtt_client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
    esp_mqtt_client_start(mqtt_client);
}

// (Callback CSI - z logami diagnostycznymi)
void wifi_csi_rx_cb(void *ctx, wifi_csi_info_t *info) {
    if (!info || !info->buf) { return; }
    int8_t *csi_raw_data = (int8_t *)info->buf;
    float mean = 0.0, std_dev = 0.0;
    int num_subcarriers = info->len / 2;
    if (num_subcarriers == 0) return;
    for (int i = 0; i < num_subcarriers; i++) { mean += csi_raw_data[i * 2]; }
    mean /= num_subcarriers;
    for (int i = 0; i < num_subcarriers; i++) { std_dev += pow(csi_raw_data[i * 2] - mean, 2); }
    std_dev = sqrt(std_dev / num_subcarriers);
    ESP_LOGI(TAG_CSI, "Obliczone odchylenie (std_dev): %.2f", std_dev);
    if (std_dev > MOTION_THRESHOLD) {
        ESP_LOGI(TAG_CSI, "PRÓG PRZEKROCZONY! (%.2f > %.2f)", std_dev, MOTION_THRESHOLD);
        g_last_motion_timestamp = esp_timer_get_time();
    }
}

// (Zadanie zarządzania obecnością - bez zmian)
static void presence_management_task(void *pvParameters) {
    while (1) {
        bool current_presence_status = false;
        if (g_last_motion_timestamp > 0) {
            int64_t time_since_last_motion = (esp_timer_get_time() - g_last_motion_timestamp) / 1000000;
            if (time_since_last_motion < PRESENCE_TIMEOUT_S) { current_presence_status = true; }
        }
        if (current_presence_status != g_is_present) {
            g_is_present = current_presence_status;
            if (mqtt_connected) {
                const char *payload = g_is_present ? "{\"obecnosc\":\"tak\"}" : "{\"obecnosc\":\"nie\"}";
                esp_mqtt_client_publish(mqtt_client, ESP_MQTT_TOPIC_PRESENCE, payload, 0, 1, 0);
                ESP_LOGI(TAG_CSI, "ZMIANA STANU -> Obecność: %s", g_is_present ? "TAK" : "NIE");
            }
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// (Zadanie konfiguracji CSI - bez zmian)
static void csi_task(void *pvParameters) {
    xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
    ESP_LOGI(TAG_CSI, "Wi-Fi połączone, konfiguruję CSI...");
    ESP_ERROR_CHECK(esp_wifi_set_csi(true));
    wifi_csi_config_t csi_config = { .lltf_en = true, .htltf_en = false, .stbc_htltf2_en = false, .ltf_merge_en = true, .channel_filter_en = false, .manu_scale = false, };
    ESP_ERROR_CHECK(esp_wifi_set_csi_config(&csi_config));
    ESP_ERROR_CHECK(esp_wifi_set_csi_rx_cb(wifi_csi_rx_cb, NULL));
    ESP_LOGI(TAG_CSI, "Konfiguracja CSI zakończona. Nasłuchiwanie...");
    vTaskDelete(NULL);
}


// +++ NOWE ZADANIE DO AKTYWNEGO SKANOWANIA +++
static void wifi_scan_task(void *pvParameters) {
    ESP_LOGI(TAG_CSI, "Uruchomiono zadanie aktywnego skanowania dla CSI.");
    vTaskDelay(pdMS_TO_TICKS(5000));
    wifi_scan_config_t scan_config = { .ssid = 0, .bssid = 0, .channel = 0, .show_hidden = true };
    while (true) {
        esp_wifi_scan_start(&scan_config, true);
        vTaskDelay(pdMS_TO_TICKS(200)); // Skanuj co 200 ms dla szybkiej reakcji
    }
}


void app_main(void) {
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
      ESP_ERROR_CHECK(nvs_flash_erase());
      ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);
    wifi_init_sta();
    mqtt_app_start();
    xTaskCreate(&csi_task, "csi_task", 4096, NULL, 5, NULL);
    xTaskCreate(&presence_management_task, "presence_task", 4096, NULL, 5, NULL);

    // +++ URUCHOMIENIE NOWEGO ZADANIA +++
    xTaskCreate(&wifi_scan_task, "wifi_scan_task", 4096, NULL, 4, NULL);
}

Wymagany cmake list

idf_component_register(SRCS "main.c"
                    INCLUDE_DIRS "."
                    REQUIRES esp_wifi esp_event mqtt esp_timer nvs_flash)

W pliku config, zaznaczyć wsparcie CSI

Ja pobrałem jeszcze https://components.espressif.com/components/espressif/esp-radar może się okazać że nie jest potrzebny gdyż espressif daje wbudowane wsparcie. Musisz sprawdzić. 

Tak samo jak działanie i dostrajanie

 

 

Edytowano Sierpień 13, 2025 przez _LM_