Kategória: Arduino.

OV7670

Reklámként dobta fel nekem a pár dolláros, OV7670 típusú Arduino kamerát, melynek nem tudtam ellenállni. Végül ez lett a legbonyolultabb Arduino eszköz, mellyel valaha találkoztam. A kód megértéséhez az Arduino chipjének legmélyebb bugyraiba kellett beleásnom magamat, és egy igen jelentős részét mind a mai napig nem értem.

A másik, amit érdemes rögtön az elején tisztázni: ezzel nem lehet minőségi fotókat készíteni. Élesben szinte biztosan nem tudjuk használni (pl. arra, hogy ha a mozgásérzékelő mozgást érzékel, akkor készítsen automatikusan pár fotót, amit mondjuk egy kártyára ment), és az összetettsége miatt oktatási célra is alkalmatlan. Igazából egy dologra jó csak: ha valaki szereti a bütykölős kihívásokat, annak megfelelő elfoglaltságot nyújt elég hosszú időre.

A következő leírás alapján készítettem el a projektet: https://create.arduino.cc/projecthub/techmirtz/visual-capturing-with-ov7670-on-arduino-069ebb

Bekötés

Maga az eszköz 18 lábat tartalmaz, és a bekötéshez a rengeteg kábelen kívül szükségünk van két 4,7kΩ és két 10 kΩ ellenállásra. Célszerű külön áramforrást biztosítani az eszköznek, és a külön áramforrás - pólusát összekötni az Arduino GND-vel. Bekötés:

• OV7670 3v3 → 3,3 V
• OV7670 GND → GND
• OV7670 SIOC → Arduno A5
• OV7670 SIOC → 10 kΩ → 3,3 V
• OV7670 SIOD → Arduno A4
• OV7670 VSYNC → Arduino D3
• OV7670 HREF → Arduino D8
• OV7670 PCLK → Arduino D2
• OV7670 XCLK → 4,7 kΩ → Arduino D11
• OV7670 XCLK → 4,7 kΩ (ez egy másik ellenállás) → GND
• OV7670 D7 → Arduino D7
• OV7670 D6 → Arduino D6
• OV7670 D5 → Arduino D5
• OV7670 D4 → Arduino D4
• OV7670 D3 → Arduino D3
• OV7670 D2 → Arduino D2
• OV7670 D1 → Arduino D1
• OV7670 D0 → Arduino D0
• OV7670 RESET → 3,3 V
• OV7670 PWDN → GND

Az alábbi ábra (mely mindkét fent hivatkozott oldalon megtalálható) a bekötést illusztrálja:

Az említett oldalakon azt is megtaláljuk, hogy melyik láb micsoda.

Arduino kód

Az Arduino kódja lényegesen hosszabb, és nagyságrendekkel bonyolultabb, mint amihez hozzászoktunk, íme:

#include <stdint.h>
#include <util/twi.h>
#include <util/delay.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
 
#define F_CPU 16000000UL
#define COM7_RESET 0x80
#define COM8_AEC 0x01
#define COM8_AECSTEP 0x40
#define COM8_AGC 0x04
#define COM8_AWB 0x02
#define COM8_BFILT 0x20
#define COM8_FASTAEC 0x80
#define COM11_EXP 0x02
#define COM11_HZAUTO 0x10
#define COM13_UVSAT 0x40
#define COM15_R00FF 0xc0
#define COM16_AWBGAIN 0x08
#define REG_AEB 0x25
#define REG_AECH 0x10
#define REG_AEW 0x24
#define REG_BD50MAX 0xa5
#define REG_BD60MAX 0xab
#define REG_BLUE 0x01
#define REG_COM1 0x04
#define REG_COM2 0x09
#define REG_COM3 0x0c
#define REG_COM4 0x0d
#define REG_COM5 0x0e
#define REG_COM6 0x0f
#define REG_COM7 0x12
#define REG_COM8 0x13
#define REG_COM9 0x14
#define REG_COM10 0x15
#define REG_COM11 0x3b
#define REG_COM12 0x3c
#define REG_COM13 0x3d
#define REG_COM14 0x3e
#define REG_COM15 0x40
#define REG_COM16 0x41
#define REG_COM17 0x42
#define REG_EDGE 0x3f
#define REG_GAIN 0x00
#define REG_GFIX 0x69
#define REG_HAECC1 0x9f
#define REG_HAECC2 0xa0
#define REG_HAECC3 0xa6
#define REG_HAECC4 0xa7
#define REG_HAECC5 0xa8
#define REG_HAECC6 0xa9
#define REG_HAECC7 0xaa
#define REG_HREF 0x32
#define REG_HSTART 0x17
#define REG_HSTOP 0x18
#define REG_HSYEN 0x31
#define REG_HSYST 0x30
#define REG_MVFP 0x1e
#define REG_RED 0x02
#define REG_REG76 0x76
#define REG_RGB444 0x8c
#define REG_TSLB 0x3a
#define REG_VPT 0x26
#define REG_VREF 0x03
#define REG_VSTART 0x19
#define REG_VSTOP 0x1a
#define camAddr_RD 0x43
#define camAddr_WR 0x42
 
struct Regval {
  uint8_t reg_num;
  uint16_t value;
};
 
const struct Regval qvga_ov7670[] PROGMEM = {
  { REG_COM14, 0x19 },
  { 0x72, 0x11 },
  { 0x73, 0xf1 },
  { REG_HSTART, 0x16 },
  { REG_HSTOP, 0x04 },
  { REG_HREF, 0xa4 },
  { REG_VSTART, 0x02 },
  { REG_VSTOP, 0x7a },
  { REG_VREF, 0x0a },
  { 0xff, 0xff }
};
 
const struct Regval yuv422_ov7670[] PROGMEM = {
  { REG_COM7, 0x00 },
  { REG_RGB444, 0x00 },
  { REG_COM1, 0x00 },
  { REG_COM15, COM15_R00FF },
  { REG_COM9, 0x6A },
  { 0x4f, 0x80 },
  { 0x50, 0x80 },
  { 0x51, 0x00 },
  { 0x52, 0x22 },
  { 0x53, 0x5e },
  { 0x54, 0x80 },
  { REG_COM13, COM13_UVSAT },
  { 0xff, 0xff }
};
 
