🙍🏽 😞 ⛅️ जंग लगा हुआ। STM32F103C8T6 (ब्लैक पिल) डिबग बोर्ड का उपयोग करके कॉर्टेक्स-एम 3 प्रोसेसर के लिए विकास 👩🏼‍🎓 ⏭️ 👩🏼‍🏫

नमस्कार! मैं आपको रस्ट एंबेडेड प्रोजेक्ट से परिचित कराना चाहता हूं । यह हमें एम्बेडेड प्लेटफार्मों (एंबेडेड लिनक्स / आरटीओएस / बेयर मेटल) के विकास के लिए रस्ट प्रोग्रामिंग भाषा का उपयोग करने की अनुमति देता है।

इस लेख में, हम उन घटकों पर विचार करेंगे जो कॉर्टेक्स-एम 3 माइक्रोप्रोसेसर के लिए विकास शुरू करने के लिए आवश्यक हैं। उसके बाद हम एक सरल उदाहरण लिखेंगे - बिल्ट-इन एलईडी का निमिष।

ऐसा करने के लिए, हमें एक सस्ती और सस्ते चीनी डिबग बोर्ड STM32F103C8T6 या ब्लैक पिल (काले रंग और छोटे आकार के कारण) की आवश्यकता है। ब्लू - ब्लू पिल में बोर्ड का एक संस्करण भी है। मैं इसकी अनुशंसा नहीं करता, क्योंकि मैंने सुना है कि इसमें गलत अवरोधक है, जो यूएसबी पोर्ट का उपयोग करते समय समस्याओं का कारण बनता है। पिंस (निष्कर्ष) की व्यवस्था में ब्लैक पिल से इसका दूसरा अंतर। लेकिन उस पर बाद में।

हमें STM32 डिबग बोर्डों के लिए एक प्रोग्रामर की भी आवश्यकता होगी। इस लेख में, हम सस्ते और सस्ती चीनी एसटी-लिंक वी 2 प्रोग्रामर का उपयोग करेंगे।

जंग संकलक संस्करण

आरंभ करने के लिए, आपको यह सुनिश्चित करने की आवश्यकता है कि आपका संकलक संस्करण 1.31 या अधिक हाल का है। आप कमांड दर्ज करके अपने संकलक संस्करण की जांच कर सकते हैं:

> rustc --version

घटक स्थापना

अब हम आवश्यक घटकों को स्थापित करना शुरू कर सकते हैं।

GNU आर्म एंबेडेड टूलचिन

हमें एआरएम चिप्स के लिए एक डिबगर की आवश्यकता होगी - आर्म-नोनी-एग्बी-जीडीबी। इंस्टॉलर को लॉन्च करें और निर्देशों का पालन करें। स्थापना के अंत में, " पर्यावरण चर में पथ जोड़ें " विकल्प की जांच करना सुनिश्चित करें ।

लिंक डाउनलोड करें

स्थापना के बाद, आप जांच सकते हैं कि कमांड लाइन में निम्नलिखित दर्ज करके सब कुछ है या नहीं:

> arm-none-eabi-gdb -v

यदि सब कुछ क्रम में है, तो आप स्थापित घटक का संस्करण देखेंगे।

एसटी-लिंक ड्राइवर

एसटी-लिंक प्रोग्रामर के लिए ड्राइवर को स्थापित करने के लिए आगे बढ़ते हैं।

इंस्टॉलर के निर्देशों का पालन करें और सुनिश्चित करें कि आप अपने ऑपरेटिंग सिस्टम की थोड़ी गहराई के आधार पर ड्राइवर के सही ( चौंसठ बिट या बत्तीस ) संस्करण स्थापित करते हैं ।

डाउनलोड करने के लिए लिंक

ST- लिंक उपकरण

अगला कदम फर्मवेयर के लिए आवश्यक उपकरणों को स्थापित करना है - एसटी-लिंक टूल। संग्रह को डाउनलोड करें और इसे किसी भी सुविधाजनक स्थान पर अनज़िप करें, आपको पर्यावरण चर " पथ " में बिन सबफ़ोल्डर ( स्टिंकल-1.3.0 \ बिन ) के लिए पथ निर्दिष्ट करना होगा । डाउनलोड करने के लिए लिंक

