Аз съм един от разработчиците на операционната система Embox, и в тази статия ще разкажа за това как успях да стартирам OpenCV на платка STM32746G.

Ако потърсите нещо като „OpenCV на платка STM32“, можете да намерите много хора, които се интересуват от използването на тази библиотека на платки STM32 или други микроконтролери.
Има няколко видеа, които според заглавията би трябвало да демонстрират това, което е нужно, но обикновено (във всички видеа, които съм виждал) на платката STM32 се прави само получаване на изображение от камерата и извеждане на резултата на екрана, а самата обработка на изображението става или на обикновен компютър, или на по-мощни платки (например Raspberry Pi).

Защо е сложен този процес?

Популярността на търсенията се обяснява с това, че OpenCV е най-популярната библиотека за компютърно зрение, а следователно повече разработчици са запознати с нея, и възможността да се стартира код, предназначен за десктоп, на микроконтролер значително улеснява процеса на разработка. Но защо все още няма популярни готови рецепти за решаване на този проблем?

Проблемът с използването на OpenCV на малки платки е свързан с две особености:

• Ако компилирате библиотеката дори с минимален набор от модули, тя просто не ще се побере в флаш паметта на същата STM32F7Discovery (дори без да се отчита ОС) поради много голям код (няколко мегабайта инструкции)
• Самата библиотека е написана на C++, следователно
  • Необходима е поддръжка на C++ рантайм (изключения и т.н.)
  • Няма достатъчно поддръжка на LibC/Posix, която обикновено съществува в ОС за вградени системи — нужна е стандартна библиотека на C++ и стандартна библиотека за шаблони STL (vector и т.н.)

Портиране на Embox

Както обикновено, преди портиране на каквито и да е програми в операционната система, е добре да опитате да я съберете в вида, в който я е замислил разработчикът. В нашия случай проблеми с това не възникват — източниците могат да се намерят на GitHub, библиотеката се сглобява под GNU/Linux обикновен cmake.

От добрите новини — OpenCV може да се сглобява от самото начало като статична библиотека, което прави портирането по-лесно. Сглобяваме библиотеката със стандартна конфигурация и виждаме колко място заема. Всеки модул се сглобява в отделна библиотека.

