Fixed according to feedback

2026-01-10 17:12:32 +07:00
parent f72f0be591
commit 19fb847b7d
24 changed files with 1531 additions and 1266 deletions
@@ -22,7 +22,7 @@

 #i ในโลกปัจจุบัน อินเทอร์เน็ตนั้นก็เป็นสิ่งที่สำคัญมากเช่นกัน และสถานที่ส่วนใหญ่มักจะมีอินเทอร์เน็ต
 จึงก่อให้เกิดการที่มีอุปกรณ์อินเทอร์เน็ตรอบตัวเพิ่มขึ้นทุกวัน และได้มีสิ่งที่เรียกว่า Internet of Things
-(IoT) เกิดขึ้น ซึ่งคืออุปกรณ์ที่ถูกปรับปรุงให้ใช้งานได้ดีขึ้นด้วยเทคโนโลยีไร้สายต่าง ๆ เช่น Wi-Fi,
+(IoT) เกิดขึ้น ซึ่งคืออุปกรณ์ที่ถูกปรับปรุงให้ใช้งานได้ดีขึ้นด้วยเทคโนโลยีไร้สายต่าง ๆ เช่น#jb Wi-Fi,
 Bluetooth, Zigbee, และ Thread

 #i โครงงานนี้จึงมีเป้าหมายที่จะแก้ไขปัญหาที่กล่าวไปข้างต้น พร้อมศึกษาและเรียนรู้เกี่ยวกับเทคโนโลยีไร้สาย
@@ -50,7 +50,7 @@ Wi-Fi และ NFC เพื่อสร้างอุปกรณ์ยืน

 #i เครื่องยืนยันตัวตนด้วย NFC คืออุปกรณ์ความปลอดภัยที่มีหน้าที่ในการยืนยันตัวตนบุคคลที่เข้าออกพื้นที่
 โดยใช้เทคโนโลยี NFC
-เป็นระบบยืนยันตัวตนบุคคลและใช้เซนเซอร์ตรวจจับความเคลื่อนใหวในการตรวจสอบหากมีบุคคลเข้าไปโดยไม่ได้รับอนุญาต
+เป็นระบบยืนยันตัวตนบุคคลและใช้เซนเซอร์ตรวจจับความเคลื่อนไหวในการตรวจสอบหากมีบุคคลเข้าไปโดยไม่ได้รับอนุญาต

 #show: page-theme

@@ -28,86 +28,268 @@ Boehm garbage collector ตามลำดับ

 === การพัฒนาช่วงแรก

-==== ภาษา B
+#h(9.75em) ที่มาของภาษา C มีความเชื่อมโยงอย่างใกล้ชิดกับการพัฒนาระบบปฏิบัติการ#jb Unix
+ซึ่งเดิมทีเขียนด้วยภาษาแอสเซมบลีบน PDP-7 โดย Dennis Ritchie และ Ken Thompson
+โดยนำแนวคิดหลายอย่างจากเพื่อนร่วมงานมาใช้ ในที่สุดพวกเขาก็ตัดสินใจย้ายระบบปฏิบัติการไปยัง PDP-11
+เวอร์ชัน Unix ดั้งเดิมบน PDP-11 ก็ได้รับการพัฒนาด้วยภาษาแอสเซมบลีเช่นกัน

-==== ภาษา B ใหม่และ C รุ่นแรก
+=== ภาษา B

-==== โครงสร้างและการเขียน Unix kernel ใหม่
+#h(13.5em) ทอมป์สันต้องการภาษาโปรแกรมสำหรับการพัฒนายูทิลิตี้สำหรับแพลตฟอร์มใหม่
+เขาพยายามเขียนคอมไพเลอร์ Fortran ก่อน
+แต่ในไม่ช้าเขาก็ล้มเลิกความคิดนั้นและสร้างเวอร์ชันย่อของภาษาโปรแกรมระบบ ที่พัฒนาขึ้นใหม่ชื่อ BCPL แทน
+คำอธิบายอย่างเป็นทางการของ BCPL ยังไม่พร้อมใช้งานในขณะนั้นและทอมป์สันได้แก้ไขไวยากรณ์ให้
+"กระชับ" น้อยลงและคล้ายกับ ALGOL ที่เรียบง่ายกว่า ที่เรียกว่า SMALGOL เขาเรียกผลลัพธ์ นี้ว่า B
+โดยอธิบายว่าเป็น#jb "ความหมายของ BCPL ที่มีไวยากรณ์ SMALGOL จำนวนมาก" เช่นเดียวกับ BCPL, B
+มีคอมไพเลอร์ บูตสแตรปเพื่ออำนวยความสะดวกในการพอร์ตไปยังเครื่องใหม่ในที่สุด
+มีการเขียนยูทิลิตี้เพียงไม่กี่ตัวใน B เพราะมันช้าเกินไปและไม่สามารถใช้ประโยชน์จากคุณสมบัติของ PDP-11
+เช่นการเข้าถึงที่อยู่ไบต์ได้
+
+=== ภาษา B ใหม่และ C รุ่นแรก
+
+#h(13.5em) ในปี พ.ศ. 2514 ริชชีเริ่มปรับปรุง B เพื่อใช้คุณสมบัติของ PDP-11 ที่ทรงพลังยิ่งขึ้น
+การเพิ่มเติมที่สำคัญคือประเภทข้อมูลอักขระ เขาเรียกสิ่งนี้ว่า New B (NB) ทอมป์สันเริ่มใช้ NB เพื่อเขียน
+เคอร์เนล Unix และข้อกำหนดของเขากำหนดทิศทางการพัฒนาภาษา
+
+จนถึงปี 1972 มีการเพิ่มประเภทข้อมูลที่หลากหลายมากขึ้นให้กับภาษา NB ภาษา NB มีอาร์เรย์ของ int และ
+char และได้มีการเพิ่มพอยเตอร์ ความสามารถในการสร้างพอยเตอร์ไปยังประเภทอื่นๆ
+อาร์เรย์ของทุกประเภท และประเภทที่จะส่งคืนจากฟังก์ชัน
+อาร์เรย์ภายในนิพจน์ได้รับการปฏิบัติเสมือนเป็นพอยเตอร์ มีการเขียนคอมไพเลอร์ใหม่ และเปลี่ยนชื่อภาษาเป็น
+C
+
+คอมไพเลอร์ C และยูทิลิตี้บางส่วนที่สร้างขึ้นด้วยคอมไพเลอร์นี้ถูกรวมอยู่ใน Unix เวอร์ชัน 2
+ซึ่งเรียกอีกอย่างว่า Research Unix
+
+=== โครงสร้างและการเขียน Unix kernel ใหม่
+
+#h(13.5em) ใน Unix เวอร์ชัน 4 ซึ่งวางจำหน่ายในเดือนพฤศจิกายน พ.ศ. 2516 เคอร์เนล ของ Unix
+ได้รับการเขียนใหม่อย่างกว้างขวางด้วยภาษา C ในเวลานั้น ภาษา C
+ได้รับคุณสมบัติที่ทรงพลังบางอย่างเช่นประเภท struct
+
+ตัวประมวลผลล่วงหน้าได้รับการแนะนำประมาณปี 1973 ตามคำแนะนำของ Alan Snyder
+และยังเป็นการยอมรับถึงประโยชน์ของกลไกการรวมไฟล์ที่มีอยู่ใน BCPL และPL/I
+เวอร์ชันดั้งเดิมให้เฉพาะไฟล์ที่รวมไว้และการแทนที่สตริงแบบง่ายเท่านั้น `#include` รวม `#define`
+ถึงมาโครที่ไม่มีพารามิเตอร์ หลังจากนั้นไม่นาน ก็มีการขยายเพิ่มเติม โดยส่วนใหญ่โดย Mike Lesk
+และต่อมาโดย John Reiser เพื่อรวมมาโครที่มีอาร์กิวเมนต์และการคอมไพล์แบบมีเงื่อนไข
+
+Unix เป็นหนึ่งในเคอร์เนลระบบปฏิบัติการแรกๆ
+ที่เขียนด้วยภาษาอื่นที่ไม่ใช่ภาษาแอสเซมบลีตัวอย่างก่อนหน้านี้ได้แก่ ระบบ Multics (ซึ่งเขียนด้วยภาษา
+PL/I ) และ Master Control Program (MCP) สำหรับ Burroughs B5000 (ซึ่งเขียนด้วยภาษา
+ALGOL ) ในปี 1961 ในช่วงปี 1977 Ritchie และ Stephen C. Johnson
+ได้ทำการเปลี่ยนแปลงเพิ่มเติมให้กับภาษาเพื่ออำนวยความสะดวกในการพกพาระบบปฏิบัติการUnix
+คอมไพเลอร์ Portable C ของ Johnson เป็นพื้นฐานสำหรับการใช้งาน C บนแพลตฟอร์มใหม่ๆ
+หลายแพลตฟอร์ม

 === K&R C

+#h(9.75em) ในปี พ.ศ. 2521 Brian KernighanและDennis Ritchie ได้ตีพิมพ์หนังสือ The C
+Programming Language ฉบับพิมพ์ครั้งแรกหนังสือเล่มนี้รู้จักกันในชื่อย่อ K&R
+ตามชื่อย่อของผู้เขียนและทำหน้าที่เป็นข้อกำหนดที่ไม่เป็นทางการ ของภาษาเป็นเวลาหลายปีเวอร์ชันของภาษา
+C ที่อธิบายไว้ในหนังสือเล่มนี้มักเรียกกันว่า "K&R C" เนื่องจาก หนังสือเล่มนี้ได้รับการเผยแพร่ในปี พ.ศ.
+2521 จึงเรียกอีกอย่างว่า C78 หนังสือฉบับพิมพ์ครั้งที่สองครอบคลุมมาตรฐาน ANSI C ในภายหลัง
+ซึ่งจะกล่าวถึงต่อไป
+
+K&R ได้เพิ่มฟีเจอร์ด้านภาษาหลายอย่าง:
+
+ ไลบรารีอินพุต/เอาต์พุตมาตรฐาน
+ long int ประเภทข้อมูล
+ unsigned int ประเภทข้อมูล
+ ตัวดำเนินการกำหนดค่าแบบผสมในรูปแบบ =_op_ (เช่น `=-`) ถูกเปลี่ยนเป็นรูปแบบ _op_= (นั่นคือ
+  `-=`)#jb เพื่อขจัดความกำกวมทางความหมายที่เกิดจากโครงสร้างเช่น `i=-10` ซึ่งถูกตีความว่า
+  `i =- 10` (ลด `i` ลง 10) แทนที่จะเป็นความหมายที่ตั้งใจไว้ (ให้ `i` เป็น -10)
+
+#h(9.75em) แม้หลังจากมีการเผยแพร่มาตรฐาน ANSI ปี 1989 แล้วก็ตาม เป็นเวลาหลายปีที่ K&R C
+ยังคงถูกพิจารณาว่าเป็น "ตัวหารร่วมที่ต่ำที่สุด" ที่โปรแกรมเมอร์ภาษา C
+ยึดถือเมื่อต้องการความสามารถในการพกพาได้สูงสุด
+เนื่องจากคอมไพเลอร์รุ่นเก่าจำนวนมากยังคงถูกใช้งานอยู่และเนื่องจากโค้ด K&R C
+ที่เขียนอย่างระมัดระวังก็สามารถเป็นไปตามมาตรฐาน C ได้เช่นกัน
+
+แม้ว่า C เวอร์ชันต่อมาจะกำหนดให้ฟังก์ชันต้องมีการประกาศประเภทอย่างชัดเจนแต่ C เวอร์ชัน K&R
+กำหนดให้ฟังก์ชันที่ส่งคืนค่าประเภทอื่นที่ไม่ใช่ประเภท ที่กำหนดไว้เท่านั้น int ที่จะต้องประกาศก่อนใช้งาน
+ฟังก์ชันที่ใช้โดยไม่มีการประกาศล่วงหน้าจะถือว่าส่งคืนค่าประเภทที่กำหนด int ไว้
+
 === ANSI C และ ISO C

+#h(9.75em) ในช่วงปลายทศวรรษ 1970 และ 1980 ภาษา C เวอร์ชันต่างๆ ถูกนำไปใช้งานใน
+คอมพิวเตอร์เมนเฟรมมินิคอมพิวเตอร์และไมโครคอมพิวเตอร์หลากหลายรุ่นรวมถึง IBM PC ด้วย
+เนื่องจากความนิยมของคอมพิวเตอร์ประเภทนี้เพิ่มขึ้นอย่างมาก
+
+#h(9.75em) ในปี 1983 สถาบันมาตรฐานแห่งชาติอเมริกัน (ANSI) ได้จัดตั้งคณะกรรมการ#jb X3J11
+เพื่อกำหนดมาตรฐานของภาษา C X3J11 ใช้มาตรฐาน C ที่อิงตามการใช้งานบนระบบ Unix เป็นพื้นฐาน
+อย่างไรก็ตามส่วนที่ไม่สามารถพกพาได้ของไลบรารี C บน Unix ได้ถูกส่งต่อไปยังกลุ่มทำงาน IEEE 1003
+เพื่อใช้เป็นพื้นฐานสำหรับ มาตรฐาน POSIX ในปี 1988 ในปี 1989 มาตรฐาน C ได้รับการรับรองเป็น
+ANSI X3.159-1989 "ภาษาโปรแกรม C" เวอร์ชันนี้ของภาษามักถูกเรียกว่า ANSI C, Standard C
+หรือบางครั้งเรียกว่า C89
+
+#h(9.75em) ในปี 1990 มาตรฐาน ANSI C (พร้อมการเปลี่ยนแปลงรูปแบบ)
+ได้รับการรับรองโดยองค์การมาตรฐานสากล (ISO) ในชื่อ ISO/IEC 9899:1990 ซึ่งบางครั้งเรียกว่า C90
+ดังนั้น คำว่า "C89" และ "C90" จึงหมายถึงภาษาโปรแกรมเดียวกัน
+
+#h(9.75em) เช่นเดียวกับองค์กรมาตรฐานแห่งชาติอื่นๆ ANSI ไม่ได้พัฒนามาตรฐาน C ด้วยตนเองอีกต่อไป
+แต่จะอ้างอิงถึงมาตรฐาน C สากล ซึ่งดูแลโดยคณะทำงาน ISO/IEC JTC1/SC22 /WG14
+การนำมาตรฐานสากลฉบับปรับปรุงมาใช้ในระดับประเทศมักเกิดขึ้นภายในหนึ่งปีหลังจากที่ ISO
+เผยแพร่มาตรฐานดังกล่าว
+
+#h(9.75em) หนึ่งในเป้าหมายของกระบวนการกำหนดมาตรฐานภาษา C คือการสร้างซูเปอร์เซ็ตของ K&R C
+โดยรวมเอาคุณสมบัติที่ไม่เป็นทางการหลายอย่างที่ถูกนำมาใช้ในภายหลัง
+คณะกรรมการมาตรฐานยังได้เพิ่มคุณสมบัติเพิ่มเติมอีกหลายอย่างเช่นต้นแบบฟังก์ชัน (ยืมมาจาก C++),
+voidพอยเตอร์, การรองรับชุดอักขระและภาษาท้องถิ่นระหว่างประเทศ และการปรับปรุงพรีโปรเซสเซอร์
+แม้ว่าไวยากรณ์สำหรับการประกาศพารามิเตอร์จะได้รับการปรับปรุงให้รวมรูปแบบที่ใช้ใน C++
+แต่ก็ยังคงอนุญาตให้ใช้อินเทอร์เฟซ K&R เพื่อความเข้ากันได้กับซอร์สโค้ดที่มีอยู่
+
+#h(9.75em) C89 ได้รับการสนับสนุนจากคอมไพเลอร์ C ในปัจจุบัน และโค้ด C สมัยใหม่ส่วนใหญ่ก็ใช้ C89
+เป็นพื้นฐานโปรแกรมใดๆ ที่เขียนด้วยภาษา C มาตรฐานเท่านั้น และไม่มีข้อสมมติฐานใดๆ ที่ขึ้นอยู่กับฮาร์ดแวร์
+จะทำงานได้อย่างถูกต้องบนแพลตฟอร์มใดๆ ที่มีการใช้งาน C ที่สอดคล้องกับมาตรฐาน
+ภายในขีดจำกัดของทรัพยากร หากไม่ระมัดระวัง
+โปรแกรมอาจคอมไพล์ได้เฉพาะบนแพลตฟอร์มใดแพลตฟอร์มหนึ่ง หรือด้วยคอมไพเลอร์เฉพาะเท่านั้น
+ตัวอย่างเช่น เนื่องจากการใช้ไลบรารีที่ไม่เป็นมาตรฐาน เช่น ไลบรารี GUI
+หรือการพึ่งพาคุณลักษณะเฉพาะของคอมไพเลอร์หรือแพลตฟอร์ม เช่น ขนาดที่แน่นอนของชนิดข้อมูลและลำดับไบต์
+
+#h(9.75em)
+ในกรณีที่โค้ดต้องสามารถคอมไพล์ได้ทั้งโดยคอมไพเลอร์ที่สอดคล้องกับมาตรฐานหรือคอมไพเลอร์ที่ใช้ C แบบ
+K&R นั้น `__STDC__` สามารถใช้มาโครเพื่อแบ่งโค้ดออกเป็นส่วนมาตรฐานและส่วน K&R
+เพื่อป้องกันการใช้คุณสมบัติที่มีเฉพาะใน C มาตรฐานบนคอมไพเลอร์ที่ใช้ C แบบ K&R
+
+#h(9.75em) หลังจากกระบวนการกำหนดมาตรฐาน ANSI/ISO ข้อกำหนดภาษา C
+ยังคงค่อนข้างคงที่เป็นเวลาหลายปี ในปี 1995 มีการเผยแพร่การแก้ไขมาตรฐานฉบับที่ 1 ของมาตรฐาน C ปี
+1990 (ISO/IEC 9899/AMD1:1995 ซึ่งเรียกกันอย่างไม่เป็นทางการว่า C95)
+เพื่อแก้ไขรายละเอียดบางประการและเพิ่มการสนับสนุนชุดอักขระสากลที่ครอบคลุมมากขึ้น
+
 === C99

+#h(9.75em) มาตรฐาน C ได้รับการแก้ไขเพิ่มเติมในช่วงปลายทศวรรษ 1990 ส่งผลให้มีการตีพิมพ์
+ISO/IEC 9899:1999 ในปี 1999 ซึ่งโดยทั่วไปเรียกว่า "C99" ต่อมาได้มีการแก้ไขเพิ่มเติมอีกสามครั้งโดย
+Technical Corrigenda
+
+#h(9.75em) C99 ได้นำเสนอคุณสมบัติใหม่หลายประการรวมถึงฟังก์ชันอินไลน์ชนิดข้อมูลใหม่หลายชนิด(รวมถึง
+long long intชนิด ข้อมูล complex ที่ใช้แทนจำนวนเชิงซ้อน)
+อาร์เรย์ที่มีความยาวแปรผันได้และสมาชิกอาร์เรย์ที่ยืดหยุ่นการสนับสนุนที่ดีขึ้นสำหรับเลขทศลอย IEEE 754
+การสนับสนุนมาโครแบบแปรผัน (มาโครที่มีจำนวนอาร์กิวเมนต์ แปรผันได้)
+และการสนับสนุนความคิดเห็นแบบบรรทัดเดียวที่ขึ้นต้นด้วย `@` `//` เช่นเดียวกับใน BCPL หรือ C++
+คุณสมบัติเหล่านี้หลายอย่างได้ถูกนำไปใช้เป็นส่วนขยายในคอมไพเลอร์ C หลายตัวแล้ว
+
+#h(9.75em) โดยส่วนใหญ่แล้ว C99 สามารถใช้งานร่วมกับ C90 ได้ แต่มีความเข้มงวดมากกว่าในบางด้าน
+โดยเฉพาะอย่างยิ่ง การประกาศที่ไม่มีตัวระบุประเภทจะไม่ถือว่ามีintการกำหนดโดยปริยายอีกต่อไป
+มีการกำหนดมาโครมาตรฐาน `__STDC_VERSION__` พร้อมค่า `199901L` เพื่อระบุว่ามีการสนับสนุน C99
+คอม ไพเลอร์ C อื่นๆ เช่น GCC, Solaris Studio และคอมไพเลอร์ C อื่นๆ
+ในปัจจุบันรองรับคุณสมบัติใหม่หลายอย่างหรือทั้งหมดของ C99 อย่างไรก็ตาม คอมไพเลอร์ C ใน Microsoft
+Visual C++ ใช้มาตรฐาน C89 และส่วนต่างๆ ของ C99 ที่จำเป็นสำหรับการใช้งานร่วมกับ C++11
+
+#h(9.75em) นอกจากนี้ มาตรฐาน C99 ยังกำหนดให้รองรับตัวระบุที่ใช้ Unicode
+ในรูปแบบของอักขระพิเศษ (เช่น `\u0040` หรือ `\U0001f431`) และแนะนำให้รองรับชื่อ Unicode
+ดิบด้วย
+
 === C11

+#h(9.75em) งานปรับปรุงมาตรฐาน C ฉบับใหม่เริ่มขึ้นในปี 2550 โดยเรียกกันอย่างไม่เป็นทางการว่า
+"C1X" จนกระทั่งมีการประกาศใช้มาตรฐาน ISO/IEC 9899:2011 อย่างเป็นทางการในวันที่ 8 ธันวาคม
+2554 คณะกรรมการมาตรฐาน C ได้กำหนดแนวทางเพื่อจำกัดการนำคุณสมบัติใหม่ๆ
+ที่ยังไม่ได้รับการทดสอบโดยระบบที่มีอยู่มาใช้
+
+#h(9.75em) มาตรฐาน C11 เพิ่มคุณสมบัติใหม่มากมายให้กับภาษา C และไลบรารี
+รวมถึงมาโครแบบเจเนริกชนิดโครงสร้างนิรนามการสนับสนุน Unicode ที่ดีขึ้น
+การดำเนินการอะตอมิกการทำงานแบบมัลติเธรดและฟังก์ชันตรวจสอบขอบเขต
+นอกจากนี้ยังทำให้บางส่วนของไลบรารี C99 ที่มีอยู่เป็นตัวเลือก และปรับปรุงความเข้ากันได้กับ C++
+มาโครมาตรฐาน `__STDC_VERSION__` ถูกกำหนดไว้เพื่อ `201112L` ระบุว่ามีการสนับสนุน C11 แล้ว
+
 === C17

+#h(9.75em) C17 เป็นชื่อเรียกอย่างไม่เป็นทางการของ ISO/IEC 9899:2018
+ซึ่งเป็นมาตรฐานสำหรับภาษาโปรแกรม C ที่เผยแพร่ในเดือนมิถุนายน 2018
+มาตรฐานนี้ไม่ได้เพิ่มคุณสมบัติใหม่ใดๆ ให้กับภาษา แต่เป็นการแก้ไขทางเทคนิคและการชี้แจงข้อบกพร่องใน
+C11 เท่านั้น มาโครมาตรฐาน `__STDC_VERSION__` ถูกกำหนดขึ้นเพื่อ `201710L` ระบุว่ามีการรองรับ
+C17 แล้ว
+
 === C23

+#h(9.75em) C23 เป็นชื่อเรียกอย่างไม่เป็นทางการของการแก้ไขมาตรฐานภาษา C หลักในปัจจุบัน
+ซึ่งในระหว่างการพัฒนาส่วนใหญ่เรียกว่า "C2X" โดยสร้างขึ้นจากเวอร์ชันก่อนหน้า และแนะนำคุณสมบัติใหม่
+เช่น คำหลักใหม่ ความหมายเพิ่มเติมสำหรับเพื่อ `auto`
+ให้มีการอนุมานประเภทเมื่อประกาศตัวแปรประเภทใหม่รวมถึง `nullptr_t` และ `_BitInt` (N)
+และการขยายไลบรารีมาตรฐาน
+
+C23 ได้รับการเผยแพร่ในเดือนตุลาคม 2024 ในชื่อ ISO/IEC 9899:2024 มาโครมาตรฐาน
+`__STDC_VERSION__` ถูกกำหนดไว้ `202311L` เพื่อระบุว่ามีการสนับสนุน C23
+
 === C2Y

+#h(9.75em) C2Y เป็นชื่อเรียกอย่างไม่เป็นทางการของการแก้ไขมาตรฐานภาษา C ครั้งใหญ่ถัดไป หลังจาก
+C23 (C2X) ซึ่งคาดว่าจะออกในช่วงปลายทศวรรษ 2020 ดังนั้นจึงมีเลข '2' ใน "C2Y" ร่างฉบับแรกของ
+C2Y ได้รับการเผยแพร่ในเดือนกุมภาพันธ์ 2024 ในชื่อ N3220 โดยกลุ่มทำงาน ISO/IEC JTC1/SC22
+/WG14
+
 === Embedded C

+#h(9.75em) ในอดีตการเขียนโปรแกรม C
+สำหรับระบบฝังตัวจำเป็นต้องใช้ส่วนขยายที่ไม่เป็นมาตรฐานของภาษา C เพื่อรองรับคุณสมบัติพิเศษ
+เช่นการคำนวณเลขทศนิยมคงที่
+ธนาคารหน่วยความจำหลายชุดที่แตกต่างกันและการดำเนินการอินพุต/เอาต์พุตพื้นฐาน
+
+#h(9.75em) ในปี 2551 คณะกรรมการมาตรฐาน C ได้เผยแพร่รายงานทางเทคนิคที่ขยายภาษา C
+เพื่อแก้ไขปัญหาเหล่านี้โดยการจัดหามาตรฐานทั่วไปสำหรับการใช้งานทั้งหมดให้ปฏิบัติตาม
+ซึ่งรวมถึงคุณสมบัติหลายอย่างที่ไม่มีในภาษา C ปกติ เช่น การคำนวณเลขทศนิยมคงที่
+พื้นที่แอดเดรสแบบมีชื่อและการกำหนดแอดเดรสฮาร์ดแวร์ I/O พื้นฐาน
+
 == ตัวแปร (Variables)

 #i ตัวแปรในภาษา C เบื้องต้นแล้วประกอบไปด้วยประเภทของข้อมูลและชื่อตัวแปร
 โดยที่ชื่อตัวแปรนั้นสามารถเป็นรายการที่ถูกแบ่งด้วยเครื่องหมายจุลภาคได้ด้วยเช่นกัน ตัวอย่างคือ

