การเขียนโปรแกรมไมโครคอนโทรลเลอร์กับการเขียนโปรแกรมเชิงวัตถุ

ฉันได้เขียนโปรแกรมพื้นฐานเชิงวัตถุด้วย C ++ (การสร้าง B-Tree, Hashing Algorithms, Double Linked Lists) และฉันได้ทำโครงการเล็ก ๆ ใน C (เช่นการทำเครื่องคิดเลขวิทยาศาสตร์เป็นต้น)

ความแตกต่างของการเขียนโปรแกรมฮาร์ดแวร์ (โดยเฉพาะสำหรับไมโครคอนโทรลเลอร์) จากการเขียนโปรแกรมซอฟต์แวร์ / เชิงวัตถุในแง่ของความคิดและ "การคิด" ที่โปรแกรมเมอร์ต้องมีคืออะไร?

ปกติแล้วฉันจะถือว่ายากกว่าคนอื่น ๆ

ด้วยพื้นหลังของฉัน (ตามที่อธิบายไว้ข้างต้น) ฉันจะต้องมีการเตรียมตัวมากมายสำหรับการเขียนโปรแกรมฮาร์ดแวร์หรือฉันสามารถดำดิ่งเข้าได้โดยไม่ต้องเตรียมตัวมากเกินไป?

คุณจะต้องละทิ้งกระบวนทัศน์เชิงวัตถุเมื่อจัดการกับไมโครคอนโทรลเลอร์ส่วนใหญ่

โดยทั่วไปแล้ว Microcontrollers จะลงทะเบียนและ จำกัด RAM ด้วยอัตราสัญญาณนาฬิกาที่ช้าและไม่มีเส้นทางรหัส pipelining / ขนาน คุณสามารถลืมเกี่ยวกับ Java บน PIC ตัวอย่างเช่น

คุณต้องมีความคิดภาษาแอสเซมบลีและเขียนขั้นตอน

คุณต้องทำให้โค้ดของคุณค่อนข้างแบนและหลีกเลี่ยงการเรียกซ้ำเนื่องจากข้อ จำกัด ของ RAM มักจะทำให้เกิดปัญหาสแต็ก

คุณต้องเรียนรู้วิธีเขียนรูทีนการบริการขัดจังหวะซึ่งมีประสิทธิภาพ (โดยปกติจะเป็นภาษาแอสเซมบลี)

คุณอาจต้อง refactor บางส่วนของรหัสด้วยตนเองในภาษาแอสเซมบลีเพื่อใช้งานฟังก์ชันที่คอมไพเลอร์ไม่สนับสนุน (หรือสนับสนุนไม่ดี)

คุณต้องเขียนโค้ดทางคณิตศาสตร์ที่คำนึงถึงขนาดคำและการขาดความสามารถของ FPU ของไมโครคอนโทรลเลอร์ส่วนใหญ่ (เช่นทำการคูณ 32 บิตบน 8 บิต micro = evil)

มันเป็นโลกที่แตกต่าง สำหรับฉันแล้วการมีวิทยาการคอมพิวเตอร์หรือภูมิหลังการเขียนโปรแกรมมืออาชีพอาจเป็นอุปสรรคได้มากเท่ากับการไม่มีความรู้เลยเมื่อต้องรับมือกับไมโครคอนโทรลเลอร์

คุณต้องคิดหลายสิ่ง:

• คุณจะใช้ C เป็นภาษา
• คุณยังสามารถสร้างความรู้สึกของการวางแนววัตถุโดยใช้ตัวชี้ฟังก์ชั่นเพื่อให้คุณสามารถแทนที่ฟังก์ชั่นอื่น ๆ ได้ฉันใช้วิธีนี้ในโครงการในอดีตและปัจจุบันและทำงานได้ดีมาก ดังนั้น OO จึงอยู่ที่นั่นเพียงบางส่วน แต่ไม่ใช่ในภาษา C ++

มีข้อ จำกัด อื่น ๆ ที่จะเข้ามาเล่นเช่นความเร็วที่ จำกัด และหน่วยความจำ ดังนั้นตามแนวทางทั่วไปฉันหลีกเลี่ยง:

• ใช้ heap หากมีวิธีการแก้ปัญหาโดยไม่ต้อง Malloc ฉันทำอย่างนั้น ตัวอย่างเช่นฉัน preallocate บัฟเฟอร์และใช้มัน
• ฉันตั้งใจลดขนาดสแต็กในการตั้งค่าคอมไพเลอร์เพื่อเผชิญหน้ากับปัญหาขนาดสแต็กตั้งแต่ต้น
• ฉันคิดว่ารหัสทุกบรรทัดเดียวจะถูกขัดจังหวะโดยเหตุการณ์ดังนั้นฉันจึงหลีกเลี่ยงโค้ดที่ไม่ใช่ reentrant
• ฉันคิดว่าแม้การขัดจังหวะจะซ้อนกันดังนั้นฉันจึงเขียนรหัสนั้น
• ฉันหลีกเลี่ยงการใช้ระบบปฏิบัติการเว้นแต่จำเป็น 70% ของโครงการฝังตัวไม่จำเป็นต้องใช้ระบบปฏิบัติการ หากฉันต้องใช้ระบบปฏิบัติการฉันจะใช้เฉพาะสิ่งที่มีซอร์สโค้ดให้เท่านั้น (Freertos ฯลฯ )
• ถ้าฉันใช้ระบบปฏิบัติการฉันเกือบจะเป็นนามธรรมอยู่เสมอเพื่อให้ฉันสามารถเปลี่ยนระบบปฏิบัติการในเวลาไม่กี่ชั่วโมง
• สำหรับไดรเวอร์และอื่น ๆ ฉันจะใช้ไลบรารีที่จัดทำโดยผู้จัดจำหน่ายเท่านั้นฉันไม่เคยทำซ้ำบิตเลยเว้นเสียแต่ว่าฉันไม่มีทางเลือกอื่น ทำให้โค้ดสามารถอ่านได้และปรับปรุงการดีบัก
• ฉันดูลูปและสิ่งอื่น ๆ โดยเฉพาะใน ISR เพื่อให้แน่ใจว่าเร็วพอ
• ฉันใช้ GPIOs สองสามอันในการวัดสิ่งต่างๆการสลับบริบทเวลาทำงานของ ISR เป็นต้น

รายการไปที่ฉันอาจต่ำกว่าค่าเฉลี่ยในแง่ของการเขียนโปรแกรมซอฟต์แวร์ผมมั่นใจว่ามีแนวทางปฏิบัติที่ดีกว่า

ฉันทำทั้งสองอย่างดังนั้นนี่คือมุมมองของฉัน

ฉันคิดว่าทักษะที่สำคัญที่สุดในการฝังตัวคือความสามารถในการดีบักของคุณ ความคิดที่ต้องการนั้นแตกต่างกันมากซึ่งอาจผิดพลาดได้และคุณต้องเปิดกว้างในการพิจารณาวิธีต่าง ๆ ทั้งหมดที่คุณพยายามทำผิดไป

นี่คือปัญหาที่ใหญ่ที่สุดเดียวสำหรับนักพัฒนาที่ฝังตัวใหม่ คนที่ใช้พีซีมักจะเข้มงวดกว่าเดิมเพราะพวกเขาคุ้นเคยกับมันมาก พวกเขามักจะเสียเวลาค้นหาเครื่องมือเพื่อทำสิ่งต่าง ๆ แทน (คำใบ้: มีไม่มาก) มีการตบหัวเข้าไปในกำแพงหลายครั้งหลายครั้งไม่รู้ว่าจะทำอะไร หากคุณรู้สึกว่าตัวเองติดอยู่ให้ถอยออกมาและคิดว่าคุณสามารถระบุได้ว่าอะไรที่ผิดพลาด อย่างเป็นระบบผ่านการ จำกัด รายการปัญหาที่อาจเกิดขึ้นของคุณให้แคบลงจนกระทั่งคุณเข้าใจได้ เป็นไปตามโดยตรงจากกระบวนการนี้ที่คุณควร จำกัด ขอบเขตของปัญหาโดยไม่เปลี่ยนแปลงมากเกินไปในครั้งเดียว

