आपका दिन शुभ हो!

जैसा कि वादा किया गया है, मैं इलेक्ट्रॉनिक भरने और सॉफ्टवेयर के अधिक विस्तृत विवरण के साथ अपनी पिछली पोस्ट जारी रखूंगा।

लुन 1.0

पहला डिज़ाइन विकल्प बहुत सरल था: stm32vl- डिस्कवरी, एक प्राचीन रेडियो-नियंत्रित मशीन से रिमोट कंट्रोल और मोटर्स के लिए 2 इनवर्टर। यदि योजनाबद्ध रूप से, यह कुछ इस तरह से देखा जाता है:

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

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

प्रारंभिक फर्मवेयर

#include <stm32f10x.h>
#include <stm32f10x_gpio.h>
#include <stm32f10x_rcc.h>
#include <stm32f10x_tim.h>
# अलग करें <misc.h>

शून्य init_leds ();
शून्य init_motors ();
शून्य init_timer ();
शून्य init_button ();
शून्य Delay_sig ();

int sec = 0;
int sm1 = 1000;
int m1 = 750;
int m2 = 750;
int i, l;

uint8_t r1 = 0, r2 = 0, r3 = 0, r4 = 0;

#define पहले_मोटर GPIO_Pin_10
#define second_motor GPIO_Pin_12
#define सर्वो_मोटर GPIO_Pin_11
#define blue_led GPIO_Pin_8
#define green_led GPIO_Pin_9

#define रेडियो 4 GPIO_Pin_8
#define रेडियो 3 GPIO_Pin_9
#define रेडियो 2 GPIO_Pin_10
#define रेडियो 1 GPIO_Pin_11

#define BUTTON GPIO_Pin_0

int main ()

{
init_leds ();
init_button ();
init_motors ();
init_timer ();

SysTick_Config (SystemCoreClock / 300);

करना
{

r1 = GPIO_ReadInputDataBit (GPIOA, radio1);
r2 = GPIO_ReadInputDataBit (GPIOA, radio2);
r3 = GPIO_ReadInputDataBit (GPIOA, रेडियो 3);
r4 = GPIO_ReadInputDataBit (GPIOA, radio4);

} जबकि (1);
}

शून्य SysTick_Handler ()
{
स्थिर uint8_t btn_old_state = 0;
uint8_t btn_state = GPIO_ReadInputDataBit (GPIOA, BUTTON);

अगर (btn_old_state == 0 && btn_state == 1)
{
if (m1 <1000) m1 = m1 + 50;
}

अगर (r1 == 1)
{
if (sm1 <1600) sm1 = sm1 + 10;
}

अन्यथा
{
if (sm1> 1000) sm1 = sm1-10;
}

अगर (r3 == 1)
{
एम 2 = 900;
}

अन्यथा
{
एम 2 = 750;
}

अगर (r2 == 1)
{
if (sm1> 400) sm1 = sm1-10;
}

अन्यथा
{
if (sm1 <1000) sm1 = sm1 + 10;
}

अगर (r4 == 1)
{
एम 1 = 750;
}

btn_old_state = btn_state;
}

शून्य init_leds ()
{
RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOC, सक्षम);
GPIO_InitTypeDef gpio;
GPIO_StructInit (& gpio);
gpio.GPIO_Mode = GPIO_Mode_Out_PP;
gpio.GPIO_Pin = blue_led | green_led;
GPIO_Init (GPIOC, & gpio);
GPIO_ResetBits (GPIOC, blue_led);
GPIO_ResetBits (GPIOC, green_led);
}

शून्य init_motors ()
{
RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOC, सक्षम);
GPIO_InitTypeDef gpio;
GPIO_StructInit (& gpio);
gpio.GPIO_Mode = GPIO_Mode_Out_PP;
gpio.GPIO_Pin = first_motor | second_motor | servo_motor
GPIO_Init (GPIOC, & gpio);
GPIO_ResetBits (GPIOC, first_motor);
GPIO_ResetBits (GPIOC, second_motor);
GPIO_ResetBits (GPIOC, सर्वो_मोटर);
}