+#afigure(
  ```c
  int data;
  float a, b, c;
-```
+  ```,
+  kind: image,
+  caption: [ตัวอย่างการประกาศตัวแปรในภาษา C],
+)

 == ประเภทข้อมูล (Data Types)

-#i ข้อมูลที่เกี่ยวข้องกับตัวเลขมักมีประเภท *unsigned* และ *signed* โดยความแตกต่างหากอธิบายสั้น
+#h(6em) ข้อมูลที่เกี่ยวข้องกับตัวเลขมักมีประเภท unsigned และ signed โดยความแตกต่างหากอธิบายสั้น
 ๆ คือ

- *Signed (มีเครื่องหมาย):* ตัวเลขที่สามารถติดลบได้ ระยะข้อมูลตัวอย่างคือ -128 ถึง 127
- *Unsigned (ไม่มีเครื่องหมาย):* ตัวเลขที่ไม่สามารถติดลบได้ ระยะข้อมูลตัวอย่างคือ 0 ถึง 255
+#[
+  #set enum(indent: 6em)
+  + Signed (มีเครื่องหมาย): ตัวเลขที่สามารถติดลบได้ ระยะข้อมูลตัวอย่างคือ -128 ถึง 127
+  + Unsigned (ไม่มีเครื่องหมาย): ตัวเลขที่ไม่สามารถติดลบได้ ระยะข้อมูลตัวอย่างคือ 0 ถึง 255
+]

-#i จะสังเกตได้ว่า ข้อมูลประเภท unsigned นั้นสามารถเก็บตัวเลขบวกได้จำนวนมากกว่า คือสูงสุดที่ 255
-แต่หากนำค่าสัมบูรณ์ (absolute value) ของระยะข้อมูลแบบ signed มาบวกกัน เช่น\
+#h(6em) จะสังเกตได้ว่า ข้อมูลประเภท unsigned นั้นสามารถเก็บตัวเลขบวกได้จำนวนมากกว่า คือสูงสุดที่
+255 แต่หากนำค่าสัมบูรณ์ (absolute value) ของระยะข้อมูลแบบ signed มาบวกกัน เช่น\
 #math.equation($|-128| + |127|$, alt: "ค่าสัมบูรณ์ของ -128 บวกค่าสัมบูรณ์ของ 127")
 จะพบว่าได้ค่า 255 หมายความว่า จริง ๆ แล้วข้อมูลประเภท signed สามารถเก็บข้อมูลได้ 255
 ตัวเลขเช่นกัน เพียงแต่ว่าครึ่งหนึ่งของตัวเลขที่สามารถเก็บได้เป็นตัวเลขติดลบ

-*หมายเหตุ:* เลขคณิตจำนวนเต็มมีนิยามแตกต่างกันสำหรับชนิดจำนวนเต็มแบบ signed และ unsigned
-โปรดดูตัวดำเนินการเลขคณิต โดยเฉพาะอย่างยิ่งการโอเวอร์โฟลว์จำนวนเต็ม
+#h(6em) ดังนั้นโปรดจำไว้ว่า เลขคณิตจำนวนเต็มมีนิยามแตกต่างกันสำหรับชนิดจำนวนเต็มแบบ signed และ
+unsigned โปรดดูตัวดำเนินการเลขคณิต โดยเฉพาะอย่างยิ่งการโอเวอร์โฟลว์จำนวนเต็ม

 === ประเภทบูลีน (Boolean)

-*หมายเหตุ:* ประเภทบูลีนนั้นถูกนำเสนอครั้งแรกในมาตรฐาน C99
+ประเภทบูลีนนั้นถูกนำเสนอครั้งแรกในมาตรฐาน C99 โดยการกล่าวถึงประเภทข้อมูลบูลีนนั้น ในประวัติของภาษา C แล้วมีสองแบบ

-โดยการกล่าวถึงประเภทข้อมูลบูลีนนั้น ในประวัติของภาษา C แล้วมีสองแบบ
-
- `_Bool` (และมีมาโคร `bool`): จนถึงมาตรฐาน C23
- `bool` (ที่ไม่ใช่แค่มาโคร): มีตั้งแต่มาตรฐาน C23
+ `_Bool` (และมีมาโคร `bool`): จนถึงมาตรฐาน C23
+ `bool` (ที่ไม่ใช่แค่มาโคร): มีตั้งแต่มาตรฐาน C23

 === ประเภทจำนวนเต็ม (Integer)

- `short int` (หรืออีกชื่อหนึ่งคือ `short` และสามารถใช้คีย์เวิร์ด `signed` ได้)
- `unsigned short int` (หรือ `unsigned short`)
- `int` (หรือ `signed int`) \
+ `short int` (หรืออีกชื่อหนึ่งคือ `short` และสามารถใช้คีย์เวิร์ด `signed` ได้)
+ `unsigned short int` (หรือ `unsigned short`)
+ `int` (หรือ `signed int`) \
  คือประเภทข้อมูลตัวเลขที่ปกติที่สุด และจะถูกการันตีว่าจะมีขนาดขั้นต่ำ 16 บิตเสมอ
  โดยระบบทั่วไปส่วนใหญ่ในปัจจุบันจะเป็น 32 บิต
- `unsigned int` (หรือเพียงแค่ `unsigned`): คือประเภท `int` ในแบบ `unsigned`, มี
+ `unsigned int` (หรือเพียงแค่ `unsigned`): คือประเภท `int` ในแบบ `unsigned`, มี
  modulo arithmetic, และเหมาะสมสำหรับการเปลี่ยนแปลงบิต
- `long int` (หรือ `long`)
- `unsigned long int` (หรือ `unsigned long`)
-
-#pagebreak()
-
- มีเพิ่มตั้งแต่ C99:
-  - `long long int` (หรือ `long long`)
-  - `unsigned long long int` (หรือ `unsigned long long`)
- มีเพิ่มตั้งแต่ C23:
-  - `_BitInt(n)` (หรือ `signed _BitInt(n)`): ประเภทข้อมูล signed แบบมีขนาดชัดเจน โดย
+ `long int` (หรือ `long`)
+ `unsigned long int` (หรือ `unsigned long`)
+ มีเพิ่มตั้งแต่ C99:
+  + `long long int` (หรือ `long long`)
+  + `unsigned long long int` (หรือ `unsigned long long`)
+ มีเพิ่มตั้งแต่ C23:
+  + `_BitInt(n)` (หรือ `signed _BitInt(n)`): ประเภทข้อมูล signed แบบมีขนาดชัดเจน โดย
    n แทนด้วยจำนวนบิต (รวมถึงบิตเครื่องหมาย และ n จะต้องไม่มากกว่า `BITINT_MAXWIDTH`
    จากไฟล์ `<limits.h>`)
-  - `unsigned _BitInt(n)`: เหมือนข้างต้น เพียงแค่เป็นประเภท unsigned
+  + `unsigned _BitInt(n)`: เหมือนข้างต้น เพียงแค่เป็นประเภท unsigned
    (และไม่มีบิตเครื่องหมาย)

 และเหมือนประเภทข้อมูลอื่น ๆ คุณสามารถเรียงคีย์เวิร์ดแบบใดก็ได้ เช่น `unsigned long long int`
@@ -221,74 +403,54 @@ float a, b, c;
  caption: [ขนาดของข้อมูลเป็นบิต (ต่อ)],
 )

-และนอกจากค่าบิตขั้นต่ำ มาตรฐาน C นั้นการันตีว่า:
-
-#i ```c 1``` == ```c sizeof(char)``` #sym.lt.eq ```c sizeof(short)``` #sym.lt.eq
-```c sizeof(int)``` #sym.lt.eq ```c sizeof(long)``` #sym.lt.eq
-```c sizeof(long long)```
-
-*หมายเหตุ:* เงื่อนไขนี้อนุญาตกรณีสุดขีดที่ทุกประเภทมีขนาด 64 บิตและ `sizeof` คืนค่า `1`
-สำหรับทุกประเภท

 ==== รูปแบบข้อมูล (data model)

-#i รูปแบบข้อมูล หรือ data model คือรูปแบบการเก็บข้อมูลของโปรแกรมซึ่งเป็นสิ่งที่กำหนดขนาดของตัวแปร
+#h(13.5em) รูปแบบข้อมูล หรือ data model
+คือรูปแบบการเก็บข้อมูลของโปรแกรมซึ่งเป็นสิ่งที่กำหนดขนาดของตัวแปร
 โดยรูปแบบข้อมูลนั้นจะถูกกำหนดโดยแพลตฟอร์มเป้าหมาย
 ซึ่งมีหน่วยประมวลผลและระบบปฏิบัติการเป็นปัจจัยหลัก โดยตามตารางในหัวข้อก่อนหน้า หลัก ๆ
 แล้วมีรูปแบบข้อมูลอยู่ 4 รูปแบบ คือ LP32, ILP32, LLP64, และ LP64 ซึ่งหากต้องการหาความหาย L
 หมายถึง Long, P หมายถึง Pointer, และ I หมายถึง Integer (จำนวนเต็ม) แล้วตามด้วยเลขบิต
-ดังนั้น สรุปแล้วจึงจะมีความหมายดังนี้
-
-ระบบ 32 บิต:
- LP32 หรือ 2/4/4: `long` และ Pointer มีขนาด 32 บิต
-  - Win16 API
- ILP32 หรือ 4/4/4: `int`, `long`, และ Pointer มีขนาด 32 บิต
-  - Win32 API
-  - ระบบ Unix และเสมือน Unix (Linux, Mac OS X)
-
-ระบบ 64 บิต:
- LLP64 หรือ 4/4/8: `long long` และ Pointer มีขนาด 64 บิต
-  - Win64 API
- LP64 หรือ 4/8/8: `long` และ Pointer มีขนาด 64 บิต
-  - ระบบ Unix และเสมือน Unix (Linux, Mac OS X)
-
-#i รูปแบบอื่น ๆ นั้นหาได้ยาก ตัวอย่างเช่น ILP64 (8/8/8: `int`, `long`, และ Pointer ขนาด
-64 บิต) ที่มีการใช้งานแค่ในระบบ Unix 64 บิตช่วงเริ่มต้น (เช่น Unicos บน Cray)
-
-และโปรดจำไว้ว่า ตัวเลขที่มีขนาดแน่นอนนั้นมีให้ใช้งานใน `<stdint.h>` ตั้งแต่ C99

 === ประเภทจำนวนทศนิยมจริง (Real floating types)

-ภาษา C นั้นมีประเภทข้อมูลสำหรับแทนตัวเลขทศนิยมจริง 3 (หรือ 6 ตั้งแต่ C23) ประเภท
+#h(9.75em) ภาษา C นั้นมีประเภทข้อมูลสำหรับแทนตัวเลขทศนิยมจริง 3 (หรือ 6 ตั้งแต่ C23) ประเภท

- `float`: จำนวนทศนิยมความแม่นยำเดี่ยว ตรงกับฟอร์แมตมาตรฐาน IEEE-754 binary32 หากรองรับ
- `double`: จำนวนทศนิยมความแม่นยำสองเท่า ตรงกับฟอร์แมตมาตรฐาน IEEE-754 binary64
+ `float`: จำนวนทศนิยมความแม่นยำเดี่ยว ตรงกับฟอร์แมตมาตรฐาน IEEE-754 binary32 หากรองรับ
+ `double`: จำนวนทศนิยมความแม่นยำสองเท่า ตรงกับฟอร์แมตมาตรฐาน IEEE-754 binary64
  หากรองรับ
- `long double`: จำนวนทศนิยมความแม่นยำเพิ่มเติม ตรงกับฟอร์แมตมาตรฐาน IEEE-754 binary128
+ `long double`: จำนวนทศนิยมความแม่นยำเพิ่มเติม ตรงกับฟอร์แมตมาตรฐาน IEEE-754 binary128
  หากรองรับ มิฉะนั้นจะตรงกับ IEEE-754 binary64-extended หากรองรับ
  มิฉะนั้นจะตรงกับรูปแบบจำนวนทศนิยมที่ไม่ตรงกับมาตรฐาน IEEE-754
  รูปแบบใดก็ได้ตราบใดที่มีความแม่นยำกว่า binary64 และระยะข้อมูลนั้นอย่างน้อยก็ต้องดีเท่า binary64
  และหากไม่รองรับทั้งหมดนั้น จะตรงกับฟอร์แมตมาตรฐาน IEEE-754 binary64
-  - รูปแบบ binary128 นั้นถูกใช้โดยระบบ HP-UX, SPARC, MIPS, ARM64, และ z/OS บางระบบ
-  - รูปแบบ IEEE-754 binary64-extended ที่รู้จักกันอย่างแพร่หลายที่สุดคือรูปแบบความแม่นยำเพิ่มเติม
+  + รูปแบบ binary128 นั้นถูกใช้โดยระบบ HP-UX, SPARC, MIPS, ARM64, และ z/OS บางระบบ
+  + รูปแบบ IEEE-754 binary64-extended ที่รู้จักกันอย่างแพร่หลายที่สุดคือรูปแบบความแม่นยำเพิ่มเติม
    80 บิต x87 ซึ่งถูกใช้โดยสถาปัตยกรรม x86 และ x86-64 บางระบบ (การยกเว้นที่ควรพูดถึงคือ
    MSVC ที่กำหนดให้ `long double` อยู่ในรูปแบบเดียวกันกับ `double`, เช่น binary64)

 เมื่อใช้มาตรฐาน C ตั้งแต่ C23 เป็นต้นไปและหากแพลตฟอร์มของคุณใช้งานคอนแสตนต์มาโคร
 `__STDC_IEC_60559_DFP__` ข้อมูลประเภทตัวเลขทศนิยมดังต่อไปนี้จะถูกรองรับด้วย:

- `_Decimal32`: แทนรูปแบบมาตรฐาน IEEE-754 decimal32
- `_Decimal64`: แทนรูปแบบมาตรฐาน IEEE-754 decimal64
- `_Decimal128`: แทนรูปแบบมาตรฐาน IEEE-754 decimal128
+#[
+  #set enum(indent:9.75em)
+  + `_Decimal32`: แทนรูปแบบมาตรฐาน IEEE-754 decimal32
+ `_Decimal64`: แทนรูปแบบมาตรฐาน IEEE-754 decimal64
+ `_Decimal128`: แทนรูปแบบมาตรฐาน IEEE-754 decimal128
+]

 มิฉะนั้น ประเภทตัวเลขทศนิยมเพิ่มเติมเหล่านี้จะไม่ถูกรองรับ

 ข้อมูลประเภททศนิยมอาจรองรับค่าพิเศษเพิ่มเติมได้แก่

- อนันต์ (Infinity, ทั้งบวกและลบ)
- ศูนย์ติดลบ, `-0.0` โดยมีค่าเท่ากับศูยน์ที่ติดบวก แต่อาจมีความหมายในบางสมการ เช่น
+#[
+  #set enum(indent: 9.75em)
+  + อนันต์ (Infinity, ทั้งบวกและลบ)
+ ศูนย์ติดลบ, `-0.0` โดยมีค่าเท่ากับศูยน์ที่ติดบวก แต่อาจมีความหมายในบางสมการ เช่น
  `1.0 / 0.0 == INFINITY` แต่ `1.0 / -0.0 == -INFINITY`
- ไม่ใช่ตัวเลข (not-a-number; NaN) ซึ่งไม่เท่ากับอะไรเลย (รวมถึงตัวมันเอง)
+ ไม่ใช่ตัวเลข (not-a-number; NaN) ซึ่งไม่เท่ากับอะไรเลย (รวมถึงตัวมันเอง)
+]

 ทศนิยมจำนวนจริงสามารถถูกใช้กับตัวดำเนินการทางคณิตศาสตร์ได้ *+ - / \**
 และฟังก์ชันทางคณิตศาสตร์จาก `<math.h>`
@@ -297,22 +459,15 @@ float a, b, c;

 === ประเภทจำนวนทศนิยมซับซ้อน (Complex floating types)

-#i ประเภทข้อมูลจำนวนทศนิยมซับซ้อนนั้นเป็นประเภทที่แทนตัวเลขเชิงซ้อน (complex number) นั้นคือ
-ตัวเลขที่สามารถถูกเขียนแทนเป็นผลรวมของจำนวนจริงและจำนวนจริงที่คูณด้วยจำนวนจินตภาพ:
-#math.equation($a + b i$, alt: "a บวก b i")
+#h(9.75em) ประเภทข้อมูลจำนวนทศนิยมซับซ้อนนั้นเป็นประเภทที่แทนตัวเลขเชิงซ้อน (complex number)
+นั้นคือ ตัวเลขที่สามารถถูกเขียนแทนเป็นผลรวมของจำนวนจริงและจำนวนจริงที่คูณด้วยจำนวนจินตภาพ (a +
+bi) โดยประเภทจำนวนเชิงซ้อนมีอยู่สามประเภท ได้แก่

-ประเภทจำนวนเชิงซ้อนมีอยู่สามประเภท ได้แก่
-
- ```c float _Complex``` (และสามารถใช้ ```c float complex``` ได้เช่นกันหากนำเข้า
+ `float _Complex` (และสามารถใช้ `float complex` ได้เช่นกันหากนำเข้า `<complex.h>`)
+ `double _Complex` (และสามารถใช้ `double complex` ได้เช่นกันหากนำเข้า `<complex.h>`)
+ `long double _Complex` (และสามารถใช้ `long double complex` ได้เช่นกันหากนำเข้า
  `<complex.h>`)
- ```c double _Complex``` (และสามารถใช้ ```c double complex``` ได้เช่นกันหากนำเข้า
-  `<complex.h>`)
- ```c long double _Complex``` (และสามารถใช้ ```c long double complex```
-  ได้เช่นกันหากนำเข้า `<complex.h>`)

-*หมายเหตุ:* เหมือนกับประเภทอื่น ๆ สามารถพิมพ์คีย์เวิร์ดในลำดับใดก็ได้
-```c long double complex```, ```c complex long double``` และแม้แต่
-```c double complex long``` นั้นคือประเภทข้อมูลเดียวกัน

 === ประเภทจำนวนทศนิยมจินตภาพ (Imaginary floating types)

@@ -324,52 +479,47 @@ float a, b, c;

 ประเภทจำนวนเชิงซ้อนมีอยู่สามประเภท ได้แก่

- ```c float _Imaginary``` (และสามารถใช้ ```c float imaginary``` ได้เช่นกันหากนำเข้า
+ `float _Imaginary` (และสามารถใช้ `float imaginary` ได้เช่นกันหากนำเข้า
+  `<complex.h>`)
+ `double _Imaginary` (และสามารถใช้ `double imaginary` ได้เช่นกันหากนำเข้า
+  `<complex.h>`)
+ `long double _Imaginary` (และสามารถใช้ `long double imaginary` ได้เช่นกันหากนำเข้า
  `<complex.h>`)
- ```c double _Imaginary``` (และสามารถใช้ ```c double imaginary```
-  ได้เช่นกันหากนำเข้า `<complex.h>`)
- ```c long double _Imaginary``` (และสามารถใช้ ```c long double imaginary```
-  ได้เช่นกันหากนำเข้า `<complex.h>`)

-*หมายเหตุ:* เหมือนกับประเภทอื่น ๆ สามารถพิมพ์คีย์เวิร์ดในลำดับใดก็ได้
-```c long double imaginary```, ```c imaginary long double``` และแม้แต่
-```c double imaginary long``` นั้นคือประเภทข้อมูลเดียวกัน

 === ประเภทตัวอักษร (Character)

- `signed char`: ประเภทสำหรับตัวอักษรแบบ signed
- `unsigned char`: ประเภทสำหรับตัวอักษรแบบ unsigned
- `char`: ประเภทสำหรับตัวอักษรแบบไม่ระบุระยะข้อมูล ซึ่งสามารถเท่ากับ `signed char` หรือ
+ `signed char`: ประเภทสำหรับตัวอักษรแบบ signed
+ `unsigned char`: ประเภทสำหรับตัวอักษรแบบ unsigned
+ `char`: ประเภทสำหรับตัวอักษรแบบไม่ระบุระยะข้อมูล ซึ่งสามารถเท่ากับ `signed char` หรือ
  `unsigned char` ก็ได้ขึ้นอยู่กับแพลตฟอร์มและคอมไพเลอร์ แต่อย่างไรก็ตาม `char`
  นั้นไม่ใช่เพียงแค่มาโครที่ลิงก์ไปยังประเภทอื่น ๆ แต่ `char` คือประเภทของมันเอง

 === คีย์เวิร์ด

- `bool`, `true`, `false`, `char`, `int`, `short`, `long`, `signed`, `unsigned`,
+ `bool`, `true`, `false`, `char`, `int`, `short`, `long`, `signed`, `unsigned`,
  `float`, `double`.
- `_Bool`, `_BitInt`, `_Complex`, `_Imaginary`, `_Decimal32`, `_Decimal64`,
+ `_Bool`, `_BitInt`, `_Complex`, `_Imaginary`, `_Decimal32`, `_Decimal64`,
  `_Decimal128`.

 === ระยะค่าที่เก็บได้

-#i ตารางต่อไปนี้ให้ข้อมูลเกี่ยวกับขอบเขตของประเภทข้อมูลต่าง ๆ
-
-#i ก่อนมาตรฐาน C23 มาตรฐาน C อนุญาตการแทนตัวเลขแบบใดก็ได้ และระยะขั้นต่ำของตัวเลข N บิตคือ
-#math.equation($-(2^(N-1)-1)$, alt: "ลบ 2 ยกกำลัง N ลบ 1 ทั้งหมดลบ 1") ถึง
-#math.equation($+2^(N-1)-1$, alt: "บวก 2 ยกกำลัง N ลบ 1 ทั้งหมดลบ 1") (เช่น *-127*
-ถึง *127* สำหรับประเภทตัวเลข 8 บิต) ซึ่งตรงกับขอบเขตของส่วนเติมเต็มหนึ่ง (one's complement)
+#h(9.75em) ก่อนมาตรฐาน C23 มาตรฐาน C อนุญาตการแทนตัวเลขแบบใดก็ได้ และระยะขั้นต่ำของตัวเลข
+N บิตคือ #math.equation($-(2^(N-1)-1)$, alt: "ลบ 2 ยกกำลัง N ลบ 1 ทั้งหมดลบ 1") ถึง
+#math.equation($+2^(N-1)-1$, alt: "บวก 2 ยกกำลัง N ลบ 1 ทั้งหมดลบ 1") (เช่น -127 ถึง
+127 สำหรับประเภทตัวเลข 8 บิต) ซึ่งตรงกับขอบเขตของส่วนเติมเต็มหนึ่ง (one's complement)
 หรือการแทนจำนวนมีเครื่องหมาย (sign-and-magnitude)

-#i อย่างไรก็ตาม รูปแบบข้อมูลที่ใช้กันอย่างแพร่หลายทั้งหมด (รวมถึง ILP32, LP32, LP64, และ
-LLP64) และคอมไพเลอร์ C เกือบทั้งหมดใช้การแทนตัวเลขแบบส่วนเติมเต็มสอง (two's complement)
-(มีข้อยกเว้นที่ทราบแค่บางคอมไพเลอร์สำหรับระบบ UNISYS) และตั้งแต่มาตรฐาน C23
+#h(9.75em) อย่างไรก็ตาม รูปแบบข้อมูลที่ใช้กันอย่างแพร่หลายทั้งหมด (รวมถึง ILP32, LP32, LP64,
+และ LLP64) และคอมไพเลอร์ C เกือบทั้งหมดใช้การแทนตัวเลขแบบส่วนเติมเต็มสอง (two's
+complement) (มีข้อยกเว้นที่ทราบแค่บางคอมไพเลอร์สำหรับระบบ UNISYS) และตั้งแต่มาตรฐาน C23
 มันคือการแทนตัวเลขแบบเดียวที่ถูกอนุญาตให้ใช้โดยมาตรฐาน และมีขอบเขตที่แน่นอนระหว่าง
 #math.equation($-2^(N-1)$, alt: "ลบ 2 ยกกำลัง N ลบ 1") ถึง #math.equation(
  $+2^(N-1)-1$,
  alt: "บวก 2 ยกกำลัง N ลบ 1 ทั้งหมดลบ 1",
-) (เช่น *-128* ถึง *127* สำหรับประเภทตัวเลข 8 บิต)
+) (เช่น -128 ถึง 127 สำหรับประเภทตัวเลข 8 บิต)

-(มีการเพิ่มจุลภาคในทศนิยมเพื่อเพิ่มความสะดวกในการอ่าน)
+#h(9.75em) ตารางต่อไปนี้ให้ข้อมูลเกี่ยวกับขอบเขตของประเภทข้อมูลต่าง ๆ (มีการเพิ่มจุลภาคในทศนิยมเพื่อเพิ่มความสะดวกในการอ่าน)

 #show table.cell.where(x: 0): strong
 #show math.equation.where(block: true): set block(spacing: 0.6em)
@@ -439,17 +589,17 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    [IEEE-754],
    table.cell(
      [
-        - min subnormal:
+        + min subnormal:
          #math.equation(
            $± 1.401,298,4 · 10^(-45)$,
            alt: "บวกลบ 1.4012984 คูณ 10 ยกกำลัง -45",
          )
-        - min normal:
+        + min normal:
          #math.equation(
            $± 1.175,494,3 · 10^(-38)$,
            alt: "บวกลบ 1.1754943 คูณ 10 ยกกำลัง -38",
          )
-        - max: \
+        + max: \
          #math.equation(
            $± 3.402,823,4 · 10^(38)$,
            alt: "บวกลบ 3.4028234 คูณ 10 ยกกำลัง 38",
@@ -459,11 +609,11 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    ),
    table.cell(
      [
-        - min subnormal:\
+        + min subnormal:\
          `±0x1p-149`
-        - min normal:\
+        + min normal:\
          `±0x1p-126`
-        - max:\
+        + max:\
          `±0x1.fffffep+127`
      ],
      align: left,
@@ -473,19 +623,19 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    [IEEE-754],
    table.cell(
      [
-        - min subnormal:
+        + min subnormal:
          #math.equation(
            $± 4.940,656,458,412\ · 10^(-324)$,
            alt: "บวกลบ 4.940656458412 คูณ 10 ยกกำลัง ลบ 324",
            block: true,
          )
-        - min normal:
+        + min normal:
          #math.equation(
            $± 2.225,073,858,507,201,\ 4 · 10^(-308)$,
            alt: "บวกลบ 2.2250738585072014 คูณ 10 ยกกำลัง ลบ 308",
            block: true,
          )
-        - max:
+        + max:
          #math.equation(
            $± 1.797,693,134,862,315,\ 7 · 10^308$,
            alt: "บวกลบ 1.7976931348623157 คูณ 10 ยกกำลัง 308",
@@ -496,11 +646,11 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    ),
    table.cell(
      [
-        - min subnormal:
+        + min subnormal:
          `±0x1p-1074`
-        - min normal:\
+        + min normal:\
          `±0x1p-1022`
-        - max: `±0x1` \ `.fffffffffffffp+1023`
+        + max: `±0x1` \ `.fffffffffffffp+1023`
      ],
      align: left,
    ),
@@ -527,19 +677,19 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    [x86],
    table.cell(
      [
-        - min subnormal:
+        + min subnormal:
          #math.equation(
            $± 3.645,199,531,882,474,\ 602,528 · 10^(-4951)$,
            alt: "บวกลบ 3.645199531882474602528 คูณ 10 ยกกำลัง ลบ 4951",
            block: true,
          )
-        - min normal:
+        + min normal:
          #math.equation(
            $± 3.362,103,143,112,093,\ 506,263 · 10^(-4932)$,
            alt: "บวกลบ 3.362103143112093506263 คูณ 10 ยกกำลัง ลบ 4932",
            block: true,
          )
-        - max:
+        + max:
          #math.equation(
            $± 1.189,731,495,357,231,\ 765,021 · 10^(4932)$,
            alt: "บวกลบ 1.189731495357231765021 คูณ 10 ยกกำลัง 4932",
@@ -550,11 +700,11 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    ),
    table.cell(
      [
-        - min subnormal:
+        + min subnormal:
          `±0x1p-16445`
-        - min normal:
+        + min normal:
          `±0x1p-16382`
-        - max: `±0x1.ffffffff`\ `fffffffep+16383`
+        + max: `±0x1.ffffffff`\ `fffffffep+16383`
      ],
      align: left,
    ),
@@ -563,19 +713,19 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    [IEEE-754],
    table.cell(
      [
-        - min subnormal:
+        + min subnormal:
          #math.equation(
            $± 6.475,175,119,438,025,\ 110,924,438,958,227,\ 646,552,5 · 10^(-4966)$,
            alt: "บวกลบ 6.4751751194380251109244389582276465525 คูณ 10 ยกกำลัง ลบ 4966",
            block: true,
          )
-        - min normal:
+        + min normal:
          #math.equation(
            $± 3.362,103,143,112,093,\ 506,262,677,817,321,\ 752,602,6 · 10^(-4932)$,
            alt: "บวกลบ 3.3621031431120935062626778173217526026 คูณ 10 ยกกำลัง ลบ 4932",
            block: true,
          )
-        - max:
+        + max:
          #math.equation(
            $± 1.189,731,495,357,231,\ 765,085,759,326,628,\ 007,016,2 · 10^4932$,
            alt: "บวกลบ 1.1897314953572317650857593266280070162 คูณ 10 ยกกำลัง 4932",
@@ -586,11 +736,11 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    ),
    table.cell(
      [
-        - min subnormal:
+        + min subnormal:
          `±0x1p-16494`
-        - min normal:
+        + min normal:
          `±0x1p-16382`
-        - max: `±0x1.ffffffffffffff`\ `ffffffffffffffp+16383`
+        + max: `±0x1.ffffffffffffff`\ `ffffffffffffffp+16383`
      ],
      align: left,
    ),
@@ -601,11 +751,11 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    [],
    table.cell(
      [
-        - min subnormal:\
+        + min subnormal:\
          #math.equation($± 1 · 10^(-101)$, alt: "บวกลบ 1 คูณ 10 ยกกำลัง ลบ 101")
-        - min normal:\
+        + min normal:\
          #math.equation($± 1 · 10^(-95)$, alt: "บวกลบ 1 คูณ 10 ยกกำลัง ลบ 95")
-        - max:\
+        + max:\
          #math.equation(
            $± 9.999'999 · 10^96$,
            alt: "บวกลบ 9.999999 คูณ 10 ยกกำลัง 96",
@@ -619,11 +769,11 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    [],
    table.cell(
      [
-        - min subnormal:\
+        + min subnormal:\
          #math.equation($± 1 · 10^(-398)$, alt: "บวกลบ 1 คูณ 10 ยกกำลัง ลบ -398")
-        - min normal:\
+        + min normal:\
          #math.equation($± 1 · 10^(-383)$, alt: "บวกลบ 1 คูณ 10 ยกกำลัง ลบ 383")
-        - max:
+        + max:
          #math.equation(
            $± 9.999'999'999'999'999\ · 10^384$,
            alt: "บวกลบ 9.999999999999999 คูณ 10 ยกกำลัง 384",
@@ -638,17 +788,17 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
    [],
    table.cell(
      [
-        - min subnormal:\
+        + min subnormal:\
          #math.equation(
            $± 1 · 10^(-6176)$,
            alt: "บวกลบ 1 คูณ 10 ยกกำลัง ลบ 6176",
          )
-        - min normal:\
+        + min normal:\
          #math.equation(
            $± 1 · 10^(-6143)$,
            alt: "บวกลบ 1 คูณ 10 ยกกำลัง ลบ 6143",
          )
-        - max:
+        + max:
          #math.equation(
            $ ± 9.999'999'999'999'999'\ 999'999'999'999'999'999\ · 10^6144 $,
            alt: "บวกลบ 9.999999999999999999999999999999999 คูณ 10 ยกกำลัง 6144",
@@ -665,11 +815,11 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห

 == ชุดแปลโปรแกรมของกนู (GNU Compiler Collection; GCC)

-#i ในกระบวนการการพัฒนาโครงงานนี้
+#h(6em) ในกระบวนการการพัฒนาโครงงานนี้
 ชุดแปลโปรแกรมของกนูนั้นถูกใช้เป็นหลักเนื่องจากเป็นชุดแปลโปรแกรม (คอมไพเลอร์; Compiler)
 ที่ใช้เป็นหลักในการพัฒนาโคดที่สร้างบนพื้นฐาน Arduino และบอร์ดต่าง ๆ รวมถึงบอร์ด ESP32

-#i ชุดคอมไพเลอร์ GNU (GNU Compiler Collection; GCC) (เดิมชื่อ GNU C Compiler)
+#h(6em) ชุดคอมไพเลอร์ GNU (GNU Compiler Collection; GCC) (เดิมชื่อ GNU C Compiler)
 คือชุดคอมไพเลอร์จากโครงการ GNU ที่รองรับภาษาโปรแกรม สถาปัตยกรรมฮาร์ดแวร์
 และระบบปฏิบัติการต่าง ๆ มูลนิธิซอฟต์แวร์เสรี (FSF) เผยแพร่ GCC
 ในฐานะซอฟต์แวร์เสรีภายใต้สัญญาอนุญาตสถูกเรียกาธารณะทั่วไปของ GNU (GNU GPL) GCC
@@ -677,13 +827,13 @@ LLP64) และคอมไพเลอร์ C เกือบทั้งห
 Linux ด้วยโคดประมาณ 15 ล้านบรรทัดในปี 2019 GCC จึงเป็นหนึ่งในโปรแกรมฟรีที่ใหญ่ที่สุดเท่าที่เคยมีมา
 GCC มีบทบาทสำคัญในการเติบโตของซอฟต์แวร์เสรี ทั้งในฐานะเครื่องมือและตัวอย่าง

-#i นอกจากจะเป็นคอมไพเลอร์อย่างเป็นทางการของระบบปฏิบัติการ GNU แล้ว GCC
+#h(6em) นอกจากจะเป็นคอมไพเลอร์อย่างเป็นทางการของระบบปฏิบัติการ GNU แล้ว GCC
 ยังได้รับการยอมรับให้เป็นคอมไพเลอร์มาตรฐานโดยระบบปฏิบัติการคอมพิวเตอร์สมัยใหม่ที่คล้ายกับ Unix อื่นๆ
 อีกมากมาย รวมถึงระบบปฏิบัติการ Linux ส่วนใหญ่ ระบบปฏิบัติการตระกูล BSD ส่วนใหญ่ก็เปลี่ยนมาใช้ GCC
 ไม่นานหลังจากเปิดตัว แม้ว่าหลังจากนั้น FreeBSD และ Apple macOS ได้เปลี่ยนมาใช้คอมไพเลอร์ Clang
 ส่วนใหญ่เป็นเพราะเหตุผลด้านลิขสิทธิ์ GCC ยังสามารถคอมไพเลอร์โคดสำหรับระบบปฏิบัติการ Windows,
 Android, iOS, Solaris, HP-UX, AIX และ MS-DOS ได้อีกด้วย

-#i GCC ได้รับการพอร์ตไปยังแพลตฟอร์มและสถาปัตยกรรมชุดคำสั่งต่าง ๆ มากกว่าคอมไพเลอร์อื่น ๆ
+#h(6em) GCC ได้รับการพอร์ตไปยังแพลตฟอร์มและสถาปัตยกรรมชุดคำสั่งต่าง ๆ มากกว่าคอมไพเลอร์อื่น ๆ
 และถูกนำไปใช้งานอย่างกว้างขวางในฐานะเครื่องมือในการพัฒนาซอฟต์แวร์ทั้งแบบฟรีและแบบที่เป็นกรรมสิทธิ์
 นอกจากนี้ GCC ยังพร้อมใช้งานสำหรับระบบฝังตัวมากมาย รวมถึงชิปที่ใช้ ARM และ Power ISA
@@ -1,6 +1,6 @@
 #import "../PageTemplate.typ": page-theme
 #import "@preview/i-figured:0.2.4"
-// #show: page-theme
+#set enum(numbering: "1)")

 #set heading(numbering: "บทที่ 1")
 #include "Intro.typ"
@@ -11,7 +11,6 @@
 #include "Buzzer.typ"
 #include "HTTP.typ"
 #include "HTTPS.typ"
-#pagebreak()
 #include "TLS.typ"
 #include "NFC.typ"
 #include "Flutter.typ"
@@ -30,8 +30,6 @@ Alibaba
 สามารถคอมไพล์เป็นโค้ดเครื่อง JavaScript หรือ WebAssembly ได้ รองรับอินเทอร์เฟซ มิกซ์อิน
 คลาสนามธรรม เจเนอริกแบบรีไฟด์ และการอนุมานชนิดข้อมูล

-#pagebreak()
-
 == สถาปัตยกรรม

 #iii Flutter ถูกออกแบบมาให้เป็นระบบแบบเลเยอร์ที่ต่อขยายได้
@@ -66,26 +64,31 @@ Linux การใช้ตัวฝังตัว โค้ด Flutter สา
 ที่อยู่เบื้องหลังด้วยคลาส Dart ไลบรารีนี้เปิดเผยส่วนประกอบพื้นฐานระดับต่ำสุด เช่น
 คลาสสำหรับควบคุมระบบย่อยการรับข้อมูล กราฟิก และการแสดงผลข้อความ

+#pagebreak()
+
 #iii โดยทั่วไป นักพัฒนาจะโต้ตอบกับ Flutter ผ่านเฟรมเวิร์ก Flutter
 ซึ่งเป็นเฟรมเวิร์กที่ทันสมัยและตอบสนองต่อสิ่งรอบข้าง เขียนด้วยภาษา Dart
-เฟรมเวิร์กนี้ประกอบด้วยชุดไลบรารีแพลตฟอร์ม เลย์เอาต์ และพื้นฐานที่ครบครัน
-ซึ่งประกอบด้วยเลเยอร์หลายชั้น เริ่มจากล่างขึ้นบน ได้แก่:
+เฟรมเวิร์กนี้ประกอบด้วยชุดไลบรารี แพลตฟอร์ม#jb เลย์เอาต์ และพื้นฐานที่ครบครัน
+ซึ่งประกอบด้วยเลเยอร์หลายชั้น เริ่มจากล่างขึ้นบน ได้แก่

- คลาสพื้นฐานและบริการส่วนประกอบต่างๆ เช่น แอนิเมชัน การวาดภาพ และท่าทางสัมผัส
+#[
+  #set enum(indent: 5.5em)
+  + คลาสพื้นฐานและบริการส่วนประกอบต่างๆ เช่น แอนิเมชัน การวาดภาพ และท่าทางสัมผัส
    ซึ่งนำเสนอนามธรรมที่ใช้กันทั่วไปเหนือพื้นฐานที่อยู่เบื้องหลัง

- เลเยอร์การเรนเดอร์ให้นามธรรมสำหรับการจัดการเลย์เอาต์ ด้วยเลเยอร์นี้
+  + เลเยอร์การเรนเดอร์ให้นามธรรมสำหรับการจัดการเลย์เอาต์ ด้วยเลเยอร์นี้
    คุณสามารถสร้างโครงสร้างแบบต้นไม้ของวัตถุที่เรนเดอร์ได้ คุณสามารถจัดการวัตถุเหล่านี้แบบไดนามิก
    โดยโครงสร้างแบบต้นไม้จะอัปเดตเลย์เอาต์โดยอัตโนมัติเพื่อสะท้อนการเปลี่ยนแปลงของคุณ

- เลเยอร์วิดเจ็ตเป็นนามธรรมของการประกอบ
+  + เลเยอร์วิดเจ็ตเป็นนามธรรมของการประกอบ
    วัตถุเรนเดอร์แต่ละชิ้นในเลเยอร์การเรนเดอร์จะมีคลาสที่สอดคล้องกันในเลเยอร์วิดเจ็ต นอกจากนี้
    เลเยอร์วิดเจ็ตยังช่วยให้คุณกำหนดการรวมกันของคลาสที่คุณสามารถนำกลับมาใช้ใหม่ได้
    นี่คือเลเยอร์ที่แนะนำโมเดลการเขียนโปรแกรมแบบตอบสนอง

- ไลบรารี Material และ Cupertino
+  + ไลบรารี Material และ Cupertino
    นำเสนอชุดควบคุมที่ครอบคลุมซึ่งใช้ส่วนประกอบพื้นฐานของเลเยอร์วิดเจ็ตเพื่อนำภาษาการออกแบบ
    Material หรือ iOS ไปใช้
+]

 #iii เฟรมเวิร์ก Flutter มีขนาดค่อนข้างเล็ก
 ฟีเจอร์ระดับสูงหลายอย่างที่นักพัฒนาอาจใช้ถูกพัฒนาขึ้นมาในรูปแบบของแพ็กเกจ
@@ -94,8 +97,6 @@ Linux การใช้ตัวฝังตัว โค้ด Flutter สา
 แพ็กเกจบางส่วนมาจากระบบนิเวศที่กว้างกว่า ครอบคลุมบริการต่างๆ เช่น การชำระเงินภายในแอป
 การตรวจสอบสิทธิ์ของ Apple และแอนิเมชัน

-#pagebreak()
-
 == โครงสร้างของแอปพลิเคชัน

 #iii แผนภาพต่อไปนี้แสดงภาพรวมของส่วนประกอบต่างๆ ที่ประกอบกันเป็นแอป Flutter
@@ -104,35 +105,41 @@ Linux การใช้ตัวฝังตัว โค้ด Flutter สา
 คำอธิบายด้านล่างจะอธิบายคำศัพท์บางคำที่ใช้กันทั่วไปในการอธิบายส่วนประกอบของแอป Flutter

 #afigure(
-  image("Flutter/app-anatomy.svg", width: 3in),
+  image("Flutter/app-anatomy.svg", width: 2.5in),
  attr: [Flutter, ภายใต้ CC BY 4.0],
-  alt: "แผนผังสถาปัตยกรรม Flutter",
-  caption: [สถาปัตยกรรม Flutter],
+  alt: "เลเยอร์ต่าง ๆ ของแอพลิเคชัน Flutter ที่ถูกสร้างโดย flutter create",
+  caption: [เลเยอร์ต่าง ๆ ของแอพลิเคชัน Flutter],
 )

- แอปพลิเคชัน Dart (Dart app)
-  - ประกอบวิดเจ็ตเข้าด้วยกันเพื่อสร้าง UI ที่ต้องการ
-  - ดำเนินการตามตรรกะทางธุรกิจ
-  - นักพัฒนาแอปเป็นเจ้าของ
- เฟรมเวิร์ก (Framework)
-  - ให้ API ระดับสูงสำหรับการสร้างแอปคุณภาพสูง (ตัวอย่างเช่น วิดเจ็ต การทดสอบการกด#jb
+#[
+  #set enum(indent: 9.25em)
+  === แอปพลิเคชัน Dart (Dart app)
+  + ประกอบวิดเจ็ตเข้าด้วยกันเพื่อสร้าง UI ที่ต้องการ
+  + ดำเนินการตามตรรกะทางธุรกิจ
+  + นักพัฒนาแอปเป็นเจ้าของ
+
+  === เฟรมเวิร์ก (Framework)
+  + ให้ API ระดับสูงสำหรับการสร้างแอปคุณภาพสูง (ตัวอย่างเช่น วิดเจ็ต การทดสอบการกด
    การตรวจจับท่าทาง การเข้าถึงได้ และการอินพุต ข้อความ)
-  - ประกอบต้นวิดเจ็ตของแอปพลิเคชันเป็นฉาก
-#pagebreak()
- เอนจิน (Engine)
-  - มีหน้าที่แปลงฉากเป็นรูปแบบแรสเตอร์
-  - ให้การทำงานระดับต่ำของแกนกลางของ Flutter API (เช่น กราฟิก การจัดข้อความ และรันไทม์
+  + ประกอบต้นวิดเจ็ตของแอปพลิเคชันเป็นฉาก
+
+  === เอนจิน (Engine)
+  + มีหน้าที่แปลงฉากเป็นรูปแบบแรสเตอร์
+  + ให้การทำงานระดับต่ำของแกนกลางของ Flutter API (เช่น กราฟิก การจัดข้อความ และรันไทม์
    Dart)
-  - เปิดเผยฟังก์ชันระดับนี้ให้แก่เฟรมเวิร์กผ่าน API `dart:ui`
-  - บูรณาการกับแพลตฟอร์มต่าง ๆ ด้วย API ตัวฝังตัว
- ตัวฝังตัว (Embedder)
-  - ประสานงานกับระบบปฏิบัติการภายใต้สำหรับการเข้าถึงบริการต่าง ๆ เช่น พื้นผิวการเรนเดอร์
+  + เปิดเผยฟังก์ชันระดับนี้ให้แก่เฟรมเวิร์กผ่าน API `dart:ui`
+  + บูรณาการกับแพลตฟอร์มต่าง ๆ ด้วย API ตัวฝังตัว
+
+  === ตัวฝังตัว (Embedder)
+  + ประสานงานกับระบบปฏิบัติการภายใต้สำหรับการเข้าถึงบริการต่าง ๆ เช่น พื้นผิวการเรนเดอร์
    การเข้าถึง และการป้อนข้อมูล
-  - จัดการลูปอิเวนต์
-  - เปิดเผย API เฉพาะแพลตฟอร์มเพื่อบูรณาการตัวฝังตัวเข้าไปยังแอป
- ตัวรัน (Runner)
-  - ประกอบชิ้นส่วนที่ถูกเปิดเผยโดยตัวฝังตัวเข้าเป็นแพคเกจแอปพลิเคชันที่สามารถใช้งานได้บนแพลตฟอร์มเป้าหมาย
-  - บางส่วนถูกสร้างขึ้นโดย `flutter create` และมีเจ้าของเป็นผู้พัฒนาแอป
+  + จัดการลูปอิเวนต์
+  + เปิดเผย API เฉพาะแพลตฟอร์มเพื่อบูรณาการตัวฝังตัวเข้าไปยังแอป
+
+  === ตัวรัน (Runner)
+  + ประกอบชิ้นส่วนที่ถูกเปิดเผยโดยตัวฝังตัวเข้าเป็นแพคเกจแอปพลิเคชันที่สามารถใช้งานได้บนแพลตฟอร์มเป้าหมาย
+  + บางส่วนถูกสร้างขึ้นโดย `flutter create` และมีเจ้าของเป็นผู้พัฒนาแอป
+]

 == ระบบการดีไซน์

@@ -140,11 +147,11 @@ Linux การใช้ตัวฝังตัว โค้ด Flutter สา

 #[
  #set enum(indent: 5.5em)
-  + Material Design: การดีไซน์ของ Google สำหรับ Android
-  + Cupertino Design: การดีไซน์ของ Apple สำหรับ iOS
+  + Material Design คือการดีไซน์ของ Google สำหรับ Android
+  + Cupertino Design คือการดีไซน์ของ Apple สำหรับ iOS
 ]

-#iii *หมายเหตุ:* Cupertino Design ถูกแทนที่โดย Liquid Glass แล้ว โดยในปัจจุบันทีม Flutter
+#iii อย่างไรก็ตาม Cupertino Design ถูกแทนที่โดย Liquid Glass แล้ว โดยในปัจจุบันทีม Flutter
 กำลังทำการตรวจสอบและแก้ไขโครงสร้างระบบดีไซน์ ดังนั้น หากมีผู้พัฒนาต้องการใช้เอฟเฟกต์#jb Liquid
 Glass ในแอปพลิเคชัน Flutter จึงจำเป็นต้องพึงพาแพคเกจบุคคลที่สามก่อนในขณะนี้ (Flutter เวอร์ชัน
 3.38.5 ณ เวลาที่พิมพ์)
@@ -198,6 +205,8 @@ Glass ในแอปพลิเคชัน Flutter จึงจำเป็
 การแปลงแผนผังหลายแผนผังของวัตถุให้เป็นแผนผังระดับล่างของวัตถุ
 และการแพร่กระจายการเปลี่ยนแปลงไปยังแผนผังวิดเจ็ตเหล่านี้

+#pagebreak()
+
 #iii วิดเจ็ตประกาศส่วนติดต่อผู้ใช้โดยการเขียนทับเมธอด `build()` ซึ่งเป็นฟังก์ชันที่แปลงสถานะเป็น
 UI:

@@ -53,16 +53,19 @@ Foundation; EFF) ด้วยการสนับสนุนจากนัก
 ผู้สร้างเว็บเบราว์เซอร์จึงไว้วางใจผู้ให้บริการออกใบรับรองในการออกใบรับรองที่ถูกต้อง ดังนั้น
 ผู้ใช้ควรเชื่อถือการเชื่อมต่อ HTTPS ไปยังเว็บไซต์ก็ต่อเมื่อเป็นไปตามเงื่อนไขทั้งหมดต่อไปนี้:

- ผู้ใช้เชื่อมั่นว่าอุปกรณ์ของตน โฮสต์เบราว์เซอร์ และวิธีการเข้าถึงเบราว์เซอร์นั้นไม่ถูกบุกรุก (กล่าวคือ
+#[
+  #set enum(indent: 6em)
+  + ผู้ใช้เชื่อมั่นว่าอุปกรณ์ของตน โฮสต์เบราว์เซอร์ และวิธีการเข้าถึงเบราว์เซอร์นั้นไม่ถูกบุกรุก (กล่าวคือ
    ไม่มีการโจมตีซัพพลายเชน)
- ผู้ใช้เชื่อมั่นว่าซอฟต์แวร์เบราว์เซอร์ใช้งาน HTTPS
+  + ผู้ใช้เชื่อมั่นว่าซอฟต์แวร์เบราว์เซอร์ใช้งาน HTTPS
    ได้อย่างถูกต้องพร้อมกับผู้ให้บริการออกใบรับรองที่ติดตั้งไว้ล่วงหน้าอย่างถูกต้อง
- ผู้ใช้เชื่อมั่นว่าผู้ให้บริการออกใบรับรองจะรับรองเฉพาะเว็บไซต์ที่ถูกต้องตามกฎหมายเท่านั้น (กล่าวคือ
+  + ผู้ใช้เชื่อมั่นว่าผู้ให้บริการออกใบรับรองจะรับรองเฉพาะเว็บไซต์ที่ถูกต้องตามกฎหมายเท่านั้น (กล่าวคือ
    ผู้ให้บริการออกใบรับรองจะไม่ถูกบุกรุกและไม่มีการออกใบรับรองที่ผิดพลาด)
- เว็บไซต์มีใบรับรองที่ถูกต้อง ซึ่งหมายความว่าได้รับการลงนามโดยผู้ให้บริการที่เชื่อถือได้
- ใบรับรองระบุเว็บไซต์ได้อย่างถูกต้อง (เช่น เมื่อเบราว์เซอร์เข้าชม https://example.com
+  + เว็บไซต์มีใบรับรองที่ถูกต้อง ซึ่งหมายความว่าได้รับการลงนามโดยผู้ให้บริการที่เชื่อถือได้
+  + ใบรับรองระบุเว็บไซต์ได้อย่างถูกต้อง (เช่น เมื่อเบราว์เซอร์เข้าชม https://example.com
    ใบรับรองที่ได้รับนั้นถูกต้องสำหรับ example.com และไม่ใช่ของหน่วยงานอื่น)
- ผู้ใช้เชื่อมั่นว่าเลเยอร์การเข้ารหัสของโปรโตคอล (SSL/TLS) มีความปลอดภัยเพียงพอจากการดักฟัง
+  + ผู้ใช้เชื่อมั่นว่าเลเยอร์การเข้ารหัสของโปรโตคอล (SSL/TLS) มีความปลอดภัยเพียงพอจากการดักฟัง
+]

 #iii HTTPS มีความสำคัญอย่างยิ่งต่อเครือข่ายที่ไม่ปลอดภัยและเครือข่ายที่อาจถูกแทรกแซง
 เครือข่ายที่ไม่ปลอดภัย เช่น จุดเชื่อมต่อ Wi-Fi สาธารณะ
@@ -81,8 +84,7 @@ HTTPS นอกจากนี้ ยังพบว่าเครือข่

 #iii การปรับใช้ HTTPS ยังอนุญาตให้ใช้ HTTP/2 และ HTTP/3 (และรุ่นก่อนหน้าอย่าง SPDY และ
 QUIC) ซึ่งเป็น HTTP เวอร์ชันใหม่ที่ออกแบบมาเพื่อลดเวลา ขนาด และความหน่วงในการโหลดหน้าเว็บ
-
-#iii และมีการแนะนำให้ใช้ HTTP Strict Transport Security (HSTS) ร่วมกับ HTTPS
+และมีการแนะนำให้ใช้ HTTP Strict Transport Security (HSTS) ร่วมกับ HTTPS
 เพื่อป้องกันผู้ใช้จากการโจมตีแบบ man-in-the-middle โดยเฉพาะอย่างยิ่ง SSL stripping

 == ความปลอดภัย
@@ -107,7 +109,10 @@ QUIC) ซึ่งเป็น HTTP เวอร์ชันใหม่ที
 คุกกี้บนเว็บไซต์ที่รันผ่าน HTTPS จะต้องเปิดใช้งานแอตทริบิวต์ secure ในเว็บไซต์ที่มีข้อมูลละเอียดอ่อน
 ผู้ใช้และเซสชันจะถูกเปิดเผยทุกครั้งที่เข้าถึงเว็บไซต์นั้นด้วย HTTP แทนที่จะเป็น HTTPS

+#v(1em)
+
 == รายละเอียดทางเทคนิค
+#v(1em)

 === ความแตกต่างจาก HTTP

@@ -1,22 +1,23 @@
 #import "../PageTemplate.typ": chapter-page, i, jb
 #show: chapter-page
-#set enum(indent: 3em, numbering: n => "2." + str(n))

 #heading([#linebreak()ทฤษฎีและเอกสารที่เกี่ยวข้อง])

-#i ผู้จัดทำโครงงาน#h(1em)เครื่องยืนยันตัวตนด้วย NFC#h(1em)ได้ศึกษาทฤษฎีที่เกี่ยวข้องต่าง ๆ และ\
+#i ผู้จัดทำโครงงาน เครื่องยืนยันตัวตนด้วย NFC ได้ศึกษาทฤษฎีที่เกี่ยวข้องต่าง ๆ และ#jb
 รวบรวมแนวทางและหลักการต่าง ๆ จากเอกสารงานวิจัยที่เกี่ยวข้องดังต่อไปนี้

-+ ไมโครคอนโทรเลอร์ (Microcontroller)
-+ เซ็นเซอร์ (Sensors)
-+ ลำโพงสัญญาณ (Buzzer)
-+ เกณฑ์วิธีขนส่งข้อความหลายมิติ (HyperText Transfer Protocol; HTTP)
-+ เกณฑ์วิธีขนส่งข้อความหลายมิติแบบมั่นคง (Hypertext Transfer Protocol Secure; HTTPS)
-+ เกณฑ์วิธีความมั่นคงของชั้นขนส่ง (Transport Layer Security; TLS)
-+ การสื่อสารสนามใกล้ (Near-field communication; NFC)
-+ Flutter
-+ Git
-+ ภาษาซี (C Programming Language)
+#block(inset: (left: 3em))[
+  2.1 ไมโครคอนโทรเลอร์ (Microcontroller)\
+  2.2 เซ็นเซอร์ (Sensors)\
+  2.3 ลำโพงสัญญาณ (Buzzer)\
+  2.4 เกณฑ์วิธีขนส่งข้อความหลายมิติ (HyperText Transfer Protocol; HTTP)\
+  2.5 เกณฑ์วิธีขนส่งข้อความหลายมิติแบบมั่นคง (Hypertext Transfer Protocol Secure; HTTPS)\
+  2.6 เกณฑ์วิธีความมั่นคงของชั้นขนส่ง (Transport Layer Security; TLS)\
+  2.7 การสื่อสารสนามใกล้ (Near-field communication; NFC)\
+  2.8 Flutter\
+  2.9 Git\
+  2.10 ภาษาซี (C Programming Language)
+]

 #set heading(numbering: "1.1")
 #counter(heading).update((2, 0))
@@ -73,6 +73,8 @@ programmable" (ตั้งโปรแกรมได้ครั้งเด
  caption: "ไมโครคอนโทรลเลอร์ PIC ต่าง ๆ ที่มี EPROM ภายใน",
 )

+#v(1em)
+
 #afigure(
  image(
    "Microcontroller/Microcomputer_with_EPROM_(piggyback).jpg",
@@ -133,20 +135,23 @@ Microchip PIC16C84)
 ดอลลาร์#jb สหรัฐฯ (1,000 หน่วย แต่ที่ 0.466 ดอลลาร์สหรัฐสำหรับ 5,000 หน่วย)

 #iiii ในปี 2018 ไมโครคอนโทรลเลอร์ราคาถูกที่สูงกว่าปี 2015 ทั้งหมดมีราคาแพงกว่า
-(โดยคำนวณอัตราเงินเฟ้อระหว่างราคาปี 2018 ถึง 2015 สำหรับหน่วยเฉพาะเหล่านั้น) ที่:
- ไมโครคอนโทรลเลอร์ 8 บิตสามารถซื้อได้ในราคา 0.319 ดอลลาร์สหรัฐฯ (1,000 หน่วย) หรือสูงกว่า
+(โดยคำนวณอัตราเงินเฟ้อระหว่างราคาปี 2018 ถึง 2015 สำหรับหน่วยเฉพาะเหล่านั้น)
+โดยไมโครคอนโทรลเลอร์ 8 บิตสามารถซื้อได้ในราคา 0.319 ดอลลาร์สหรัฐฯ (1,000 หน่วย) หรือสูงกว่า
 2.6%
- ไมโครคอนโทรลเลอร์ 16 บิตมีราคา 0.464 ดอลลาร์สหรัฐฯ (1,000 หน่วย) หรือ 21% สูงกว่า
- แบบ 32 บิตในราคา 0.503 ดอลลาร์สหรัฐฯ (1,000 หน่วย แต่อยู่ที่ 0.466 ดอลลาร์สหรัฐฯ สำหรับ
-5,000) หรือสูงกว่า 33%
+
+#iiii ไมโครคอนโทรลเลอร์ 16 บิตมีราคา 0.464 ดอลลาร์สหรัฐฯ (1,000 หน่วย) หรือ 21% สูงกว่า
+
+#iiii แบบ 32 บิตในราคา 0.503 ดอลลาร์สหรัฐฯ (1,000 หน่วย แต่อยู่ที่ 0.466 ดอลลาร์สหรัฐฯ
+สำหรับ 5,000) หรือสูงกว่า 33%

 === คอมพิวเตอร์ที่เล็กที่สุด

 #iiii เมื่อวันที่ 21 มิถุนายน 2018 มหาวิทยาลัยมิชิแกนได้ประกาศ "คอมพิวเตอร์ที่เล็กที่สุดในโลก"
 อุปกรณ์ดังกล่าวเป็น "ระบบเซ็นเซอร์ไร้สายและไร้แบตเตอรี่ขนาด 0.04 ลบ.มม. 16 nW
-พร้อมด้วยโปรเซสเซอร์ Cortex-M0+ ในตัวและการสื่อสารแบบออปติกสำหรับการวัดอุณหภูมิของเซลล์"
-"วัดด้านข้างเพียง 0.3 มม. ประมาณขนาดเมล็ดข้าว [...] นอกเหนือจาก RAM และเซลล์แสงอาทิตย์แล้ว
-อุปกรณ์#jb คอมพิวเตอร์รุ่นใหม่ยังมีโปรเซสเซอร์และเครื่องส่งและตัวรับสัญญาณไร้สาย
+พร้อมด้วยโปรเซสเซอร์ Cortex-M0+ ในตัวและการสื่อสารแบบออปติกสำหรับการวัดอุณหภูมิของเซลล์"#jb
+"วัดด้านข้างเพียง 0.3 มม. ประมาณขนาดเมล็ดข้าว [...] นอกเหนือจาก RAM
+และเซลล์แสงอาทิตย์แล้ว#jb อุปกรณ์
+คอมพิวเตอร์รุ่นใหม่ยังมีโปรเซสเซอร์และเครื่องส่งและตัวรับสัญญาณไร้สาย
 เนื่องจากมีขนาดเล็กเกินไปที่จะมีเสาอากาศวิทยุแบบธรรมดา อุปกรณ์จึงรับและส่งข้อมูลด้วยแสงที่มองเห็นได้
 สถานีฐานให้แสงสำหรับพลังงานและการเขียนโปรแกรม และรับข้อมูล" อุปกรณ์นี้มีขนาด 1/10 ของขนาดที่
 IBM อ้างสิทธิ์ก่อนหน้านี้ คอมพิวเตอร์ที่มีขนาดเป็นสถิติโลกเมื่อหลายเดือนก่อนในเดือนมีนาคม 2018 ซึ่ง#jb
@@ -156,37 +161,38 @@ IBM อ้างสิทธิ์ก่อนหน้านี้ คอมพ

 == ประเภท

-#iii ณ ปี 2008 มีผู้ขายและสถาปัตยกรรมไมโครคอนโทรลเลอร์จำนวนมาก รวมไปถึง:
+#iii ณ ปี 2008 มีผู้ขายและสถาปัตยกรรมไมโครคอนโทรลเลอร์จำนวนมาก รวมไปถึง:#jb

- หน่วยประมวลผล ARM core (หลายผู้ขาย)
-  - คอร์ประเภท ARM Cortex-M นั้นมีเป้าหมายเพื่อทำงานในไมโครคอนโทรลเลอร์โดยเฉพาะ
- Microchip Technology Atmel AVR (8 บิต), AVR32 (32 บิต), และ AT91SAM (32 บิต)
- คอร์ M8C ของ Cypress Semiconductor's ที่ถูกใช้ใน Cypress PSoC ของพวกเขา
- Freescale ColdFire (32 บิต) และ S08 (8 บิต)
- Freescale 68HC11 (8 บิต) และอื่น ๆ ที่มีรากฐานมาจากครอบครัว Motorola 6800
- Intel 8051, ซึ่งนอกจาก Intel ก็ถูกผลิตโดย NXP Semiconductors, Infineon, และอื่น ๆ
+#block(inset: (left: 5.5em))[
+  + หน่วยประมวลผล ARM core โดยเฉพาะคอร์ประเภท ARM Cortex-M
+  + Microchip Technology Atmel AVR (8 บิต), AVR32 (32 บิต), และ AT91SAM (32 บิต)
+  + คอร์ M8C ของ Cypress Semiconductor's ที่ถูกใช้ใน Cypress PSoC ของพวกเขา
+  + Freescale ColdFire (32 บิต) และ S08 (8 บิต)
+  + Freescale 68HC11 (8 บิต) และอื่น ๆ ที่มีรากฐานมาจากครอบครัว Motorola 6800
+  + Intel 8051, ซึ่งนอกจาก Intel ก็ถูกผลิตโดย NXP Semiconductors, Infineon, และอื่น ๆ
    หลายรายการ
- Infineon: 8 บิต XC800, 16 บิต XE166, 32 บิต XMC4000 (ARM based Cortex M4F), 32 บิต
-  TriCore, และ 32 บิต Aurix Tricore Bit microcontrollers
- Maxim Integrated MAX32600, MAX32620, MAX32625, MAX32630, MAX32650, MAX32640
- MIPS
- Microchip Technology PIC, (8 บิต PIC16, PIC18, 16 บิต dsPIC33 / PIC24), (32 บิต
+  + Infineon: 8 บิต XC800, 16 บิต XE166, 32 บิต XMC4000 (ARM based Cortex M4F), 32
+    บิต TriCore, และ 32 บิต Aurix Tricore Bit microcontrollers
+  + Maxim Integrated MAX32600, MAX32620, MAX32625, MAX32630, MAX32650, MAX32640
+  + MIPS
+  + Microchip Technology PIC, (8 บิต PIC16, PIC18, 16 บิต dsPIC33 / PIC24), (32 บิต
    PIC32)
- NXP Semiconductors LPC1000, LPC2000, LPC3000, LPC4000 (32 บิต), LPC900, LPC700
-  (8 บิต)
- Parallax Propeller
- PowerPC ISE
- Rabbit 2000 (8 บิต)
- Renesas Electronics: RL78 16 บิต MCU; RX 32 บิต MCU; SuperH; V850 32 บิต MCU; H8;
-  R8C 16 บิต MCU
- Silicon Laboratories ไมโครคอนโทรลเลอร์ Pipelined 8 บิต 8051
+  + NXP Semiconductors LPC1000, LPC2000, LPC3000, LPC4000 (32 บิต), LPC900,
+    LPC700 (8 บิต)
+  + Parallax Propeller
+  + PowerPC ISE
+  + Rabbit 2000 (8 บิต)
+  + Renesas Electronics: RL78 16 บิต MCU; RX 32 บิต MCU; SuperH; V850 32 บิต MCU;
+    H8; R8C 16 บิต MCU
+  + Silicon Laboratories ไมโครคอนโทรลเลอร์ Pipelined 8 บิต 8051
    และไมโครคอนโทรลเลอร์แบบ ARM-based 32 บิต สัญญาณผสม
- STMicroelectronics STM8 (8 บิต), ST10 (16 บิต), STM32 (32 บิต), SPC5 (automotive
-  32 บิต)
- Texas Instruments TI MSP430 (16 บิต), MSP432 (32 บิต), C2000 (32 บิต)
- Toshiba TLCS-870 (8 บิต/16 บิต)
+  + STMicroelectronics STM8 (8 บิต), ST10 (16 บิต), STM32 (32 บิต), SPC5
+    (automotive 32 บิต)
+  + Texas Instruments TI MSP430 (16 บิต), MSP432 (32 บิต), C2000 (32 บิต)
+  + Toshiba TLCS-870 (8 บิต/16 บิต)
+]

-และยังมีอีกมากมาย โดยบางอย่างนั้นถูกใช้ในแอปพลิเคชันที่เจาะจงมาก
+#iiii และยังมีอีกมากมาย โดยบางอย่างนั้นถูกใช้ในแอปพลิเคชันที่เจาะจงมาก
 หรือเหมือนกับหน่วยประมวลผลเฉพาะแอปพลิเคชันมากกว่าไมโครคอนโทรลเลอร์
 ตลาดไมโครคอนโทรลเลอร์นั้นกระจัดกระจายเป็นอย่างมาก และมีผู้ขาย เทคโนโลยี และตลาดมากมาย
 และผู้ขายจำนวนมากขายหลายสถาปัตยกรรม
@@ -195,16 +201,27 @@ IBM อ้างสิทธิ์ก่อนหน้านี้ คอมพ

 #iii ESP32 คือกลุ่มไมโครคอนโทรลเลอร์ราคาประหยัดและประหยัดพลังงานที่ผสานรวมความสามารถทั้ง
 Wi-Fi และบลูทูธ ชิปเหล่านี้มีตัวเลือกการประมวลผลที่หลากหลาย รวมถึงไมโครโปรเซสเซอร์ Tensilica
-Xtensa LX6 ที่มีให้เลือกทั้งแบบ dual-core และ single-core, โปรเซสเซอร์ Xtensa LX7
+Xtensa LX6 ที่มีให้เลือกทั้งแบบ dual-core และ single-core, โปรเซสเซอร์#jb Xtensa LX7
 dual-core หรือไมโครโปรเซสเซอร์ RISC-V แบบ single-core นอกจากนี้ ESP32
 ยังรวมส่วนประกอบที่จำเป็นสำหรับการสื่อสารข้อมูลไร้สาย เช่น สวิตช์เสาอากาศในตัว บาลัน RF
 เครื่องขยายกำลัง เครื่องรับสัญญาณรบกวนต่ำ ตัวกรอง และโมดูลการจัดการพลังงาน

+#[
+  // #set par(spacing: 0.75em)
+  #afigure(
+    image("Microcontroller/ESP32-C3_RISC-V_NodeMCU_board.jpg", width: 2in),
+    alt: "บอร์ดสีดำ มีพิน GPIO ด้านข้างและมีชิพอยู่บริเวณด้านบนบอร์ด",
+    attr: [Popolon, CC BY-SA 4.0,
+      https://commons.wikimedia.org/w/index.php?curid=112634884],
+    caption: [บอร์ด NodeMCU ที่มี ESP32-C3-32S],
+  )
+
  #iii โดยทั่วไปแล้ว ESP32
-จะถูกฝังอยู่บนแผงวงจรพิมพ์เฉพาะอุปกรณ์หรือนำเสนอเป็นส่วนหนึ่งของชุดการพัฒนาที่มีพินและตัวเชื่อมต่อ GPIO
-ที่หลากหลาย โดยมีการกำหนดค่าที่แตกต่างกันไปตามรุ่นและผู้ผลิต ESP32 ได้รับการออกแบบโดย Espressif
-Systems และผลิตโดย TSMC โดยใช้กระบวนการ 40 นาโนเมตร มันเป็นผู้สืบทอดของไมโครคอนโทรลเลอร์
-ESP8266
+  จะถูกฝังอยู่บนแผงวงจรพิมพ์เฉพาะอุปกรณ์หรือนำเสนอเป็นส่วนหนึ่งของชุดการพัฒนาที่มีพินและตัวเชื่อมต่อ
+  GPIO ที่หลากหลาย โดยมีการกำหนดค่าที่แตกต่างกันไปตามรุ่นและผู้ผลิต ESP32 ได้รับการออกแบบโดย
+  Espressif Systems และผลิตโดย TSMC โดยใช้กระบวนการ 40 นาโนเมตร
+  มันเป็นผู้สืบทอดของไมโครคอนโทรลเลอร์ ESP8266
+]

 === Espressif Systems

@@ -220,11 +237,10 @@ things (IoT)

 == ตารางพาร์ทิชัน (Partition Table)

-#i ตารางพาร์ทิชันคือสิ่งที่กำหนดการจัดการรูปแบบหน่วยความจำแฟลชและข้อมูลต่าง ๆ
+#iii ตารางพาร์ทิชันคือสิ่งที่กำหนดการจัดการรูปแบบหน่วยความจำแฟลชและข้อมูลต่าง ๆ
 จะถูกเก็บไว้ในแต่ละพาร์ทิชัน
 โดยผู้พัฒนาสามารถใช้รูปแบบตารางพาร์ทิชันที่ถูกกำหนดมาไว้แล้วหรือสามารถกำหนดรูปแบบตารางพาร์ทิชันเองก็ได้
-
-#i โดยตารางพาร์ทัชันที่ถูกใช้ในโครงงานนี้มีรูปแบบดังนี้
+โดยตารางพาร์ทัชันที่ถูกใช้ในโครงงานนี้มีรูปแบบดังนี้

 #let partition-table = csv("PartitionTable.csv")

@@ -238,20 +254,21 @@ things (IoT)
  caption: [รายการพาร์ทิชัน],
 )

-ซึ่งคือตารางค่าเริ่มต้นของ ESP32 ใน Arduino platform
+#iii ซึ่งคือตารางค่าเริ่มต้นของ ESP32 ใน Arduino platform
 อย่างไรก็ตามมีการเปลี่ยนแปลงระบบเก็บไฟล์จาก SPIFFS เป็น LittleFS โดยที่:

-+ Name: ชื่อของพาร์ทิชัน ห้ามซ้ำกัน ชื่อนั้นไม่สำคัญต่อระบบและต้องขนาดไม่เกิน 16 ตัวอักษร
+#block(inset: (left: 6em))[
+  + Name คือ ชื่อของพาร์ทิชัน ห้ามซ้ำกัน ชื่อนั้นไม่สำคัญต่อระบบและต้องขนาดไม่เกิน 16 ตัวอักษร
  (ไม่มีอักขระพิเศษ)
-+ Type: ประเภทของพาร์ทัชัน สามารถเป็น data หรือ app ได้
-  - app คือพาร์ทิชันที่ใช้ในการเก็บแอปพลิเคชัน
-  - data คือพาร์ทิชันที่ใช้ในการเก็บข้อมูลทั่วไป
-+ SubType: ประเภทย่อย ระบุการใช้งานของพาร์ทิชัน app และ data
-  - data
-    - ota: พาร์ทัชันเก็บข้อมูล OTA (สำหรับการอัพเดททางอากาศ, Over-the-air update)
-      โดยหากไม่ใช้งาน OTA สามารถนำออกได้ โดยขนาดของพาร์ทิชันนี้ควรจะมีขนาดที่แน่นอนอยู่ที่ 8 KiB
-      (0x2000 ไบต์)
-    - nvs: พาร์ทิชันเก็บข้อมูลทั่วไปเช่น ข้อมูล Wi-Fi, ข้อมูลการสอบเทียบ PHY ของอุปกรณ์,
+  + Type คือ ประเภทของพาร์ทิชัน สามารถเป็น data หรือ app ได้
+    + app คือพาร์ทิชันที่ใช้ในการเก็บแอปพลิเคชัน
+    + data คือพาร์ทิชันที่ใช้ในการเก็บข้อมูลทั่วไป
+  + SubType คือ ประเภทย่อย ระบุการใช้งานของพาร์ทิชัน data และ app
+    + data
+      + ota คือ พาร์ทัชันเก็บข้อมูล OTA (สำหรับการอัพเดททางอากาศ, Over-the-air update)
+        โดยหากไม่ใช้งาน OTA สามารถนำออกได้ โดยขนาดของพาร์ทิชันนี้ควรจะมีขนาดที่แน่นอนอยู่ที่ 8
+        KiB (0x2000 ไบต์)
+      + nvs คือ พาร์ทิชันเก็บข้อมูลทั่วไปเช่น ข้อมูล Wi-Fi, ข้อมูลการสอบเทียบ PHY ของอุปกรณ์,
        และข้อมูลอื่น ๆ ที่ต้องถูกเก็บบนหน่วยความจำถาวร (Non-volatile memory)
        โดยพาร์ทิชันประเภทนี้เหมาะสมสำหรับการเก็บข้อมูลการตั้งค่าเล็กน้อย ใบรองรับคลาวด์ ฯลฯ
        และการใช้งาน NVS อีกอย่างคือการเก็บข้อมูลที่ละเอียดอ่อน เนื่องจาก NVS รองรับการเข้ารหัส
@@ -259,52 +276,53 @@ things (IoT)
        และหากจำเป็น คุณสามารถขยายขนาดเพิ่มได้ โดยขนาดที่แนะนำนั้นอยู่ระหว่าง 12 KiB และ 64
        KiB ถึงแม้ว่าคุณจะสามารถขยายให้มันใหญ่กว่านี้ได้ การใช้งานระบบไฟล์เช่น FAT หรือ SPIFFS
        นั้นจะเหมาะสมสำหรับข้อมูลที่ใหญ่กว่า
-    - coredump: ประเภทพาร์ทิชันย่อยนี้มีหน้าที่ในการเก็บข้อมูล core dump บนหน่วยความจำแฟลช โดย
-      core dump นั้นคือข้อมูลที่ถูกใช้งานสำหรับการตรวจสอบข้อผิด-พลาดร้ายแรงเช่นการแครชและแพนิค
+      + coredump คือ ประเภทพาร์ทิชันย่อยนี้มีหน้าที่ในการเก็บข้อมูล core dump บนหน่วยความจำแฟลช
+        โดย core dump
+        นั้นคือข้อมูลที่ถูกใช้งานสำหรับการตรวจสอบข้อผิด-พลาดร้ายแรงเช่นการแครชและแพนิค
        โดยฟังก์ชันนี้จะต้องถูกเปิดในการตั้งค่าโปรเจกต์และตั้งที่หมายในการแฟลช
        และพาร์ทิชันนี้มีขนาดที่แนะนำอยู่ที่ 64 KiB (0x10000)
-    - nvs_keys: พาร์ทิชันที่เป็นประเภทย่อยนี้เก็บคีย์การเข้ารหัสของพาร์ทัชัน NVS
+      + nvs_keys คือ พาร์ทิชันที่เป็นประเภทย่อยนี้เก็บคีย์การเข้ารหัสของพาร์ทัชัน NVS
        เมื่อการเข้ารหัสถูกใช้งาน โดยมีขนาดอยู่ที่ 4 KiB (0x1000)
-    - fat: กำหนดพาร์ทิชันสำหรับระบบไฟล์ FAT โดยที่จะเหมาะสมสำหรับข้อมูลใหญ่ ๆ
+      + fat คือ กำหนดพาร์ทิชันสำหรับระบบไฟล์ FAT โดยที่จะเหมาะสมสำหรับข้อมูลใหญ่ ๆ
        และหากข้อมูลนั้นถูกเปลี่ยนแปลงบ่อย โดยระบบไฟล์ FAT สามารถใช้ฟีเจอร์ wear leveling
        และการเข้ารหัสได้
-    - spiffs: กำหนดพาร์ทิชันสำหรับระบบไฟล์ SPIFFS เหมาะสำหรับไฟล์ใหญ่เช่นกันและรองรับ wear
-      leveling อย่างไรก็ตาม ระบบไฟล์นี้ไม่รองรับการเข้ารหัส
-  - app
-    - factory: พาร์ทิชันเก็บแอปพลิเคชันเริ่มต้น
-      โปรแกรมบูตโหลดเดอร์จะเลือกพาร์ทิชันนี้เป็นแอปพลิเคชันเริ่มต้นหากไม่มีพาร์ทิชัน OTA หรือพาร์ทิชัน
-      OTA นั้นว่างเปล่า หากมีการใช้พาร์ทิชัน OTA พาร์ทิชัน ota_0
+      + spiffs คือ กำหนดพาร์ทิชันสำหรับระบบไฟล์ SPIFFS เหมาะสำหรับไฟล์ใหญ่เช่นกันและรองรับ
+        wear leveling อย่างไรก็ตาม ระบบไฟล์นี้ไม่รองรับการเข้ารหัส
+    + app
+      + factory คือ พาร์ทิชันเก็บแอปพลิเคชันเริ่มต้น
+        โปรแกรมบูตโหลดเดอร์จะเลือกพาร์ทิชันนี้เป็นแอปพลิเคชันเริ่มต้นหากไม่มีพาร์ทิชัน OTA
+        หรือพาร์ทิชัน OTA นั้นว่างเปล่า หากมีการใช้พาร์ทิชัน OTA พาร์ทิชัน ota_0
        สามารถถูกใช้เป็นแอปพลิเคชันเริ่มต้นได้และพาร์ทิชัน factory สามารถถูกนำออกได้
-    - ota_0 ถึง ota_15: พาร์ทิชัน ota_x นั้นถูกใช้สำหรับอัพเดท OTA โดยฟีเจอร์ OTA
+      + ota_0 ถึง ota_15 คือ พาร์ทิชัน ota_x นั้นถูกใช้สำหรับอัพเดท OTA โดยฟีเจอร์ OTA
        นั้นจำเป็นต้องใช้พาร์ทิชัน OTA อย่างน้อย 2 พาร์ทิชัน (โดยปกติคือ ota_0 และ ota_1)
        และจำเป็นต้องใช้พาร์ทิชัน ota ด้วยเช่นกันในการเก็บข้อมูลเกี่ยวกับ OTA โดยสามารถมีพาร์ทิชัน
        OTA ได้สูงสุด 16 พาร์ทิชัน แต่ 2 พาร์ทิชันคือจำนวนขั้นต่ำที่ต้องใช้สำหรับฟีเจอร์ OTA แบบเบสิค
-    - test: ใช้สำหรับการทดสอบในโรงงาน
-+ Offset: กำหนดพื้นที่ที่พาร์ทิชันนั้น ๆ เริ่มต้น โดย Offset นั้นถูกกำหนดโดยการรวมค่า Offset
-  และขนาดของพาร์ทิชันก่อนหน้า \
-  หมายเหตุ: Offset จะต้องเป็นทวีคูณของ 4 KiB (0x1000)
+      + test คือ ใช้สำหรับการทดสอบในโรงงาน
+  + Offset คือ กำหนดพื้นที่ที่พาร์ทิชันนั้น ๆ เริ่มต้น โดย Offset นั้นถูกกำหนดโดยการรวมค่า Offset
+    และขนาดของพาร์ทิชันก่อนหน้า 0 อย่างไรก็ตาม Offset จะต้องเป็นทวีคูณของ 4 KiB (0x1000)
    และพาร์ทิชันแอพจะต้องจัดตำแหน่งให้มีขนาด 64 KiB (0x10000) โดยหากปล่อยให้ว่าง ค่า Offset
    จะถูกคำนวนโดยอัตโนมัติตามตำแหน่งท้ายของพาร์ทิชันก่อนหน้า รวมถึงการจัดตำแหน่งใด ๆ ที่จำเป็น
    อย่างไรก็ตาม Offset ของพาร์ทิชันแรกนั้นจะต้องเป็น 0x9000 และ 0x10000
    สำหรับพาร์ทิชันแอปพลิเคชันแรก
-+ Size: ขนาดของพาร์ทิชัน โดยค่านี้สามารถเป็นเลขทศนิยม, ตัวเลข Hex (นำหน้าด้วย 0x),
+  + Size คือ ขนาดของพาร์ทิชัน โดยค่านี้สามารถเป็นเลขทศนิยม, ตัวเลข Hex (นำหน้าด้วย 0x),
    หรือใช้ตัวอักษรต่อท้ายเพื่อบ่งบอกหน่วย K (กิโล) หรือ M (เมกา) เช่น 4096 = 4K = 0x1000
-+ Flags: ในปัจจุบันคอลัมน์นี้ใช้เพียงแค่เพื่อบ่งบอกว่าพาร์ทิชันนั้น ๆ ถูกเข้ารหัสหรือไม่
+  + Flags คือ ในปัจจุบันคอลัมน์นี้ใช้เพียงแค่เพื่อบ่งบอกว่าพาร์ทิชันนั้น ๆ ถูกเข้ารหัสหรือไม่
+]

 == littlefs
-#i littlefs คือระบบไฟล์ขนาดเล็กที่ปลอดภัยต่อความล้มเหลวที่ออกแบบมาสำหรับ#jb
+#iii littlefs คือระบบไฟล์ขนาดเล็กที่ปลอดภัยต่อความล้มเหลวที่ออกแบบมาสำหรับ#jb
 ไมโครคอนโทรลเลอร์

-ความยืดหยุ่นในการป้องกันการสูญเสียพลังงาน littlefs ออกแบบมาเพื่อรับมือกับปัญหาไฟฟ้าดับแบบสุ่ม
+#iii ความยืดหยุ่นในการป้องกันการสูญเสียพลังงาน littlefs ออกแบบมาเพื่อรับมือกับปัญหาไฟฟ้าดับแบบสุ่ม
 การดำเนินการไฟล์ทั้งหมดมีการรับประกันการคัดลอกข้อมูลเมื่อเขียนข้อมูล (copy-on-write) ที่แข็งแกร่ง
 และหากไฟฟ้าดับ ระบบไฟล์จะกลับสู่สถานะปกติล่าสุดที่ทราบ

-การปรับระดับการสึกหรอแบบไดนามิก littlefs ออกแบบมาเพื่อแฟลชโดยเฉพาะ
+#iii การปรับระดับการสึกหรอแบบไดนามิก littlefs ออกแบบมาเพื่อแฟลชโดยเฉพาะ
 และมอบการปรับระดับการสึกหรอบนบล็อกแบบไดนามิก นอกจากนี้ littlefs
 ยังสามารถตรวจจับบล็อกเสียและแก้ไขปัญหาได้

-RAM/ROM แบบมีขอบเขต littlefs ออกแบบมาเพื่อทำงานกับหน่วยความจำขนาดเล็ก การใช้งาน#jb RAM
-ถูกจำกัดอย่างเข้มงวด ซึ่งหมายความว่าการใช้ RAM จะไม่เปลี่ยนแปลงเมื่อระบบไฟล์เติบโตขึ้น#jb
+#iii RAM/ROM แบบมีขอบเขต littlefs ออกแบบมาเพื่อทำงานกับหน่วยความจำขนาดเล็ก#jb การใช้งาน
+RAM ถูกจำกัดอย่างเข้มงวด ซึ่งหมายความว่าการใช้ RAM จะไม่เปลี่ยนแปลงเมื่อระบบไฟล์เติบโตขึ้น
 ระบบไฟล์ไม่มีการเรียกซ้ำแบบไม่มีขอบเขต
 และหน่วยความจำแบบไดนามิกถูกจำกัดให้อยู่ในบัฟเฟอร์ที่กำหนดค่าได้ซึ่งสามารถจัดเตรียมแบบคงที่ได้

@@ -322,8 +340,8 @@ RAM/ROM แบบมีขอบเขต littlefs ออกแบบมาเ
 โดยการจำกัดจำนวนการลบข้อมูลที่อนุญาตบนบล็อกต่อการจัดสรรแต่ละครั้ง ตัวจัดสรรจะปรับระดับการ#jb
 สึกหรอแบบไดนามิกทั่วทั้งระบบไฟล์

-#show raw: set par(leading: 0.4em)
-#show raw: set text(size: 8pt)
+#show raw: set par(leading: 0.35em)
+#show raw: set text(size: 6pt)

 #afigure(
  ```
@@ -74,13 +74,13 @@ Field) สนามแม่เหล็กไฟฟ้าสลับเป็

 มาตรฐาน ISO/IEC 18092 รองรับอัตราข้อมูล 106, 212 หรือ 424 กิโลบิต/วินาที

-การสื่อสารเกิดขึ้นระหว่างอุปกรณ์ "ตัวเริ่มต้น" ที่ใช้งานอยู่และอุปกรณ์เป้าหมาย ซึ่งอาจเป็น:
+การสื่อสารเกิดขึ้นระหว่างอุปกรณ์ "ตัวเริ่มต้น" ที่ใช้งานอยู่และอุปกรณ์เป้าหมาย ซึ่งอาจเป็น

-/ พาสซีฟ: อุปกรณ์ตัวเริ่มต้นจะทำหน้าที่เป็นสนามแม่เหล็กพาหะ
+ พาสซีฟ โดยอุปกรณ์ตัวเริ่มต้นจะทำหน้าที่เป็นสนามแม่เหล็กพาหะ
  และอุปกรณ์เป้าหมายจะสื่อสารโดยการปรับสนามแม่เหล็กตกกระทบ ในโหมดนี้
  อุปกรณ์เป้าหมายอาจดึงพลังงานจากสนามแม่เหล็กที่ตัวเริ่มต้นจัดหาให้