const struct Regval ov7670_default_regs[] PROGMEM = {
  { REG_COM7, COM7_RESET },
  { REG_TSLB, 0x04 },
  { REG_COM7, 0x00 },
  { REG_HSTART, 0x13 }, { REG_HSTOP, 0x01 },
  { REG_HREF, 0xb6 }, { REG_VSTART, 0x02 },
  { REG_VSTOP, 0x7a }, { REG_VREF, 0x0a },
  { REG_COM3, 0x00 }, { REG_COM14, 0x00 },
  { 0x70, 0x3a }, { 0x71, 0x35 },
  { 0x72, 0x11 }, { 0x73, 0xf0 },
  { 0xa2, 0x01 }, { REG_COM10, 0x0 },
  { 0x7a, 0x20 }, { 0x7b, 0x10 },
  { 0x7c, 0x1e }, { 0x7d, 0x35 },
  { 0x7e, 0x5a }, { 0x7f, 0x69 },
  { 0x80, 0x76 }, { 0x81, 0x80 },
  { 0x82, 0x88 }, { 0x83, 0x8f },
  { 0x84, 0x96 }, { 0x85, 0xa3 },
  { 0x86, 0xaf }, { 0x87, 0xc4 },
  { 0x88, 0xd7 }, { 0x89, 0xe8 },
  { REG_COM8, COM8_FASTAEC | COM8_AECSTEP },
  { REG_GAIN, 0x00 }, { REG_AECH, 0x00 },
  { REG_COM4, 0x40 }, { REG_COM9, 0x18 },
  { REG_BD50MAX, 0x05 }, { REG_BD60MAX, 0x07 },
  { REG_AEW, 0x95 }, { REG_AEB, 0x33 },
  { REG_VPT, 0xe3 }, { REG_HAECC1, 0x78 },
  { REG_HAECC2, 0x68 }, { 0xa1, 0x03 },
  { REG_HAECC3, 0xd8 }, { REG_HAECC4, 0xd8 },
  { REG_HAECC5, 0xf0 }, { REG_HAECC6, 0x90 },
  { REG_HAECC7, 0x94 },
  { REG_COM8, COM8_FASTAEC | COM8_AECSTEP | COM8_AGC | COM8_AEC },
  { 0x30, 0x00 }, { 0x31, 0x00 },
  { REG_COM5, 0x61 }, { REG_COM6, 0x4b },
  { 0x16, 0x02 }, { REG_MVFP, 0x07 },
  { 0x21, 0x02 }, { 0x22, 0x91 },
  { 0x29, 0x07 }, { 0x33, 0x0b },
  { 0x35, 0x0b }, { 0x37, 0x1d },
  { 0x38, 0x71 }, { 0x39, 0x2a },
  { REG_COM12, 0x78 }, { 0x4d, 0x40 },
  { 0x4e, 0x20 }, { REG_GFIX, 0x00 },
  { 0x74, 0x10 },
  { 0x8d, 0x4f }, { 0x8e, 0x00 },
  { 0x8f, 0x00 }, { 0x90, 0x00 },
  { 0x91, 0x00 }, { 0x96, 0x00 },
  { 0x9a, 0x00 }, { 0xb0, 0x84 },
  { 0xb1, 0x0c }, { 0xb2, 0x0e },
  { 0xb3, 0x82 }, { 0xb8, 0x0a },
  { 0x43, 0x0a }, { 0x44, 0xf0 },
  { 0x45, 0x34 }, { 0x46, 0x58 },
  { 0x47, 0x28 }, { 0x48, 0x3a },
  { 0x59, 0x88 }, { 0x5a, 0x88 },
  { 0x5b, 0x44 }, { 0x5c, 0x67 },
  { 0x5d, 0x49 }, { 0x5e, 0x0e },
  { 0x6c, 0x0a }, { 0x6d, 0x55 },
  { 0x6e, 0x11 }, { 0x6f, 0x9e },
  { 0x6a, 0x40 }, { REG_BLUE, 0x40 },
  { REG_RED, 0x60 },
  { REG_COM8, COM8_FASTAEC | COM8_AECSTEP | COM8_AGC | COM8_AEC | COM8_AWB },
  { 0x4f, 0x80 }, { 0x50, 0x80 },
  { 0x51, 0x00 },    { 0x52, 0x22 },
  { 0x53, 0x5e }, { 0x54, 0x80 },
  { 0x58, 0x9e },
  { REG_COM16, COM16_AWBGAIN }, { REG_EDGE, 0x00 },
  { 0x75, 0x05 }, { REG_REG76, 0xe1 },
  { 0x4c, 0x00 }, { 0x77, 0x01 },
  { REG_COM13, 0x48 }, { 0x4b, 0x09 },
  { 0xc9, 0x60 }, { 0x56, 0x40 },
  { 0x34, 0x11 }, { REG_COM11, COM11_EXP | COM11_HZAUTO },
  { 0xa4, 0x82 }, { 0x96, 0x00 },
  { 0x97, 0x30 }, { 0x98, 0x20 },
  { 0x99, 0x30 }, { 0x9a, 0x84 },
  { 0x9b, 0x29 }, { 0x9c, 0x03 },
  { 0x9d, 0x4c }, { 0x9e, 0x3f },
  { 0x78, 0x04 },
  { 0x79, 0x01 }, { 0xc8, 0xf0 },
  { 0x79, 0x0f }, { 0xc8, 0x00 },
  { 0x79, 0x10 }, { 0xc8, 0x7e },
  { 0x79, 0x0a }, { 0xc8, 0x80 },
  { 0x79, 0x0b }, { 0xc8, 0x01 },
  { 0x79, 0x0c }, { 0xc8, 0x0f },
  { 0x79, 0x0d }, { 0xc8, 0x20 },
  { 0x79, 0x09 }, { 0xc8, 0x80 },
  { 0x79, 0x02 }, { 0xc8, 0xc0 },
  { 0x79, 0x03 }, { 0xc8, 0x40 },
  { 0x79, 0x05 }, { 0xc8, 0x30 },
  { 0x79, 0x26 }, { 0xff, 0xff }
};
 
void error_led(){
  DDRB |= 32; // make sure led is output
  while (true) { //wait for reset
    PORTB ^= 32; // toggle led
    _delay_ms(100);
  }
}
 
void twiStart() {
  TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); // send start
  while (!(TWCR & (1 << TWINT))); // wait for start to be transmitted
  if ((TWSR & 0xF8) != TW_START) {
    error_led();
  }
}
 
