20 KiB

Raw Permalink Blame History

Zachycení obrázku - Wio Terminal

V této části lekce přidáte ke svému Wio Terminalu kameru a budete z ní zachycovat obrázky.

Hardware

Wio Terminal potřebuje kameru.

Použitá kamera je ArduCam Mini 2MP Plus. Jedná se o 2megapixelovou kameru založenou na obrazovém senzoru OV2640. Komunikuje přes SPI rozhraní pro zachycení obrázků a používá I2C pro konfiguraci senzoru.

Připojení kamery

ArduCam nemá Grove konektor, místo toho se připojuje k SPI a I2C sběrnicím přes GPIO piny na Wio Terminalu.

Úkol - připojení kamery

Připojte kameru.

Piny na spodní straně ArduCam musí být připojeny k GPIO pinům na Wio Terminalu. Aby bylo snazší najít správné piny, připevněte kolem pinů nálepku GPIO pinů, která je součástí Wio Terminalu:

Pomocí propojovacích vodičů proveďte následující připojení:

Pin ArduCAM	Pin Wio Terminal	Popis
CS	24 (SPI_CS)	SPI Chip Select
MOSI	19 (SPI_MOSI)	SPI Controller Output, Peripheral Input
MISO	21 (SPI_MISO)	SPI Controller Input, Peripheral Output
SCK	23 (SPI_SCLK)	SPI Serial Clock
GND	6 (GND)	Zem - 0V
VCC	4 (5V)	Napájení 5V
SDA	3 (I2C1_SDA)	I2C Serial Data
SCL	5 (I2C1_SCL)	I2C Serial Clock

Připojení GND a VCC poskytuje napájení 5V pro ArduCam. Kamera běží na 5V, na rozdíl od Grove senzorů, které běží na 3V. Toto napájení pochází přímo z USB-C připojení, které napájí zařízení.

💁 Pro SPI připojení stále používají štítky pinů na ArduCam a názvy pinů Wio Terminalu v kódu starší konvenci pojmenování. Instrukce v této lekci budou používat novou konvenci pojmenování, kromě případů, kdy jsou názvy pinů použity v kódu.

Nyní můžete připojit Wio Terminal k vašemu počítači.

Naprogramování zařízení pro připojení ke kameře

Wio Terminal nyní může být naprogramován tak, aby používal připojenou kameru ArduCAM.

Úkol - naprogramování zařízení pro připojení ke kameře

Vytvořte nový projekt Wio Terminal pomocí PlatformIO. Nazvěte tento projekt fruit-quality-detector. Přidejte kód do funkce setup pro konfiguraci sériového portu.
Přidejte kód pro připojení k WiFi, s vašimi WiFi přihlašovacími údaji v souboru config.h. Nezapomeňte přidat požadované knihovny do souboru platformio.ini.
Knihovna ArduCam není dostupná jako Arduino knihovna, kterou lze nainstalovat ze souboru platformio.ini. Místo toho ji bude potřeba nainstalovat ze zdroje z jejich GitHub stránky. Můžete ji získat buď:
- Klonováním repozitáře z https://github.com/ArduCAM/Arduino.git
- Navštívením repozitáře na GitHubu na github.com/ArduCAM/Arduino a stažením kódu jako zip z tlačítka Code
Potřebujete pouze složku ArduCAM z tohoto kódu. Zkopírujte celou složku do složky lib ve vašem projektu.

⚠️ Celá složka musí být zkopírována, takže kód bude v lib/ArduCam. Nekopírujte pouze obsah složky ArduCam do složky lib, zkopírujte celou složku.
Kód knihovny ArduCam funguje pro více typů kamer. Typ kamery, kterou chcete použít, je konfigurován pomocí kompilátorových příznaků - tím se udržuje velikost knihovny co nejmenší odstraněním kódu pro kamery, které nepoužíváte. Pro konfiguraci knihovny pro kameru OV2640 přidejte následující na konec souboru platformio.ini:
```
build_flags =
    -DARDUCAM_SHIELD_V2
    -DOV2640_CAM
```
Toto nastavuje 2 kompilátorové příznaky:
- ARDUCAM_SHIELD_V2 pro informování knihovny, že kamera je na Arduino desce, známé jako shield.
- OV2640_CAM pro informování knihovny, aby zahrnula pouze kód pro kameru OV2640.

Přidejte hlavičkový soubor do složky src nazvaný camera.h. Tento soubor bude obsahovat kód pro komunikaci s kamerou. Přidejte do tohoto souboru následující kód:

#pragma once