शून्य init_button ()
{
RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOA, सक्षम);
GPIO_InitTypeDef gpio;
GPIO_StructInit (& gpio);
gpio.GPIO_Mode = GPIO_Mode_IPD;
gpio.GPIO_Pin = BUTTON | Radio1 | Radio2 | radio3 | radio4 | BT_en |
gpio.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init (GPIOA, & gpio);
}

शून्य init_timer ()
{
RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM6, सक्षम);
TIM_TimeBaseInitTypeDef base_timer;
TIM_TimeBaseStructInit (& base_timer);
base_timer.TIM_Prescaler = 12000 - 1;
base_timer.TIM_Period = 20;
TIM_TimeBaseInit (TIM6, और base_timer);
TIM_ITConfig (TIM6, TIM_IT_Update, ENABLE);

TIM_Cmd (TIM6, सक्षम);
NVIC_EnableIRQ (TIM6_DAC_IRQn);
}

शून्य विलंब_ ()
{
int int = 0;
for (us = 0; us <5000; us ++)
{
if (us == sm1) {GPIO_ResetBits (GPIOC, इमदादी_मोटर)};
if (us == m1) {GPIO_ResetBits (GPIOC, first_motor);};
if (us == m2) {GPIO_ResetBits (GPIOC, second_motor);};
}
}

शून्य TIM6_DAC_IRQHandler ()
{
अगर (TIM_GetITStatus (TIM6, TIM_IT_Update)! = RESET)
{
TIM_ClearITPendingBit (TIM6, TIM_IT_Update);
GPIO_SetBits (GPIOC, first_motor);
GPIO_SetBits (GPIOC, second_motor);
GPIO_SetBits (GPIOC, सर्वो_मोटर);
Delay_sig ();
}
}

लुन 2.0

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

यह पता चला:

मुख्य निराशा यह पता लगाना था कि CoIDE STM32F303 माइक्रोकंट्रोलर्स की प्रोग्रामिंग का समर्थन नहीं करता है। बिना किसी हिचकिचाहट के, उसी ग्रहण की एक वाणिज्यिक सभा - एटोलिक ट्रूस्टुडिओ को स्थापित किया गया था। लाइट संस्करण संकलित फर्मवेयर (32KB से अधिक नहीं) के आकार तक सीमित था, यह हमारे लिए अनुकूल था और परियोजना दूसरे वातावरण में चली गई।
एसटी वेबसाइट पर, आप इस आईडीई के लिए उदाहरण के लिए स्रोत कोड डाउनलोड कर सकते हैं, जिसने हमें बहुत प्रसन्न किया। समस्या तब सामने आई जब उन्होंने कोड का गहराई से अध्ययन करना शुरू किया। तथ्य यह है कि आप बस पिछले फर्मवेयर से कोड को कॉपी नहीं कर सकते हैं, STM32f3 में, STM32f100 के साथ तुलना में, कई रजिस्टरों का उद्देश्य बदल गया है। और उस समय हमें निर्माता से केवल उदाहरण मिले, ऐसा महसूस हुआ कि कोई भी इस डिबगिंग बोर्ड को बिल्कुल भी नहीं कर रहा है, हालांकि यह एक साल से बिक्री पर था। समस्याएँ तब जोड़ी गईं जब हमने आर्द्रता सेंसर स्थापित करने का निर्णय लिया। मैंने लेख "STM32 + DHT11" से सेंसर के साथ काम करने के लिए ईमानदारी से कोड उधार लिया था, लेकिन इस बिंदु पर लिखे फर्मवेयर ने पूरी तरह से नए कोड के साथ काम करने से इनकार कर दिया, यह सिर्फ निष्पादित नहीं किया। संकलन के दौरान कोई त्रुटि या चेतावनी नहीं थी, लेकिन कोड हठपूर्वक सही तरीके से निष्पादित नहीं करना चाहता था, दो दिनों और कई तंत्रिका कोशिकाओं की हत्या से पता चला कि यदि आप सेटिंग्स में अनुकूलन को अक्षम करते हैं, तो सब कुछ काम करेगा। लेकिन यहां एक समस्या थी जो मुझे बिल्कुल भी उम्मीद नहीं थी, अनुकूलन को अक्षम करने के बाद, फर्मवेयर का आकार 32K से अधिक होने लगा, मुझे एक नए विकास के माहौल की तलाश करनी थी। कुछ समय की खोज के बाद, मुझे एक ग्रहण-आधारित आईडीई स्थापित करने के बारे में एक लेख आया। यह एक परियोजना बनाने और फिर से आगे बढ़ने के लिए बनी हुई है।
ब्लूटूथ मॉड्यूल की खरीद के साथ, एंड्रॉइड के लिए एक एप्लिकेशन का विकास शुरू हुआ। इससे पहले, मैंने मोबाइल उपकरणों के लिए कभी आवेदन नहीं लिखा था, इसलिए इसे शुरू करना काफी कठिन था। आलेखीय संपादक में बटन कैसे चला गया इसकी गलतफहमी के कारण त्रुटि हुई और अनुप्रयोग समापन विशेष रूप से निराशाजनक था।
प्रोग्रामेटिक परिवर्तनों के अलावा, लेआउट को नया स्वरूप देने के लिए बहुत समय समर्पित किया गया था।

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

