STM32F3DISCOVERY, एक्सेलेरोमीटर, स्टेपर मोटर्स और थोड़ा सा जादू

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

काम का उद्देश्य एक मोबाइल रोबोट को संवेदन और नियंत्रित करने के लिए एक प्रणाली विकसित करना था। इन बड़े शब्दों के पीछे मेरे लिए बहुत बड़ा लेकिन दिलचस्प काम नहीं है।

बिंदु के करीब। हमारे पास एक माइक्रोप्रोसेसर, सेंसर का एक पैकेट, एक कदम इंजन है, और यह आवश्यक है कि माइक्रोप्रोसेसर सेंसर (एक्सीलेरोमीटर और गायरोस्कोप) से डेटा पढ़े, एक पीसी को यह जानकारी भेजें, कंप्यूटर से इंजन को नियंत्रित करने के लिए एक कमांड प्राप्त करें, और इंजन को घुमाएं।

खरीद:

उन्होंने निम्नलिखित घटकों को चुना:

• STM32F3DISCOVERY, क्योंकि इसमें एक्सेलेरोमीटर और जाइरोस्कोप पहले से बोर्ड पर लगाए गए हैं। और एसटीएम 32 के तहत पहले से ही कई तैयार उदाहरण हैं, जो कार्य को आसान (आंशिक रूप से आसान) करना चाहिए था।
• डिजिटल एक्सीलेरोमीटर LIS331DH, 3-अक्ष, उच्च परिशुद्धता (2 जी से 8 जी तक)। सामान्य तौर पर, लगभग पूरी एलआईएस * श्रृंखला बहुत अच्छी है और आवश्यकताओं को फिट करती है।
• कदम इंजन FL42STH25-0404A, ठीक है, यहाँ, मेरे पसंदीदा विभाग के आसपास क्या पड़ा था, जो व्यवसाय में चला गया।

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

थोड़ा हम समझते हैं:

हमें बॉक्स से STM32F3DISCOVERY मिलता है, इसे पीसी से कनेक्ट करें और इसे शुरू करें। डेमो कार्यक्रम से पता चलता है कि एक विचलन होने पर लैंप झपकाते हैं, अर्थात, सेंसर काम कर रहे हैं। हम चिल्लाते हैं "हुर्रे!" और समझने के लिए कोड में चढ़ते हैं और वास्तव में आवश्यक को लागू करते हैं।


और बहुत आवश्यक है, लेकिन सबसे पहले मैंने बाहरी सेंसर (ऑन-बोर्ड नहीं) तक पहुंचने से रोकने का फैसला किया। मिलाप एक्सल, कनेक्ट। धुरी को जोड़ने के लिए 2 इंटरफेस हैं: SPI और I2C। मैंने एसपीआई पर रहने का फैसला किया, क्योंकि मुझे पहले से ही ATTINY2313 पर इससे निपटना था (मैंने इसे प्रोग्रामेटिक रूप से लागू किया) और सोचा कि हार्डवेयर SPI के साथ कोई समस्या नहीं होनी चाहिए।

मैं इसे आसान चाहता था, यह हमेशा की तरह निकला

कनेक्शन: MISO - MISO, MOSI - MOSI, SCK - SCK, CS को किसी भी पैर पर लटका दिया जा सकता है, क्योंकि हम इसे प्रोग्रामेटिक रूप से खींचेंगे।
पहले हमें SPI को इनिशियलाइज़ करना होगा। इस उदाहरण में, SPI2 के साथ काम किया जाता है, क्योंकि पहले SPI के माध्यम से अंतर्निहित गाइरोस्कोप कार्य (या एक्सल, मुझे ठीक से याद नहीं है):

void SPI2_Configuration(void) { RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_5); // SCK GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_5); // MISO GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_5); // MOSI SPI_InitTypeDef SPI_InitStructure; SPI_StructInit(&SPI_InitStructure); SPI_I2S_DeInit(SPI2); SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b; SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SPI_InitStructure.SPI_Mode = SPI_Mode_Master; SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; SPI_InitStructure.SPI_CRCPolynomial = 7; SPI_Init(SPI2, &SPI_InitStructure); /* Configure the Priority Group to 1 bit */ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); /* Configure the SPI interrupt priority */ NVIC_InitStructure.NVIC_IRQChannel = SPI2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Initialize the FIFO threshold */ SPI_RxFIFOThresholdConfig(SPI2, SPI_RxFIFOThreshold_QF); SPI_Cmd(SPI2, ENABLE); } 

WHO_AM_I रजिस्टर से डेटा पढ़ने की कोशिश कर रहा है:
getValue = getRegisterValue(&AXELx, 0x0F);
जहाँ

 char getRegisterValue(AXEL_TypeDef* AXELx, char address) { AXELx->CS_Port->BRR = AXELx->CS_Pin; SPI_I2S_SendData16(SPI2, 0x8000|(address<<8)); while(!SPI_I2S_GetFlagStatus(SPI2,SPI_I2S_FLAG_RXNE)); AXELx->CS_Port->BSRR = AXELx->CS_Pin; return SPI_I2S_ReceiveData16(SPI2); } 

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

खैर, हम इस तरह लिखेंगे:

 void setRegisterValue(AXEL_TypeDef* AXELx, char address, char data) { AXELx->CS_Port->BRR = AXELx->CS_Pin; SPI_I2S_SendData16(SPI2,((short)address<<8)|(short)data); while(!SPI_I2S_GetFlagStatus(SPI2,SPI_I2S_FLAG_RXNE)); AXELx->CS_Port->BSRR = AXELx->CS_Pin; SPI_I2S_ReceiveData16(SPI2); } 

सही संचालन के लिए, सेंसर को भी आरंभीकृत किया जाना चाहिए, अर्थात्, इंगित करें कि हम सभी तीन अक्षों के साथ पढ़ेंगे और ऑपरेटिंग आवृत्ति का संकेत देंगे (हम नियंत्रण शब्द के अर्थ और इसके गठन के लिए डेटा पत्रक में एक्सल को देखते हैं)।

 void Axel_Init(AXEL_TypeDef* AXELx) { GPIO_InitTypeDef GPIO_InitStructure; /* Enable Axel CS Pin */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Pin = AXELx->CS_Pin; GPIO_Init(AXELx->CS_Port, &GPIO_InitStructure); setRegisterValue(AXELx, 0x20, 0x27); } 

सेंसर समाप्त होने के साथ, हुर्रे! अब चलो स्टेपर मोटर नियंत्रण पर चलते हैं।

चुपचाप चले जाना - तुम जारी रखोगे

एसडी को नियंत्रित करने के लिए, चालक VNH3SP30 का उपयोग किया गया था। सच है, यह आपको स्टेपर मोटर की दो में से केवल एक वाइंडिंग को नियंत्रित करने की अनुमति देता है, इसलिए हमें इनमें से 2 शॉल की आवश्यकता है।

इस प्रकार, एक घुमावदार को नियंत्रित करने के लिए, हमें संपूर्ण मोटर - 6 के लिए माइक्रोकंट्रोलर (एक वाहक आवृत्ति और 2 दिशाओं) से 3 आउटपुट की आवश्यकता होती है।

सुविधा के लिए बंदरगाहों को परिभाषित करें:

 #define A_PULSE_PORT GPIOB #define A_PULSE_PIN GPIO_Pin_2 #define A_DIR1_PORT GPIOB #define A_DIR1_PIN GPIO_Pin_0 #define A_DIR2_PORT GPIOE #define A_DIR2_PIN GPIO_Pin_8 #define B_PULSE_PORT GPIOE #define B_PULSE_PIN GPIO_Pin_12 #define B_DIR1_PORT GPIOE #define B_DIR1_PIN GPIO_Pin_10 #define B_DIR2_PORT GPIOE #define B_DIR2_PIN GPIO_Pin_14 

और उन्हें इनिशियलाइज़ करें:

 void StepMotorSetup() { RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOE, ENABLE); /*       */ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_Pin = A_PULSE_PIN; GPIO_Init(A_PULSE_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = B_PULSE_PIN; GPIO_Init(B_PULSE_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = A_DIR1_PIN; GPIO_Init(A_DIR1_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = B_DIR1_PIN; GPIO_Init(B_DIR1_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = A_DIR2_PIN; GPIO_Init(A_DIR2_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = B_DIR2_PIN; GPIO_Init(B_DIR2_PORT, &GPIO_InitStructure); } 

मोटर द्वारा 1 कदम बनाने के लिए, आवश्यक क्रम में मोटर वाइंडिंग को चालू करना आवश्यक है, अर्थात्, ड्राइवरों पर नियंत्रण संकेत लागू करें

नियंत्रण संकेत मुखौटा इस प्रकार है:

 u8 WireConFullStep[4][4] = {{1, 0, 0, 0}, {0, 0, 1, 0}, {0, 1, 0, 0}, {0, 0, 0, 1}}; 

और अब हम सही दिशा में एक कदम बढ़ाते हैं। इस मामले में दिशा नियंत्रण संकेतों के मुखौटा पर बाईपास की दिशा द्वारा निर्धारित की जाती है:

 void DoStep(int index) { GPIO_ResetBits(A_DIR1_PORT, A_DIR1_PIN); GPIO_ResetBits(A_DIR2_PORT, A_DIR2_PIN); GPIO_ResetBits(B_DIR1_PORT, B_DIR1_PIN); GPIO_ResetBits(B_DIR2_PORT, B_DIR2_PIN); GPIO_ResetBits(A_PULSE_PORT, A_PULSE_PIN); GPIO_ResetBits(B_PULSE_PORT, B_PULSE_PIN); if(WireConFullStep[index][0] == 1) { GPIO_SetBits(A_DIR1_PORT, A_DIR1_PIN); GPIO_SetBits(A_PULSE_PORT, A_PULSE_PIN); } if(WireConFullStep[index][1] == 1) { GPIO_SetBits(A_DIR2_PORT, A_DIR2_PIN); GPIO_SetBits(A_PULSE_PORT, A_PULSE_PIN); } if(WireConFullStep[index][2] == 1) { GPIO_SetBits(B_DIR1_PORT, B_DIR1_PIN); GPIO_SetBits(B_PULSE_PORT, B_PULSE_PIN); } if(WireConFullStep[index][3] == 1) { GPIO_SetBits(B_DIR2_PORT, B_DIR2_PIN); GPIO_SetBits(B_PULSE_PORT, B_PULSE_PIN); } } 

सुविधा के लिए, हम एक वामावर्त चरण और एक दक्षिणावर्त चरण परिभाषित करते हैं:

 void CWStep() { DoStep(CurIndex); CurIndex+=1; if(CurIndex > 3) CurIndex = 0; } void CCWStep() { DoStep(CurIndex); CurIndex-=1; if(CurIndex < 0) CurIndex = 3; } 

और अब हम एक फ़ंक्शन लिखेंगे, जिसके साथ हम इंजन को सही दिशा में सही चरणों की संख्या में घुमाएंगे:

 void Steps(u8 dir, s16 n) { s16 i = 0; for(i = 0; i < n; i++) { if(dir) { CWStep(); udelay(15000); } else { CCWStep(); udelay(15000); } } } 

इस फ़ंक्शन में, समय विलंब डाला जाता है ताकि अगले कदम पर कमांड भेजने से पहले स्टेपर मोटर के पास एक कदम उठाने का समय हो।

हमारे हाथों में शक्ति अधिक से अधिक होती जा रही है और हम अगले चरण पर जा रहे हैं - एक पीसी को डेटा भेजना और एक पीसी से एसडी का प्रबंधन करना।

USB संचार

USB के साथ काम करने के लिए, मैंने USB के साथ काम करने के उदाहरणों में से एक का उपयोग किया, जिसका नाम है VirtualComport_Loopback (STM32 USB-FS-Device विकास किट में इंटरनेट खोजें)। इस डेमो में, पीसी से जुड़े stm32 को एक वर्चुअल कॉम पोर्ट के रूप में परिभाषित किया गया था, और सभी प्राप्त डेटा को वापस भेज दिया। खैर, यह हमें पूरी तरह से सूट करता है! हम इस उदाहरण को लेते हैं, विनिमय और वॉइला के लूप को तोड़ते हैं - इसका उपयोग करते हैं।

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

दरअसल, हमें निम्नलिखित कोड के बारे में पता चला:
USB आरंभीकरण:

  Set_System(); Set_USBClock(); USB_Interrupts_Config(); USB_Init(); 

जब तक हम उपयोगकर्ता बटन दबाते हैं, हम प्रतीक्षा करते हैं:

  while (1) { /* Data exhange via USB */ if (bDeviceState == CONFIGURED && UserButtonPressed != 0) { … } } 

UserButton पर क्लिक करने के लिए हैंडलर:

 __IO uint32_t i =0; extern __IO uint32_t UserButtonPressed; void EXTI0_IRQHandler(void) { if ((EXTI_GetITStatus(USER_BUTTON_EXTI_LINE) == SET)&&(STM_EVAL_PBGetState(BUTTON_USER) != RESET)) { /* Delay */ for(i=0; i<0x7FFFF; i++); /* Wait for SEL button to be pressed */ while(STM_EVAL_PBGetState(BUTTON_USER) != RESET); /* Delay */ for(i=0; i<0x7FFFF; i++); UserButtonPressed++; if (UserButtonPressed > 0x2) { UserButtonPressed = 0x0; } /* Clear the EXTI line pending bit */ EXTI_ClearITPendingBit(USER_BUTTON_EXTI_LINE); } } 

निष्कर्ष

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


मैं STM32F3 के तहत IAR के लिए एक परियोजना भी संलग्न करूंगा। बहुत सारे "खराब" कोड हैं, क्योंकि यह "यदि यह काम करता है, लेकिन जल्द ही" के सिद्धांत पर सबसे अधिक भाग के लिए लिखा गया था। कोड पर किसी भी टिप्पणी के लिए, और न केवल, मैं आभारी रहूंगा।

dl.dropboxusercontent.com/u/61862295/VirtualComport_Loopback.rar

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

प्रयुक्त स्रोत:

1. STM32F3 डिस्कवरी किट फर्मवेयर पैकेज, जिसमें 28 उदाहरण हैं और 4 विभिन्न IDEs www.st.com/web/en/catalog/tools/PF258154 के लिए पूर्वनिर्मित परियोजनाएं शामिल हैं।
2. सूचीबद्ध सभी उपकरणों के लिए डेटाशिट्स।