ਮੈਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਡਿਵੈਲਪਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਾਂ ਐਮਬਾਕਸ, ਅਤੇ ਇਸ ਲੇਖ ਵਿਚ ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ ਕਿ ਮੈਂ STM32746G ਬੋਰਡ 'ਤੇ ਓਪਨਸੀਵੀ ਨੂੰ ਚਲਾਉਣ ਲਈ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ.

ਜੇਕਰ ਤੁਸੀਂ ਖੋਜ ਇੰਜਣ ਵਿੱਚ "STM32 ਬੋਰਡ 'ਤੇ ਓਪਨਸੀਵੀ" ਵਰਗਾ ਕੁਝ ਟਾਈਪ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਲੱਭ ਸਕਦੇ ਹੋ ਜੋ STM32 ਬੋਰਡਾਂ ਜਾਂ ਹੋਰ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ 'ਤੇ ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਨ।
ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਵਿਡੀਓਜ਼ ਹਨ ਜੋ, ਨਾਮ ਦੁਆਰਾ ਨਿਰਣਾ ਕਰਦੇ ਹੋਏ, ਇਹ ਦਿਖਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕੀ ਲੋੜ ਹੈ, ਪਰ ਆਮ ਤੌਰ 'ਤੇ (ਸਾਰੇ ਵੀਡੀਓਜ਼ ਵਿੱਚ ਜੋ ਮੈਂ ਦੇਖਿਆ ਹੈ) STM32 ਬੋਰਡ 'ਤੇ, ਕੈਮਰੇ ਤੋਂ ਸਿਰਫ ਚਿੱਤਰ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਨਤੀਜਾ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਅਤੇ ਚਿੱਤਰ ਪ੍ਰੋਸੈਸਿੰਗ ਜਾਂ ਤਾਂ ਇੱਕ ਨਿਯਮਤ ਕੰਪਿਊਟਰ 'ਤੇ, ਜਾਂ ਵਧੇਰੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਬੋਰਡਾਂ 'ਤੇ ਕੀਤੀ ਜਾਂਦੀ ਸੀ (ਉਦਾਹਰਨ ਲਈ, ਰਾਸਬੇਰੀ ਪਾਈ)।

ਇਹ ਖਾ ਕਿਉਂ ਹੈ?

ਖੋਜ ਸਵਾਲਾਂ ਦੀ ਪ੍ਰਸਿੱਧੀ ਇਸ ਤੱਥ ਦੁਆਰਾ ਵਿਆਖਿਆ ਕੀਤੀ ਗਈ ਹੈ ਕਿ ਓਪਨਸੀਵੀ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਕੰਪਿਊਟਰ ਵਿਜ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੋਰ ਡਿਵੈਲਪਰ ਇਸ ਤੋਂ ਜਾਣੂ ਹਨ, ਅਤੇ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ 'ਤੇ ਡੈਸਕਟੌਪ-ਤਿਆਰ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਹੁਤ ਸਰਲ ਬਣਾਉਂਦੀ ਹੈ। ਪਰ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਅਜੇ ਵੀ ਕੋਈ ਪ੍ਰਸਿੱਧ ਤਿਆਰ ਪਕਵਾਨ ਕਿਉਂ ਨਹੀਂ ਹਨ?

ਛੋਟੇ ਸ਼ਾਲਾਂ 'ਤੇ ਓਪਨਸੀਵੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਮੱਸਿਆ ਦੋ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਸਬੰਧਤ ਹੈ:

• ਜੇਕਰ ਤੁਸੀਂ ਮੌਡਿਊਲਾਂ ਦੇ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਸੈੱਟ ਦੇ ਨਾਲ ਵੀ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਕੰਪਾਇਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਇੱਕ ਬਹੁਤ ਵੱਡੇ ਕੋਡ (ਕਈ ਮੈਗਾਬਾਈਟ ਨਿਰਦੇਸ਼ਾਂ) ਦੇ ਕਾਰਨ ਉਸੇ STM32F7Discovery (ਭਾਵੇਂ OS ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖੇ ਬਿਨਾਂ) ਦੀ ਫਲੈਸ਼ ਮੈਮੋਰੀ ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਹੋਵੇਗਾ।
• ਲਾਇਬ੍ਰੇਰੀ ਖੁਦ C++ ਵਿੱਚ ਲਿਖੀ ਗਈ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ
  • ਸਕਾਰਾਤਮਕ ਰਨਟਾਈਮ ਲਈ ਸਮਰਥਨ ਦੀ ਲੋੜ ਹੈ (ਅਪਵਾਦ, ਆਦਿ)
  • LibC/Posix ਲਈ ਥੋੜਾ ਸਮਰਥਨ, ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਏਮਬੈਡਡ ਸਿਸਟਮਾਂ ਲਈ OS ਵਿੱਚ ਪਾਇਆ ਜਾਂਦਾ ਹੈ - ਤੁਹਾਨੂੰ ਇੱਕ ਸਟੈਂਡਰਡ ਪਲੱਸ ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ਇੱਕ ਸਟੈਂਡਰਡ STL ਟੈਂਪਲੇਟ ਲਾਇਬ੍ਰੇਰੀ (ਵੈਕਟਰ, ਆਦਿ) ਦੀ ਲੋੜ ਹੈ।

Embox ਵਿੱਚ ਪੋਰਟਿੰਗ

ਆਮ ਵਾਂਗ, ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਪੋਰਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਇਸ ਨੂੰ ਉਸ ਰੂਪ ਵਿੱਚ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਹੈ ਜਿਸ ਵਿੱਚ ਵਿਕਾਸਕਰਤਾਵਾਂ ਨੇ ਇਸਦਾ ਇਰਾਦਾ ਕੀਤਾ ਸੀ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਸ ਨਾਲ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ - ਸਰੋਤ ਕੋਡ 'ਤੇ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ github, ਲਾਇਬ੍ਰੇਰੀ ਆਮ cmake ਨਾਲ GNU/Linux ਦੇ ਅਧੀਨ ਬਣਾਈ ਗਈ ਹੈ।

ਚੰਗੀ ਖ਼ਬਰ ਇਹ ਹੈ ਕਿ ਓਪਨਸੀਵੀ ਨੂੰ ਬਾਕਸ ਤੋਂ ਬਾਹਰ ਇੱਕ ਸਥਿਰ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਤੌਰ ਤੇ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਪੋਰਟਿੰਗ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਅਸੀਂ ਇੱਕ ਮਿਆਰੀ ਸੰਰਚਨਾ ਨਾਲ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਇਕੱਠੀ ਕਰਦੇ ਹਾਂ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਉਹ ਕਿੰਨੀ ਥਾਂ ਲੈਂਦੇ ਹਨ। ਹਰੇਕ ਮੋਡੀਊਲ ਨੂੰ ਇੱਕ ਵੱਖਰੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਇਕੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

> 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 MiB ਤੋਂ ਵੱਧ ਹੈ। ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਜੇਕਰ ਇਹ ਸਥਿਰ ਤੌਰ 'ਤੇ ਕਿਸੇ ਖਾਸ ਐਪਲੀਕੇਸ਼ਨ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ, ਤਾਂ ਕੋਡ ਘੱਟ ਹੋ ਜਾਵੇਗਾ।