#include <ArduCAM.h>
#include <Wire.h>

class Camera
{
public:
    Camera(int format, int image_size) : _arducam(OV2640, PIN_SPI_SS)
    {
        _format = format;
        _image_size = image_size;
    }

    bool init()
    {
        // Reset the CPLD
        _arducam.write_reg(0x07, 0x80);
        delay(100);

        _arducam.write_reg(0x07, 0x00);
        delay(100);

        // Check if the ArduCAM SPI bus is OK
        _arducam.write_reg(ARDUCHIP_TEST1, 0x55);
        if (_arducam.read_reg(ARDUCHIP_TEST1) != 0x55)
        {
            return false;
        }

        // Change MCU mode
        _arducam.set_mode(MCU2LCD_MODE);

        uint8_t vid, pid;

        // Check if the camera module type is OV2640
        _arducam.wrSensorReg8_8(0xff, 0x01);
        _arducam.rdSensorReg8_8(OV2640_CHIPID_HIGH, &vid);
        _arducam.rdSensorReg8_8(OV2640_CHIPID_LOW, &pid);
        if ((vid != 0x26) && ((pid != 0x41) || (pid != 0x42)))
        {
            return false;
        }

        _arducam.set_format(_format);
        _arducam.InitCAM();
        _arducam.OV2640_set_JPEG_size(_image_size);
        _arducam.OV2640_set_Light_Mode(Auto);
        _arducam.OV2640_set_Special_effects(Normal);
        delay(1000);

        return true;
    }

    void startCapture()
    {
        _arducam.flush_fifo();
        _arducam.clear_fifo_flag();
        _arducam.start_capture();
    }

    bool captureReady()
    {
        return _arducam.get_bit(ARDUCHIP_TRIG, CAP_DONE_MASK);
    }

    bool readImageToBuffer(byte **buffer, uint32_t &buffer_length)
    {
        if (!captureReady()) return false;

        // Get the image file length
        uint32_t length = _arducam.read_fifo_length();
        buffer_length = length;

        if (length >= MAX_FIFO_SIZE)
        {
            return false;
        }
        if (length == 0)
        {
            return false;
        }

        // create the buffer
        byte *buf = new byte[length];

        uint8_t temp = 0, temp_last = 0;
        int i = 0;
        uint32_t buffer_pos = 0;
        bool is_header = false;

        _arducam.CS_LOW();
        _arducam.set_fifo_burst();

        while (length--)
        {
            temp_last = temp;
            temp = SPI.transfer(0x00);
            //Read JPEG data from FIFO
            if ((temp == 0xD9) && (temp_last == 0xFF)) //If find the end ,break while,
            {
                buf[buffer_pos] = temp;

                buffer_pos++;
                i++;

                _arducam.CS_HIGH();
            }
            if (is_header == true)
            {
                //Write image data to buffer if not full
                if (i < 256)
                {
                    buf[buffer_pos] = temp;
                    buffer_pos++;
                    i++;
                }
                else
                {
                    _arducam.CS_HIGH();

                    i = 0;
                    buf[buffer_pos] = temp;

                    buffer_pos++;
                    i++;

                    _arducam.CS_LOW();
                    _arducam.set_fifo_burst();
                }
            }
            else if ((temp == 0xD8) & (temp_last == 0xFF))
            {
                is_header = true;

                buf[buffer_pos] = temp_last;
                buffer_pos++;
                i++;

                buf[buffer_pos] = temp;
                buffer_pos++;
                i++;
            }
        }

        _arducam.clear_fifo_flag();

        _arducam.set_format(_format);
        _arducam.InitCAM();
        _arducam.OV2640_set_JPEG_size(_image_size);

        // return the buffer
        *buffer = buf;
    }

private:
    ArduCAM _arducam;
    int _format;
    int _image_size;
};

Toto je nízkoúrovňový kód, který konfiguruje kameru pomocí knihoven ArduCam a extrahuje obrázky, když je to potřeba, pomocí SPI sběrnice. Tento kód je velmi specifický pro ArduCam, takže se nemusíte starat o to, jak funguje.