void twiWriteByte(uint8_t data, uint8_t type) {
  TWDR = data;
  TWCR = _BV(TWINT) | _BV(TWEN);
  while (!(TWCR & (1 << TWINT))) {}
  if ((TWSR & 0xF8) != type) {
    error_led();
  }
}
 
void twiAddr(uint8_t addr, uint8_t typeTWI){
  TWDR = addr; // send address
  TWCR = _BV(TWINT) | _BV(TWEN); // clear interrupt to start transmission
  while ((TWCR & _BV(TWINT)) == 0) {} // wait for transmission
  if ((TWSR & 0xF8) != typeTWI) {
    error_led();
  }
}
 
void wrReg(uint8_t reg, uint8_t dat){
  twiStart();
  twiAddr(camAddr_WR, TW_MT_SLA_ACK);
  twiWriteByte(reg, TW_MT_DATA_ACK);
  twiWriteByte(dat, TW_MT_DATA_ACK);
  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
  _delay_ms(1);
}
 
static uint8_t twiRd(uint8_t nack){
  if (nack) {
    TWCR = _BV(TWINT) | _BV(TWEN);
    while ((TWCR & _BV(TWINT)) == 0);
    if ((TWSR & 0xF8) != TW_MR_DATA_NACK) {
      error_led();
    }
    return TWDR;
  } else {
    TWCR = _BV(TWINT) | _BV(TWEN) | _BV(TWEA);
    while ((TWCR & _BV(TWINT)) == 0);
    if ((TWSR & 0xF8) != TW_MR_DATA_ACK) {
      error_led();
    }
    return TWDR;
  }
}
 
uint8_t rdReg(uint8_t reg) {
  uint8_t dat;
  twiStart();
  twiAddr(camAddr_WR, TW_MT_SLA_ACK);
  twiWriteByte(reg, TW_MT_DATA_ACK);
  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
  _delay_ms(1);
  twiStart();
  twiAddr(camAddr_RD, TW_MR_SLA_ACK);
  dat = twiRd(1);
  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
  _delay_ms(1);
  return dat;
}
 
void wrSensorRegs8_8(const struct Regval reglist[]) {
  uint8_t reg_addr, reg_val;
  const struct Regval *next = reglist;
  while ((reg_addr != 0xff) | (reg_val != 0xff)) {
    reg_addr = pgm_read_byte(&next->reg_num);
    reg_val = pgm_read_byte(&next->value);
    wrReg(reg_addr, reg_val);
    next++;
  }
}
 
void setColor(){
  wrSensorRegs8_8(yuv422_ov7670);
}
 
void setRes(){
  wrReg(REG_COM3, 4); // REG_COM3 enable scaling
  wrSensorRegs8_8(qvga_ov7670);
}
 
void camInit(){
  wrReg(0x12, 0x80);
  _delay_ms(100);
  wrSensorRegs8_8(ov7670_default_regs);
  wrReg(REG_COM10, 32); //PCLK does not toggle on HBLANK.
}
 
void arduinoUnoInut() {
  cli(); //disable interrupts
 
  DDRB |= (1 << 3); // make pin 11 output
  ASSR &= ~(_BV(EXCLK) | _BV(AS2));
  TCCR2A = (1 << COM2A0) | (1 << WGM21) | (1 << WGM20);
  TCCR2B = (1 << WGM22) | (1 << CS20);
  OCR2A = 0;
  DDRC &= ~15; //low d0-d3 camera
  DDRD &= ~252; //d7-d4 and interrupt pins
  _delay_ms(3000);
 
  //set up twi for 100khz
  TWSR &= ~3; //disable prescaler for TWI
  TWBR = 72; //set to 100khz
 
  UBRR0H = 0; //enable serial
  UBRR0L = 1; //0 = 2M baud rate. 1 = 1M baud. 3 = 0.5M. 7 = 250k 207 is 9600 baud rate.
  UCSR0A |= 2; //double speed aysnc
  UCSR0B = (1 << RXEN0) | (1 << TXEN0); //Enable receiver and transmitter
  UCSR0C = 6; //async 1 stop bit 8bit char no parity bits
}
 
void setup() {
  arduinoUnoInut();
  camInit();
  setRes();
  setColor();
  wrReg(0x11, 10);
}
 
void loop() {
  char *str = PSTR("*RDY*");
  do {
    while (!(UCSR0A & (1 << UDRE0)));
    UDR0 = pgm_read_byte_near(str);
    while (!(UCSR0A & (1 << UDRE0)));
  } while (pgm_read_byte_near(++str));
 
  while (!(PIND & 8));
  while ((PIND & 8));
 
  int y = 240;
  while (y > 0) {
    y--;
    int x = 320;
    while (x > 0) {
      x--;
      while (PIND & 4);
      UDR0 = (PINC & 15) | (PIND & 240);
      while (!(UCSR0A & (1 << UDRE0)));
      while (!(PIND & 4));
      while (PIND & 4);
      while (!(PIND & 4));
    }
  }
  _delay_ms(100);
}

A kódban nagyon sok hardver szintű kódelem található: a megszokott Arduino függvényhívások helyett közvetlenül állítja a regisztereket. Ezt a kódot én magam sem értem teljes egészében: nem tudom, a program elején található hexadecimális kódok mit jelentenek. A kód többi részét komoly nehézségek árán valamelyest sikerült megértenem, melyről a Hardverközeli Arduino programozás oldalon olvashatunk részletesen.

Az eredeti forrás ennek több mint kétszerese; ennyire sikerült leredukálnom a hosszát. Bizonyos részeket megpróbáltam átírni a szokásos Arduino függvényhívásokra, viszont azt tapasztaltam, hogy az eredmény fekete foltokat tartalmazott. Ebből arra következtetek, hogy mindenképpen a legalacsonyabb szintű hozzáféréssel tudjuk csak programozni, mert különben túl lassú lesz.

Számítógépen futó kód

A tesztelés során az Arduino-nak össze kell lennie kötve a számítógéppel, és a számítógépen egy Java kódot kell futtatnunk. Persze ez sem olyan egyszerű…

