एक साधारण आर सी एयरो नाव बनाना

हवाई नाव क्यों?

1. बस;
2. सस्ते;
3. ;
4. , -.

1. यह विभिन्न प्लेटफार्मों पर रखा जा सकता है: एक नाव, स्लेज, फोम का एक टुकड़ा ...
2. यह नीचे या शैवाल पर नहीं पकड़ता है।

1. घुमाव के लिए एक स्क्रू + स्टीयरिंग व्हील ;
2. एक पेंच + इसकी मोड़ प्रणाली ;
3. दो तय शिकंजा उनके cravings को बदलकर सबसे आसान तरीका है। उसने इसका इस्तेमाल किया।

रिमोट कंट्रोल

संचालन का सिद्धांत

क्या करें?

1. पॉवर कन्वर्टर 0.9 - 5 V -> 5 V $ Ar35 के लिए पॉवर के लिए (USB कनेक्टर, बोर्ड के एक टुकड़े के साथ, कॉम्पैक्टनेस के लिए तोड़ा जा सकता है);
2. 3.3V स्टेबलाइज़र AMS1117-3-3 रेडियो मॉड्यूल को शक्ति प्रदान करने के लिए, उनकी लागत प्रति यूनिट $ 0.03 है ;
3. $ 0.15 के लिए एक उंगली की बैटरी के लिए बैटरी डिब्बे ;

आरसी मॉडल फिलिंग

घटकों

1. रेडियो मॉड्यूल को छोड़कर सभी इलेक्ट्रॉनिक्स के लिए 5 वी;
2. रेडियो मॉड्यूल के लिए 3.3 वी;
3. जितनी जरूरत हो उतनी मोटरों के लिए (मेरा 4.2 V)।

कार्यक्रम

1. आगे स्पिन;
2. वापस स्पिन;
3. मरोड़ना मत।

inline void motLeftStop(){
  PORTD &= ~(1 << MOT_LEFT_PLUS);
  PORTD &= ~(1 << MOT_LEFT_MINUS);
}

inline void motLeftForward(){    
  PORTD |= 1 << MOT_LEFT_PLUS;
  PORTD &= ~(1 << MOT_LEFT_MINUS);
}

inline void motLeftBackward(){
  PORTD &= ~(1 << MOT_LEFT_PLUS);
  PORTD |= 1 << MOT_LEFT_MINUS;
}

inline void motRightStop(){
  PORTD &= ~(1 << MOT_RIGHT_PLUS);
  PORTD &= ~(1 << MOT_RIGHT_MINUS);
}

inline void motRightForward(){
  PORTD |= 1 << MOT_RIGHT_PLUS;
  PORTD &= ~(1 << MOT_RIGHT_MINUS);
}

inline void motRightBackward(){
  PORTD &= ~(1 << MOT_RIGHT_PLUS);
  PORTD |= 1 << MOT_RIGHT_MINUS;
}

int8_t motLeft = 0, motRight = 0; // -127..+127

ISR(TIMER2_OVF_vect)
{
  if(motLeft > 0)
    motLeftForward();
  else if(motLeft < 0)
    motLeftBackward();
  if(motRight > 0)
    motRightForward();
  else if(motRight < 0)
    motRightBackward();
}

ISR(TIMER2_COMPA_vect)
{
  motLeftStop();
}

ISR(TIMER2_COMPB_vect)
{
  motRightStop();
}

1. MotLeft / motRight (मॉड्यूल महत्वपूर्ण नहीं है) में एक सकारात्मक, नकारात्मक या शून्य मान लिखें;
2. OCR2A / OCR2B में "रोटेशन की गति" रिकॉर्ड करें।

void setMotLeft(int8_t v){ // -127..+127
  if(abs(v) < 5) v = 0;
  motLeft = v;  
  OCR2A = abs(v) * 2;
}

void setMotRight(int8_t v){ // -127..+127
  if(abs(v) < 5) v = 0;
  motRight = v;
  OCR2B = abs(v) * 2;
}

if(abs(v) < 5) v = 0;