मैं लेख के सभी प्रोग्राम कोड लाने की बात नहीं देखता, और मुझे लगता है कि बेहतर होगा कि मैं उन बिंदुओं पर ध्यान दूं जो समस्याओं का कारण थे।

कार्यक्रम के लिए क्या कार्य निर्धारित किए गए थे:

0. सर्वो और इनवर्टर को नियंत्रित करने के लिए;
1. डिबग बोर्ड में निर्मित सेंसर से डेटा पढ़ें;
2. संकेतों के अनुसार, पाठ्यक्रम को समायोजित करें;
3. फोन को डेटा प्राप्त करें और भेजें;
4. रास्ते में आने वाली बाधाओं को रोकें या जाएं;
5. एक उपयुक्त मार्ग खोजें;
6. परिधीय सेंसर से डेटा पढ़ें;
7. बैटरी को बहुत अधिक बाहर न जाने दें।

पीडब्लूएम पर तीन चैनलों के साथ पॉइंट जीरो का आयोजन किया गया था। परिणामस्वरूप, कोड को निष्पादित करने के बाद, निम्नलिखित चित्र बाहर निकलना चाहिए:

, जहां लंबवत एक सेल 0.4 वोल्ट है, और क्षैतिज रूप से एक सेल 2.5 एमएस है।

PWM इनिशियलाइज़ेशन

शून्य TIM_Init ()

{

uint16_t Channel1Pulse = 139, Channel2Pulse = 104, Channel3Pulse = 104;

TIM_Config ();

/ * TIM1 घड़ी सक्षम करें * /

RCC_APB2PeriphClockCmd (RCC_APB2Periph_TIM1, ENABLE);

/ * समय आधार विन्यास * /

TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t) ((SystemCoreClock / 100000));

TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

TIM_TimeBaseStructure.TIM_Period = (1000);

TIM_TimeBaseStructure.TIM_ClockDivision = 0;

TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;

TIM_TimeBaseInit (TIM1, & TIM_TimeBaseStructure);

/ * चैनल 1, पीडब्लूएम मोड में 2,3 कॉन्फ़िगरेशन * /

TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;

TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;

TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Disable;

TIM_OCInitStructure.TIM_Pulse = Channel1Pulse;

TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;

TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Set;

TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset;

TIM_OC1Init (TIM1, & TIM_OCInitStructure);

TIM_OCInitStructure.TIM_Pulse = Channel2Pulse;

TIM_OC2Init (TIM1, & TIM_OCInitStructure);

TIM_OCInitStructure.TIM_Pulse = Channel3Pulse;

TIM_OC3Init (TIM1, & TIM_OCInitStructure);

/ * TIM1 काउंटर सक्षम * /

TIM_Cmd (TIM1, सक्षम);

/ * TIM1 मुख्य आउटपुट सक्षम * /

TIM_CtrlPWMOutputs (TIM1, सक्षम);

}

गति को बदलने के लिए केवल लिखना आवश्यक था:

TIM_OCInitStructure.TIM_Pulse = n;
TIM_OC1Init (TIM1, & TIM_OCInitStructure);

पहला बिंदु पूरी तरह से निर्माता से उदाहरणों द्वारा तय किया गया था। हां, मैं डेटा ले सकता था, लेकिन प्रोसेसिंग के बिना कुछ करना मुश्किल था।

ग्राफ़ फ़िल्टर के बिना एक्सेलेरोमीटर रीडिंग प्रदर्शित करते हैं। पहले एक रोल होता है, फिर पिच होता है, फिर उसी समय रोल और पिच दोनों होते हैं।

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

फ्लोट getPitch ()
{
वापसी atan2 (2 * (q2 * q3 + q0 * q1), q0 * q0 - q1 * q1 - q2 * q2 + q3 * q3);
}

फ्लोट गेटवाईव ()
{
रिटर्न असिन (-2 * (q1 * q3 - q0 * q2));
}

फ्लोट getRoll ()
{
वापसी atan2 (2 * (q1 * q2 + q0 * q3), q0 * q0 + q1 * q1 - q2 * q2 - q3 * q3);
}

जब एसवीपी पाठ्यक्रम सुधार मोड में प्रवेश करता है, तो वर्तमान स्थिति को संदर्भ बिंदु के रूप में लिया जाता है:

nullkorr = getRoll () * DegToRadIMU;

अगला, वर्तमान स्थिति उसी तरह से निर्धारित की जाती है और संदर्भ बिंदु और वर्तमान स्थिति के बीच के कोण की गणना की जाती है।

फ्लोट रेटंगल (फ्लोट ए, फ्लोट बी)
{
ए + = 180;
बी + = 180;
int r1 = 0;
r1 = ab;
r1 = r1% 360;
if (r1 <0) r1 + = 360;
if (r1> 180) वापसी - (360 - r1);
और वापसी r1;
}

कोण की गणना करने के बाद, डेटा को इमदादी ड्राइव पर प्रेषित किया जाता है जहां सुधार कोण वर्तमान रोटेशन कोण से लिया जाता है।

तीसरे पैराग्राफ के साथ कोई समस्या नहीं थी, UART के साथ या HC-04 के साथ काम करने के उदाहरणों को खोजना मुश्किल नहीं है।
चौथे बिंदु के साथ कुछ परेशानियां थीं, अल्ट्रासोनिक सेंसर आर्द्रता संवेदक के रूप में एक ही समय में आया था, और मैं एक नए विकास वातावरण की तलाश कर रहा था। हां, और सेंसर के परीक्षण ने मेरे गुलाबी सपनों को नष्ट कर दिया कि यह एक सीधे संकीर्ण बीम में टकराता है और सामग्री और सतह के रोटेशन के कोण की परवाह किए बिना वापस परिलक्षित होता है। एमके को अनावश्यक कार्यों के साथ लोड नहीं करने के लिए, सेंसर के साथ संचार को बाधित करने पर आयोजित किया जाता है। इस जगह इस अच्छे आदमी से एक उदाहरण लिया जाता है । मुझे कोड को थोड़ा नया करना पड़ा, क्योंकि टाइमर STM32f3 में थोड़ा बदल गया।

संशोधित विकल्प

/ **

** ==================================================== ===========================

**

** सार: अल्ट्रासोनिक सेंसर बाधा हैंडलर

**

** ==================================================== ===========================

* /

शून्य EXTI3_IRQHandler (शून्य)