คนฝังตัวที่มีประสบการณ์มักจะทำการดีบั๊กเพื่อให้ได้รับ ... คนส่วนใหญ่ที่ไม่สามารถทำได้ดีไม่นาน (หรือทำงานใน บริษัท ขนาดใหญ่ที่ยอมรับ "เฟิร์มแวร์ยาก" เป็นคำตอบว่าทำไมคุณสมบัติบางอย่าง สายปี)

คุณกำลังทำงานกับโค้ดที่ทำงานบนระบบภายนอกกับระบบการพัฒนาของคุณโดยมีองศาการมองเห็นที่แตกต่างกันในเป้าหมายของคุณจากแพลตฟอร์มหนึ่งไปอีกแพลตฟอร์มหนึ่ง หากอยู่ภายใต้การควบคุมของคุณให้กดเพื่อขอความช่วยเหลือในการพัฒนาเพื่อช่วยเพิ่มการมองเห็นนี้ในระบบเป้าหมายของคุณ ใช้พอร์ตอนุกรม debug, บิตการดีบักเอาต์พุต, แสงกะพริบที่มีชื่อเสียง, ฯลฯ อย่างน้อยที่สุดเรียนรู้วิธีการใช้ออสซิลโลสโคปและใช้ pin I / O กับขอบเขต 'เพื่อดูว่าฟังก์ชันบางอย่างเข้า / ออก, ไฟ ISRs ฯลฯ ฉันได้เฝ้าดูผู้คนต่อสู้กันนานเกินความจำเป็นอย่างแท้จริงเพียงเพราะพวกเขาไม่เคยใส่ใจที่จะตั้งค่า / เรียนรู้วิธีใช้ลิงก์ดีบักเกอร์ JTAG ที่เหมาะสม

มันสำคัญมากที่คุณต้องตระหนักว่าทรัพยากรใดที่คุณมีเมื่อเทียบกับพีซี อ่านเอกสารข้อมูลอย่างละเอียด พิจารณาทรัพยากร 'ต้นทุน' ของสิ่งที่คุณพยายามทำ เรียนรู้เทคนิคการดีบักเชิงทรัพยากรเช่นการเติมพื้นที่สแต็กด้วยค่าเวทย์มนตร์เพื่อติดตามการใช้สแต็ก

ในขณะที่ต้องใช้ทักษะการดีบักในระดับหนึ่งสำหรับพีซีและซอฟต์แวร์ฝังตัวมันมีความสำคัญยิ่งกว่ากับการฝังตัว

ฉันสันนิษฐานว่าประสบการณ์ C ++ ของคุณนั้นขึ้นกับพีซี

ข้อผิดพลาดที่มักจะทำโดยโปรแกรมเมอร์ที่ย้ายมาจากเครื่องคอมพิวเตอร์ไปยังไมโครคอนโทรลเลอร์คือการที่พวกเขาไม่ได้ตระหนักถึงวิธีการทรัพยากรที่ จำกัดสามารถ ในพีซีจะไม่มีใครหยุดคุณเมื่อคุณสร้างตารางที่มีรายการ 100,000 รายการหรือเขียนโปรแกรมที่รวบรวมรหัสเครื่องได้ 1MB
มีเป็นไมโครคอนโทรลเลอร์ที่มีความมั่งคั่งของทรัพยากรหน่วยความจำโดยเฉพาะอย่างยิ่งในระดับไฮเอนด์ แต่ก็ยังคงเป็นหนทางไกลจากสิ่งที่คุณจะใช้ในการ สำหรับโครงการงานอดิเรกที่คุณอาจจะสามารถไปได้สูงสุด แต่ในโครงการมืออาชีพที่คุณจะมักจะถูกบังคับให้ทำงานร่วมกับอุปกรณ์ขนาดเล็กเพราะมันถูกกว่า
ในโครงการหนึ่งฉันทำงานกับ TI MSP430F1101. หน่วยความจำของโปรแกรม 1KB, แฟลชการกำหนดค่า 128 ไบต์, RAM 128 ไบต์ โปรแกรมไม่พอดีใน 1K ดังนั้นฉันต้องเขียนฟังก์ชัน 23 ไบต์ใน Flash configuration กับตัวควบคุมขนาดเล็กเหล่านี้คุณคำนวณโดยไบต์ ในโอกาสอื่นหน่วยความจำของโปรแกรมมีขนาดเล็กเกินไป 4 ไบต์ เจ้านายจะไม่ให้ฉันใช้คอนโทรลเลอร์ที่มีหน่วยความจำมากขึ้น แต่ฉันต้องปรับรหัสเครื่องที่ได้รับการปรับให้เหมาะสมที่สุดแล้ว (มันถูกเขียนขึ้นในแอสเซมเบลอร์) เพื่อให้พอดีกับ 4 ไบต์พิเศษคุณจะได้ภาพ

