Arduino प्लेटफॉर्म लोकप्रिय है, भले ही इसे डांटा गया हो या प्रशंसा की गई हो। इसके निर्माता कुछ माउस क्लिक + कोड और वॉइला की कुछ पंक्तियों के स्तर तक प्रवेश की दहलीज को कम करने में कामयाब रहे - यहां आपके पास एक निमिष एलईडी है। और सामान्य तौर पर, AVR पर शिल्प के तेजी से प्रोटोटाइप के लिए, Arduino चीज बेहद सुविधाजनक है। केवल एक चीज वे विफल हो गए आईडीई, जिसे आईडीई कॉल करना मुश्किल है। आईडीई के कार्यों के बीच, यह केवल एक चीज प्रदान करता है - एक परियोजना के निर्माण और विधानसभा का स्वचालन।

विंडोज उपयोगकर्ताओं के लिए, एक विकल्प है: एमएस विज़ुअल स्टूडियो कम्युनिटी + vMicro प्लगइन जो आपको स्केच लिखने की अनुमति देता है, लेकिन आईडीई द्वारा प्रदान की गई सभी अच्छाइयों के साथ। प्लग-इन "स्टूडियो" मेनू के माध्यम से स्टूडियो में समस्याओं के बिना स्विंग करता है और परीक्षण में आपको जितना पसंद है उतना काम करता है। सिद्धांत में भुगतान किया गया संस्करण चरण-दर-चरण डिबगिंग का समर्थन करता है, लेकिन वे, vMicro की लाइसेंस प्राप्त प्रतिलिपि के स्वामी के रूप में, बहुत प्रभावित नहीं थे।

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

1. मिट्टी की तैयारी

क्यूटी क्रिएटर किसी भी अधिक या कम स्वाभिमानी लिनक्स वितरण के रिपॉजिटरी में उपलब्ध है। उदाहरण के लिए archa में इसे इस तरह मिलता है

$ sudo pacman -S qtcreator 

इसके अलावा, हमें खुद Arduino के बारे में पैकेजों की आवश्यकता होगी।

 $ sudo pacman -S arduino arduino-avr-core 

जिस दिन हम अंततः Arduino को भूल जाते हैं, हमें AVR के लिए एक और संकलक, कोडांतरक, लिंकर और मानक C लाइब्रेरी की आवश्यकता होगी, इसलिए हम उन्हें डालते हैं

 $ sudo pacman -S avr-gcc avr-binutils avr-libc 

हम इस आलेख में डीबगर और एमुलेटर का परीक्षण करेंगे, इसलिए हम ऐसे पैकेज स्थापित करेंगे

 $ sudo pacman -S avr-gdb simavr 

2. क्यूटी क्रिएटर में एक प्रोजेक्ट बनाएं

Qt Creator चलाएं और C ++ में Qt के बिना एक नया प्रोजेक्ट बनाएं



परियोजना के लिए एक स्थान चुनें और इसे एक नाम दें



एक बिल्ड सिस्टम के रूप में, एक नियमित रूप से qmake लें



हम डिफ़ॉल्ट रूप से काम कर रहे सेट को छोड़ देते हैं, इसे बाद में ठीक करें



संस्करण नियंत्रण के तहत, प्रोजेक्ट को इच्छानुसार जोड़ें



हमें मानक C ++ प्रोजेक्ट मिलता है



परियोजना में केवल दो फाइलें हैं: main.cpp और led-blink.pro। पहले एक को हटा दिया जाता है, दूसरे को वहां लिखी गई हर चीज से साफ कर दिया जाता है, पूरी तरह से खाली प्रोजेक्ट मिलने पर



अब पेन के साथ, हम Arduino के लिए प्रोजेक्ट संरचना बनाते हुए, एक .pro फ़ाइल में टेक्स्ट लिखना शुरू करते हैं

 #     #    Arduino Core ARDUINO_DIR=/usr/share/arduino/hardware/archlinux-arduino/avr/ #    (Arduino Uno, Nano, Mini) ARDUINO_MCU=atmega328p #    ARDUINO_FCPU = 16000000L 

हम परियोजना से Qt से संबंधित सभी चीजों को बाहर करते हैं और परियोजना टेम्पलेट का चयन करते हैं

 #  ,   Qt   ! QT -= gui core CONFIG -= qt #   - ,      ELF TEMPLATE = app 

हमने इकट्ठे बाइनरी और उसके नाम के लिए निर्देशिका निर्धारित की है

 DESTDIR = ../bin TARGET = led-blink 

अगला, शीर्ष लेख खोज निर्देशिकाओं को कनेक्ट करें

 #    INCLUDEPATH += $$ARDUINO_DIR/cores/arduino INCLUDEPATH += $$ARDUINO_DIR/variants/standard INCLUDEPATH += $$ARDUINO_DIR/libraries INCLUDEPATH += /usr/avr/include 

C कंपाइलर और उसकी चाबियों को परिभाषित करें

 QMAKE_CC = /usr/bin/avr-gcc QMAKE_CFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections QMAKE_CFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU QMAKE_CFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR 

और सी ++ संकलक और इसकी चाबियाँ

 QMAKE_CXX = /usr/bin/avr-g++ QMAKE_CXXFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections QMAKE_CXXFLAGS += -fno-exceptions -fno-threadsafe-statics QMAKE_CXXFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU QMAKE_CXXFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR 

लिंकर और उसकी कुंजी सेट करें

 QMAKE_LINK = /usr/bin/avr-gcc QMAKE_LFLAGS = -w -Os -Wl,--gc-sections -mmcu=$$ARDUINO_MCU QMAKE_LIBS = -lm 

हम बोर्ड पर बाद के फर्मवेयर के लिए इंटेल हेक्स में इसे मोड़ने के लिए, ईएलएफ फ़ाइल के पोस्ट-प्रोसेसिंग को कॉन्फ़िगर करते हैं

 QMAKE_POST_LINK += /usr/bin/avr-objcopy -O ihex -j .text -j .data -S ${TARGET} ${TARGET}.hex 

