एम्बेडेड में Go: एक भाषा में फर्मवेयर लिखना जो स्टैक को नहीं उड़ाती

Go और हार्डवेयर: यह कोई मज़ाक क्यों नहीं है?

जब आप "एम्बेडेड डेवलपमेंट" वाक्यांश सुनते हैं, तो आमतौर पर आप C, असेंबली और एक एलईडी के माध्यम से दर्दनाक डिबगिंग की कल्पना करते हैं। लेकिन दुनिया स्थिर नहीं है। आज, Go (या Golang) आत्मविश्वास से माइक्रोकंट्रोलर की दुनिया के दरवाजे पर दस्तक दे रहा है। और यह सिर्फ ऐसे ही नहीं, बल्कि गोरूटीन, गार्बेज कलेक्टर और बिल्ट-इन इंटरफेस के साथ दस्तक दे रहा है।

इस लेख में, हम समझेंगे कि Go पर एम्बेडेड डेवलपमेंट कैसा दिखता है, एक काल्पनिक माइक्रोकंट्रोलर के लिए वास्तविक कोड लिखेंगे, और समझेंगे कि क्या यह प्रयास के लायक है। स्पॉइलर: हाँ, यदि आप मेमोरी लीक से थक गए हैं और पढ़ने योग्य कोड पसंद करते हैं।

Go क्यों, C क्यों नहीं? तीन स्तंभ

क्लासिक एम्बेडेड C है। लेकिन Go में तीन killer-विशेषताएं हैं जो इंजीनियरों को अपनी आदतों पर पुनर्विचार करने के लिए मजबूर करती हैं:

\n
• मेमोरी सुरक्षा: कोई जंगली पॉइंटर नहीं जो अंतरिक्ष में उड़ सकते हैं। Go कंपाइलर C कंपाइलर से अधिक सख्त है।
\n
• गोरूटीन: हल्के थ्रेड जो माइक्रोकंट्रोलर की इवेंट-ओरिएंटेड आर्किटेक्चर पर पूरी तरह से फिट बैठते हैं।
\n
• क्रॉस-प्लेटफ़ॉर्म: आप Mac पर कोड लिखते हैं और ARM Cortex-M के लिए कंपाइल करते हैं। बिना किसी झंझट के।
\n

बेशक, एक बारीकियां है: नेटिव Go (gc) छोटे MCU के लिए कंपाइल नहीं कर सकता। लेकिन एक प्रोजेक्ट है TinyGo — एक कंपाइलर जो Go को किलोबाइट मेमोरी वाले हार्डवेयर के लिए अनुकूलित करता है। हम इसी पर ध्यान केंद्रित करेंगे।

पर्यावरण सेटअप: TinyGo और आपका बोर्ड

कोड लिखने से पहले, आइए अपना वर्कस्टेशन तैयार करें। Go पर एम्बेडेड डेवलपमेंट के लिए आपको आवश्यकता होगी:

\n
1. TinyGo इंस्टॉल करें: brew install tinygo (या आधिकारिक साइट से डाउनलोड करें)।
\n
2. अपने बोर्ड के लिए टूलचेन इंस्टॉल करें (उदाहरण के लिए, STM32 के लिए ARM GCC)।
\n
3. USB के माध्यम से बोर्ड कनेक्ट करें।
\n

जांचें कि सब कुछ काम कर रहा है:

tinygo version\ntinygo: 0.31.0 (linux/amd64)\n

अब आप किसी भी समर्थित बोर्ड के लिए कोड कंपाइल कर सकते हैं: tinygo build -target=arduino-nano -o firmware.hex main.go।

पहला blink: Go पर एलईडी

शैली का क्लासिक। पिन से कनेक्ट करें, पिन को टॉगल करें। इस प्रकार Go पर माइक्रोकंट्रोलर प्रोग्रामिंग दिखती है:

package main\n\nimport (\n    "machine"\n    "time"\n)\n\nfunc main() {\n    // बिल्ट-इन एलईडी आमतौर पर पिन 13 (या LED_BUILTIN) पर होती है\n    led := machine.LED\n    led.Configure(machine.PinConfig{Mode: machine.PinOutput})\n\n    for {\n        led.High()\n        time.Sleep(500 * time.Millisecond)\n        led.Low()\n        time.Sleep(500 * time.Millisecond)\n    }\n}\n

कंपाइल करें और बोर्ड पर फ्लैश करें:

tinygo flash -target=arduino-nano -port=/dev/ttyUSB0 main.go\n

वोइला! एलईडी झपक रही है। ध्यान दें: हम machine पैकेज का उपयोग कर रहे हैं — यह TinyGo का हार्डवेयर एब्स्ट्रैक्शन है। यह अपने पीछे रजिस्टरों के साथ काम को छुपाता है, लेकिन एक स्वच्छ Go इंटरफ़ेस प्रदान करता है।

GPIO और इंटरप्ट के साथ काम करना

वास्तविक परियोजनाओं में, केवल झपकाना पर्याप्त नहीं है। आपको बटन, सेंसर पढ़ने और घटनाओं पर प्रतिक्रिया देने की आवश्यकता है। एम्बेडेड सिस्टम के लिए Go में, इंटरप्ट को चैनल और गोरूटीन के माध्यम से कार्यान्वित किया जाता है। उदाहरण: एक बटन प्रेस हैंडलर संलग्न करें।

package main\n\nimport (\n    "machine"\n    "fmt"\n)\n\nfunc main() {\n    button := machine.D2\n    button.Configure(machine.PinConfig{Mode: machine.PinInputPullup})\n\n    // प्रेस की प्रतीक्षा करें (pin == LOW, क्योंकि पुल-अप से जुड़ा है)\n    for {\n        if !button.Get() {\n            fmt.Println("बटन दबाया गया!")\n        }\n    }\n}\n

लेकिन यह एक busy loop है। अधिक कुशल चाहते हैं? चैनल के माध्यम से इंटरप्ट का उपयोग करें:

func main() {\n    button := machine.D2\n    button.Configure(machine.PinConfig{Mode: machine.PinInputPullup})\n\n    // घटनाओं के लिए चैनल\n    ch := make(chan bool, 1)\n    button.SetInterrupt(machine.PinFalling,