ทั้งนี้ขึ้นอยู่กับแพลตฟอร์มที่คุณกำลังทำงานคุณจะต้องจัดการกับมากในระดับต่ำ I / O สภาพแวดล้อมการพัฒนาบางอย่างมีฟังก์ชั่นในการเขียนไปที่ LCD แต่สำหรับคนอื่น ๆ ที่คุณเป็นเจ้าของและต้องอ่านแผ่นข้อมูลของ LCD ตั้งแต่ต้นจนจบเพื่อที่จะรู้วิธีควบคุมมัน
คุณอาจต้องควบคุมรีเลย์นั่นง่ายกว่าจอ LCD แต่คุณจะต้องไปที่ระดับการลงทะเบียนของไมโครคอนโทรลเลอร์ แผ่นข้อมูลหรือคู่มือผู้ใช้อีกครั้ง คุณจะต้องรู้จักโครงสร้างของไมโครคอนโทรลเลอร์ซึ่งคุณจะพบในบล็อกไดอะแกรมอีกครั้งในแผ่นข้อมูล ในสมัยของไมโครโปรเซสเซอร์เราพูดถึงโมเดลการเขียนโปรแกรมซึ่งโดยทั่วไปเป็นกลุ่มผู้ลงทะเบียนของโปรเซสเซอร์ ไมโครคอนโทรลเลอร์ในปัจจุบันมีความซับซ้อนมากจนรายละเอียดของการลงทะเบียนทั้งหมดสามารถเป็นส่วนที่ดีที่สุดของแผ่นข้อมูล 100 หน้า IIRC เป็นเพียงคำอธิบายของโมดูลนาฬิกาสำหรับ MSP430 มีความยาว 25 หน้า

$\mu$

ไมโครคอนโทรลเลอร์มักจะมีโปรแกรมใน C C ++ ค่อนข้างเป็นทรัพยากรหิวดังนั้นจึงมักจะออก (การใช้งาน C ++ ส่วนใหญ่สำหรับไมโครคอนโทรลเลอร์ให้เซตย่อย C ++ ที่ จำกัด ) อย่างที่ฉันพูดขึ้นอยู่กับแพลตฟอร์มที่คุณอาจมีห้องสมุดที่มีฟังก์ชั่นมากมายซึ่งสามารถช่วยคุณประหยัดเวลาในการพัฒนา มันคุ้มค่าที่จะสละเวลาศึกษามันอาจช่วยให้คุณประหยัดเวลาได้มากในภายหลังถ้าคุณรู้ว่ามีอะไรให้บ้าง

"การเขียนโปรแกรมฮาร์ดแวร์" อาจมีความหมายหลายอย่าง การเขียนโปรแกรมชิปขนาดเล็กมาก (คิดว่า 10F200, 512 คำแนะนำ, RAM ไม่กี่ไบต์) อาจเหมือนกับการออกแบบวงจรอิเล็กทรอนิกส์ ในอีกด้านหนึ่งการเขียนโปรแกรมไมโครคอนโทรลเลอร์ Cortex ขนาดใหญ่ (1 Mb FLASH, 64 kB RAM) สามารถเป็นจำนวนมากเช่นการเขียนโปรแกรม PC / GUI โดยใช้ชุดเครื่องมือ GUI ขนาดใหญ่ IMHO โปรแกรมเมอร์ฝังตัว / เรียลไทม์ที่ดีต้องการทักษะทั้งจากซอฟต์แวร์เช่นด้านการออกแบบและจากด้านการออกแบบวงจร สำหรับ uC C ++ ที่ใหญ่กว่านั้นเป็นตัวเลือกภาษาที่ดีสำหรับ C ที่มีขนาดเล็กมากอาจเป็นตัวเลือกเดียว ความรู้ของ Assemby นั้นมีประโยชน์ แต่ฉันไม่แนะนำให้ทำโครงการที่จริงจังทั้งหมดในการชุมนุม

ฉันทำงานฝังตัวอย่างจริงจังกับผู้คนจากทั้งสองฝ่าย (SWI และ EE) โดยทั่วไปฉันชอบคน SWI โดยที่พวกเขามีประสบการณ์เกี่ยวกับการเขียนโปรแกรมแบบมัลติเธรด

คำถามของคุณดูเหมือนว่าคุณต้องการดำน้ำในการเขียนโปรแกรมแบบฝังตัว โดยทั้งหมดทำเช่นนั้น สำหรับด้านระดับต่ำ (การต่อพ่วงอุปกรณ์ต่อพ่วงในชิปของคุณและฮาร์ดแวร์รอบ ๆ ) คุณจะต้องเรียนรู้ทักษะใหม่ ๆ แต่ก็เป็นงานจำนวนมากโดยไม่ต้องมีแนวคิดใหม่มากมาย สำหรับเลเยอร์ที่สูงขึ้นของโครงการของคุณคุณสามารถวาด knwoledge ที่มีอยู่ของคุณ

สำหรับทุกวิธีไลบรารี arduino ที่คุณเรียกว่ามีรหัส C / C ++ ที่ทำให้เป็นไปได้มันเป็นแพคเกจที่ดีสำหรับคุณที่จะใช้เป็น API ดูซอร์สโค้ดของ arduino ภายใต้ไดเรคทอรีฮาร์ดแวร์ / arduino / * และคุณจะเห็น C / C ++ เขียนทั้งหมดสำหรับคุณซึ่งโต้ตอบโดยตรงกับรีจิสเตอร์ของ AVR microcontroller หากวัตถุประสงค์ของคุณคือการเรียนรู้วิธีการเขียนสิ่งต่าง ๆ เช่นนี้ (สำหรับฮาร์ดแวร์โดยตรง) มีหลายสิ่งที่จะครอบคลุม หากวัตถุประสงค์ของคุณคือการทำงานบางอย่างให้ใช้ห้องสมุดของพวกเขาก็อาจจะไม่ได้พูดอะไรมากนักเนื่องจากการทำงานหนักของคุณและห้องสมุดและสภาพแวดล้อมในการพัฒนานั้นใช้งานง่ายมาก

กฎบางอย่างของหัวแม่มือแม้ว่าเมื่อทำงานกับอุปกรณ์ที่ จำกัด ทรัพยากรที่สามารถนำไปใช้กับสภาพแวดล้อมของ Arduino หรืออื่น ๆ :

ระวังจำนวนหน่วยความจำที่คุณใช้ ทั้งขนาดรหัส (ซึ่งไปที่หน่วยความจำแฟลช) และการใช้ RAM แบบคงที่ (ค่าคงที่ในรหัสของคุณที่จะมีอยู่เสมอใน RAM) ฉันจะยืนยันว่าการใช้ RAM แบบคงที่นั้นสำคัญกว่าสำหรับการเริ่มต้นเนื่องจากง่ายต่อการดูมากกว่า ไม่ใช่เรื่องแปลกที่คุณจะมี 1,000 ไบต์เท่านั้นที่จะทำงานกับสแต็กกองและค่าคงที่ของคุณ จงฉลาดในการใช้จ่ายของคุณดังนั้นหลีกเลี่ยงสิ่งต่าง ๆ เช่นอาร์เรย์จำนวนเต็มยาว (4 ไบต์แต่ละตัว) เมื่อไบต์หรือถ่านที่ไม่ได้ลงชื่อ (1 ไบต์แต่ละตัว) จะพอเพียง คำตอบอื่นที่นี่ครอบคลุมประเด็นสำคัญอื่น ๆ ได้เป็นอย่างดีดังนั้นฉันจะหยุดที่นี่ส่วนใหญ่ฉันต้องการที่จะได้รับตรงข้ามว่ามีมากมายที่จะครอบคลุมหากคุณไม่ได้ใช้ห้องสมุด arduino และเขียนห้องสมุด C ของคุณเอง

เกี่ยวกับการเขียนโปรแกรมไมโครคอนโทรลเลอร์กับ OOP พวกมันไม่ใช่สิ่งที่ตรงกันข้าม มันเป็นความจริงที่ไลบรารีผู้ขายทั้งหมดอยู่ใน C ธรรมดา แต่ทุกแพลตฟอร์มรองรับ C ++ OOP เช่นกัน นักพัฒนาสามารถสร้างและสร้างไลบรารีระดับสูงของ C ++ และเฟิร์มแวร์อุปกรณ์ที่อยู่ด้านบน ตัวอย่างที่ดีคือห้องสมุด Arduino, เป็นทางการและผู้ใช้สร้างขึ้น - คลาส C ++ ส่วนใหญ่ อาจไม่ใช่ข้อดีของ OOP ทั้งหมดที่สามารถนำมาใช้ประโยชน์ได้อย่างเต็มที่ในสภาพแวดล้อมแบบฝังตัว

เกี่ยวกับความคิดและการคิดตามที่ระบุไว้ในคำตอบอื่น ๆ ไมโครคอนโทรลเลอร์เป็นแพลตฟอร์มที่ จำกัด ทรัพยากร (โดยเฉพาะใน RAM ความเร็วน้อยกว่า) - สิ่งต่าง ๆ เช่นการจัดสรรหน่วยความจำแบบไดนามิกข้อยกเว้น C ++ มักจะถูกตัดออก ด้วยการเลือกฮาร์ดแวร์ที่เหมาะสมจึงเป็นเรื่องง่ายที่จะนำมาใช้กับข้อ จำกัด เหล่านี้และใช้เทคนิคอื่น ๆ (ยังใช้กันอย่างแพร่หลายในแพลตฟอร์มอื่น ๆ )

ในมุมมองของฉันความท้าทายที่ยากขึ้นอาจเป็นอีกมิติหนึ่งที่เพิ่มเติมในการเขียนโปรแกรมแบบฝัง - เวลา นี่เป็นเพราะโดยปกติแล้วซอฟต์แวร์ฝังตัวจะจัดการกับเหตุการณ์แบบเรียลไทม์มากโปรโตคอลที่กำหนดเวลาอย่างเคร่งครัดในการขับเคลื่อนฮาร์ดแวร์ต่อพ่วงและงานทั่วไปเอง (นี่เป็นสิ่งที่คล้ายคลึงกันในแพลตฟอร์ม "ระดับสูง" อื่น ๆ

เตรียมพร้อมที่จะอ่านเอกสารข้อมูลจำนวนมากเมื่อต้องรับมือกับฮาร์ดแวร์ใหม่ - ฉันคิดว่ามันอาจเกี่ยวข้องกับส่วนของคำถาม "mindset" :) แน่นอนว่า EE และฮาร์ดแวร์จำเป็นต้องมีความรู้บางอย่าง

นอกจากนี้ฉันต้องการที่จะทราบว่าวันนี้การพัฒนาซอฟต์แวร์ฝังตัวไม่จำเป็นต้องมีภาษาแอสเซมบลี ในความเป็นจริง Java (BTW เป็น OOP ตามค่าเริ่มต้น) อยู่ที่นี่แล้วและกำลังเพิ่มขึ้น (อย่างน้อยสำหรับอุปกรณ์ฝังตัวบางคลาสเช่นอุปกรณ์ IoT มันอาจมีอนาคตที่สดใสมาก)