-/ คล่องแคล่ว: ทั้งอุปกรณ์เริ่มต้นและอุปกรณ์เป้าหมายสื่อสารกันโดยการสร้างฟิลด์ของตัวเองสลับกัน
+ คล่องแคล่ว โดยทั้งอุปกรณ์เริ่มต้นและอุปกรณ์เป้าหมายสื่อสารกันโดยการสร้างฟิลด์ของตัวเองสลับกัน
  อุปกรณ์จะหยุดส่งสัญญาณเพื่อรับข้อมูลจากอีกอุปกรณ์หนึ่ง โหมดนี้กำหนดให้อุปกรณ์ทั้งสองต้องมีแหล่งจ่ายไฟ

 #figure(
@@ -99,13 +99,13 @@ Field) สนามแม่เหล็กไฟฟ้าสลับเป็
 จะใช้การเข้ารหัสแบบมิลเลอร์ที่ปรับเปลี่ยนแล้วพร้อมการมอดูเลต 100
 เปอร์เซ็นต์ในกรณีอื่นๆทั้งหมดจะใช้การเข้ารหัสแบบแมนเชสเตอร์โดยมีอัตราการมอดูเลต 10 เปอร์เซ็นต์

-อุปกรณ์ NFC ที่ใช้งานอยู่ทุกเครื่องสามารถทำงานในโหมดใดโหมดหนึ่งหรือหลายโหมดได้:
+#iii อุปกรณ์ NFC ที่ใช้งานอยู่ทุกเครื่องสามารถทำงานในโหมดใดโหมดหนึ่งหรือหลายโหมดได้

-/ การจำลองการ์ด NFC: ช่วยให้อุปกรณ์ที่รองรับ NFC เช่น สมาร์ทโฟน ทำหน้าที่เหมือนสมาร์ทการ์ด
+ การจำลองการ์ด NFC ช่วยให้อุปกรณ์ที่รองรับ NFC เช่น สมาร์ทโฟน ทำหน้าที่เหมือนสมาร์ทการ์ด
  ช่วยให้ผู้ใช้ทำธุรกรรมต่างๆ เช่น การชำระเงินหรือการออกตั๋วได้ ดูการจำลองการ์ดโฮสต์
-/ เครื่องอ่าน/เขียน NFC: ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC สามารถอ่านข้อมูลที่จัดเก็บไว้ในแท็ก NFC
+ เครื่องอ่าน/เขียน NFC ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC สามารถอ่านข้อมูลที่จัดเก็บไว้ในแท็ก NFC
  ราคาไม่แพงที่ฝังอยู่ในฉลากหรือโปสเตอร์อัจฉริยะได้
-/ NFC เพียร์ทูเพียร์: ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC
+ NFC เพียร์ทูเพียร์ ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC
  สองเครื่องสามารถสื่อสารกันเพื่อแลกเปลี่ยนข้อมูลในลักษณะ เฉพาะกิจ

 แท็ก NFC คือหน่วยเก็บข้อมูลแบบพาสซีฟที่อุปกรณ์ NFC สามารถอ่านและเขียนข้อมูลได้ในบางกรณี#jb
@@ -19,18 +19,14 @@ OpenSSL ถูกใช้อย่างแพร่หลายในเซิ
 และ BSD ), Microsoft Windows และ OpenVMS


-#iii OpenSSL รองรับอัลกอริทึมการเข้ารหัสที่แตกต่างกันจำนวนหนึ่ง:
+#iii OpenSSL รองรับอัลกอริทึมการเข้ารหัสที่แตกต่างกันจำนวนหนึ่ง โดยฟังก์ชันการเข้ารหัสได้แก่ AES,
+Blowfish, Camellia, ChaCha20, Poly1305, SEED, CAST-128, DES, IDEA, RC2, RC4,
+RC5, Triple DES, GOST 28147-89, SM4

-*รหัส:*
-AES, Blowfish, Camellia, ChaCha20, Poly1305, SEED, CAST-128, DES, IDEA, RC2,
-RC4, RC5, Triple DES, GOST 28147-89, SM4
+#iii ฟังก์ชันแฮชการเข้ารหัสได้แก่ MD5, MD4, MD2, SHA-1, SHA-2, SHA-3, RIPEMD-160,
+MDC-2, GOST R 34.11-94, BLAKE2, วังวน, SM3

-*ฟังก์ชันแฮชการเข้ารหัส:*
-MD5, MD4, MD2, SHA-1, SHA-2, SHA-3, RIPEMD-160, MDC-2, GOST R 34.11-94, BLAKE2,
-วังวน, SM3
-
-*การเข้ารหัสด้วยคีย์สาธารณะ:*
-RSA, DSA, การแลกเปลี่ยนคีย์ Diffie--Hellman, เส้นโค้งวงรี, X25519, Ed25519, X448,
-Ed448, GOST R 34.10-2001, SM2
+#iii ฟังก์ชันการเข้ารหัสด้วยคีย์สาธารณะได้แก่ RSA, DSA, การแลกเปลี่ยนคีย์ Diffie--Hellman,
+เส้นโค้งวงรี, X25519, Ed25519, X448, Ed448, GOST R 34.10-2001, SM2

 (การปกปิดแบบสมบูรณ์แบบได้รับการสนับสนุนโดยใช้เส้นโค้งวงรี Diffie--Hellman ตั้งแต่เวอร์ชัน 1.0)
@@ -9,6 +9,8 @@
 (IR) ที่แผ่ออกมาจากวัตถุในระยะการมองเห็น เซ็นเซอร์ชนิดนี้มักใช้ในเครื่องตรวจจับความเคลื่อนไหว แบบ
 PIR เซ็นเซอร์ PIR มักใช้ในสัญญาณเตือนภัยและระบบไฟส่องสว่างอัตโนมัติ

+#v(1em)
+
 #afigure(
  image("PIR/Front-Fresnel_type.jpg", height: image-height),
  attr: [Jack LaRosa, Public Domain,
@@ -17,7 +19,7 @@ PIR เซ็นเซอร์ PIR มักใช้ในสัญญาณ
  caption: [เครื่องตรวจจับการเคลื่อนไหวแบบ PIR ทั่วไปสำหรับที่พักอาศัย/เชิงพาณิชย์],
 )

-#iii เซ็นเซอร์ PIR ตรวจจับการเคลื่อนไหวทั่วไป แต่ไม่ได้ให้ข้อมูลว่าใครหรือสิ่งใดเคลื่อนไหว ดังนั้น
+#iii เซ็นเซอร์ PIR ตรวจจับการเคลื่อนไหวทั่วไป แต่ไม่ได้ให้ข้อมูลว่าใครหรือสิ่งใดเคลื่อนไหว#jb ดังนั้น
 จึงจำเป็นต้องใช้ เซ็นเซอร์ IR แบบสร้างภาพ เซ็นเซอร์ PIR มักเรียกสั้นๆ ว่า "PIR"
 หรือบางครั้งเรียกว่า "PID" ซึ่งย่อมาจาก "เครื่องตรวจจับอินฟราเรดแบบพาสซีฟ" เซ็นเซอร์ PIR
 ตรวจจับการเคลื่อนไหวทั่วไป แต่ไม่ได้ให้ข้อมูลว่าใครหรือสิ่งใดเคลื่อนไหว ดังนั้น จึงจำเป็นต้องใช้ เซ็นเซอร์
