Blockdit Logo (Mobile)
Chaiyot@J6
•
29 ส.ค. 2022 เวลา 00:32 • วิทยาศาสตร์ & เทคโนโลยี
"3 เคล็ดลับสําหรับการออกแบบซอฟต์แวร์ที่ใช้ข้อมูลเป็นศูนย์กลาง"
3 Tips for Data-Centric Software Design
โดย Jacob Beningo
เผยแพร่บนเว็บไซต์ DesignNews 8 สิงหาคม 2565
แปลและเรียบเรียง : พ.อ. ชัยยศ ศุภมิตรกฤษณา
หากคุณต้องการการออกแบบซอฟต์แวร์ที่ยอดเยี่ยมเพียงทําตามข้อมูล
แนวทางที่ยอดเยี่ยมในการแก้ปัญหาระบบซอฟต์แวร์แบบฝังตัวจํานวนมาก คือการใช้ประโยชน์จากการออกแบบซอฟต์แวร์ที่ใช้ข้อมูลเป็นศูนย์กลาง ข้อมูลเป็นหัวใจสําคัญของทุกระบบที่ฝังตัว ขั้นแรกข้อมูลจะผ่านเซ็นเซอร์แบบสุ่ม อินเทอร์เฟซการสื่อสาร และอุปกรณ์อินพุต/เอาต์พุต
จากนั้นข้อมูลจะถูกแปลง ถูกกรอง และถูกประมวลผลเป็นสินทรัพย์ข้อมูลใหม่ในระบบ ในที่สุดข้อมูลนั้นจะถูกดําเนินการเพื่อสร้างผลลัพธ์ หลักการแรกในการออกแบบซอฟต์แวร์ คือข้อมูลกําหนดการออกแบบ ต่อไปนี้คือเคล็ดลับ 3 ข้อสําหรับการออกแบบซอฟต์แวร์ที่ใช้ข้อมูลเป็นศูนย์กลาง
เคล็ดลับ #1 - ติดตามข้อมูล
ระบบซอฟต์แวร์ทุกระบบที่เป็นแกนหลักมีศูนย์กลางอยู่ที่ข้อมูล การออกแบบสถาปัตยกรรมซอฟต์แวร์ที่มีประสิทธิภาพและประสิทธิผลและการใช้งานจะต้องเป็นไปตามข้อมูลนั้น น่าเสียดายที่มีข้อจำกัดหลายอย่างที่ข้อมูลสามารถทําได้ในระบบซอฟต์แวร์
ขั้นแรก ให้สร้างข้อมูล ตัวอย่างเช่น ในระบบฝังตัวอาจมีเซ็นเซอร์อนาล็อกที่สร้างแรงดันไฟฟ้าที่วัดโดยตัวแปลงอนาล็อกเป็นดิจิตอลภายในของไมโครคอนโทรลเลอร์ อินพุตหน้าจอแบบสัมผัสอาจขัดจังหวะและให้คู่พิกัด x/y ข้อมูลมักถูกผลิตเป็นอินพุตหรือเอาต์พุตของระบบ การออกแบบซอฟต์แวร์ที่ใช้ข้อมูลเป็นศูนย์กลางจะระบุอินพุตและเอาต์พุตอย่างรอบคอบเนื่องจากนั่นคือที่ที่เราจะพบข้อมูลที่ผลิตได้
ที่่มา https://www.circuitbasics.com
ถัดไป ข้อมูลจะถูกประมวลผล การแปลงแบบอนาล็อกเป็นดิจิทัลจะสร้างการนับ ADC (Analog to Digital Converter) ในรูปแบบดั้งเดิม ข้อมูลเซ็นเซอร์อาจถูกประมวลผลเพื่อสร้างค่าตัวเลขทศนิยมที่แสดงถึงหน่วยทางวิทยาศาสตร์ของเซ็นเซอร์ โดยปกติแล้วจะเป็นเรื่องปกติมากขึ้นที่จะปล่อยให้ค่าเซ็นเซอร์อยู่ในรูปแบบดั้งเดิม แต่มีการกรองข้อมูล ตัวอย่างเช่น ข้อมูลอาจมีตัวกรอง low-pass หรือ hi-pass เพื่อขจัดค่ารบกวน นักออกแบบจําเป็นต้องติดตามข้อมูลเพื่อทําความเข้าใจวิธีการประมวลผล
ที่มา : https://passionofphysics.blogspot.com
ในที่สุด ข้อมูลจะถูกจัดเก็บ ข้อมูลอาจถูกจัดเก็บไว้ในหน่วยความจําเป็นค่าเดียว ข้อมูลอาจถูกจัดเก็บไว้ในอาร์เรย์ของค่าที่จะถูกประมวลผลร่วมกัน ข้อมูลอาจถูกบันทึกลงในหน่วยความจําถาวรเพื่อใช้ในภายหลัง อีกครั้ง การทําความเข้าใจวิธีการจัดเก็บข้อมูลเป็นสิ่งสําคัญต่อกระบวนการออกแบบ
ไม่ว่าเซ็นเซอร์หรืออินเทอร์เฟซการสื่อสารจะสร้างข้อมูลหรือไม่ก็ไม่สําคัญ ไม่สําคัญว่าจะเก็บไว้ในการ์ด SD หรือชิปหน่วยความจํา จากมุมมองของการออกแบบ จะใส่ใจว่าข้อมูลเข้าและออกจากระบบ (ผลิต) ได้รับการประมวลผลและจัดเก็บในที่สุด ในการสร้างการออกแบบซอฟต์แวร์ที่มีประสิทธิภาพ ต้องติดตามข้อมูล จัดทําเอกสารข้อมูลในแต่ละสถานะและวิธีการแปลงข้อมูล หากทําเช่นนี้จะพบว่าการออกแบบนั้นเข้าที่เข้าทางอย่างเป็นธรรมชาติ
เคล็ดลับ #2 - จัดทําเอกสารว่าข้อมูลมีการเปลี่ยนแปลงอย่างไร
ในทุกระบบ ข้อมูลดิบจะถูกถ่ายโอนและแปลงเป็นข้อมูลที่มีค่าแล้วส่งออกไป การติดตามวิธีที่ข้อมูลไหลผ่านระบบสามารถขับเคลื่อนสถาปัตยกรรมซอฟต์แวร์ได้ดี อย่างไรก็ตาม การจัดทําเอกสารว่าข้อมูลเปลี่ยนแปลงและวิวัฒน์ไปทั่วทั้งระบบอย่างไร สามารถช่วยให้ผู้ออกแบบกําหนดขอบเขตขนาดของซอฟต์แวร์ได้
ตัวอย่างเช่น ถ้ามีข้อมูลเซ็นเซอร์อนาล็อกบางตัวถูกแปลงเป็นตัวเลขและแสดงในข้อมูล telemetry ก็จะไม่จําเป็นต้องใช้พลังงานการประมวลผลมาก การประมวลผลข้อมูลนั้นง่าย อย่างไรก็ตาม หากข้อมูลเซ็นเซอร์ถูกดึงเก็บไว้ในบัฟเฟอร์แบบวงกลม (circular buffer) ถูกกรอง แล้วถูกแปลงเป็นหน่วยวิทยาศาสตร์
ข้อมูลนั้นจำเป็นต้องได้รับการสนใจมากขึ้น การจัดทําเอกสารบันทึกการไหลของข้อมูลและเหตุการณ์การประมวลผลสามารถช่วยให้นักออกแบบสามารถควบคุมและเข้าใจการออกแบบได้ แม้ว่าจะไม่เคยมีการระบุไมโครคอนโทรลเลอร์หรือฮาร์ดแวร์อย่างเป็นทางการก็ตาม
รูป circular buffer แบบใช้หลักการ FIFO (First In First Out) ที่มา : https://th.wikipedia.org
ในช่วงเริ่มต้นของการออกแบบให้ทําตามขั้นตอนง่าย ๆ เหล่านี้:
1. ระบุข้อมูลที่ผลิตในระบบ
2. ตรวจสอบว่าสินทรัพย์ข้อมูลแต่ละรายการเคลื่อนที่ผ่านซอฟต์แวร์อย่างไร
3. จัดทําเอกสารว่าข้อมูลมีการเปลี่ยนแปลงอย่างไรตลอดอายุการใช้งาน
4. บันทึกสื่อเก็บข้อมูลและวิธีการเข้าถึงข้อมูล
การสร้างแผนภาพการไหลของข้อมูลอย่างง่ายสามารถกําหนดสถาปัตยกรรมซอฟต์แวร์และตรวจสอบให้แน่ใจว่าสามารถปรับขนาดได้และไม่ซับซ้อนเกินไป
เคล็ดลับ #3 - ดําเนินการกับข้อมูลเมื่อเริ่มกิจกรรมหรืองาน
ดําเนินการกับข้อมูลเมื่อเริ่มกิจกรรมหรืองาน
งานทั่วไปในระบบฝังตัวจะประมวลผลข้อมูลในขั้นตอนต่อไปนี้:
1. ดึงข้อมูลใหม่
2. กรอง/ประมวลผลข้อมูล
3. ผลลัพธ์ที่ได้
กระบวนการนี้ดูเหมือนมีเหตุผล น่าเสียดายที่ไม่จําเป็นต้องพอดีกับการออกแบบระบบฝังตัวแบบเรียลไทม์ เป้าหมายหลักของระบบแบบเรียลไทม์คือการกําหนดและลดความผันผวน (jitter) กระบวนการข้างต้นสามารถเพิ่มศักยภาพให้กับความผันผวน แทนที่จะลดให้น้อยที่สุด ลองพิจารณาตัวอย่าง
งานควบคุมมอเตอร์จะอ่านการวัดกระแสและแรงดันไฟฟ้าแบบอนาล็อกล่าสุด จากนั้นเรียกใช้ผ่านตัวควบคุม PID ตัวควบคุม PID จะให้เอาต์พุตสําหรับสถานะมอเตอร์ใหม่ การผ่านตัวควบคุม PID แต่ละครั้งอาจไม่ทํางานในจํานวนรอบสัญญาณนาฬิกาเท่ากันขึ้นอยู่กับการออกแบบคอนโทรลเลอร์ อาจมีค่าเวลาที่หลากหลาย มีความเป็นไปได้ที่การขัดจังหวะจะเกิดขึ้นในช่วงกลางของการคํานวณ PID ผลที่ได้คือเอาต์พุตมอเตอร์ไม่เคยได้รับการอัปเดตพร้อมกัน มันเคลื่อนที่ไปรอบ ๆ เล็กน้อยและผันผวน ซึ่งอาจส่งผลต่อการตอบสนองของมอเตอร์
วิธีที่แน่นอนกว่าในการดําเนินการกับเอาต์พุตข้อมูลใหม่สําหรับมอเตอร์ที่ลดความผันผวนคือการเปลี่ยนขั้นตอนเป็น:
1. ผลลัพธ์ก่อนหน้า
2. ดึงข้อมูลใหม่
3. กรอง/ประมวลผลข้อมูล
ในกรณีนี้ เอาต์พุตใหม่จะถูกส่งไปยังมอเตอร์เสมอเมื่อเริ่มลูปก่อนที่จะประมวลผลเพิ่มเติมหรือกิจกรรมอื่น ๆ ที่ไม่เป็นตัวกําหนดเกิดขึ้น เราอาจกําลังดําเนินการกับข้อมูลที่อาจจะเก่ากว่าเล็กน้อย แต่เราสามารถอธิบายสิ่งนั้นและลดความผันผวนลงอย่างมาก
ข้อสรุปสําหรับการออกแบบซอฟต์แวร์ที่ดีขึ้น
ทุกอย่างล้วนมาลงที่ข้อมูล เมื่อแจกแจงสิ่งที่กําลังทําเพื่อออกแบบและใช้ซอฟต์แวร์แบบฝังตัว ซอฟต์แวร์ฝังตัวไม่มีอะไรมากไปกว่าการประมวลผลการจัดเก็บและการส่งออกข้อมูลในลักษณะที่กําหนดขึ้น
การปฏิบัติตามแนวทางการออกแบบซอฟต์แวร์ที่ใช้ข้อมูลเป็นศูนย์กลางจะส่งผลให้เกิดสถาปัตยกรรมที่เน้นสิ่งที่สําคัญที่สุดของข้อมูล แล้วจะพบว่าการออกแบบมีประสิทธิภาพ มีประสิทธิผล โดยไม่ต้องสนใจรูปแบบและวิธีการออกแบบใหม่ๆ ถ้าคุณต้องการการออกแบบซอฟต์แวร์ที่ยอดเยี่ยม เพียงทําตามข้อมูล
โฆษณา