• Ellenőrizzük, hogy van-e a számítógépünkön Java fordító (javac -version) és Java futtató (java -version). Ha nincs, töltsük le és telepítsük fel a JDK-t. Fontos, hogy 32 bites legyen, és a leírásban 1.8-as szerepel, így a letöltő oldal a következő: https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html. Letöltés és feltelepítés után a Java bin könyvtárát adjuk hozzá a PATH környezeti változóhoz: Edit the system environment variables -> Environment Variables … -> alul Path -> Edit … -> adjuk hozzá a megfelelő könyvtárat, pl. c:\Program Files (x86)\Java\jdk1.8.0_211\bin.
• Töltsük le ezt a fájlt: [[extra.rar]].
• A benne található win32com.dll fájlt másoljuk a JDK bin könyvtárába, pl. c:\Program Files (x86)\Java\jdk1.8.0_211\bin\.
• A lib\comm.jar fájt másoljuk a JRE lib\ext könyvtárába, pl. c:\Program Files (x86)\Java\jre1.8.0_211\lib\ext\.
• A lib\javax.comm.properties fájlt másoljuk a JRE lib könyvtárába, pl. c:\Program Files (x86)\Java\jre1.8.0_211\lib\.

A tömörített fájlt tartalmaz Java kódot is, ezt viszont a következőre egyszerűsítettem. A fájl neve legyen SimpleRead.java.

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
 
import javax.comm.CommPortIdentifier;
import javax.comm.SerialPort;
 
public class SimpleRead {
    private static final int WIDTH = 320;
    private static final int HEIGHT = 240;
 