V main.cpp přidejte následující kód pod ostatní include příkazy pro zahrnutí tohoto nového souboru a vytvoření instance třídy kamery:
```
#include "camera.h"

Camera camera = Camera(JPEG, OV2640_640x480);
```
Toto vytvoří Camera, která ukládá obrázky jako JPEGy v rozlišení 640 x 480. Ačkoli jsou podporována vyšší rozlišení (až 3280x2464), klasifikátor obrázků pracuje na mnohem menších obrázcích (227x227), takže není potřeba zachytávat a odesílat větší obrázky.
Přidejte následující kód pod tento pro definování funkce pro nastavení kamery:
```
void setupCamera()
{
    pinMode(PIN_SPI_SS, OUTPUT);
    digitalWrite(PIN_SPI_SS, HIGH);

    Wire.begin();
    SPI.begin();

    if (!camera.init())
    {
        Serial.println("Error setting up the camera!");
    }
}
```
Funkce setupCamera začíná konfigurací SPI chip select pinu (PIN_SPI_SS) jako vysokého, čímž se Wio Terminal stává SPI kontrolérem. Poté spustí I2C a SPI sběrnice. Nakonec inicializuje třídu kamery, která konfiguruje nastavení senzoru kamery a zajišťuje, že vše je správně zapojeno.
Zavolejte tuto funkci na konci funkce setup:
```
setupCamera();
```
Sestavte a nahrajte tento kód a zkontrolujte výstup ze sériového monitoru. Pokud uvidíte Error setting up the camera!, zkontrolujte zapojení, aby bylo zajištěno, že všechny kabely spojují správné piny na ArduCam se správnými GPIO piny na Wio Terminalu a všechny propojovací kabely jsou správně usazeny.

Zachycení obrázku

Wio Terminal nyní může být naprogramován tak, aby zachytil obrázek, když je stisknuto tlačítko.

Úkol - zachycení obrázku

Mikrokontroléry spouštějí váš kód nepřetržitě, takže není snadné spustit něco jako pořízení fotografie bez reakce na senzor. Wio Terminal má tlačítka, takže kamera může být nastavena tak, aby byla spuštěna jedním z tlačítek. Přidejte následující kód na konec funkce setup pro konfiguraci tlačítka C (jednoho ze tří tlačítek nahoře, toho nejblíže k vypínači).
```
pinMode(WIO_KEY_C, INPUT_PULLUP);
```
Režim INPUT_PULLUP v podstatě invertuje vstup. Například normálně by tlačítko posílalo nízký signál, když není stisknuto, a vysoký signál, když je stisknuto. Když je nastaveno na INPUT_PULLUP, posílá vysoký signál, když není stisknuto, a nízký signál, když je stisknuto.
Před funkcí loop přidejte prázdnou funkci pro reakci na stisknutí tlačítka:
```
void buttonPressed()
{

}
```
Zavolejte tuto funkci ve funkci loop, když je tlačítko stisknuto:
```
void loop()
{
    if (digitalRead(WIO_KEY_C) == LOW)
    {
        buttonPressed();
        delay(2000);
    }

    delay(200);
}
```
Tento klíč kontroluje, zda je tlačítko stisknuto. Pokud je stisknuto, je zavolána funkce buttonPressed a smyčka se zpozdí o 2 sekundy. Toto je pro umožnění času na uvolnění tlačítka, aby dlouhý stisk nebyl zaregistrován dvakrát.

💁 Tlačítko na Wio Terminalu je nastaveno na INPUT_PULLUP, takže posílá vysoký signál, když není stisknuto, a nízký signál, když je stisknuto.
Přidejte následující kód do funkce buttonPressed:
```
camera.startCapture();

while (!camera.captureReady())
    delay(100);

Serial.println("Image captured");

byte *buffer;
uint32_t length;

if (camera.readImageToBuffer(&buffer, length))
{
    Serial.print("Image read to buffer with length ");
    Serial.println(length);

    delete(buffer);
}
```
Tento kód zahájí zachycení kamery voláním startCapture. Hardware kamery nefunguje tak, že vrací data, když je požadujete, místo toho pošlete instrukci k zahájení zachycení a kamera bude pracovat na pozadí na zachycení obrázku, jeho převodu na JPEG a uložení do lokálního bufferu na samotné kameře. Volání captureReady poté zkontroluje, zda zachycení obrázku skončilo.

Jakmile zachycení skončí, data obrázku jsou zkopírována z bufferu na kameře do lokálního bufferu (pole bajtů) pomocí volání readImageToBuffer. Délka bufferu je poté odeslána na sériový monitor.
Sestavte a nahrajte tento kód a zkontrolujte výstup na sériovém monitoru. Pokaždé, když stisknete tlačítko C, bude zachycen obrázek a uvidíte velikost obrázku odeslanou na sériový monitor.
```
Connecting to WiFi..
Connected!
Image captured
Image read to buffer with length 9224
Image captured
Image read to buffer with length 11272
```
Různé obrázky budou mít různé velikosti. Jsou komprimovány jako JPEGy a velikost souboru JPEG pro dané rozlišení závisí na tom, co je na obrázku.

