დაიწყეთ STM32– ის განვითარება Linux– ზე: 4 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

ამ ინსტრუქციაში, მე ვაპირებ გაჩვენოთ რამდენად ადვილია Linux– ზე STM32 პროგრამების შემუშავების დაწყება. მე დავიწყე Linux– ის გამოყენება, როგორც ჩემი მთავარი მანქანა 2 წლის წინ და არ დამანებეს თავი. ყველაფერი მუშაობს უფრო სწრაფად და უკეთესად ვიდრე ფანჯრები. რა თქმა უნდა, დროდადრო ნაკლებად მოსახერხებელია, მაგრამ ეს აიძულებს თქვენ ისწავლოთ საგნები უფრო ღრმად, რათა გამოიყენოთ იგი.

ყოველ შემთხვევაში, ამ სასწავლო, სერიის ნაწილი, რომელსაც მე ვიწყებ აქ და youtube– ზე არის იმის შესახებ, თუ როგორ უნდა დავიწყო იგი. გთხოვთ, დარწმუნდეთ, რომ უყურებთ ჩემს youtube ვიდეოს, სადაც მე ავხსნი ყველაფერს, როგორც ერთ სეგმენტს და თქვენ შეგიძლიათ ჩემ გვერდით კოდირება.

ამ სერიაში მე გაჩვენებთ, თუ როგორ შეგიძლიათ განავითაროთ მხოლოდ ტექსტური რედაქტორი, როგორიცაა notepad, SublimeText ან Atom, ასე რომ თქვენ არ გჭირდებათ რაიმე საკუთრების პროგრამული უზრუნველყოფა ან IDE. ეს ისეთივე შიშველი ძვლებია, როგორც გასაკვირი ადვილია.

ნაბიჯი 1: ჩამოტვირთეთ ყველაფერი, რაც გჭირდებათ

თქვენ უნდა გადმოწეროთ სამი ნაწილი, რომ ყველაფერი იმუშაოს:

• GCC შემდგენელი ARM– ისთვის
• Firmware ფაილები STM32
• St-link პროგრამა
• საცდელი პროექტი

შემდგენელი არის პროგრამული უზრუნველყოფის ძირითადი ნაწილი, რომელიც ადგენს ჩვენს C კოდს ბიბლიოთეკის ყველა სხვა ფაილთან ერთად მანქანურ ენაზე, რომლის გაგებაც შეუძლია ჩვენს stm32 კონტროლერს. ჩამოტვირთეთ ამ შემდგენლის უახლესი წინასწარ შედგენილი ვერსია.

საქაღალდე, რომელიც შეიცავს STM32 firmware არის ის, რომელიც ინახავს ყველა დაწყებულ და ძირითად ფაილს, რომელიც საჭიროა ძირითადი პროცესორის მუშაობისთვის. ჩვენ ვიყენებთ სტანდარტულ პერიფერიულ ბიბლიოთეკას, რომელსაც HAL- მა გადააჭარბა. მე მომწონს StPeriphLibrary, როგორც კომპანიები, რომლებიც მუშაობენ ამ პროცესორებზე, იყენებენ მათ, რადგან ის არის ძლიერი და ძველი და მხარდაჭერილი. ის ასევე უფრო მკაცრია. ეს არ წყვეტს სამუშაოს, რომელიც თქვენ უნდა გააკეთოთ პერიფერიული მოწყობილობის ინიციალიზაციისთვის ან LED- ის ჩართვისთვის, მაგრამ ის აიძულებს თქვენ გაიგოთ როგორ მუშაობს ეს პროცესორები. ამის წყალობით თქვენ გაქვთ მეტი ცოდნა შინაგანი მუშაობის შესახებ და ამით აგრძნობინებთ ნებისმიერი ამოცანის პროგრამირებას.

პროგრამული უზრუნველყოფის ბოლო ნაწილია st-link. ის შენარჩუნებულია github– ზე და გამოიყენება შედგენილი ორობითი ფაილების გადასატანად პროცესორზე stlink IC დაფაზე, რომელიც ემსახურება როგორც SWD / JTAG პროგრამისტს / გამართულს.

ასევე მე მოგაწოდეთ პროექტის საქაღალდის ნიმუში, რომელზეც მოგვიანებით ვისაუბრებ და შეგიძლიათ გადმოწეროთ. ის არის პირველი VIDEO1 საქაღალდის შიგნით.

ნაბიჯი 2: პროგრამული უზრუნველყოფის ინსტალაცია

მას შემდეგ რაც გადმოტვირთავთ ყველა ფაილს, მე გირჩევთ ჩადოთ ისინი საერთო საქაღალდეში, რადგან ისინი ყველა ერთად გამოიყენება ერთი და იმავე მიზნით. მე ყველა საქაღალდე ჩავდე საქაღალდეში სახელწოდებით "ჩაშენებული" ჩემს HOME დირექტორიაში.

ჩვენ დავიწყებთ ყველაზე მარტივი, STM32 ბიბლიოთეკებით. თქვენ მიერ გადმოწერილი საქაღალდე შეიძლება დარჩეს იქ. უბრალოდ დარწმუნდით, რომ მიმოიხედე გარშემო, რომ ნახოთ სად ინახება შესაბამისი ფაილები. ამიტომ თქვენ შეგიძლიათ შეცვალოთ და შეცვალოთ მთავარი MakeFile, ასე რომ ის იმუშავებს თქვენს პლატფორმაზე.

მეორე უმარტივესი არის შემდგენელი. თქვენ ასევე არ გჭირდებათ ამის გაკეთება, მაგრამ ჩვენ ვაქცევთ შემდგენელს გლობალურად ხელმისაწვდომ ფუნქციად, ასე რომ თქვენ შეგიძლიათ დარეკოთ შემდგენელს ნებისმიერი საქაღალდიდან, მიუხედავად ბილიკისა. ყველა ნაბიჯი შეიძლება გაკეთდეს ტერმინალში ან gui– ში, მაგრამ მე მიყვარს ტერმინალის გამოყენება, რადგან გამოცდილების მიღებისას ის უფრო სწრაფად და მარტივად ხდება და მე გირჩევთ გამოიყენოთ ტერმინალი უფრო მეტად, თუ ამის გეშინიათ. აქ არის ნაბიჯები:

1. შედით თქვენს სახლის საქაღალდეში "/home/YOURUSERNAME/" ან "~/" ან ჩაწერეთ cd ტერმინალში
2. გახსენით ფაილი ".bashrc" აკრეფით: nano.bashrc
3. გადაახვიეთ ფაილის ბოლომდე და დაამატეთ ეს ხაზი: ექსპორტი PATH = $ PATH: ~/ჩადგმული/gcc-arm-none-eabi-8-2018-q4/bin
4. გასვლა შენახვით: CTRL+X, დააწკაპუნეთ Y, ENTER
5. გაუშვით ბრძანება: წყარო.bashrc ტერმინალური წყაროების განახლებისთვის
6. შეამოწმეთ მუშაობს თუ არა ყველაფერი აკრეფით: arm-none-eabi-gcc-ვერსია, მან უნდა აჩვენოს შემდგენლის უახლესი ვერსია

St-link– ის ინსტალაციისთვის, ამოიღეთ არქივი, რომელიც გადმოწერილი გაქვთ ჩაშენებულ საქაღალდეში. შემდეგ მიჰყევით ამ ნაბიჯებს:

1. გაიქეცი: გააკეთე
2. შედით საქაღალდეში "build/Release": cd build/Release
3. ჩაწერეთ ls და ნახავთ ორ შემსრულებელს, სახელწოდებით "st-flash" და "st-util"
4. გადაიტანეთ ეს ორი მშობლის დირექტორიაში stlink: mv st-flash st-util../../

5. თქვენ შეგიძლიათ, თუ გსურთ გამოიყენოთ ეს ორი ფუნქცია გლობალურად, შეცვალოთ ფაილი ".bashrc" დამატებით:

   საექსპორტო PATH = $ PATH:/ჩამონტაჟებული/stlink/

Სულ ეს არის! თქვენ გაქვთ ყველაფერი რაც გჭირდებათ. ახლა წაიღე შენი საყვარელი ტექსტური რედაქტორი. გამოიყენეთ მხოლოდ სტანდარტული, უფრო ჭკვიანი, როგორიცაა SublimeText ან Atom, ეს არის ის, რასაც მე ვიყენებ.

ნაბიჯი 3: საცდელი პროექტის შექმნა

ჩვენ ახლა შევქმნით პროექტის ნიმუშს, რომელიც შეგიძლიათ გამოიყენოთ ყოველი პროექტის დასაწყებად. ის ჰგავს შაბლონს, რომლის ყველა ძირითადი პარამეტრი უკვე დამუშავებულია.

შეგიძლიათ გადმოწეროთ ჩემს MEGA– ზე, ბმული არის ამ სასწავლო ინსტრუქციის პირველ საფეხურზე და ჩემი ყოველი youtube ვიდეოს ქვეშ. შიგნით არის ცარიელი main.c ფაილი, ასევე რამდენიმე დამწყები ფაილი ამ პროცესორისა და Makefile– ისთვის. Makefile არის ის, ვინც ეუბნება C შემდგენელს სად იპოვოს arm შემდგენელი, როგორ შეადგინოს და სად არის ყველა ბიბლიოთეკა. თქვენი პროექტის შესაბამისი ფაილების მისაღებად, შეგიძლიათ შეხვიდეთ STM32 ბიბლიოთეკის საქაღალდეში და შეამოწმოთ საქაღალდეები "პროექტი" ან "მაგალითები". შიგნით ნახავთ და დააკოპირებთ ამ ფაილებს: main.c, Makefile და XXX_conf.h, system_XXX.c. ასევე დაგჭირდებათ stm32_flash.ld ბმულის ფაილი, რომელიც შეგიძლიათ იხილოთ საქაღალდეში:

"/FLASH_Program/TrueSTUDIO/FLASH_Program/", რომელიც არის მაგალითის საქაღალდეში ან უბრალოდ მოძებნეთ ფაილი.

Makefile შეგიძლიათ იხილოთ ინტერნეტში ან გადაწერა ჩემი საქაღალდედან, მაგრამ თქვენ უნდა შეცვალოთ რამდენიმე რამ. მოდით განვიხილოთ ჩემი ჩანაწერის ფაილი და რისი შეცვლა შეგიძლიათ.

# გზა საქაღალდის დახშობისთვის კოდის ასატვირთად ბორტზე

STLINK = ~/ჩაშენებული/stlink # განათავსეთ თქვენი საწყისი ფაილები აქ (*.c) SRCS = main.c system_stm32f4xx.c # ბიბლიოთეკების წყაროს ფაილები #SRCS += stm32f4xx_rcc.c #SRCS += stm32f4xx_gpio.c # ორობითი იქნება გენერირებული ეს სახელი (.elf,.bin,.hex) PROJ_NAME = ტესტი # განათავსეთ თქვენი STM32F4 ბიბლიოთეკის კოდის დირექტორია აქ, შეცვალეთ თქვენი სახელი თქვენი სახელით STM_COMMON =/home/matej/Embedded/STM32F4-Discovery_FW_V1.1.0 # შემდგენლის პარამეტრები. შეცვალეთ მხოლოდ CFLAGS, რომ შეიცავდეს სხვა სათაურის ფაილებს. CC = arm -none -eabi -gcc OBJCOPY = arm -none -eabi -objcopy # შემდგენელი დროშები CFLAGS = -g -O2 -Wall -Tstm32_flash.ld CFLAGS += -DUSE_STDPERIPH_DRIVER CFLAGS += -mumb -mian -p = ქერქი-m4 -mthumb-interwork CFLAGS += -mfloat-abi = მყარი -mfpu = fpv4-sp-d16 CFLAGS += -I. # ჩართეთ ფაილები STM ბიბლიოთეკებიდან CFLAGS += -I $ (STM_COMMON)/ბიბლიოთეკები/CMSIS/ჩართეთ CFLAGS += -I $ (STM_COMMON)/ბიბლიოთეკები/CMSIS/ST/STM32F4xx/ჩართეთ CFLAGS += -I $ (STM_COMMON) ბიბლიოთეკები/STM32F4xx_StdPeriph_Driver/inc CFLAGS += -I $ (STM_COMMON)/Utilities/STM32F4 -Discovery # დაამატეთ გაშვების ფაილი SRCS += $ (STM_COMMON)/ბიბლიოთეკები/CMSIS/ST/STM32F4xxxx/წყარო/წყარო/წყარო s OBJS = $ (SRCS:.c =.o) vpath %.c $ (STM_COMMON)/ბიბლიოთეკები/STM32F4xx_StdPeriph_Driver/src \. PHONY: proj all: proj proj: $ (PROJ_NAME).elf $ (PROJ_NAME).elf: $ (SRCS) $ (CC) $ (CFLAGS) $^ -o $@ $ (OBJCOPY) -O ihex $ (PROJ_NAME).elf $ (PROJ_NAME). Hex $ (OBJCOPY) -O ორობითი $ (PROJ_NAME) საკუთარი თავი $ (PROJ_NAME). ბინის გაწმენდა: rm -f *.o $ (PROJ_NAME).elf $ (PROJ_NAME). Hex $ (PROJ_NAME).bin # Flash # STM32F4 დაწვა: proj $ (STLINK)/st -flash ჩაწერა $ (PROJ_NAME). კომბინირებული 0x80000000