@@ -36,8 +38,11 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
 โดยปกติแล้วรังสีนี้มองไม่เห็นด้วยตาเปล่าเนื่องจากแผ่รังสีในช่วงความยาวคลื่นอินฟราเรด
 แต่อุปกรณ์อิเล็กทรอนิกส์ที่ออกแบบมาเพื่อจุดประสงค์นี้ สามารถตรวจจับได้

-== เครื่องตรวจจับการเคลื่อนไหวแบบ PIR
+#v(1em)

+
+== เครื่องตรวจจับการเคลื่อนไหวแบบ PIR
+\
 #afigure(
  image("PIR/Motion_detector.jpg", height: image-height),
  alt: "เครื่องตรวจจับความเคลื่อนไหว ติดตั้งบนเพดาน",
@@ -45,7 +50,6 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
    https://commons.wikimedia.org/w/index.php?curid=6087132],
  caption: [เครื่องตรวจจับความเคลื่อนไหว PIR ใช้สำหรับควบคุมไฟภายนอกอาคารแบบอัตโนมัติ],
 )
-
 #afigure(
  image("PIR/Camera_trap,_fotopułapka,_kamera_leśna,_kamera_obserwacyjna.jpg"),
  attr: [Dariusz Kowalczyk, CC BY-SA 4.0,
@@ -156,6 +160,8 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
    โฟกัสแสงไปที่ชิ้นส่วนเซ็นเซอร์ไพโรอิเล็กทริกที่อยู่ด้านล่าง],
 )

+#v(3em)
+
 #afigure(
  image("PIR/Fresnel_only.jpg", height: 2in),
  attr: [Jack LaRosa, Public Domain,
@@ -165,6 +171,8 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
    โดยมีแหล่งกำเนิดแสงจุดอยู่ด้านหลัง เพื่อแสดงเลนส์แต่ละตัว],
 )

+#v(3em)
+
 #afigure(
  image("PIR/Circuit_board_revealed.jpg", height: 2in),
  attr: [Jack LaRosa, Public Domain,
@@ -189,6 +197,8 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
  caption: [PID ทั่วไปสำหรับที่พักอาศัย/เชิงพาณิชย์ที่ ใช้กระจกแบ่งส่วนภายในเพื่อการโฟกัส],
 )

+#v(1em)
+
 #afigure(
  image("PIR/Mirror_type_opened.jpg", height: 2in),
  attr: [Deuxdad, Public Domain,
@@ -197,6 +207,8 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
  caption: [ถอดฝาครอบออกแล้ว กระจกแบ่งส่วน ด้านล่างมีแผงวงจรพิมพ์ (PC) อยู่ด้านบน],
 )

+#v(1em)
+
 #afigure(
  image("PIR/Mirror_in_place.jpg", height: 2in),
  attr: [Jack LaRosa, Public Domain,
@@ -213,6 +225,8 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
  caption: [กระจกพาราโบลาแบบแบ่งส่วนถอดออกจากตัวเครื่อง],
 )

+#v(1em)
+
 #afigure(
  image("PIR/Rear_of_circuit_board2.jpg", height: 2in),
  attr: [Jack LaRosa, Public Domain,
@@ -222,6 +236,8 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
    เซ็นเซอร์ไพโรอิเล็กทริกแสดงด้วยลูกศรสีเขียว],
 )

+#v(2em)
+
 == รูปแบบลำแสง

 #afigure(
@@ -233,6 +249,8 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
    ความยาวของลำแสงเป็นตัวชี้วัดความไวของเครื่องตรวจจับในทิศทางนั้น],
 )

+#v(2em)
+
 #h(9.75em) จากการโฟกัส ทำให้มุมมองของเครื่องตรวจจับกลายเป็นรูปแบบลำแสง ภายใต้มุมบางมุม
 (โซน) เซ็นเซอร์ PIR แทบจะไม่ได้รับพลังงานรังสีใด ๆ และภายใต้มุมอื่น ๆ PIR
 จะได้รับพลังงานอินฟราเรดในปริมาณที่เข้มข้น
@@ -295,9 +313,9 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก

 == เทอร์โมมิเตอร์แบบควบคุมระยะไกลด้วย PIR

-#h(9.75em) มีการออกแบบวงจร PIR ที่ใช้วัดอุณหภูมิของวัตถุที่อยู่ห่างไกลในวงจรดังกล่าว จะใช้เอาต์พุต
-PIR แบบไม่มีค่าความแตกต่าง สัญญาณเอาต์พุตจะถูกประเมินตามการสอบเทียบสเปกตรัม IR
-ของสสารชนิดเฉพาะที่ต้องการตรวจวัด ด้วยวิธีนี้ การวัดอุณหภูมิจากระยะไกลจึงค่อนข้างแม่นยำและแม่นยำ
+#h(9.75em) มีการออกแบบวงจร PIR ที่ใช้วัดอุณหภูมิของวัตถุที่อยู่ห่างไกลในวงจรดังกล่าว#jb
+จะใช้เอาต์พุต PIR แบบไม่มีค่าความแตกต่าง สัญญาณเอาต์พุตจะถูกประเมินตามการสอบเทียบ#jb สเปกตรัม
+IR ของสสารชนิดเฉพาะที่ต้องการตรวจวัด ด้วยวิธีนี้ การวัดอุณหภูมิจากระยะไกลจึงค่อนข้างแม่นยำและแม่นยำ
 หากไม่มีการสอบเทียบกับชนิดของวัสดุที่ตรวจวัด อุปกรณ์เทอร์โมมิเตอร์ PIR
 จะสามารถวัดการเปลี่ยนแปลงของการแผ่รังสี IR ซึ่งสอดคล้องกับการเปลี่ยนแปลงของอุณหภูมิโดยตรง
 แต่ไม่สามารถคำนวณค่าอุณหภูมิที่แท้จริงได้
@@ -39,24 +39,26 @@ Navigator
 โปรโตคอลใช้การจับมือกับรหัสแบบอสมมาตรเพื่อกำหนดค่าการเข้ารหัสไม่เพียงเท่านั้น
 แต่ยังรวมถึงคีย์ที่ใช้ร่วมกันเฉพาะเซสชัน
 ซึ่งการสื่อสารต่อไปจะถูกเข้ารหัสโดยใช้รหัสแบบสมมาตรในระหว่างการจับมือนี้
-ไคลเอนต์และเซิร์ฟเวอร์จะตกลงกันเกี่ยวกับพารามิเตอร์ต่างๆ ที่ใช้สร้างความปลอดภัยของการเชื่อมต่อ:
+ไคลเอนต์และเซิร์ฟเวอร์จะตกลงกันเกี่ยวกับพารามิเตอร์ต่างๆ ที่ใช้สร้างความปลอดภัยของการเชื่อมต่อ

- การจับมือเริ่มต้นเมื่อไคลเอนต์เชื่อมต่อกับเซิร์ฟเวอร์ที่เปิดใช้งาน TLS
+#block(inset: (left: 6em))[
+  + การจับมือเริ่มต้นเมื่อไคลเอนต์เชื่อมต่อกับเซิร์ฟเวอร์ที่เปิดใช้งาน TLS
  เพื่อขอการเชื่อมต่อที่ปลอดภัยและไคลเอนต์แสดงรายการชุดรหัสที่รองรับ (รหัสและฟังก์ชันแฮช)
- จากรายการนี้ เซิร์ฟเวอร์จะเลือกฟังก์ชันรหัสและแฮชที่รองรับ และแจ้งให้ไคลเอนต์ทราบถึงการตัดสินใจ
- โดยปกติแล้วเซิร์ฟเวอร์จะระบุตัวตนในรูปแบบของใบรับรองดิจิทัลใบรับรองประกอบด้วยชื่อเซิร์ฟเวอร์ผู้ให้บริการออกใบรับรอง
+ จากรายการนี้ เซิร์ฟเวอร์จะเลือกฟังก์ชันรหัสและแฮชที่รองรับ และแจ้งให้ไคลเอนต์ทราบถึงการตัดสินใจ
+ โดยปกติแล้วเซิร์ฟเวอร์จะระบุตัวตนในรูปแบบของใบรับรองดิจิทัลใบรับรองประกอบด้วยชื่อเซิร์ฟเวอร์ผู้ให้บริการออกใบรับรอง
  (CA) ที่เชื่อถือได้ซึ่งรับรองความถูกต้องของใบรับรอง และคีย์การเข้ารหัสสาธารณะของเซิร์ฟเวอร์
- ลูกค้าต้องยืนยันความถูกต้องของใบรับรองก่อนดำเนินการต่อ
- ในการสร้างคีย์เซสชันที่ใช้สำหรับการเชื่อมต่อที่ปลอดภัย ไคลเอนต์จะต้องทำดังนี้:
-  - เข้ารหัสตัวเลขสุ่ม (PreMasterSecret)
+ ลูกค้าต้องยืนยันความถูกต้องของใบรับรองก่อนดำเนินการต่อ
+ ในการสร้างคีย์เซสชันที่ใช้สำหรับการเชื่อมต่อที่ปลอดภัย ไคลเอนต์จะต้องทำดังนี้:
+  + เข้ารหัสตัวเลขสุ่ม (PreMasterSecret)
    ด้วยคีย์สาธารณะของเซิร์ฟเวอร์และส่งผลลัพธ์ไปยังเซิร์ฟเวอร์
    (ซึ่งเฉพาะเซิร์ฟเวอร์เท่านั้นที่จะสามารถถอดรหัสด้วยคีย์ส่วนตัว)
    จากนั้นทั้งสองฝ่ายใช้ตัวเลขสุ่มเพื่อสร้างคีย์เซสชันเฉพาะสำหรับการเข้ารหัสและถอดรหัสข้อมูลในระหว่างเซสชันในภายหลังหรือ
-  - ใช้การแลกเปลี่ยนคีย์ Diffie--Hellman (หรือรูปแบบ DH ที่เป็นเส้นโค้งวงรี)
+  + ใช้การแลกเปลี่ยนคีย์ Diffie--Hellman (หรือรูปแบบ DH ที่เป็นเส้นโค้งวงรี)
    เพื่อสร้างคีย์เซสชันแบบสุ่มและไม่ซ้ำกันอย่างปลอดภัยสำหรับการเข้ารหัสและถอดรหัส
    ซึ่งมีคุณสมบัติเพิ่มเติมของการปกปิดแบบส่งต่อ : หากคีย์ส่วนตัวของเซิร์ฟเวอร์ถูกเปิดเผยในอนาคต
    จะไม่สามารถใช้คีย์นั้นเพื่อถอดรหัสเซสชันปัจจุบันได้
    แม้ว่าเซสชันนั้นจะถูกดักจับและบันทึกโดยบุคคลที่สามก็ตาม
+]

 #iii
 การดำเนินการนี้จะสิ้นสุดการจับมือและเริ่มการเชื่อมต่อที่ปลอดภัยซึ่งจะถูกเข้ารหัสและถอดรหัสด้วยคีย์เซสชันจนกว่าการเชื่อมต่อจะสิ้นสุดลงหากขั้นตอนใดขั้นตอนหนึ่งข้างต้นล้มเหลวการจับมือ
@@ -72,7 +74,9 @@ TLS จะล้มเหลวและการเชื่อมต่อจ
 #iii เมื่อได้รับการรักษาความปลอดภัยโดย TLS การเชื่อมต่อระหว่างไคลเอนต์ (เช่น เว็บเบราว์เซอร์)
 และเซิร์ฟเวอร์ (เช่น wikipedia.org) จะมีคุณสมบัติทั้งหมดดังต่อไปนี้

- การเชื่อมต่อเป็นแบบส่วนตัว (หรือมีความลับ) เนื่องจาก มีการใช้
+#[
+  #set enum(indent: 6em)
+  + การเชื่อมต่อเป็นแบบส่วนตัว (หรือมีความลับ) เนื่องจาก มีการใช้
    อัลกอริทึมคีย์แบบสมมาตรในการเข้ารหัสข้อมูลที่ส่ง
    คีย์สำหรับการเข้ารหัสแบบสมมาตรนี้จะถูกสร้างขึ้นอย่างเฉพาะเจาะจงสำหรับแต่ละการเชื่อมต่อ
    และอิงจากความลับร่วมที่เจรจากันไว้เมื่อเริ่มต้นเซสชัน
@@ -81,9 +85,10 @@ TLS จะล้มเหลวและการเชื่อมต่อจ
    (ความลับที่เจรจากันไว้จะไม่สามารถเข้าถึงได้โดยผู้ดักฟังและไม่สามารถได้รับ
    แม้แต่โดยผู้โจมตีที่วางตัวเองอยู่ตรงกลางการเชื่อมต่อ) และเชื่อถือได้
    (ไม่มีผู้โจมตีคนใดสามารถแก้ไขการสื่อสารระหว่างการเจรจาโดยไม่ถูกตรวจพบ)
- การยืนยันตัวตนของฝ่ายที่สื่อสารสามารถยืนยันได้โดยใช้การเข้ารหัสด้วยคีย์สาธารณะการยืนยันตัวตนนี้จำเป็นสำหรับเซิร์ฟเวอร์และเป็นทางเลือกสำหรับไคลเอนต์
- การเชื่อมต่อมีความน่าเชื่อถือ (หรือมีความสมบูรณ์)
+ การยืนยันตัวตนของฝ่ายที่สื่อสารสามารถยืนยันได้โดยใช้การเข้ารหัสด้วยคีย์สาธารณะการยืนยันตัวตนนี้จำเป็นสำหรับเซิร์ฟเวอร์และเป็นทางเลือกสำหรับไคลเอนต์
+ การเชื่อมต่อมีความน่าเชื่อถือ (หรือมีความสมบูรณ์)
  เนื่องจากข้อความแต่ละข้อความที่ส่งออกจะมีการตรวจสอบความสมบูรณ์ของข้อความโดยใช้รหัสยืนยันข้อความเพื่อป้องกันการสูญหายหรือการเปลี่ยนแปลงข้อมูลที่ไม่ถูกตรวจพบระหว่างการส่งข้อมูล
+]

 #iii TLS รองรับวิธีการที่หลากหลายสำหรับการแลกเปลี่ยนคีย์ การเข้ารหัสข้อมูล
 และการตรวจสอบความถูกต้องของข้อความ ดังนั้น การกำหนดค่า TLS
@@ -26,24 +26,20 @@ Study Group 17 และมีพื้นฐานมาจาก Abstract Synt
 #iiii โครงสร้างที่กำหนดไว้โดยมาตรฐานจะแสดงอยู่ในภาษาทางการที่เรียกว่า Abstract Syntax
 Notation One (ASN.1)

-โครงสร้างของใบรับรองดิจิทัล X.509 v3 มีดังนี้:
+#iiii โครงสร้างของใบรับรองดิจิทัล X.509 v3 มีดังนี้

- ใบรับรอง
-  - หมายเลขเวอร์ชัน
-  - หมายเลขซีเรียล
-  - รหัสอัลกอริทึมลายเซ็น
-  - ชื่อผู้ออก
-  - ระยะเวลาใช้งาน
-    - ไม่ก่อน
-    - ไม่หลังจากนั้น
-  - ชื่อเรื่อง
-  - ข้อมูลคีย์สาธารณะของเรื่อง
-    - อัลกอริทึมคีย์สาธารณะ
-    - คีย์สาธารณะของเรื่อง รหัสประจำตัวผู้ออก (ทางเลือก) รหัสประจำตัวเฉพาะเรื่อง (ทางเลือก)
-      ส่วนขยาย (ทางเลือก)
-
-  - อัลกอริทึมลายเซ็นใบรับรอง
-  - ลายเซ็นใบรับรอง
+ ใบรับรอง
+  + หมายเลขเวอร์ชัน
+  + หมายเลขซีเรียล
+  + รหัสอัลกอริทึมลายเซ็น
+  + ชื่อผู้ออก
+  + ระยะเวลาใช้งานไม่ก่อนหรือไม่หลังจากนั้น
+  + ชื่อเรื่อง
+  + ข้อมูลคีย์สาธารณะของเรื่องได้แก่อัลกอริทึมคีย์สาธารณะ
+      คีย์สาธารณะของเรื่องเช่นรหัสประจำตัวผู้ออก (ไม่จำเป็น)
+      รหัสประจำตัวเฉพาะเรื่อง (ไม่จำเป็น) ส่วนขยาย (ไม่จำเป็น)
+ อัลกอริทึมลายเซ็นใบรับรอง
+ ลายเซ็นใบรับรอง

 #iiii ฟิลด์ส่วนขยาย (ถ้ามี) จะเป็นลำดับของส่วนขยายใบรับรองอย่างน้อยหนึ่งรายการ
 แต่ละส่วนขยายมีรหัสประจำตัวเฉพาะของตัวเอง ซึ่งแสดงเป็นตัวระบุวัตถุ (OID)
@@ -74,38 +70,41 @@ Notation One (ASN.1)
 #iiii นามสกุลไฟล์ที่ใช้กันทั่วไปสำหรับใบรับรอง X.509
 มีหลายประเภทนามสกุลไฟล์เหล่านี้ยังใช้สำหรับข้อมูลอื่น ๆ เช่น คีย์ส่วนตัวด้วย

- `.pem` -- (อีเมลอิเล็กทรอนิกส์ที่เพิ่มความเป็นส่วนตัว) ใบรับรอง DER ที่เข้ารหัส Base64
+#[
+  #set enum(indent: 9.75em)
+  + `.pem` -- (อีเมลอิเล็กทรอนิกส์ที่เพิ่มความเป็นส่วนตัว) ใบรับรอง DER ที่เข้ารหัส Base64
  แนบระหว่าง `-----BEGIN CERTIFICATE-----` และ `-----END CERTIFICATE-----`
- `.cer`, `.crt`, `.der` -- โดยปกติจะอยู่ในรูปแบบไบนารี DER แต่ใบรับรองที่เข้ารหัส Base64
+ `.cer`, `.crt`, `.der` -- โดยปกติจะอยู่ในรูปแบบไบนารี DER แต่ใบรับรองที่เข้ารหัส Base64
  ก็เป็นเรื่องปกติเช่นกัน (ดู `.pem` ด้านบน)
- `.p8`, `.p8e`, `.pk8` -- คีย์ส่วนตัวที่ส่งออกตามที่ระบุไว้ใน PKCS\#8 อาจอยู่ในรูปแบบ DER หรือ
+ `.p8`, `.p8e`, `.pk8` -- คีย์ส่วนตัวที่ส่งออกตามที่ระบุไว้ใน PKCS\#8 อาจอยู่ในรูปแบบ DER หรือ
  PEM ที่ขึ้นต้นด้วย `-----BEGIN PRIVATE KEY-----` คีย์ที่เข้ารหัสจะขึ้นต้นด้วย
  `-----BEGIN ENCRYPTED PRIVATE KEY-----` และอาจมี `.p8e` เป็นนามสกุลไฟล์
- `.p10`, `.csr` -- PKCS\#10 เป็นคำขอลงนามใบรับรอง (CSR) ในรูปแบบ PEM ขึ้นต้นด้วย
+ `.p10`, `.csr` -- PKCS\#10 เป็นคำขอลงนามใบรับรอง (CSR) ในรูปแบบ PEM ขึ้นต้นด้วย
  `-----BEGIN CERTIFICATE REQUEST-----` แบบฟอร์มเหล่านี้สร้างขึ้นเพื่อส่งไปยังผู้ออกใบรับรอง
  (CA) แบบฟอร์มประกอบด้วยรายละเอียดสำคัญของใบรับรองที่ร้องขอ เช่น ชื่อสามัญ (/CN), หัวเรื่อง,
  องค์กร, รัฐ, ประเทศ รวมถึงคีย์สาธารณะของใบรับรองที่ต้องการให้ลงนาม
  คีย์เหล่านี้จะได้รับการลงนามโดย CA และใบรับรองจะถูกส่งกลับคืน ใบรับรองที่ส่งคืนคือใบรับรอง
  สาธารณะ (ซึ่งมีคีย์สาธารณะแต่ไม่มีคีย์ส่วนตัว) ซึ่งตัวใบรับรองเองสามารถอยู่ในรูปแบบต่างๆ
  ได้หลายรูปแบบ แต่โดยปกติจะเป็น `.p7r`
- `.p7r` -- คำตอบ ของ PKCS\#7 ต่อ CSR ประกอบด้วยใบรับรองที่เพิ่งลงนาม และใบรับรองของ CA
+ `.p7r` -- คำตอบ ของ PKCS\#7 ต่อ CSR ประกอบด้วยใบรับรองที่เพิ่งลงนาม และใบรับรองของ CA
  เอง
- `.p7s` -- ลายเซ็นดิจิทัล PKCS\#7 อาจมีไฟล์หรือข้อความที่ลงนามต้นฉบับ ใช้ใน S/MIME
+ `.p7s` -- ลายเซ็นดิจิทัล PKCS\#7 อาจมีไฟล์หรือข้อความที่ลงนามต้นฉบับ ใช้ใน S/MIME
  สำหรับการลงนามในอีเมลกำหนดไว้ใน RFC 2311
- `.p7m` -- PKCS\#7 (SignedData, EnvelopedData) ข้อความ เช่น ไฟล์ที่เข้ารหัส
+ `.p7m` -- PKCS\#7 (SignedData, EnvelopedData) ข้อความ เช่น ไฟล์ที่เข้ารหัส
  ("enveloped") ข้อความ หรือจดหมายอีเมล MIME กำหนดไว้ใน RFC 2311
- `.p7c` -- โครงสร้าง SignedData แบบ "certs-only" ของ PKCS\#7 ที่เสื่อมลง
+ `.p7c` -- โครงสร้าง SignedData แบบ "certs-only" ของ PKCS\#7 ที่เสื่อมลง
  โดยไม่มีข้อมูลใดๆ ให้ลงนาม กำหนดไว้ใน RFC 2311
- `.p7b` -- โครงสร้าง SignedData ของ PKCS\#7 ที่ไม่มีข้อมูล มีเพียงใบรับรองแบบบันเดิลหรือ CRL
+ `.p7b` -- โครงสร้าง SignedData ของ PKCS\#7 ที่ไม่มีข้อมูล มีเพียงใบรับรองแบบบันเดิลหรือ CRL
  (ไม่ค่อยเกิดขึ้น) แต่ไม่มีคีย์ส่วนตัว ใช้รูปแบบ DER หรือ BER หรือ PEM ที่ขึ้นต้นด้วย
  `-----BEGIN PKCS7-----` รูปแบบที่ Windows ใช้สำหรับการแลกเปลี่ยนใบรับรอง รองรับโดย Java
  แต่มักใช้นามสกุล `.keystore` แทน ซึ่งแตกต่างจากใบรับรองแบบ `.pem`
  รูปแบบนี้มีวิธีที่กำหนดไว้สำหรับการรวมใบรับรองเส้นทางการรับรอง
- `.p12`, `.pfx`, `.pkcs12` -- PKCS\#12 อาจมีใบรับรอง (สาธารณะ) และคีย์ส่วนตัว
+ `.p12`, `.pfx`, `.pkcs12` -- PKCS\#12 อาจมีใบรับรอง (สาธารณะ) และคีย์ส่วนตัว
  (ป้องกันด้วยรหัสผ่าน) ในไฟล์เดียว `.pfx` - _Personal Information eXchange_ PFX
  ซึ่งเป็นรุ่นก่อนของ PKCS\#12 (โดยปกติจะมีข้อมูลในรูปแบบ PKCS\#12 เช่น ไฟล์ PFX ที่สร้างใน IIS)
- `.crl` -- รายการเพิกถอนใบรับรอง (CRL)
+ `.crl` -- รายการเพิกถอนใบรับรอง (CRL)
  หน่วยงานที่ออกใบรับรองจะจัดทำรายการเหล่านี้ขึ้นเพื่อใช้ในการเพิกถอนใบรับรองก่อนหมดอายุ
+]

 #iiii PKCS\#7 เป็นมาตรฐานสำหรับการลงนามหรือเข้ารหัสข้อมูล (เรียกอย่างเป็นทางการว่า
 "enveloping")
@@ -3,23 +3,23 @@

 = X.690 (การเข้ารหัส DER)

-#iii X.690 เป็น มาตรฐาน ITU-T ที่ระบุรูปแบบการเข้ารหัส ASN.1 หลายรูปแบบ:
+#iii X.690 เป็น มาตรฐาน ITU-T ที่ระบุรูปแบบการเข้ารหัส ASN.1 หลายรูปแบบ

- กฎการเข้ารหัสพื้นฐาน (BER)
- กฎการเข้ารหัสแบบ Canonical (CER)
- กฎการเข้ารหัสที่โดดเด่น (DER)
+== กฎการเข้ารหัสพื้นฐาน (BER)

-กฎการเข้ารหัสพื้นฐาน (BER) คือกฎดั้งเดิมที่วางไว้โดยมาตรฐาน ASN.1
+#iiii กฎการเข้ารหัสพื้นฐาน (BER) คือกฎดั้งเดิมที่วางไว้โดยมาตรฐาน ASN.1
 สำหรับการเข้ารหัสข้อมูลในรูปแบบไบนารี กฎเหล่านี้ ซึ่งเรียกรวมกันว่าไวยากรณ์การถ่ายโอนในภาษา ASN.1
 กำหนดจำนวนอ็อกเท็ต (ไบต์ 8 บิต) ที่ใช้ในการเข้ารหัสข้อมูล

-#iii โดยโครงงานนี้ใช้ใบรับรองในรูปแบบการเข้ารหัส DER ซึ่ง DER (Distinguished Encoding
+== กฎการเข้ารหัสที่โดดเด่น (DER)
+
+#iiii โดยโครงงานนี้ใช้ใบรับรองในรูปแบบการเข้ารหัส DER ซึ่ง DER (Distinguished Encoding
 Rules) เป็น BER
 แบบจำกัดรูปแบบหนึ่งสำหรับการสร้างไวยากรณ์การถ่ายโอนข้อมูลที่ชัดเจนสำหรับโครงสร้างข้อมูลที่อธิบายโดย
 ASN.1 เช่นเดียวกับ CER การเข้ารหัส DER ถือเป็นการเข้ารหัส BER ที่ถูกต้อง DER เหมือนกับ BER
 โดยตัดตัวเลือกของผู้ส่งออกทั้งหมด ยกเว้นตัวเลือกเดียว

-#iii DER เป็นส่วนย่อยของ BER ที่ให้วิธีการเข้ารหัสค่า ASN.1 เพียงวิธีเดียว DER
+#iiii DER เป็นส่วนย่อยของ BER ที่ให้วิธีการเข้ารหัสค่า ASN.1 เพียงวิธีเดียว DER
 มีไว้สำหรับสถานการณ์ที่จำเป็นต้องมีการเข้ารหัสเฉพาะ เช่น
 ในการเข้ารหัสลับและช่วยให้มั่นใจว่าโครงสร้างข้อมูลที่จำเป็นต้องมีการลงนามดิจิทัลจะสร้างการแสดงแบบอนุกรมที่ไม่ซ้ำกัน
 DER ถือเป็นรูปแบบมาตรฐานของ BER ตัวอย่างเช่นใน BER ค่าบูลีน true
@@ -0,0 +1,258 @@
+#import "../PageTemplate.typ": *
+
+== สร้างไฟล์แอปพลิเคชันด้วยตนเอง
+
+#i โครงงานนี้ใช้แอปพลิเคชันที่สร้างขึ้นมาเอง โดยในการพัฒนาแอปพลิเคชัน
+อย่างน้อยต้องมีส่วนประกอบดังกล่าวก่อน
+
+- Flutter
+- Git (ซึ่งคุณจะติดตั้งแล้วหากคุณทำตาม@writingFirmware)
+
+#i อย่างไรก็ตาม Flutter มีข้อจำกัดว่า มีเพียง Android
+เท่านั้นที่ไม่ว่าแพลตฟอร์มไหนก็จะสามารถคอมไพล์ไฟล์ `.apk` ออกมาได้ ดังนั้น
+การสร้างแอปพลิเคชันสำหรับ Linux ต้องทำบน Linux เท่านั้น และการสร้างแอปพลิเคชันสำหรับ Windows
+ต้องทำบน Windows เท่านั้น
+
+=== การติดตั้งโปรแกรมเขียนโคด
+
+#iii จริง ๆ แล้วนั้น Flutter สามารถทำงานกับโปรแกรมเขียนโคดใดก็ได้
+แต่มีโปรแกรมเหล่านี้ที่อาจมีประสบการณ์การพัฒนาที่ดีกว่าโปรแกรมอื่น:
+
+- Visual Studio Code (VS Code)
+- Android Studio
+- JetBrains IntelliJ
+- Firebase Studio
+
+#iii โครงงานนี้ใช้โปรแกรมเขียนโคด Android Studio เป็นหลักเนื่องจากแอปพลิเคชันโครงงานมี
+Android เป็นเป้าหมายหลัก และ Android SDK สามารถจัดการได้ง่ายกว่าใน Android Studio
+
+#iii การติดตั้ง Flutter สามารถทำได้สองวิธีด้วยกัน คือการติดตั้งผ่าน Visual Studio Code (VS
+Code) และการติดตั้งด้วยตนเอง โดยหากต้องการใช้ VS Code เป็นโปรแกรมเขียนโคดอยู่แล้ว
+สามารถติดตั้งผ่าน VS Code ได้เลย แต่ก่อนอื่น ต้องทำการติดตั้งโปรแกรมและไลบรารีพื้นฐานที่จำเป็นสำหรับ
+Flutter ก่อน
+
+#pagebreak()
+
+=== การติดตั้งโปรแกรมและไลบรารีที่จำเป็น
+
+#[
+  #set enum(indent: 5.5em)
+  + Windows: ติดตั้ง Git สำหรับ Windows ซึ่งคุณสามารถดูขั้นตอนการติดตั้งได้ที่
+    https://git-scm.com/install/windows หรือเพียงแค่ใช้คำสั่งด้านล่าง
+    #afigure(
+      ```sh
+      winget install --id Git.Git -e --source winget
+      ```,
+      kind: image,
+      caption: [คำสั่งในการติดตั้ง Git],
+    )
+  + Linux: โปรดดู@flLinuxDetails สำหรับรายละเอียดแพคเกจและคำสั่งที่ต้องใช้สำหรับระบบต่าง ๆ
+
+  + macOS: ใช้คำสั่งต่อไปนี้ในการติดตั้งเครื่องมือ Xcode ต่าง ๆ รวมถึง Git
+    #afigure(
+      ```sh
+      xcode-select --install
+      ```,
+      kind: image,
+      caption: [คำสั่งในการติดตั้งเครื่องมือ Xcode],
+    )
+]
+
+=== การติดตั้งผ่าน Visual Studio Code
+
+#block(inset: (left: 4.5em))[
+  #set enum(indent: 1em)
+  + เปิด VSCode
+  + ติดตั้งส่วนขยาย Flutter \
+    อยู่ภายใต้ ID `Dart-Code.flutter` ทั้งบน Visual Studio Marketplace และ OpenVSX
+  + ติดตั้ง Flutter ด้วย VS Code
+    + เปิด Command Palette ด้วยเมนู *View* > *Command Palette* หรือกด Ctrl + Shift +
+      P
+    + ใน Command Palette พิมพ์ `flutter`.
+    + เลือก *Flutter: New Project*
+    + VS Code จะให้คุณเลือก Flutter SDK บนคอมพิวเตอร์ของคุณ เลือก *Download SDK*
+    + เมือหน้าไดอะลอก *Select Folder for Flutter SDK* แสดงขึ้น เลือกสถานที่ที่คุณอยากติดตั้ง
+      Flutter
+    + คลิก *Clone Flutter* \
+      ในระหว่างการดาวน์โหลด VS Code จะแสดงการแจ้งเตือนนี้:
+      ```
+      Downloading the Flutter SDK. This may take a few minutes.
+      ```
+      การดาวน์โหลดนี้จะใช้เวลาสองสามนาที หากคุณเชื่อว่าการดาวน์โหลดหยุดชะงัก คุณสามารถคลิก
+      *Cancel* แล้วเริ่มต้นการติดตั้งใหม่ได้
+    + คลิก *Add SDK to PATH* \
+      เมื่อเสร็จสิ้น จะมีการแจ้งเตือน
+      ```
+      The Flutter SDK was added to your PATH
+      ```
+    + VS Code อาจแสดงการแจ้งเตือนเกี่ยวกับการเก็บข้อมูลของ Google หากคุณยินยอม คลิก *OK*
+    + เพื่อความแน่ใจ กรุณาปิดเทอร์มินัลทุกหน้าต่างหรือรีสตาร์ท VS Code เพื่อให้แน่ใจว่า Flutter
+      จะสามารถใช้ผ่านเทอร์มินัลได้
+  + เมื่อเสร็จสิ้น ใช้คำสั่ง `flutter doctor -v` ในเทอร์มินัลที่คุณเลือกเพื่อตรวจสอบการติดตั้ง
+    Flutter ของคุณ \
+    หากคำสั่งไม่เจอหรือเกิดข้อผิดพลาดขึ้น ตรวจสอบ
+    https://docs.flutter.dev/install/troubleshoot สำหรับข้อมูลเพิ่มเติม
+]
+
+=== การติดตั้งด้วยตนเอง
+
+#iii แนะนำให้ทำตาม https://docs.flutter.dev/install/manual#install-flutter
+เนื่องจากกระบวนการนี้ต้องใช้ข้อมูลที่ใหม่ล่าสุด
+
+1. ดาวน์โหลด Flutter (สามารถหาปุ่มดาวน์โหลดได้จากลิงก์ด้านบน)
+2. สร้างโฟลเดอร์สำหรับเก็บ Flutter SDK
+3. ทำการแตกไฟล์ที่ดาวน์โหลดมา
+4. เพิ่ม Flutter เข้าไปยัง PATH ของคุณ (วิธีการขึ้นอยู่กับระบบปฏิบัติการ)
+5. ยืนยันความถูกต้องของการติดตั้งของคุณด้วยคำสั่ง `flutter doctor -v`
+
+=== ข้อมูลเฉพาะแพลตฟอร์ม
+
+==== Android <flAndroid>
+
+#iiii ในการพัฒนาแอปพลิเคชัน Android โดยใช้เฟรมเวิร์ก Flutter
+จำเป็นต้องใช้ส่วนประกอบเครื่องมือพัฒนา Android ดังนี้
+
+- Android SDK (API Level 36 ณ เวลาที่พิมพ์)
+- Android SDK Build-Tools
+- Android SDK Command-line Tools
+- Android SDK Platform-Tools
+- Android Emulator (ไม่บังคับ)
+
+โดยแนะนำให้จัดการและติดตั้งเครื่องมือเหล่านี้ผ่าน Android Studio
+
+#iiii ในการติดตั้ง Android SDK ควรติดตั้ง Android SDK
+ล่าสุดถึงแม้ว่าอุปกรณ์ของคุณจะใช้เวอร์ชันที่เก่ากว่านั้น
+เพื่อความมั่นใจว่าแอปพลิเคชันจะสามารถใช้กับอุปกรณ์ที่ใหม่ล่าสุดได้
+
+#iiii แอปพลิเคชัน Android จะมี SDK/API level เป้าหมาย (Target SDK/API level) และ
+SDK/API level ขั้นต่ำ (Minimum SDK/API level) โครงงานนี้ ณ เวลาที่พิมพ์ ใช้ API level
+เป้าหมาย 36 (Android 16) และ API level ขั้นต่ำ 24 (Android 7) ซึ่งรวมกันแล้ว
+แอปพลิเคชัน#jb Android จะสามารถติดตั้งได้บนระบบตั้งแต่ API level ขั้นต่ำจนถึง API level
+เป้าหมาย หรือก็คือ แอปพลิเคชันในโครงงานนี้สามารถติดตั้งได้ตั้งแต่บนระบบ Android 7 ถึง Android 16
+นั่นเอง
+
+===== Java/Kotlin
+
+#iiiii Java และ Kotlin เป็นภาษาสำคัญสำหรับการพัฒนาแอปพลิเคชัน Android ถึงอย่างไรก็ตาม
+แอปพลิเคชัน Flutter นั้นถูกเขียนด้วยภาษา Dart แต่ยังจำเป็นต้องมีโคด Java และ Kotlin
+เล็กน้อยเพื่อเริ่มต้นแอปพลิเคชัน Flutter
+
+#iiiii โดยปกติแล้ว Flutter จะสร้างโคดพื้นฐานขึ้นมาให้สำหรับการเริ่มแอปพลิเคชันแบบพื้นฐาน
+ดังนั้นจึงไม่จำเป็นต้องมีการเขียนโคด Java หรือ Kotlin เอง แต่ในบางกรณี
+อาจต้องเขียนโคดเพิ่มเองหากมีความต้องการเข้าถึงฟีเจอร์พื้นฐานระบบที่ Flutter ไม่มี API
+เพื่อให้เข้าถึงได้และไม่มีแพคเกจเพื่อรองรับฟีเจอร์ที่ต้องการ
+
+#iiiii โครงการนี้ใช้ Java 21 (JetBrains Runtime/Azul Zulu OpenJDK)
+เป็นหลักในการทำงานกับ Gradle แต่แอปพลิเคชัน Android ที่ผลิตออกมานั้น
+เพื่อให้เข้ากับเวอร์ชันที่เก่ากว่าของระบบปฏิบัติการได้ ใช้ Java 11
+
+===== Gradle
+
+#iiiii Gradle เป็นเครื่องมือสร้างระบบอัตโนมัติสำหรับการพัฒนาซอฟต์แวร์หลายภาษา จัดการงานต่าง ๆ
+เช่น การคอมไพล์ การแพ็คเกจ การทดสอบ การปรับใช้ และการเผยแพร่ ภาษาที่รองรับ ได้แก่ Java
+(รวมถึงภาษา Kotlin, Groovy, Scala ที่ใช้ JDK), C/C++ และ JavaScript Gradle
+พัฒนาต่อยอดจากแนวคิดของ Apache Ant และ Apache Maven และนำเสนอภาษาเฉพาะโดเมนที่ใช้
+Groovy และ Kotlin ซึ่งต่างจากการกำหนดค่าโครงการที่ใช้ XML ที่ Maven ใช้ Gradle
+ใช้กราฟแบบอะไซคลิกกำกับทิศทางเพื่อจัดการการอ้างอิง กราฟนี้ใช้เพื่อกำหนดลำดับของงานที่ควรดำเนินการ
+Gradle ทำงานบน Java Virtual Machine
+
+#iiiii Gradle คือเครื่องมือหลักที่ใช้ในการจัดการโปรเจกต์ Java ส่วนใหญ่ รวมถึงโปรเจกต์ Android
+โดยในโครงการนี้ จะใช้ Gradle เวอร์ชัน 8.14.3 เป็นหลัก
+
+#iiiii โดยปกติแล้ว ผู้พัฒนานั้นไม่มีความจำเป็นที่จะต้องแตะต้อง Gradle ด้วยตนเอง และ Flutter
+จะทำการจัดการเอง แต่หากมีความจำเป็นต้องใช้คำสั่ง Gradle ด้วยตนเอง จะมีสคริปต์ `gradlew` (หรือ
+`gradlew.bat` สำหรับผู้ใช้ Windows) ภายในโฟลเดอร์ `android` ของโปรเจกต์ Flutter
+เสมอเพื่อเรียกใช้ Gradle ที่ถูกดาวน์โหลดมาสำหรับโปรเจกต์นั้น ๆ
+
+==== Linux <flLinuxDetails>
+
+#iiii เช่นเดียวกับ Android ที่กล่าวไปข้างต้น Flutter
+มีการสร้างโคดสำหรับการเปิดแอปพลิเคชันแบบพื้นฐาน แต่สำหรับ Linux แล้วนั้น Flutter ใช้โคด C++
+และเฟรมเวิร์ก CMake ในการสร้างรากฐานของแอปพลิเคชัน
+
+#iiii ในการพัฒนาแอปพลิเคชันสำหรับ Linux ต้องติดตั้งโปรแกรมเพิ่มเติม#jb (build dependencies)
+ขยายความคือ ด้านบนคือสิ่งที่จำเป็นหากมีระบบอื่นเป็นเป้าหมาย แต่หากต้องการพัฒนาแอปพลิเคชัน Linux
+ต้องติดตั้งโปรแกรมในรายการหน้าถัดไปเพิ่ม
+
+#pagebreak()
+
+#grid(
+  columns: 2,
+  column-gutter: 1in,
+  [
+    - GTK 3 (ไลบรารีสำหรับการพัฒนา)
+    - pkg-config
+    - ไลบรารี GNU Standard C++ v3
+  ],
+  [
+    - Clang
+    - CMake
+    - Ninja
+  ],
+)
+
+#iiii การติดตั้งไลบรารีและโปรแกรมที่กล่าวไปข้างต้นจะแตกต่างกันไปแต่ละการแจกจ่าย Linux และ
+Flutter ใช้ไลบรารีพื้นฐานดังกล่าวในการทำงานของแอปพลิเคชัน (runtime dependencies)
+
+- GTK 3
+- blkid
+- LZMA
+
+แต่โดยทั่วไปแล้ว ไลบรารีเหล่านี้ควรถูกติดตั้งมาอยู่แล้วหากคุณใช้ graphical desktop ทั่วไป
+
+===== Debian
+
+#afigure(
+  ```sh
+  # Development dependencies:
+  sudo apt install curl git unzip xz-utils zip libglu1-mesa
+
+  # Linux build dependencies:
+  sudo apt install clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-12-dev
+
+  # Runtime dependencies:
+  sudo apt install libgtk-3-0 libblkid1 liblzma5
+  ```,
+  kind: image,
+  caption: [คำสั่งในการติดตั้งรายการแพคเกจต่าง ๆ บน Debian],
+)
+
+===== Fedora Linux
+
+#afigure(
+  ```sh
+  # Development dependencies:
+  sudo dnf install curl git unzip xz zip mesa-libglu
+
+  # Linux build dependencies:
+  sudo dnf install clang cmake ninja-build pkgconf gtk3
+
+  # Runtime dependencies:
+  sudo dnf install gtk3 libblkid xz
+  ```,
+  kind: image,
+  caption: [คำสั่งในการติดตั้งรายการแพคเกจต่าง ๆ บน Fedora Linux],
+)
+
+===== Arch Linux
+
+#afigure(
+  ```sh
+  # Development dependencies:
+  sudo pacman -S --needed curl git unzip xz zip glu
+
+  # Linux build dependencies:
+  sudo pacman -S --needed clang cmake ninja pkgconf gtk3
+
+  # Runtime dependencies:
+  sudo pacman -S --needed util-linux-libs xz gtk3
+  ```,
+  kind: image,
+  caption: [คำสั่งในการติดตั้งรายการแพคเกจต่าง ๆ บน Arch Linux],
+)
+
+==== macOS/iOS
+
+#iiii การพัฒนาแอปพลิเคชันสำหรับ macOS และ iOS นั้นต้องทำบน#jb macOS
+เท่านั้นและจำเป็นต้องพึ่งพาเครื่องมือ Xcode แต่เนื่องจากในโครงงานนี้ไม่มีผู้ใช้ macOS
+จึงไม่สามารถสร้างไบนารีสำหรับ macOS และ iOS ออกมาได้ และไม่ใช่เป้าหมายของโครงงานนี้เช่นกัน
@@ -344,260 +344,7 @@ https://gitskette.dailitation.xyz/linesofcodes/liteauth-firmware32 และท

 #iiii *หมายเหตุ:* โปรดใช้คำสั่งประเภท `pio run` ในโฟลเดอร์ของโปรเจกต์