💁 Tento kód najdete ve složce code-camera/wio-terminal.

😀 Úspěšně jste zachytili obrázky pomocí svého Wio Terminalu.

Volitelné - ověření obrázků z kamery pomocí SD karty

Nejjednodušší způsob, jak zobrazit obrázky zachycené kamerou, je zapsat je na SD kartu ve Wio Terminalu a poté je zobrazit na vašem počítači. Proveďte tento krok, pokud máte volnou microSD kartu a microSD slot ve vašem počítači nebo adaptér.

Wio Terminal podporuje pouze microSD karty o velikosti až 16GB. Pokud máte větší SD kartu, nebude fungovat.

Úkol - ověření obrázků z kamery pomocí SD karty

Naformátujte microSD kartu jako FAT32 nebo exFAT pomocí příslušných aplikací na vašem počítači (Disk Utility na macOS, File Explorer na Windows nebo pomocí příkazových nástrojů v Linuxu).
Vložte microSD kartu do slotu těsně pod vypínačem. Ujistěte se, že je zcela zasunutá, dokud nezaklapne a zůstane na místě, možná ji budete muset zatlačit pomocí nehtu nebo tenkého nástroje.
Přidejte následující příkazy include na začátek souboru main.cpp:
```
#include "SD/Seeed_SD.h"
#include <Seeed_FS.h>
```

Před funkcí setup přidejte následující funkci:

void setupSDCard()
{
    while (!SD.begin(SDCARD_SS_PIN, SDCARD_SPI))
    {
        Serial.println("SD Card Error");
    }
}

Tato funkce konfiguruje SD kartu pomocí SPI sběrnice.

Zavolejte tuto funkci z funkce setup:
```
setupSDCard();
```
Přidejte následující kód nad funkci buttonPressed:
```
int fileNum = 1;

void saveToSDCard(byte *buffer, uint32_t length)
{
    char buff[16];
    sprintf(buff, "%d.jpg", fileNum);
    fileNum++;

    File outFile = SD.open(buff, FILE_WRITE );
    outFile.write(buffer, length);
    outFile.close();

    Serial.print("Image written to file ");
    Serial.println(buff);
}
```
Toto definuje globální proměnnou pro počet souborů. Tato proměnná se používá pro názvy souborů obrázků, takže může být zachyceno více obrázků s postupně se zvyšujícími názvy souborů - 1.jpg, 2.jpg a tak dále.

Poté definuje funkci saveToSDCard, která přijímá buffer dat bajtů a délku bufferu. Vytvoří se název souboru pomocí počtu souborů a počet souborů se zvýší, aby byl připraven na další soubor. Binární data z bufferu jsou poté zapsána do souboru.

Zavolejte funkci saveToSDCard z funkce buttonPressed. Volání by mělo být předtím, než je buffer smazán:

Serial.print("Image read to buffer with length ");
Serial.println(length);

saveToSDCard(buffer, length);

delete(buffer);

Sestavte a nahrajte tento kód a zkontrolujte výstup na sériovém monitoru. Pokaždé, když stisknete tlačítko C, bude zachycen obrázek a uložen na SD kartu.

Connecting to WiFi..
Connected!
Image captured
Image read to buffer with length 16392
Image written to file 1.jpg
Image captured
Image read to buffer with length 14344
Image written to file 2.jpg

Vypněte microSD kartu a vysuňte ji mírným zatlačením a uvolněním, a karta vyskočí. Možná budete potřebovat tenký nástroj, abyste to udělali. Připojte microSD kartu k vašemu počítači, abyste si mohli prohlédnout obrázky.

💁 Může trvat několik snímků, než se vyvážení bílé kamery samo upraví. Všimnete si toho podle barvy zachycených snímků, první několik může vypadat barevně nesprávně. Vždy to můžete obejít změnou kódu tak, aby zachytil několik snímků, které jsou ignorovány ve funkci setup.

Upozornění:
Tento dokument byl přeložen pomocí služby pro automatický překlad Co-op Translator. I když se snažíme o přesnost, mějte prosím na paměti, že automatické překlady mohou obsahovat chyby nebo nepřesnosti. Původní dokument v jeho původním jazyce by měl být považován za závazný zdroj. Pro důležité informace se doporučuje profesionální lidský překlad. Neodpovídáme za jakékoli nedorozumění nebo nesprávné interpretace vyplývající z použití tohoto překladu.

20 KiB Raw Permalink Blame History