update esp32cam

dispositivos/esp32-cam/README.md

@@ -9,24 +9,6 @@ Dispositivo base para trabajar con ESP32-CAM.
 - `capture.py` Script para capturar una fotografía
 - `process.py` Script para detectar colores
 
-## Firmware
-
-La placa ESP32-CAM se puede utilizar con MicroPython. Utilizaremos el driver `micropython-camera-driver` de [Mauro Riva](https://github.com/lemariva). Se puede descargar desde el repositorio en [GitHub](https://github.com/lemariva/micropython-camera-driver).
-
-Como la placa no posee conexión USB, hay que utilizar un adaptador USB-TTL. Las conexiones son las que muestra la imagen.
-
-![Conexiones FTDI <> ESP32-CAM](./FTDI.png)
-
-Para instalarlo:
-
-```bash
-esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
-```
-
-```bash
-esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 micropython_camera_feeeb5ea3_esp32_idf4_4.bin
-```
-
 ## Pinout
 
 ![Pinout ESP32-CAM](./ESP32-CAM%20Pinout.jpg)
@@ -66,9 +48,173 @@ esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 micropython_ca
 | GPIO 27   | SCL SIOC_GPIO_NUM         | OV2640                |
 | GPIO 32   | POWER PIN PWDN_GPIO_NUM   | OV2640                |
 
+## Firmware
+
+La placa ESP32-CAM se puede utilizar con MicroPython. Utilizaremos el driver `micropython-camera-driver` de [Mauro Riva](https://github.com/lemariva). Se puede descargar desde el repositorio en [GitHub](https://github.com/lemariva/micropython-camera-driver).
+
+Como la placa no posee conexión USB, hay que utilizar un adaptador USB-TTL. Las conexiones son las que muestra la imagen.
+
+![Conexiones FTDI <> ESP32-CAM](./FTDI.png)
+
+Para instalarlo:
+
+```bash
+esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
+```
+
+```bash
+esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 micropython_camera_feeeb5ea3_esp32_idf4_4.bin
+```
+
+## Métodos
+
+**init**, activa e inicializa la cámara.
+
+```python
+# Formato
+camera.init(0, parámetro=valor, …)
+```
+
+- `xclk_freq_hz` = `[10000000, 20000000 ]`: Frecuencia de reloj de la cámara en Hz
+- `frame_size`: Tamaño de la imagen capturada
+- `pixel_format` = `[JPEG, YUV422, GRAYSCALE, RGB565]`: Formato de la imagen capturada
+- `jpeg_quality` = `[10..63]`: Calidad de la imagen capturada, los valores menores representan mayor calidad
+- `fb_location` = `[DRAM, PSRAM]`: Ubicación de la imagen capturada, es conveniente usar PSRAM.
+
+```python
+# Ejemplo
+camera.init(0, format=camera.JPEG, fb_location=camera.PSRAM)
+```
+
+**deinit**, desactiva la cámara.
+
+```python
+# Ejemplo
+camera.deinit()
+```
+
+**flip**, cambia la orientación vertical de la imagen.
+
+- `0`: Imagen normal
+- `1`: Imagen invertida
+
+```python
+# Ejemplo
+camera.flip(0)
+```
+
+**mirror**, cambia la orientación horizontal de la imagen.
+
+- `0`: Imagen normal
+- `1`: Imagen invertida
+
+```python
+# Ejemplo
+camera.mirror(1)
+```
+
+**framesize**, especifica el tamaño y resolución de la imagen capturada.
+
+- `FRAME_96X96` = 96*96
+- `FRAME_QQVGA` = 160*120
+- `FRAME_QCIF` = 176*144
+- `FRAME_HQVGA` = 240*160
+- `FRAME_240X240` = 240*240
+- `FRAME_QVGA` = 320*240
+- `FRAME_CIF` = 352*288
+- `FRAME_HVGA` = 480*320
+- `FRAME_VGA` = 640*480
+- `FRAME_SVGA` = 800*600
+- `FRAME_XGA` = 1024*768
+- `FRAME_HD` = 1280*720
+- `FRAME_SXGA` = 1280*1024
+- `FRAME_UXGA` = 1600*1200
+- `FRAME_FHD` = 1920*1080
+- `FRAME_P_HD` = 2048*1152
+- `FRAME_P_3MP` = 2048*1536
+- `FRAME_QXGA` = 2048*1536
+- `FRAME_QHD` = 2560*1440
+- `FRAME_WQXGA` = 2560*1600
+- `FRAME_P_FHD`
+- `FRAME_QSXGA` = 2560*2048
+
+```python
+# Ejemplo
+camera.framesize(camera.FRAME_CIF)
+```
+
+**quality**, especifica la calidad de la imagen capturada. Varia entre 10 (calidad alta) y 63 (calidad baja).
+
+```python
+# Ejemplo
+camera.quality(10)
+```
+
+**contrast**, especifica el contraste de la imagen. Varia entre -2 (contraste bajo) y 2 (contraste alto). Por omisión vale 0.
+
+```python
+# Ejemplo
+camera.contrast(1)
+```
+
+**saturation**, especifica la saturación (intensidad de los colores) de la imagen. Varia entre -2 (baja intensidad) y 2 (alta intensidad). Por omisión vale 0.
+
+```python
+# Ejemplo
+camera.saturation(-1)
+```
+
+**brightness**, especifica el brillo de la imagen. Varia entre -2 (mas bajo) y 2 (mas alto). Por omisión vale 0.
+
+```python
+# Ejemplo
+camera.brightness(1)
+```
+
+**speffect**, aplica un efecto a la imagen.
+
+- `EFFECT_NONE`: sin efecto, valor por omisión
+- `EFFECT_NEG`: negativo
+- `EFFECT_BW`: escala de grises
+- `EFFECT_RED`: rojizo
+- `EFFECT_GREEN`: verdoso
+- `EFFECT_BLUE`: azulado
+- `EFFECT_RETRO`: sepia
+
+```python
+# Ejemplo
+camera.speffect(camera.EFFECT_NONE)
+```
+
+**whitebalance**, equilibra los niveles de los colores básicos (Rojo, Verde y Azul).
+
+- `WB_NONE`: sin compensación
+- `WB_SUNNY`: compensa días soleados
+- `WB_CLOUDY`: compensa días nublados
+- `WB_OFFICE`: compensa iluminación fría
+- `WB_HOME`: compensa iluminación cálida
+
+```python
+# Ejemplo
+camera.whitebalance(camera.WB_NONE)
+```
+
+**capture**, captura una imagen.
+
+```python
+# Ejemplo
+img = camera.capture()
+```
+
+## Ejemplo de captura
+
+`capture.py` permite capturar una foto 640*480 y almacenarla en PSRAM.
+
+![Captura](./IMG1.jpg)
+
 ## Recursos
 
 - [Aprende a programar la ESP32-CAM en Micropython. Parte 1](https://www.profetolocka.com.ar/2022/04/18/aprende-a-programar-la-esp32-cam-en-micropython-parte-1/)
 - [Aprende a programar la ESP32-CAM en Micropython. Parte 2](https://www.profetolocka.com.ar/2022/04/25/aprende-a-programar-la-esp32-cam-en-micropython-parte-2/)
 - [ESP32 CAM introducción y primeros pasos](https://programarfacil.com/esp32/esp32-cam/)
-- [ESP32-CAM: Machine Vision Tips, Camera Guides and Projects](https://www.arducam.com/esp32-machine-vision-learning-guide/)
+- [ESP32-CAM: Machine Vision Tips, Camera Guides and Projects](https://www.arducam.com/esp32-machine-vision-learning-guide/)

dispositivos/esp32-cam/capture.py

@@ -1,22 +1,43 @@
-# Código para Capturar una Imagen
-# https://lemariva.com/blog/2020/06/micropython-support-cameras-m5camera-esp32-cam-etc
+# Captura de fotos con ESP32CAM
+# Creado el 7 de junio de 2024
 
-import esp
-import machine
-import time
 import camera
+import machine
+from time import sleep
 
-# Inicializar la cámara
-camera.init(0, format=camera.JPEG)
+flash = machine.Pin(4, machine.Pin.OUT)
 
-# Capturar una imagen
-buf = camera.capture()
+foto_count = 1
 
-# Guardar la imagen en un archivo
-#with open("captura.jpg", "wb") as f:
-#    f.write(buf)
+while (True):
+
+    nombre = "IMG"+str(foto_count)+".jpg"
+    print(nombre)
+
+    try:
+        camera.init(0, format=camera.JPEG, fb_location=camera.PSRAM)
+        camera.framesize(camera.FRAME_VGA)
 
-print("Imagen guardada como captura.jpg")
+        flash.value(1)
+        sleep (0.5)
 
-# Finalizar la cámara
-camera.deinit()
+        # Captura la imagen
+        img = camera.capture()
+        print("Tamaño=",len(img))
+
+        flash.value(0)
+        camera.deinit ()
+
+        # Guardar la imagen en el sistema de archivos
+        imgFile = open(nombre, "wb")
+        imgFile.write(img)
+        imgFile.close()
+
+        foto_count += 1
+
+        sleep (10)
+
+    except Exception as err:
+
+        print("Error= "+str (err))
+        sleep(2)

dispositivos/esp32-cam/process.py

@@ -1,7 +1,7 @@
 # Detección de Colores con MicroPython
 #
-# Para realizar la detección de colores, puedes usar técnicas básicas de procesamiento
-# de imágenes. Aquí hay un ejemplo simple para detectar un color específico en la imagen.
+# Para realizar la detección de colores, podes usar técnicas básicas de procesamiento
+# de imágenes. Este ejemplo permite detectar un color específico en la imagen.
 # Capturar y Procesar la Imagen:
 
 import esp