• თქვენ შეგიძლიათ შეცვალოთ პირველი ხაზი, რათა შეცვალოთ გზა თქვენი დახურული სასარგებლო საქაღალდეში

• თქვენ შეგიძლიათ შეცვალოთ ხაზი თქვენი საქაღალდის დანიშნულების ადგილამდე ბიბლიოთეკებით და YOURUSERNAME- ით

  STM_COMMON =/მთავარი/YOURUSERNAME/ჩაშენებული/STM32F4-Discovery_FW_V1.1.0

• ასევე შეამოწმეთ განყოფილება, სადაც ყველა ბიბლიოთეკაა დაკავშირებული. ეს შეიძლება შეიცვალოს იმ პლატფორმის მიხედვით, რომელსაც თქვენ იყენებთ, ასე რომ გთხოვთ შეამოწმოთ ცვლილებები ფაილის ხეში. სხვაგან, რომელიც მოიცავს რაიმე ბილიკს გარკვეულ ფაილებზე, მაგალითად, მომდევნო სტრიქონი გაშვების ფაილით შეიძლება შეიცვალოს.

მას შემდეგ რაც თქვენ დაარედაქტირეთ ეს ყველაფერი Makefile– ში, შეგიძლიათ შეამოწმოთ მუშაობს თუ არა თქვენს დირექტორიაში ტერმინალის გახსნით და აკრეფით: make. თუ ის ადგენს ყველაფერს უპრობლემოდ, მაშინ თქვენ მზად ხართ. თუ არა, შეხედეთ შემდგენლის შეცდომებს და შეცვალეთ Makefile.

ასევე, როდესაც მე ვიყენებ Atom- ს, კოდის ორ ნაწილს ვდებ გვერდიგვერდ. ჩვეულებრივ main.c და Makefile მარცხნივ, რადგან თქვენ გჭირდებათ მხოლოდ ერთხელ Makefile- ის რედაქტირება და ბიბლიოთეკები მარჯვნივ. თქვენ შეგიძლიათ ნახოთ სურათზე, რომ მე გავხსენი საქაღალდე, რომელიც შეიცავს.c და.h ფაილებს თითოეული ბიბლიოთეკისთვის. ამ ყველაფრის ნახვა შეგიძლიათ ვიდეოებში.

ნაბიჯი 4: დასრულდა

ახლა, როდესაც თქვენ გაქვთ Makefile კონფიგურირებული და შემდგენელი მუშაობს, შეგიძლიათ გამოიყენოთ ეს საქაღალდე ყველა პროექტისთვის, როგორც შაბლონი, ასე რომ დარწმუნდით, რომ შეინახავთ ამ საქაღალდის ასლს.

ასევე შეგიძლიათ შეამოწმოთ st-flash და st-info პროგრამები თქვენი განვითარების დაფის ჩართვით და ტერმინალში აკრეფით:

st-info-გამოძიება

თქვენ შეგიძლიათ ნახოთ პლატფორმა, რომელსაც ცნობს პროგრამული უზრუნველყოფა და IC ოჯახი, ქეში და სხვა პერსონალი. შეგიძლიათ ჩაწეროთ:

ქ-ინფო

ყველა არსებული პარამეტრის სანახავად.

ახლა თქვენ შეგიძლიათ დაიწყოთ პროგრამირება. შემდეგ სასწავლო და ვიდეოში მე გაჩვენებთ GPIO- ს და საათების საფუძვლებს. ეს ორი არის საფუძველი ყველა დანარჩენისთვის, რადგან თითქმის ყველაფერი, რასაც დაფა ურთიერთობს, დასრულებულია GPIO– ით და ყველაფერი მუშაობს საათზე და თქვენ ნახავთ ამ პროცესორების პროგრამირების ნიმუშს.

მანამდე კი გმადლობთ, რომ შეამოწმეთ ჩემი სასწავლო და ჩემი youtube ვიდეო, თუ ეს ჯერ არ გაგიკეთებიათ.