निर्दिष्ट करें कि कौन सी हेडर फ़ाइलें प्रोजेक्ट में शामिल हैं।

 HEADERS += $$files($$ARDUINO_DIR/cores/arduino/*.h) HEADERS += $$files($$ARDUINO_DIR/variants/standard/*.h) 

Arduino Core स्रोत फ़ाइलों को परिभाषित करें

 SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.c) SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.cpp) 

तो, ठीक है, हम वास्तव में स्केचिंग कब शुरू करेंगे? चलिए अब शुरू करते हैं, लेकिन हमने जो काम किया है, महान डॉन्स, स्केच कोड काम करने के लिए आवश्यक न्यूनतम है।

अब प्रोजेक्ट में स्केच स्रोत जोड़ें। ट्री में प्रोजेक्ट पर राइट-क्लिक करें और "नया जोड़ें ..." चुनें C ++ स्रोत फ़ाइल जोड़ें



प्रोजेक्ट के अंदर स्रोतों को व्यवस्थित करने के लिए, अगली विंडो में



"ब्राउज़ करें" पर क्लिक करें और * .cpp फ़ाइलों के लिए src फ़ोल्डर बनाएं



अब फाइल को एक नाम दें



अगली विंडो "समाप्त" पर क्लिक करें। हमें ऐसी तस्वीर मिलती है



IDE इस फाइल को led-blink.pro बिल्ड स्क्रिप्ट में जोड़ देगा

 HEADERS += $$files($$ARDUINO_DIR/cores/arduino/*.h) HEADERS += $$files($$ARDUINO_DIR/variants/standard/*.h) #  Arduino Core SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.c) \ src/led-blink.cpp SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.cpp) 

लेकिन लंबे समय तक स्रोत की सूची नहीं बनाने के लिए, मैं आमतौर पर ऐसा करता हूं

 #  Arduino Core HEADERS += $$files($$ARDUINO_DIR/cores/arduino/*.h) HEADERS += $$files($$ARDUINO_DIR/variants/standard/*.h) #  Arduino Core SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.c) SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.cpp) #   SOURCES += $$files(./src/*.cpp) 

अब हम वही करेंगे जो Arduino IDE कभी प्रदान नहीं करेगा: स्केच में एक हेडर फ़ाइल जोड़ें, ऊपर जैसा कदम



इस फ़ाइल में, आवश्यक प्रोजेक्ट हेडर जोड़ें

 #ifndef LED_BLINK_H #define LED_BLINK_H #include <Arduino.h> #endif // LED_BLINK_H 

हेडर और स्रोतों के लिए पथ कॉन्फ़िगर करें

 #  INCLUDEPATH += ./include HEADERS += $$files(./include/*.h) #   SOURCES += $$files(./src/*.cpp) 

और अब अंत में एक स्केच लिखें

 #include "led-blink.h" //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void setup() { } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void loop() { } 

अब हम प्रोजेक्ट ट्री पर राइट क्लिक करते हैं और "असेंबल" का चयन करते हैं



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



सब कुछ ठीक है, ईएलएफ है, जो नियंत्रक में फर्मवेयर के लिए डिबगिंग और हेक्स के समय उपयोगी है। अब आइए पिन 13 पर एलईडी के साथ एक और ब्लिंकर लिखें

 #include "led-blink.h" #define LED_STAND_PIN 13 unsigned long time = 0; unsigned long DELAY = 500000; bool on = false; //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void setup() { pinMode(LED_STAND_PIN, OUTPUT); } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void loop() { if ( micros() >= time + DELAY ) { time = micros(); on = !on; } uint8_t state = on ? HIGH : LOW; digitalWrite(LED_STAND_PIN, state); } 

हम परियोजना को इकट्ठा करते हैं, बिन / पर जाते हैं। हम आपके USB बोर्ड में चिपक जाते हैं। मेरे मामले में यह ऊनो है, मेरे सिस्टम पर यह प्रोग्रामिंग के लिए नाम / dev / ttyACM0 के साथ एक पोर्ट स्थापित करता है। आदेश निष्पादित करें

 $ avrdude -c arduino -p m328p -P /dev/ttyACM0 -b 115200 -U flash:w:led-blink.hex:i 

यहां

• -पी / देव / ttyACM0 - प्रोग्रामर पोर्ट
  
• -p m328p - नियंत्रक मॉडल
  
• -सी अरडिनो - प्रोग्रामर का प्रकार: यूनो बोर्ड के लिए अंतर्निहित
  
• -b 115200 - पोर्ट स्पीड
  
• -U फ्लैश: w: एलईडी- blink.hex: i - फर्मवेयर के क्षेत्र, ऑपरेशन के प्रकार (लिखने) और फर्मवेयर फ़ाइल को इंगित करें
  

इसी के समान एक निकास

 avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% 0.00s avrdude: Device signature = 0x1e950f (probably m328p) avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed To disable this feature, specify the -D option. avrdude: erasing chip avrdude: reading input file "led-blink.hex" avrdude: writing flash (2838 bytes): Writing | ################################################## | 100% 0.47s avrdude: 2838 bytes of flash written avrdude: verifying flash memory against led-blink.hex: avrdude: load data flash data from input file led-blink.hex: avrdude: input file led-blink.hex contains 2838 bytes avrdude: reading on-chip flash data: Reading | ################################################## | 100% 0.38s avrdude: verifying ... avrdude: 2838 bytes of flash verified avrdude: safemode: Fuses OK (E:00, H:00, L:00) avrdude done. Thank you. 

हमें बताता है कि प्रक्रिया अच्छी तरह से चली गई। एलईडी 2 हर्ट्ज की आवृत्ति पर झपकी लेगा।

सिद्धांत रूप में, आप आईडीई में फर्मवेयर को कॉन्फ़िगर कर सकते हैं। ऐसा करने के लिए, लॉन्च सेटिंग्स को ऐसे बनाएं



और प्रोजेक्ट शुरू करने का चयन करके (Ctrl + R दबाकर) हम फर्मवेयर निष्पादित करेंगे और ठीक उसी तरह लॉन्च करेंगे जैसे कि Arduino IDE करता है।

निष्कर्ष

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

यह उदाहरण बना है, जैसा कि वे कहते हैं, "माथे में।" वास्तव में, Arduino IDE Arduino Core को एक अलग स्थिर Core.a लाइब्रेरी में संकलित करता है और निष्पादन योग्य से जोड़ता है। नतीजतन, मानक वातावरण में एकत्र फर्मवेयर लेख में वर्णित विधि की तुलना में आकार में छोटा है। मुझे अभी भी इन बारीकियों का पता लगाना है। और इस विषय पर निम्नलिखित लेख में उसी समय हम बात करेंगे:

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

सामान्य तौर पर, हम कई मुद्दों को स्पष्ट करने की कोशिश करेंगे जो चल रही प्रक्रियाओं को समझने के लिए उपयोगी हैं, जिसके बिना भविष्य में अरुडिनो से कुछ और अधिक उन्नत करने के लिए स्विच करना मुश्किल होगा।