ਆਉ ਵੱਧ ਤੋਂ ਵੱਧ ਮੋਡੀਊਲ ਕੱਢਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਤਾਂ ਕਿ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਉਦਾਹਰਨ ਇਕੱਠੀ ਕੀਤੀ ਜਾ ਸਕੇ (ਜੋ, ਉਦਾਹਰਨ ਲਈ, ਸਿਰਫ਼ 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 MiB ਅਜੇ ਵੀ ਕਾਫ਼ੀ ਹੈ, ਪਰ ਪਹਿਲਾਂ ਹੀ ਸਫਲਤਾ ਦੀ ਉਮੀਦ ਦਿੰਦਾ ਹੈ।

ਈਮੂਲੇਟਰ ਵਿੱਚ ਚਲਾਓ

ਇਮੂਲੇਟਰ 'ਤੇ ਡੀਬੱਗ ਕਰਨਾ ਬਹੁਤ ਸੌਖਾ ਹੈ, ਇਸ ਲਈ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਲਾਇਬ੍ਰੇਰੀ ਕਿਮੂ 'ਤੇ ਕੰਮ ਕਰਦੀ ਹੈ। ਇੱਕ ਇਮੂਲੇਟਡ ਪਲੇਟਫਾਰਮ ਦੇ ਰੂਪ ਵਿੱਚ, ਮੈਂ ਇੰਟੀਗ੍ਰੇਟਰ / CP ਚੁਣਿਆ, ਕਿਉਂਕਿ ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ARM ਵੀ ਹੈ, ਅਤੇ ਦੂਜਾ, Embox ਇਸ ਪਲੇਟਫਾਰਮ ਲਈ ਗ੍ਰਾਫਿਕਸ ਆਉਟਪੁੱਟ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।

ਐਮਬਾਕਸ ਵਿੱਚ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਬਣਾਉਣ ਲਈ ਇੱਕ ਵਿਧੀ ਹੈ, ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅਸੀਂ ਓਪਨਸੀਵੀ ਨੂੰ ਇੱਕ ਮੋਡੀਊਲ ਵਜੋਂ ਜੋੜਦੇ ਹਾਂ (ਸਟੈਟਿਕ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ "ਘੱਟੋ-ਘੱਟ" ਬਿਲਡ ਲਈ ਸਾਰੇ ਇੱਕੋ ਜਿਹੇ ਵਿਕਲਪਾਂ ਨੂੰ ਪਾਸ ਕਰਨਾ), ਇਸ ਤੋਂ ਬਾਅਦ ਮੈਂ ਇੱਕ ਸਧਾਰਨ ਐਪਲੀਕੇਸ਼ਨ ਜੋੜਦਾ ਹਾਂ ਜੋ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

version.cpp:

#include <stdio.h>
#include <opencv2/core/utility.hpp>

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

    return 0;
}

ਅਸੀਂ ਸਿਸਟਮ ਨੂੰ ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ, ਇਸਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ - ਸਾਨੂੰ ਉਮੀਦ ਕੀਤੀ ਆਉਟਪੁੱਟ ਮਿਲਦੀ ਹੈ.

root@embox:/#opencv_version                                                     
OpenCV: 
General configuration for OpenCV 4.0.1 =====================================
  Version control:               bd6927bdf-dirty

  Platform:
    Timestamp:                   2019-06-21T10:02:18Z
    Host:                        Linux 5.1.7-arch1-1-ARCH x86_64
    Target:                      Generic arm-unknown-none
    CMake:                       3.14.5
    CMake generator:             Unix Makefiles
    CMake build tool:            /usr/bin/make
    Configuration:               Debug

  CPU/HW features:
    Baseline:
      requested:                 DETECT
      disabled:                  VFPV3 NEON

  C/C++:
    Built as dynamic libs?:      NO
< Дальше идут прочие параметры сборки -- с какими флагами компилировалось,
  какие модули OpenCV включены в сборку и т.п.>

ਅਗਲਾ ਕਦਮ ਕੁਝ ਉਦਾਹਰਨਾਂ ਨੂੰ ਚਲਾਉਣਾ ਹੈ, ਤਰਜੀਹੀ ਤੌਰ 'ਤੇ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤੇ ਗਏ ਮਿਆਰੀ ਵਿੱਚੋਂ ਇੱਕ। ਤੁਹਾਡੀ ਸਾਈਟ 'ਤੇ. ਮੈਂ ਚੁਣ ਲਿਆ ਬਾਰਡਰ ਡਿਟੈਕਟਰ ਕੈਨੀ.

