ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನ ಡೆವಲಪರ್ಗಳಲ್ಲಿ ನಾನು ಒಬ್ಬ
ನೀವು ಹುಡುಕಾಟ ಎಂಜಿನ್ನಲ್ಲಿ "OpenCV ಆನ್ STM32 ಬೋರ್ಡ್" ಎಂದು ಟೈಪ್ ಮಾಡಿದರೆ, STM32 ಬೋರ್ಡ್ಗಳು ಅಥವಾ ಇತರ ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್ಗಳಲ್ಲಿ ಈ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಲು ಆಸಕ್ತಿ ಹೊಂದಿರುವ ಕೆಲವು ಜನರನ್ನು ನೀವು ಕಾಣಬಹುದು.
ಹೆಸರಿನಿಂದ ನಿರ್ಣಯಿಸುವುದು, ಅಗತ್ಯವಿರುವದನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕಾದ ಹಲವಾರು ವೀಡಿಯೊಗಳಿವೆ, ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ (ನಾನು ನೋಡಿದ ಎಲ್ಲಾ ವೀಡಿಯೊಗಳಲ್ಲಿ) STM32 ಬೋರ್ಡ್ನಲ್ಲಿ, ಕ್ಯಾಮೆರಾದಿಂದ ಚಿತ್ರವನ್ನು ಮಾತ್ರ ಸ್ವೀಕರಿಸಲಾಗಿದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಇಮೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಸಾಮಾನ್ಯ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಅಥವಾ ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಬೋರ್ಡ್ಗಳಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ರಾಸ್ಪ್ಬೆರಿ ಪೈ).
ಏಕೆ ಕಷ್ಟ?
ಹುಡುಕಾಟ ಪ್ರಶ್ನೆಗಳ ಜನಪ್ರಿಯತೆಯನ್ನು OpenCV ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಕಂಪ್ಯೂಟರ್ ವಿಷನ್ ಲೈಬ್ರರಿ ಎಂದು ವಿವರಿಸಲಾಗಿದೆ, ಅಂದರೆ ಹೆಚ್ಚಿನ ಡೆವಲಪರ್ಗಳು ಅದರೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದಾರೆ ಮತ್ತು ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್ನಲ್ಲಿ ಡೆಸ್ಕ್ಟಾಪ್-ಸಿದ್ಧ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವು ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಆದರೆ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಇನ್ನೂ ಜನಪ್ರಿಯ ರೆಡಿಮೇಡ್ ಪಾಕವಿಧಾನಗಳು ಏಕೆ ಇಲ್ಲ?
ಸಣ್ಣ ಶಾಲುಗಳಲ್ಲಿ OpenCV ಅನ್ನು ಬಳಸುವ ಸಮಸ್ಯೆಯು ಎರಡು ವೈಶಿಷ್ಟ್ಯಗಳಿಗೆ ಸಂಬಂಧಿಸಿದೆ:
- ನೀವು ಕನಿಷ್ಟ ಸೆಟ್ ಮಾಡ್ಯೂಲ್ಗಳೊಂದಿಗೆ ಲೈಬ್ರರಿಯನ್ನು ಕಂಪೈಲ್ ಮಾಡಿದರೆ, ದೊಡ್ಡ ಕೋಡ್ (ಹಲವಾರು ಮೆಗಾಬೈಟ್ಗಳ ಸೂಚನೆಗಳು) ಕಾರಣದಿಂದಾಗಿ ಅದೇ STM32F7Discovery (OS ಅನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳದೆ) ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಗೆ ಸರಿಹೊಂದುವುದಿಲ್ಲ.
- ಲೈಬ್ರರಿಯನ್ನು ಸಿ ++ ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ, ಅಂದರೆ
- ಧನಾತ್ಮಕ ರನ್ಟೈಮ್ಗೆ ಬೆಂಬಲದ ಅಗತ್ಯವಿದೆ (ವಿನಾಯಿತಿಗಳು, ಇತ್ಯಾದಿ)
- LibC/Posix ಗೆ ಕಡಿಮೆ ಬೆಂಬಲ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಎಂಬೆಡೆಡ್ ಸಿಸ್ಟಮ್ಗಳಿಗಾಗಿ OS ನಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ - ನಿಮಗೆ ಪ್ರಮಾಣಿತ ಪ್ಲಸ್ ಲೈಬ್ರರಿ ಮತ್ತು ಪ್ರಮಾಣಿತ STL ಟೆಂಪ್ಲೇಟ್ ಲೈಬ್ರರಿ (ವೆಕ್ಟರ್, ಇತ್ಯಾದಿ) ಅಗತ್ಯವಿದೆ.
ಎಂಬಾಕ್ಸ್ಗೆ ಪೋರ್ಟ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಎಂದಿನಂತೆ, ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ಗೆ ಪೋರ್ಟ್ ಮಾಡುವ ಮೊದಲು, ಅದನ್ನು ಡೆವಲಪರ್ಗಳು ಉದ್ದೇಶಿಸಿರುವ ರೂಪದಲ್ಲಿ ನಿರ್ಮಿಸಲು ಪ್ರಯತ್ನಿಸುವುದು ಒಳ್ಳೆಯದು. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇದರೊಂದಿಗೆ ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲ - ಮೂಲ ಕೋಡ್ ಅನ್ನು ಕಾಣಬಹುದು
ಒಳ್ಳೆಯ ಸುದ್ದಿ ಏನೆಂದರೆ, ಓಪನ್ಸಿವಿಯನ್ನು ಬಾಕ್ಸ್ನ ಹೊರಗೆ ಸ್ಥಿರ ಲೈಬ್ರರಿಯಾಗಿ ನಿರ್ಮಿಸಬಹುದು, ಇದು ಪೋರ್ಟಿಂಗ್ ಅನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ನಾವು ಪ್ರಮಾಣಿತ ಸಂರಚನೆಯೊಂದಿಗೆ ಲೈಬ್ರರಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಮತ್ತು ಅವರು ಎಷ್ಟು ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತಾರೆ ಎಂಬುದನ್ನು ನೋಡುತ್ತೇವೆ. ಪ್ರತಿಯೊಂದು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪ್ರತ್ಯೇಕ ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.
> 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 ಮತ್ತು .ಡೇಟಾ ಹೆಚ್ಚು ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ, ಆದರೆ ಕೋಡ್ 70 MiB ಗಿಂತ ಹೆಚ್ಚು. ನಿರ್ದಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್ಗೆ ಇದು ಸ್ಥಿರವಾಗಿ ಲಿಂಕ್ ಆಗಿದ್ದರೆ, ಕೋಡ್ ಕಡಿಮೆ ಆಗುತ್ತದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ.
ಸಾಧ್ಯವಾದಷ್ಟು ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಹೊರಹಾಕಲು ಪ್ರಯತ್ನಿಸೋಣ ಇದರಿಂದ ಕನಿಷ್ಠ ಉದಾಹರಣೆಯನ್ನು ಜೋಡಿಸಲಾಗುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ಓಪನ್ಸಿವಿ ಆವೃತ್ತಿಯನ್ನು ಸರಳವಾಗಿ ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ), ಆದ್ದರಿಂದ ನಾವು ನೋಡುತ್ತೇವೆ 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 ಕೋಡ್ ಇನ್ನೂ ಸಾಕಷ್ಟು ಇದೆ, ಆದರೆ ಈಗಾಗಲೇ ಯಶಸ್ಸಿನ ಭರವಸೆಯನ್ನು ನೀಡುತ್ತದೆ.
ಎಮ್ಯುಲೇಟರ್ನಲ್ಲಿ ರನ್ ಮಾಡಿ
ಎಮ್ಯುಲೇಟರ್ನಲ್ಲಿ ಡೀಬಗ್ ಮಾಡುವುದು ತುಂಬಾ ಸುಲಭ, ಆದ್ದರಿಂದ ಮೊದಲು ಲೈಬ್ರರಿಯು qemu ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಎಮ್ಯುಲೇಟೆಡ್ ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಆಗಿ, ನಾನು ಇಂಟಿಗ್ರೇಟರ್ / ಸಿಪಿ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿದ್ದೇನೆ, ಏಕೆಂದರೆ ಮೊದಲನೆಯದಾಗಿ, ಇದು ARM ಆಗಿದೆ, ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ಎಂಬಾಕ್ಸ್ ಈ ಪ್ಲಾಟ್ಫಾರ್ಮ್ಗಾಗಿ ಗ್ರಾಫಿಕ್ಸ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.
ಎಂಬಾಕ್ಸ್ ಬಾಹ್ಯ ಗ್ರಂಥಾಲಯಗಳನ್ನು ನಿರ್ಮಿಸುವ ಕಾರ್ಯವಿಧಾನವನ್ನು ಹೊಂದಿದೆ, ಅದನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು OpenCV ಅನ್ನು ಮಾಡ್ಯೂಲ್ ಆಗಿ ಸೇರಿಸುತ್ತೇವೆ (ಸ್ಥಿರ ಲೈಬ್ರರಿಗಳ ರೂಪದಲ್ಲಿ "ಕನಿಷ್ಠ" ನಿರ್ಮಾಣಕ್ಕಾಗಿ ಒಂದೇ ರೀತಿಯ ಆಯ್ಕೆಗಳನ್ನು ರವಾನಿಸುತ್ತೇವೆ), ಅದರ ನಂತರ ನಾನು ಈ ರೀತಿ ಕಾಣುವ ಸರಳ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇನೆ:
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()
ಕ್ಯೂಟಿ, ಜಿಟಿಕೆ ಮತ್ತು ವಿಂಡೋಸ್ ಇಂಟರ್ಫೇಸ್ಗಳ ಮೂಲಕ ಚಿತ್ರಗಳನ್ನು ಸೆಳೆಯಬಹುದು, ಇದು ಖಂಡಿತವಾಗಿಯೂ STM32 ಗಾಗಿ ಸಂರಚನೆಯಲ್ಲಿ ಇರುವುದಿಲ್ಲ. ವಾಸ್ತವವಾಗಿ, QT ಅನ್ನು STM32F7Discovery ನಲ್ಲಿಯೂ ಸಹ ಚಲಾಯಿಸಬಹುದು, ಆದರೆ ಇದನ್ನು ಇನ್ನೊಂದು ಲೇಖನದಲ್ಲಿ ಚರ್ಚಿಸಲಾಗುವುದು 🙂
ಎಡ್ಜ್ ಡಿಟೆಕ್ಟರ್ನ ಫಲಿತಾಂಶವನ್ನು ಯಾವ ಸ್ವರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂಬ ಸಣ್ಣ ಸ್ಪಷ್ಟೀಕರಣದ ನಂತರ, ನಾವು ಚಿತ್ರವನ್ನು ಪಡೆಯುತ್ತೇವೆ.
ಮೂಲ ಚಿತ್ರ
ಪರಿಣಾಮವಾಗಿ
STM32F7Discovery ನಲ್ಲಿ ರನ್ ಆಗುತ್ತಿದೆ
32F746GDISCOVERY ನಲ್ಲಿ ನಾವು ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ ಬಳಸಬಹುದಾದ ಹಲವಾರು ಹಾರ್ಡ್ವೇರ್ ಮೆಮೊರಿ ವಿಭಾಗಗಳಿವೆ.
- 320KiB RAM
- ಚಿತ್ರಕ್ಕಾಗಿ 1MiB ಫ್ಲ್ಯಾಷ್
- 8MiB SDRAM
- 16MiB QSPI NAND ಫ್ಲ್ಯಾಶ್
- microSD ಕಾರ್ಡ್ ಸ್ಲಾಟ್
ಚಿತ್ರಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು SD ಕಾರ್ಡ್ ಅನ್ನು ಬಳಸಬಹುದು, ಆದರೆ ಕನಿಷ್ಠ ಉದಾಹರಣೆಯನ್ನು ಚಲಾಯಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ತುಂಬಾ ಉಪಯುಕ್ತವಲ್ಲ.
ಪ್ರದರ್ಶನವು 480 × 272 ರ ರೆಸಲ್ಯೂಶನ್ ಅನ್ನು ಹೊಂದಿದೆ, ಅಂದರೆ ಫ್ರೇಮ್ಬಫರ್ ಮೆಮೊರಿಯು 522 ಬಿಟ್ಗಳ ಆಳದಲ್ಲಿ 240 ಬೈಟ್ಗಳಾಗಿರುತ್ತದೆ, ಅಂದರೆ. ಇದು RAM ನ ಗಾತ್ರಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಫ್ರೇಮ್ಬಫರ್ ಮತ್ತು ಹೀಪ್ (ಓಪನ್ಸಿವಿ ಸೇರಿದಂತೆ, ಚಿತ್ರಗಳು ಮತ್ತು ಸಹಾಯಕ ರಚನೆಗಳಿಗಾಗಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ) SDRAM ನಲ್ಲಿದೆ, ಉಳಿದಂತೆ (ಸ್ಟ್ಯಾಕ್ಗಳು ಮತ್ತು ಇತರ ಸಿಸ್ಟಮ್ ಅಗತ್ಯಗಳಿಗಾಗಿ ಮೆಮೊರಿ ) RAM ಗೆ ಹೋಗುತ್ತದೆ.
STM32F7Discovery ಗಾಗಿ ನಾವು ಕನಿಷ್ಟ ಸಂರಚನೆಯನ್ನು ತೆಗೆದುಕೊಂಡರೆ (ಸಂಪೂರ್ಣ ನೆಟ್ವರ್ಕ್, ಎಲ್ಲಾ ಆಜ್ಞೆಗಳನ್ನು ಹೊರಹಾಕಿ, ಸ್ಟಾಕ್ಗಳನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ಚಿಕ್ಕದಾಗಿ ಮಾಡಿ, ಇತ್ಯಾದಿ) ಮತ್ತು ಅಲ್ಲಿ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ OpenCV ಅನ್ನು ಸೇರಿಸಿದರೆ, ಅಗತ್ಯವಿರುವ ಮೆಮೊರಿಯು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:
text data bss dec hex filename
2876890 459208 312736 3648834 37ad42 build/base/bin/embox
ಯಾವ ವಿಭಾಗಗಳು ಎಲ್ಲಿಗೆ ಹೋಗುತ್ತವೆ ಎಂಬುದರ ಬಗ್ಗೆ ಹೆಚ್ಚು ಪರಿಚಯವಿಲ್ಲದವರಿಗೆ, ನಾನು ವಿವರಿಸುತ್ತೇನೆ: in .text
и .rodata
ಸೂಚನೆಗಳು ಮತ್ತು ಸ್ಥಿರಾಂಕಗಳು (ಸ್ಥೂಲವಾಗಿ ಹೇಳುವುದಾದರೆ, ಓದಲು ಮಾತ್ರ ಡೇಟಾ) ಇರುತ್ತದೆ .data
ಡೇಟಾ ಬದಲಾಗಬಲ್ಲದು, .bss
"ಶೂನ್ಯ" ಅಸ್ಥಿರಗಳಿವೆ, ಆದಾಗ್ಯೂ, ಒಂದು ಸ್ಥಳದ ಅಗತ್ಯವಿದೆ (ಈ ವಿಭಾಗವು RAM ಗೆ "ಹೋಗುತ್ತದೆ").
ಒಳ್ಳೆಯ ಸುದ್ದಿ ಅದು .data
/.bss
ಹೊಂದಿಕೊಳ್ಳಬೇಕು, ಆದರೆ ಜೊತೆಗೆ .text
ತೊಂದರೆಯೆಂದರೆ ಚಿತ್ರಕ್ಕೆ ಕೇವಲ 1MiB ಮೆಮೊರಿ ಇದೆ. ಹೊರಹಾಕಬಹುದು .text
ಉದಾಹರಣೆಯಿಂದ ಚಿತ್ರವನ್ನು ಓದಿ ಮತ್ತು ಅದನ್ನು ಓದಿ, ಉದಾಹರಣೆಗೆ, ಪ್ರಾರಂಭದಲ್ಲಿ SD ಕಾರ್ಡ್ನಿಂದ ಮೆಮೊರಿಗೆ, ಆದರೆ fruits.png ಸುಮಾರು 330KiB ತೂಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಇದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದಿಲ್ಲ: ಹೆಚ್ಚಿನವು .text
OpenCV ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ.
ದೊಡ್ಡದಾಗಿ, ಕೇವಲ ಒಂದು ವಿಷಯ ಮಾತ್ರ ಉಳಿದಿದೆ - ಕೋಡ್ನ ಭಾಗವನ್ನು QSPI ಫ್ಲ್ಯಾಷ್ಗೆ ಲೋಡ್ ಮಾಡುವುದು (ಇದು ಸಿಸ್ಟಮ್ ಬಸ್ಗೆ ಮೆಮೊರಿಯನ್ನು ಮ್ಯಾಪಿಂಗ್ ಮಾಡಲು ವಿಶೇಷ ಕಾರ್ಯಾಚರಣೆಯ ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ, ಇದರಿಂದಾಗಿ ಪ್ರೊಸೆಸರ್ ಈ ಡೇಟಾವನ್ನು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು). ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಮಸ್ಯೆ ಉದ್ಭವಿಸುತ್ತದೆ: ಮೊದಲನೆಯದಾಗಿ, ಸಾಧನವನ್ನು ರೀಬೂಟ್ ಮಾಡಿದ ತಕ್ಷಣ QSPI ಫ್ಲ್ಯಾಷ್ ಡ್ರೈವ್ನ ಮೆಮೊರಿ ಲಭ್ಯವಿರುವುದಿಲ್ಲ (ನೀವು ಮೆಮೊರಿ-ಮ್ಯಾಪ್ ಮಾಡಿದ ಮೋಡ್ ಅನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ), ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ನೀವು ಈ ಮೆಮೊರಿಯನ್ನು "ಫ್ಲಾಶ್" ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಒಂದು ಪರಿಚಿತ ಬೂಟ್ಲೋಡರ್.
ಪರಿಣಾಮವಾಗಿ, QSPI ನಲ್ಲಿ ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಲಿಂಕ್ ಮಾಡಲು ನಿರ್ಧರಿಸಲಾಯಿತು, ಮತ್ತು TFTP ಮೂಲಕ ಅಗತ್ಯವಿರುವ ಬೈನರಿಯನ್ನು ಸ್ವೀಕರಿಸುವ ಸ್ವಯಂ-ಬರೆದ ಲೋಡರ್ನೊಂದಿಗೆ ಅದನ್ನು ಫ್ಲಾಶ್ ಮಾಡಲು ನಿರ್ಧರಿಸಲಾಯಿತು.
ಪರಿಣಾಮವಾಗಿ
ಈ ಲೈಬ್ರರಿಯನ್ನು ಎಂಬಾಕ್ಸ್ಗೆ ಪೋರ್ಟ್ ಮಾಡುವ ಕಲ್ಪನೆಯು ಸುಮಾರು ಒಂದು ವರ್ಷದ ಹಿಂದೆ ಕಾಣಿಸಿಕೊಂಡಿತು, ಆದರೆ ಹಲವಾರು ಕಾರಣಗಳಿಂದ ಅದನ್ನು ಮತ್ತೆ ಮತ್ತೆ ಮುಂದೂಡಲಾಯಿತು. ಅವುಗಳಲ್ಲಿ ಒಂದು libstdc++ ಮತ್ತು ಪ್ರಮಾಣಿತ ಟೆಂಪ್ಲೇಟ್ ಲೈಬ್ರರಿಗೆ ಬೆಂಬಲವಾಗಿದೆ. ಎಂಬಾಕ್ಸ್ನಲ್ಲಿನ ಸಿ ++ ಬೆಂಬಲದ ಸಮಸ್ಯೆ ಈ ಲೇಖನದ ವ್ಯಾಪ್ತಿಯನ್ನು ಮೀರಿದೆ, ಆದ್ದರಿಂದ ಈ ಲೈಬ್ರರಿ ಕೆಲಸ ಮಾಡಲು ಸರಿಯಾದ ಪ್ರಮಾಣದಲ್ಲಿ ನಾವು ಈ ಬೆಂಬಲವನ್ನು ಸಾಧಿಸಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಮಾತ್ರ ಇಲ್ಲಿ ಹೇಳುತ್ತೇನೆ 🙂
ಕೊನೆಯಲ್ಲಿ, ಈ ಸಮಸ್ಯೆಗಳನ್ನು ನಿವಾರಿಸಲಾಗಿದೆ (ಓಪನ್ಸಿವಿ ಉದಾಹರಣೆ ಕೆಲಸ ಮಾಡಲು ಕನಿಷ್ಠ ಸಾಕು), ಮತ್ತು ಉದಾಹರಣೆಯು ನಡೆಯಿತು. ಕ್ಯಾನಿ ಫಿಲ್ಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಗಡಿಗಳನ್ನು ಹುಡುಕಲು ಬೋರ್ಡ್ಗೆ 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 ಫ್ಲಾಶ್ ಡ್ರೈವ್ಗೆ qspi.bin.bin ಅನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಿ. ಹೋಸ್ಟ್ನಲ್ಲಿ, ಇದನ್ನು ಮಾಡಲು, 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
ಎಂಬಾಕ್ಸ್ನಲ್ಲಿ (ಅಂದರೆ ಬೂಟ್ಲೋಡರ್ನಲ್ಲಿ), ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾಗಿದೆ (ಸರ್ವರ್ ವಿಳಾಸ 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