> size lib/*so --totals
   text    data     bss     dec     hex filename
1945822   15431     960 1962213  1df0e5 lib/libopencv_calib3d.so
17081885     170312   25640 17277837    107a38d lib/libopencv_core.so
10928229     137640   20192 11086061     a928ed lib/libopencv_dnn.so
 842311   25680    1968  869959   d4647 lib/libopencv_features2d.so
 423660    8552     184  432396   6990c lib/libopencv_flann.so
8034733   54872    1416 8091021  7b758d lib/libopencv_gapi.so
  90741    3452     304   94497   17121 lib/libopencv_highgui.so
6338414   53152     968 6392534  618ad6 lib/libopencv_imgcodecs.so
21323564     155912  652056 22131532    151b34c lib/libopencv_imgproc.so
 724323   12176     376  736875   b3e6b lib/libopencv_ml.so
 429036    6864     464  436364   6a88c lib/libopencv_objdetect.so
6866973   50176    1064 6918213  699045 lib/libopencv_photo.so
 698531   13640     160  712331   ade8b lib/libopencv_stitching.so
 466295    6688     168  473151   7383f lib/libopencv_video.so
 315858    6972   11576  334406   51a46 lib/libopencv_videoio.so
76510375     721519  717496 77949390    4a569ce (TOTALS)

Както можем да видим от последния ред, .bss и .data заемат не толкова много пространство, но кодът е над 70 МиБ. Ясно е, че ако това бъде статично свързано с конкретно приложение, кодът ще намалее.

Нека опитаме да изключим колкото се може повече модули, за да изградим минимален пример (който, например, просто ще изведе версията на OpenCV), така че да гледаме. cmake .. -LA и изключваме във опциите всичко, което може да се изключи.

        -DBUILD_opencv_java_bindings_generator=OFF 
        -DBUILD_opencv_stitching=OFF 
        -DWITH_PROTOBUF=OFF 
        -DWITH_PTHREADS_PF=OFF 
        -DWITH_QUIRC=OFF 
        -DWITH_TIFF=OFF 
        -DWITH_V4L=OFF 
        -DWITH_VTK=OFF 
        -DWITH_WEBP=OFF

> size lib/libopencv_core.a --totals
   text    data     bss     dec     hex filename
3317069   36425   17987 3371481  3371d9 (TOTALS)

От една страна, това е само един модул от библиотеката, от друга страна, това е без оптимизация от компилатора по размер на кода (-Os). ~3 МиБ код — това все още е доста много, но вече дава надежда за успех.

Стартиране в емулатор

На емулатора е много по-лесно да се отстраняват грешки, така че първо ще се уверим, че библиотеката работи на qemu. Като емулирана платформа избрах Integrator/CP, тъй като, от една страна, това е също ARM, а от друга, Embox поддържа графичен изход за тази платформа.

В Embox има механизъм за изграждане на външни библиотеки, с помощта на който добавяме OpenCV като модул (передавайки всички същите опции за "минимално" изграждане под формата на статични библиотеки), след което добавям проста програма, която изглежда така:

version.cpp:

#include 
#include 

int main() {
    printf("OpenCV: %s", cv::getBuildInformation().c_str());

    return 0;
}

Сглобяваме системата, стартираме — получаваме очаквания изход.

root@embox: /#opencv_version
OpenCV:
Обща конфигурация за OpenCV 4.0.1 =====================================
  Контрол на версията:               bd6927bdf-dirty

  Платформа:
    Времеви печат:                   2019-06-21T10:02:18Z
    Хост:                        Linux 5.1.7-arch1-1-ARCH x86_64
    Цел:                      Generic arm-unknown-none
    CMake:                       3.14.5
    Генератор на CMake:             Unix Makefiles
    Инструмент за изграждане на CMake:            /usr/bin/make
    Конфигурация:               Debug

  CPU/HW функции:
    Базова:
      поиск:                 DETECT
      деактивирано:                  VFPV3 NEON

  C/C++:
    Изградени като динамични библиотеки?:      НЕ

Следващата стъпка е да стартирате някакъв пример, по-добре стандартен от тези, които предлагат самите разработчици на техния сайт. Аз избрах детектора на ръбове Кенни.

Примерът беше малко променен, за да показва изображението с резултата директно във фрейм-буфера. Това трябваше да се направи, тъй като функцията imshow() може да изобразява изображения чрез интерфейсите QT, GTK и Windows, които очевидно няма да бъдат в конфигурацията за STM32. Всъщност, QT също може да бъде стартиран на STM32F7Discovery, но за това ще се говори в друга статия 🙂

След кратко изясняване в какъв точно формат се съхранява резултатът от работа на детектора на ръбове, получаваме изображение.

Оригинално изображение

Резултат

Стартиране на STM32F7Discovery

На 32F746GDISCOVERY има няколко хардуерни секции на паметта, които можем по един или друг начин да използваме

1. 320KiB оперативна памет
2. 1MiB флаш памет за образа
3. 8MiB SDRAM
4. 16MiB QSPI NAND флаш
5. Порт за microSD карта

SD картата може да се използва за съхранение на изображения, но в контекста на стартиране на минимален пример, това не е много полезно.
Дисплеят има разрешение 480×272, което означава, че паметта за фрейм-буфера ще бъде 522 240 байта при дълбочина от 32 бита, т.е. това е повече от размера на оперативната памет, така че фрейм-буфера и купчината (която ще е необходима и за OpenCV, за да съхранява данни за изображения и помощни структури) ще се разположат в SDRAM, всичко останало (паметта за стекове и други системни нужди) ще отиде в RAM.

Ако вземете минималната конфигурация за STM32F7Discovery (да изхвърлите мрежата, всички команди, да направите стековете колкото се може по-малки и т.н.) и добавите OpenCV с примери, необходимата памет ще бъде следната:

   text    data     bss     dec     hex filename
2876890  459208  312736 3648834  37ad42 build/base/bin/embox

За тези, които не са много запознати с това, какви секции къде се поставят, ще обясня: в .text и .rodata се намират инструкции и константи (грубо казано, readonly-данни), в .data се намират променливи данни, в .bss се намират „нулевите“ променливи, на които все пак им е необходимо място (тази секция „отива“ в RAM).

Добрата новина е, че .data/.bss трябва да се поберат, но с .text проблем — под образа има само 1MiB памет. Може да изхвърлим от .text картината от примера и да я четем, например, от SD-картата в паметта при стартиране, но fruits.png тежи около 330KiB, така че това не решава проблема: голямата част .text състои точно от кода на OpenCV.

В крайна сметка остава само едно — да се зареди част от кода на QSPI-флашка (тя има специален режим на работа за мапиране на паметта на системната шина, така че процесорът може да достъпи тези данни директно). При това възниква проблем: първо, паметта на QSPI-флашката не е достъпна веднага след рестартиране на устройството (необходимо е отделно инициализиране на режима за мапиране на паметта), второ, не може да се „запише“ тази памет с обичайния загрузчик.

В резултат бе решено да се свърже целият код в QSPI, а да се запише с самописен загрузчик, който да получава необходимия бинарник по TFTP.

Резултат

Идеята да се портва тази библиотека на Embox се появи преди около година, но нонстоп се отлага по различни причини. Една от тях — поддръжка на libstdc++ и стандартната библиотека с шаблони. Проблемът с поддръжката на C++ в Embox надхвърля обсега на тази статия, затова тук просто ще кажа, че успяхме да постигнем тази поддръжка в необходимия обем за работа на тази библиотека 🙂

В резултат на това тези проблеми бяха преодоляни (най-малкото, в достатъчна степен за работа с примера OpenCV), и примерът се стартира. 40 дълги секунди отнема на платката да намери границите с филтъра Кени. Това, разбира се, е твърде дълго (има идеи как да оптимизираме този процес, по което може да се напише отделна статия в случай на успех).

Все пак, междинната цел беше създаването на прототип, който да покаже принципната възможност за стартиране на OpenCV на STM32, следователно, тази цел беше постигната, ура!

tl;dr: стъпкова инструкция

0: Изтеглете изходниците на Embox, например така:

    git clone https://github.com/embox/embox && cd ./embox

1: Да започнем със създаването на загрузчика, който „ще запише“ QSPI-флашката.

    make confload-arm/stm32f7cube

Сега трябва да настроим мрежата, тъй като изображенията ще се зареждат по TFTP. За да зададете IP адресите на платката и хоста, е необходимо да промените файла conf/rootfs/network.

Примерна конфигурация:

iface eth0 inet static
    address 192.168.2.2
    netmask 255.255.255.0
    gateway 192.168.2.1
    hwaddress aa:bb:cc:dd:ee:02

gateway — адрес на хоста, от който ще бъде заредено изображението, address — адрес на платката.

След това събираме буутлоудера:

    направи

2: Обикновено зареждане на буутлоудера (извинете за каламбура) на платката — тук няма нищо специфично, необходимо е да се направи както за всяко друго приложение за STM32F7Discovery. Ако не знаете как става това, можете да прочетете за него тук.
3: Компилиране на изображението с конфигурация за OpenCV.

    make confload-platform/opencv/stm32f7discovery
    make

4: Извличане от ELF секции, които трябва да бъдат записани в QSPI, в qspi.bin

    arm-none-eabi-objcopy -O binary build/base/bin/embox build/base/bin/qspi.bin 
        --only-section=.text --only-section=.rodata 
        --only-section='.ARM.ex*' 
        --only-section=.data

В директорията conf има скрипт, който прави това, така че можете да го стартирате

    ./conf/qspi_objcopy.sh # Нужният бинарен файл -- build/base/bin/qspi.bin

5: С помощта на tftp зареждаме qspi.bin.bin на QSPI флашка. На хоста е необходимо да копирате qspi.bin в кореновата папка на tftp сървъра (обикновено това е /srv/tftp/ или /var/lib/tftpboot/; пакетите за съответния сървър са налични в повечето популярни дистрибуции, обикновено се нарича tftpd или tftp-hpa, понякога трябва да стартирате systemctl start tftpd.service за да започне).

    # вариант для tftpd
    sudo cp build/base/bin/qspi.bin /srv/tftp
    # вариант для tftp-hpa
    sudo cp build/base/bin/qspi.bin /var/lib/tftpboot

На Embox (т.е. в буутлоудера) трябва да се изпълни следната команда (предполагам, че адресът на сървъра е 192.168.2.1):

    embox> qspi_loader qspi.bin 192.168.2.1

6: С помощта на командата goto е необходимо да „скочите“ в QSPI паметта. Конкретната локация ще варира в зависимост от това как е свързано изображението, можете да видите този адрес с командата mem 0x90000000 (адресът на старта се побира в второто 32-битово слово на изображението); също така ще е необходимо да се зададе стека с флаг -s, адресът на стека е на адрес 0x90000000, пример:

    embox>mem 0x90000000
    0x90000000:     0x20023200  0x9000c27f  0x9000c275  0x9000c275
                      ↑           ↑
              това е адресът    това е адресът 
                на стека        на първата
                           инструкция

    embox>goto -i 0x9000c27f -s 0x20023200 # Флагът -i е необходим, за да се забранят прекъсванията по време на инициализацията на системата

7: Запускаме

    embox> edges 20

и се наслаждаваме на 40-секундно търсене на граници 🙂

Ако нещо не върви по план — пишете issue в нашето хранилище, или в mailing list-a embox-devel@googlegroups.com, или в коментарите тук.

Източник: habr.com