void motInit(){
  DDRD |= (1 << MOT_LEFT_PLUS) | (1 << MOT_LEFT_MINUS) | (1 << MOT_RIGHT_PLUS) | (1 << MOT_RIGHT_MINUS);
  //TCCR2B |= (1 << CS22)|(1 << CS21)|(1 << CS20); // set up timer with prescaler = 1024.   16 
  //TCCR2B |= (1 << CS22)|(0 << CS21)|(0 << CS20); // set up timer with prescaler = 64.   1 
  TCCR2B |= (0 << CS22)|(1 << CS21)|(0 << CS20); // set up timer with prescaler = 8.  128 
  //TCCR2B |= (0 << CS22)|(0 << CS21)|(1 << CS20); // set up timer with prescaler = 1.  16 
  TIMSK2 |= (1 << TOIE2)|(1 << OCIE2A)|(1 << OCIE2B); // enable overflow interrupt
  TCCR2A &= ~(3); // set WGM20 = 0, WGM21 = 0
  TCCR2B &= ~(1 << 3); // set WGM22 = 0
  setMotLeft(0);
  setMotRight(0);
  sei();
}

1. बिजली चालू करते समय, जॉयस्टिक की प्रारंभिक स्थिति को याद रखें;
2. चक्र में, जॉयस्टिक की स्थिति को पढ़ें, उससे शून्य स्थिति को घटाएं और नाव को डेटा भेजें।

struct ControlStatus{
  int16_t x,y;
}  controlStatus;

    uint8_t packet[MAX_BUFF]; 
    memset(packet, 0, MAX_BUFF);    
    controlStatus.x = (int16_t)analogRead(1) - x0;
    controlStatus.y = (int16_t)analogRead(0) - y0;
    memcpy(packet, &controlStatus, sizeof(controlStatus));
    Mirf.send(packet);
    while(Mirf.isSending()){;};

  while (Mirf.dataReady()) { 
    uint8_t data[MAX_BUFF];
    Mirf.getData(data);
    memcpy(&controlStatus, data, sizeof(controlStatus));
    setMotRot(-controlStatus.x);
    setMotForward(controlStatus.y); 
  }

void setMotRot(int16_t v){
  if(abs(v)<10) v = 0;
  motRot = (int32_t)v;
}
void setMotForward(int16_t v){
  if(abs(v)<10) v = 0;
  motForward = (int32_t)v;
}

1. आनुपातिक;
2. एकीकृत।

int32_t iDeltaRot = 0;
void motTick(){
  int32_t rot = getRotAvg(); //     
  int32_t deltaRot = rot - motRot * rotMaxSpeed / 512;
  iDeltaRot += deltaRot;
  int32_t motRight = (int32_t)motForward * forwardMult - deltaRot * rotMult - iDeltaRot * iDeltaRotMult, 
          motLeft  = (int32_t)motForward * forwardMult + deltaRot * rotMult + iDeltaRot * iDeltaRotMult;  

  int32_t motMax = max(abs(motRight), abs(motLeft));
  if(motMax > 127){
    motRight = (int32_t)motRight * 127 / motMax;
    motLeft  = (int32_t)motLeft  * 127 / motMax;
  }
  
  setMotRight(motRight);
  setMotLeft(motLeft);
}

1. हम नाव के रोटेशन की वास्तविक गति (सड़ांध) और वांछित (motRot * rotMaxSpeed) के बीच अंतर की गणना करते हैं;
2. हम motRight और motLeft शिकंजा की वांछित घूर्णी गति की गणना करते हैं;
3. यदि वांछित रोटेशन की गति अधिकतम संभव से अधिक है, तो हम उनके बीच के अनुपात को बनाए रखते हुए उन्हें कम करते हैं;
4. हम setMotRight / setMotLeft को पहले से ही हमें परिचित कहते हैं।

1. फॉरवर्डमूल - जॉयस्टिक फॉरवर्ड / बैकवर्ड के आंदोलन की संवेदनशीलता;
2. रोटमैक्सस्पीड - दाएं / बाएं सभी तरह से जॉयस्टिक को झुकाते समय वांछित रोटेशन की गति;
3. RotMult - आनुपातिक घटक का गुणांक (वांछित से वर्तमान रोटेशन की गति का विचलन रोटेशन को कितना प्रभावित करता है);
4. iDeltaRotMult - अभिन्न घटक का गुणांक (वांछित से चालू मोड़ का विचलन कितना रोटेशन को प्रभावित करता है)।

स्थिति संकेत

1. लैपटॉप;
2. एलसीडी नोकिया 5110

   
   