    public static void main(String[] args) {
        if (args.length != 2) {
            System.out.println("Usage: SimpleRead port outputdir");
            System.out.println("E.g.: SimpleRead COM3 c:/out/");
            return;
        }
 
        Enumeration portList = CommPortIdentifier.getPortIdentifiers();
        CommPortIdentifier portId = null;
 
        while (portList.hasMoreElements()) {
            portId = (CommPortIdentifier) portList.nextElement();
            if (portId.getName().equals(args[0])) {
                break;
            }
        }
        if (portId != null) {
            int[][] rgb = new int[HEIGHT][WIDTH];
            int[][] rgbTranspose = new int[WIDTH][HEIGHT];
 
            try {
                SerialPort serialPort = (SerialPort) portId.open("SimpleReadApp", 1000);
                InputStream inputStream = serialPort.getInputStream();
                serialPort.setSerialPortParams(1000000, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
                int counter = 0;
                while (true) {
                    System.out.println("Looking for image");
                    boolean isImageStart = false;
                    while (!isImageStart) {
                        isImageStart = true;
                        char[] command = {'*', 'R', 'D', 'Y', '*'};
                        for (int index = 0; index < command.length; index++) {
                            if (!(command[index] == (char)inputStream.read())) {
                                isImageStart = false;
                                break;
                            }
                        }
                    }
                    System.out.println("Found image: " + counter);
                    for (int y = 0; y < HEIGHT; y++) {
                        for (int x = 0; x < WIDTH; x++) {
                            int result = (char)inputStream.read();
                            rgb[y][x] = ((result & 0xFF) << 16) | ((result & 0xFF) << 8) | (result & 0xFF);
                        }
                    }
                    for (int y = 0; y < HEIGHT; y++) {
                        for (int x = 0; x < WIDTH; x++) {
                            rgbTranspose[x][y] = rgb[y][x];
                        }
                    }
                    saveBMP(args[1] + (counter++) + ".bmp", rgbTranspose);
                    System.out.println("Saved image: " + counter);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("Port " + args[0] + " not found.");
        }            
    }
 
    public static void saveBMP(String filename, int[][] rgbValues) throws IOException {
        byte offset = 54;
 
        FileOutputStream fos = new FileOutputStream(new File(filename));
        byte[] bytes = new byte[54 + 3 * rgbValues.length * rgbValues[0].length];
 
        bytes[0] = 'B';
        bytes[1] = 'M';
 
        bytes[5] = (byte)bytes.length;
        bytes[4] = (byte)(bytes.length >> 8);
        bytes[3] = (byte)(bytes.length >> 16);
        bytes[2] = (byte)(bytes.length >> 24);
 
        bytes[10] = offset;            
        bytes[14] = 40;
 
        int width = rgbValues[0].length;
        bytes[18] = (byte)width;
        bytes[19] = (byte)(width >> 8);
        bytes[20] = (byte)(width >> 16);
        bytes[21] = (byte)(width >> 24);
 
        int height = rgbValues.length;
        bytes[22] = (byte)height;
        bytes[23] = (byte)(height >> 8);
        bytes[24] = (byte)(height >> 16);
        bytes[25] = (byte)(height >> 24);
 
        bytes[26] = 1;
        bytes[28] = 24;
 
        for (int row = 0; row < height; row++) {
            for (int column = 0; column < width; column++) {
                int rgb = rgbValues[row][column];
                int index = offset + 3 * (column + width * row);
                bytes[index + 2] = (byte)(rgb >> 16);
                bytes[index + 1] = (byte)(rgb >> 8);
                bytes[index] = (byte)rgb;
            }
        }
 
        fos.write(bytes);
        fos.close();
    }
}

Ez - azon túl, hogy egy fájlból áll - paraméterezhető: megadható neki egyrészt, hogy melyik portról olvassa az adatokat (a fenti példákban 5 lehetséges portra van "bedrótozva"), másrészt a kimeneti könyvtár is beállítható. Fordítás:

javac SimpleRead.java

Teszt

Hozzuk létre a megfelelő könyvtárat. Majd indítsuk el az olvasó programot a következőképpen:

java SimpleRead COM3 c:/out/

A portot állítsuk be a megfelelőre, amit az Arduino IDE-ből is ki tudunk olvasni, és a kimeneti könyvtárat is állítsuk be megfelelően. Az Arduino legyen rákapcsolva a számítógép soros portjára.

Ha mindent jól csináltunk, akkor a kimeneti könyvtárban megjelennek az elkészült képek. Ezek várhatóan először igen elmosódottak lesznek. Próbáljuk meg az objektív elcsavarásával és/vagy a távolság megváltoztatásával módosítani a fókuszt. A megvilágítás legyen megfelelő. Valamint türelmesnek kell lennünk: idővel adott beállításokkal is javulhat az eredmény. Túl nagy csodára sajnos nem számíthatunk; az alábbi képet elég sok próbálkozást követő tudtam elkészíteni:

ESP32-CAM + OV2640

A fenti leírás elkészítése óta eltelt pár év. Örömmel vettem Tóth Andrásnak, a Mikrovezérlő Blog és Webáruház (https://www.microcontroller.hu/) tulajdonosa felkérését, hogy választhatok egy eszközt a készletből, és készítsek róla leírást. Mivel korábban nagyon nehézkes volt a kamera használata, ezen viszont egyből látszott, hogy lényegesen egyszerűbb lesz, erre esett a választásom. Megvásárolható a https://www.microcontroller.hu/termek/esp32-cam-ov2640-kameraval/ oldalon.

Egy másik magyar nyelvű leírás erről az eszközről: https://bitekmindenhol.blog.hu/2019/10/23/esp32_kamera.

Szükséges eszközök

Az alábbiakra lesz szükségünk a projekt végrehajtásához:

• ESP32-CAM mikrokontroller OV2640 kamerával,
• internetkapcsolat (vagy Arduino IDE és az ESP32 alaplapok telepítve kell, hogy legyenek),
• wifi (nem elég a LAN, muszáj a wifi hálózat),
• laptop,
• (USB-TTL átalakító és 5 anya-anya kábel) VAGY (Arduino UNO és 4 anya-apa, 1 anya-anya és 1 apa-apa kábel és USB kábel az Arduino UNO számítógépre kötéséhez).

Az Arduino IDE beállítása

Telepítés

Ha még nem tettük meg, töltsük le és telepítsük az Arduono IDE-t a https://www.arduino.cc/en/software oldalról.

Beállítások

Az Arduino UNO alapból nem támogatja az ESP32 lapkákat, így (az ESP8266 családhoz hasonlóan) azt külön be kell állítani.

Edit → Preferences: az Additional Boards Manager URLs: ide írjuk be az alábbit:

https://dl.espressif.com/dl/package_esp32_index.json

Sok esetben már az ESP8266 család lapkáinak a leírója benne van; ez esetben vesszővel választhatjuk el:

https://dl.espressif.com/dl/package_esp32_index.json, http://arduino.esp8266.com/stable/package_esp8266com_index.json

Alaplapok betöltése

Tools → Boards → Boards Manager…

A keresőbe írjuk be ezt: esp32, majd telepítsük. Ez hosszú ideig eltart és nagy mennyiségű adatot tölt a hálózatról, így célszerű korlátlan netes elérésű hálzatóról végrehajtani ezt a lépést.

Alaplap beállítások

Tools → Boards → ESP32 Wrover Module

Sajnos elég nehéz megtalálni, ugyanis nagyon sokféle ESP32 lapka létezik. Az Arduino IDE frissebb verzióiban legalább típus szerint almenükbe szedtél (alap, ESP8266, ESP32), a korábbiakban viszont mindez ömlesztve van, ráadásul nem is ábécé sorrendben.

Az alábbiakat állítsuk be (szinte mindet át kell állítani):

• Upload Speed: 115200
• Flash Frequency: 40MHz
• Flash Mode: QIO
• Partition Scheme: Huge APP (3MB No OTA/1MP SPIFFS)
• Core Debug Level: None
• Port: rákötés után megjelenik valami, majd azt kell kiválasztani (tehát egyvalami jelenik meg, de ki kell választani)
• Programmer: AVR ISP

Bekötés

Az ESP32-CAM eszközön nincs USB port, közvetlenül tehát nem tudjuk rákötni a számítógépre. Két lehetőségünk van: vagy USB-TTL átalakítót használunk, vagy egy Arduino UNO-t (vagy hasonlót).

USB-TTL átalakító

Az alábbi bekötést valósítsuk meg:

• ESP32-CAM GND → USB-TTL GND
• ESP32-CAM 5V → USB-TTL 5V
• ESP32-CAM U0R → USB-TTL TX
• ESP32-CAM U0T → USB-TTL RX
• ESP32-CAM GPIO0 → ESP32-CAM GND

(A kép forrása: https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-card/.)

Dugjuk be az USB-TTL átalakítót a számítógép valamelyik USB portjára. Érdemes az Eszközkezelőn belül megnézni a Portokat; elvileg ott láthatjuk:

(Az enyémen azt jelzi, hogy már nem támogatott, de azért még nagyon jól működik.)

Arduino UNO lapka használata

A fenti alternatívája ez a megoldás (tehát a félreértések elkerülése érdekében: vagy az egyik, vagy a másik, nem kell mindkettő). Vegyünk egy Arduino UNO vagy hasonló lapkát (Én történetesen WeMos R1 D1-et használtam), majd valósítsuk meg az alábbi bekötést:

• ESP32-CAM GND → Arduino GND
• ESP32-CAM 5V → Arduino 5V
• ESP32-CAM U0R → Arduino TX
• ESP32-CAM U0T → Arduino RX
• ESP32-CAM GPIO0 → ESP32-CAM GND
• Arduino RESET → Arduino GND

(A képet a neten találtam, egy ouTube videó képernyőképeként; a kép forrása a bal alsó sarkában található felirat alapján a https://easyelectronicsproject.com/ oldal.)

Dugjuk rá az Arduino-t a számítógépre.

Megjegyzések

A flash mode-ot (mindkét esetben) a ESP32-CAM GPIO0 → ESP32-CAM GND biztosítja. Olyan videóval is találkoztam, amely kihangsúlyozta, hogy meg kell nyomni a Reset gombot ahhoz, hogy flash módba kerüljön. Azt én is tapasztaltam egyszer, hogy enélkül nem indult el az írás, bár ekkor néhány másodperc után leállt, ugyanakkor volt sikeres feltöltésem a Reset megnyomása nélkül is. Szóval ezt ki kell tapasztalni.

Több leírásban nem az 5 Volt, hanem a 3,3 Volt szerepel, ill. van olyan is, amely azt állítja, hogy a számítógép 5 Voltja nem elegendő, külső tápra van szükség. Ez utóbbi úgy néz ki, hogy az USB számítógépre és áramba is be van dugva egyszerre.

Web szerver

A program feltöltése

Az első projekt a web szerver, melynek a kódja megtalálható a példaprogramok között az Arduino IDE-ben:

File → Examples → ESP32 → Camera → CameraWebServer

Néhány dolgot módosítanunk kell.

A CameraWebServer.cpp fájl 10-14. soraiban #define makrók találhatóak. Alapértelmezésben a #define CAMERA_MODEL_WROVER_KIT van kiválasztva. Azt tegyük megjegyzésbe, és vegyük ki a megjegyzésből a #define CAMERA_MODEL_AI_THINKER-t:

// Select camera model
//#define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
#define CAMERA_MODEL_AI_THINKER

A 18. és 19. sorban az alábbi két sort látjuk:

const char* ssid = "*********";
const char* password = "*********";

A csillagok helyére írjuk be a mi wifink azonosítóját és jelszavát. Ugyanazt a hálózatot adjuk meg, amivel a számítógépünkkel csatlakozunk.

Mentsük le a módosított projektet (File → Save); az alapértelmezett könyvtár megteszi, de választhatunk másikat is.

Ha még nem tettük meg, kössük rá az USB-TTL átalakítót vagy az Arduino-t. Győződjünk meg arról, hogy a Tools → Ports alatt a megfelelő van kiválasztva.

Töltsük fel a kódot:

Sketch → Upload

Ha nem indul, nyomjuk meg a Reset gombot.

A fordítás és a feltöltés is eltart egy jódarabig, nagyságrendileg egy percig. A sikeres feltöltést az alábbi jelzi:

Leaving...
Hard resetting via RTS pin...

Több olyan videót is láttam, ahol a feltöltés során hibaüzenetre panaszkodtak; ezt én nem tapasztaltam.

A program indítása

Sikeres feltöltés után húzzuk ki a ESP32-CAM GPIO0 → ESP32-CAM GND kábelt, ill. Arduino UNO használata esetén az Arduino RESET → Arduino GND kábelt is. Nyissuk meg a serial monitort.

Tools → Serial Monitor

A Baud Rate-et állítsuk 115200-ra, majd nyomjuk meg az ESP32-n a Reset gombot. Ha minden rendben ment, a lentihez hasonló üzenetet kell látnunk:

Az alsó sorban a Camera Ready! után kiír egy IP címet; a példában ez http://192.168.1.73/; ezt jegyezzük fel.

Most már kihúzhatjuk a TX és RX kábeleket, elég, ha csak tápot és GND-t kap az ESP32-CAM, és nem is feltétlenül kell, hogy a számtógép USBjére kapcsolódjon, akár egy konnektoros USB átalakítóba is bedughatjuk.

Nyissuk meg egy böngészővel a fenti oldalt. (A számítógép ugyanarra a wifi hálózatra legyen csatlakozva, mint amit megadtunk az ESP32-CAM-nek.) A következő nyílik meg:

Kapcsoljuk be lent a stream-et (Start Stream). Fent jó eséllyel meg fog jelenni egy kicsi homályos kép. A felbontást (Resolution) állítsuk magasabbra. A kamera lencséjét forgatva próbáljuk élesíteni a képet

Kellő kitartással egy ilyen képet is elérhetünk:

Képek készítése

Képet a lenti Get Still segítségével tudunk készíteni; érdemes először azt megnyomni, és nem a stream-ből menteni. Játsszunk el kicsit a lehetőségekkel! Néhány lehetőség, amire rájöttem:

• Resolution: a kép felbontása.
• Quality: képminőség (jó eséllyel a jpeg minősége).
• Brightness: világosság (mivel elég durva egységekben lehet csak módosítani, a gyakorlatban használhatatlan).
• Contrast: kontraszt (szintúgy, bár itt ez már használhatóbb).
• Saturation: színtelítettség.
• Special Effect: különleges hatások, pl. negatív, szépia stb.
• WB: a fehéregyensúly beállításával kapcsolatos lehetőségek.
• H és V-Mirror: tükrözések.
• Face Detection és Face Recognition: arcfelismerés; ezt nem sikerült működésre bírnom.

Néhány kép, amit készítettem; egyiken sincs semmilyen utófeldolgozás.

Városkép:

Makró:

Szépia:

Lehetséges problémák

Használat során számos probléma adódhat; itt most csak párat sorolok fel.

Furcsa hibaüzenetek vagy csíkozódás jelenik meg: ez az instabil áramforrásra utal. Ez esetben célszerű a hálózati áramforrásra dugható USB átalakítót használni.

A stream megakad: újra kell indítani, esetleg az oldalt újra be kell tölteni, esetleg az ESP32-CAM-et is újra kell indítani.

Problémát okozhat az is, hogy messze van a wifi jeltől, és "leszakad"; ez esetben beszerezhetünk külső antennát.

Mentés MicroSD kártyára

Érdemes kihasználni a beépített microSD kártyaolvasót! Ehhez szerezzünk be egy microSD kártyát. Csatlakoztassuk a számítógéphez (ehhez szükség lehet egy USB-microSD vagy SD-microSD átalakítóra) és formázzuk le: Fájlkezelő → az "Ez a gép" alatt keressük meg a megfelelő lemezt (ez általában az E, vagy azt nem sokkal követő betűjelű meghajtó lesz) → jobb kattintás → Formázás… Érdemes tudni, hogy az ESP32 csak 4 GB-ig tudja kezelni a microSD kártyát. (Annál nagyobbat is használhatunk, de csak az alsó 4 GB-ot fogja "látni".)

Program

Ezt a projektet a https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-card/ oldal alapján készítettem; a példaprogram is onnan származik. A beállítás és a bekötés megegyezik az előzővel, a program viszont az alábbi:

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-cam-take-photo-save-microsd-card
 
  IMPORTANT!!! 
   - Select Board "AI Thinker ESP32-CAM"
   - GPIO 0 must be connected to GND to upload a sketch
   - After connecting GPIO 0 to GND, press the ESP32-CAM on-board RESET button to put your board in flashing mode
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/
 
#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h"                // SD Card ESP32
#include "SD_MMC.h"            // SD Card ESP32
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <EEPROM.h>            // read and write from flash memory
 
// define the number of bytes you want to access
#define EEPROM_SIZE 1
 
// Pin definition for CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM     32
#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
 
int pictureNumber = 0;
 
void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
 
  Serial.begin(115200);
  //Serial.setDebugOutput(true);
  //Serial.println();
 
  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_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_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; 
 
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
 
  // Init Camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
 
  //Serial.println("Starting SD Card");
  if(!SD_MMC.begin()){
    Serial.println("SD Card Mount Failed");
    return;
  }
 
  uint8_t cardType = SD_MMC.cardType();
  if(cardType == CARD_NONE){
    Serial.println("No SD Card attached");
    return;
  }
 
  camera_fb_t * fb = NULL;
 
  // Take Picture with Camera
  fb = esp_camera_fb_get();  
  if(!fb) {
    Serial.println("Camera capture failed");
    return;
  }
  // initialize EEPROM with predefined size
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;
 
  // Path where new picture will be saved in SD Card
  String path = "/picture" + String(pictureNumber) +".jpg";
 
  fs::FS &fs = SD_MMC; 
  Serial.printf("Picture file name: %s\n", path.c_str());
 
  File file = fs.open(path.c_str(), FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file in writing mode");
  } 
  else {
    file.write(fb->buf, fb->len); // payload (image), payload length
    Serial.printf("Saved file to path: %s\n", path.c_str());
    EEPROM.write(0, pictureNumber);
    EEPROM.commit();
  }
  file.close();
  esp_camera_fb_return(fb); 
 
  // Turns off the ESP32-CAM white on-board LED (flash) connected to GPIO 4
  pinMode(4, OUTPUT);
  digitalWrite(4, LOW);
  rtc_gpio_hold_en(GPIO_NUM_4);
 
  delay(2000);
  Serial.println("Going to sleep now");
  delay(2000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}
 
void loop() {
 
}

A program működése: látható, hogy a loop() üres: valójában ez úgy működik, hogy elindul, beállítja magát, készít egy képet (a "vaku" is villan), azt elmenti az SD kártyára, majd "mély alvó" módba kerül. Érdemes megfigyelni azt, hogy a sorszámot az EEPROM-ban tárolja, ami megmarad akkor is, ha nem kap áramot.

Használat

Feltöltés után csak tápot kapjon (5V + GND), a többi kábelre (TX, RX, flash mód) nincs szükség. Ha még nem tettük meg, helyezzünk be egy microSD kártyát, irányítsuk a fotózandó témára a kamerát, majd nyomjuk meg a Reset gombot. Ha minden rendben ment, akkor a vaku villan, és elkészít egy fotót. Ezt többször is megismételhetjük. A probléma viszont leginkább az, hogy nem látjuk az eredményt. Ahhoz ki kell vennünk a kártyafoglalatból a kártyát, és rá kell csatlakoztatnunk a számtógépre. Só eséllyel nem egy jól megvilágított, éles képet fogunk látni, hanem egy sötét "pacát". Próbáljuk meg csavargatni a lencsét az élesítéshez.

Eredmény

Kicsit "vakon" próbálgatva a következő legjobb minőséget sikerült elérnem:

Szóval ez a lehetőség egyelőre inkább még csak érdekes mint hasznos.

Előnyök

Ennyi tapasztalat után foglaljuk össze az eszköz előnyeit!

• A mikrokontroller tudása: nagyságrendekkel az Arduino UNO felett.
  • Memória: a Flash memória mérete 4 MB. Emlékeztetőül: az Arduino UNO memóriája 32 kB. Az SRAM memória mérete is ekkora nagyságrenddel nagyobb.
  • A lábak száma: abból kevesebb van, mindössze 16 (az Arduino UNO-n 32), ráadásul ezekből csak 9 használható általános célra, viszont azt is érdemes figyelembe venni, hogy Arduino UNO-val szinte nem marad láb üresen, ha egy kamerát csatlakoztatunk hozzá, az egyebekről (pl. wifi, kártyaolvasó) nem is beszélve. Tehát az ESP-CAM-mel anélkül tudunk értelmes projekteket készíteni, hogy a tápon kívül akár egyetlen másik lábat felhasználnánk.
  • Kiegészítők: aki már próbálkozott Arduino UNO-val mindenféle projektekkel, az különösen értékeli azt, hogy az ESP32 integráltan tartalmaz wifit, MicroSD kártya olvasót, Bluetooth-ot, egy vakut (szinte már zavaróan nagy fényerejű LED-et) és külső antenna foglalatot is.
• A kamera tudása: hasonló nagyságrendi ugrás tapasztalható az OV7670 és az OV2640 között is.
  • Az OV7670 0,3 megapixeles, míg az OV2640 2 megapixeles.
  • Az OV7670 fekete-fehér képeket készít, míg az OV2640 színest.
  • Az OV7670 csak BMP képet készített, míg az OV2640 számos lehetőséget biztosít: többféle formátum, stream-elés, alap beállítások (pl. fényerő, fehéregyensúly stb.), sőt, még arcfelismerés is van benne, bár azt nekem nem sikerült beüzemelnem.
• Bekötés: a korábban kipróbált, OV7670 jelű eszközhöz 23 kapcsolatot kellett létrehozni, ami tehát legalább 23 kábelt jelentett. Ráadásul ez csak a kamera összekapcsolását jelentette az Arduino-val. Így a gyakorlatban azt használhatatlanná tette. Itt viszont egy vékony fóliát kell megfelelően ráhelyezni a mikrokontrollerre, és az minden szükséges kapcsolatot tartalmaz. Ennek a jelentőségét az nem is igazán értheti meg, aki nem kínlódott a másikkal.
• Ár: az integrált mikrokontroller és a kamera együttes ára 10 dollár alatti, és ez igaz a fent megadott magyar kiskereskedelmi árra is. Azt gondolom, hogy - figyelembe véve a fenti tudást - nyugodt szívvel kijelenthetjük, hogy filléres tétel.

A benne rejlő perspektíva szinte félelmetes!

Hátrányok

Nem tudunk elmenni az eszköz hátrányai mellett sem. Nemcsak amiatt, mert úgymond illik hátrányokat is írni a kiegyensúlyozottság látszatát fenntartva, hanem valóban vannak neki.

• IDE problémák:
  • Az Arduino IDE alapból nem támogatja az ESP32-es mikrokontroller családot. Ez persze nem az ESP32 hibája, hanem az Arduino IDE-é, de egy felhasználót hol kell, hogy ez érdekelje? Lehet persze mondani, hogy nem kötelező Arduino IDE-t használni, lehet mást is, pl. PlatformIO-t, de annak még hosszabb a betanulási görbéje. És egy projekt megvalósításakor a legkevésbé az integrált fejlesztőkörnyezetet szeretnénk tanulni!
  • Szinte semelyik alapértelmezett vagy logikus beállítás nem megfelelő, gondosan át kell állítani sokmindent.
• Az ESP32-CAM hardver problémái
  • USB hiánya: nem lehet közvetlenül számítógépre kötni, kell egy köztes eszköz, pl. egy USB-TTL átalakító (vagy FTDI programozó). Ami azért nyilván alapeszköz, de mégsem annyira, mint mondjuk egy csavarhúzó. Személy szerint én elvárnék pl. egy mikro USB foglalatot, még akkor is, ha ennek következtében valamelyest meg kell növelni a lapka méretét.
  • Nehezen hozzáférhető power gomb: érdemes lett volna picit hozzáférhetőbb helyre tenni.
  • Nehezen olvasható pinek: egyrészt nagyon pici, másrészt nem azon az oldalon van a felirat, ahol a tű.
• A kamera gyengeségei
  • Könnyen romló hatást kelt: egy vékony fóliában vannak a kábelek; az embernek az az érzése, hogy egy rossz mozdulattal tönkre teszi
  • A lencse nehezen csavarható, akadozik: legalábbis nálam. Kezdeti problémák miatt valójában kettőt is kaptam, és mindkettőnél csak kombináltfogóval sikerült megmozdítanom, és utána is nehézkesen csavarható puszta kézzel, ha egyáltalán.
  • Nem stabil, magyarán lötyög. Jó lenne, ha fixen bele lehetne pattintani a kamera fejét is magára a mikrokontrollerre, hogy legalább ahhoz képest ne mozdulhasson el.
  • Tudásban még mindig van hova fejlődni: habár óriási az előrelépés a korábbihoz képest még mindig nem éri el azt a szintet, hogy hétköznapi célokra használni lehessen. A legnagyobb probléma szerintem az élesség; egy automatikus élesség állítás sokat dobna rajta.
  • Az eredmény lehetne szebb: még egy belépő szintű okostelefon kamerájától is messze elmarad.
• Feltöltési problémák
  • Elárulok egy kulisszatitkot: az első eszköz, amit kaptam, egyáltalán nem működött, különböző hibaüzenetekkel leállt. A másodiknál, amit kaptam, már elindult a feltöltés, de pár másodperc elteltével leállt. Kipróbáltam egy másik számítógéppel: ott egyáltalán nem működött. Egy harmadik számítógépen az elsőként használt USB-vel nem működött, végül ott egy másik USB-vel sikerült csak feltöltenem. Szóval nagyon nehézkes, és ha valakinek csak egy számítógépe van, akkor egyáltalán nem biztos, hogy tudni fogja használni. Azzal a számítógéppel, amellyel nem működött az ESP32-CAM, szépen működött pl. a WeMos.
  • A feltöltés során rengeteg hibaüzenettel lehet találkozni: szinte ahány YouTube videó készült a témában, annyi problémáról számoltak be. Hol az IDE írt ki hibát, "de azt figyelmen kívül kell hagyni", hol a tápellátás nem volt megfelelő (külső tápra volt szükség), de olyan is volt, hogy az induláskor esett végtelen ciklusba.
  • A fordítás és a feltöltés is hosszú ideig tart. Ennek a pontos ideje persze számítógép függő, ám a nagyságrend perces. Ez elfogadhatatlanul hosszú idő egy fejlesztés során, amikor esetleg minden apró változtatást ki szeretnénk próbálni.
  • Nincs egyértelműen ajánlott módja a fejlesztésnek. Lehet 3,3 Voltot használni, de 5 Voltot is. Használhatunk Arduino UNO-t (vagy más lapkát) a számítógépre kötéshez, de USB-TTL átalakítót is. Használhatjuk az Arduino UNO-t, a PlatformIO-t, vagy a gyártó saját fejlesztőeszközét. Csakhogy a nagy szabadság oda vezet, hogy egy adott konfigurációra esetleg nem találunk segítséget, ha elakadunk. Szerintem sokkal jobb lenne egy egyértelműen javasolt megoldás.
• Csúnya kód a kód önmagában nehezen érthető.
  • CameraWebServer.cpp: nagyon sok a konfiguráció. Csak a konfiguráció 40 soron keresztül történik. Pl. egy esp_camera_init(ESP-32-OV2640); szerintem tökéletesen elég kellene, hogy legyen; mindenki tudná, hogy miről van szó. Azt is problémának tartom, hogy a CAMERA_MODEL_WROVER_KIT van alapból kiválasztva, viszont még nem találkoztam olyannal, aki nem CAMERA_MODEL_AI_THINKER-t használna. Legyen az az alapértelmezett, a többit meg rejtsék el!
  • app_httpd.cpp: ez egy hosszú, nehezen érthető kód. Érzésem szerint jó része mehetne a könyvtárba.
  • camera_index.h: ez oly mértékben kritikán aluli, hogy ha osztályzatot kellene adnom az egész projektre, már önmagában ez megakadályozná, hogy átmenőt adjak: ez nem más, mint egy gzippelt index.html oldal bájtjainak a felsorolása. Legyen már ott egy normális HTML oldal!
  • camera_pins.h: szerintem felesleges. Tekintettel arra, hogy a pin kiosztás a kialakításból adódóan eleve adott, azokat library szinten kellene lefixálni, és elrejteni a fejlesztő elől. Azt a pár típust konstansként fel kellene sorolni, egy konfigurációban megadni, és minden mást a könyvtárnak kellene intéznie.
• Üzemeltetési problémák
  • Instabil webszerver: gyakran megszakad a kapcsolat, leáll a stream-elés; ennek sok esetben az ESP32-CAM fizikai újraindítása a megoldás. (Ez a tény önmagában kizárja az eszköz megfigyelő kameraként történő alkalmazását.)
  • Csíkozódás: a kép sokszor csúnya, csíkos lesz. Ez tápellátási problémákra vezethető vissza

Összegzés

Hatalmas tudású eszköz filléres árért, ám még van hová fejlődnie. Még hobbielektronikai mércével mérve is kifejezetten macerás a használata, és elfogadhatatlanul instabil. Arra még semmiképpen sem alkalmas, hogy mondjuk egy iskolai szakkör keretein belül szerettessük meg a diákokkal a mikroelektronikát, és arra se, hogy ennek segítségével olyan okosházat építsünk, melyben nem egy kellően "megszállott", mikrokontrollerekkel álmodó ember él.

Ugyanakkor ha lesz még egy akkora lépés, mint ami volt az OV7670 és az OV2640 között (ill. az Arduino UNO és az ESP-CAM között; és miért ne lenne), akkor az már megfelelő lesz árban, tudásban és stabilitásban is ahhoz, hogy akár oktatási, akár gyakorlati célokra felhasználjuk. Az az érzésem, hogy ezzel a cikkel picit előre szaladtunk az időben (magyarán_: a világ még nem tart itt), de pár év múlva ismét érdemes lesz ránézni az aktuális lehetőségre, és remélhetőleg elkészül a következő fejezet, melyben arról tudok majd beszámolni, hogy mennyire olcsó, nagy tudás és könnyen használható eszközt sikerült kipróbálnom.

Az oldal második fejezete a https://www.microcontroller.hu/blog/nodemcu/esp32-cam-es-ov2640/ oldalon is megjelent.