{

// यदि आपने एक उभरता हुआ मोर्चा पकड़ा है

अगर (कैच_स्टैटस)

{

// पल्स अवधि की गिनती शुरू करें

TIM6-> CR1 | = TIM_CR1_CEN;

// गिरने वाले किनारे को पकड़ने के लिए स्विच करें

catcher_status = 1;

EXTI-> RTSR & = ~ EXTI_RTSR_TR3;

EXTI-> FTSR | = EXTI_FTSR_TR3;

}

// अगर गिरती हुई धार

अन्यथा

{

TIM6-> CR1 & = ~ TIM_CR1_CEN; // टाइमर बंद करो

अगर (TIM6-> CNT> 58)

{

अवधि = TIM6-> CNT; // माइक्रोसेकंड में अवधि पढ़ें

अगर (अवधि <5800 && korr <25 && korr> -25 && stepmode == 5)

{

एम 1 = 0;

Upper_ctrl (m1); // मोटर बंद

बी बी एफ = 0;

stepmode = 1;

}

smas [scnum] = TIM6-> CNT;

}

TIM6-> CNT = 0; // शून्य रजिस्टर काउंटर

// बढ़ते किनारे को पकड़ने के लिए स्विच करें

catcher_status = 0;

EXTI-> FTSR & = ~ EXTI_FTSR_TR3;

EXTI-> RTSR | = EXTI_RTSR_TR3;

// 50 एमएस उलटी गिनती के लिए टाइमर 6 शुरू करें

TIM6-> DIER | = TIM_DIER_UIE; // टाइमर व्यवधान सक्षम करें

TIM6-> CR1 | = TIM_CR1_CEN; // टाइमर शुरू करें

}

EXTI-> पीआर | = 0x01; // ध्वज को साफ़ करें

}

/ **

** ==================================================== ===========================

**

** सार: अल्ट्रासोनिक सेंसर बाधा हैंडलर

** TIM7 बाधा हैंडलर

** टाइमर के बाद कॉल किया गया 7 सिग्नल पल्स के लिए 10 μs गिना गया है

** ==================================================== ===========================

* /

शून्य TIM7_IRQHandler (शून्य)

{

TIM7-> SR & = ~ TIM_SR_UIF; // UIF फ्लैग को रीसेट करें

GPIOD-> ODR और = ~ GPIO_Pin_2; // सिग्नल आवेग को रोकें

TIM7-> DIER & = ~ TIM_DIER_UIE; // टाइमर को बाधित करने में अक्षम करें 7

}

/ **

** ==================================================== ===========================

**

** सार: अल्ट्रासोनिक सेंसर बाधा हैंडलर

** बाधित हैंडलर TIM6_DAC

** टाइमर 6 के बाद कॉल किया जाता है, चक्र अवधि के लिए 50 μs गिना जाता है

** ==================================================== ===========================

* /

शून्य TIM6_DAC_IRQHandler (शून्य)

{

TIM6-> SR & = ~ TIM_SR_UIF; // UIF फ्लैग को रीसेट करें

यदि (स्कैनिंग == 2)

{

अगर (smas [scnum]> 800)

{

scnum ++;

US_servo_ctrl (scnum);

अगर (scnum> = 160)

{

scnum = 0;

स्कैन करना = 3;

US_servo_ctrl (80);

}

}

अन्यथा

{

scd ++;

अगर (scd> 3)

{

scd = 0;

smas [scnum] = 23200;

scnum ++;

US_servo_ctrl (scnum);

}

}

}

GPIOD-> ODR | = GPIO_Pin_2; // सिग्नल पल्स चालू करें

// 10 एमएस उलटी गिनती के लिए टाइमर 7 शुरू करें

TIM7-> DIER | = TIM_DIER_UIE; // टाइमर इंटरप्ट 7 को सक्षम करें

TIM7-> CR1 | = TIM_CR1_CEN; // टाइमर शुरू करें

}

शून्य USsensor_init ()

{

// ====================================================== ========================

// सेट टाइमर 6

// 2 उद्देश्यों के लिए उपयोग किया जाता है:

// 1) इको पल्स की अवधि की गिनती (150 μs - 25 ms)

// 2) चक्र अवधि की रिपोर्टिंग के लिए रुकावट के साथ गिनती - समय,

// इको लाइन में अवशिष्ट दोलनों के क्षीणन के लिए आवश्यक

// ====================================================== ========================

// टाइमर टाइमिंग चालू करें

RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM6, सक्षम);

// माइक्रोसेकंड में एक बार ट्रिगर करने के लिए सीमक सेट करें

TIM6-> PSC = 72 - 1;

// ट्रिगर सीमा - 50 एमएस = 50,000 μs

TIM6-> ARR = 50000;

// TIM6_IRQn व्यवधान सक्षम करें - चक्र अवधि की गणना करने के लिए आवश्यक