1. माइक्रोकंट्रोलर GD32F103R8T6;
2. एसडीआरएएम विनबॉन्ड W9864G6KH-6 (8 एमबी);
3. Winbond W25Q256FVFG फ्लैश मेमोरी (32 एमबी, 100,000 फिर से लिखना चक्र, जो बहुत अच्छा है);
4. FPGA Altera MAX II EPM570T144C5N

1. उपयोग करने के लिए बहुत आसान है। यूट्यूब पर सरल प्रलेखन, उदाहरण, वीडियो हैं ... कुछ घंटों में आप इसे खरोंच से समझ सकते हैं। उसके बारे में जानने के लिए आपको लगभग सभी चीज़ों की ज़रूरत है: विकी पेज और इंस्ट्रक्शन सेट
2. बहुत तेज विकास। विजुअल स्टूडियो जैसा विजुअल एडिटर (केवल आसान)। मैंने घटकों को फेंक दिया और सब कुछ काम करता है।
3. उच्च गुणवत्ता वाले घटक। 100k फिर से लिखने के लिए एक ही फ्लैश मेमोरी।
4. एक डीबगर जो पीसी का उपयोग करके एक डिस्प्ले का अनुकरण कर सकता है और एक COM पोर्ट के माध्यम से अपने एमके के साथ संवाद कर सकता है। आपको डिवाइस को पूरी तरह से विकसित करने, डिबग करने और प्रदर्शन खरीदने की अनुमति देता है, केवल तभी जब सब कुछ काम करता है।
   हालांकि उसके साथ एक समस्या है

   . . , , .
   
5. प्रतिरोधक सेंसर आप काफी छोटे नियंत्रण बना सकते हैं और उन्हें अपने नाखूनों या किसी स्टाइलस के साथ प्रहार कर सकते हैं।

1. मूल्य। $ 50 अभी भी 4.3 '' के प्रदर्शन के लिए बहुत कुछ है।
2. कुछ मौजूदा घटक हैं, कुछ घटक सेटिंग्स, कैसे अपनी खुद की बनाने के लिए स्पष्ट नहीं है। यह आंशिक रूप से आरेखण (रेखाएँ, आयताकार, मंडलियाँ, ...) के कार्यों से ऑफसेट होता है।
3. उन्नत किए जाने पर मानक गेज घटक टिमटिमाता है।
4. नहीं (कम से कम मुझे नहीं मिला) पारदर्शिता।
5. बिजली की आवश्यकताएं: 4.75-7 वी और औसत वर्तमान 250 एमए। जब वोल्टेज गिरता है, तो डिस्प्ले चमकने लगता है।
6. केवल UART SPI और I²C पर उसके साथ संचार कर सकता है।
7. GPIO आउटपुट केवल एक लूप (कोई कंघी 2.54 मिमी) के लिए, कोई ADC नहीं।

1. स्थिति संकेत। मुझे मुख्य रूप से दिलचस्पी है:
   
   • शिकंजा की "घूर्णी गति";
   • IDeltaRot चर का मान वांछित वांछित कोण कितना भिन्न होता है;
   • नाव रोटेशन की गति;
   • नाव के रोटेशन का कोण;
   • रिमोट कंट्रोल से पैकेट प्राप्त करने की आवृत्ति;
   • प्रेरक कार्य के लिए कॉल की आवृत्ति।
   
   
2. पैरामीटर्स सेट करना, अर्थात् फॉरवर्डमूल, रॉटमैक्सस्पीड, रॉटमल्ट, आईडेलरॉटमूल्ट।

1. संकेत:
   
   
   
2. पैरामीटर सेटिंग्स: पहले 4 कॉलम बाएं से दाएं: फॉरवर्डमूल, रोटमॉल्ट, आईडेलरॉटमॉल्ट, रोटमैक्सस्पीड।
   
   
   
   
   

की विशेषताओं

• रॉड 9 जी;
• वजन 115 ग्राम, जिसमें से बैटरी 52 जी वजन;
• अधिकतम त्वरण 0.77 m / s ^ 2 है। मानव के लिए 5 किमी / घंटा, अगर कोई पानी प्रतिरोध नहीं था, तो नाव 1.8 एस में तेजी लाएगी;
• यदि आप रिमोट कंट्रोल और नाव (डिस्प्ले और बैटरी के बिना) दोनों में अरुडिनो नैनो का उपयोग करते हैं तो घटकों की लागत लगभग $ 15 है।

निष्कर्ष