माल-binutils

अंत में, पैकेज कार्गो-बिनुटिल्स स्थापित करें, यह कंसोल में दो कमांड द्वारा किया जाता है।

> cargo install cargo-binutils
> rustup component add llvm-tools-preview

यह घटकों की स्थापना को पूरा करता है।

प्रोजेक्ट बनाना और स्थापित करना

जारी रखने के लिए, हमें " stm32f103c8t6 " नाम के साथ एक नई परियोजना बनाने की आवश्यकता है । मुझे आपको याद दिलाना है, यह कमांड द्वारा किया गया है:

> cargo new stm32f103c8t6

परियोजना निर्भरता और अनुकूलन

Cargo.toml फ़ाइल में आवश्यक लाइब्रेरी कनेक्ट करें :

[package]
name = "stm32f103c8t6"
version = "0.1.0"
authors = ["Nick"]
edition = "2018"

#      Cortex-M3
[dependencies]
cortex-m = "*"
cortex-m-rt = "*"
cortex-m-semihosting = "*"
panic-halt = "*"
nb = "0.1.2"
embedded-hal = "0.2.3"

#       stm32f1
[dependencies.stm32f1xx-hal]
version = "0.5.2"
features = ["stm32f100", "rt"]

#   `cargo fix`!
[[bin]]
name = "stm32f103c8t6"
test = false
bench = false

#   
[profile.release]
codegen-units = 1 #  
debug = true #  ,     Flash 
lto = true #

इसके अलावा, आप देख सकते हैं कि, फ़ाइल के अंत में, कोड अनुकूलन सक्षम किया गया है।

कोर्टेक्स-एम-आरटी लाइब्रेरी को प्रोजेक्ट की रूट डायरेक्टरी में एक फाइल बनाने की आवश्यकता होती है, इसे " मैमोरी.एक्स " कहा जाना चाहिए । यह इंगित करता है कि हमारे डिवाइस की मेमोरी और उसका पता कितना है:

MEMORY
{
 FLASH : ORIGIN = 0x08000000, LENGTH = 64K
 RAM : ORIGIN = 0x20000000, LENGTH = 20K
}

लक्ष्य मंच और डिफ़ॉल्ट संकलन लक्ष्य निर्धारित करना

संकलक के लिए लक्ष्य प्लेटफ़ॉर्म सेट करना आवश्यक है, यह कमांड द्वारा किया जाता है:

> rustup target add thumbv7m-none-eabi

उसके बाद, "बनाने के .cargo " फ़ोल्डर रूट निर्देशिका और "में config " उस में फ़ाइल । विन्यास

फाइल की सामग्री :

[target.thumbv7m-none-eabi]

[target.'cfg(all(target_arch = "arm", target_os = "none"))']

rustflags = ["-C", "link-arg=-Tlink.x"]

[build]
target = "thumbv7m-none-eabi"  # Cortex-M3

इसे में, हम डिफ़ॉल्ट संकलन लक्ष्य की पहचान की, इस एक हाथ में हमारे कोड संकलन करने की अनुमति देता है .elf एक सरल और परिचित कमांड के साथ फ़ाइल:

> cargo build --release

उदाहरण

यह सुनिश्चित करने के लिए कि यह काम करता है, सबसे सरल उदाहरण पर विचार करें - एक एलईडी निमिष। Main.rs

फ़ाइल की सामग्री :

#![deny(unsafe_code)]
#![no_std]
#![no_main]

use panic_halt as _;

use nb::block;

use stm32f1xx_hal::{
    prelude::*,
    pac,
    timer::Timer,
};
use cortex_m_rt::entry;
use embedded_hal::digital::v2::OutputPin;

//   .
#[entry]
fn main() -> ! {
    
    //     
    let cp = cortex_m::Peripherals::take().unwrap();
    let dp = pac::Peripherals::take().unwrap();
    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();

    let clocks = rcc.cfgr.freeze(&mut flash.acr);
    let mut gpiob = dp.GPIOB.split(&mut rcc.apb2);

    //   b12   .
    //  "crh"      .
    //   0-7,    "crl".
    let mut led = gpiob.pb12.into_push_pull_output(&mut gpiob.crh);
    //        .
    let mut timer = Timer::syst(cp.SYST, &clocks)
    .start_count_down(1.hz());

    //     
    //    .
    loop {
        block!(timer.wait()).unwrap();
        led.set_high().unwrap();
        block!(timer.wait()).unwrap();
        led.set_low().unwrap();
    }
}