-=== สร้างไฟล์แอปพลิเคชันด้วยตนเอง
-
-#iii โครงงานนี้ใช้แอปพลิเคชันที่สร้างขึ้นมาเอง โดยในการพัฒนาแอปพลิเคชัน
-อย่างน้อยต้องมีส่วนประกอบดังกล่าวก่อน
-
- Flutter
- Git (ซึ่งคุณจะติดตั้งแล้วหากคุณทำตาม@writingFirmware)
-
-#iii อย่างไรก็ตาม Flutter มีข้อจำกัดว่า มีเพียง Android
-เท่านั้นที่ไม่ว่าแพลตฟอร์มไหนก็จะสามารถคอมไพล์ไฟล์ `.apk` ออกมาได้ ดังนั้น
-การสร้างแอปพลิเคชันสำหรับ Linux ต้องทำบน Linux เท่านั้น และการสร้างแอปพลิเคชันสำหรับ Windows
-ต้องทำบน Windows เท่านั้น
-
-==== การติดตั้งโปรแกรมเขียนโคด
-
-#iiiii จริง ๆ แล้วนั้น Flutter สามารถทำงานกับโปรแกรมเขียนโคดใดก็ได้
-แต่มีโปรแกรมเหล่านี้ที่อาจมีประสบการณ์การพัฒนาที่ดีกว่าโปรแกรมอื่น:
-
- Visual Studio Code (VS Code)
- Android Studio
- JetBrains IntelliJ
- Firebase Studio
-
-#iii โครงงานนี้ใช้โปรแกรมเขียนโคด Android Studio เป็นหลักเนื่องจากแอปพลิเคชันโครงงานมี
-Android เป็นเป้าหมายหลัก และ Android SDK สามารถจัดการได้ง่ายกว่าใน Android Studio
-
-#iii การติดตั้ง Flutter สามารถทำได้สองวิธีด้วยกัน คือการติดตั้งผ่าน Visual Studio Code (VS
-Code) และการติดตั้งด้วยตนเอง โดยหากต้องการใช้ VS Code เป็นโปรแกรมเขียนโคดอยู่แล้ว
-สามารถติดตั้งผ่าน VS Code ได้เลย แต่ก่อนอื่น ต้องทำการติดตั้งโปรแกรมและไลบรารีพื้นฐานที่จำเป็นสำหรับ
-Flutter ก่อน
-
-#pagebreak()
-
-==== การติดตั้งโปรแกรมและไลบรารีที่จำเป็น
-
-#[
-  #set enum(indent: 9.25em)
-  + Windows: ติดตั้ง Git สำหรับ Windows ซึ่งคุณสามารถดูขั้นตอนการติดตั้งได้ที่
-    https://git-scm.com/install/windows หรือเพียงแค่ใช้คำสั่งด้านล่าง
-    #afigure(
-      ```sh
-      winget install --id Git.Git -e --source winget
-      ```,
-      kind: image,
-      caption: [คำสั่งในการติดตั้ง Git],
-    )
-  + Linux: โปรดดู@flLinuxDetails สำหรับรายละเอียดแพคเกจและคำสั่งที่ต้องใช้สำหรับระบบต่าง ๆ
-
-  + macOS: ใช้คำสั่งต่อไปนี้ในการติดตั้งเครื่องมือ Xcode ต่าง ๆ รวมถึง Git
-    #afigure(
-      ```sh
-      xcode-select --install
-      ```,
-      kind: image,
-      caption: [คำสั่งในการติดตั้งเครื่องมือ Xcode],
-    )
-]
-
-==== การติดตั้งผ่าน Visual Studio Code
-
-#block(inset: (left: 8.25em))[
-  #set enum(indent: 1em)
-  + เปิด VSCode
-  + ติดตั้งส่วนขยาย Flutter \
-    อยู่ภายใต้ ID `Dart-Code.flutter` ทั้งบน Visual Studio Marketplace และ OpenVSX
-  + ติดตั้ง Flutter ด้วย VS Code
-    + เปิด Command Palette ด้วยเมนู *View* > *Command Palette* หรือกด Ctrl + Shift +
-      P
-    + ใน Command Palette พิมพ์ `flutter`.
-    + เลือก *Flutter: New Project*
-    + VS Code จะให้คุณเลือก Flutter SDK บนคอมพิวเตอร์ของคุณ เลือก *Download SDK*
-    + เมือหน้าไดอะลอก *Select Folder for Flutter SDK* แสดงขึ้น เลือกสถานที่ที่คุณอยากติดตั้ง
-      Flutter
-    + คลิก *Clone Flutter* \
-      ในระหว่างการดาวน์โหลด VS Code จะแสดงการแจ้งเตือนนี้:
-      ```
-      Downloading the Flutter SDK. This may take a few minutes.
-      ```
-      การดาวน์โหลดนี้จะใช้เวลาสองสามนาที หากคุณเชื่อว่าการดาวน์โหลดหยุดชะงัก คุณสามารถคลิก
-      *Cancel* แล้วเริ่มต้นการติดตั้งใหม่ได้
-    + คลิก *Add SDK to PATH* \
-      เมื่อเสร็จสิ้น จะมีการแจ้งเตือน
-      ```
-      The Flutter SDK was added to your PATH
-      ```
-    + VS Code อาจแสดงการแจ้งเตือนเกี่ยวกับการเก็บข้อมูลของ Google หากคุณยินยอม คลิก *OK*
-    + เพื่อความแน่ใจ กรุณาปิดเทอร์มินัลทุกหน้าต่างหรือรีสตาร์ท VS Code เพื่อให้แน่ใจว่า Flutter
-      จะสามารถใช้ผ่านเทอร์มินัลได้
-  + เมื่อเสร็จสิ้น ใช้คำสั่ง `flutter doctor -v` ในเทอร์มินัลที่คุณเลือกเพื่อตรวจสอบการติดตั้ง
-    Flutter ของคุณ \
-    หากคำสั่งไม่เจอหรือเกิดข้อผิดพลาดขึ้น ตรวจสอบ
-    https://docs.flutter.dev/install/troubleshoot สำหรับข้อมูลเพิ่มเติม
-]
-
-==== การติดตั้งด้วยตนเอง
-
-#iiii แนะนำให้ทำตาม https://docs.flutter.dev/install/manual#install-flutter
-เนื่องจากกระบวนการนี้ต้องใช้ข้อมูลที่ใหม่ล่าสุด
-
-1. ดาวน์โหลด Flutter (สามารถหาปุ่มดาวน์โหลดได้จากลิงก์ด้านบน)
-2. สร้างโฟลเดอร์สำหรับเก็บ Flutter SDK
-3. ทำการแตกไฟล์ที่ดาวน์โหลดมา
-4. เพิ่ม Flutter เข้าไปยัง PATH ของคุณ (วิธีการขึ้นอยู่กับระบบปฏิบัติการ)
-5. ยืนยันความถูกต้องของการติดตั้งของคุณด้วยคำสั่ง `flutter doctor -v`
-
-==== ข้อมูลเกี่ยวกับแพลตฟอร์ม
-
-===== Android <flAndroid>
-
-#iiiii ในการพัฒนาแอปพลิเคชัน Android โดยใช้เฟรมเวิร์ก Flutter
-จำเป็นต้องใช้ส่วนประกอบเครื่องมือพัฒนา Android ดังนี้
-
- Android SDK (API Level 36 ณ เวลาที่พิมพ์)
- Android SDK Build-Tools
- Android SDK Command-line Tools
- Android SDK Platform-Tools
- Android Emulator (ไม่บังคับ)
-
-โดยแนะนำให้จัดการและติดตั้งเครื่องมือเหล่านี้ผ่าน Android Studio
-
-#iiiii ในการติดตั้ง Android SDK ควรติดตั้ง Android SDK
-ล่าสุดถึงแม้ว่าอุปกรณ์ของคุณจะใช้เวอร์ชันที่เก่ากว่านั้น
-เพื่อความมั่นใจว่าแอปพลิเคชันจะสามารถใช้กับอุปกรณ์ที่ใหม่ล่าสุดได้
-
-#iiiii แอปพลิเคชัน Android จะมี SDK/API level เป้าหมาย (Target SDK/API level) และ
-SDK/API level ขั้นต่ำ (Minimum SDK/API level) โครงงานนี้ ณ เวลาที่พิมพ์ ใช้ API level
-เป้าหมาย 36 (Android 16) และ API level ขั้นต่ำ 24 (Android 7) ซึ่งรวมกันแล้ว
-แอปพลิเคชัน#jb Android จะสามารถติดตั้งได้บนระบบตั้งแต่ API level ขั้นต่ำจนถึง API level
-เป้าหมาย หรือก็คือ แอปพลิเคชันในโครงงานนี้สามารถติดตั้งได้ตั้งแต่บนระบบ Android 7 ถึง Android 16
-นั่นเอง
-
-====== Java/Kotlin
-
-#iiiiii Java และ Kotlin เป็นภาษาสำคัญสำหรับการพัฒนาแอปพลิเคชัน Android ถึงอย่างไรก็ตาม
-แอปพลิเคชัน Flutter นั้นถูกเขียนด้วยภาษา Dart แต่ยังจำเป็นต้องมีโคด Java และ Kotlin
-เล็กน้อยเพื่อเริ่มต้นแอปพลิเคชัน Flutter
-
-#iiiiii โดยปกติแล้ว Flutter จะสร้างโคดพื้นฐานขึ้นมาให้สำหรับการเริ่มแอปพลิเคชันแบบพื้นฐาน
-ดังนั้นจึงไม่จำเป็นต้องมีการเขียนโคด Java หรือ Kotlin เอง แต่ในบางกรณี
-อาจต้องเขียนโคดเพิ่มเองหากมีความต้องการเข้าถึงฟีเจอร์พื้นฐานระบบที่ Flutter ไม่มี API
-เพื่อให้เข้าถึงได้และไม่มีแพคเกจเพื่อรองรับฟีเจอร์ที่ต้องการ
-
-#iiiiii โครงการนี้ใช้ Java 21 (JetBrains Runtime/Azul Zulu OpenJDK)
-เป็นหลักในการทำงานกับ Gradle แต่แอปพลิเคชัน Android ที่ผลิตออกมานั้น
-เพื่อให้เข้ากับเวอร์ชันที่เก่ากว่าของระบบปฏิบัติการได้ ใช้ Java 11
-
-====== Gradle
-
-#iiiiii Gradle เป็นเครื่องมือสร้างระบบอัตโนมัติสำหรับการพัฒนาซอฟต์แวร์หลายภาษา จัดการงานต่าง ๆ
-เช่น การคอมไพล์ การแพ็คเกจ การทดสอบ การปรับใช้ และการเผยแพร่ ภาษาที่รองรับ ได้แก่ Java
-(รวมถึงภาษา Kotlin, Groovy, Scala ที่ใช้ JDK), C/C++ และ JavaScript Gradle
-พัฒนาต่อยอดจากแนวคิดของ Apache Ant และ Apache Maven และนำเสนอภาษาเฉพาะโดเมนที่ใช้
-Groovy และ Kotlin ซึ่งต่างจากการกำหนดค่าโครงการที่ใช้ XML ที่ Maven ใช้ Gradle
-ใช้กราฟแบบอะไซคลิกกำกับทิศทางเพื่อจัดการการอ้างอิง กราฟนี้ใช้เพื่อกำหนดลำดับของงานที่ควรดำเนินการ
-Gradle ทำงานบน Java Virtual Machine
-
-#iiiiii Gradle คือเครื่องมือหลักที่ใช้ในการจัดการโปรเจกต์ Java ส่วนใหญ่ รวมถึงโปรเจกต์ Android
-โดยในโครงการนี้ จะใช้ Gradle เวอร์ชัน 8.14.3 เป็นหลัก
-
-#iiiiii โดยปกติแล้ว ผู้พัฒนานั้นไม่มีความจำเป็นที่จะต้องแตะต้อง Gradle ด้วยตนเอง และ Flutter
-จะทำการจัดการเอง แต่หากมีความจำเป็นต้องใช้คำสั่ง Gradle ด้วยตนเอง จะมีสคริปต์ `gradlew` (หรือ
-`gradlew.bat` สำหรับผู้ใช้ Windows) ภายในโฟลเดอร์ `android` ของโปรเจกต์ Flutter
-เสมอเพื่อเรียกใช้ Gradle ที่ถูกดาวน์โหลดมาสำหรับโปรเจกต์นั้น ๆ
-
-===== Linux <flLinuxDetails>
-
-#iiiii เช่นเดียวกับ Android ที่กล่าวไปข้างต้น Flutter
-มีการสร้างโคดสำหรับการเปิดแอปพลิเคชันแบบพื้นฐาน แต่สำหรับ Linux แล้วนั้น Flutter ใช้โคด C++
-และเฟรมเวิร์ก CMake ในการสร้างรากฐานของแอปพลิเคชัน
-
-#iiiii ในการพัฒนาแอปพลิเคชันสำหรับ Linux ต้องติดตั้งโปรแกรมเพิ่มเติม (build dependencies)
-ขยายความคือ ด้านบนคือสิ่งที่จำเป็นหากมีระบบอื่นเป็นเป้าหมาย แต่หากต้องการพัฒนาแอปพลิเคชัน Linux
-ต้องติดตั้งโปรแกรมในรายการด้านล่างเพิ่ม
-
-#grid(
-  columns: 2,
-  column-gutter: 1in,
-  [
-    - GTK 3 (ไลบรารีสำหรับการพัฒนา)
-    - pkg-config
-    - ไลบรารี GNU Standard C++ v3
-  ],
-  [
-    - Clang
-    - CMake
-    - Ninja
-  ],
-)
-
-#iiiii การติดตั้งไลบรารีและโปรแกรมที่กล่าวไปข้างต้นจะแตกต่างกันไปแต่ละการแจกจ่าย Linux และ
-Flutter ใช้ไลบรารีพื้นฐานดังกล่าวในการทำงานของแอปพลิเคชัน (runtime dependencies)
-
- GTK 3
- blkid
- LZMA
-
-แต่โดยทั่วไปแล้ว ไลบรารีเหล่านี้ควรถูกติดตั้งมาอยู่แล้วหากคุณใช้ graphical desktop ทั่วไป
-
-====== Debian
-
-#afigure(
-  ```sh
-  # Development dependencies:
-  sudo apt install curl git unzip xz-utils zip libglu1-mesa
-
-  # Linux build dependencies:
-  sudo apt install clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-12-dev
-
-  # Runtime dependencies:
-  sudo apt install libgtk-3-0 libblkid1 liblzma5
-  ```,
-  kind: image,
-  caption: [คำสั่งในการติดตั้งรายการแพคเกจต่าง ๆ บน Debian],
-)
-
-====== Fedora Linux
-
-#afigure(
-  ```sh
-  # Development dependencies:
-  sudo dnf install curl git unzip xz zip mesa-libglu
-
-  # Linux build dependencies:
-  sudo dnf install clang cmake ninja-build pkgconf gtk3
-
-  # Runtime dependencies:
-  sudo dnf install gtk3 libblkid xz
-  ```,
-  kind: image,
-  caption: [คำสั่งในการติดตั้งรายการแพคเกจต่าง ๆ บน Fedora Linux],
-)
-
-====== Arch Linux
-
-#afigure(
-  ```sh
-  # Development dependencies:
-  sudo pacman -S --needed curl git unzip xz zip glu
-
-  # Linux build dependencies:
-  sudo pacman -S --needed clang cmake ninja pkgconf gtk3
-
-  # Runtime dependencies:
-  sudo pacman -S --needed util-linux-libs xz gtk3
-  ```,
-  kind: image,
-  caption: [คำสั่งในการติดตั้งรายการแพคเกจต่าง ๆ บน Arch Linux],
-)
-
-===== macOS/iOS
-
-#iiiii การพัฒนาแอปพลิเคชันสำหรับ macOS และ iOS นั้นต้องทำบน#jb macOS
-เท่านั้นและจำเป็นต้องพึ่งพาเครื่องมือ Xcode แต่เนื่องจากในโครงงานนี้ไม่มีผู้ใช้ macOS
-จึงไม่สามารถสร้างไบนารีสำหรับ macOS และ iOS ออกมาได้ และไม่ใช่เป้าหมายของโครงงานนี้เช่นกัน
+#include "BuildApp.typ"

 == การทดสอบ

@@ -3,7 +3,7 @@
  set page(
    paper: "a4",
    margin: (
-      top: 1.5in,
+      top: 4cm,
      left: 1.5in,
      right: 1in,
      bottom: 1in,
@@ -29,15 +29,15 @@
  "assets/nktc.jpg",
  width: 4cm,
  alt: "วิทยาลัยเทคนิคหนองคาย",
-)
+)\

 เครื่องยืนยันตัวตนด้วย NFC

-#v(8em)
+#v(1fr)

 #grid(
  columns: 2,
-  align: (right, left),
+  align: left,
  column-gutter: 1em,
  row-gutter: 0.75em,
  "ประภากร", "ศรีวรสาร",
@@ -45,7 +45,7 @@
  "ศตคุณ", "อุตมะ",
 )

-#v(10em)
+#v(1fr)

 โครงงานนี้เป็นส่วนหนึ่งของ วิชาโครงงานรหัสวิชา 21909-2023 \
 ตามหลักสูตรประกาศนียบัตรวิชาชีพ พุทธศักราช 2567 \
@@ -1,3 +1,6 @@
+#import "PageTemplate.typ": *
+#show: page-theme
+
 = ประวัติย่อผู้จัดทำ

 #place(right, box(stroke: (thickness: 1pt), width: 0.8in, height: 1in))
@@ -7,11 +10,11 @@
  row-gutter: 1em,
  column-gutter: 2em,
  [ชื่อ], [นางสาวประภากร ศรีวรสาร],
-  [เกิด], [วันที่ 2 ตุลาคม พ.ศ.255x],
+  [เกิด], [วันที่ 2 ตุลาคม พ.ศ.2551],
  [ที่อยู่],
  [
-    บ้านเลขที่ ก หมู่ที่ ข ตำบล ค\
-    อำเภอ ง จังหวัด หนองคาย
+    บ้านเลขที่ 192 หมู่ที่ 15 ตำบล ในเมือง\
+    อำเภอ เมืองหนองคาย จังหวัด หนองคาย
  ],
 )

@@ -21,8 +24,8 @@
  columns: 3,
  row-gutter: 1em,
  column-gutter: 2em,
-  [พ.ศ.25xx], [ป.6], [โรงเรียน x],
-  [พ.ศ.25xx], [ม.3], [โรงเรียน y],
+  [พ.ศ.2564], [ป.6], [โรงเรียน อนุบาลหนองคาย],
+  [พ.ศ.2567], [ม.3], [โรงเรียน ปทุมเทพวิทยาคาร],
  [พ.ศ.2569], [ปวช.], [สาขาวิชาช่างเทคนิคคอมพิวเตอร์ วิทยาลัยเทคนิคหนองคาย],
 )

@@ -66,7 +66,11 @@
  )
  set list(indent: 1em)
  show raw.where(block: false): set text(font: "Laksaman", size: 10.5pt)
-  show raw.where(block: true): set block(fill: rgb("#282A36"), inset: 1.5em)
+  show raw.where(block: true): set block(
+    fill: rgb("#282A36"),
+    stroke: black + 2pt,
+    inset: 1.5em,
+  )
  show raw.where(block: true): set raw(theme: "Dracula.tmTheme")
  show raw.where(block: true): set text(
    fill: rgb("#F8F8F2"),
@@ -77,6 +81,8 @@
  show heading: set block(below: 1em)
  show heading.where(level: 1): set text(size: 12pt, weight: "bold")
  show heading.where(level: 1): set align(center)
+  show heading.where(level: 1): set block(below: 2em)
+  show heading.where(level: 2): set block(above: 2em)
  show heading.where(level: 2): set text(weight: "bold")
  show heading: it => {
    if it.level > 2 {
@@ -90,6 +96,66 @@
  }
  show math.equation: set text(font: "Laksaman")
  show table.cell.where(y: 0): strong
+  show image: it => {
+    block(stroke: black + 2pt, it)
+  }
+  show figure.where(kind: "i-figured-table"): set align(start)
+  show figure.where(kind: table): set figure.caption(position: top)
+  show figure.caption: it => {
+    text(weight: "bold")[
+      #it.supplement
+      #it.counter.display(it.numbering)
+    ]
+    it.body
+  }
+  show figure.caption.where(position: bottom): it => place(center, it, dy: 2em)
+  set figure.caption(separator: "")
+  // show figure.where(kind: image): set figure(gap: 2em)
+  show figure.where(kind: image): set block(below: 2.5em)
+  set enum(number-align: start + top)
+  set ref(supplement: "หัวข้อ")
+  doc
+}
+
+#let fake-h1(body) = {
+  align(center, text(body, weight: "bold", size: 12pt))
+}
+
+#let sane-theme(doc) = {
+  set page(
+    paper: "a4",
+    margin: (
+      top: 1.5in,
+      left: 1.5in,
+      right: 1in,
+      bottom: 1in,
+    ),
+    header: context [
+      #h(1fr)
+      #counter(page).display(thai-numbering)
+    ],
+  )
+  set text(
+    lang: "th",
+    font: "Laksaman",
+    size: 10.5pt,
+  )
+  set par(
+    justify: true,
+    justification-limits: (
+      tracking: (min: -1pt, max: 3pt),
+    ),
+    leading: 1em,
+  )
+  set list(indent: 1em)
+  show raw: set text(font: "Cascadia Code")
+  show heading: set text(size: 10.5pt)
+  show heading: set block(below: 1em)
+  show heading.where(level: 1): set text(size: 12pt, weight: "bold")
+  show heading.where(level: 1): set align(center)
+  show heading.where(level: 2): set text(weight: "bold")
+  show math.equation: set text(font: "Laksaman")
+  show table.cell.where(y: 0): strong
  show figure.caption: it => {
    text(weight: "bold")[
      #it.supplement
@@ -91,12 +91,12 @@ wkTls:
 wkC:
    type: Web
    title: C (programming language)
-    date: 2025-11-26
+    date: 2026-1-3
    language: en
    publisher: มูลนิธิวิกิมีเดีย (ภายใต้ CC BY-SA 4.0)
    url:
-        date: 2025-11-30
-        value: https://en.wikipedia.org/w/index.php?title=C_(programming_language)&oldid=1324211766
+        date: 2026-1-5
+        value: https://en.wikipedia.org/w/index.php?title=C_(programming_language)&oldid=1330924334

 wkGcc:
    type: Web
@@ -9,7 +9,17 @@
  ),
 )

-#include "ปก.typ"
+#[
+  #show raw.where(block: false): set text(font: "Laksaman", size: 10.5pt)
+  #show raw.where(block: true): set block(fill: rgb("#282A36"), inset: 1.5em)
+  #show raw.where(block: true): set raw(theme: "Dracula.tmTheme")
+  #show raw.where(block: true): set text(
+    fill: rgb("#F8F8F2"),
+    font: "Cascadia Code",
+    size: 10pt,
+  )
+
+  #include "Cover.typ"

  #counter(page).update(1)
  #show: page-theme
@@ -23,15 +33,34 @@
    show linebreak: [ ]
    link(
      it.element.location(),
-    it.indented(it.prefix(), context [
-      #it.body()
-      #box(width: 1fr, repeat[.])
-      #context thai-numbering(counter(page).at(it.element.location()).first())
-    ]),
+      grid(
+        columns: 3,
+        column-gutter: 1fr,
+        it.indented(it.prefix(), it.body()),
+        h(1em),
+        context thai-numbering(counter(page).at(it.element.location()).first()),
+      ),
    )
  }

+  #[
+    #set page(header: none)
+    #show outline.entry: it => {
+      it
+
+      context {
+        let outline-pages = counter(page).at(it.location()).first()
+        let current-page = counter(page).get().first()
+
+        if current-page > outline-pages {
+          fake-h1("สารบัญ (ต่อ)")
+          v(1em)
+        }
+      }
+    }
    #outline(depth: 2, indent: 3.75em)
+  ]
+

  #pagebreak()

@@ -96,6 +125,7 @@
  }

  #image-credits()
+]

 #include "ภาคผนวก/ภาคผนวก.typ"
 #include "History.typ"
@@ -1,18 +1,26 @@
 #import "../PageTemplate.typ": *
-#show: page-theme

+#[
+  #show: page-theme
  = ภาคผนวก

  == ลิขสิทธิ์เนื้อหาโครงงาน

-#i #sym.copyright พ.ศ. 2568 งานนี้อยู่ภายใต้สัญญาอนุญาต Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) หากต้องการดูรายละเอียดเพิ่มเติมเกี่ยวกับสัญญาอนุญาตนี้ โปรดไปที่ https://creativecommons.org/licenses/by-sa/4.0/
+  #i #sym.copyright พ.ศ. 2568 งานนี้อยู่ภายใต้สัญญาอนุญาต Creative Commons
+  Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
+  หากต้องการดูรายละเอียดเพิ่มเติมเกี่ยวกับสัญญาอนุญาตนี้ โปรดไปที่
+  https://creativecommons.org/licenses/by-sa/4.0/

-#i นอกจากที่กล่าวถึงในบรรณานุกรมภาพแล้ว หนังสือโครงงานนี้มีการใช้ไอคอนจาก Visual Studio Code (จาก GitHub repository `microsoft/vscode-codicons`) เวอร์ชัน 0.0.43 และไอคอนจากปลั๊กอิน Dart ใน Visual Studio Code (`Dart-Code/Dart-Code`) เวอร์ชัน 3.124.0 ซึ่งทั้งคู่อยู่ภายใต้ MIT license
+  #i นอกจากที่กล่าวถึงในบรรณานุกรมภาพแล้ว หนังสือโครงงานนี้มีการใช้ไอคอนจาก Visual Studio
+  Code (จาก GitHub repository `microsoft/vscode-codicons`) เวอร์ชัน 0.0.43
+  และไอคอนจากปลั๊กอิน Dart ใน Visual Studio Code (`Dart-Code/Dart-Code`) เวอร์ชัน
+  3.124.0 ซึ่งทั้งคู่อยู่ภายใต้ MIT license

  == ลิขสิทธิ์ซอร์สโคดโครงงาน

  #i เนื่องจากโคดในโครงการนี้เป็นสาธารณะและถูกปกป้องด้วยกฎหมายลิขสิทธิ์
-โคดนี้จึงมาพร้อมกับสัญญาอนุญาตในการใช้งานโคดสาธารณะทั่วไปของ GNU (GNU Public License) เวอร์ชัน 3
+  โคดนี้จึงมาพร้อมกับสัญญาอนุญาตในการใช้งานโคดสาธารณะทั่วไปของ GNU (GNU Public License)
+  เวอร์ชัน 3

  #i โดยสรุปแล้ว สัญญาอนุญาตนี้มีคุณสมบัติดังนี้ (ไม่ใช่คำแนะนำทางกฎหมาย
  โปรดอ่านเนื้อหาสัญญาเต็มเพื่อรายละเอียดที่ชัดเจน)
@@ -31,9 +39,11 @@
  - หากมีการแก้ไขเนื้อหาที่ติดลิขสัทธิ์ ต้องมีหมายเหตุชัดเจนว่างานนั้นถูกแก้ไขจากงานต้นฉบับ

  และมีข้อจำกัดว่า:
- ผู้ที่เป็นเจ้าของงานไม่มีความรับผิดชอบใด ๆ ทั้งสิ้นหากเกิดความเสียหายต่อการใช้หรือใช้ไม่ได้ของโปรแกรม
+  - ผู้ที่เป็นเจ้าของงานไม่มีความรับผิดชอบใด ๆ
+    ทั้งสิ้นหากเกิดความเสียหายต่อการใช้หรือใช้ไม่ได้ของโปรแกรม
  - โปรแกรมไม่มีการรับประกันใด ๆ ทั้งสิ้น

  สัญญาอนุญาตแบบเต็มที่ถูกบังคับใช้กับโคดในโครงงานนี้มีดังนี้
+]

 #include "gpl-3.0.typ"