NVIC_SetPyerity (TIM6_DAC_IRQn, 3);

NVIC_EnableIRQ (TIM6_DAC_IRQn);

// ====================================================== ========================

// सेट टाइमर 7

// ====================================================== ========================

// टाइमर टाइमिंग चालू करें

RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM7, सक्षम);

// माइक्रोसेकंड में एक बार ट्रिगर करने के लिए सीमक सेट करें

TIM7-> PSC = 72 - 1;

// प्रतिसाद सीमा - 10 μs

TIM7-> ARR = 10;

// सिग्नल पल्स को गिनने के लिए TIM7_IRQn इंटरप्ट को सक्षम करें

NVIC_SetPyerity (TIM7_IRQn, 2);

NVIC_EnableIRQ (TIM7_IRQn);

// ====================================================== ========================

EXTI_InitTypeDef EXTI_InitStructure;

GPIO_InitTypeDef GPIO_InitStructure;

NVIC_InitTypeDef NVIC_InitStructure;

RCC_APB2PeriphClockCmd (RCC_APB2Periph_SYSCFG, सक्षम);

RCC_AHBPeriphClockCmd (RCC_AHBPeriph_GPIOD, ENABLE);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;

GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;

GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

GPIO_Init (GPIOD, और GPIO_InitStructure);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;

GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;

GPIO_Init (GPIOD, और GPIO_InitStructure);

SYSCFG_EXTILineConfig (EXTI_PortSourceGPIOD, EXTI_PinSource3);

/ * EXTI3 लाइन कॉन्फ़िगर करें * /

EXTI_InitStructure.EXTI_Line = EXTI_Line3;

EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;

EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;

EXTI_InitStructure.EXTI_LineCmd = सक्षम;

EXTI_Init (& EXTI_InitStructure);

NVIC_InitStructure.NVIC_IRQChannel = EXTI3_IRQn;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPyerity = 0x0F;

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;

NVIC_InitStructure.NVIC_IRQChannelCmd = सक्षम;

NVIC_Init (& NVIC_InitStructure);

}

यह कोड PORTD.3 पर एक रुकावट का उपयोग करता है, या इसके बजाय PORTD पर होना चाहिए, मुझे अभी भी यह पता नहीं चला है कि तीसरे पिन पर सभी बंदरगाहों पर व्यवधान क्यों उत्पन्न होता है। एक रुकावट का उपयोग निर्माता से एक उदाहरण से लिया जाता है, सीधे व्यवधान सेटिंग रजिस्टर में लिखने का प्रयास किया गया था, परिणाम "0" है या कोई रुकावट नहीं है, या यह सभी बंदरगाहों पर है।
यदि कोई समझाता है कि त्रुटि कहां होगी, तो आप बहुत आभारी होंगे।

पांचवें बिंदु को जल्दी से पारित किया गया था, लेकिन छठे में एडीसी के ट्यूनिंग ने कुछ सिरदर्द पैदा किया।
फिर, उदाहरण, कोई शिकायत नहीं, उदाहरण ठीक काम करता है। केवल उदाहरण में वे एक एडीसी चैनल से पढ़ने पर विचार करते थे, और मेरे पास उनमें से चार हैं। चैनलों, नियमित समूहों, दर्ज किए गए समूहों के बारे में डेटाशीट के संकेत। सीमित समय के कारण, पुरानी "दादाजी" पद्धति को चुना गया था:
- चैनल का आनंद;
एक बार पढ़ने की शुरुआत;
- परिणाम का सामना करना;
'बार-बार।

एडीसी ने पढ़ा

शून्य ADC1_2_IRQHandler (शून्य)

{

ADC_ClearITPendingBit (ADC1, ADC_IT_EOC);

ADC1ConvertedValue = ADC_GetConversionValue (ADC1);

/ * वोल्टेज की गणना करें * /

ADC1ConvertedVoltage = (ADC1ConvertedValue * 3300) / 0xFFF;

adcp [iadc] = ADC1ConvertedVoltage;

iadc ++;

पहले से ही = 1;

}

शून्य सेटैडचैनेल ()