ਉਦਾਹਰਨ ਨੂੰ ਫ੍ਰੇਮ ਬਫਰ ਵਿੱਚ ਸਿੱਧੇ ਨਤੀਜੇ ਦੇ ਨਾਲ ਚਿੱਤਰ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਥੋੜ੍ਹਾ ਜਿਹਾ ਮੁੜ ਲਿਖਣਾ ਪਿਆ। ਮੈਨੂੰ ਇਹ ਕਰਨਾ ਪਿਆ, ਕਿਉਂਕਿ. ਫੰਕਸ਼ਨ imshow() QT, GTK ਅਤੇ ਵਿੰਡੋਜ਼ ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਚਿੱਤਰ ਖਿੱਚ ਸਕਦੇ ਹਨ, ਜੋ ਕਿ STM32 ਲਈ ਸੰਰਚਨਾ ਵਿੱਚ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਨਹੀਂ ਹੋਣਗੇ। ਅਸਲ ਵਿੱਚ, QT ਨੂੰ STM32F7Discovery 'ਤੇ ਵੀ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਸ ਬਾਰੇ ਕਿਸੇ ਹੋਰ ਲੇਖ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਜਾਵੇਗੀ 🙂

ਥੋੜ੍ਹੇ ਜਿਹੇ ਸਪਸ਼ਟੀਕਰਨ ਤੋਂ ਬਾਅਦ ਕਿਨਾਰੇ ਖੋਜਕ ਦਾ ਨਤੀਜਾ ਕਿਸ ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਸਾਨੂੰ ਇੱਕ ਚਿੱਤਰ ਮਿਲਦਾ ਹੈ।

ਅਸਲੀ ਤਸਵੀਰ

ਇਸ ਦਾ ਨਤੀਜਾ

STM32F7Discovery 'ਤੇ ਚੱਲ ਰਿਹਾ ਹੈ

32F746GDISCOVERY 'ਤੇ ਕਈ ਹਾਰਡਵੇਅਰ ਮੈਮੋਰੀ ਸੈਕਸ਼ਨ ਹਨ ਜੋ ਅਸੀਂ ਕਿਸੇ ਨਾ ਕਿਸੇ ਤਰੀਕੇ ਨਾਲ ਵਰਤ ਸਕਦੇ ਹਾਂ।

1. 320KiB ਰੈਮ
2. ਚਿੱਤਰ ਲਈ 1MiB ਫਲੈਸ਼
3. 8MiB SDRAM
4. 16MiB QSPI NAND ਫਲੈਸ਼
5. microSD ਕਾਰਡ ਸਲਾਟ

ਇੱਕ SD ਕਾਰਡ ਨੂੰ ਚਿੱਤਰਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਉਦਾਹਰਣ ਨੂੰ ਚਲਾਉਣ ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਇਹ ਬਹੁਤ ਉਪਯੋਗੀ ਨਹੀਂ ਹੈ.
ਡਿਸਪਲੇਅ ਦਾ ਰੈਜ਼ੋਲਿਊਸ਼ਨ 480×272 ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਫਰੇਮਬਫਰ ਮੈਮੋਰੀ 522 ਬਿੱਟ ਦੀ ਡੂੰਘਾਈ 'ਤੇ 240 ਬਾਈਟ ਹੋਵੇਗੀ, ਯਾਨੀ. ਇਹ RAM ਦੇ ਆਕਾਰ ਤੋਂ ਵੱਧ ਹੈ, ਇਸਲਈ ਫਰੇਮਬਫਰ ਅਤੇ ਹੀਪ (ਜਿਸ ਦੀ ਲੋੜ ਹੋਵੇਗੀ, OpenCV ਸਮੇਤ, ਚਿੱਤਰਾਂ ਅਤੇ ਸਹਾਇਕ ਢਾਂਚਿਆਂ ਲਈ ਡੇਟਾ ਸਟੋਰ ਕਰਨ ਲਈ) SDRAM ਵਿੱਚ ਸਥਿਤ ਹੋਣਗੇ, ਬਾਕੀ ਸਭ ਕੁਝ (ਸਟੈਕ ਲਈ ਮੈਮੋਰੀ ਅਤੇ ਹੋਰ ਸਿਸਟਮ ਲੋੜਾਂ) RAM 'ਤੇ ਜਾਵੇਗਾ।

ਜੇਕਰ ਅਸੀਂ STM32F7Discovery ਲਈ ਘੱਟੋ-ਘੱਟ ਸੰਰਚਨਾ ਲੈਂਦੇ ਹਾਂ (ਪੂਰਾ ਨੈੱਟਵਰਕ, ਸਾਰੀਆਂ ਕਮਾਂਡਾਂ, ਸਟੈਕ ਨੂੰ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਛੋਟਾ ਬਣਾਉ, ਆਦਿ) ਅਤੇ ਓਪਨਸੀਵੀ ਨੂੰ ਉਦਾਹਰਨਾਂ ਦੇ ਨਾਲ ਜੋੜਦੇ ਹਾਂ, ਤਾਂ ਲੋੜੀਂਦੀ ਮੈਮੋਰੀ ਇਸ ਤਰ੍ਹਾਂ ਹੋਵੇਗੀ:

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

ਉਹਨਾਂ ਲਈ ਜੋ ਬਹੁਤੇ ਜਾਣੂ ਨਹੀਂ ਹਨ ਕਿ ਕਿਹੜੇ ਭਾਗ ਕਿੱਥੇ ਜਾਂਦੇ ਹਨ, ਮੈਂ ਵਿਆਖਿਆ ਕਰਾਂਗਾ: ਵਿੱਚ .text и .rodata ਹਦਾਇਤਾਂ ਅਤੇ ਸਥਿਰਾਂਕ (ਮੋਟੇ ਤੌਰ 'ਤੇ, ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ ਡੇਟਾ) ਵਿੱਚ ਹਨ .data ਡੇਟਾ ਪਰਿਵਰਤਨਸ਼ੀਲ ਹੈ, .bss ਇੱਥੇ "ਨਲ" ਵੇਰੀਏਬਲ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ, ਫਿਰ ਵੀ, ਇੱਕ ਜਗ੍ਹਾ ਦੀ ਲੋੜ ਹੈ (ਇਹ ਭਾਗ RAM ਵਿੱਚ "ਜਾਵੇਗਾ")।

ਚੰਗੀ ਖ਼ਬਰ ਇਹ ਹੈ ਕਿ .data/.bss ਫਿੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਪਰ ਨਾਲ .text ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਚਿੱਤਰ ਲਈ ਸਿਰਫ 1MiB ਮੈਮੋਰੀ ਹੈ. ਬਾਹਰ ਸੁੱਟਿਆ ਜਾ ਸਕਦਾ ਹੈ .text ਉਦਾਹਰਨ ਤੋਂ ਤਸਵੀਰ ਲਓ ਅਤੇ ਇਸਨੂੰ ਪੜ੍ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਸ਼ੁਰੂਆਤੀ ਸਮੇਂ SD ਕਾਰਡ ਤੋਂ ਮੈਮੋਰੀ ਵਿੱਚ, ਪਰ fruits.png ਦਾ ਭਾਰ ਲਗਭਗ 330KiB ਹੈ, ਇਸ ਲਈ ਇਹ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਨਹੀਂ ਕਰੇਗਾ: ਜ਼ਿਆਦਾਤਰ .text OpenCV ਕੋਡ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।

ਆਮ ਤੌਰ 'ਤੇ, ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਚੀਜ਼ ਬਚੀ ਹੈ - ਕੋਡ ਦੇ ਇੱਕ ਹਿੱਸੇ ਨੂੰ ਇੱਕ QSPI ਫਲੈਸ਼ ਉੱਤੇ ਲੋਡ ਕਰਨਾ (ਇਸ ਵਿੱਚ ਸਿਸਟਮ ਬੱਸ ਵਿੱਚ ਮੈਮੋਰੀ ਨੂੰ ਮੈਪ ਕਰਨ ਲਈ ਓਪਰੇਸ਼ਨ ਦਾ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੋਡ ਹੈ, ਤਾਂ ਜੋ ਪ੍ਰੋਸੈਸਰ ਸਿੱਧੇ ਇਸ ਡੇਟਾ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕੇ)। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇੱਕ ਸਮੱਸਿਆ ਪੈਦਾ ਹੁੰਦੀ ਹੈ: ਪਹਿਲਾਂ, ਇੱਕ QSPI ਫਲੈਸ਼ ਡਰਾਈਵ ਦੀ ਮੈਮੋਰੀ ਡਿਵਾਈਸ ਦੇ ਰੀਬੂਟ ਹੋਣ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਉਪਲਬਧ ਨਹੀਂ ਹੁੰਦੀ ਹੈ (ਤੁਹਾਨੂੰ ਮੈਮੋਰੀ-ਮੈਪਡ ਮੋਡ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ), ਅਤੇ ਦੂਜਾ, ਤੁਸੀਂ ਇਸ ਮੈਮੋਰੀ ਨੂੰ "ਫਲੈਸ਼" ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ. ਇੱਕ ਜਾਣਿਆ ਬੂਟਲੋਡਰ.

ਨਤੀਜੇ ਵਜੋਂ, QSPI ਵਿੱਚ ਸਾਰੇ ਕੋਡ ਨੂੰ ਲਿੰਕ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਗਿਆ ਸੀ, ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਸਵੈ-ਲਿਖਤ ਲੋਡਰ ਨਾਲ ਫਲੈਸ਼ ਕਰੋ ਜੋ TFTP ਦੁਆਰਾ ਲੋੜੀਂਦੀ ਬਾਈਨਰੀ ਪ੍ਰਾਪਤ ਕਰੇਗਾ।

ਇਸ ਦਾ ਨਤੀਜਾ

ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਐਮਬਾਕਸ ਵਿੱਚ ਪੋਰਟ ਕਰਨ ਦਾ ਵਿਚਾਰ ਲਗਭਗ ਇੱਕ ਸਾਲ ਪਹਿਲਾਂ ਪ੍ਰਗਟ ਹੋਇਆ ਸੀ, ਪਰ ਕਈ ਕਾਰਨਾਂ ਕਰਕੇ ਇਸਨੂੰ ਵਾਰ-ਵਾਰ ਮੁਲਤਵੀ ਕਰ ਦਿੱਤਾ ਗਿਆ ਸੀ। ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ libstdc++ ਅਤੇ ਸਟੈਂਡਰਡ ਟੈਂਪਲੇਟ ਲਾਇਬ੍ਰੇਰੀ ਲਈ ਸਮਰਥਨ ਹੈ। Embox ਵਿੱਚ C++ ਸਹਾਇਤਾ ਦੀ ਸਮੱਸਿਆ ਇਸ ਲੇਖ ਦੇ ਦਾਇਰੇ ਤੋਂ ਬਾਹਰ ਹੈ, ਇਸ ਲਈ ਇੱਥੇ ਮੈਂ ਸਿਰਫ਼ ਇਹੀ ਕਹਾਂਗਾ ਕਿ ਅਸੀਂ ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਕੰਮ ਕਰਨ ਲਈ ਸਹੀ ਮਾਤਰਾ ਵਿੱਚ ਇਸ ਸਹਾਇਤਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਕਾਮਯਾਬ ਰਹੇ 🙂

ਅੰਤ ਵਿੱਚ, ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਦੂਰ ਕੀਤਾ ਗਿਆ (ਘੱਟੋ ਘੱਟ ਓਪਨਸੀਵੀ ਉਦਾਹਰਨ ਲਈ ਕੰਮ ਕਰਨ ਲਈ ਕਾਫ਼ੀ), ਅਤੇ ਉਦਾਹਰਨ ਚੱਲੀ। ਬੋਰਡ ਨੂੰ ਕੈਨੀ ਫਿਲਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੀਮਾਵਾਂ ਦੀ ਖੋਜ ਕਰਨ ਲਈ 40 ਲੰਬੇ ਸਕਿੰਟ ਲੱਗਦੇ ਹਨ। ਇਹ, ਬੇਸ਼ਕ, ਬਹੁਤ ਲੰਮਾ ਹੈ (ਇਸ ਮਾਮਲੇ ਨੂੰ ਕਿਵੇਂ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਹੈ ਇਸ ਬਾਰੇ ਵਿਚਾਰ ਹਨ, ਸਫਲਤਾ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਇਸ ਬਾਰੇ ਇੱਕ ਵੱਖਰਾ ਲੇਖ ਲਿਖਣਾ ਸੰਭਵ ਹੋਵੇਗਾ).

ਹਾਲਾਂਕਿ, ਵਿਚਕਾਰਲਾ ਟੀਚਾ ਇੱਕ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣਾ ਸੀ ਜੋ ਕ੍ਰਮਵਾਰ STM32 'ਤੇ OpenCV ਚਲਾਉਣ ਦੀ ਬੁਨਿਆਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਦਰਸਾਏਗਾ, ਇਹ ਟੀਚਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਹੂਰੇ!

tl; dr: ਕਦਮ ਦਰ ਕਦਮ ਨਿਰਦੇਸ਼

0: ਐਮਬਾਕਸ ਸਰੋਤਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ, ਇਸ ਤਰ੍ਹਾਂ:

    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 - ਬੋਰਡ ਦਾ ਪਤਾ.

ਉਸ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਬੂਟਲੋਡਰ ਨੂੰ ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ:

    make

2: ਬੋਰਡ 'ਤੇ ਬੂਟਲੋਡਰ ਦੀ ਆਮ ਲੋਡਿੰਗ (ਸ਼ੱਕ ਲਈ ਮਾਫੀ) - ਇੱਥੇ ਕੁਝ ਖਾਸ ਨਹੀਂ ਹੈ, ਤੁਹਾਨੂੰ STM32F7Discovery ਲਈ ਕਿਸੇ ਹੋਰ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਤਰ੍ਹਾਂ ਅਜਿਹਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਜੇ ਤੁਸੀਂ ਨਹੀਂ ਜਾਣਦੇ ਕਿ ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਇੱਥੇ.
3: OpenCV ਲਈ ਇੱਕ ਸੰਰਚਨਾ ਦੇ ਨਾਲ ਇੱਕ ਚਿੱਤਰ ਨੂੰ ਕੰਪਾਇਲ ਕਰਨਾ.

    make confload-platform/opencv/stm32f7discovery
    make

4: QSPI ਨੂੰ qspi.bin 'ਤੇ ਲਿਖਣ ਲਈ ELF ਭਾਗਾਂ ਤੋਂ ਐਕਸਟਰੈਕਟ

    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 нужен чтобы запретить прерывания во время инициализации системы

    < Начиная отсюда будет вывод не загрузчика, а образа с OpenCV >

7: ਲਾਂਚ ਕਰੋ

    embox> edges 20

ਅਤੇ 40-ਸਕਿੰਟ ਦੀ ਬਾਰਡਰ ਖੋਜ ਦਾ ਆਨੰਦ ਮਾਣੋ 🙂

ਜੇ ਕੁਝ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ - ਇਸ ਵਿੱਚ ਇੱਕ ਮੁੱਦਾ ਲਿਖੋ ਸਾਡੀ ਰਿਪੋਜ਼ਟਰੀ, ਜਾਂ ਮੇਲਿੰਗ ਸੂਚੀ ਵਿੱਚ [ਈਮੇਲ ਸੁਰੱਖਿਅਤ], ਜਾਂ ਇੱਥੇ ਇੱਕ ਟਿੱਪਣੀ ਵਿੱਚ.

ਸਰੋਤ: www.habr.com