पहली पंक्ति में, - विशेषता का उपयोग करके #![deny(unsafe_code)], हम असुरक्षित कोड का उपयोग करने की संभावना को हटा देते हैं।

दूसरी पंक्ति में, हमने विशेषता को रखा #![no_std], यह आवश्यक है, क्योंकि हम नंगे लोहे के लिए एक एप्लिकेशन बना रहे हैं, और मानक पुस्तकालय को एक ऑपरेटिंग सिस्टम की आवश्यकता है।

इसके बाद एक विशेषता आती #![no_main]है जो संकलक को बताती है कि हम तर्क वेक्टर और रिटर्न प्रकार के साथ डिफ़ॉल्ट डिफ़ॉल्ट फ़ंक्शन का उपयोग नहीं कर रहे हैं। इसका कोई मतलब नहीं है, क्योंकि हमारे पास एक ऑपरेटिंग सिस्टम या अन्य रनटाइम नहीं है जो फ़ंक्शन को कॉल करता है और रिटर्न मान संसाधित करता है।

विशेषताओं के बाद, हम आवश्यक मॉड्यूल को दायरे में प्लग करते हैं।

इसके बाद एक कार्य होता है, हमारे मामले में, आदत से बाहर, हम इसे कहते हैं -main()। यह कार्यक्रम का प्रवेश बिंदु है, यह विशेषता द्वारा निर्धारित किया जाता है #[entry]।

मुख्य फ़ंक्शन के अंदर, हम एक परिधीय वस्तु के लिए एक हैंडल बनाते हैं जो सभी परिधीय उपकरणों का "मालिक" होता है।

उसके बाद, हम बोर्ड में निर्मित एलईडी के लिए जिम्मेदार पिन को आउटपुट पर सेट कर सकते हैं। चूंकि मेरे मामले में यह एक ब्लैक पिल बोर्ड है , इसमें लगी एलईडी पिन B12 से जुड़ी है । यदि आपके पास एक ब्लू पिल बोर्ड है , तो अंतर्निहित एलईडी के लिए पिन C13 जिम्मेदार है । इसलिए, हम पिन बी 12 को एक पुश-पुल आउटपुट के रूप में सेट करते हैं और इसे एक वेरिएबल में असाइन करते हैं led।

अब हम सिस्टम टाइमर के लिए अपडेट इवेंट ट्रिगर समय सेट कर सकते हैं, और इसे एक चर में सहेज सकते हैंtimer। हमारे उदाहरण में, यह समय एक सेकंड का है।

फिर, एक अंतहीन लूप में, हम अपने कार्यक्रम के तर्क का वर्णन कर सकते हैं। यह बहुत सरल है, पहले timerकार्यक्रम के निष्पादन को तब तक के लिए रोक देता है जब तक कि इसमें निर्दिष्ट समय बीत नहीं जाता। अगला कदम अंतर्निहित एलईडी के पिन को उच्च पर सेट करना है , इसलिए यह रोशनी करता है। उसके बाद, कार्यक्रम का निष्पादन फिर से उसी टाइमर द्वारा, एक सेकंड के लिए अवरुद्ध कर दिया जाता है। और एलईडी का पिन कम सेट किया जाता है, इसलिए यह बाहर निकल जाता है। इसके अलावा, कार्यक्रम को चक्रीय रूप से दोहराया जाता है।

संकलन

अब जब हमने प्रोग्राम कोड और लॉजिक का पता लगा लिया है, हम इसे कमांड के साथ .elf फाइल में संकलित कर सकते हैं :

> cargo build --release

इस प्रारूप में न केवल बाइनरी कोड है, बल्कि कुछ हेडर और भी बहुत कुछ है। यह तब उपयोगी होता है जब फ़ाइल को अन्य सॉफ़्टवेयर, जैसे ऑपरेटिंग सिस्टम या बूटलोडर द्वारा लॉन्च किया जाता है।

लेकिन, नंगे धातु पर कार्यक्रम को चलाने के लिए, हमें एक .elf फ़ाइल नहीं , बल्कि एक .bin फ़ाइल की आवश्यकता होती है । एक .bin फ़ाइल एक सॉफ्टवेयर छवि है जिसे माइक्रो-कंट्रोलर की मेमोरी में बाइट लिखा जा सकता है। .Elf फ़ाइल को कमांड का उपयोग करके .bin फ़ाइल में बदला जा सकता है :

> cargo objcopy --bin stm32f103c8t6 --target thumbv7m-none-eabi --release -- -O binary stm32f103c8t6.bin

अब हमारी बाइनरी फ़ाइल फर्मवेयर के लिए तैयार है।

संबंध

हम एसटी-लिंक वी 2 प्रोग्रामर का उपयोग करके बोर्ड को फ्लैश करेंगे। ऐसा करने के लिए, आपको पहले इसे बोर्ड से कनेक्ट करना होगा।

प्रोग्रामर मामले पर कनेक्टर की एक पिन व्यवस्था है। आपको कनेक्टर में कटआउट पर ध्यान देने की आवश्यकता है, यह आरेख पर भी प्रदर्शित किया जाता है, जो आपको यह समझने की अनुमति देता है कि कनेक्शन कैसे बनाया जाए। बोर्ड पर संबंधित पिन के साथ प्रोग्रामर

के 3.3V और GND पिन को कनेक्ट करें । पिंग SWDIO DIO को पिन करने के लिए कनेक्ट करें , और CLK को पिन करने के लिए SWCLK को पिन करें ।

बोर्ड को प्रोग्रामर से कनेक्ट करने के बाद, हम कंप्यूटर से एसटी-लिंक कनेक्ट कर सकते हैं।

ध्यान!कनेक्ट करने से पहले, बोर्ड से अन्य सभी बिजली स्रोतों को डिस्कनेक्ट करें, यदि कोई हो, अन्यथा यह बोर्ड या कंप्यूटर को नुकसान पहुंचा सकता है।

अब हम कनेक्शन की जांच कर सकते हैं:

> st-info --descr

कंसोल में, हमें " एफ 1 मध्यम-घनत्व डिवाइस " लाइन को देखना चाहिए ।

फर्मवेयर

वैकल्पिक रूप से, चमकने से पहले, आप बोर्ड की मेमोरी को साफ कर सकते हैं यदि उस पर कुछ लिखा है:

> st-flash erase

अंत में, हम फर्मवेयर शुरू कर सकते हैं:

> st-flash write stm32f1.bin 0x8000000

यदि सब कुछ सही ढंग से किया जाता है, तो आपको एक निमिष एलईडी देखना चाहिए। बधाई हो!

निष्कर्ष

इसलिए, बोर्ड को फ्लैश करने के लिए, आपको क्रमिक रूप से दर्ज किए गए आदेशों के इस सेट का उपयोग करना चाहिए:

> cargo build --release
> cargo objcopy --bin stm32f103c8t6 --target thumbv7m-none-eabi --release -- -O binary stm32f103c8t6.bin
> st-flash erase
> st-flash write stm32f1.bin 0x8000000

अपने जीवन को सरल बनाने के लिए, हम इन कमांड के साथ एक .bat फ़ाइल बना सकते हैं और इसे कंसोल से चला सकते हैं।

लेखक से

यदि आप इन गाइडों में रुचि रखते हैं, तो मेरे YouTube चैनल में आपका स्वागत है ।
इसके अलावा, हाल ही में, मैंने एक टेलीग्राम चैनल शुरू किया, जहां मैं मैनुअल और किताबें, समाचार, हास्य और रस्ट प्रोग्रामिंग भाषा से संबंधित अन्य चीजों के विभिन्न अनुवाद प्रकाशित करता हूं। वहाँ आप अपने सवालों को पूछने और मदद पाने के लिए, अपने प्रोजेक्ट जमा करने या समान विचारधारा वाले लोगों के साथ चैट करने के लिए कई चैटरूम के लिंक पा सकते हैं।

ध्यान देने के लिए आपको धन्यवाद!

जंग लगा हुआ। STM32F103C8T6 (ब्लैक पिल) डिबग बोर्ड का उपयोग करके कॉर्टेक्स-एम 3 प्रोसेसर के लिए विकास