{

/ * ADC चैनल कॉन्फ़िगर करें * /

numadc [0] = 7; // बीटी

numadc [1] = 16; // किलोमीटर

numadc [2] = 6; // बैटरी वोल्टेज

numadc [3] = 3; // गैस सेंसर

kadc = 4; // राशि चैनल

}

शून्य getADC (uint8_t चैनल)

{

यदि (ADCready == 1)

{

पहले से ही = 0;

ADC_RegularChannelConfig (ADC1, चैनल, 1, ADC_SampleTime);

ADC_StartConversion (ADC1);

}

}

uint8_t ADC_init ()

{

uint16_t कैलिब्रेशन_वल्यू = 0;

ADC_InitTypeDef ADC_InitStructure;

ADC_CommonInitTypeDef ADC_CommonInitStructure;

GPIO_InitTypeDef GPIO_InitStructure;

/ * ADC घड़ी कॉन्फ़िगर करें * /

RCC_ADCCLKConfig (RCC_ADC12PLLCLK_Div2);

/ * ADC1 घड़ी सक्षम करें * /

RCC_AHBPeriphClockCmd (RCC_AHBPeriph_ADC12, सक्षम);

/ * एडीसी चैनल विन्यास * /

/ * GPIOC पेरिफ़ घड़ी सक्षम करें * /

RCC_AHBPeriphClockCmd (RCC_AHBPeriph_GPIOC, ENABLE);

RCC_AHBPeriphClockCmd (RCC_AHBPeriph_GPIOA, ENABLE);

/ * ADC Channel7 को अनुरूप इनपुट के रूप में कॉन्फ़िगर करें * /

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 |

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;

GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;

GPIO_Init (GPIOC, और GPIO_InitStructure);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;

GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;

GPIO_Init (GPIOA, और GPIO_InitStructure);

ADC_StructInit (& ADC_InitStructure);

/ * अंशांकन प्रक्रिया * /

ADC_VoltageRegulatorCmd (ADC1, सक्षम);

/ * देरी देरी के बराबर * /

विलंब (15);

ADC_SelectCalibrationMode (ADC1, ADC_CalibrationMode_Single);

ADC_StartCalibration (ADC1);

जबकि (ADC_GetCalibrationStatus (ADC1)! = RESET);

calibration_value = ADC_GetCalibrationValue (ADC1);

ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;

ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;

ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Dadabled;

ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot;

ADC_CommonInitStructure.ADC_TwoSamplingDelay = 1000;

ADC_CommonInit (ADC1, और ADC_CommonInitStructure);

ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable;

ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;

ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;

ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;

ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;

ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;

ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;

ADC_InitStructure.ADC_NbrOfRegChannel = 1;

ADC_Init (ADC1, और ADC_InitStructure);

ADC_RegularChannelSequencerLengthConfig (ADC1,1);

/ * ADC1 नियमित चैनल 7 विन्यास * /

ADC_RegularChannelConfig (ADC1, ADC_Channel_7, 1, ADC_SampleTime);

ADC_TempSensorCmd (ADC1, सक्षम);

/ * ADC1 सक्षम करें / /

ADC_Cmd (ADC1, सक्षम);

/ * ADRDY के लिए प्रतीक्षा करें * /

जबकि (ADC_GetFlagStatus (ADC1, ADC_FLAG_RDY));

NVIC_InitTypeDef NVIC_InitStructure;

NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

NVIC_InitStructure.NVIC_IRQChannelCmd = सक्षम;

NVIC_Init (& NVIC_InitStructure);

ADC_ITConfig (ADC1, ADC_IT_EOC, सक्षम);

वापसी 1;

}

/ * और कहीं मुख्य जगह पर

अगर (iadc <kadc)

{

getADC (numadc [iadc]);

}

अन्यथा

{

iadc = 0;

}

* /

जब मैंने एडीसी का पता लगाया, तब सातवें पैराग्राफ में दिक्कत नहीं हुई।

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

कुछ हद तक कक्षा

सार्वजनिक वर्ग

पेंट पेंट;

int [] एक्स;

int [] वाई;

अंतिम स्थिर int त्रिज्या = 50;

int PointerCount;

