👩🏻‍🔧 👩🏽‍💻 ◻️ STM32 भाग 3: पहली परियोजना 🔳 👨🏿‍🌾 👰🏾

हम एक ऐसे समाज का निरीक्षण करते हैं जो मशीनों पर निर्भर है, लेकिन एक ही समय में उन सभी का अधिक अकुशल उपयोग करता है। - डगलस रुश्कोफ

यह वाक्यांश हर प्रोग्रामर के लिए एक प्रेरणा के रूप में कार्य करना चाहिए। आखिरकार, यह आप ही हैं जो यह तय करते हैं कि मशीन अपने संसाधनों का उपयोग कैसे करती है। लेकिन समय की शुरुआत से, एक व्यक्ति अपने अधिकार को आसान तरीके से बदले में तीसरे पक्ष को तय करने का अधिकार सौंपता है। मेरे लेखों के लाभों के बारे में पूछने से पहले जब "क्यूब" होता है, तो अपने आप से पूछें कि "क्यूब" मेरे लिए क्यों तय करता है।

STM32 भाग 1:
STM32 मूल बातें भाग 2: प्रारंभ

तो, चलो हमारे साहसिक कार्य जारी रखें। हमने पहले से ही इनिशियलाइज़ेशन स्क्रिप्ट लिखी है, जो लिंकर और कंपाइलर का पता लगा चुकी है। एलईडी को ब्लिंक करने का समय आ गया है। इस लेख में, हम आरसीसी और जीपीआईओ ब्लॉक की बुनियादी बातों पर जाएंगे, और एक हेडर जोड़ेंगे, जिसका उपयोग हम भविष्य की परियोजनाओं में करेंगे। जाओ।

आरसीसी - रीसेट और क्लॉक कंट्रोल, रजिस्टरों का एक ब्लॉक जो प्रोसेसर और बाह्य उपकरणों की घड़ी को नियंत्रित करता है। इस इकाई द्वारा कई घड़ी स्रोत नियंत्रित किए जाते हैं: एचएसआई (हाई स्पीड इंटरनल), एचएसई (हाई स्पीड एक्सटर्नल), पीएलएल / पीएलएलएसएआई / पीएलएलआई 2 एस (चरणबद्ध लूप लॉक)। इन सभी घड़ी स्रोतों का उपयोग प्रोसेसर द्वारा किया जा सकता है, निश्चित रूप से, यदि आरसीसी ब्लॉक रजिस्टरों को सही तरीके से कॉन्फ़िगर किया गया है। हम इस बारे में अगले लेख में विस्तार से बात करेंगे।

GPIO - सामान्य प्रयोजन इनपुट और आउटपुट। रजिस्टरों का ब्लॉक जो चमकती एलईडी के लिए बनाया गया है। अर्थात, यह हमारे माइक्रोन, वास्तविक दुनिया के लिए एक पोर्टल के पैरों को नियंत्रित करने के लिए एक ब्लॉक है। परिचित Atmega328p (Arduino) के विपरीत, stm32 पैरों का एक व्यापक अनुकूलन प्रदान करता है। उदाहरण के लिए, मेगा पर ओपन ड्रेन फुट फ़ंक्शन उपलब्ध नहीं है। इसके अलावा, जिस गति से यूके पैर पर वोल्टेज बढ़ाता है, उसका नियंत्रण कॉन्फ़िगर किया जा सकता है।

तो चलो पहले से ही पलक, हाँ। पहले हमें दो हेडर की आवश्यकता होती है जिसमें हम इन रजिस्टरों की संरचना का वर्णन करते हैं। इसलिए, हमें संदर्भ पुस्तिका मिलती है और हमें इसकी आवश्यकता की जानकारी की तलाश में इसका अध्ययन करना पड़ता है। मैं STM32F746NG - डिस्कवरी पर इस बोर्ड के लिए सभी कोड पर काम करता हूं।

पहली चीज़ जो हमें चाहिए वह है इन ब्लॉकों के पते, बुनियादी। आरसीसी ब्लॉक से शुरू करते हैं और rcc.h हेडर बनाते हैं। इसमें हम मैक्रो RCC_BASE बनाएंगे, और रजिस्टर ब्लॉक की संरचना का भी वर्णन करेंगे, और संरचना के लिए एक पॉइंटर बनाएंगे।

rcc.h

#define RCC_BASE   0x40023800

typedef struct
{
  volatile unsigned int CR;           
  volatile unsigned int PLLCFGR;      
  volatile unsigned int CFGR;         
  volatile unsigned int CIR;          
  volatile unsigned int AHB1RSTR;     
  volatile unsigned int AHB2RSTR;     
  volatile unsigned int AHB3RSTR;     
  unsigned int          RESERVED0;    
  volatile unsigned int APB1RSTR;     
  volatile unsigned int APB2RSTR;     
  unsigned int          RESERVED1[2]; 
  volatile unsigned int AHB1ENR;      
  volatile unsigned int AHB2ENR;      
  volatile unsigned int AHB3ENR;      
  unsigned int          RESERVED2;    
  volatile unsigned int APB1ENR;      
  volatile unsigned int APB2ENR;      
  unsigned int          RESERVED3[2]; 
  volatile unsigned int AHB1LPENR;    
  volatile unsigned int AHB2LPENR;    
  volatile unsigned int AHB3LPENR;    
  unsigned int          RESERVED4;    
  volatile unsigned int APB1LPENR;    
  volatile unsigned int APB2LPENR;    
  unsigned int          RESERVED5[2]; 
  volatile unsigned int BDCR;         
  volatile unsigned int CSR;          
  unsigned int          RESERVED6[2]; 
  volatile unsigned int SSCGR;        
  volatile unsigned int PLLI2SCFGR;   
  volatile unsigned int PLLSAICFGR;   
  volatile unsigned int DCKCFGR1;     
  volatile unsigned int DCKCFGR2;     

} RCC_Struct;

#define RCC ((RCC_Struct *) RCC_BASE)

जीपीओ रजिस्टर ब्लॉक के साथ एक ही ऑपरेशन करते हैं, केवल एक पॉइंटर के बिना और दूसरा मैक्रो जोड़ें, GPIO_OFFSET। इसके बारे में नीचे बात करें।

gpio.h

#define GPIO_BASE   0x40020000
#define GPIO_OFFSET 0x400

typedef struct
{
   volatile unsigned int MODER;   
   volatile unsigned int OTYPER;  
   volatile unsigned int OSPEEDR; 
   volatile unsigned int PUPDR;   
   volatile unsigned int IDR;     
   volatile unsigned int ODR;     
   volatile unsigned int BSRR;    
   volatile unsigned int LCKR;    
   volatile unsigned int AFR[2];  

} GPIO_Struct;

आइए देखें कि यहां क्या मामला है और हमें संरचनाओं की आवश्यकता क्यों है। तथ्य यह है कि हम एक संकेतक के माध्यम से एक संरचना तक रजिस्टर का उपयोग कर सकते हैं, हमें इसे शुरू करने की आवश्यकता नहीं है क्योंकि यह पहले से मौजूद है। उदाहरण के लिए:

RCC->AHB1ENR = 0;

यह मेमोरी स्पेस बचाता है, और कभी-कभी इसकी आवश्यकता नहीं होती है। लेकिन आज बचत के बारे में नहीं।

इसलिए हमारे पास दो हेडर तैयार हैं, यह सीखना बाकी है कि इन रजिस्टरों की मदद से कैसे कूदें और बनाएं int main();। यह सब सरल है और काफी नहीं है। STM32 में, रजिस्टर ब्लॉक तक पहुंचने के लिए, हमें पहले उस पर एक घड़ी जमा करनी होगी, अन्यथा डेटा उस तक पहुंच जाएगा। मैं टायर की संरचना में गहराई तक नहीं जाऊंगा, लेकिन जैसा कहूं वैसा ही बनूंगा। ब्लाकों को अलग-अलग टायरों पर रखा गया है। हमारी इकाई AHB1 बस में स्थित है। यही है, हमें एएचबी 1 बस पर एक विशिष्ट पोर्ट को सक्षम करने की आवश्यकता है, मेरे मामले में यह पोर्ट I है। शुरुआत के लिए, निश्चित रूप से हमें मुख्य फ़ंक्शन की आवश्यकता है।

आइए हमारी स्टार्टअप फ़ाइल को थोड़ा अपडेट करें और int main () जोड़ें; और फिर main.c फाइल ही बनाएं

extern void *_estack;

void Reset_Handler();
void Default_Handler();

//   
int  main();

void NMI_Handler()                    __attribute__ ((weak, alias ("Default_Handler")));
void HardFault_Handler()              __attribute__ ((weak, alias ("Default_Handler")));

void *vectors[] __attribute__((section(".isr_vector"), used)) = {
    &_estack,
	&Reset_Handler,
	&NMI_Handler,
	&HardFault_Handler
};

extern void *_sidata, *_sdata, *_edata, *_sbss, *_ebss;



void __attribute__((naked, noreturn)) Reset_Handler()
{


	void **pSource, **pDest;
	for (pSource = &_sidata, pDest = &_sdata; pDest != &_edata; pSource++, pDest++)
		*pDest = *pSource;

	for (pDest = &_sbss; pDest != &_ebss; pDest++)
		*pDest = 0;

    //   
    main();

	while(1);
}

void __attribute__((naked, noreturn)) Default_Handler(){
    while(1);
}

और अब हम main.c फाइल बनाते हैं फ़ाइल में, मैंने कोड में टिप्पणियों में सब कुछ चित्रित करने की कोशिश की, इसलिए हमने इसे पढ़ा और इसमें तल्लीन किया। यदि आपके कोई प्रश्न हैं, तो नीचे दिए गए टिप्पणियों में लिखें, मैं जवाब दूंगा।

#include "rcc.h"
#include "gpio.h"


int main()
{
    //  GPIO I ,   8 ( )
    RCC->AHB1ENR |= (1<<8);

    //     
    //          
    //      
    volatile GPIO_Struct *GPIOI = (GPIO_Struct *)(GPIO_BASE + (GPIO_OFFSET*8));  

    //     ""
    GPIOI->MODER |= (1<<2);

    //   ,   , push-pull,   .
    //   push pull
    GPIOI->OTYPER &= ~(1<<1);

    //      ,       
    GPIOI->OSPEEDR |= (2<<2);

    //   
    while(1){
        for(volatile int i = 0; i < 1000000; i++){
            // 
        }

        // ,   1   0  .
        GPIOI->ODR ^= (1<<1);
    }

    return 0;
}

अब हमें सत्यापन के लिए एक परियोजना को एक साथ रखना होगा और इसे माइक्रोन पर फेंकना होगा। मैंने गितुब पर एक रिपॉजिटरी पोस्ट किया जो सभी को बनाने की आवश्यकता है मेक यूटिलिटी को चलाने के लिए।

make

आपका ध्यान देने के लिए आप सभी का धन्यवाद, अगले लेख में हम आरसीसी इकाई और इसके साथ कैसे काम करें, इस बारे में अधिक बात करेंगे।

STM32 भाग 3: पहली परियोजना

More articles: