Lilygo T-cam s3

[Michal88]

Wyświetlacz w esp pokazuje błąd kamery.

 

#include <Arduino.h>
#include "esp_camera.h"
#include <WiFi.h>
#include <Wire.h>
// Zamiast SSD1306.h użyjemy właściwej biblioteki
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// Zastąp poniższe dane swoimi danymi sieci WiFi (opcjonalnie)
const char* ssid = "NAZWA_WIFI";
const char* password = "HASLO_WIFI";

// Definicja pinów kamery dla LILYGO T-Camera S3
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM     38
#define SIOD_GPIO_NUM     5      // SDA
#define SIOC_GPIO_NUM     4      // SCL
#define Y9_GPIO_NUM       9      // Data9
#define Y8_GPIO_NUM       10     // Data8
#define Y7_GPIO_NUM       11     // Data7
#define Y6_GPIO_NUM       13     // Data6
#define Y5_GPIO_NUM       21     // Data5
#define Y4_GPIO_NUM       48     // Data4
#define Y3_GPIO_NUM       47     // Data3
#define Y2_GPIO_NUM       14     // Data2
#define VSYNC_GPIO_NUM    8      // VSYNC
#define HREF_GPIO_NUM     18     // HREF
#define PCLK_GPIO_NUM     39     // PCLK

// Piny I2C dla OLED
#define OLED_SDA          7      // I007 zgodnie z pinout
#define OLED_SCL          6      // I006 zgodnie z pinout
#define OLED_RST          -1     // Nie używany
#define SCREEN_WIDTH      128    // Szerokość wyświetlacza OLED w pikselach
#define SCREEN_HEIGHT     64     // Wysokość wyświetlacza OLED w pikselach
#define OLED_ADDR         0x3C   // Adres I2C wyświetlacza

// Inicjalizacja wyświetlacza OLED
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RST);

// Ustawienie adresu IP serwera
IPAddress ip;

void startCameraServer();

bool initCamera() {
  // Opóźnienie przed inicjalizacją kamery dla stabilizacji zasilania
  delay(100);
  
  // Konfiguracja kamery
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  
  // Konfiguracja jakości i rozmiaru obrazu
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;  // 800x600
    config.jpeg_quality = 10;            // 0-63 (niższa wartość = lepsza jakość)
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_VGA;   // 640x480
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  
  // Reset kamery (jeśli pin resetowania jest dostępny)
  if (RESET_GPIO_NUM >= 0) {
    pinMode(RESET_GPIO_NUM, OUTPUT);
    digitalWrite(RESET_GPIO_NUM, LOW);
    delay(10);
    digitalWrite(RESET_GPIO_NUM, HIGH);
    delay(10);
  }
  
  // Próba inicjalizacji z kilkoma powtórzeniami
  esp_err_t err;
  int retry_count = 0;
  do {
    err = esp_camera_init(&config);
    if (err != ESP_OK) {
      Serial.printf("Inicjalizacja kamery nie powiodła się z błędem 0x%x, próba %d\n", err, retry_count+1);
      delay(500);
    }
    retry_count++;
  } while (err != ESP_OK && retry_count < 3);
  
  if (err != ESP_OK) {
    Serial.printf("Inicjalizacja kamery nie powiodła się po %d próbach z błędem 0x%x\n", retry_count, err);
    return false;
  }

  // Dostosowanie ustawień sensora (opcjonalnie)
  sensor_t * s = esp_camera_sensor_get();
  s->set_brightness(s, 0);     // -2 to 2
  s->set_contrast(s, 0);       // -2 to 2
  s->set_saturation(s, 0);     // -2 to 2
  s->set_special_effect(s, 0); // 0 = brak efektu
  s->set_whitebal(s, 1);       // 0 = wyłączone, 1 = włączone
  s->set_awb_gain(s, 1);       // 0 = wyłączone, 1 = włączone
  s->set_wb_mode(s, 0);        // 0 auto
  s->set_exposure_ctrl(s, 1);  // 0 = wyłączone, 1 = włączone
  s->set_gain_ctrl(s, 1);      // 0 = wyłączone, 1 = włączone
  s->set_aec2(s, 0);           // 0 = wyłączone, 1 = włączone
  s->set_ae_level(s, 0);       // -2 to 2
  s->set_aec_value(s, 300);    // 0 to 1200
  s->set_hmirror(s, 0);        // 0 = wyłączone, 1 = włączone
  s->set_vflip(s, 0);          // 0 = wyłączone, 1 = włączone
  
  Serial.println("Inicjalizacja kamery powiodła się!");
  return true;
}

void initDisplay() {
  // Inicjalizacja wyświetlacza OLED
  Wire.begin(OLED_SDA, OLED_SCL);
  
  // Zresetuj wyświetlacz (jeśli pin RESET jest dostępny)
  if (OLED_RST >= 0) {
    pinMode(OLED_RST, OUTPUT);
    digitalWrite(OLED_RST, LOW);
    delay(20);
    digitalWrite(OLED_RST, HIGH);
  }
  
  // Inicjalizacja wyświetlacza SSD1306
  if(!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
    Serial.println(F("Inicjalizacja SSD1306 nie powiodła się"));
    // Nieskończona pętla
    for(;;);
  }
  
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
}

void showCameraInfo() {
  display.clearDisplay();
  display.setCursor(0, 0);
  display.setTextSize(1);
  display.println("T-Camera S3");
  
  display.setCursor(0, 16);
  display.println("Kamera OK");
  
  // Wyświetl IP, jeśli połączono z WiFi
  if (WiFi.status() == WL_CONNECTED) {
    display.setCursor(0, 32);
    display.print("IP: ");
    display.println(ip.toString());
  } else {
    display.setCursor(0, 32);
    display.println("Brak WiFi");
  }
  
  display.display();
}

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();
  
  // Inicjalizacja wyświetlacza
  initDisplay();
  
  display.clearDisplay();
  display.setCursor(0, 16);
  display.println("Inicjalizacja...");
  display.display();
  
  // Inicjalizacja kamery
  if (!initCamera()) {
    display.clearDisplay();
    display.setCursor(0, 16);
    display.println("Błąd kamery!");
    display.display();
    
    // Mruganie diodą podczas błędu (opcjonalnie)
    while (true) {
      delay(1000);
    }
  }
  
  // Połączenie z WiFi (opcjonalnie)
  if (strlen(ssid) > 0) {
    WiFi.begin(ssid, password);
    WiFi.setSleep(false);
    
    int timeout = 0;
    while (WiFi.status() != WL_CONNECTED && timeout < 20) {
      delay(500);
      Serial.print(".");
      display.clearDisplay();
      display.setCursor(0, 16);
      display.println("Łączenie z WiFi...");
      display.setCursor(0, 32);
      display.print(timeout);
      display.print("/20");
      display.display();
      timeout++;
    }
    
    if (WiFi.status() == WL_CONNECTED) {
      ip = WiFi.localIP();
      Serial.println("WiFi połączone");
      Serial.print("IP: ");
      Serial.println(ip);
      
      // Uruchomienie serwera kamery (opcjonalnie)
      startCameraServer();
    } else {
      Serial.println("Nie udało się połączyć z WiFi");
    }
  }
  
  showCameraInfo();
}

void loop() {
  // Tu możesz dodać dodatkowe funkcje, np. odczyt PIR, przycisków, itp.
  delay(1000);
}

// Kod serwera kamery - musimy go zaimplementować, jeśli chcemy udostępnić obraz przez WiFi
// Ta funkcja powinna być zdefiniowana w osobnym pliku, np. app_httpd.cpp
void startCameraServer() {
  // Tutaj powinna być implementacja serwera HTTP dla podglądu kamery
  Serial.println("Serwer kamery uruchomiony");
}

Serial monitor 

 

15:15:34.132 -> E (226) cam_hal: cam_dma_config(301): frame buffer malloc failedE (1501) cam_hal: cam_dma_config(301): frame buffer malloc failed
15:15:34.132 -> E (1501) cam_hal: cam_config(390): cam_dma_config failed
15:15:34.133 -> E (1501) gdma: gdma_disconnect(314): no peripheral is connected to the channel
15:15:34.133 -> E (1508) camera: Camera config failed with error 0xffffffff

 

[99teki]

- jaka wersja Arduino oraz wersja board esp32.

- ja np. pracuje na Arduino 2.3.4 oraz board esp32 2.0.17. (czasami wersja 2.0.6)

 

[Michal88]

Arduino 2.3.4 I zdjęcie całej płytki

https://zapodaj.net/plik-YNcv1zWbQK

 

https://zapodaj.net/plik-hAr8EtHVJ6