सार्वजनिक कुछ दृश्य (संदर्भ संदर्भ, गुणनिष्ठ गुण)

{

सुपर (संदर्भ, गुण);

पेंट = नया पेंट ();

पेंट.सेटकोलर (Color.RED);

पेंट.सेटस्ले (Style.STROKE);

पेंट.सेटस्ट्रोकविथ (3);

पॉइंटरकाउंट = 0;

X = नया int [10]; // ये निर्देशांक के सरणियाँ होंगे (हम 10 उंगलियों तक अनुभव करेंगे)

वाई = नया इंट [10];

}

सार्वजनिक बूलियन onTouchEvent (MotionEvent ईवेंट)

{

StringBuilder परिणाम = नया StringBuilder (300);

PointerCount = event.getPointerCount ();

for (int i = 0; मैं <PointerCount; i ++)

{

int ptrId = event.getPointerId (i);

X [i] = (int) event.getX (i); // निर्देशांक याद रखें

Y [i] = (int) event.getY (i);

MainActivity.flag = 1;

MainActivity.setX (X [i], Y [i], ptrId);

}

सच लौटना;

}

संरक्षित शून्य onDraw (कैनवास कैनवास)

{

for (int i = 0; मैं <PointerCount; i ++)

{

if (Y [i] <(MainActivity.height / 4)) Y [i] = MainActivity.height / 4;

if (Y [i]> (MainActivity.height * 0.75) -75) Y [i] = (int) (MainActivity.height * 0.75) -75;

कैनवस.ट्रैककैरल (एक्स [i], वाई [i], रेडियस, पेंट);

कैनवस। विथलाइन (MainActivity. उपलब्धता / 2, (int) (MainActivity.height * 0.75) -25, X [i], Y [i], पेंट);

कैनवस.विट्रलाइन (0, (int) (MainActivity.height / 4) -50, MainActivity. उपलब्धता, (int) (MainActivity.height / 4) -50, पेंट);

कैनवस.विट्रलाइन (0, (int) (MainActivity.height * 0.75) -25, MainActivity. उपलब्धता, (int) (MainActivity.height * 0.75) -25, पेंट);

}

अमान्य ();

}

}

और सेंसर के बारे में जानकारी प्रदर्शित करने के लिए DialogFragment का उपयोग किया गया था:

संवाद वर्ग

पब्लिक क्लास डायलॉग डायलॉगफ्रैगमेंट लागू करता है OnClickListener {

अंतिम स्ट्रिंग LOG_TAG = "myLogs";

android.widget.TextView डाच;

सार्वजनिक दृश्य onCreateView (लेआउटइन्फ्लैटर इनफ्लोटर, व्यूग्रुप कंटेनर,

बंडल को बचाया गया

getDialog ()। setTitle ("सेंसर रीडिंग");

देखें v = inflater.inflate (R.layout.dialog, null);

v.findViewById (R.id.btnYes) .setOnClickListener (यह);

datch = (android.widget.TextView) v.findViewById (R.id.textView1);

datch.setText (MainActivity.mesdat);

वापसी v;

}

सार्वजनिक शून्य पर क्लिक करें (देखें v) {

Log.d (LOG_TAG, "डायलॉग:" + ((बटन) v) .getText ());

खारिज ();

}

सार्वजनिक शून्य onDismiss (DialogInterface संवाद) {

super.onDismiss (संवाद);

Log.d (LOG_TAG, "संवाद: onDismiss");

}

सार्वजनिक शून्य onCancel (DialogInterface संवाद) {

super.onCancel (संवाद);

Log.d (LOG_TAG, "संवाद: onCancel");

}

}

अंतभाषण

मुझे पता है कि निर्माण प्रक्रिया केवल सामान्य शब्दों में कवर की गई है, लेकिन यदि कोई प्रश्न हैं, तो मैं निश्चित रूप से उनका जवाब देने की कोशिश करूंगा। प्रबंधन कार्यक्रम आदर्श से बहुत दूर है, अभी भी बहुत कुछ विचार करना बाकी है। , « » . .

लुन होवरक्राफ्ट भाग 2

लुन 1.0

लुन 2.0

अंतभाषण

More articles: