linesofcodes/liteauthdocs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Finish Flutter heading

Browse Source
This commit is contained in:
Satakun Utama
2025-12-31 21:54:51 +07:00
parent f37340d485
commit 1c627501dd
28 changed files with 1577 additions and 1402 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Chapter2/Buzzer.typ
+15 -5
View File
@@ -1,20 +1,30 @@
#import "../PageTemplate.typ": i #import "../PageTemplate.typ": *
= ลำโพงสัญญาณ (Buzzer) = ลำโพงสัญญาณ (Buzzer)
#i Buzzer เป็นอุปกรณ์ส่งสัญญาณเสียงซึ่งอาจเป็น อุปกรณ์ เชิงกลเครื่องกลไฟฟ้าหรือเพียโซอิเล็กทริก (เรียกสั้น ๆ ว่าเพียโซ) การใช้งานทั่วไปของบัซเซอร์และบี๊บเปอร์ ได้แก่อุปกรณ์แจ้งเตือนตัวตั้งเวลาวงจรและการยืนยันการป้อนข้อมูลของผู้ใช้ เช่น การคลิกเมาส์หรือการกดแป้นพิมพ์ #i Buzzer เป็นอุปกรณ์ส่งสัญญาณเสียงซึ่งอาจเป็น อุปกรณ์ เชิงกลเครื่องกลไฟฟ้าหรือเพียโซอิเล็กทริก
(เรียกสั้น ๆ ว่าเพียโซ) การใช้งานทั่วไปของบัซเซอร์และบี๊บเปอร์
ได้แก่อุปกรณ์แจ้งเตือนตัวตั้งเวลาวงจรและการยืนยันการป้อนข้อมูลของผู้ใช้ เช่น
การคลิกเมาส์หรือการกดแป้นพิมพ์
ประเภทของ Buzzer มี 3 ชนิด คือ ประเภทของ Buzzer มี 3 ชนิด คือ
== ไฟฟ้าเชิงกล (Electromechanical) == ไฟฟ้าเชิงกล (Electromechanical)
#i อุปกรณ์ในยุคแรกๆ ใช้ระบบไฟฟ้าเครื่องกลแบบเดียวกับกระดิ่งไฟฟ้าโดยไม่มีฆ้องโลหะ ในทำนองเดียวกันรีเลย์อาจเชื่อมต่อเพื่อตัดกระแสไฟฟ้า ที่ทำหน้าที่สั่งการตัวเอง ซึ่งทำให้หน้าสัมผัสส่งเสียงหึ่งๆ (หน้าสัมผัสจะส่งเสียงหึ่งๆ ที่ความถี่สายหากใช้ไฟฟ้ากระแสสลับ) บ่อยครั้งที่อุปกรณ์เหล่านี้ถูกยึดไว้กับผนังหรือเพดานเพื่อใช้เป็นแผงเก็บเสียง คำว่า "buzzer" มาจากเสียงแหบๆ ของ buzzer ระบบไฟฟ้าเครื่องกล #iii อุปกรณ์ในยุคแรกๆ ใช้ระบบไฟฟ้าเครื่องกลแบบเดียวกับกระดิ่งไฟฟ้าโดยไม่มีฆ้องโลหะ
ในทำนองเดียวกันรีเลย์อาจเชื่อมต่อเพื่อตัดกระแสไฟฟ้า ที่ทำหน้าที่สั่งการตัวเอง
ซึ่งทำให้หน้าสัมผัสส่งเสียงหึ่งๆ (หน้าสัมผัสจะส่งเสียงหึ่งๆ ที่ความถี่สายหากใช้ไฟฟ้ากระแสสลับ)
บ่อยครั้งที่อุปกรณ์เหล่านี้ถูกยึดไว้กับผนังหรือเพดานเพื่อใช้เป็นแผงเก็บเสียง คำว่า "buzzer"
มาจากเสียงแหบๆ ของ buzzer ระบบไฟฟ้าเครื่องกล
== กลไก (Mechanical) == กลไก (Mechanical)
#i จอยบัซเซอร์เป็นตัวอย่างของบัซเซอร์แบบกลไกล้วนๆ และจำเป็นต้องมีไดรเวอร์ ตัวอย่างอื่นๆ ของบัซเซอร์ประเภทนี้คือกริ่งประตู #iii จอยบัซเซอร์เป็นตัวอย่างของบัซเซอร์แบบกลไกล้วนๆ และจำเป็นต้องมีไดรเวอร์ ตัวอย่างอื่นๆ
ของบัซเซอร์ประเภทนี้คือกริ่งประตู
== เพียโซอิเล็กทริก (Piezoelectric) == เพียโซอิเล็กทริก (Piezoelectric)
#i องค์ประกอบเพียโซอิเล็กทริกอาจถูกขับเคลื่อนด้วย วงจรอิเล็กทรอนิกส์ แบบสั่นหรือ แหล่ง สัญญาณเสียง อื่นๆ ซึ่งขับเคลื่อนด้วยเครื่องขยายเสียงเพียโซอิเล็กทริกเสียงที่มักใช้เพื่อระบุว่ามีการกดปุ่ม ได้แก่ เสียงคลิก เสียงกริ่ง หรือเสียงบี๊บ #iii องค์ประกอบเพียโซอิเล็กทริกอาจถูกขับเคลื่อนด้วย วงจรอิเล็กทรอนิกส์ แบบสั่นหรือ แหล่ง สัญญาณเสียง
อื่นๆ ซึ่งขับเคลื่อนด้วยเครื่องขยายเสียงเพียโซอิเล็กทริกเสียงที่มักใช้เพื่อระบุว่ามีการกดปุ่ม ได้แก่ เสียงคลิก
เสียงกริ่ง หรือเสียงบี๊บ
Chapter2/CLanguage.typ
+13 -92
View File
@@ -24,108 +24,31 @@ Boehm garbage collector ตามลำดับ
#i ตั้งแต่ปี 2000 เป็นต้นมาภาษาซี ได้รับการจัดอันดับอย่างต่อเนื่องให้อยู่ในอันดับสี่ภาษาสูงสุดในดัชนี TIOBE #i ตั้งแต่ปี 2000 เป็นต้นมาภาษาซี ได้รับการจัดอันดับอย่างต่อเนื่องให้อยู่ในอันดับสี่ภาษาสูงสุดในดัชนี TIOBE
ซึ่งเป็นการวัดความนิยมของภาษาการเขียนโปรแกรม ซึ่งเป็นการวัดความนิยมของภาษาการเขียนโปรแกรม
== ตัวอย่าง "hello, world" == ประวัติ
#i โดยการเรียนภาษาเขียนโปรแกรมใหม่ ๆ ต้องเริ่มด้วยการเขียนโปรแกรมในภาษานั้น ๆ === การพัฒนาช่วงแรก
โดยโปรแกรมแรกที่จะเขียนนั้นเหมือน ๆ กันในทุกภาษา คือการพิมพ์ "hello, world"
```c ==== ภาษา B
#include <stdio.h>
int main() ==== ภาษา B ใหม่และ C รุ่นแรก
{
printf("hello, world\n");
}
```
#i คุณสามารถบันทึกไฟล์นี้เป็นไฟล์ที่มีส่วนขยายไฟล์ `.c` เช่น `hello.c` ได้เลย ==== โครงสร้างและการเขียน Unix kernel ใหม่
แต่การจะรันโปรแกรมนี้นั้นขึ้นอยู่กับระบบปฏิบัติการของคุณ ตัวอย่างเช่นบนระบบที่มีชุดคอมไพเลอร์ GCC (หรือ
MinGW สำหรับเวอร์ชันบน Windows) ติดตั้งอยู่สามารถใช้คำสั่ง
```bash === K&R C
cc hello.c
```
เพื่อคอมไพล์ไฟล์ได้ หากคุณไม่ได้ทำอะไรผิดพลาดไป เช่นการพิมพ์ตกหรือการสะกดผิด === ANSI C และ ISO C
การคอมไพล์จะดำเนินการไปอย่างเงียบ ๆ และสร้างไฟล์ไบนารีชื่อ `a.out` ออกมา
คุณสามารถรันไฟล์นั้นบนเทอร์มินัลของคุณได้โดยการพิมพ์ `./a.out` แล้วจึงจะได้ข้อความดังต่อไปนี้ออกมา
``` === C99
hello, world
```
#i โดยโปรแกรมภาษา C นั้น ไม่ว่าจะขนาดใด จะประกอบไปด้วยฟังก์ชันและตัวแปร === C11
โดยฟังก์ชันจะประกอบไปด้วยสเตตเมนต์ (statements) ที่ระบุสิ่งที่โปรแกรมจะต้องกระทำ
และตัวแปรนั้นกำหนดค่าที่จะถูกใช้งานในการกระทำเหล่านั้น โดยในตัวอย่างมีฟังก์ชันชื่อ `main`
ซึ่งปกติแล้วคุณมีอิสระในการตั้งชื่อฟังก์ชันว่าอะไรก็ได้ แต่ฟังก์ชัน `main` นั้นพิเศษ
เพราะโปรแกรมของคุณนั้นมีจุดเริ่มต้นที่ `main` ดังนั้น โปรแกรมทุกโปรแกรมต้องมี `main` อยู่สักที่
#i โดยปกติแล้วฟังก์ชัน `main` นั้นจะเรียกใช้ฟังก์ชันอื่น ๆ เพื่อทำงานให้มัน โดยอาจเป็นฟังก์ชันที่คุณเขียน === C17
หรือฟังก์ชันที่มาจากไลบรารีที่คุณใช้งาน ในบรรทัดแรกของโปรแกรมตัวอย่าง
```c === C23
#include <stdio.h>
```
มีหน้าที่ในการนำเข้าข้อมูลเกี่ยวกับไลบรารีอินพุต/เอาต์พุตมาตรฐาน โดยบรรทัดนี้นั้นอยู่ในไฟล์ ภาษา C === C2Y
หลายไฟล์ เนื่องจากการแสดงผลข้อมูลนั้นเป็นการกระทำที่ถูกกระทำบ่อย
#i หนึ่งในวิธีการโอนถ่ายข้อมูลระหว่างฟังก์ชันคือการมอบรายการของข้อมูลที่ต้องการมอบให้แก่ฟังก์ชัน === Embedded C
โดยค่าที่มอบให้ฟังก์ชันเหล่านั้นมีชื่อเรียกว่า อาร์กิวเมนต์ (arguments)
ซึ่งวงเล็บที่ตามหลังชื่อฟังก์ชันนั้นคือวงเล็บที่จะครอบรายการอาร์กิวเมนต์ โดยในตัวอย่างฟังก์ชัน `main`
นั้นไม่หวังค่าอาร์กิวเมนต์ใด ๆ สังเกตได้จาก `()` ที่เป็นรายการที่ว่างปล่าว
#i สเตตเมนต์ที่อยู่ภายในฟังก์ชันนั้นจะถูกครอบด้วยวงเล็บปีกกา `{}` ซึ่งในฟังก์ชัน `main` มีแค่ 1
สเตตเมนต์ คือ
```c
printf("hello, world\n");
```
#i โดยฟังก์ชันนั้นจะถูกเรียกใช้ได้โดยการเรียกชื่อมัน ตามด้วยรายการอาร์กิวเมนต์ที่ถูกครอบด้วยวงเล็บ
ดังนั้น สเตตเมนต์นี้จึงมีการเรียกใช้ฟังก์ชัน `printf` ด้วยอาร์กิวเมนต์ `"hello, world\n"` โดยที่
`printf` เป็นฟังก์ชันจากไลบรารีที่ทำการพรินต์ข้อมูล
(ซึ่งการพรินต์ในที่นี้คือการแสดงผลข้อความบนหน้าจอในเทอร์มินัล)
และข้อมูลที่มันแสดงนั้นก็คือรายการอักขระที่ถูกครอบอยู่ด้วยเครื่องหมายอัญประกาศนั่นเอง
#i รายการอักขระที่ถูกครอบด้วยเครื่องหมายอัญประกาศ เช่น `"hello, world\n"` นั้นมีชื่อเรียกว่า
character string หรือ string constant และในตัวอย่างนี้นั้น
เราจะมีการใช้รายการอักขระนี้เป็นเพียงแค่อาร์กิวเมนต์ของ `printf` และฟังก์ชันอื่น ๆ
#i ลำดับตัวอักษร `\n` ในสตริงคือสัญกรณ์ภาษา C สำหรับ#emph[ตัวอักษรบรรทัดใหม่]
ซึ่งเมื่อถูกพรินต์แล้วจะให้เอาต์พุตไปอยู่ทางด้านซ้ายของบรรทัดใหม่ โดยหากไม่ใส่ `\n`
(ซึ่งคุณสามารถทดลองได้เลย) คุณจะพบว่าไม่มีการขึ้นบรรทัดใหม่ของข้อความ และคุณต้องใช้ `\n`
ในการขึ้นบรรทัดใหม่ และหากคุณลองทำแบบนี้:
```c
printf("Hello, world
");
```
คอมไพเลอร์ภาษา C นั้นจะแสดงข้อความแสดงข้อผิดพลาดขึ้นมา
#i `printf` นั้นจะไม่มีทางใส่ตัวอักษรขึ้นบรรทัดใหม่ให้โดยอัตโนมัติ ดังนั้นคุณสามารถเรียกใช้ฟังก์ชันหลาย
ๆ ครั้งเพื่อค่อย ๆ สร้างเอาต์พุตออกมาได้ โดยที่โปรแกรมแรกของเราจะสามารถเขียนแบบนี้ได้
```c
#include <stdio.h>
int main()
{
printf("hello, ");
printf("world");
printf("\n");
}
```
แล้วข้อความที่แสดงออกมาจะยังคงเดิม
#i คุณสามารถสังเกตได้ว่า `\n` นั้นจะแทนตัวอักษรตัวเดียว โดยสัญกรณ์ _escape sequence_ เช่น
`\n` คือรูปแบบในการเขียนตัวอักษรที่อาจพิมพ์ได้ยากหรือตัวอักษรล่องหน โดยสัญกรณ์อื่น ๆ
ในประเภทเดียวกันมีตัวอย่างเช่น `\t` สำหรับตัวอักษรแท็บ, `\b` สำหรับ backspace, `\"`
สำหรับการพิมพ์สัญลักษณ์อัญประกาศ
(ไม่เช่นนั้นตัวอักษรอัญประกาศจะถูกถือว่าเป็นตัวอักษรในการเริ่มต้น/สิ้นสุดของสตริง), และ `\\`
สำหรับการพิมพ์ตัวอักษร backslash เอง
== ตัวแปร (Variables) == ตัวแปร (Variables)
@@ -195,8 +118,6 @@ float a, b, c;
#show table.cell.where(y: 1): strong #show table.cell.where(y: 1): strong
#show table.cell: set par(justify: false, leading: 0.5em) #show table.cell: set par(justify: false, leading: 0.5em)
#show figure: i-figured.show-figure.with(level: 4)
#figure( #figure(
table( table(
columns: 7, columns: 7,
Chapter2/Chapter2.typ
+1 -11
View File
@@ -2,14 +2,6 @@
#import "@preview/i-figured:0.2.4" #import "@preview/i-figured:0.2.4"
// #show: page-theme // #show: page-theme
#show heading: i-figured.reset-counters.with(level: 3)
#show figure: i-figured.show-figure.with(level: 3)
#show raw.where(block: false): set text(font: "Laksaman")
#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"))
#set heading(numbering: "บทที่ 1") #set heading(numbering: "บทที่ 1")
#include "Intro.typ" #include "Intro.typ"
@@ -19,11 +11,9 @@
#include "Buzzer.typ" #include "Buzzer.typ"
#include "HTTP.typ" #include "HTTP.typ"
#include "HTTPS.typ" #include "HTTPS.typ"
#pagebreak()
#include "TLS.typ" #include "TLS.typ"
#include "NFC.typ" #include "NFC.typ"
#pagebreak()
#include "Flutter.typ" #include "Flutter.typ"
#include "Git.typ" #include "Git.typ"
#include "CLanguage.typ" #include "CLanguage.typ"
Chapter2/Flutter.typ
+170 -675
View File
@@ -2,6 +2,7 @@
#import "@preview/treet:1.0.0": * #import "@preview/treet:1.0.0": *
#import "@preview/tiaoma:0.3.0" #import "@preview/tiaoma:0.3.0"
#set heading(numbering: "1.1", offset: 1) #set heading(numbering: "1.1", offset: 1)
#set figure(kind: image)
= Flutter <flutter> = Flutter <flutter>
@@ -19,731 +20,225 @@ Alibaba
ช่วยลดความยุ่งยากในการรองรับหลายแพลตฟอร์ม เนื่องจากสามารถใช้โคด UI ช่วยลดความยุ่งยากในการรองรับหลายแพลตฟอร์ม เนื่องจากสามารถใช้โคด UI
ที่เหมือนกันได้กับทุกแพลตฟอร์มเป้าหมาย ที่เหมือนกันได้กับทุกแพลตฟอร์มเป้าหมาย
== การติดตั้งโปรแกรมเขียนโคด
#i จริง ๆ แล้วนั้น Flutter สามารถทำงานกับโปรแกรมเขียนโคดใดก็ได้
แต่มีโปรแกรมเหล่านี้ที่อาจมีประสบการณ์การพัฒนาที่ดีกว่าโปรแกรมอื่น:
- Visual Studio Code (VS Code)
- Android Studio
- JetBrains IntelliJ
- Firebase Studio
#i โครงงานนี้ใช้โปรแกรมเขียนโคด Android Studio เป็นหลักเนื่องจากแอพลิเคชันโครงงานมี Android
เป็นเป้าหมายหลัก และ Android SDK สามารถจัดการได้ง่ายกว่าใน Android Studio
=== Android Studio
#i Android Studio สามารถดาวน์โหลดได้ผ่าน https://developer.android.com/studio
หรือสามารถถูกติดตั้งและจัดการผ่านแอพลิเคชัน JetBrains Toolbox ได้เช่นกัน
(https://www.jetbrains.com/toolbox-app/)
== การติดตั้ง Flutter <flInstall>
#i การติดตั้ง Flutter สามารถทำได้สองวิธีด้วยกัน คือการติดตั้งผ่าน Visual Studio Code (VS
Code) และการติดตั้งด้วยตนเอง โดยหากต้องการใช้ VS Code เป็นโปรแกรมเขียนโคดอยู่แล้ว
สามารถติดตั้งผ่าน VS Code ได้เลย
#i แต่ก่อนอื่น ต้องทำการติดตั้งโปรแกรมและไลบรารีพื้นฐานที่จำเป็นสำหรับ Flutter ก่อน
=== การติดตั้งโปรแกรมและไลบรารีที่จำเป็น
==== Windows
#grid(
columns: 2,
column-gutter: 1em,
[#i ในการพัฒนาซอฟต์แวร์บน Windows ด้วย Flutter คุณจำเป็นต้องติดตั้ง Git สำหรับ Windows
ซึ่งคุณสามารถดูขั้นตอนการติดตั้งได้โดยการสแกน QR code ด้านข้าง หรือที่
https://git-scm.com/install/windows หรือเพียงแค่ใช้ WinGet
ในการติดตั้งโดยการใช้คำสั่งด้านล่าง],
tiaoma.qrcode(
"https://git-scm.com/install/windows",
width: 1in,
alt: "QR โคดสำหรับหน้าการติดตั้ง Git สำหรับ Windows",
),
)
```sh
winget install --id Git.Git -e --source winget
```
==== Linux
#i Flutter ใช้ไลบรารีดังต่อไปนี้ในขั้นตอนการพัฒนาแอพลิเคชันบน Linux (development
dependencies; ยังไม่รวมไลบรารีและโปรแกรมที่ต้องมีในการสร้างแอพลิเคชัน _สำหรับ_ Linux)
#grid(
columns: 2,
column-gutter: 2in,
[
- curl
- git
- unzip
],
[
- xz
- zip
- glu
],
)
หากต้องการคำสั่งในการติดตั้งแพคเกจเหล่านี้ โปรดดู@flLinuxDetails
==== macOS
#i จำเป็นต้องทำการติดตั้งเครื่องมือ command-line Xcode เพื่อเข้าถึงเครื่องมือที่ Flutter
จำเป็นต้องใช้ รวมถึง Git
ในการดาวน์โหลดเครื่องมือ ใช้คำสั่งต่อไปนี้ในเทอร์มินัลที่คุณเลือก:
```sh
xcode-select --install
```
#i หากคุณไม่ได้ติดตั้งเครื่องมืออยู่แล้ว จะมีไดอะลอกเพื่อคอนเฟิร์มว่าคุณต้องการที่จะติดตั้งมัน กด
*Install* และกด *Done* เมื่อทำการติดตั้งเสร็จสิ้นแล้ว
#pagebreak()
=== การติดตั้งผ่าน Visual Studio Code
#[
#set enum(indent: 3em)
+ เปิด 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 สำหรับข้อมูลเพิ่มเติม
]
=== การติดตั้งด้วยตนเอง
#i แนะนำให้ทำตาม https://docs.flutter.dev/install/manual#install-flutter
เนื่องจากกระบวนการนี้ต้องใช้ข้อมูลที่ใหม่ล่าสุด
1. ดาวน์โหลด Flutter (สามารถหาปุ่มดาวน์โหลดได้จากลิงก์ด้านบน)
2. สร้างโฟลเดอร์สำหรับเก็บ Flutter SDK
3. ทำการแตกไฟล์ที่ดาวน์โหลดมา
4. เพิ่ม Flutter เข้าไปยัง PATH ของคุณ (วิธีการขึ้นอยู่กับระบบปฏิบัติการ)
5. ยืนยันความถูกต้องของการติดตั้งของคุณด้วยคำสั่ง `flutter doctor -v`
== Dart == Dart
#i Dart เป็นภาษาโปรแกรมที่ออกแบบโดย Lars Bak และ Kasper Lund และพัฒนาโดย Google #iii Dart เป็นภาษาโปรแกรมที่ออกแบบโดย Lars Bak และ Kasper Lund และพัฒนาโดย Google
สามารถใช้พัฒนาแอปพลิเคชันบนเว็บ มือถือ เซิร์ฟเวอร์ และเดสก์ท็อปได้ สามารถใช้พัฒนาแอปพลิเคชันบนเว็บ มือถือ เซิร์ฟเวอร์ และเดสก์ท็อปได้
และยังเป็นภาษาหลักที่ใช้ในการพัฒนาแอพลิเคชัน Flutter และยังเป็นภาษาหลักที่ใช้ในการพัฒนาแอปพลิเคชัน Flutter
#i Dart เป็นภาษาเชิงวัตถุ อิงคลาส และรวบรวมขยะ (garbage-collection) ด้วยไวยากรณ์แบบ C #iii Dart เป็นภาษาเชิงวัตถุ อิงคลาส และรวบรวมขยะ (garbage-collection) ด้วยไวยากรณ์แบบ C
สามารถคอมไพล์เป็นโค้ดเครื่อง JavaScript หรือ WebAssembly ได้ รองรับอินเทอร์เฟซ มิกซ์อิน สามารถคอมไพล์เป็นโค้ดเครื่อง JavaScript หรือ WebAssembly ได้ รองรับอินเทอร์เฟซ มิกซ์อิน
คลาสนามธรรม เจเนอริกแบบรีไฟด์ และการอนุมานชนิดข้อมูล คลาสนามธรรม เจเนอริกแบบรีไฟด์ และการอนุมานชนิดข้อมูล
== การสร้างโปรเจกต์ #pagebreak()
#i ตั้งแต่หัวข้อนี้เป็นต้นไป จะเป็นข้อมูลสำหรับการทำงานกับ Android Studio == สถาปัตยกรรม
เป็นหลักเนื่องจากเป็นโปรแกรมหลักที่ถูกใช้งานในการพัฒนาแอพลิเคชันโครงงานนี้
#i หากยังไม่ได้ติดตั้งปลั๊กอิน Flutter โปรดติดตั้งปลั๊กอินก่อน โดยหากอยู่ในหน้าต้อนรับ #iii Flutter ถูกออกแบบมาให้เป็นระบบแบบเลเยอร์ที่ต่อขยายได้
สามารถติดตั้งปลั๊กอินได้โดยการเข้าไปยังแท็บ *Plugins* หรือหากเปิดโปรเจกต์อื่นอยู่ ประกอบด้วยไลบรารีอิสระหลายชุดที่แต่ละชุดพึ่งพาเลเยอร์ที่อยู่ด้านล่าง
สามารถเข้าถึงหน้าปลั๊กอินได้โดยการกดที่ไอคอนฟันเฟืองในแถบเครื่องมือ แล้วกด *Plugins...* ไม่มีเลเยอร์ใดที่มีสิทธิ์พิเศษในการเข้าถึงเลเยอร์ด้านล่าง
หลังจากนั้น ในแท็บ *Marketplace* ของหน้าปลั๊กอิน ค้นหา *Flutter* (ผู้ผลิตปลั๊กอินคือ Google) และทุกส่วนของเฟรมเวิร์กถูกออกแบบมาให้เป็นตัวเลือกและสามารถทดแทนได้
แล้วกด *Install*
#afigure( #afigure(
image("Flutter/homePage.png", width: 65%), image("Flutter/archdiagram.png", width: 80%),
alt: "หน้ายินดีต้อนรับในแท็บ Projects ที่กำลังแสดงรายการโปรเจกต์และปุ่มในการสร้างโปรเจกต์ใหม่", attr: [Flutter, ภายใต้ CC BY 4.0],
caption: [หน้ายินดีต้อนรับใน Android Studio], alt: "แผนผังสถาปัตยกรรม Flutter",
caption: [สถาปัตยกรรม Flutter],
) )
#i เมื่อคลิก *New Flutter Project* จะมีหน้าถามสถานที่ติดตั้ง Flutter SDK หลังจากนั้น กด #iii สำหรับระบบปฏิบัติการที่อยู่ภายใต้ แอปพลิเคชัน Flutter
*Next* แล้วจะมีหน้าต่อไปนี้ขึ้นมาเพื่อให้คุณกรอกรายละเอียดโปรเจกต์ จะถูกบรรจุในลักษณะเดียวกับแอปพลิเคชันเนทีฟอื่น ๆ โดยตัวฝังตัว (Embedder)
เฉพาะแพลตฟอร์มจะทำหน้าที่เป็นจุดเริ่มต้น ประสานงานกับระบบปฏิบัติการที่อยู่ภายใต้เพื่อเข้าถึงบริการต่างๆ
เช่น พื้นผิวการแสดงผล การเข้าถึง และการป้อนข้อมูล และจัดการลูปเหตุการณ์ข้อความ
ตัวฝังตัวเขียนด้วยภาษาที่เหมาะสมกับแพลตฟอร์ม ปัจจุบันคือ Java และ C++ สำหรับ Android, Swift
และ Objective-C/Objective-C++ สำหรับ#jb iOS และ macOS และ C++ สำหรับ Windows และ
Linux การใช้ตัวฝังตัว โค้ด Flutter สามารถรวมเข้ากับแอปพลิเคชันที่มีอยู่แล้วในรูปแบบโมดูล
หรือโค้ดอาจเป็นเนื้อหาทั้งหมดของแอปพลิเคชันก็ได้ Flutter
มีตัวฝังตัวจำนวนมากสำหรับแพลตฟอร์มเป้าหมายทั่วไป แต่ก็ยังมีตัวฝังตัวอื่นๆ อีกด้วย
#afigure( #iii หัวใจหลักของ Flutter คือ Flutter engine ซึ่งส่วนใหญ่เขียนด้วยภาษา C++
image("Flutter/newProjectPage.png", width: 80%), และรองรับฟังก์ชันพื้นฐานที่จำเป็นต่อการทำงานของแอปพลิเคชัน Flutter ทั้งหมด
alt: "หน้ากรอกรายละเอียดโปรเจกต์ใหม่", เอนจินนี้มีหน้าที่ในการแปลงฉากที่ประกอบขึ้นเป็นภาพแรสเตอร์ทุกครั้งที่จำเป็นต้องวาดเฟรมใหม่
caption: [หน้าโปรเจกต์ใหม่], มันมีหน้าที่ให้การใช้งานระดับต่ำของ API หลักของ Flutter รวมถึงการจัดวางข้อความกราฟิก
) การรับส่งข้อมูลไฟล์และเครือข่าย รันไทม์ Dart และเครื่องมือคอมไพล์
รายละเอียดที่จำเป็นต้องกรอกในการสร้างโปรเจกต์ใหม่มีดังนี้: #iii เอนจินนี้ถูกเปิดเผยสู่เฟรมเวิร์ก Flutter ผ่านทาง dart:ui ซึ่งห่อหุ้มโค้ด C++
ที่อยู่เบื้องหลังด้วยคลาส Dart ไลบรารีนี้เปิดเผยส่วนประกอบพื้นฐานระดับต่ำสุด เช่น
คลาสสำหรับควบคุมระบบย่อยการรับข้อมูล กราฟิก และการแสดงผลข้อความ
- *Project name:* ชื่อโปรเจกต์ #iii โดยทั่วไป นักพัฒนาจะโต้ตอบกับ Flutter ผ่านเฟรมเวิร์ก Flutter
- *Project location:* โฟลเดอร์ที่ต้องการเก็บโปรเจกต์ ซึ่งเป็นเฟรมเวิร์กที่ทันสมัยและตอบสนองต่อสิ่งรอบข้าง เขียนด้วยภาษา Dart
- *Description:* รายละเอียดโปรเจกต์ เฟรมเวิร์กนี้ประกอบด้วยชุดไลบรารีแพลตฟอร์ม เลย์เอาต์ และพื้นฐานที่ครบครัน
- *Project type:* ประเภทโปรเจกต์ ในกรณีนี้เป็นค่า *Application* ซึ่งประกอบด้วยเลเยอร์หลายชั้น เริ่มจากล่างขึ้นบน ได้แก่:
เนื่องจากเราต้องการสร้างแอพลิเคชัน
- *Organization:* โดเมนเนมย้อนหลังขององค์กรที่พัฒนา (Reverse domain name notation;
Reverse-DNS)
- *Android language:* เลือกระหว่าง Java และ Kotlin เป็นภาษาหลักที่ใช้ในแอพลิเคชัน Android
- *Platforms:* แพลตฟอร์มที่โปรเจกต์จะรองรับ อย่างไรก็ตาม
การสร้างไฟล์ไบนารีสำหรับแอพลิเคชันขึ้นอยู่กับแพลตฟอร์มที่พัฒนาแอพลิเคชันเช่นกัน หมายความว่า
ถึงแม้ตามทฤษฎีแล้วแอพลิเคชันของคุณจะรองรับ iOS คุณต้องมีอุปกรณ์ Mac ในการสร้างไฟล์แอพลิเคชัน
iOS ออกมา
เมื่อทำการใส่รายละเอียดทั้งหมดแล้ว สามารถกด Create เพื่อสร้างโปรเจกต์ได้เลย - คลาสพื้นฐานและบริการส่วนประกอบต่างๆ เช่น แอนิเมชัน การวาดภาพ และท่าทางสัมผัส
ซึ่งนำเสนอนามธรรมที่ใช้กันทั่วไปเหนือพื้นฐานที่อยู่เบื้องหลัง
- เลเยอร์การเรนเดอร์ให้นามธรรมสำหรับการจัดการเลย์เอาต์ ด้วยเลเยอร์นี้
คุณสามารถสร้างโครงสร้างแบบต้นไม้ของวัตถุที่เรนเดอร์ได้ คุณสามารถจัดการวัตถุเหล่านี้แบบไดนามิก
โดยโครงสร้างแบบต้นไม้จะอัปเดตเลย์เอาต์โดยอัตโนมัติเพื่อสะท้อนการเปลี่ยนแปลงของคุณ
- เลเยอร์วิดเจ็ตเป็นนามธรรมของการประกอบ
วัตถุเรนเดอร์แต่ละชิ้นในเลเยอร์การเรนเดอร์จะมีคลาสที่สอดคล้องกันในเลเยอร์วิดเจ็ต นอกจากนี้
เลเยอร์วิดเจ็ตยังช่วยให้คุณกำหนดการรวมกันของคลาสที่คุณสามารถนำกลับมาใช้ใหม่ได้
นี่คือเลเยอร์ที่แนะนำโมเดลการเขียนโปรแกรมแบบตอบสนอง
- ไลบรารี Material และ Cupertino
นำเสนอชุดควบคุมที่ครอบคลุมซึ่งใช้ส่วนประกอบพื้นฐานของเลเยอร์วิดเจ็ตเพื่อนำภาษาการออกแบบ
Material หรือ iOS ไปใช้
#iii เฟรมเวิร์ก Flutter มีขนาดค่อนข้างเล็ก
ฟีเจอร์ระดับสูงหลายอย่างที่นักพัฒนาอาจใช้ถูกพัฒนาขึ้นมาในรูปแบบของแพ็กเกจ
รวมถึงปลั๊กอินของแต่ละแพลตฟอร์ม เช่น กล้องและเว็บวิว ตลอดจนฟีเจอร์ที่ไม่ขึ้นกับแพลตฟอร์ม เช่น
ตัวอักษร, HTTP และแอนิเมชัน ซึ่งสร้างขึ้นจากไลบรารีหลักของ Dart และ Flutter
แพ็กเกจบางส่วนมาจากระบบนิเวศที่กว้างกว่า ครอบคลุมบริการต่างๆ เช่น การชำระเงินภายในแอป
การตรวจสอบสิทธิ์ของ Apple และแอนิเมชัน
#pagebreak() #pagebreak()
== แอพลิเคชันตัวอย่าง == โครงสร้างของแอปพลิเคชัน
เมื่อกดรันแอพลิเคชันด้วยไอคอน #box( #iii แผนภาพต่อไปนี้แสดงภาพรวมของส่วนประกอบต่างๆ ที่ประกอบกันเป็นแอป Flutter
image("Flutter/vscode_play.svg", alt: "Play"), ทั่วไปที่สร้างขึ้นโดยคำสั่ง `flutter create` แผนภาพนี้แสดงตำแหน่งของ Flutter Engine
baseline: 15%, ในโครงสร้างนี้ เน้นขอบเขตของ API และระบุที่เก็บโค้ด (repository) ที่ส่วนประกอบแต่ละส่วนอยู่
) (หรือ Shift+F10 ใน Android Studio) จะได้แอพลิเคชันดังรูปด้านล่างออกมา คำอธิบายด้านล่างจะอธิบายคำศัพท์บางคำที่ใช้กันทั่วไปในการอธิบายส่วนประกอบของแอป Flutter
#afigure( #afigure(
grid( image("Flutter/app-anatomy.svg", width: 3in),
columns: 2, attr: [Flutter, ภายใต้ CC BY 4.0],
align: horizon, alt: "แผนผังสถาปัตยกรรม Flutter",
image( caption: [สถาปัตยกรรม Flutter],
"Flutter/mobileExampleApp.png",
height: 2.5in,
alt: "แอพลิเคชันมือถือ มีแถบสีม่วง ตัวเลขแสดงจำนวนครั้งที่กดปุ่มและปุ่มกดเพิ่มจำนวน",
),
image(
"Flutter/desktopExampleApp.png",
width: 90%,
alt: "โปรแกรมคอมพิวเตอร์ แถบหน้าต่างโปรแกรมสีดำ ในหน้าต่างประกอบด้วยส่วนประกอบคล้ายแอพลิเคชันบนโทรศัพท์",
),
),
caption: [แอพลิเคชันตัวอย่างบน Android 15 และ Arch Linux],
)
#show raw.where(block: true): set block(below: 2em)
_*หมายเหตุ:* โคดในห้วข้อนี้ถูกนำ comment ออกเพื่อความรวบรัด_
ภายในโฟลเดอร์โปรเจกต์ใหม่ จะมีไฟล์ `lib/main.dart` พร้อมแอพลิเคชันตัวอย่าง
โดยในบรรทัดแรก จะมีการนำเข้า Material UI
#set figure(kind: "image", supplement: "รูปที่")
#afigure(
```dart
import 'package:flutter/material.dart';
```,
caption: [โคดนำเข้าแพคเกจ],
)
และถัดมา จะมีฟังก์ชันหลักชื่อ `main` ที่ทำหน้าที่ในการรันแอพลิเคชัน โดยมีการรับอาร์กิวเมนต์เป็นวิดเจ็ท
ซึ่งในกรณีนี้เป็นการสร้างวัตถุจากคลาส `MyApp` ที่เป็นวิดเจ็ท
#afigure(
```dart
void main() {
runApp(const MyApp());
}
```,
caption: [ฟังก์ชัน main],
)
ถัดมาจะมีคลาส `MyApp` ที่สืบทอดมาจาก `StatelessWidget` ซึ่งคือคลาสสำหรับวิดเจ็ทที่ไร้สถานะ
("Stateless")
#afigure(
```dart
class MyApp extends StatelessWidget {
```,
caption: [],
)
ซึ่งในคลาสจะมี constructor ที่สามารถรับค่าคีย์ได้:
#afigure(
```dart
const MyApp({super.key});
```,
caption: [],
)
และจะมีฟังก์ชันในการสร้างวิดเจ็ท ซึ่งฟังก์ชันนี้เป็นการสืบทอดฟังก์ชันมา สังเกตได้จาก `@override`
#afigure(
```dart
@override
Widget build(BuildContext context) {
```,
caption: [],
)
และในฟังก์ชันจะมีการสร้างวัตถุ MaterialApp ซึ่งมีหน้าที่ในการเก็บข้อมูลเกี่ยวกับแอพลิเคชัน Material
UI รวมถึงข้อมูลเช่น ชื่อแอพลิเคชัน (`title`) และธีม (`theme`)
#afigure(
```dart
return MaterialApp(
title: 'Flutter Demo',
```,
caption: [],
)
โดยข้อมูลธีมนั้นถูกเก็บด้วยการสร้างวัตถุ `ThemeData`
#afigure(
```dart
theme: ThemeData(
```,
caption: [],
)
และมีการสร้างธีมสีจากสีหลักโดยการใช้เมธอด `ColorScheme.fromSeed` แต่ในโคดด้านล่างนี้ คลาส
`ColorScheme` นั้นถูกอนุมานขึ้นมา โดยใน Dart 3.10 มีฟีเจอร์ "dot shorthands"
ซึ่งเป็นทางลัดในการข้ามการเขียนชื่อคลาส ซึ่งชื่อคลาสสามารถถูกอนุมานขึ้นมาได้เนื่องจากอาร์กิวเมนต์
`colorScheme` นั้นคาดหวังค่าที่เป็นวัตถุจากคลาส `ColorScheme` อยู่แล้ว
#afigure(
```dart
colorScheme: .fromSeed(seedColor: Colors.deepPurple),
),
```,
caption: [],
)
และต่อมา อาร์กิวเมนต์ `home` เป็นอาร์กิวเมนต์ที่รับค่าเป็นวิดเจ็ทซึ่งจะเป็นหน้าแรกของแอพลิเคชัน
#afigure(
```dart
home: const MyHomePage(title: 'Flutter Demo Home Page'),
);
}
}
```,
kind: "image",
supplement: "รูปที่",
caption: [],
)
ถัดมา มีการสร้างคลาส `MyHomePage` ที่ถูกใช้ด้านบน โดยคลาสเป็น `StatefulWidget`
ซึ่งหมายความว่า เป็นคลาสที่มีสถานะ (State)
#afigure(
```dart
class MyHomePage extends StatefulWidget {
```,
caption: [],
)
โดยใน constructor มีการรับค่าพารามีเตอร์ `title`
#afigure(
```dart
const MyHomePage({super.key, required this.title});
```,
caption: [],
)
โดยคลาสนี้เป็นคลาสที่เก็บการตั้งค่าวิดเจ็ท และเป็นคลาสที่เก็บค่าพารามิเตอร์จากวิดเจ็ทที่เหนือกว่า
และตัวแปรในคลาสย่อยของ `StatefulWidget` นั้นจะมีคีย์เวิร์ด `final` เสมอ ซึ่งหมายถึงว่า
ตัวแปรนี้เปลี่ยนแปลงไม่ได้หลังจากสร้างวัตถุจากคลาสแล้ว
#afigure(
```dart
final String title;
```,
caption: [],
)
ต่อมาจึงมีการสร้างวัตถุ State ซึ่งในฟังก์ชัน `createState` ที่ถูกสืบทอดมานั้น จะมีการสร้างวัตถุ State
จากคลาส `_MyHomePageState` (โดยที่ `_`
หมายถึงว่าคลาสนั้นเป็นส่วนตัวและไม่ควรถูกนำเข้าโดยไฟล์อื่น)
#afigure(
```dart
@override
State<MyHomePage> createState() => _MyHomePageState();
}
```,
caption: [],
)
#afigure(
```dart
class _MyHomePageState extends State<MyHomePage> {
int _counter = 0;
void _incrementCounter() {
```,
caption: [],
)
โดยในฟังก์ชัน `_incrementCounter` มีการเรียกใช้ฟังก์ชัน `setState` ซึ่งจะแจ้งเตือน Flutter
ว่ามีการเปลี่ยนแปลงสถานะ ซึ่งจะก่อให้เกิดการเร็นเดอร์วิดเจ็ทใหม่ และในอาร์กิวเมนต์ของ `setState`
คือฟังก์ชันไม่ระบุชื่อ (anonymous functions หรืออีกชื่อหนึ่งคือ lambda) ที่เปลี่ยนแปลงสถานะของวิดเจ็ท
#afigure(
```dart
setState(() {
_counter++;
});
}
```,
caption: [],
)
โดยต่อมา มีฟังก์ชัน `build` เช่นเคยที่มีหน้าที่ในการสร้างวิดเจ็ท โดยฟังก์ชัน `build`
ของวิดเจ็ทที่มีสถานะนั้นจะถูกรันใหม่ทุกครั้งที่มีการเปลี่ยนแปลงสถานะ
#afigure(
```dart
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
```,
caption: [],
)
*การทดลอง:* ในระหว่างที่รันแอพลิเคชันอยู่ ลองเปลี่ยนสีพื้นหลังของวิดเจ็ท `AppBar` (เป็นค่าอื่นเช่น
`Colors.amber`) แล้วทำการ hot reload โดยการกดไอคอน#box(
image("Flutter/flutterHotReload.svg", alt: "สายฟ้า", width: 1.5em),
baseline: 20%,
)เพื่อเห็นการเปลี่ยนแปลงของสีแถบแอพลิเคชันในระหว่างที่สีของวิดเจ็ทอื่น ๆ ยังคงเดิม
#afigure(
```dart
backgroundColor: Theme.of(context).colorScheme.inversePrimary,
```,
caption: [],
)
โดยในอาร์กิวเมนต์ `title` นี้มีการใช้ค่าที่รับมาจากวิดเจ็ทที่เหนือกว่า โดย `widget`
ในที่นี้คือวัตถุของคลาส `MyHomePage` ที่ทำหน้าที่เก็บค่า `title` ของเรา แล้วเราจึงทำค่า `title`
นั้นใส่ในวิดเจ็ทข้อความ (`Text`)
#afigure(
```dart
title: Text(widget.title),
),
```,
caption: [],
)
`Center` เป็นวิดเจ็ทจัดเลย์เอาต์ โดยจะทำให้ลูก 1 วิดเจ็ทของมัน (`child`) อยู่ตรงกลาง
#afigure(
```dart
body: Center(
```,
caption: [],
)
และ `Column` เป็นวิดเจ็ทจัดเลย์เอาต์เช่นกัน มันรับลูกหลายคน (`children`) แล้วจัดเรียงมันในแนวตั้ง
โดยค่าเริ่มต้นแล้ว มันจะจัดให้ตัวเองกว้างเท่ากับลูก ๆ ของมัน
และพยายามจัดให้ตัวเองสูงเท่าวิดเจ็ทที่สูงกว่า
วิดเจ็ทคอลัมน์มีหลายคุณสมบัติในการควบคุมขนาดของมันและการจัดวางลูก ๆ ของมัน
โดยด้านล่างมีการใช้อาร์กิวเมนต์ `mainAxisAlignment` ในการจัดลูก ๆ ของมันให้อยู่ตรงกลางในแนวตั้ง
โดย "main axis" หรือ แกนหลัก ในกรณีนี้คือแนวตั้ง เพราะคอลัมน์นั้นเป็นแนวตั้ง (และ "cross axis"
หรือแกนไขว้ จะเป็นแนวนอน คือแนวตรงข้ามกับแนวหลัก)
#afigure(
```dart
child: Column(
mainAxisAlignment: .center,
children: [
const Text('You have pushed the button this many times:'),
Text(
'$_counter',
```,
caption: [],
)
การเข้าถึงธีมของแอพลิเคชัน (```dart Theme.of(context)```) แล้วนำธีมข้อความ
`headlineMedium` มาใช้:
#afigure(
```dart
style: Theme.of(context).textTheme.headlineMedium,
), // Text
],
), // Column
), // Center
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
child: const Icon(Icons.add),
),
);
}
}
```,
caption: [],
) )
- แอปพลิเคชัน Dart (Dart app)
- ประกอบวิดเจ็ตเข้าด้วยกันเพื่อสร้าง UI ที่ต้องการ
- ดำเนินการตามตรรกะทางธุรกิจ
- นักพัฒนาแอปเป็นเจ้าของ
- เฟรมเวิร์ก (Framework)
- ให้ API ระดับสูงสำหรับการสร้างแอปคุณภาพสูง (ตัวอย่างเช่น วิดเจ็ต การทดสอบการกด
การตรวจจับท่าทาง การเข้าถึงได้ และการอินพุตข้อความ)
- ประกอบต้นวิดเจ็ตของแอปพลิเคชันเป็นฉาก
#pagebreak() #pagebreak()
- เอนจิน (Engine)
== โครงสร้างโปรเจกต์ Flutter <flStructure> - มีหน้าที่แปลงฉากเป็นรูปแบบแรสเตอร์
- ให้การทำงานระดับต่ำของแกนกลางของ Flutter API (เช่น กราฟิก การจัดข้อความ และรันไทม์
ในโครงงานนี้ โปรเจกต์ Flutter มีโครงสร้างคร่าว ๆ ดังกล่าว Dart)
- เปิดเผยฟังก์ชันระดับนี้ให้แก่เฟรมเวิร์กผ่าน API `dart:ui`
#tree-list[ - บูรณาการกับแพลตฟอร์มต่าง ๆ ด้วย API ตัวฝังตัว
- android - ตัวฝังตัว (Embedder)
- app - ประสานงานกับระบบปฏิบัติการภายใต้สำหรับการเข้าถึงบริการต่าง ๆ เช่น พื้นผิวการเรนเดอร์
- src การเข้าถึง และการป้อนข้อมูล
- main - จัดการลูปอิเวนต์
- java: โคด Java - เปิดเผย API เฉพาะแพลตฟอร์มเพื่อบูรณาการตัวฝังตัวเข้าไปยังแอป
- kotlin: โคด Kotlin - ตัวรัน (Runner)
- res: โฟลเดอร์ทรัพยากร เช่น ไอคอนแอพลิเคชัน - ประกอบชิ้นส่วนที่ถูกเปิดเผยโดยตัวฝังตัวเข้าเป็นแพคเกจแอปพลิเคชันที่สามารถใช้งานได้บนแพลตฟอร์มเป้าหมาย
- AndroidManifest.xml - บางส่วนถูกสร้างขึ้นโดย `flutter create` และมีเจ้าของเป็นผู้พัฒนาแอป
- build.gradle.kts
- settings.gradle.kts
- assets
- certificates
- rootCA.crt: ใบรับรอง Root (ดู@x509 สำหรับรายละเอียด)
- build: โฟลเดอร์สำหรับเก็บไฟล์ไบนารี
- ios
- lib: ซอร์สโคดของแอพลิเคชัน
- linux
- macos
- test
- windows
- l10n.yaml: ไฟล์ตั้งค่าฟีเจอร์แปลภาษา
- pubspec.yaml: ไฟล์ข้อมูลโปรเจกต์ Flutter
]
(รายการข้างต้นรวมถึงแค่ไฟล์ที่สำคัญที่จะถูกกล่าวถึงใน@flutter นี้)
== การนำเข้าแพคเกจ
#i ไฟล์ `pubspec.yaml` เป็นไฟล์ที่เก็บข้อมูลเกี่ยวกับโปรเจกต์ Flutter ของคุณ เช่น ชื่อ คำอธิบาย
เวอร์ชัน และรวมถึงสิ่งที่จะกล่าวถึงในหัวข้อนี้ คือการติดตั้งและนำเข้าแพคเกจภายนอกมาใช้ในโปรเจกต์
#i โดยหากไม่รวมรายละเอียดโปรเจกต์เบื้องต้นเช่นชื่อและคำอธิบายแล้ว ไฟล์ `pubspec.yaml`
จะมีรายละเอียดดังนี้
`environment` นั้นจะกล่าวถึงสิ่งแวดล้อม ซึ่งในกรณีนี้มีเพียง `sdk` ที่ระบุเวอร์ชันของ Flutter SDK
ในการคอมไพล์โปรเจกต์
```yaml
environment:
sdk: ^3.10.1
```
`dependencies` จะกล่าวถึงไลบรารีที่โปรเจกต์พึ่งพา ซึ่งโดยค่าเริ่มต้นแล้ว
ในโปรเจกต์ตัวอย่างจะมีการติดตั้งเซ็ทไอคอน Cupertino มาให้ (`cupertino_icons`;
หรือเรียกอย่างง่ายว่า ไอคอน iOS) ซึ่งแน่นอนว่าหากคุณไม่ใช้ สามารถลบทิ้งได้
```yaml
dependencies:
flutter:
sdk: flutter
cupertino_icons: ^1.0.8
```
`dev_dependencies` กล่าวถึงไลบรารีที่โปรเจกต์พึ่งพา#emph([ในการพัฒนา]) หมายความว่า
ไลบรารีเหล่านี้จะไม่ถูกใส่เข้าไปยังแอพลิเคชันของคุณโดยตรง โดยตามค่าเริ่มต้นแล้ว จะมีแพคเกจ
`flutter_test` ที่ถูกดึงมาจาก Flutter SDK โดยตรง และมี `flutter_lints`
สำหรับการตรวจข้อผิดพลาดในโคด
```yaml
dev_dependencies:
flutter_test:
sdk: flutter
flutter_lints: ^6.0.0
```
`flutter` เป็นการตั้งค่าเกี่ยวกับ Flutter โดยที่ตามค่าเริ่มต้นแล้วจะมีค่า `uses-material-design`
มาให้เป็น `true` ซึ่งจะเป็นการบอกกับ Flutter ว่าแอพลิเคชันนั้นใช้ Material design
```yaml
flutter:
uses-material-design: true
```
และนอกจากนั้นแล้ว ในส่วนของ `flutter`
นี้จะเป็นส่วนที่ลิสต์รายการไฟล์เพิ่มเติมที่ต้องการใส่เข้าไปในแอพลิเคชันด้วยเช่นกัน ตัวอย่างเช่น
โครงงานนี้มีการเพิ่มเติมในส่วน `flutter` ดังนี้:
```yaml
assets:
- assets/certificates/rootCA.crt
```
โดยจะเป็นการเพิ่มไฟล์ใบรับรอง `rootCA.crt` เข้าไปกับแอพลิเคชันเพื่อใช้ในการส่งคำขอ HTTPS
ไปยังอุปกรณ์ของโครงงาน
#pagebreak()
== ระบบการดีไซน์ == ระบบการดีไซน์
โดยใน Flutter แล้วนั้น ไม่รวมแพคเกจบุคคลที่สาม จะมีระบบการดีไซน์อยู่สองแบบคือ: #iii โดยใน Flutter แล้วนั้น ไม่รวมแพคเกจบุคคลที่สาม จะมีระบบการดีไซน์อยู่สองแบบคือ:
+ Material Design: การดีไซน์ของ Google สำหรับ Android #[
+ Cupertino Design: การดีไซน์ของ Apple สำหรับ iOS #set enum(indent: 5.5em)
+ Material Design: การดีไซน์ของ Google สำหรับ Android
+ Cupertino Design: การดีไซน์ของ Apple สำหรับ iOS
]
*หมายเหตุ:* Cupertino Design ถูกแทนที่โดย Liquid Glass แล้ว โดยในปัจจุบันทีม Flutter #iii *หมายเหตุ:* Cupertino Design ถูกแทนที่โดย Liquid Glass แล้ว โดยในปัจจุบันทีม Flutter
กำลังทำการตรวจสอบและแก้ไขโครงสร้างระบบดีไซน์ ดังนั้น หากมีผู้พัฒนาต้องการใช้เอฟเฟกต์ Liquid กำลังทำการตรวจสอบและแก้ไขโครงสร้างระบบดีไซน์ ดังนั้น หากมีผู้พัฒนาต้องการใช้เอฟเฟกต์#jb Liquid
Glass ในแอพลิเคชัน Flutter จึงจำเป็นต้องพึงพาแพคเกจบุคคลที่สามก่อนในขณะนี้ (Flutter เวอร์ชัน Glass ในแอปพลิเคชัน Flutter จึงจำเป็นต้องพึงพาแพคเกจบุคคลที่สามก่อนในขณะนี้ (Flutter เวอร์ชัน
3.38.3 ณ เวลาที่พิมพ์) 3.38.5 ณ เวลาที่พิมพ์)
#i แอพลิเคชันในโครงงานนี้ใช้ Material Design เนื่องจากมีเป้าหมายหลักเป็นแพลตฟอร์ม Android #iii Material Design คือภาษาการดีไซน์ที่ถูกพัฒนาโดย Google และถูกเปิดตัวครั้งแรก 25 มิถุนายน
โดย Material Design คือภาษาการดีไซน์ที่ถูกพัฒนาโดย Google และถูกเปิดตัวครั้งแรก 25 มิถุนายน
2014 และมีเวอร์ชันหลัก 3 เวอร์ชันด้วยกัน โดยที่เวอร์ชันที่ 3 ถูกเปิดตัวในงาน Google I/O 2021 2014 และมีเวอร์ชันหลัก 3 เวอร์ชันด้วยกัน โดยที่เวอร์ชันที่ 3 ถูกเปิดตัวในงาน Google I/O 2021
และมีชื่อว่า "Material You" (แต่ชื่อธรรมดา "Material Design 3" ก็ยังถูกใช้งานกันอย่างปกติ) และมีชื่อว่า "Material You" (แต่ชื่อธรรมดา "Material Design 3" ก็ยังถูกใช้งานกันอย่างปกติ)#jb
และในงาน Google I/O 2025 มีการเปิดตัว "Material 3 Expressive" ซึ่งเป็นการปรับปรุงต่อจาก และในงาน Google I/O 2025 มีการเปิดตัว "Material 3 Expressive"
Material You เดิมสำหรับ Android 16 และ Wear OS 6 และสามารถดูรายละเอียดเพิ่มเติมเกี่ยวกับ ซึ่งเป็นการปรับปรุงต่อจาก#jb Material You เดิมสำหรับ Android 16 และ Wear OS 6
Material 3 ได้ที่ https://m3.material.io/ และสามารถดูรายละเอียดเพิ่มเติมเกี่ยวกับ Material 3 ได้ที่ https://m3.material.io/
== ข้อมูลเกี่ยวกับแพลตฟอร์ม == ส่วนติดต่อผู้ใช้ที่มีปฏิกิริยา
=== Android <flAndroid> #iii บนพื้นผิว Flutter เป็นเฟรมเวิร์ก UI แบบ reactive และ declarative
ซึ่งนักพัฒนาเป็นผู้จัดเตรียมการแมปจากสถานะแอปพลิเคชันไปยังสถานะอินเทอร์เฟซ
และเฟรมเวิร์กจะทำหน้าที่อัปเดตอินเทอร์เฟซขณะรันไทม์เมื่อสถานะของแอปพลิเคชันเปลี่ยนแปลง
โมเดลนี้ได้รับแรงบันดาลใจจากงานที่มาจาก Facebook สำหรับเฟรมเวิร์ก React ของพวกเขา
ซึ่งรวมถึงการทบทวนหลักการออกแบบแบบดั้งเดิมหลายประการ
#i ในการพัฒนาแอพลิเคชัน Android โดยใช้เฟรมเวิร์ก Flutter #iii ในเฟรมเวิร์ก UI แบบดั้งเดิมส่วนใหญ่ สถานะเริ่มต้นของอินเทอร์เฟซผู้ใช้จะถูกอธิบายเพียงครั้งเดียว
จำเป็นต้องใช้ส่วนประกอบเครื่องมือพัฒนา Android ดังนี้ จากนั้นจึงอัปเดตแยกกันด้วยโคดผู้ใช้ ณ รันไทม์ เพื่อตอบสนองต่อเหตุการณ์
ความท้าทายประการหนึ่งของแนวทางนี้คือ เมื่อแอปพลิเคชันมีความซับซ้อนมากขึ้น
นักพัฒนาจำเป็นต้องทราบว่าสถานะเปลี่ยนแปลงไปอย่างไรตลอดทั้ง UI ตัวอย่างเช่น พิจารณา UI ต่อไปนี้:
- Android SDK (API Level 36 ณ เวลาที่พิมพ์) #afigure(
- Android SDK Build-Tools image("Flutter/color-picker.png", width: 70%),
- Android SDK Command-line Tools alt: "หน้าต่างเลือกสี",
- Android SDK Platform-Tools caption: [หน้าต่างเลือกสี],
- Android Emulator (ไม่บังคับ)
และแนะนำให้จัดการและติดตั้งเครื่องมือเหล่านี้ผ่าน Android Studio
#i ในการติดตั้ง Android SDK ควรติดตั้ง Android SDK
ล่าสุดถึงแม้ว่าอุปกรณ์ของคุณจะใช้เวอร์ชันที่เก่ากว่านั้น
เพื่อความมั่นใจว่าแอพลิเคชันจะสามารถใช้กับอุปกรณ์ที่ใหม่ล่าสุดได้
#i แอพลิเคชัน 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) ซึ่งรวมกันแล้ว แอพลิเคชัน Android
จะสามารถติดตั้งได้บนระบบตั้งแต่ API level ขั้นต่ำจนถึง API level เป้าหมาย หรือก็คือ
แอพลิเคชันในโครงงานนี้สามารถติดตั้งได้ตั้งแต่บนระบบ Android 7 ถึง Android 16 นั่นเอง
==== Java/Kotlin
#i Java และ Kotlin เป็นภาษาสำคัญสำหรับการพัฒนาแอพลิเคชัน Android ถึงอย่างไรก็ตาม แอพลิเคชัน
Flutter นั้นถูกเขียนด้วยภาษา Dart แต่ยังจำเป็นต้องมีโคด Java และ Kotlin
เล็กน้อยเพื่อเริ่มต้นแอพลิเคชัน Flutter
#i โดยปกติแล้ว Flutter จะสร้างโคดพื้นฐานขึ้นมาให้สำหรับการเริ่มแอพลิเคชันแบบพื้นฐาน
(อยู่ภายในโฟลเดอร์ `java` และ `kotlin` ตามที่ถูกกล่าวถึงใน@flStructure)
ดังนั้นจึงไม่จำเป็นต้องมีการเขียนโคด Java หรือ Kotlin เอง แต่ในบางกรณี
อาจต้องเขียนโคดเพิ่มเองหากมีความต้องการเข้าถึงฟีเจอร์พื้นฐานระบบที่ Flutter ไม่มี API
เพื่อให้เข้าถึงได้และไม่มีแพคเกจเพื่อรองรับฟีเจอร์ที่ต้องการ
#i โครงการนี้ใช้ Java 21 (JetBrains Runtime/Azul Zulu OpenJDK) เป็นหลักในการทำงานกับ
Gradle แต่แอพลิเคชัน Android ที่ผลิตออกมานั้น เพื่อให้เข้ากับเวอร์ชันที่เก่ากว่าของระบบปฏิบัติการได้ ใช้
Java 11
==== Gradle
#i Gradle เป็นเครื่องมือสร้างระบบอัตโนมัติสำหรับการพัฒนาซอฟต์แวร์หลายภาษา จัดการงานต่าง ๆ เช่น
การคอมไพล์ การแพ็คเกจ การทดสอบ การปรับใช้ และการเผยแพร่ ภาษาที่รองรับ ได้แก่ Java
(รวมถึงภาษา Kotlin, Groovy, Scala ที่ใช้ JDK), C/C++ และ JavaScript Gradle
พัฒนาต่อยอดจากแนวคิดของ Apache Ant และ Apache Maven และนำเสนอภาษาเฉพาะโดเมนที่ใช้
Groovy และ Kotlin ซึ่งต่างจากการกำหนดค่าโครงการที่ใช้ XML ที่ Maven ใช้ Gradle
ใช้กราฟแบบอะไซคลิกกำกับทิศทางเพื่อจัดการการอ้างอิง กราฟนี้ใช้เพื่อกำหนดลำดับของงานที่ควรดำเนินการ
Gradle ทำงานบน Java Virtual Machine
#i Gradle คือเครื่องมือหลักที่ใช้ในการจัดการโปรเจกต์ Java ส่วนใหญ่ รวมถึงโปรเจกต์ Android
โดยในโครงการนี้ จะใช้ Gradle เวอร์ชัน 8.14.3 เป็นหลัก
#i โดยปกติแล้ว ผู้พัฒนานั้นไม่มีความจำเป็นที่จะต้องแตะต้อง Gradle ด้วยตนเอง และ Flutter
จะทำการจัดการเอง แต่หากมีความจำเป็นต้องใช้คำสั่ง Gradle ด้วยตนเอง จะมีสคริปต์ `gradlew` (หรือ
`gradlew.bat` สำหรับผู้ใช้ Windows) ภายในโฟลเดอร์ `android` ของโปรเจกต์ Flutter
เสมอเพื่อเรียกใช้ Gradle ที่ถูกดาวน์โหลดมาสำหรับโปรเจกต์นั้น ๆ
=== Linux <flLinuxDetails>
#i เช่นเดียวกับ Android ที่กล่าวไปข้างต้น Flutter มีการสร้างโคดสำหรับการเปิดแอพลิเคชันแบบพื้นฐาน
แต่สำหรับ Linux แล้วนั้น Flutter ใช้โคด C++ และเฟรมเวิร์ก CMake
ในการสร้างรากฐานของแอพลิเคชัน
#i ในการพัฒนาแอพลิเคชันสำหรับ Linux ต้องติดตั้งโปรแกรมเพิ่มเติม (build dependencies)
ขยายความคือ ด้านบนคือสิ่งที่จำเป็นหากมีระบบอื่นเป็นเป้าหมาย แต่หากต้องการพัฒนาแอพลิเคชัน Linux
ต้องติดตั้งโปรแกรมในรายการด้านล่างเพิ่ม
#grid(
columns: 2,
column-gutter: 1in,
[
- GTK 3 (ไลบรารีสำหรับการพัฒนา)
- pkg-config
- ไลบรารี GNU Standard C++ v3
],
[
- Clang
- CMake
- Ninja
],
) )
#i การติดตั้งไลบรารีและโปรแกรมที่กล่าวไปข้างต้นจะแตกต่างกันไปแต่ละการแจกจ่าย Linux และ #iii มีหลายที่ที่สามารถเปลี่ยนสถานะได้: กล่องสี, แถบเลื่อนเฉดสี, ​​ปุ่มตัวเลือก เมื่อผู้ใช้โต้ตอบกับ UI
Flutter ใช้ไลบรารีพื้นฐานดังกล่าวในการทำงานของแอพลิเคชัน (runtime dependencies) การเปลี่ยนแปลงจะต้องสะท้อนให้เห็นในทุกที่ ที่เลวร้ายยิ่งกว่านั้น เว้นแต่จะได้รับการดูแล
การเปลี่ยนแปลงเล็กน้อยในส่วนใดส่วนหนึ่งของอินเทอร์เฟซผู้ใช้อาจทำให้เกิดเอฟเฟกต์คลื่นส่งผลกระทบกับโค้ดที่ดูเหมือนจะไม่เกี่ยวข้องกัน
- GTK 3 #iii วิธีแก้ปัญหาอย่างหนึ่งคือแนวทางเช่น MVC
- blkid โดยที่คุณส่งข้อมูลการเปลี่ยนแปลงไปยังโมเดลผ่านคอนโทรลเลอร์
- LZMA จากนั้นโมเดลจะพุชสถานะใหม่ไปยังมุมมองผ่านคอนโทรลเลอร์ อย่างไรก็ตาม#jb สิ่งนี้ก็เป็นปัญหาเช่นกัน
เนื่องจากการสร้างและการอัปเดตองค์ประกอบ UI
เป็นขั้นตอนสองขั้นตอนที่แยกจากกันซึ่งอาจไม่ซิงค์กันได้อย่างง่ายดาย
แต่โดยทั่วไปแล้ว ไลบรารีเหล่านี้ควรถูกติดตั้งมาอยู่แล้วหากคุณใช้ graphical desktop ทั่วไป #iii Flutter พร้อมด้วยเฟรมเวิร์กเชิงโต้ตอบอื่น ๆ ใช้แนวทางอื่นในการแก้ไขปัญหานี้
โดยแยกอินเทอร์เฟซผู้ใช้ออกจากสถานะพื้นฐานอย่างชัดเจน ด้วย API สไตล์ React
คุณจะสร้างเฉพาะคำอธิบาย UI เท่านั้น
และเฟรมเวิร์กจะดูแลการใช้การกำหนดค่านั้นเพื่อสร้างหรืออัปเดตอินเทอร์เฟซผู้ใช้ตามความเหมาะสม
==== Debian #iii ใน Flutter วิดเจ็ต (คล้ายกับส่วนประกอบใน React)
จะแสดงด้วยคลาสที่ไม่เปลี่ยนรูปซึ่งใช้ในการกำหนดค่าแผนผังของวัตถุ
วิดเจ็ตเหล่านี้ถูกใช้เพื่อจัดการแผนผังวัตถุที่แยกจากกันสำหรับโครงร่าง
ซึ่งจากนั้นจะใช้ในการจัดการแผนผังวัตถุที่แยกจากกันสำหรับการประกอบ หัวใจหลักของ Flutter
คือชุดของกลไกในการอัพเดทส่วนที่ดัดแปลงของแผนผังวิดเจ็ตอย่างมีประสิทธิภาพ
การแปลงแผนผังหลายแผนผังของวัตถุให้เป็นแผนผังระดับล่างของวัตถุ
และการแพร่กระจายการเปลี่ยนแปลงไปยังแผนผังวิดเจ็ตเหล่านี้
```sh #iii วิดเจ็ตประกาศส่วนติดต่อผู้ใช้โดยการเขียนทับเมธอด `build()` ซึ่งเป็นฟังก์ชันที่แปลงสถานะเป็น
# Development dependencies: UI:
sudo apt install curl git unzip xz-utils zip libglu1-mesa
# Linux build dependencies: #afigure(
sudo apt install clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-12-dev ```
UI = f(state)
```,
kind: image,
caption: [สูตรแสดงการทำงานอย่างคร่าว],
)
# Runtime dependencies: #iii เมธอด `build()` นั้นตามการออกแบบแล้วเป็นเมธอดที่เร็วและควรที่จะไม่มีผลข้างเคียง
sudo apt install libgtk-3-0 libblkid1 liblzma5 ทำให้เมธอดนั้นสามารถถูกเรียกใช้โดยเฟรมเวิร์กเมื่อไหร่ก็ได้ที่จำเป็น
``` (เป็นไปได้ที่จะบ่อยมากและมีการเรียกใช้หนึ่งครั้งต่อหนึ่งเฟรม)
==== Fedora Linux #iii วิธีนี้พึ่งพาลักษณะเฉพาะรันไทม์ภาษา (หากเจาะจงคือการสร้างและทำลายวัตถุอย่างรวดเร็ว) ซึ่ง
Dart นั้นเหมาะสำหรับงานนี้เป็นพิเศษ
```sh == ประวัติ
# Development dependencies:
sudo dnf install curl git unzip xz zip mesa-libglu
# Linux build dependencies: #iii Flutter เวอร์ชันแรกรู้จักกันในชื่อ "Sky" และทำงานบนระบบปฏิบัติการ Android
sudo dnf install clang cmake ninja-build pkgconf gtk3 มีการเปิดเผยในการประชุมสุดยอดนักพัฒนา Dart ประจำปี 2015
โดยมีจุดประสงค์ที่ระบุไว้คือสามารถแสดงผลได้อย่างสม่ำเสมอที่ 120 เฟรมต่อวินาที เมื่อวันที่ 4 ธันวาคม
2018 Flutter 1.0 เปิดตัวในการประชุม Flutter ที่ลอนดอน
# Runtime dependencies: #iii ในวันที่ 6 พฤษภาคม 2020 ชุดพัฒนาซอฟต์แวร์ (SDK) Dart เวอร์ชัน 2.8 และ Flutter 1.17.0
sudo dnf install gtk3 libblkid xz ได้รับการเผยแพร่ โดยเพิ่มการรองรับ Metal API
```
==== Arch Linux #iii เมื่อวันที่ 3 มีนาคม 2021 Google ได้เปิดตัว Flutter 2 ระหว่างกิจกรรม Flutter Engage
ออนไลน์ ได้เพิ่มตัวเรนเดอร์ที่ใช้ Canvas สำหรับเว็บ นอกเหนือจากตัวเรนเดอร์ที่ใช้ HTML
และการสนับสนุนแอปพลิเคชันเดสก์ท็อปแบบทดลองสำหรับ Windows, macOS, และ Linux
นอกจากนี้ยังมาพร้อมกับ Dart 2.0 ซึ่งรวมถึงการสนับสนุนด้านความปลอดภัยแบบ null (null-safety)
ความปลอดภัยแบบ null เป็นทางเลือกในตอนแรกเนื่องจากเป็นการเปลี่ยนแปลงครั้งใหญ่และบังคับใช้ใน
Dart 3 ที่เปิดตัวในปี 2023
```sh #iii ในวันที่ 12 พฤษภาคม 2022 Flutter 3 และ Dart 2.17
# Development dependencies: ได้รับการเผยแพร่โดยมีการรองรับแพลตฟอร์มเดสก์ท็อปทั้งหมดอย่างเสถียร
sudo pacman -S --needed curl git unzip xz zip glu
# Linux build dependencies: #iii เมื่อวันที่ 27 ตุลาคม 2024 นักพัฒนาชุมชน Flutter จำนวนหนึ่งได้ประกาศเปิดตัว Flock
sudo pacman -S --needed clang cmake ninja pkgconf gtk3 ซึ่งเป็นเวอร์ชันแยกของ Flutter ที่มีจุดประสงค์เพื่อให้ง่ายต่อการร่วมพัฒนา
ในขณะเดียวกันก็ยังคงรักษาความสอดคล้องกับทุกการเปลี่ยนแปลงที่เกิดขึ้นในโค้ดต้นทาง
# Runtime dependencies: #iii ในปี 2025 Google ยังคงพัฒนา Flutter ต่อไปด้วยสถาปัตยกรรมแบบโมดูลาร์ที่ได้รับการปรับปรุง
sudo pacman -S --needed util-linux-libs xz gtk3 การรองรับอุปกรณ์พับได้ และการเพิ่มประสิทธิภาพ ARM IoT ตามที่ระบุไว้ในแผนงานฉบับปรับปรุง
```
=== macOS/iOS
#i การพัฒนาแอพลิเคชันสำหรับ macOS และ iOS นั้นต้องทำบน macOS
เท่านั้นและจำเป็นต้องพึ่งพาเครื่องมือ Xcode แต่เนื่องจากในโครงงานนี้ไม่มีผู้ใช้ macOS
จึงไม่สามารถสร้างไบนารีสำหรับ macOS และ iOS ออกมาได้ และไม่ใช่เป้าหมายของโครงงานนี้เช่นกัน
Chapter2/Flutter/app-anatomy.svg
+72
View File
File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 59 KiB

Chapter2/Flutter/archdiagram.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 106 KiB

Chapter2/Flutter/color-picker.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 101 KiB

Chapter2/Flutter/desktopExampleApp.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 37 KiB

Chapter2/Flutter/mobileExampleApp.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 62 KiB

Chapter2/Flutter/newProjectPage.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 63 KiB

Chapter2/Git.typ
+8 -8
View File
@@ -2,14 +2,14 @@
= Git = Git
#i Git เป็นระบบซอฟต์แวร์ควบคุมเวอร์ชันแบบกระจาย ที่สามารถจัดการเวอร์ชันของซอร์สโคดหรือข้อมูลได้ มักใช้เพื่อควบคุมซอร์สโคดโดยโปรแกรมเมอร์ที่พัฒนาซอฟต์แวร์ร่วมกัน #i Git เป็นระบบซอฟต์แวร์ควบคุมเวอร์ชันแบบกระจาย ที่สามารถจัดการเวอร์ชันของซอร์สโคดหรือข้อมูลได้
มักใช้เพื่อควบคุมซอร์สโคดโดยโปรแกรมเมอร์ที่พัฒนาซอฟต์แวร์ร่วมกัน
== Gitea == Gitea
#i Gitea เป็นชุดซอฟต์แวร์ forge สำหรับการโฮสต์ระบบควบคุมเวอร์ชันการพัฒนาซอฟต์แวร์โดยใช้ Git รวมถึงฟีเจอร์การทำงานร่วมกันอื่น ๆ เช่น การติดตามบั๊ก การตรวจสอบโคด การผสานรวมอย่างต่อเนื่อง (Continuous Integration; CI) กระดาน Kanban ระบบรายงานปัญหา และวิกิ รองรับการโฮสต์ด้วยตนเอง และยังมีอินสแตนซ์สาธารณะของบุคคลที่หนึ่งให้ใช้งานฟรีอีกด้วย Gitea เป็นส่วนหนึ่งของ Gogs และเขียนด้วยภาษา Go Gitea สามารถโฮสต์ได้บนทุกแพลตฟอร์มที่รองรับ Go รวมถึง FreeBSD, Linux, macOS และ Windows โครงการนี้ได้รับทุนสนับสนุนจาก Open Collective #iii Gitea เป็นชุดซอฟต์แวร์ forge สำหรับการโฮสต์ระบบควบคุมเวอร์ชันการพัฒนาซอฟต์แวร์โดยใช้ Git
รวมถึงฟีเจอร์การทำงานร่วมกันอื่น ๆ เช่น การติดตามบั๊ก การตรวจสอบโคด การผสานรวมอย่างต่อเนื่อง
#i โครงงานนี้ใช้ Gitea (self-hosted) ในการโฮสต์โคดของโครงงาน โดยมี repository หลัก ๆ ดังนี้ (Continuous Integration; CI) กระดาน Kanban ระบบรายงานปัญหา และวิกิ
รองรับการโฮสต์ด้วยตนเอง และยังมีอินสแตนซ์สาธารณะของบุคคลที่หนึ่งให้ใช้งานฟรีอีกด้วย Gitea
- https://gitskette.dailitation.xyz/linesofcodes/liteauth-firmware32 - เฟิร์มแวร์ ESP32 เป็นส่วนหนึ่งของ Gogs และเขียนด้วยภาษา Go Gitea สามารถโฮสต์ได้บนทุกแพลตฟอร์มที่รองรับ Go
- https://gitskette.dailitation.xyz/linesofcodes/liteauthconfig - แอพลิเคชัน Flutter ตั้งค่าอุปกรณ์ รวมถึง FreeBSD, Linux, macOS และ Windows โครงการนี้ได้รับทุนสนับสนุนจาก Open Collective
- https://gitskette.dailitation.xyz/linesofcodes/liteauthdocs - เอกสารโครงงานเล่มนี้
Chapter2/HTTPS.typ
+15 -15
View File
@@ -25,7 +25,7 @@ Foundation; EFF) ด้วยการสนับสนุนจากนัก
== โดยรวม == โดยรวม
#i รูปแบบ Uniform Resource Identifier (URI) ของ HTTPS #iii รูปแบบ Uniform Resource Identifier (URI) ของ HTTPS
มีรูปแบบการใช้งานที่เหมือนกันกับรูปแบบ HTTP อย่างไรก็ตาม HTTPS มีรูปแบบการใช้งานที่เหมือนกันกับรูปแบบ HTTP อย่างไรก็ตาม HTTPS
จะส่งสัญญาณให้เบราว์เซอร์ใช้ชั้นการเข้ารหัสเพิ่มเติมของ SSL/TLS เพื่อปกป้องการรับส่งข้อมูลซึ่ง SSL/TLS จะส่งสัญญาณให้เบราว์เซอร์ใช้ชั้นการเข้ารหัสเพิ่มเติมของ SSL/TLS เพื่อปกป้องการรับส่งข้อมูลซึ่ง SSL/TLS
เหมาะอย่างยิ่งสำหรับ HTTP เหมาะอย่างยิ่งสำหรับ HTTP
@@ -34,11 +34,11 @@ Foundation; EFF) ด้วยการสนับสนุนจากนัก
ซึ่งโดยทั่วไปมีเพียงเซิร์ฟเวอร์เท่านั้นที่ได้รับการรับรองความถูกต้อง ซึ่งโดยทั่วไปมีเพียงเซิร์ฟเวอร์เท่านั้นที่ได้รับการรับรองความถูกต้อง
(โดยไคลเอนต์ตรวจสอบใบรับรองของเซิร์ฟเวอร์) (โดยไคลเอนต์ตรวจสอบใบรับรองของเซิร์ฟเวอร์)
#i HTTPS สร้างช่องทางที่ปลอดภัยบนเครือข่ายที่ไม่ปลอดภัย #iii HTTPS สร้างช่องทางที่ปลอดภัยบนเครือข่ายที่ไม่ปลอดภัย
วิธีนี้ช่วยให้มั่นใจได้ถึงการป้องกันที่เหมาะสมจากผู้ดักฟังและการโจมตีแบบ man-in-the-middle วิธีนี้ช่วยให้มั่นใจได้ถึงการป้องกันที่เหมาะสมจากผู้ดักฟังและการโจมตีแบบ man-in-the-middle
โดยมีเงื่อนไขว่ามีการใช้ชุดการเข้ารหัสที่เหมาะสม และใบรับรองเซิร์ฟเวอร์ได้รับการตรวจสอบและเชื่อถือได้ โดยมีเงื่อนไขว่ามีการใช้ชุดการเข้ารหัสที่เหมาะสม และใบรับรองเซิร์ฟเวอร์ได้รับการตรวจสอบและเชื่อถือได้
#i เนื่องจาก HTTPS เชื่อมโยง HTTP ทั้งหมดเข้ากับ TLS โดยตรงจึงสามารถเข้ารหัสโปรโตคอล HTTP #iii เนื่องจาก HTTPS เชื่อมโยง HTTP ทั้งหมดเข้ากับ TLS โดยตรงจึงสามารถเข้ารหัสโปรโตคอล HTTP
พื้นฐานทั้งหมดได้ ซึ่งรวมถึง URL ของคำขอ พารามิเตอร์การค้นหา ส่วนหัว และคุกกี้ พื้นฐานทั้งหมดได้ ซึ่งรวมถึง URL ของคำขอ พารามิเตอร์การค้นหา ส่วนหัว และคุกกี้
(ซึ่งมักจะมีข้อมูลระบุตัวตนของผู้ใช้) อย่างไรก็ตาม (ซึ่งมักจะมีข้อมูลระบุตัวตนของผู้ใช้) อย่างไรก็ตาม
เนื่องจากที่อยู่เว็บไซต์และหมายเลขพอร์ตเป็นส่วนหนึ่งของโปรโตคอล TCP/IP พื้นฐาน HTTPS เนื่องจากที่อยู่เว็บไซต์และหมายเลขพอร์ตเป็นส่วนหนึ่งของโปรโตคอล TCP/IP พื้นฐาน HTTPS
@@ -48,8 +48,8 @@ Foundation; EFF) ด้วยการสนับสนุนจากนัก
แต่ไม่สามารถอนุมานส่วนที่เหลือของ URL) ที่ผู้ใช้กำลังสื่อสารด้วย แต่ไม่สามารถอนุมานส่วนที่เหลือของ URL) ที่ผู้ใช้กำลังสื่อสารด้วย
รวมถึงปริมาณข้อมูลที่ถ่ายโอนและระยะเวลาของการสื่อสาร แต่อย่างไรก็ตามไม่รวมถึงเนื้อหาของการสื่อสาร รวมถึงปริมาณข้อมูลที่ถ่ายโอนและระยะเวลาของการสื่อสาร แต่อย่างไรก็ตามไม่รวมถึงเนื้อหาของการสื่อสาร
#i เว็บเบราว์เซอร์รู้วิธีเชื่อถือเว็บไซต์ HTTPS โดยอ้างอิงจากผู้ให้บริการออกใบรับรอง (Certificate #iii เว็บเบราว์เซอร์รู้วิธีเชื่อถือเว็บไซต์ HTTPS โดยอ้างอิงจากผู้ให้บริการออกใบรับรอง#jb
Authority) ที่ติดตั้งไว้ล่วงหน้าในซอฟต์แวร์ (Certificate Authority) ที่ติดตั้งไว้ล่วงหน้าในซอฟต์แวร์
ผู้สร้างเว็บเบราว์เซอร์จึงไว้วางใจผู้ให้บริการออกใบรับรองในการออกใบรับรองที่ถูกต้อง ดังนั้น ผู้สร้างเว็บเบราว์เซอร์จึงไว้วางใจผู้ให้บริการออกใบรับรองในการออกใบรับรองที่ถูกต้อง ดังนั้น
ผู้ใช้ควรเชื่อถือการเชื่อมต่อ HTTPS ไปยังเว็บไซต์ก็ต่อเมื่อเป็นไปตามเงื่อนไขทั้งหมดต่อไปนี้: ผู้ใช้ควรเชื่อถือการเชื่อมต่อ HTTPS ไปยังเว็บไซต์ก็ต่อเมื่อเป็นไปตามเงื่อนไขทั้งหมดต่อไปนี้:
@@ -64,7 +64,7 @@ Authority) ที่ติดตั้งไว้ล่วงหน้าใน
ใบรับรองที่ได้รับนั้นถูกต้องสำหรับ example.com และไม่ใช่ของหน่วยงานอื่น) ใบรับรองที่ได้รับนั้นถูกต้องสำหรับ example.com และไม่ใช่ของหน่วยงานอื่น)
- ผู้ใช้เชื่อมั่นว่าเลเยอร์การเข้ารหัสของโปรโตคอล (SSL/TLS) มีความปลอดภัยเพียงพอจากการดักฟัง - ผู้ใช้เชื่อมั่นว่าเลเยอร์การเข้ารหัสของโปรโตคอล (SSL/TLS) มีความปลอดภัยเพียงพอจากการดักฟัง
#i HTTPS มีความสำคัญอย่างยิ่งต่อเครือข่ายที่ไม่ปลอดภัยและเครือข่ายที่อาจถูกแทรกแซง #iii HTTPS มีความสำคัญอย่างยิ่งต่อเครือข่ายที่ไม่ปลอดภัยและเครือข่ายที่อาจถูกแทรกแซง
เครือข่ายที่ไม่ปลอดภัย เช่น จุดเชื่อมต่อ Wi-Fi สาธารณะ เครือข่ายที่ไม่ปลอดภัย เช่น จุดเชื่อมต่อ Wi-Fi สาธารณะ
ซึ่งเปิดโอกาสให้ทุกคนในเครือข่ายท้องถิ่นเดียวกันสามารถดักจับแพ็กเก็ตและค้นพบข้อมูลสำคัญที่ไม่ได้รับการป้องกันโดย ซึ่งเปิดโอกาสให้ทุกคนในเครือข่ายท้องถิ่นเดียวกันสามารถดักจับแพ็กเก็ตและค้นพบข้อมูลสำคัญที่ไม่ได้รับการป้องกันโดย
HTTPS นอกจากนี้ ยังพบว่าเครือข่าย WLAN HTTPS นอกจากนี้ ยังพบว่าเครือข่าย WLAN
@@ -72,22 +72,22 @@ HTTPS นอกจากนี้ ยังพบว่าเครือข่
การกระทำเช่นนี้สามารถถูกนำไปใช้ในทางที่ผิดได้หลายวิธี เช่น การกระทำเช่นนี้สามารถถูกนำไปใช้ในทางที่ผิดได้หลายวิธี เช่น
การฉีดมัลแวร์ลงในหน้าเว็บและการขโมยข้อมูลส่วนบุคคลของผู้ใช้ การฉีดมัลแวร์ลงในหน้าเว็บและการขโมยข้อมูลส่วนบุคคลของผู้ใช้
#i เมื่อมีข้อมูลมากขึ้นเกี่ยวกับการเฝ้าระวังมวลชนทั่วโลกและการขโมยข้อมูลส่วนบุคคลของอาชญากร #iii เมื่อมีข้อมูลมากขึ้นเกี่ยวกับการเฝ้าระวังมวลชนทั่วโลกและการขโมยข้อมูลส่วนบุคคลของอาชญากร
การใช้ระบบรักษาความปลอดภัย HTTPS บนเว็บไซต์ทั้งหมดจึงมีความสำคัญเพิ่มมากขึ้นเรื่อยๆ การใช้ระบบรักษาความปลอดภัย HTTPS บนเว็บไซต์ทั้งหมดจึงมีความสำคัญเพิ่มมากขึ้นเรื่อยๆ
โดยไม่คำนึงถึงประเภทของการเชื่อมต่ออินเทอร์เน็ตที่ใช้งาน โดยไม่คำนึงถึงประเภทของการเชื่อมต่ออินเทอร์เน็ตที่ใช้งาน
แม้ว่าข้อมูลเมตาเกี่ยวกับหน้าเว็บแต่ละหน้าที่ผู้ใช้เข้าชมอาจไม่ถือว่ามีความละเอียดอ่อน แม้ว่าข้อมูลเมตาเกี่ยวกับหน้าเว็บแต่ละหน้าที่ผู้ใช้เข้าชมอาจไม่ถือว่ามีความละเอียดอ่อน
แต่เมื่อนำมารวมกันแล้ว ข้อมูลเมตาเหล่านี้อาจเปิดเผยข้อมูลเกี่ยวกับผู้ใช้ได้มาก แต่เมื่อนำมารวมกันแล้ว ข้อมูลเมตาเหล่านี้อาจเปิดเผยข้อมูลเกี่ยวกับผู้ใช้ได้มาก
และกระทบต่อความเป็นส่วนตัวของผู้ใช้ และกระทบต่อความเป็นส่วนตัวของผู้ใช้
#i การปรับใช้ HTTPS ยังอนุญาตให้ใช้ HTTP/2 และ HTTP/3 (และรุ่นก่อนหน้าอย่าง SPDY และ QUIC) #iii การปรับใช้ HTTPS ยังอนุญาตให้ใช้ HTTP/2 และ HTTP/3 (และรุ่นก่อนหน้าอย่าง SPDY และ
ซึ่งเป็น HTTP เวอร์ชันใหม่ที่ออกแบบมาเพื่อลดเวลา ขนาด และความหน่วงในการโหลดหน้าเว็บ QUIC) ซึ่งเป็น HTTP เวอร์ชันใหม่ที่ออกแบบมาเพื่อลดเวลา ขนาด และความหน่วงในการโหลดหน้าเว็บ
#i และมีการแนะนำให้ใช้ HTTP Strict Transport Security (HSTS) ร่วมกับ HTTPS #iii และมีการแนะนำให้ใช้ HTTP Strict Transport Security (HSTS) ร่วมกับ HTTPS
เพื่อป้องกันผู้ใช้จากการโจมตีแบบ man-in-the-middle โดยเฉพาะอย่างยิ่ง SSL stripping เพื่อป้องกันผู้ใช้จากการโจมตีแบบ man-in-the-middle โดยเฉพาะอย่างยิ่ง SSL stripping
== ความปลอดภัย == ความปลอดภัย
#i ความปลอดภัยของ HTTPS อยู่ที่ TLS พื้นฐาน #iii ความปลอดภัยของ HTTPS อยู่ที่ TLS พื้นฐาน
ซึ่งโดยทั่วไปจะใช้คีย์สาธารณะและคีย์ส่วนตัวระยะยาวเพื่อสร้างคีย์เซสชันระยะสั้น ซึ่งโดยทั่วไปจะใช้คีย์สาธารณะและคีย์ส่วนตัวระยะยาวเพื่อสร้างคีย์เซสชันระยะสั้น
ซึ่งจะถูกนำไปใช้ในการเข้ารหัสการไหลของข้อมูลระหว่างไคลเอนต์และเซิร์ฟเวอร์ ใบรับรอง X.509 ซึ่งจะถูกนำไปใช้ในการเข้ารหัสการไหลของข้อมูลระหว่างไคลเอนต์และเซิร์ฟเวอร์ ใบรับรอง X.509
ถูกใช้เพื่อยืนยันตัวตนของเซิร์ฟเวอร์ (และบางครั้งรวมถึงไคลเอนต์ด้วย) ด้วยเหตุนี้ ถูกใช้เพื่อยืนยันตัวตนของเซิร์ฟเวอร์ (และบางครั้งรวมถึงไคลเอนต์ด้วย) ด้วยเหตุนี้
@@ -100,10 +100,10 @@ HTTPS นอกจากนี้ ยังพบว่าเครือข่
ซึ่งรับประกันว่าการสื่อสารที่เข้ารหัสที่บันทึกไว้ในอดีตจะไม่สามารถดึงข้อมูลและถอดรหัสได้ ซึ่งรับประกันว่าการสื่อสารที่เข้ารหัสที่บันทึกไว้ในอดีตจะไม่สามารถดึงข้อมูลและถอดรหัสได้
หากคีย์ลับหรือรหัสผ่านระยะยาวถูกบุกรุกในอนาคต ไม่ใช่ทุกเว็บเซิร์ฟเวอร์ที่จะมีระบบความลับแบบส่งต่อ หากคีย์ลับหรือรหัสผ่านระยะยาวถูกบุกรุกในอนาคต ไม่ใช่ทุกเว็บเซิร์ฟเวอร์ที่จะมีระบบความลับแบบส่งต่อ
#i เพื่อให้ HTTPS มีประสิทธิภาพ เว็บไซต์จะต้องโฮสต์ผ่าน HTTPS ทั้งหมด #iii เพื่อให้ HTTPS มีประสิทธิภาพ เว็บไซต์จะต้องโฮสต์ผ่าน HTTPS ทั้งหมด
หากเนื้อหาบางส่วนของเว็บไซต์ถูกโหลดผ่าน HTTP (เช่น สคริปต์หรือรูปภาพ) หากเนื้อหาบางส่วนของเว็บไซต์ถูกโหลดผ่าน HTTP (เช่น สคริปต์หรือรูปภาพ)
หรือหากโหลดเฉพาะหน้าที่มีข้อมูลละเอียดอ่อน เช่น หน้าเข้าสู่ระบบ ผ่าน HTTPS ขณะที่ส่วนอื่นๆ หรือหากโหลดเฉพาะหน้าที่มีข้อมูลละเอียดอ่อน เช่น หน้าเข้าสู่ระบบ ผ่าน HTTPS ขณะที่ส่วนอื่น ๆ
ของเว็บไซต์ผ่าน HTTP ธรรมดา ผู้ใช้จะเสี่ยงต่อการถูกโจมตีและการเฝ้าระวัง นอกจากนี้ ของเว็บไซต์ผ่าน HTTP ธรรมดา#jb ผู้ใช้จะเสี่ยงต่อการถูกโจมตีและการเฝ้าระวัง นอกจากนี้
คุกกี้บนเว็บไซต์ที่รันผ่าน HTTPS จะต้องเปิดใช้งานแอตทริบิวต์ secure ในเว็บไซต์ที่มีข้อมูลละเอียดอ่อน คุกกี้บนเว็บไซต์ที่รันผ่าน HTTPS จะต้องเปิดใช้งานแอตทริบิวต์ secure ในเว็บไซต์ที่มีข้อมูลละเอียดอ่อน
ผู้ใช้และเซสชันจะถูกเปิดเผยทุกครั้งที่เข้าถึงเว็บไซต์นั้นด้วย HTTP แทนที่จะเป็น HTTPS ผู้ใช้และเซสชันจะถูกเปิดเผยทุกครั้งที่เข้าถึงเว็บไซต์นั้นด้วย HTTP แทนที่จะเป็น HTTPS
@@ -179,7 +179,7 @@ Microsoft Internet Explorer ของ Apple ที่ใช้คุณสมบ
===== การเพิกถอนใบรับรอง ===== การเพิกถอนใบรับรอง
#iiiiii ใบรับรองอาจถูกเพิกถอนก่อนหมดอายุได้ เช่น เนื่องจากความลับของคีย์ส่วนตัวถูกละเมิด #iiiiii ใบรับรองอาจถูกเพิกถอนก่อนหมดอายุได้ เช่น เนื่องจากความลับของคีย์ส่วนตัวถูกละเมิด
เบราว์เซอร์ยอดนิยมเวอร์ชันที่ใหม่พอเช่น Firefox Opera และ Internet Explorer บน Windows เบราว์เซอร์ยอดนิยมเวอร์ชันที่ใหม่พอเช่น Firefox Opera และ#jb Internet Explorer บน Windows
Vista จะใช้ Online Certificate Status Protocol (OCSP) เพื่อตรวจสอบว่าไม่เป็นเช่นนั้น Vista จะใช้ Online Certificate Status Protocol (OCSP) เพื่อตรวจสอบว่าไม่เป็นเช่นนั้น
เบราว์เซอร์จะส่งหมายเลขซีเรียลของใบรับรองไปยังผู้ออกใบรับรองหรือผู้แทนผ่าน OCSP เบราว์เซอร์จะส่งหมายเลขซีเรียลของใบรับรองไปยังผู้ออกใบรับรองหรือผู้แทนผ่าน OCSP
และผู้ออกใบรับรองจะตอบกลับ โดยแจ้งให้เบราว์เซอร์ทราบว่าใบรับรองยังคงใช้ได้อยู่หรือไม่ นอกจากนี้ CA และผู้ออกใบรับรองจะตอบกลับ โดยแจ้งให้เบราว์เซอร์ทราบว่าใบรับรองยังคงใช้ได้อยู่หรือไม่ นอกจากนี้ CA
Chapter2/Intro.typ
+23 -18
View File
@@ -23,21 +23,26 @@
== ไมโครคอนโทรเลอร์ (Microcontroller) == ไมโครคอนโทรเลอร์ (Microcontroller)
#i ความรู้เกี่ยวกับไมโครคอนโทรลเลอร์เบื้องต้น ไมโครคอนโทรลเลอร์ (มักย่อว่า uC หรือ MCU) คือ #i ไมโครคอนโทรลเลอร์ (Microcontroller, MC, uC, หรือ #(sym.mu)C)
อุปกรณ์ควบคุมขนาดเล็ก ซึ่งบรรจุความสามารถที่คล้ายคลึงกับระบบคอมพิวเตอร์ โดยใน หรือหน่วยไมโครคอนโทรลเลอร์ (Microcontroller Unit; MCU)
ไมโครคอนโทรลเลอร์ได้รวม เอาซีพียูหน่วยความจำและพอร์ต ซึ่งเป็นส่วนประกอบหลักสำคัญของ เป็นคอมพิวเตอร์ขนาดเล็กบนวงจรรวมเดียว (Integrated Circuit; IC)
ระบบคอมพิวเตอร์เข้าไว้ด้วยกัน โดยทำการบรรจุเข้าไว้ในตัวถังเดียวกัน ไมโครคอนโทรลเลอร์ถ้าแปล โดยไมโครคอนโทรลเลอร์ประกอบด้วยแกนประมวลผลหนึ่งแกนหรือมากกว่า
ความหมายแบบตรงตัวก็คือ ระบบคอนโทรลขนาดเล็กเรียกอีกอย่างหนึ่งคือเป็นระบบคอมพิวเตอร์ ขนาดเล็ก#jb พร้อมด้วยหน่วยความจำและอุปกรณ์ต่อพ่วงอินพุต/เอาต์พุตที่ตั้งโปรแกรมได้
ที่สามารถนำมาประยุกต์ใช้งานได้หลากหลาย โดยผ่านการออกแบบวงจรให้เหมาะกับงาน ต่างๆ หน่วยความจำโปรแกรมในรูปแบบของ NOR flash, OTP ROM, หรือ ferroelectric RAM
และยังสามารถเขียนโปรแกรมคำสั่งเพื่อควบคุมขา Input/Output เพื่อสั่งงานให้ไป ควบคุม อุปกรณ์ต่าง มักจะถูกรวมไว้ในชิปด้วยเช่นกัน รวมถึง RAM จำนวนเล็กน้อย
ๆ#jb ได้อีกด้วย ซึ่งก็นับว่าเป็นระบบที่สามารถนำมาประยุกต์ใช้งานได้หลากหลาย ทั้ง ทางด้าน Digital ไมโครคอนโทรลเลอร์ได้รับการออกแบบมาสำหรับการใช้งานแบบฝังตัว
และ Analog ยกตัวอย่างเช่น ระบบสัญญาณตอบรับอัตโนมัติ, ระบบบัตรคิว, ระบบ ตอกบัตรพนักงาน และอื่นๆ ซึ่งแตกต่างจากไมโครโปรเซสเซอร์ที่ใช้ในคอมพิวเตอร์ส่วนบุคคลหรือแอปพลิเคชันทั่วไปอื่น ๆ
ยิ่งระบบไมโครคอนโทรลเลอร์ในยุคปัจจุบันนั้นสามารถทำการเชื่อต่อกับ ระบบ Network ที่ประกอบด้วยชิปแยกชิ้นต่าง ๆ
ของคอมพิวเตอร์ทั่วไปได้อีกด้วย ดังนั้นการสั่งงานจึงไม่ใช่แค่หน้าแผงวงจร แต่ อาจจะเป็นการสั่งงานอยู่คนละ
ซีกโลกผ่านเครือข่ายอินเตอร์เน็ตก็ได้โครงสร้างโดยทั่วไปของไมโครคอนโทรลเลอร์นั้น #i ในศัพท์สมัยใหม่ ไมโครคอนโทรลเลอร์นั้นคล้ายคลึงกับระบบบนชิป (System on a chip; SoC)
สามารถแบ่งออกมาได้เป็น 5 ส่วนใหญ่ ๆ ได้แก่ หน่วยประมวลผลกลาง หรือ ซีพียู, หน่วยความจำ, แต่มีความซับซ้อนน้อยกว่า SoC อาจมีไมโครคอนโทรลเลอร์เป็นส่วนประกอบหนึ่ง
ส่วนติดต่อกับอุปกรณ์ภายนอก หรือพอร์ต, ช่องทางเดินของสัญญาณ หรือบัส และ วงจรกำเนิดสัญญาณนาฬิกา#jb แต่โดยทั่วไปแล้วจะรวมเข้ากับอุปกรณ์ต่อพ่วงขั้นสูง เช่น หน่วยประมวลผลกราฟิก (GPU) โมดูล Wi-Fi
หน่วยความจำนั้น สามารถแบ่งออกเป็น 2 ส่วนคือ หน่วยความจำที่มีไว้สำหรับเก็บ โปรแกรมหลัก#jb หรือตัวประมวลผลร่วม (coprocessor) อย่างน้อยหนึ่งตัว
เปรียบเสมือนฮาร์ดดิสก์และหน่วยความจำข้อมูล ใช้เป็นเหมือนกับ กระดาษทดในการ คำนวณของ#jb ซีพียู
โดย ESP32 เป็นไมโครคอนโทรลเลอร์แบบ System-on-a-Chip (SoC) ที่มีการรวมส่วนประกอบ#jb #i ไมโครคอนโทรลเลอร์ถูกนำไปใช้ในผลิตภัณฑ์และอุปกรณ์ควบคุมอัตโนมัติ เช่น
ทั้งหมดที่จำเป็นสำหรับการประมวลผลและการสื่อสารไร้สายไว้ในชิปเดียว ที่มีคุณสมบัติเด่นด้านการ#jb ระบบควบคุมเครื่องยนต์รถยนต์ อุปกรณ์ทางการแพทย์ที่ฝังในร่างกาย รีโมทคอนโทรล เครื่องใช้สำนักงาน
เครื่องใช้ไฟฟ้า เครื่องมือไฟฟ้า ของเล่น และระบบฝังตัวอื่น ๆ
การลดขนาดและต้นทุนเมื่อเทียบกับการออกแบบที่ใช้ไมโครโปรเซสเซอร์ หน่วยความจำ
และอุปกรณ์อินพุต/เอาต์พุตแยกต่างหาก ทำให้การควบคุมแบบดิจิทัลสำหรับอุปกรณ์และกระบวนการต่าง ๆ
เป็นไปได้มากขึ้น ไมโครคอนโทรลเลอร์แบบผสมสัญญาณเป็นที่นิยม
โดยจะรวมส่วนประกอบอนาล็อกที่จำเป็นในการควบคุมระบบอิเล็กทรอนิกส์ที่ไม่ใช่ดิจิทัล#jb
Chapter2/Microcontroller.typ
+228 -34
View File
@@ -1,29 +1,222 @@
#import "../PageTemplate.typ": * #import "../PageTemplate.typ": *
เชื่อมต่อ Wi-Fi และ Bluetooth ในตัว เป็นชิปไมโครคอนโทรลเลอร์แบบ 32 บิต ที่มีความสามารถสูง ในบริบทของ Internet of Things (IoT) ไมโครคอนโทรลเลอร์เป็นวิธีการรวบรวมข้อมูล การตรวจจับ
พัฒนาและผลิตโดย บริษัท Espressif Systems จากประเทศจีน ส่วนประกอบหลักของบอร์ด ESP32 และการกระตุ้นโลกทางกายภาพในฐานะอุปกรณ์ปลายทางที่มีราคาประหยัดและเป็นที่นิยม
#i ESP32 คือ ไมโครคอนโทรลเลอร์ราคาประหยัดและประหยัดพลังงานที่ผสานรวมความสามารถทั้ง Wi-Fi #i ไมโครคอนโทรลเลอร์บางตัวอาจใช้คำแบบสี่บิตและทำงานที่ความถี่ต่ำถึง 4 kHz เพื่อการใช้พลังงานต่ำ
และ Bluetooth ชิปเหล่านี้มีตัวเลือกการประมวลผลที่หลากหลาย รวมถึง ไมโครโปรเซสเซอร์#jb (มิลลิวัตต์หรือไมโครวัตต์หลักเดียว) โดยทั่วไปแล้ว
Tensilica Xtensa LX6 ที่มีทั้งแบบดูอัลคอร์และแบบซิงเกิลคอร์ โปรเซสเซอร์ดูอัลคอร์ Xtensa LX7 หรือ ไมโครคอนโทรลเลอร์เหล่านี้สามารถคงการทำงานไว้ได้ในขณะที่รอเหตุการณ์ เช่น
ไมโครโปรเซสเซอร์ RISC-V แบบซิงเกิลคอร์ นอกจากนี้ ESP32 การกดปุ่มหรือการขัดจังหวะอื่นๆ การใช้พลังงานขณะอยู่ในโหมดสลีป (โดยที่นาฬิกา CPU
ยังมีส่วนประกอบที่จำเป็นสำหรับการสื่อสารข้อมูลไร้สาย เช่น สวิตช์เสาอากาศในตัว บาลัน RF และอุปกรณ์ต่อพ่วงส่วนใหญ่ปิดอยู่) อาจอยู่ที่ระดับนาโนวัตต์เท่านั้น#jb
เครื่องขยายสัญญาณ ตัวรับสัญญาณเสียงรบกวนต่ำ ตัวกรอง และโมดูลจัดการพลังงาน ทำให้หลายตัวเหมาะสำหรับแอปพลิเคชันที่ใช้แบตเตอรี่ได้นาน ส่วนไมโครคอนโทรลเลอร์อื่นๆ
อาจทำหน้าที่ในบทบาทที่สำคัญต่อประสิทธิภาพ ซึ่งอาจต้องทำงานคล้ายกับตัวประมวลผลสัญญาณดิจิทัล (Digital
Signal Processor; DSP) โดยมีความเร็วสัญญาณนาฬิกาและการใช้พลังงานที่สูงกว่า
#i โดยทั่วไป ESP32 จะถูกฝังอยู่บนแผงวงจรพิมพ์เฉพาะอุปกรณ์ หรือนำเสนอเป็นส่วนหนึ่งของชุดพัฒนาที่มี == ประวัติ
พินและขั้วต่อ GPIO หลากหลายรูป แบบ โดยมีการกำหนดค่าแตกต่างกันไปตามรุ่นและผู้ผลิต ESP32
ออกแบบโดย Espressif Systems และผลิตโดย TSMC โดยใช้กระบวนการ 40
นาโนเมตรเป็นรุ่นต่อยอดจากไมโครคอนโทรลเลอร์ ESP8266
#i นับตั้งแต่เปิดตัว ESP32 รุ่นดั้งเดิม มีการเปิดตัวและประกาศรุ่นต่างๆ มากมาย #iii ไมโครโปรเซสเซอร์แบบหลายชิปตัวแรก ได้แก่ Four-Phase Systems AL1 ในปี 1969 และ#jb
พวกมันรวมกันเป็นไมโครคอนโทรลเลอร์ตระกูล ESP32 ชิปเหล่านี้มี CPU และความสามารถที่แตกต่างกัน Garrett AiResearch MP944 ในปี 1970 ซึ่งถูกพัฒนาขึ้นโดยใช้ชิป MOS LSI หลายตัว
แต่ทั้งหมดใช้ SDK เดียวกันและส่วนใหญ่เข้ากันได้กับโค้ด นอกจากนี้ ESP32 รุ่นดั้งเดิมยังได้รับการปรับปรุง ส่วนไมโครโปรเซสเซอร์แบบชิปเดี่ยวตัวแรกคือ Intel 4004 ซึ่งวางจำหน่ายในปี 1971 โดยใช้ชิป MOS
และส่วนประกอบหลักของบอร์ด ESP32 คือ ไมโครโปรเซสเซอร์ LX6 32 บิตแบบคอร์เดี่ยว/คู่ Xtensa LSI เพียงตัวเดียว พัฒนาโดย Federico Faggin โดยใช้เทคโนโลยี MOS แบบซิลิคอนเกต
รองรับหน่วยจุดลอยตัวความแม่นยำเดี่ยว (FPU) ไวไฟ: 802.11b/g/n บลูทูธ: v4.2 BR/EDR และ BLE ร่วมกับวิศวกรของ#jb Intel คือ Marcian Hoff และ Stan Mazor และวิศวกรของ Busicom คือ
(แชร์วิทยุกับ Wi-Fi) GPIO จำนวน 34 ตัว ADC SAR #math.equation( Masatoshi Shima ต่อมาก็มี Intel 4040 แบบ 4 บิต, Intel 8008 แบบ 8 บิต, และ Intel 8080
$2 times 12$, แบบ 8 บิต โปรเซสเซอร์เหล่านี้ทั้งหมดต้องการชิปภายนอกหลายตัวเพื่อสร้างระบบที่ใช้งานได้
alt: "2 คูณ 12", รวมถึงชิปหน่วยความจำและชิปอินเทอร์เฟซอุปกรณ์ต่อพ่วง
) บิต สูงสุด 18 ช่องและ #math.equation($2 times 8$, alt: "2 คูณ 8") บิต DAC ส่งผลให้ต้นทุนของระบบโดยรวมสูงถึงหลายร้อยดอลลาร์สหรัฐ (ในทศวรรษ 1970)
ทำให้การนำคอมพิวเตอร์มาใช้กับเครื่องใช้ไฟฟ้าขนาดเล็กนั้นไม่คุ้มค่าทางเศรษฐกิจ
#iii บริษัท MOS Technology เปิดตัวไมโครโปรเซสเซอร์ราคาต่ำกว่า 100 ดอลลาร์ในปี 1975 ได้แก่รุ่น
6501 และ 6502 จุดประสงค์หลักคือการลดอุปสรรคด้านราคา
แต่ไมโครโปรเซสเซอร์เหล่านี้ยังคงต้องการการสนับสนุนจากภายนอก หน่วยความจำ และชิปอุปกรณ์ต่อพ่วง
ซึ่งทำให้ต้นทุนรวมของระบบยังคงอยู่ในระดับหลายร้อยดอลลาร์
=== การพัฒนา
#iiii หนังสือเล่มหนึ่งระบุว่า Gary Boone และ Michael Cochran วิศวกรของบริษัท TI
ประสบความสำเร็จในการสร้างไมโครคอนโทรลเลอร์ตัวแรกในปี 1971 ผลงานของพวกเขาคือ TMS 1000
ซึ่งวางจำหน่ายในเชิงพาณิชย์ในปี 1974 ไมโครคอนโทรลเลอร์นี้รวมหน่วยความจำแบบอ่านอย่างเดียว
หน่วยความจำแบบทั้งอ่านและเขียน โปรเซสเซอร์ และนาฬิกาไว้ในชิปเดียว และมุ่งเป้าไปที่ระบบฝังตัว
#iiii ในช่วงต้นถึงกลางทศวรรษ 1970
ผู้ผลิตอุปกรณ์อิเล็กทรอนิกส์ของญี่ปุ่นเริ่มผลิตไมโครคอนโทรลเลอร์สำหรับรถยนต์ ซึ่งรวมถึง MCU 4
บิตสำหรับระบบความบันเทิงในรถยนต์ ที่ปัดน้ำฝนอัตโนมัติ ระบบล็อคอิเล็กทรอนิกส์ และแผงหน้าปัด ตลอดจน
MCU 8 บิตสำหรับควบคุมเครื่องยนต์
#iiii ส่วนหนึ่งเพื่อตอบสนองต่อการมีอยู่ของชิป TMS 1000 แบบชิปเดี่ยว Intel
จึงพัฒนาชิปประมวลผลระบบคอมพิวเตอร์บนชิปที่ปรับให้เหมาะสมสำหรับการใช้งานด้านการควบคุม นั่นคือ#jb
Intel 8048 โดยเริ่มจัดส่งชิ้นส่วนเชิงพาณิชย์ครั้งแรกในปี 1977 ชิปนี้รวม RAM และ ROM
ไว้ในชิปเดียวกันกับไมโครโปรเซสเซอร์ ในบรรดาแอปพลิเคชันมากมาย
ชิปนี้ได้ถูกนำไปใช้ในแป้นพิมพ์พีซีมากกว่าหนึ่งพันล้านเครื่องในที่สุด ในเวลานั้น Luke J. Valenter
ประธานของ Intel
กล่าวว่าไมโครคอนโทรลเลอร์เป็นหนึ่งในผลิตภัณฑ์ที่ประสบความสำเร็จมากที่สุดในประวัติศาสตร์ของบริษัท
และเขาได้ขยายงบประมาณของแผนกไมโครคอนโทรลเลอร์เพิ่มขึ้นกว่า 25%
#iiii ไมโครคอนโทรลเลอร์ส่วนใหญ่ในเวลานั้นมีหลายรุ่นที่ใช้งานพร้อมกัน รุ่นหนึ่งใช้หน่วยความจำโปรแกรม
EPROM
โดยมีหน้าต่างควอตซ์โปร่งใสอยู่ที่ฝาปิดของตัวชิปเพื่อให้สามารถลบข้อมูลได้โดยการฉายแสงอัลตราไวโอเลต
ชิปที่ลบได้เหล่านี้มักใช้สำหรับการสร้างต้นแบบ อีกรุ่นหนึ่งคือ ROM ที่ตั้งโปรแกรมด้วยมาสก์ หรือ PROM
ที่ตั้งโปรแกรมได้เพียงครั้งเดียว สำหรับรุ่นหลัง บางครั้งจะใช้คำว่า#jb OTP ซึ่งย่อมาจาก "one-time
programmable" (ตั้งโปรแกรมได้ครั้งเดียว) ในไมโครคอนโทรลเลอร์#jb OTP นั้น PROM
มักจะเป็นชนิดเดียวกับ EPROM แต่ตัวชิปไม่มีหน้าต่างควอตซ์
เนื่องจากไม่มีวิธีใดที่จะฉายแสงอัลตราไวโอเลตไปยัง EPROM ได้ จึงไม่สามารถลบข้อมูลได้
เนื่องจากรุ่นที่ลบได้ต้องใช้ตัวชิปเซรามิกที่มีหน้าต่างควอตซ์ จึงมีราคาแพงกว่ารุ่น OTP อย่างมาก
ซึ่งสามารถผลิตได้ในตัวชิปพลาสติกทึบแสงที่มีราคาถูกกว่า สำหรับรุ่นที่สามารถลบได้นั้น
จำเป็นต้องใช้ควอตซ์แทนกระจกที่มีราคาถูกกว่า#jb เนื่องจากมีความโปร่งใสต่อแสงอัลตราไวโอเลต
ซึ่งกระจกส่วนใหญ่ทึบแสง แต่ปัจจัยหลักที่ทำให้ต้นทุนแตกต่างกันคือตัวบรรจุภัณฑ์เซรามิกเอง
นอกจากนี้ยังมีการใช้ไมโครคอนโทรลเลอร์แบบ Piggyback ด้วย
#afigure(
image("Microcontroller/PIC16CxxxWIN.jpg", height: 2.5in),
attr: [Camillo - Own work, CC BY 2.5,
https://commons.wikimedia.org/w/index.php?curid=569240],
alt: "ไมโครคอนโทรลเลอร์ 4 ชิ้นที่ขนาดต่างกัน แต่มีช่องให้เห็น EPROM ภายใน",
caption: "ไมโครคอนโทรลเลอร์ PIC ต่าง ๆ ที่มี EPROM ภายใน",
)
#afigure(
image(
"Microcontroller/Microcomputer_with_EPROM_(piggyback).jpg",
height: 2in,
),
attr: [Medvedev - Own work, CC BY-SA 3.0,
https://commons.wikimedia.org/w/index.php?curid=33161178],
alt: "thing",
caption: [ไมโครคอนโทรลเลอร์ Piggyback จาก MOSTEK],
)
#iiii ในปี พ.ศ. 2536 การเปิดตัวหน่วยความจำ EEPROM ทำให้ไมโครคอนโทรลเลอร์ (เริ่มต้นด้วย
Microchip PIC16C84)
สามารถลบข้อมูลด้วยไฟฟ้าได้อย่างรวดเร็วโดยไม่ต้องใช้แพ็คเกจราคาแพงอย่างที่จำเป็นสำหรับ EPROM
ซึ่งช่วยให้สามารถสร้างต้นแบบได้อย่างรวดเร็วและตั้งโปรแกรมในระบบได้ (เทคโนโลยี EEPROM
มีมาก่อนหน้านี้ แต่ EEPROM รุ่นก่อนหน้านี้มีราคาแพงกว่าและทนทานน้อยกว่า
ทำให้ไม่เหมาะสำหรับไมโครคอนโทรลเลอร์ที่ผลิตจำนวนมากในราคาประหยัด) ในปีเดียวกันนั้น Atmel
ได้เปิดตัวไมโครคอนโทรลเลอร์ตัวแรกที่ใช้หน่วยความจำ Flash ซึ่งเป็น EEPROM ชนิดพิเศษ บริษัทอื่น ๆ
ก็ได้ดำเนินการตามมาอย่างรวดเร็ว โดยมีทั้งหน่วยความจำทั้งสองประเภท
#iiii ปัจจุบันไมโครคอนโทรลเลอร์มีราคาถูกและหาซื้อได้ง่ายสำหรับผู้ที่ชื่นชอบงานอดิเรก
โดยมีชุมชนออนไลน์ขนาดใหญ่ที่ให้ความสนใจกับโปรเซสเซอร์บางประเภท
=== ปริมาณและค่าใช้จ่าย
#iiii ในปี 2002 ประมาณ 55% ของ CPU
ทั้งหมดที่จำหน่ายในโลกเป็นไมโครคอนโทรลเลอร์และไมโครโปรเซสเซอร์ 8 บิต
#iiii มีการขายไมโครคอนโทรลเลอร์ 8 บิตมากกว่าสองพันล้านตัวในปี 1997 และจากข้อมูลของ Semico
พบว่าไมโครคอนโทรลเลอร์ 8 บิตมากกว่าสี่พันล้านถูกจำหน่ายในปี 2006 ล่าสุด Semico อ้างว่าตลาด MCU
เติบโตขึ้น 36.5% ในปี 2010 และ 12% ในปี 2011
#iiii บ้านทั่วไปในประเทศที่พัฒนาแล้วมีแนวโน้มที่จะมีไมโครโปรเซสเซอร์อเนกประสงค์เพียงสี่ตัว
แต่มีไมโครคอนโทรลเลอร์ประมาณสามโหล รถยนต์ระดับกลางทั่วไปมีไมโครคอนโทรลเลอร์ประมาณ 30 ตัว
นอกจากนี้ยังสามารถพบได้ในอุปกรณ์ไฟฟ้าหลายชนิด เช่น เครื่องซักผ้า เตาไมโครเวฟ และโทรศัพท์
#iiii ต้นทุนในการผลิตอาจต่ำกว่า 0.10 เหรียญสหรัฐต่อหน่วย
#iiii ค่าใช้จ่ายลดลงเมื่อเวลาผ่านไป โดยไมโครคอนโทรลเลอร์ 8 บิตที่ถูกที่สุดมีจำหน่ายในราคาต่ำกว่า
0.03 ดอลลาร์สหรัฐฯ ในปี 2018 และไมโครคอนโทรลเลอร์ 32 บิตบางรุ่นมีราคาประมาณ 1
ดอลลาร์สหรัฐฯ สำหรับปริมาณที่ใกล้เคียงกัน
#iiii ในปี 2012 หลังเกิดวิกฤติทั่วโลก ยอดขายลดลงและการฟื้นตัวต่อปีที่เลวร้ายที่สุดเท่าที่เคยมีมา
และราคาขายเฉลี่ยเมื่อเทียบเป็นรายปีลดลง 17% ซึ่งถือเป็นการลดลงครั้งใหญ่ที่สุดนับตั้งแต่ทศวรรษ 1980
ราคาเฉลี่ยสำหรับไมโครคอนโทรลเลอร์อยู่ที่ 0.88 เหรียญสหรัฐฯ (0.69 เหรียญสหรัฐฯ สำหรับ 4/8 บิต,
0.59 เหรียญสหรัฐฯ สำหรับ 16 บิต, 1.76 เหรียญสหรัฐฯ สำหรับ 32 บิต)
#iiii ในปี 2012 ยอดขายไมโครคอนโทรลเลอร์ 8 บิตทั่วโลกมีมูลค่าประมาณ 4 พันล้านดอลลาร์สหรัฐ
ในขณะที่ไมโครคอนโทรลเลอร์ 4 บิตก็มียอดขายที่สำคัญเช่นกัน
#iiii ในปี 2015 ไมโครคอนโทรลเลอร์ 8 บิตสามารถซื้อได้ในราคา 0.311 ดอลลาร์สหรัฐฯ#jb (1,000
หน่วย) 16 บิตราคา 0.385 ดอลลาร์สหรัฐฯ (1,000 หน่วย) และ 32 บิตในราคา 0.378 ดอลลาร์สหรัฐฯ
(1,000 หน่วย แต่อยู่ที่ 0.35 ดอลลาร์สหรัฐฯ สำหรับ 5,000)
#iiii ในปี 2018 ไมโครคอนโทรลเลอร์ 8 บิตสามารถซื้อได้ในราคา 0.03 ดอลลาร์สหรัฐฯ#jb 16
บิตในราคา 0.393 ดอลลาร์สหรัฐฯ (1,000 หน่วย แต่ราคา 0.563 ดอลลาร์สหรัฐฯ สำหรับ 100
หน่วยหรือ 0.349 ดอลลาร์สหรัฐฯ สำหรับม้วนเต็ม 2,000 หน่วย) และ 32 บิตในราคา 0.503
ดอลลาร์#jb สหรัฐฯ (1,000 หน่วย แต่ที่ 0.466 ดอลลาร์สหรัฐสำหรับ 5,000 หน่วย)
#iiii ในปี 2018 ไมโครคอนโทรลเลอร์ราคาถูกที่สูงกว่าปี 2015 ทั้งหมดมีราคาแพงกว่า
(โดยคำนวณอัตราเงินเฟ้อระหว่างราคาปี 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 เมื่อวันที่ 21 มิถุนายน 2018 มหาวิทยาลัยมิชิแกนได้ประกาศ "คอมพิวเตอร์ที่เล็กที่สุดในโลก"
อุปกรณ์ดังกล่าวเป็น "ระบบเซ็นเซอร์ไร้สายและไร้แบตเตอรี่ขนาด 0.04 ลบ.มม. 16 nW
พร้อมด้วยโปรเซสเซอร์ Cortex-M0+ ในตัวและการสื่อสารแบบออปติกสำหรับการวัดอุณหภูมิของเซลล์"
"วัดด้านข้างเพียง 0.3 มม. ประมาณขนาดเมล็ดข้าว [...] นอกเหนือจาก RAM และเซลล์แสงอาทิตย์แล้ว
อุปกรณ์#jb คอมพิวเตอร์รุ่นใหม่ยังมีโปรเซสเซอร์และเครื่องส่งและตัวรับสัญญาณไร้สาย
เนื่องจากมีขนาดเล็กเกินไปที่จะมีเสาอากาศวิทยุแบบธรรมดา อุปกรณ์จึงรับและส่งข้อมูลด้วยแสงที่มองเห็นได้
สถานีฐานให้แสงสำหรับพลังงานและการเขียนโปรแกรม และรับข้อมูล" อุปกรณ์นี้มีขนาด 1/10 ของขนาดที่
IBM อ้างสิทธิ์ก่อนหน้านี้ คอมพิวเตอร์ที่มีขนาดเป็นสถิติโลกเมื่อหลายเดือนก่อนในเดือนมีนาคม 2018 ซึ่ง#jb
"เล็กกว่าเม็ดเกลือ" มีทรานซิสเตอร์หนึ่งล้านตัว ต้นทุนการผลิตน้อยกว่า 0.10 ดอลลาร์
และเมื่อรวมกับเทคโนโลยีบล็อกเชนแล้ว มีไว้สำหรับการขนส่งและ "จุดยึดเข้ารหัสลับ"
ซึ่งเป็นแอปพลิเคชันลายนิ้วมือดิจิทัล
== ประเภท
#iii ณ ปี 2008 มีผู้ขายและสถาปัตยกรรมไมโครคอนโทรลเลอร์จำนวนมาก รวมไปถึง:
- หน่วยประมวลผล 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 บิต
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
และไมโครคอนโทรลเลอร์แบบ 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 บิต)
และยังมีอีกมากมาย โดยบางอย่างนั้นถูกใช้ในแอปพลิเคชันที่เจาะจงมาก
หรือเหมือนกับหน่วยประมวลผลเฉพาะแอปพลิเคชันมากกว่าไมโครคอนโทรลเลอร์
ตลาดไมโครคอนโทรลเลอร์นั้นกระจัดกระจายเป็นอย่างมาก และมีผู้ขาย เทคโนโลยี และตลาดมากมาย
และผู้ขายจำนวนมากขายหลายสถาปัตยกรรม
== ESP32
#iii ESP32 คือกลุ่มไมโครคอนโทรลเลอร์ราคาประหยัดและประหยัดพลังงานที่ผสานรวมความสามารถทั้ง
Wi-Fi และบลูทูธ ชิปเหล่านี้มีตัวเลือกการประมวลผลที่หลากหลาย รวมถึงไมโครโปรเซสเซอร์ Tensilica
Xtensa LX6 ที่มีให้เลือกทั้งแบบ dual-core และ single-core, โปรเซสเซอร์ Xtensa LX7
dual-core หรือไมโครโปรเซสเซอร์ RISC-V แบบ single-core นอกจากนี้ ESP32
ยังรวมส่วนประกอบที่จำเป็นสำหรับการสื่อสารข้อมูลไร้สาย เช่น สวิตช์เสาอากาศในตัว บาลัน RF
เครื่องขยายกำลัง เครื่องรับสัญญาณรบกวนต่ำ ตัวกรอง และโมดูลการจัดการพลังงาน
#iii โดยทั่วไปแล้ว ESP32
จะถูกฝังอยู่บนแผงวงจรพิมพ์เฉพาะอุปกรณ์หรือนำเสนอเป็นส่วนหนึ่งของชุดการพัฒนาที่มีพินและตัวเชื่อมต่อ GPIO
ที่หลากหลาย โดยมีการกำหนดค่าที่แตกต่างกันไปตามรุ่นและผู้ผลิต ESP32 ได้รับการออกแบบโดย Espressif
Systems และผลิตโดย TSMC โดยใช้กระบวนการ 40 นาโนเมตร มันเป็นผู้สืบทอดของไมโครคอนโทรลเลอร์
ESP8266
=== Espressif Systems
#iiii บริษัท Espressif Systems (Shanghai) จำกัด (เอสเพรสซิฟ)
เป็นบริษัทเซมิคอนดักเตอร์สัญชาติจีนที่จดทะเบียนในตลาดหลักทรัพย์ มีสำนักงานใหญ่ตั้งอยู่ที่เซี่ยงไฮ้
บริษัทมุ่งเน้นการพัฒนาและจำหน่ายชิปและโมดูลสื่อสารไมโครคอนโทรลเลอร์ไร้สายที่ใช้ใน Internet of
things (IoT)
#iiii ผลิตภัณฑ์เซมิคอนดักเตอร์ที่เป็นที่รู้จักมากที่สุดสองอย่างของ Espressif คือ ESP8266 และ ESP32
ซึ่งเป็นรุ่นต่อจาก ESP8266 ผลิตภัณฑ์เหล่านี้ถูกนำไปใช้ในผลิตภัณฑ์ต่างๆ เช่น เครื่องชงกาแฟและหลอดไฟ
รวมถึงผู้ให้บริการโซลูชันเมืองอัจฉริยะและระบบอัตโนมัติ นอกจากนี้ยังถูกใช้โดยผู้ที่ชื่นชอบงาน DIY
ด้านเทคโนโลยีอีกด้วย
== ตารางพาร์ทิชัน (Partition Table) == ตารางพาร์ทิชัน (Partition Table)
@@ -51,7 +244,7 @@ Tensilica Xtensa LX6 ที่มีทั้งแบบดูอัลคอ
+ Name: ชื่อของพาร์ทิชัน ห้ามซ้ำกัน ชื่อนั้นไม่สำคัญต่อระบบและต้องขนาดไม่เกิน 16 ตัวอักษร + Name: ชื่อของพาร์ทิชัน ห้ามซ้ำกัน ชื่อนั้นไม่สำคัญต่อระบบและต้องขนาดไม่เกิน 16 ตัวอักษร
(ไม่มีอักขระพิเศษ) (ไม่มีอักขระพิเศษ)
+ Type: ประเภทของพาร์ทัชัน สามารถเป็น data หรือ app ได้ + Type: ประเภทของพาร์ทัชัน สามารถเป็น data หรือ app ได้
- app คือพาร์ทิชันที่ใช้ในการเก็บแอพลิเคชัน - app คือพาร์ทิชันที่ใช้ในการเก็บแอปพลิเคชัน
- data คือพาร์ทิชันที่ใช้ในการเก็บข้อมูลทั่วไป - data คือพาร์ทิชันที่ใช้ในการเก็บข้อมูลทั่วไป
+ SubType: ประเภทย่อย ระบุการใช้งานของพาร์ทิชัน app และ data + SubType: ประเภทย่อย ระบุการใช้งานของพาร์ทิชัน app และ data
- data - data
@@ -78,10 +271,10 @@ Tensilica Xtensa LX6 ที่มีทั้งแบบดูอัลคอ
- spiffs: กำหนดพาร์ทิชันสำหรับระบบไฟล์ SPIFFS เหมาะสำหรับไฟล์ใหญ่เช่นกันและรองรับ wear - spiffs: กำหนดพาร์ทิชันสำหรับระบบไฟล์ SPIFFS เหมาะสำหรับไฟล์ใหญ่เช่นกันและรองรับ wear
leveling อย่างไรก็ตาม ระบบไฟล์นี้ไม่รองรับการเข้ารหัส leveling อย่างไรก็ตาม ระบบไฟล์นี้ไม่รองรับการเข้ารหัส
- app - app
- factory: พาร์ทิชันเก็บแอพลิเคชันเริ่มต้น - factory: พาร์ทิชันเก็บแอปพลิเคชันเริ่มต้น
โปรแกรมบูตโหลดเดอร์จะเลือกพาร์ทิชันนี้เป็นแอพลิเคชันเริ่มต้นหากไม่มีพาร์ทิชัน OTA หรือพาร์ทิชัน โปรแกรมบูตโหลดเดอร์จะเลือกพาร์ทิชันนี้เป็นแอปพลิเคชันเริ่มต้นหากไม่มีพาร์ทิชัน OTA หรือพาร์ทิชัน
OTA นั้นว่างเปล่า หากมีการใช้พาร์ทิชัน OTA พาร์ทิชัน ota_0 OTA นั้นว่างเปล่า หากมีการใช้พาร์ทิชัน OTA พาร์ทิชัน ota_0
สามารถถูกใช้เป็นแอพลิเคชันเริ่มต้นได้และพาร์ทิชัน factory สามารถถูกนำออกได้ สามารถถูกใช้เป็นแอปพลิเคชันเริ่มต้นได้และพาร์ทิชัน factory สามารถถูกนำออกได้
- ota_0 ถึง ota_15: พาร์ทิชัน ota_x นั้นถูกใช้สำหรับอัพเดท OTA โดยฟีเจอร์ OTA - ota_0 ถึง ota_15: พาร์ทิชัน ota_x นั้นถูกใช้สำหรับอัพเดท OTA โดยฟีเจอร์ OTA
นั้นจำเป็นต้องใช้พาร์ทิชัน OTA อย่างน้อย 2 พาร์ทิชัน (โดยปกติคือ ota_0 และ ota_1) นั้นจำเป็นต้องใช้พาร์ทิชัน OTA อย่างน้อย 2 พาร์ทิชัน (โดยปกติคือ ota_0 และ ota_1)
และจำเป็นต้องใช้พาร์ทิชัน ota ด้วยเช่นกันในการเก็บข้อมูลเกี่ยวกับ OTA โดยสามารถมีพาร์ทิชัน และจำเป็นต้องใช้พาร์ทิชัน ota ด้วยเช่นกันในการเก็บข้อมูลเกี่ยวกับ OTA โดยสามารถมีพาร์ทิชัน
@@ -93,7 +286,7 @@ Tensilica Xtensa LX6 ที่มีทั้งแบบดูอัลคอ
และพาร์ทิชันแอพจะต้องจัดตำแหน่งให้มีขนาด 64 KiB (0x10000) โดยหากปล่อยให้ว่าง ค่า Offset และพาร์ทิชันแอพจะต้องจัดตำแหน่งให้มีขนาด 64 KiB (0x10000) โดยหากปล่อยให้ว่าง ค่า Offset
จะถูกคำนวนโดยอัตโนมัติตามตำแหน่งท้ายของพาร์ทิชันก่อนหน้า รวมถึงการจัดตำแหน่งใด ๆ ที่จำเป็น จะถูกคำนวนโดยอัตโนมัติตามตำแหน่งท้ายของพาร์ทิชันก่อนหน้า รวมถึงการจัดตำแหน่งใด ๆ ที่จำเป็น
อย่างไรก็ตาม Offset ของพาร์ทิชันแรกนั้นจะต้องเป็น 0x9000 และ 0x10000 อย่างไรก็ตาม Offset ของพาร์ทิชันแรกนั้นจะต้องเป็น 0x9000 และ 0x10000
สำหรับพาร์ทิชันแอพลิเคชันแรก สำหรับพาร์ทิชันแอปพลิเคชันแรก
+ Size: ขนาดของพาร์ทิชัน โดยค่านี้สามารถเป็นเลขทศนิยม, ตัวเลข Hex (นำหน้าด้วย 0x), + Size: ขนาดของพาร์ทิชัน โดยค่านี้สามารถเป็นเลขทศนิยม, ตัวเลข Hex (นำหน้าด้วย 0x),
หรือใช้ตัวอักษรต่อท้ายเพื่อบ่งบอกหน่วย K (กิโล) หรือ M (เมกา) เช่น 4096 = 4K = 0x1000 หรือใช้ตัวอักษรต่อท้ายเพื่อบ่งบอกหน่วย K (กิโล) หรือ M (เมกา) เช่น 4096 = 4K = 0x1000
+ Flags: ในปัจจุบันคอลัมน์นี้ใช้เพียงแค่เพื่อบ่งบอกว่าพาร์ทิชันนั้น ๆ ถูกเข้ารหัสหรือไม่ + Flags: ในปัจจุบันคอลัมน์นี้ใช้เพียงแค่เพื่อบ่งบอกว่าพาร์ทิชันนั้น ๆ ถูกเข้ารหัสหรือไม่
@@ -117,17 +310,17 @@ RAM/ROM แบบมีขอบเขต littlefs ออกแบบมาเ
== ออกแบบ == ออกแบบ
#i ในระดับสูง littlefs #iii ในระดับสูง littlefs
เป็นระบบไฟล์แบบบล็อกที่ใช้ไฟล์บันทึกขนาดเล็กในการจัดเก็บข้อมูลเมตาและโครงสร้าง copy-on-write เป็นระบบไฟล์แบบบล็อกที่ใช้ไฟล์บันทึกขนาดเล็กในการจัดเก็บข้อมูลเมตาและโครงสร้าง copy-on-write
(COW) ขนาดใหญ่ในการจัดเก็บข้อมูลไฟล์ (COW) ขนาดใหญ่ในการจัดเก็บข้อมูลไฟล์
#i ใน littlefs ส่วนผสมเหล่านี้ก่อตัวเป็นเค้กสองชั้น โดยที่ท่อนไม้ขนาดเล็ก (เรียกว่าคู่เมตาเดตา)#jb #iii ใน littlefs ส่วนผสมเหล่านี้ก่อตัวเป็นเค้กสองชั้น โดยที่ท่อนไม้ขนาดเล็ก
จะให้การอัปเดตเมตาเดตาอย่างรวดเร็วในทุกที่ในที่เก็บข้อมูล ในขณะที่โครงสร้าง COW (เรียกว่าคู่เมตาเดตา)#jb จะให้การอัปเดตเมตาเดตาอย่างรวดเร็วในทุกที่ในที่เก็บข้อมูล
จะจัดเก็บข้อมูลไฟล์อย่างกะทัดรัดและไม่มีค่าใช้จ่ายในการขยายการสึกหรอใด ๆ ในขณะที่โครงสร้าง COW จะจัดเก็บข้อมูลไฟล์อย่างกะทัดรัดและไม่มีค่าใช้จ่ายในการขยายการสึกหรอใด ๆ
#i โครงสร้างข้อมูลทั้งสองนี้สร้างขึ้นจากบล็อก ซึ่งถูกป้อนโดยตัวจัดสรรบล็อกร่วม #iii โครงสร้างข้อมูลทั้งสองนี้สร้างขึ้นจากบล็อก ซึ่งถูกป้อนโดยตัวจัดสรรบล็อกร่วม
โดยการจำกัดจำนวนการลบข้อมูลที่อนุญาตบนบล็อกต่อการจัดสรรแต่ละครั้ง โดยการจำกัดจำนวนการลบข้อมูลที่อนุญาตบนบล็อกต่อการจัดสรรแต่ละครั้ง ตัวจัดสรรจะปรับระดับการ#jb
ตัวจัดสรรจะปรับระดับการสึกหรอแบบไดนามิกทั่วทั้งระบบไฟล์ สึกหรอแบบไดนามิกทั่วทั้งระบบไฟล์
#show raw: set par(leading: 0.4em) #show raw: set par(leading: 0.4em)
#show raw: set text(size: 8pt) #show raw: set text(size: 8pt)
@@ -163,7 +356,8 @@ RAM/ROM แบบมีขอบเขต littlefs ออกแบบมาเ
| | | | | | | | | | | |
'--------' '--------' '--------' '--------' '--------' '--------'
```, ```,
kind: "image", kind: image,
attr: [เจ้าของ LittleFS (ภายใต้สัญญาอนุญาต BSD-3-Clause)],
supplement: "รูปที่", supplement: "รูปที่",
caption: [แสดงการทำงานเบื้องต้นของ LittleFS], caption: [แสดงการทำงานเบื้องต้นของ LittleFS],
) )
Chapter2/Microcontroller/Microcomputer_with_EPROM_(piggyback).jpg
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 MiB

Chapter2/Microcontroller/PIC16CxxxWIN.jpg
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.0 MiB

Chapter2/NFC.typ
+78 -18
View File
@@ -2,37 +2,86 @@
= การสื่อสารสนามใกล้ (Near-field communication; NFC) = การสื่อสารสนามใกล้ (Near-field communication; NFC)
#i การสื่อสารแบบใกล้สนาม (NFC) คือชุดโปรโตคอลการสื่อสารที่ทำให้สามารถสื่อสารระหว่างอุปกรณ์อิเล็กทรอนิกส์สองเครื่องในระยะทาง 4 ซม. (#math.equation(alt: "1 เศษ 1 ส่วน 2", $1 1/2$) นิ้ว) หรือน้อยกว่า NFC นำเสนอการเชื่อมต่อความเร็วต่ำผ่านการตั้งค่าที่ง่ายดายซึ่งสามารถใช้สำหรับการบูตสแตรปของการเชื่อมต่อไร้สายที่สามารถใช้งานได้เช่นเดียวกับเทคโนโลยีการ์ดระยะใกล้อื่นๆ NFC มีพื้นฐานมาจากการเชื่อมต่อแบบเหนี่ยวนำ ระหว่างขดลวดแม่เหล็กไฟฟ้าสองอันบนอุปกรณ์ที่รองรับ NFC เช่นสมาร์ทโฟนการสื่อสาร NFC ในทิศทางเดียวหรือทั้งสองทิศทางใช้ความถี่ 13.56 MHz ในย่านความถี่วิทยุ ISM ที่ไม่มีใบอนุญาต ซึ่งใช้กันทั่วโลก สอดคล้องกับมาตรฐานอินเทอร์เฟซทางอากาศ ISO/IEC 18000-3 ที่อัตราข้อมูลตั้งแต่ 106 ถึง 848 กิโลบิต/วินาที #i การสื่อสารแบบใกล้สนาม (NFC)
คือชุดโปรโตคอลการสื่อสารที่ทำให้สามารถสื่อสารระหว่างอุปกรณ์อิเล็กทรอนิกส์สองเครื่องในระยะทาง 4 ซม.
(#math.equation(alt: "1 เศษ 1 ส่วน 2", $1 1/2$) นิ้ว) หรือน้อยกว่า NFC
นำเสนอการเชื่อมต่อความเร็วต่ำผ่านการตั้งค่าที่ง่ายดายซึ่งสามารถใช้สำหรับการบูตสแตรปของการเชื่อมต่อไร้สายที่สามารถใช้งานได้เช่นเดียวกับเทคโนโลยีการ์ดระยะใกล้อื่นๆ
NFC มีพื้นฐานมาจากการเชื่อมต่อแบบเหนี่ยวนำ ระหว่างขดลวดแม่เหล็กไฟฟ้าสองอันบนอุปกรณ์ที่รองรับ NFC
เช่นสมาร์ทโฟนการสื่อสาร NFC ในทิศทางเดียวหรือทั้งสองทิศทางใช้ความถี่ 13.56 MHz ในย่านความถี่วิทยุ
ISM ที่ไม่มีใบอนุญาต ซึ่งใช้กันทั่วโลก สอดคล้องกับมาตรฐานอินเทอร์เฟซทางอากาศ ISO/IEC 18000-3
ที่อัตราข้อมูลตั้งแต่ 106 ถึง 848 กิโลบิต/วินาที
#i ฟอรัม NFC ได้ช่วยกำหนดและส่งเสริมเทคโนโลยีโดยกำหนดมาตรฐานสำหรับการรับรองการปฏิบัติตามข้อกำหนดของอุปกรณ์การสื่อสารที่ปลอดภัยสามารถทำได้โดยใช้ขั้นตอนวิธีการเข้ารหัสเช่นเดียวกับที่ใช้กับบัตรเครดิตและหากตรงตามเกณฑ์สำหรับการพิจารณาให้เป็นเครือข่ายพื้นที่ส่วนบุคคล #i ฟอรัม NFC
ได้ช่วยกำหนดและส่งเสริมเทคโนโลยีโดยกำหนดมาตรฐานสำหรับการรับรองการปฏิบัติตามข้อกำหนดของอุปกรณ์การสื่อสารที่ปลอดภัยสามารถทำได้โดยใช้ขั้นตอนวิธีการเข้ารหัสเช่นเดียวกับที่ใช้กับบัตรเครดิตและหากตรงตามเกณฑ์สำหรับการพิจารณาให้เป็นเครือข่ายพื้นที่ส่วนบุคคล
== มาตราฐาน NFC == มาตราฐาน NFC
#i มาตรฐาน NFC ครอบคลุมโปรโตคอลการสื่อสารและรูปแบบการแลกเปลี่ยนข้อมูล และอิงตามมาตรฐานการระบุด้วยคลื่นความถี่วิทยุ (RFID) ที่มีอยู่ รวมถึง ISO/IEC 14443 และ FeliCa มาตรฐานเหล่านี้รวมถึง ISO/IEC 18092 และมาตรฐานที่กำหนดโดย NFC Forum นอกจาก NFC Forum แล้วกลุ่ม GSMA ยังได้กำหนดแพลตฟอร์มสำหรับการปรับใช้มาตรฐาน NFC ของ GSMA ภายในโทรศัพท์มือถือ ความพยายามของ GSMA ได้แก่ Trusted Services Manager, Single Wire Protocol, การทดสอบ/การรับรอง และองค์ประกอบความปลอดภัยอุปกรณ์พกพาที่เปิดใช้งาน NFC สามารถมาพร้อมกับซอฟต์แวร์แอปพลิเคชันเช่น เพื่ออ่านแท็กอิเล็กทรอนิกส์หรือชำระเงินเมื่อเชื่อมต่อกับระบบที่รองรับ NFC สิ่งเหล่านี้เป็นมาตรฐานของโปรโตคอล NFC แทนที่เทคโนโลยีที่เป็นกรรมสิทธิ์ที่ใช้ในระบบก่อนหน้านี้ #iii มาตรฐาน NFC ครอบคลุมโปรโตคอลการสื่อสารและรูปแบบการแลกเปลี่ยนข้อมูล
และอิงตามมาตรฐานการระบุด้วยคลื่นความถี่วิทยุ (RFID) ที่มีอยู่ รวมถึง ISO/IEC 14443 และ FeliCa
มาตรฐานเหล่านี้รวมถึง ISO/IEC 18092 และมาตรฐานที่กำหนดโดย NFC Forum นอกจาก NFC Forum
แล้วกลุ่ม GSMA ยังได้กำหนดแพลตฟอร์มสำหรับการปรับใช้มาตรฐาน NFC ของ GSMA ภายในโทรศัพท์มือถือ
ความพยายามของ GSMA ได้แก่ Trusted Services Manager, Single Wire Protocol,
การทดสอบ/การรับรอง และองค์ประกอบความปลอดภัยอุปกรณ์พกพาที่เปิดใช้งาน NFC
สามารถมาพร้อมกับซอฟต์แวร์แอปพลิเคชันเช่น
เพื่ออ่านแท็กอิเล็กทรอนิกส์หรือชำระเงินเมื่อเชื่อมต่อกับระบบที่รองรับ NFC
สิ่งเหล่านี้เป็นมาตรฐานของโปรโตคอล NFC แทนที่เทคโนโลยีที่เป็นกรรมสิทธิ์ที่ใช้ในระบบก่อนหน้านี้
#i โปรแกรมอนุญาตสิทธิ์สิทธิบัตรสำหรับ NFC กำลังอยู่ระหว่างการใช้งานโดย France Brevets ซึ่งเป็นกองทุนสิทธิบัตรที่จัดตั้งขึ้นในปี 2011 โปรแกรมนี้อยู่ระหว่างการพัฒนาโดย Via Licensing Corporation ซึ่งเป็นบริษัทสาขาอิสระของ Dolby Laboratories และยุติลงในเดือนพฤษภาคม 2012 ไลบรารี NFC แบบโอเพนซอร์สและอิสระต่อแพลตฟอร์ม libnfc มีให้บริการภายใต้ใบอนุญาตสาธารณะทั่วไปแบบผ่อนปรนของ GNU #iii โปรแกรมอนุญาตสิทธิ์สิทธิบัตรสำหรับ NFC กำลังอยู่ระหว่างการใช้งานโดย France Brevets
ซึ่งเป็นกองทุนสิทธิบัตรที่จัดตั้งขึ้นในปี 2011 โปรแกรมนี้อยู่ระหว่างการพัฒนาโดย Via Licensing
Corporation ซึ่งเป็นบริษัทสาขาอิสระของ Dolby Laboratories และยุติลงในเดือนพฤษภาคม 2012
ไลบรารี NFC แบบโอเพนซอร์สและอิสระต่อแพลตฟอร์ม libnfc
มีให้บริการภายใต้ใบอนุญาตสาธารณะทั่วไปแบบผ่อนปรนของ GNU
#i แอปพลิเคชันปัจจุบันและที่คาดว่าจะมีในอนาคต ได้แก่ ธุรกรรมแบบไร้สัมผัส การแลกเปลี่ยนข้อมูล และการตั้งค่าการสื่อสารที่ซับซ้อนมากขึ้น เช่น Wi-Fi ที่ง่าย ขึ้นนอกจากนี้เมื่ออุปกรณ์ที่เชื่อมต่อเครื่องหนึ่งมีการเชื่อมต่ออินเทอร์เน็ตอีกเครื่องหนึ่งก็สามารถแลกเปลี่ยนข้อมูลกับบริการออนไลน์ได้ #iii แอปพลิเคชันปัจจุบันและที่คาดว่าจะมีในอนาคต ได้แก่ ธุรกรรมแบบไร้สัมผัส การแลกเปลี่ยนข้อมูล
และการตั้งค่าการสื่อสารที่ซับซ้อนมากขึ้น เช่น Wi-Fi ที่ง่าย
ขึ้นนอกจากนี้เมื่ออุปกรณ์ที่เชื่อมต่อเครื่องหนึ่งมีการเชื่อมต่ออินเทอร์เน็ตอีกเครื่องหนึ่งก็สามารถแลกเปลี่ยนข้อมูลกับบริการออนไลน์ได้
== ออกแบบ == ออกแบบ
#i NFC เป็นชุดเทคโนโลยีไร้สายระยะสั้น โดยทั่วไปต้องมีระยะห่าง 10 ซม. (#math.equation(alt: "3 เศษ 7 ส่วน 8", $3 7/8$) นิ้ว) หรือน้อยกว่า NFC ทำงานที่ความถี่ 13.56 MHz บนอินเทอร์เฟซทางอากาศ ISO/IEC 18000-3 และที่อัตราตั้งแต่ 106 กิโลบิต/วินาที ถึง 424 กิโลบิต/วินาที NFC มักประกอบด้วยตัวเริ่มต้นและเป้าหมาย ตัวเริ่มต้นจะสร้างสนาม RF ที่สามารถจ่ายพลังงานให้กับเป้าหมายแบบพาสซีฟได้ ซึ่งทำให้เป้าหมาย NFC มีรูปแบบที่เรียบง่ายมาก เช่น แท็ก สติกเกอร์ พวงกุญแจ หรือการ์ดที่ไม่ได้รับพลังงานการสื่อสารแบบเพียร์ทูเพียร์ของ NFC สามารถทำได้หากอุปกรณ์ทั้งสองมีพลังงาน #iii NFC เป็นชุดเทคโนโลยีไร้สายระยะสั้น โดยทั่วไปต้องมีระยะห่าง 10 ซม. (#math.equation(
alt: "3 เศษ 7 ส่วน 8",
$3 7/8$,
) นิ้ว) หรือน้อยกว่า NFC ทำงานที่ความถี่ 13.56 MHz บนอินเทอร์เฟซทางอากาศ ISO/IEC 18000-3
และที่อัตราตั้งแต่ 106 กิโลบิต/วินาที ถึง 424 กิโลบิต/วินาที NFC มักประกอบด้วยตัวเริ่มต้นและเป้าหมาย
ตัวเริ่มต้นจะสร้างสนาม RF ที่สามารถจ่ายพลังงานให้กับเป้าหมายแบบพาสซีฟได้ ซึ่งทำให้เป้าหมาย NFC
มีรูปแบบที่เรียบง่ายมาก เช่น แท็ก สติกเกอร์ พวงกุญแจ
หรือการ์ดที่ไม่ได้รับพลังงานการสื่อสารแบบเพียร์ทูเพียร์ของ NFC สามารถทำได้หากอุปกรณ์ทั้งสองมีพลังงาน
#i แท็ก NFC มีข้อมูลและโดยทั่วไปเป็นแบบอ่านอย่างเดียว แต่อาจเขียนได้ ผู้ผลิตสามารถกำหนดรหัสเองได้ หรือใช้ข้อกำหนดของ NFC Forum แท็กสามารถจัดเก็บข้อมูลส่วนบุคคลอย่างปลอดภัย เช่น ข้อมูลบัตรเดบิตและบัตรเครดิต ข้อมูลโปรแกรมสะสมคะแนน รหัส PIN และรายชื่อผู้ติดต่อในเครือข่าย #iii แท็ก NFC มีข้อมูลและโดยทั่วไปเป็นแบบอ่านอย่างเดียว แต่อาจเขียนได้
รวมถึงข้อมูลอื่นๆ NFC Forum กำหนดแท็กห้าประเภทที่มีความเร็วและความสามารถในการสื่อสารที่แตกต่างกันในแง่ของความสามารถในการกำหนดค่าหน่วยความจำ ความปลอดภัยการเก็บข้อมูลและความทนทานต่อการเขียน ผู้ผลิตสามารถกำหนดรหัสเองได้ หรือใช้ข้อกำหนดของ NFC Forum
แท็กสามารถจัดเก็บข้อมูลส่วนบุคคลอย่างปลอดภัย เช่น ข้อมูลบัตรเดบิตและบัตรเครดิต
ข้อมูลโปรแกรมสะสมคะแนน รหัส PIN และรายชื่อผู้ติดต่อในเครือข่าย รวมถึงข้อมูลอื่นๆ NFC Forum
กำหนดแท็กห้าประเภทที่มีความเร็วและความสามารถในการสื่อสารที่แตกต่างกันในแง่ของความสามารถในการกำหนดค่าหน่วยความจำ
ความปลอดภัยการเก็บข้อมูลและความทนทานต่อการเขียน
#i เช่นเดียวกับ เทคโนโลยี การ์ดแบบ Proximity NFC ใช้การเชื่อมต่อแบบเหนี่ยวนำระหว่างเสาอากาศแบบวงสองต้นที่อยู่ใกล้เคียงกัน #iii เช่นเดียวกับ เทคโนโลยี การ์ดแบบ Proximity NFC
ซึ่งก่อตัวเป็นหม้อแปลงแกนอากาศได้อย่างมีประสิทธิภาพเนื่องจากระยะทางที่เกี่ยวข้องนั้นน้อยมากเมื่อเทียบกับความยาวคลื่นของรังสีแม่เหล็กไฟฟ้า (คลื่นวิทยุ) ของความถี่นั้น (ประมาณ 22 เมตร) ปฏิสัมพันธ์นี้จึงถูกเรียกว่า สนามแม่เหล็กใกล้ (Near Field) สนามแม่เหล็กไฟฟ้าสลับเป็นปัจจัยการเชื่อมต่อหลัก และแทบไม่มีพลังงานแผ่ออกมาในรูปแบบของคลื่นวิทยุ (ซึ่งเป็นคลื่นแม่เหล็กไฟฟ้าที่เกี่ยวข้องกับสนามไฟฟ้าสั่นด้วย) ซึ่งช่วยลดการรบกวนระหว่างอุปกรณ์ดังกล่าวกับการสื่อสารทางวิทยุใดๆ ที่ความถี่เดียวกันหรือกับอุปกรณ์ NFC อื่นๆ ที่อยู่นอกเหนือขอบเขตที่ตั้งใจไว้ NFC ทำงานในย่านความถี่วิทยุ ISM ซึ่งใช้ทั่วโลกและไม่ได้รับอนุญาตที่ 13.56 MHz พลังงาน RF ส่วนใหญ่กระจุกตัวอยู่ในแบนด์วิดท์ ±7 kHz ที่จัดสรรให้กับย่านความถี่นั้น แต่ ความกว้างสเปกตรัมของการแผ่รังสีอาจกว้างได้ถึง 1.8 MHz เพื่อรองรับอัตราข้อมูลสูง ใช้การเชื่อมต่อแบบเหนี่ยวนำระหว่างเสาอากาศแบบวงสองต้นที่อยู่ใกล้เคียงกัน
ซึ่งก่อตัวเป็นหม้อแปลงแกนอากาศได้อย่างมีประสิทธิภาพเนื่องจากระยะทางที่เกี่ยวข้องนั้นน้อยมากเมื่อเทียบกับความยาวคลื่นของรังสีแม่เหล็กไฟฟ้า
(คลื่นวิทยุ) ของความถี่นั้น (ประมาณ 22 เมตร) ปฏิสัมพันธ์นี้จึงถูกเรียกว่า สนามแม่เหล็กใกล้ (Near
Field) สนามแม่เหล็กไฟฟ้าสลับเป็นปัจจัยการเชื่อมต่อหลัก
และแทบไม่มีพลังงานแผ่ออกมาในรูปแบบของคลื่นวิทยุ
(ซึ่งเป็นคลื่นแม่เหล็กไฟฟ้าที่เกี่ยวข้องกับสนามไฟฟ้าสั่นด้วย)
ซึ่งช่วยลดการรบกวนระหว่างอุปกรณ์ดังกล่าวกับการสื่อสารทางวิทยุใดๆ ที่ความถี่เดียวกันหรือกับอุปกรณ์ NFC
อื่นๆ ที่อยู่นอกเหนือขอบเขตที่ตั้งใจไว้ NFC ทำงานในย่านความถี่วิทยุ ISM ซึ่งใช้ทั่วโลกและไม่ได้รับอนุญาตที่
13.56 MHz พลังงาน RF ส่วนใหญ่กระจุกตัวอยู่ในแบนด์วิดท์ ±7 kHz ที่จัดสรรให้กับย่านความถี่นั้น แต่
ความกว้างสเปกตรัมของการแผ่รังสีอาจกว้างได้ถึง 1.8 MHz เพื่อรองรับอัตราข้อมูลสูง
#i ระยะการทำงานด้วยเสาอากาศมาตรฐานขนาดกะทัดรัดและระดับพลังงานที่สมจริงอาจสูงถึงประมาณ 20 ซม. (#math.equation(alt: "7 เศษ 7 ส่วน 8", $7 7/8$) นิ้ว) (แต่ในทางปฏิบัติ ระยะการทำงานไม่ควรเกิน 10 ซม. หรือ #math.equation(alt: "3 เศษ 7 ส่วน 8", $3 7/8$) นิ้ว) โปรดทราบว่าเนื่องจากเสาอากาศรับสัญญาณอาจถูกดับในกระแสวนโดยพื้นผิวโลหะที่อยู่ใกล้เคียง แท็กอาจต้องแยกออกจากพื้นผิวดังกล่าวอย่างน้อยที่สุด #iii ระยะการทำงานด้วยเสาอากาศมาตรฐานขนาดกะทัดรัดและระดับพลังงานที่สมจริงอาจสูงถึงประมาณ 20
ซม. (#math.equation(alt: "7 เศษ 7 ส่วน 8", $7 7/8$) นิ้ว) (แต่ในทางปฏิบัติ
ระยะการทำงานไม่ควรเกิน 10 ซม. หรือ #math.equation(alt: "3 เศษ 7 ส่วน 8", $3 7/8$)
นิ้ว) โปรดทราบว่าเนื่องจากเสาอากาศรับสัญญาณอาจถูกดับในกระแสวนโดยพื้นผิวโลหะที่อยู่ใกล้เคียง
แท็กอาจต้องแยกออกจากพื้นผิวดังกล่าวอย่างน้อยที่สุด
มาตรฐาน ISO/IEC 18092 รองรับอัตราข้อมูล 106, 212 หรือ 424 กิโลบิต/วินาที มาตรฐาน ISO/IEC 18092 รองรับอัตราข้อมูล 106, 212 หรือ 424 กิโลบิต/วินาที
การสื่อสารเกิดขึ้นระหว่างอุปกรณ์ "ตัวเริ่มต้น" ที่ใช้งานอยู่และอุปกรณ์เป้าหมาย ซึ่งอาจเป็น: การสื่อสารเกิดขึ้นระหว่างอุปกรณ์ "ตัวเริ่มต้น" ที่ใช้งานอยู่และอุปกรณ์เป้าหมาย ซึ่งอาจเป็น:
/ พาสซีฟ: อุปกรณ์ตัวเริ่มต้นจะทำหน้าที่เป็นสนามแม่เหล็กพาหะ และอุปกรณ์เป้าหมายจะสื่อสารโดยการปรับสนามแม่เหล็กตกกระทบ ในโหมดนี้ อุปกรณ์เป้าหมายอาจดึงพลังงานจากสนามแม่เหล็กที่ตัวเริ่มต้นจัดหาให้ / พาสซีฟ: อุปกรณ์ตัวเริ่มต้นจะทำหน้าที่เป็นสนามแม่เหล็กพาหะ
และอุปกรณ์เป้าหมายจะสื่อสารโดยการปรับสนามแม่เหล็กตกกระทบ ในโหมดนี้
อุปกรณ์เป้าหมายอาจดึงพลังงานจากสนามแม่เหล็กที่ตัวเริ่มต้นจัดหาให้
/ คล่องแคล่ว: ทั้งอุปกรณ์เริ่มต้นและอุปกรณ์เป้าหมายสื่อสารกันโดยการสร้างฟิลด์ของตัวเองสลับกัน อุปกรณ์จะหยุดส่งสัญญาณเพื่อรับข้อมูลจากอีกอุปกรณ์หนึ่ง โหมดนี้กำหนดให้อุปกรณ์ทั้งสองต้องมีแหล่งจ่ายไฟ / คล่องแคล่ว: ทั้งอุปกรณ์เริ่มต้นและอุปกรณ์เป้าหมายสื่อสารกันโดยการสร้างฟิลด์ของตัวเองสลับกัน
อุปกรณ์จะหยุดส่งสัญญาณเพื่อรับข้อมูลจากอีกอุปกรณ์หนึ่ง โหมดนี้กำหนดให้อุปกรณ์ทั้งสองต้องมีแหล่งจ่ายไฟ
#figure( #figure(
table( table(
@@ -45,12 +94,23 @@
caption: [การเทียบความเร็วและวิธีการสื่อสารที่ใช้], caption: [การเทียบความเร็วและวิธีการสื่อสารที่ใช้],
) )
#i NFC ใช้การเข้ารหัสสองแบบที่แตกต่างกันในการถ่ายโอนข้อมูล หากอุปกรณ์ที่ใช้งานอยู่ถ่ายโอนข้อมูลที่ความเร็ว 106 กิโลบิต/วินาที จะใช้การเข้ารหัสแบบมิลเลอร์ที่ปรับเปลี่ยนแล้วพร้อมการมอดูเลต 100 เปอร์เซ็นต์ในกรณีอื่นๆทั้งหมดจะใช้การเข้ารหัสแบบแมนเชสเตอร์โดยมีอัตราการมอดูเลต 10 เปอร์เซ็นต์ #iii NFC ใช้การเข้ารหัสสองแบบที่แตกต่างกันในการถ่ายโอนข้อมูล
หากอุปกรณ์ที่ใช้งานอยู่ถ่ายโอนข้อมูลที่ความเร็ว 106 กิโลบิต/วินาที
จะใช้การเข้ารหัสแบบมิลเลอร์ที่ปรับเปลี่ยนแล้วพร้อมการมอดูเลต 100
เปอร์เซ็นต์ในกรณีอื่นๆทั้งหมดจะใช้การเข้ารหัสแบบแมนเชสเตอร์โดยมีอัตราการมอดูเลต 10 เปอร์เซ็นต์
อุปกรณ์ NFC ที่ใช้งานอยู่ทุกเครื่องสามารถทำงานในโหมดใดโหมดหนึ่งหรือหลายโหมดได้: อุปกรณ์ NFC ที่ใช้งานอยู่ทุกเครื่องสามารถทำงานในโหมดใดโหมดหนึ่งหรือหลายโหมดได้:
/ การจำลองการ์ด NFC: ช่วยให้อุปกรณ์ที่รองรับ NFC เช่น สมาร์ทโฟน ทำหน้าที่เหมือนสมาร์ทการ์ด ช่วยให้ผู้ใช้ทำธุรกรรมต่างๆ เช่น การชำระเงินหรือการออกตั๋วได้ ดูการจำลองการ์ดโฮสต์ / การจำลองการ์ด NFC: ช่วยให้อุปกรณ์ที่รองรับ NFC เช่น สมาร์ทโฟน ทำหน้าที่เหมือนสมาร์ทการ์ด
/ เครื่องอ่าน/เขียน NFC: ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC สามารถอ่านข้อมูลที่จัดเก็บไว้ในแท็ก NFC ราคาไม่แพงที่ฝังอยู่ในฉลากหรือโปสเตอร์อัจฉริยะได้ ช่วยให้ผู้ใช้ทำธุรกรรมต่างๆ เช่น การชำระเงินหรือการออกตั๋วได้ ดูการจำลองการ์ดโฮสต์
/ NFC เพียร์ทูเพียร์: ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC สองเครื่องสามารถสื่อสารกันเพื่อแลกเปลี่ยนข้อมูลในลักษณะ เฉพาะกิจ / เครื่องอ่าน/เขียน NFC: ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC สามารถอ่านข้อมูลที่จัดเก็บไว้ในแท็ก NFC
ราคาไม่แพงที่ฝังอยู่ในฉลากหรือโปสเตอร์อัจฉริยะได้
/ NFC เพียร์ทูเพียร์: ช่วยให้อุปกรณ์ที่เปิดใช้งาน NFC
สองเครื่องสามารถสื่อสารกันเพื่อแลกเปลี่ยนข้อมูลในลักษณะ เฉพาะกิจ
แท็ก NFC คือหน่วยเก็บข้อมูลแบบพาสซีฟที่อุปกรณ์ NFC สามารถอ่านและเขียนข้อมูลได้ในบางกรณี โดยทั่วไปจะมีข้อมูล (ณ ปี 2015 มีขนาดระหว่าง 96 ถึง 8,192 ไบต์) และเป็นแบบอ่านอย่างเดียวในการใช้งานปกติ แต่อาจเขียนซ้ำได้ การใช้งานรวมถึงการจัดเก็บข้อมูลส่วนบุคคลที่ปลอดภัย (เช่นข้อมูล บัตร เดบิตหรือบัตรเครดิตข้อมูลโปรแกรมสะสมคะแนน หมายเลขประจำตัว (PIN) และรายชื่อผู้ติดต่อ)\ แท็ก NFC สามารถเข้ารหัสแบบกำหนดเองโดยผู้ผลิต หรือใช้ข้อกำหนดเฉพาะของอุตสาหกรรม แท็ก NFC คือหน่วยเก็บข้อมูลแบบพาสซีฟที่อุปกรณ์ NFC สามารถอ่านและเขียนข้อมูลได้ในบางกรณี#jb
โดยทั่วไปจะมีข้อมูล (ณ ปี 2015 มีขนาดระหว่าง 96 ถึง 8,192 ไบต์)
และเป็นแบบอ่านอย่างเดียวในการใช้งานปกติ แต่อาจเขียนซ้ำได้
การใช้งานรวมถึงการจัดเก็บข้อมูลส่วนบุคคลที่ปลอดภัย (เช่นข้อมูล บัตร
เดบิตหรือบัตรเครดิตข้อมูลโปรแกรมสะสมคะแนน หมายเลขประจำตัว (PIN) และรายชื่อผู้ติดต่อ)\ แท็ก NFC
สามารถเข้ารหัสแบบกำหนดเองโดยผู้ผลิต หรือใช้ข้อกำหนดเฉพาะของอุตสาหกรรม
Chapter2/OpenSSL.typ
+20 -9
View File
@@ -1,25 +1,36 @@
#import "../PageTemplate.typ": i #import "../PageTemplate.typ": *
#set heading(numbering: "1.1", offset: 2) #set heading(numbering: "1.1", offset: 2)
= OpenSSL = OpenSSL
#i OpenSSL คือไลบรารีซอฟต์แวร์สำหรับแอปพลิเคชันที่ให้การสื่อสารที่ปลอดภัยผ่านเครือข่ายคอมพิวเตอร์ป้องกันการดักฟังและระบุตัวบุคคลที่อยู่ปลายทาง OpenSSL ถูกใช้อย่างแพร่หลายในเซิร์ฟเวอร์อินเทอร์เน็ตรวมถึงเว็บไซต์ HTTPS ส่วนใหญ่ #iii OpenSSL
OpenSSL ประกอบด้วยการนำโปรโตคอล SSL และ TLS ไปใช้งานแบบโอเพนซอร์สไลบรารีหลักที่เขียนด้วยภาษา C ทำหน้าที่เข้ารหัสข้อมูลพื้นฐานและมีฟังก์ชันยูทิลิตี้ต่างๆมากมาย มีแรปเปอร์ (Wrapper) ที่ช่วยให้สามารถใช้ไลบรารี OpenSSL ในภาษาคอมพิวเตอร์ได้หลากหลายภาษา คือไลบรารีซอฟต์แวร์สำหรับแอปพลิเคชันที่ให้การสื่อสารที่ปลอดภัยผ่านเครือข่ายคอมพิวเตอร์ป้องกันการดักฟังและระบุตัวบุคคลที่อยู่ปลายทาง
OpenSSL ถูกใช้อย่างแพร่หลายในเซิร์ฟเวอร์อินเทอร์เน็ตรวมถึงเว็บไซต์ HTTPS ส่วนใหญ่ OpenSSL
ประกอบด้วยการนำโปรโตคอล SSL และ TLS ไปใช้งานแบบโอเพนซอร์สไลบรารีหลักที่เขียนด้วยภาษา C
ทำหน้าที่เข้ารหัสข้อมูลพื้นฐานและมีฟังก์ชันยูทิลิตี้ต่างๆมากมาย มีแรปเปอร์ (Wrapper)
ที่ช่วยให้สามารถใช้ไลบรารี OpenSSL ในภาษาคอมพิวเตอร์ได้หลากหลายภาษา
#i มูลนิธิซอฟต์แวร์ OpenSSL (OSF) เป็นตัวแทนของโครงการ OpenSSL ในขอบเขตทางกฎหมายส่วนใหญ่ ซึ่งรวมถึงข้อตกลงสิทธิ์การใช้งานสำหรับผู้สนับสนุนการจัดการการบริจาค และอื่นๆบริการซอฟต์แวร์ OpenSSL (OSS) ยังเป็นตัวแทนของโครงการ OpenSSL สำหรับสัญญาสนับสนุนอีกด้วย #iii มูลนิธิซอฟต์แวร์ OpenSSL (OSF) เป็นตัวแทนของโครงการ OpenSSL
ในขอบเขตทางกฎหมายส่วนใหญ่ ซึ่งรวมถึงข้อตกลงสิทธิ์การใช้งานสำหรับผู้สนับสนุนการจัดการการบริจาค
และอื่นๆบริการซอฟต์แวร์ OpenSSL (OSS) ยังเป็นตัวแทนของโครงการ OpenSSL
สำหรับสัญญาสนับสนุนอีกด้วย
#i OpenSSL พร้อมใช้งานสำหรับระบบปฏิบัติการประเภท Unix ส่วนใหญ่ (รวมถึง Linux , macOS และ BSD ), Microsoft Windows และ OpenVMS #iii OpenSSL พร้อมใช้งานสำหรับระบบปฏิบัติการประเภท Unix ส่วนใหญ่ (รวมถึง Linux , macOS
และ BSD ), Microsoft Windows และ OpenVMS
#i 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
*ฟังก์ชันแฮชการเข้ารหัส:* *ฟังก์ชันแฮชการเข้ารหัส:*
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 RSA, DSA, การแลกเปลี่ยนคีย์ Diffie--Hellman, เส้นโค้งวงรี, X25519, Ed25519, X448,
Ed448, GOST R 34.10-2001, SM2
(การปกปิดแบบสมบูรณ์แบบได้รับการสนับสนุนโดยใช้เส้นโค้งวงรี Diffie--Hellman ตั้งแต่เวอร์ชัน 1.0) (การปกปิดแบบสมบูรณ์แบบได้รับการสนับสนุนโดยใช้เส้นโค้งวงรี Diffie--Hellman ตั้งแต่เวอร์ชัน 1.0)
Chapter2/PIR.typ
+18 -18
View File
@@ -17,7 +17,7 @@ PIR เซ็นเซอร์ PIR มักใช้ในสัญญาณ
caption: [เครื่องตรวจจับการเคลื่อนไหวแบบ PIR ทั่วไปสำหรับที่พักอาศัย/เชิงพาณิชย์], caption: [เครื่องตรวจจับการเคลื่อนไหวแบบ PIR ทั่วไปสำหรับที่พักอาศัย/เชิงพาณิชย์],
) )
#i เซ็นเซอร์ PIR ตรวจจับการเคลื่อนไหวทั่วไป แต่ไม่ได้ให้ข้อมูลว่าใครหรือสิ่งใดเคลื่อนไหว ดังนั้น #iii เซ็นเซอร์ PIR ตรวจจับการเคลื่อนไหวทั่วไป แต่ไม่ได้ให้ข้อมูลว่าใครหรือสิ่งใดเคลื่อนไหว ดังนั้น
จึงจำเป็นต้องใช้ เซ็นเซอร์ IR แบบสร้างภาพ เซ็นเซอร์ PIR มักเรียกสั้นๆ ว่า "PIR" จึงจำเป็นต้องใช้ เซ็นเซอร์ IR แบบสร้างภาพ เซ็นเซอร์ PIR มักเรียกสั้นๆ ว่า "PIR"
หรือบางครั้งเรียกว่า "PID" ซึ่งย่อมาจาก "เครื่องตรวจจับอินฟราเรดแบบพาสซีฟ" เซ็นเซอร์ PIR หรือบางครั้งเรียกว่า "PID" ซึ่งย่อมาจาก "เครื่องตรวจจับอินฟราเรดแบบพาสซีฟ" เซ็นเซอร์ PIR
ตรวจจับการเคลื่อนไหวทั่วไป แต่ไม่ได้ให้ข้อมูลว่าใครหรือสิ่งใดเคลื่อนไหว ดังนั้น จึงจำเป็นต้องใช้ เซ็นเซอร์ ตรวจจับการเคลื่อนไหวทั่วไป แต่ไม่ได้ให้ข้อมูลว่าใครหรือสิ่งใดเคลื่อนไหว ดังนั้น จึงจำเป็นต้องใช้ เซ็นเซอร์
@@ -65,7 +65,7 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
caption: [สวิตช์ไฟภายในอาคารที่ติดตั้งเซนเซอรตรวจจับการครอบครองแบบ PIR], caption: [สวิตช์ไฟภายในอาคารที่ติดตั้งเซนเซอรตรวจจับการครอบครองแบบ PIR],
) )
#i เครื่องตรวจจับความเคลื่อนไหวแบบ PIR ใช้เพื่อตรวจจับการเคลื่อนไหวของคน สัตว์ หรือวัตถุอื่นๆ #iiii เครื่องตรวจจับความเคลื่อนไหวแบบ PIR ใช้เพื่อตรวจจับการเคลื่อนไหวของคน สัตว์ หรือวัตถุอื่นๆ
มักใช้กับสัญญาณกันขโมยและระบบไฟส่องสว่างแบบอัตโนมัติ มักใช้กับสัญญาณกันขโมยและระบบไฟส่องสว่างแบบอัตโนมัติ
== การดำเนินการ == การดำเนินการ
@@ -79,7 +79,7 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
วัตถุที่มีอุณหภูมิใกล้เคียงกันแต่มีลักษณะพื้นผิวต่างกันอาจมีรูปแบบการปล่อยรังสีอินฟราเรดที่แตกต่างกัน วัตถุที่มีอุณหภูมิใกล้เคียงกันแต่มีลักษณะพื้นผิวต่างกันอาจมีรูปแบบการปล่อยรังสีอินฟราเรดที่แตกต่างกัน
ดังนั้นการเคลื่อนย้ายวัตถุเทียบกับพื้นหลังอาจกระตุ้นเครื่องตรวจจับได้เช่นกัน ดังนั้นการเคลื่อนย้ายวัตถุเทียบกับพื้นหลังอาจกระตุ้นเครื่องตรวจจับได้เช่นกัน
#i PIR มีหลายรูปแบบการใช้งานที่หลากหลาย #iiii PIR มีหลายรูปแบบการใช้งานที่หลากหลาย
รุ่นที่นิยมใช้กันมากที่สุดมีเลนส์เฟรสเนลหรือส่วนกระจกจำนวนมาก ระยะการทำงานประมาณ 10 เมตร (30 รุ่นที่นิยมใช้กันมากที่สุดมีเลนส์เฟรสเนลหรือส่วนกระจกจำนวนมาก ระยะการทำงานประมาณ 10 เมตร (30
ฟุต) และมุมมองภาพน้อยกว่า 180° มีรุ่นที่มีมุมมองภาพกว้างกว่า รวมถึง 360° ฟุต) และมุมมองภาพน้อยกว่า 180° มีรุ่นที่มีมุมมองภาพกว้างกว่า รวมถึง 360°
ซึ่งโดยทั่วไปออกแบบมาเพื่อติดตั้งบนเพดาน PIR ซึ่งโดยทั่วไปออกแบบมาเพื่อติดตั้งบนเพดาน PIR
@@ -124,17 +124,17 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
caption: [การออกแบบเซ็นเซอร์ตรวจจับการเคลื่อนไหว PIR], caption: [การออกแบบเซ็นเซอร์ตรวจจับการเคลื่อนไหว PIR],
) )
#i โดยทั่วไปเซ็นเซอร์ PIR #iiii โดยทั่วไปเซ็นเซอร์ PIR
จะติดตั้งอยู่บนแผงวงจรพิมพ์ซึ่งมีอุปกรณ์อิเล็กทรอนิกส์ที่จำเป็นสำหรับการตีความสัญญาณจากตัวเซ็นเซอร์เอง จะติดตั้งอยู่บนแผงวงจรพิมพ์ซึ่งมีอุปกรณ์อิเล็กทรอนิกส์ที่จำเป็นสำหรับการตีความสัญญาณจากตัวเซ็นเซอร์เอง
โดยทั่วไปแล้วชุดประกอบทั้งหมดจะบรรจุอยู่ภายในตัวเรือน โดยทั่วไปแล้วชุดประกอบทั้งหมดจะบรรจุอยู่ภายในตัวเรือน
ซึ่งติดตั้งในตำแหน่งที่เซ็นเซอร์สามารถครอบคลุมพื้นที่ที่ต้องการตรวจสอบได้ ตัวเรือนมักจะมี "หน้าต่าง" ซึ่งติดตั้งในตำแหน่งที่เซ็นเซอร์สามารถครอบคลุมพื้นที่ที่ต้องการตรวจสอบได้ ตัวเรือนมักจะมี "หน้าต่าง"
พลาสติกที่พลังงานอินฟราเรดสามารถผ่านเข้ามาได้ แม้ว่ามักจะโปร่งแสงต่อแสงที่มองเห็น พลาสติกที่พลังงานอินฟราเรดสามารถผ่านเข้ามาได้ แม้ว่ามักจะโปร่งแสงต่อแสงที่มองเห็น
แต่พลังงานอินฟราเรดสามารถผ่านเข้ามายังเซ็นเซอร์ได้ผ่านหน้าต่าง แต่พลังงานอินฟราเรดสามารถผ่านเข้ามายังเซ็นเซอร์ได้ผ่านหน้าต่าง
เนื่องจากพลาสติกที่ใช้นั้นโปร่งใสต่อรังสีอินฟราเรด หน้าต่างพลาสติกช่วยลดโอกาสที่วัตถุแปลกปลอม (ฝุ่น เนื่องจากพลาสติกที่ใช้นั้นโปร่งใสต่อรังสีอินฟราเรด หน้าต่างพลาสติกช่วยลดโอกาสที่วัตถุแปลกปลอม (ฝุ่น
แมลง ฝน ฯลฯ) จะบดบังมุมมองของเซ็นเซอร์ ทำให้กลไกเสียหาย และอาจทำให้เกิดสัญญาณเตือนที่ผิดพลาด แมลง ฝน ฯลฯ)#jb จะบดบังมุมมองของเซ็นเซอร์ ทำให้กลไกเสียหาย
หน้าต่างนี้สามารถใช้เป็นตัวกรองเพื่อจำกัดความยาวคลื่นให้อยู่ที่ 8-14 ไมโครเมตร และอาจทำให้เกิดสัญญาณเตือนที่ผิดพลาด หน้าต่างนี้สามารถใช้เป็นตัวกรองเพื่อจำกัดความยาวคลื่นให้อยู่ที่
ซึ่งใกล้เคียงกับรังสีอินฟราเรดที่มนุษย์ปล่อยออกมามากที่สุด นอกจากนี้ยังสามารถใช้เป็นกลไกโฟกัสได้อีกด้วย 8-14 ไมโครเมตร ซึ่งใกล้เคียงกับรังสีอินฟราเรดที่มนุษย์ปล่อยออกมามากที่สุด
(ดูด้านล่าง) นอกจากนี้ยังสามารถใช้เป็นกลไกโฟกัสได้อีกด้วย (ดูด้านล่าง)
== การโฟกัส == การโฟกัส
@@ -233,18 +233,18 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
ความยาวของลำแสงเป็นตัวชี้วัดความไวของเครื่องตรวจจับในทิศทางนั้น], ความยาวของลำแสงเป็นตัวชี้วัดความไวของเครื่องตรวจจับในทิศทางนั้น],
) )
#i จากการโฟกัส ทำให้มุมมองของเครื่องตรวจจับกลายเป็นรูปแบบลำแสง ภายใต้มุมบางมุม (โซน)\ #h(9.75em) จากการโฟกัส ทำให้มุมมองของเครื่องตรวจจับกลายเป็นรูปแบบลำแสง ภายใต้มุมบางมุม
เซ็นเซอร์ PIR แทบจะไม่ได้รับพลังงานรังสีใด ๆ และภายใต้มุมอื่น ๆ PIR (โซน) เซ็นเซอร์ PIR แทบจะไม่ได้รับพลังงานรังสีใด ๆ และภายใต้มุมอื่น ๆ PIR
จะได้รับพลังงานอินฟราเรดในปริมาณที่เข้มข้น จะได้รับพลังงานอินฟราเรดในปริมาณที่เข้มข้น
การแยกนี้ช่วยให้เครื่องตรวจจับความเคลื่อนไหวสามารถแยกแยะระหว่างแสงสว่างที่กว้างและวัตถุที่กำลังเคลื่อนที่ได้ การแยกนี้ช่วยให้เครื่องตรวจจับความเคลื่อนไหวสามารถแยกแยะระหว่างแสงสว่างที่กว้างและวัตถุที่กำลังเคลื่อนที่ได้
#i เมื่อบุคคลเดินจากมุมหนึ่ง (ลำแสง) ไปยังอีกมุมหนึ่ง #h(9.75em) เมื่อบุคคลเดินจากมุมหนึ่ง (ลำแสง) ไปยังอีกมุมหนึ่ง
เครื่องตรวจจับจะมองเห็นบุคคลที่กำลังเคลื่อนไหวเป็นระยะ ๆ เท่านั้น เครื่องตรวจจับจะมองเห็นบุคคลที่กำลังเคลื่อนไหวเป็นระยะ ๆ เท่านั้น
ส่งผลให้สัญญาณเซ็นเซอร์เปลี่ยนแปลงอย่างรวดเร็ว ส่งผลให้สัญญาณเซ็นเซอร์เปลี่ยนแปลงอย่างรวดเร็ว
ซึ่งระบบอิเล็กทรอนิกส์จะใช้เพื่อส่งสัญญาณเตือนภัยหรือเปิดไฟ ซึ่งระบบอิเล็กทรอนิกส์จะใช้เพื่อส่งสัญญาณเตือนภัยหรือเปิดไฟ
ระบบอิเล็กทรอนิกส์จะไม่สนใจสัญญาณที่เปลี่ยนแปลงช้า ๆ ระบบอิเล็กทรอนิกส์จะไม่สนใจสัญญาณที่เปลี่ยนแปลงช้า ๆ
#i จำนวน รูปร่าง การกระจาย และความไวของโซนเหล่านี้ถูกกำหนดโดยเลนส์และกระจก #h(9.75em) จำนวน รูปร่าง การกระจาย และความไวของโซนเหล่านี้ถูกกำหนดโดยเลนส์และกระจก
ผู้ผลิตพยายามอย่างเต็มที่เพื่อสร้างรูปแบบลำแสงความไวที่เหมาะสมที่สุดสำหรับการใช้งานแต่ละประเภท ผู้ผลิตพยายามอย่างเต็มที่เพื่อสร้างรูปแบบลำแสงความไวที่เหมาะสมที่สุดสำหรับการใช้งานแต่ละประเภท
== การใช้งานระบบไฟอัตโนมัติ == การใช้งานระบบไฟอัตโนมัติ
@@ -253,7 +253,7 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
มักจะควบคุมรีเลย์ในตัวที่สามารถสลับแรงดันไฟฟ้าหลักได้ ซึ่งหมายความว่า PIR มักจะควบคุมรีเลย์ในตัวที่สามารถสลับแรงดันไฟฟ้าหลักได้ ซึ่งหมายความว่า PIR
สามารถตั้งค่าให้เปิดไฟที่เชื่อมต่อกับ PIR เมื่อตรวจพบการเคลื่อนไหวได้ วิธีนี้มักใช้ในสถานการณ์กลางแจ้ง สามารถตั้งค่าให้เปิดไฟที่เชื่อมต่อกับ PIR เมื่อตรวจพบการเคลื่อนไหวได้ วิธีนี้มักใช้ในสถานการณ์กลางแจ้ง
ทั้งเพื่อป้องกันอาชญากร (ไฟรักษาความปลอดภัย) หรือเพื่อการใช้งานจริง เช่น ทั้งเพื่อป้องกันอาชญากร (ไฟรักษาความปลอดภัย) หรือเพื่อการใช้งานจริง เช่น
การเปิดไฟประตูหน้าบ้านเพื่อให้คุณหากุญแจเจอในความมืด\ การเปิดไฟประตูหน้าบ้านเพื่อให้คุณหากุญแจเจอในความมืด
การใช้งานเพิ่มเติมสามารถทำได้ในห้องน้ำสาธารณะ ห้องเตรียมอาหารแบบวอล์กอิน ทางเดิน การใช้งานเพิ่มเติมสามารถทำได้ในห้องน้ำสาธารณะ ห้องเตรียมอาหารแบบวอล์กอิน ทางเดิน
หรือบริเวณใดก็ตามที่สามารถควบคุมไฟอัตโนมัติได้ วิธีนี้ช่วยประหยัดพลังงานได้ หรือบริเวณใดก็ตามที่สามารถควบคุมไฟอัตโนมัติได้ วิธีนี้ช่วยประหยัดพลังงานได้
เพราะไฟจะเปิดเฉพาะเมื่อจำเป็นเท่านั้น และผู้ใช้ไม่จำเป็นต้องปิดไฟเมื่อออกจากพื้นที่ เพราะไฟจะเปิดเฉพาะเมื่อจำเป็นเท่านั้น และผู้ใช้ไม่จำเป็นต้องปิดไฟเมื่อออกจากพื้นที่
@@ -271,7 +271,7 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
#h(9.75em) ผู้ผลิตแนะนำให้วางผลิตภัณฑ์อย่างระมัดระวังเพื่อป้องกันการแจ้งเตือนที่ผิดพลาด (เช่น #h(9.75em) ผู้ผลิตแนะนำให้วางผลิตภัณฑ์อย่างระมัดระวังเพื่อป้องกันการแจ้งเตือนที่ผิดพลาด (เช่น
การตรวจจับใดๆ ที่ไม่ได้เกิดจากผู้บุกรุก) การตรวจจับใดๆ ที่ไม่ได้เกิดจากผู้บุกรุก)
#i พวกเขาแนะนำให้ติดตั้ง PIR ในลักษณะที่ PIR ไม่สามารถ "มองเห็น" ออกจากหน้าต่างได้ #h(9.75em) พวกเขาแนะนำให้ติดตั้ง PIR ในลักษณะที่ PIR ไม่สามารถ "มองเห็น" ออกจากหน้าต่างได้
แม้ว่าความยาวคลื่นของรังสีอินฟราเรดที่ชิปมีความไวต่อแสงจะทะลุผ่านกระจกได้ไม่ดีนัก แม้ว่าความยาวคลื่นของรังสีอินฟราเรดที่ชิปมีความไวต่อแสงจะทะลุผ่านกระจกได้ไม่ดีนัก
แต่แหล่งกำเนิดแสงอินฟราเรดที่แรง (เช่น จากไฟหน้ารถยนต์หรือแสงแดด) แต่แหล่งกำเนิดแสงอินฟราเรดที่แรง (เช่น จากไฟหน้ารถยนต์หรือแสงแดด)
อาจทำให้เซ็นเซอร์รับภาพเกินพิกัดและทำให้เกิดสัญญาณเตือนภัยผิดพลาดได้ อาจทำให้เซ็นเซอร์รับภาพเกินพิกัดและทำให้เกิดสัญญาณเตือนภัยผิดพลาดได้
@@ -279,15 +279,15 @@ IR แบบสร้างภาพ เซ็นเซอร์ PIR มัก
ซึ่งอาจเป็นผลดีสำหรับหน้าต่างที่หันหน้าไปทางทางเท้าสาธารณะ ซึ่งอาจเป็นผลดีสำหรับหน้าต่างที่หันหน้าไปทางทางเท้าสาธารณะ
หรือเป็นผลเสียสำหรับหน้าต่างในฉากกั้นภายใน หรือเป็นผลเสียสำหรับหน้าต่างในฉากกั้นภายใน
#i ขอแนะนำว่าไม่ควรติดตั้ง PIR ในตำแหน่งที่ ช่องระบายอากาศ HVAC #h(9.75em) ขอแนะนำว่าไม่ควรติดตั้ง PIR ในตำแหน่งที่ ช่องระบายอากาศ HVAC
จะเป่าลมร้อนหรือเย็นลงบนพื้นผิวพลาสติกที่ปิดหน้าต่างของตัวบ้าน แม้ว่าอากาศจะมีค่าการแผ่รังสี ต่ำมาก จะเป่าลมร้อนหรือเย็นลงบนพื้นผิวพลาสติกที่ปิดหน้าต่างของตัวบ้าน แม้ว่าอากาศจะมีค่าการแผ่รังสี ต่ำมาก#jb
(ปล่อยพลังงานอินฟราเรดในปริมาณน้อยมาก) (ปล่อยพลังงานอินฟราเรดในปริมาณน้อยมาก)
แต่ลมที่พัดผ่านฝาครอบหน้าต่างพลาสติกอาจทำให้อุณหภูมิของพลาสติกเปลี่ยนแปลงจนทำให้เกิดสัญญาณเตือนที่ผิดพลาดได้ แต่ลมที่พัดผ่านฝาครอบหน้าต่างพลาสติกอาจทำให้อุณหภูมิของพลาสติกเปลี่ยนแปลงจนทำให้เกิดสัญญาณเตือนที่ผิดพลาดได้
#i เซ็นเซอร์มักได้รับการออกแบบมาให้ "เพิกเฉย" สัตว์เลี้ยงในบ้าน เช่น สุนัขหรือแมว #h(9.75em) เซ็นเซอร์มักได้รับการออกแบบมาให้ "เพิกเฉย" สัตว์เลี้ยงในบ้าน เช่น สุนัขหรือแมว
โดยการตั้งค่าความไวให้สูงขึ้น หรือทำให้แน่ใจว่าพื้นห้องจะไม่อยู่ในโฟกัส โดยการตั้งค่าความไวให้สูงขึ้น หรือทำให้แน่ใจว่าพื้นห้องจะไม่อยู่ในโฟกัส
#i เนื่องจากเซ็นเซอร์ PIR มีระยะการทำงานสูงสุด 10 เมตร (30 ฟุต) #h(9.75em) เนื่องจากเซ็นเซอร์ PIR มีระยะการทำงานสูงสุด 10 เมตร (30 ฟุต)
ดังนั้นการติดตั้งเครื่องตรวจจับเพียงตัวเดียวใกล้ทางเข้าจึงเพียงพอสำหรับห้องที่มีทางเข้าเพียงทางเดียว ดังนั้นการติดตั้งเครื่องตรวจจับเพียงตัวเดียวใกล้ทางเข้าจึงเพียงพอสำหรับห้องที่มีทางเข้าเพียงทางเดียว
ระบบรักษาความปลอดภัยที่ใช้ PIR ระบบรักษาความปลอดภัยที่ใช้ PIR
ยังใช้งานได้ดีกับระบบรักษาความปลอดภัยภายนอกอาคารและระบบไฟที่ไวต่อการเคลื่อนไหว ยังใช้งานได้ดีกับระบบรักษาความปลอดภัยภายนอกอาคารและระบบไฟที่ไวต่อการเคลื่อนไหว
Chapter2/Sensors.typ
+32 -6
View File
@@ -3,16 +3,42 @@
= เซนเซอร์ (Sensors) = เซนเซอร์ (Sensors)
#i โดยทั่วไปแล้ว เซนเซอร์จะถูกนิยามว่าเป็นอุปกรณ์ที่รับและตอบสนองต่อสัญญาณหรือสิ่งเร้าสิ่งเร้าคือปริมาณ คุณสมบัติ หรือสภาวะที่ถูกตรวจจับและแปลงเป็นสัญญาณไฟฟ้า #i โดยทั่วไปแล้ว เซนเซอร์จะถูกนิยามว่าเป็นอุปกรณ์ที่รับและตอบสนองต่อสัญญาณหรือสิ่งเร้าสิ่งเร้าคือปริมาณ
คุณสมบัติ หรือสภาวะที่ถูกตรวจจับและแปลงเป็นสัญญาณไฟฟ้า
#i ในความหมายกว้างที่สุด เซนเซอร์คืออุปกรณ์ โมดูล เครื่องจักร หรือระบบย่อยที่ตรวจจับเหตุการณ์หรือการเปลี่ยนแปลงในสภาพแวดล้อม และส่งข้อมูลไปยังอุปกรณ์อิเล็กทรอนิกส์อื่นๆ ซึ่งส่วนใหญ่มักจะเป็นหน่วยประมวลผลของคอมพิวเตอร์ #i ในความหมายกว้างที่สุด เซนเซอร์คืออุปกรณ์ โมดูล เครื่องจักร
หรือระบบย่อยที่ตรวจจับเหตุการณ์หรือการเปลี่ยนแปลงในสภาพแวดล้อม
และส่งข้อมูลไปยังอุปกรณ์อิเล็กทรอนิกส์อื่นๆ ซึ่งส่วนใหญ่มักจะเป็นหน่วยประมวลผลของคอมพิวเตอร์
#i เซ็นเซอร์ถูกนำมาใช้ในสิ่งของในชีวิตประจำวัน เช่น ปุ่มลิฟต์แบบสัมผัส (เซ็นเซอร์สัมผัส) และโคมไฟที่หรี่หรือสว่างขึ้นโดยการสัมผัสที่ฐาน และในแอปพลิเคชันมากมายนับไม่ถ้วนซึ่งคนส่วนใหญ่ไม่เคยตระหนักถึง ด้วยความก้าวหน้าในด้านไมโครแมชชีนเนอรี่ และแพลตฟอร์ม ไมโครคอนโทรลเลอร์ที่ใช้งานง่ายการใช้งานเซ็นเซอร์จึงขยายออกไปนอกเหนือจากสาขาแบบดั้งเดิมของการวัดอุณหภูมิ ความดัน และการไหลตัวอย่างเช่น ไปสู่เซ็นเซอร์ MARG #i เซ็นเซอร์ถูกนำมาใช้ในสิ่งของในชีวิตประจำวัน เช่น ปุ่มลิฟต์แบบสัมผัส (เซ็นเซอร์สัมผัส)
และโคมไฟที่หรี่หรือสว่างขึ้นโดยการสัมผัสที่ฐาน
และในแอปพลิเคชันมากมายนับไม่ถ้วนซึ่งคนส่วนใหญ่ไม่เคยตระหนักถึง
ด้วยความก้าวหน้าในด้านไมโครแมชชีนเนอรี่ และแพลตฟอร์ม
ไมโครคอนโทรลเลอร์ที่ใช้งานง่ายการใช้งานเซ็นเซอร์จึงขยายออกไปนอกเหนือจากสาขาแบบดั้งเดิมของการวัดอุณหภูมิ
ความดัน และการไหลตัวอย่างเช่น ไปสู่เซ็นเซอร์ MARG
#i เซ็นเซอร์แบบอนาล็อก เช่นโพเทนชิโอมิเตอร์และตัวต้านทานรับแรงยังคงมีการใช้งานอย่างแพร่หลาย การใช้งานของเซ็นเซอร์เหล่านี้รวมถึงการผลิตและเครื่องจักร เครื่องบินและอวกาศ รถยนต์ การแพทย์ หุ่นยนต์และอีกหลายแง่มุมในชีวิตประจำวันของเรา นอกจากนี้ยังมีเซ็นเซอร์อื่นๆ อีกมากมายที่ใช้วัดคุณสมบัติทางเคมีและกายภาพของวัสดุ รวมถึงเซ็นเซอร์แบบออปติคอลสำหรับการวัดดัชนีหักเห เซ็นเซอร์แบบสั่นสะเทือนสำหรับการวัดความหนืดของของเหลว และเซ็นเซอร์ทางเคมีไฟฟ้าสำหรับการตรวจสอบค่า pH ของของเหลว #i เซ็นเซอร์แบบอนาล็อก เช่นโพเทนชิโอมิเตอร์และตัวต้านทานรับแรงยังคงมีการใช้งานอย่างแพร่หลาย
การใช้งานของเซ็นเซอร์เหล่านี้รวมถึงการผลิตและเครื่องจักร เครื่องบินและอวกาศ รถยนต์ การแพทย์
หุ่นยนต์และอีกหลายแง่มุมในชีวิตประจำวันของเรา นอกจากนี้ยังมีเซ็นเซอร์อื่นๆ
อีกมากมายที่ใช้วัดคุณสมบัติทางเคมีและกายภาพของวัสดุ รวมถึงเซ็นเซอร์แบบออปติคอลสำหรับการวัดดัชนีหักเห
เซ็นเซอร์แบบสั่นสะเทือนสำหรับการวัดความหนืดของของเหลว
และเซ็นเซอร์ทางเคมีไฟฟ้าสำหรับการตรวจสอบค่า pH ของของเหลว
#i ความไวของเซนเซอร์บ่งชี้ว่าเอาต์พุตเปลี่ยนแปลงไปมากน้อยเพียงใดเมื่อปริมาณอินพุตที่วัดเปลี่ยนแปลง ตัวอย่างเช่น หากปรอทในเทอร์โมมิเตอร์เคลื่อนที่ 1 ซม. เมื่ออุณหภูมิเปลี่ยนแปลง 1 °C ความไวของมันคือ 1 ซม./°C (โดยพื้นฐานแล้วคือความชัน dy/dx โดยสมมติว่ามีลักษณะเชิงเส้น) เซนเซอร์บางชนิดอาจส่งผลต่อสิ่งที่วัดได้เช่นกัน ตัวอย่างเช่น เทอร์โมมิเตอร์วัดอุณหภูมิห้องที่เสียบลงในถ้วยของเหลวร้อนจะทำให้ของเหลวเย็นลงในขณะที่ของเหลวทำให้เทอร์โมมิเตอร์ร้อนขึ้น โดยทั่วไปเซนเซอร์ได้รับการออกแบบให้มีผลกระทบต่อสิ่งที่วัดน้อยที่สุด การทำให้เซนเซอร์มีขนาดเล็กลงมักจะช่วยปรับปรุงสิ่งนี้และอาจนำมาซึ่งข้อดีอื่นๆ #i ความไวของเซนเซอร์บ่งชี้ว่าเอาต์พุตเปลี่ยนแปลงไปมากน้อยเพียงใดเมื่อปริมาณอินพุตที่วัดเปลี่ยนแปลง
ตัวอย่างเช่น หากปรอทในเทอร์โมมิเตอร์เคลื่อนที่ 1 ซม. เมื่ออุณหภูมิเปลี่ยนแปลง#jb 1 °C
ความไวของมันคือ 1 ซม./°C (โดยพื้นฐานแล้วคือความชัน dy/dx โดยสมมติว่ามีลักษณะเชิงเส้น)#jb
เซนเซอร์บางชนิดอาจส่งผลต่อสิ่งที่วัดได้เช่นกัน ตัวอย่างเช่น
เทอร์โมมิเตอร์วัดอุณหภูมิห้องที่เสียบลงในถ้วยของเหลวร้อนจะทำให้ของเหลวเย็นลงในขณะที่ของเหลวทำให้เทอร์โมมิเตอร์ร้อนขึ้น
โดยทั่วไปเซนเซอร์ได้รับการออกแบบให้มีผลกระทบต่อสิ่งที่วัดน้อยที่สุด
การทำให้เซนเซอร์มีขนาดเล็กลงมักจะช่วยปรับปรุงสิ่งนี้และอาจนำมาซึ่งข้อดีอื่นๆ
#i ความก้าวหน้าทางเทคโนโลยีทำให้สามารถผลิตเซ็นเซอร์ได้มากขึ้นเรื่อยๆ ในระดับจุลภาคเช่น ไมโครเซ็นเซอร์โดยใช้ เทคโนโลยี MEMSในกรณีส่วนใหญ่ ไมโครเซ็นเซอร์สามารถวัดได้เร็วกว่าและมีความไวสูงกว่าเมื่อเทียบกับวิธีการแบบมหภาคเนื่องจากความต้องการข้อมูลที่รวดเร็ว ราคาไม่แพง และเชื่อถือได้เพิ่มมากขึ้นในโลกปัจจุบัน เซ็นเซอร์แบบใช้แล้วทิ้ง ซึ่งเป็นอุปกรณ์ราคาถูกและใช้งานง่ายสำหรับการตรวจสอบระยะสั้นหรือการวัดแบบครั้งเดียว จึงได้รับความสำคัญเพิ่มมากขึ้น การใช้เซ็นเซอร์ประเภทนี้ทำให้ทุกคนสามารถรับข้อมูลการวิเคราะห์ที่สำคัญได้ทุกที่ ทุกเวลา โดยไม่จำเป็นต้องปรับเทียบใหม่และไม่ต้องกังวลเรื่องการปนเปื้อน #i ความก้าวหน้าทางเทคโนโลยีทำให้สามารถผลิตเซ็นเซอร์ได้มากขึ้นเรื่อย ๆ ในระดับจุลภาคเช่น
ไมโครเซ็นเซอร์โดยใช้เทคโนโลยี MEMS ในกรณีส่วนใหญ่
ไมโครเซ็นเซอร์สามารถวัดได้เร็วกว่าและมีความไวสูงกว่าเมื่อเทียบกับวิธีการแบบมหภาคเนื่องจากความต้องการข้อมูลที่รวดเร็ว
ราคาไม่แพง#jb และเชื่อถือได้เพิ่มมากขึ้นในโลกปัจจุบัน เซ็นเซอร์แบบใช้แล้วทิ้ง
ซึ่งเป็นอุปกรณ์ราคาถูกและใช้งานง่ายสำหรับการตรวจสอบระยะสั้นหรือการวัดแบบครั้งเดียว
จึงได้รับความสำคัญเพิ่มมากขึ้น
การใช้เซ็นเซอร์ประเภทนี้ทำให้ทุกคนสามารถรับข้อมูลการวิเคราะห์ที่สำคัญได้ทุกที่ ทุกเวลา
โดยไม่จำเป็นต้องปรับเทียบใหม่และไม่ต้องกังวลเรื่องการปนเปื้อน
#include "PIR.typ" #include "PIR.typ"
Chapter2/TLS.typ
+100 -24
View File
@@ -1,53 +1,129 @@
#import "../PageTemplate.typ": i #import "../PageTemplate.typ": *
#set list(marker: ([•], [○], [■])) #set list(marker: ([•], [○], [■]))
= เกณฑ์วิธีความมั่นคงของชั้นขนส่ง (Transport Layer Security; TLS) = เกณฑ์วิธีความมั่นคงของชั้นขนส่ง (Transport Layer Security; TLS)
#i #i
เกณฑ์วิธีความมั่นคงของชั้นขนส่ง (Transport Layer Security; TLS) เป็นโปรโตคอลการเข้ารหัสที่ออกแบบมาเพื่อรักษาความปลอดภัยการสื่อสารบนเครือข่ายคอมพิวเตอร์เช่นอินเทอร์เน็ตโปรโตคอลนี้ถูกใช้อย่างแพร่หลายในแอปพลิเคชันต่างๆเช่นอีเมลการส่งข้อความโต้ตอบแบบทันทีและบริการเสียงผ่าน IP แต่การใช้งานเพื่อรักษาความปลอดภัย HTTPS ยังคงเป็นที่เปิดเผยต่อสาธารณะมากที่สุด เกณฑ์วิธีความมั่นคงของชั้นขนส่ง (Transport Layer Security; TLS)
เป็นโปรโตคอลการเข้ารหัสที่ออกแบบมาเพื่อรักษาความปลอดภัยการสื่อสารบนเครือข่ายคอมพิวเตอร์เช่นอินเทอร์เน็ตโปรโตคอลนี้ถูกใช้อย่างแพร่หลายในแอปพลิเคชันต่างๆเช่นอีเมลการส่งข้อความโต้ตอบแบบทันทีและบริการเสียงผ่าน
IP แต่การใช้งานเพื่อรักษาความปลอดภัย HTTPS ยังคงเป็นที่เปิดเผยต่อสาธารณะมากที่สุด
#i โปรโตคอล TLS มีวัตถุประสงค์หลักเพื่อรักษาความปลอดภัย รวมถึงความเป็นส่วนตัว (ความลับ) ความสมบูรณ์ และความถูกต้อง ผ่านการใช้การเข้ารหัสเช่น การใช้ใบรับรองระหว่างแอปพลิเคชันคอมพิวเตอร์ที่สื่อสารกันตั้งแต่สองแอปพลิเคชันขึ้นไป โปรโตคอลนี้ทำงานในเลเยอร์การนำเสนอและประกอบด้วยสองชั้น ได้แก่ ระเบียน TLS และโปรโตคอล TLS handshake #i โปรโตคอล TLS มีวัตถุประสงค์หลักเพื่อรักษาความปลอดภัย รวมถึงความเป็นส่วนตัว (ความลับ)
ความสมบูรณ์ และความถูกต้อง ผ่านการใช้การเข้ารหัสเช่น
การใช้ใบรับรองระหว่างแอปพลิเคชันคอมพิวเตอร์ที่สื่อสารกันตั้งแต่สองแอปพลิเคชันขึ้นไป
โปรโตคอลนี้ทำงานในเลเยอร์การนำเสนอและประกอบด้วยสองชั้น ได้แก่ ระเบียน TLS และโปรโตคอล TLS
handshake
#i Datagram Transport Layer Security (DTLS) ซึ่งเป็นโปรโตคอลการสื่อสารที่เกี่ยวข้องอย่างใกล้ชิดมอบความปลอดภัยให้กับ แอปพลิเคชันที่ใช้ ดาต้าแกรมในงานเขียนทางเทคนิค มักพบการอ้างอิงถึง "(D)TLS" เมื่อใช้กับทั้งสองเวอร์ชัน #i Datagram Transport Layer Security (DTLS)
ซึ่งเป็นโปรโตคอลการสื่อสารที่เกี่ยวข้องอย่างใกล้ชิดมอบความปลอดภัยให้กับ แอปพลิเคชันที่ใช้
ดาต้าแกรมในงานเขียนทางเทคนิค มักพบการอ้างอิงถึง "(D)TLS" เมื่อใช้กับทั้งสองเวอร์ชัน
#i TLS เป็นมาตรฐานที่ได้รับการเสนอโดย Internet Engineering Task Force (IETF) ซึ่งกำหนดขึ้นครั้งแรกในปี 1999 และเวอร์ชันปัจจุบันคือ TLS 1.3 ซึ่งกำหนดขึ้นในเดือนสิงหาคม 2018 TLS สร้างขึ้นจาก ข้อกำหนด SSL (Secure Sockets Layer) ที่ไม่รองรับอีกต่อไป (1994, 1995, 1996) ซึ่งพัฒนาโดย Netscape Communications เพื่อเพิ่มโปรโตคอล HTTPS ลงในเว็บเบราว์เซอร์ Netscape Navigator #i TLS เป็นมาตรฐานที่ได้รับการเสนอโดย Internet Engineering Task Force (IETF)
ซึ่งกำหนดขึ้นครั้งแรกในปี 1999 และเวอร์ชันปัจจุบันคือ TLS 1.3 ซึ่งกำหนดขึ้นในเดือนสิงหาคม 2018 TLS
สร้างขึ้นจาก ข้อกำหนด SSL (Secure Sockets Layer) ที่ไม่รองรับอีกต่อไป (1994, 1995, 1996)
ซึ่งพัฒนาโดย Netscape Communications เพื่อเพิ่มโปรโตคอล HTTPS ลงในเว็บเบราว์เซอร์ Netscape
Navigator
== คำอธิบาย == คำอธิบาย
#i #iii
เนื่องจากแอปพลิเคชันสามารถสื่อสารได้ทั้งแบบมีหรือไม่มี TLS (หรือ SSL) จึงจำเป็นที่ไคลเอนต์จะต้องร้องขอให้เซิร์ฟเวอร์ตั้งค่าการเชื่อมต่อ TLS หนึ่งในวิธีหลักในการทำเช่นนี้คือการใช้หมายเลขพอร์ต อื่น สำหรับการเชื่อมต่อ TLS โดยทั่วไปแล้ว พอร์ต 80 จะใช้สำหรับ การรับส่งข้อมูล HTTP ที่ไม่ได้เข้ารหัส ในขณะที่พอร์ต 443 เป็นพอร์ตทั่วไปที่ใช้สำหรับ การรับส่งข้อมูล HTTPS ที่เข้ารหัส อีกกลไกหนึ่งคือการสร้างคำขอ STARTTLS เฉพาะโปรโตคอลไปยังเซิร์ฟเวอร์เพื่อสลับการเชื่อมต่อกับ TLS ตัวอย่างเช่น เมื่อใช้โปรโตคอลอีเมลและข่าวสารบางอย่าง เนื่องจากแอปพลิเคชันสามารถสื่อสารได้ทั้งแบบมีหรือไม่มี TLS (หรือ SSL)
จึงจำเป็นที่ไคลเอนต์จะต้องร้องขอให้เซิร์ฟเวอร์ตั้งค่าการเชื่อมต่อ TLS
หนึ่งในวิธีหลักในการทำเช่นนี้คือการใช้หมายเลขพอร์ต อื่น สำหรับการเชื่อมต่อ TLS โดยทั่วไปแล้ว พอร์ต 80
จะใช้สำหรับ การรับส่งข้อมูล HTTP ที่ไม่ได้เข้ารหัส ในขณะที่พอร์ต 443 เป็นพอร์ตทั่วไปที่ใช้สำหรับ
การรับส่งข้อมูล HTTPS ที่เข้ารหัส อีกกลไกหนึ่งคือการสร้างคำขอ STARTTLS
เฉพาะโปรโตคอลไปยังเซิร์ฟเวอร์เพื่อสลับการเชื่อมต่อกับ TLS ตัวอย่างเช่น
เมื่อใช้โปรโตคอลอีเมลและข่าวสารบางอย่าง
#i เมื่อไคลเอนต์และเซิร์ฟเวอร์ตกลงที่จะใช้ TLS แล้ว พวกเขาจะเจรจา การเชื่อมต่อ แบบมีสถานะโดยใช้ขั้นตอนการจับมือ (ดูการจับมือ TLS) โปรโตคอลใช้การจับมือกับรหัสแบบอสมมาตรเพื่อกำหนดค่าการเข้ารหัสไม่เพียงเท่านั้น แต่ยังรวมถึงคีย์ที่ใช้ร่วมกันเฉพาะเซสชัน ซึ่งการสื่อสารต่อไปจะถูกเข้ารหัสโดยใช้รหัสแบบสมมาตรในระหว่างการจับมือนี้ ไคลเอนต์และเซิร์ฟเวอร์จะตกลงกันเกี่ยวกับพารามิเตอร์ต่างๆ ที่ใช้สร้างความปลอดภัยของการเชื่อมต่อ: #iii เมื่อไคลเอนต์และเซิร์ฟเวอร์ตกลงที่จะใช้ TLS แล้ว พวกเขาจะเจรจา การเชื่อมต่อ
แบบมีสถานะโดยใช้ขั้นตอนการจับมือ (ดูการจับมือ TLS)
โปรโตคอลใช้การจับมือกับรหัสแบบอสมมาตรเพื่อกำหนดค่าการเข้ารหัสไม่เพียงเท่านั้น
แต่ยังรวมถึงคีย์ที่ใช้ร่วมกันเฉพาะเซสชัน
ซึ่งการสื่อสารต่อไปจะถูกเข้ารหัสโดยใช้รหัสแบบสมมาตรในระหว่างการจับมือนี้
ไคลเอนต์และเซิร์ฟเวอร์จะตกลงกันเกี่ยวกับพารามิเตอร์ต่างๆ ที่ใช้สร้างความปลอดภัยของการเชื่อมต่อ:
- การจับมือเริ่มต้นเมื่อไคลเอนต์เชื่อมต่อกับเซิร์ฟเวอร์ที่เปิดใช้งาน TLS เพื่อขอการเชื่อมต่อที่ปลอดภัยและไคลเอนต์แสดงรายการชุดรหัสที่รองรับ (รหัสและฟังก์ชันแฮช) - การจับมือเริ่มต้นเมื่อไคลเอนต์เชื่อมต่อกับเซิร์ฟเวอร์ที่เปิดใช้งาน TLS
เพื่อขอการเชื่อมต่อที่ปลอดภัยและไคลเอนต์แสดงรายการชุดรหัสที่รองรับ (รหัสและฟังก์ชันแฮช)
- จากรายการนี้ เซิร์ฟเวอร์จะเลือกฟังก์ชันรหัสและแฮชที่รองรับ และแจ้งให้ไคลเอนต์ทราบถึงการตัดสินใจ - จากรายการนี้ เซิร์ฟเวอร์จะเลือกฟังก์ชันรหัสและแฮชที่รองรับ และแจ้งให้ไคลเอนต์ทราบถึงการตัดสินใจ
- โดยปกติแล้วเซิร์ฟเวอร์จะระบุตัวตนในรูปแบบของใบรับรองดิจิทัลใบรับรองประกอบด้วยชื่อเซิร์ฟเวอร์ผู้ให้บริการออกใบรับรอง (CA) ที่เชื่อถือได้ซึ่งรับรองความถูกต้องของใบรับรอง และคีย์การเข้ารหัสสาธารณะของเซิร์ฟเวอร์ - โดยปกติแล้วเซิร์ฟเวอร์จะระบุตัวตนในรูปแบบของใบรับรองดิจิทัลใบรับรองประกอบด้วยชื่อเซิร์ฟเวอร์ผู้ให้บริการออกใบรับรอง
(CA) ที่เชื่อถือได้ซึ่งรับรองความถูกต้องของใบรับรอง และคีย์การเข้ารหัสสาธารณะของเซิร์ฟเวอร์
- ลูกค้าต้องยืนยันความถูกต้องของใบรับรองก่อนดำเนินการต่อ - ลูกค้าต้องยืนยันความถูกต้องของใบรับรองก่อนดำเนินการต่อ
- ในการสร้างคีย์เซสชันที่ใช้สำหรับการเชื่อมต่อที่ปลอดภัย ไคลเอนต์จะต้องทำดังนี้: - ในการสร้างคีย์เซสชันที่ใช้สำหรับการเชื่อมต่อที่ปลอดภัย ไคลเอนต์จะต้องทำดังนี้:
- เข้ารหัสตัวเลขสุ่ม (PreMasterSecret) ด้วยคีย์สาธารณะของเซิร์ฟเวอร์และส่งผลลัพธ์ไปยังเซิร์ฟเวอร์ (ซึ่งเฉพาะเซิร์ฟเวอร์เท่านั้นที่จะสามารถถอดรหัสด้วยคีย์ส่วนตัว) จากนั้นทั้งสองฝ่ายใช้ตัวเลขสุ่มเพื่อสร้างคีย์เซสชันเฉพาะสำหรับการเข้ารหัสและถอดรหัสข้อมูลในระหว่างเซสชันในภายหลังหรือ - เข้ารหัสตัวเลขสุ่ม (PreMasterSecret)
- ใช้การแลกเปลี่ยนคีย์ Diffie–Hellman (หรือรูปแบบ DH ที่เป็นเส้นโค้งวงรี) เพื่อสร้างคีย์เซสชันแบบสุ่มและไม่ซ้ำกันอย่างปลอดภัยสำหรับการเข้ารหัสและถอดรหัส ซึ่งมีคุณสมบัติเพิ่มเติมของการปกปิดแบบส่งต่อ : หากคีย์ส่วนตัวของเซิร์ฟเวอร์ถูกเปิดเผยในอนาคต จะไม่สามารถใช้คีย์นั้นเพื่อถอดรหัสเซสชันปัจจุบันได้ แม้ว่าเซสชันนั้นจะถูกดักจับและบันทึกโดยบุคคลที่สามก็ตาม ด้วยคีย์สาธารณะของเซิร์ฟเวอร์และส่งผลลัพธ์ไปยังเซิร์ฟเวอร์
(ซึ่งเฉพาะเซิร์ฟเวอร์เท่านั้นที่จะสามารถถอดรหัสด้วยคีย์ส่วนตัว)
จากนั้นทั้งสองฝ่ายใช้ตัวเลขสุ่มเพื่อสร้างคีย์เซสชันเฉพาะสำหรับการเข้ารหัสและถอดรหัสข้อมูลในระหว่างเซสชันในภายหลังหรือ
- ใช้การแลกเปลี่ยนคีย์ Diffie--Hellman (หรือรูปแบบ DH ที่เป็นเส้นโค้งวงรี)
เพื่อสร้างคีย์เซสชันแบบสุ่มและไม่ซ้ำกันอย่างปลอดภัยสำหรับการเข้ารหัสและถอดรหัส
ซึ่งมีคุณสมบัติเพิ่มเติมของการปกปิดแบบส่งต่อ : หากคีย์ส่วนตัวของเซิร์ฟเวอร์ถูกเปิดเผยในอนาคต
จะไม่สามารถใช้คีย์นั้นเพื่อถอดรหัสเซสชันปัจจุบันได้
แม้ว่าเซสชันนั้นจะถูกดักจับและบันทึกโดยบุคคลที่สามก็ตาม
#i การดำเนินการนี้จะสิ้นสุดการจับมือและเริ่มการเชื่อมต่อที่ปลอดภัยซึ่งจะถูกเข้ารหัสและถอดรหัสด้วยคีย์เซสชันจนกว่าการเชื่อมต่อจะสิ้นสุดลงหากขั้นตอนใดขั้นตอนหนึ่งข้างต้นล้มเหลวการจับมือ TLS จะล้มเหลวและการเชื่อมต่อจะไม่ถูกสร้างขึ้น #iii
การดำเนินการนี้จะสิ้นสุดการจับมือและเริ่มการเชื่อมต่อที่ปลอดภัยซึ่งจะถูกเข้ารหัสและถอดรหัสด้วยคีย์เซสชันจนกว่าการเชื่อมต่อจะสิ้นสุดลงหากขั้นตอนใดขั้นตอนหนึ่งข้างต้นล้มเหลวการจับมือ
TLS จะล้มเหลวและการเชื่อมต่อจะไม่ถูกสร้างขึ้น
#i TLS และ SSL ไม่สามารถจัดวางได้อย่างลงตัวในเลเยอร์ใดเลเยอร์หนึ่งของแบบจำลอง OSI หรือแบบจำลอง TCP/IP TLS ทำงาน "บนโปรโตคอลการขนส่งที่เชื่อถือได้ (เช่น TCP)" ซึ่งหมายความว่ามันอยู่เหนือเลเยอร์การขนส่งมันทำหน้าที่เข้ารหัสให้กับเลเยอร์ที่สูงกว่า ซึ่งโดยปกติแล้วเป็นหน้าที่ของเลเยอร์การนำเสนออย่างไรก็ตาม โดยทั่วไปแอปพลิเคชันจะใช้ TLS เหมือนกับเป็นเลเยอร์การขนส่งแม้ว่าแอปพลิเคชันที่ใช้ TLS จะต้องควบคุมการเริ่มต้นการจับมือ TLS และการจัดการใบรับรองการตรวจสอบสิทธิ์ที่แลกเปลี่ยนกัน #iii TLS และ SSL ไม่สามารถจัดวางได้อย่างลงตัวในเลเยอร์ใดเลเยอร์หนึ่งของแบบจำลอง OSI
หรือแบบจำลอง TCP/IP TLS ทำงาน "บนโปรโตคอลการขนส่งที่เชื่อถือได้ (เช่น TCP)"
ซึ่งหมายความว่ามันอยู่เหนือเลเยอร์การขนส่งมันทำหน้าที่เข้ารหัสให้กับเลเยอร์ที่สูงกว่า
ซึ่งโดยปกติแล้วเป็นหน้าที่ของเลเยอร์การนำเสนออย่างไรก็ตาม โดยทั่วไปแอปพลิเคชันจะใช้ TLS
เหมือนกับเป็นเลเยอร์การขนส่งแม้ว่าแอปพลิเคชันที่ใช้ TLS จะต้องควบคุมการเริ่มต้นการจับมือ TLS
และการจัดการใบรับรองการตรวจสอบสิทธิ์ที่แลกเปลี่ยนกัน
#i เมื่อได้รับการรักษาความปลอดภัยโดย TLS การเชื่อมต่อระหว่างไคลเอนต์ (เช่น เว็บเบราว์เซอร์)\ และเซิร์ฟเวอร์ (เช่น wikipedia.org) จะมีคุณสมบัติทั้งหมดดังต่อไปนี้ #iii เมื่อได้รับการรักษาความปลอดภัยโดย TLS การเชื่อมต่อระหว่างไคลเอนต์ (เช่น เว็บเบราว์เซอร์)
และเซิร์ฟเวอร์ (เช่น wikipedia.org) จะมีคุณสมบัติทั้งหมดดังต่อไปนี้
- การเชื่อมต่อเป็นแบบส่วนตัว (หรือมีความลับ) เนื่องจาก มีการใช้ อัลกอริทึมคีย์แบบสมมาตรในการเข้ารหัสข้อมูลที่ส่ง คีย์สำหรับการเข้ารหัสแบบสมมาตรนี้จะถูกสร้างขึ้นอย่างเฉพาะเจาะจงสำหรับแต่ละการเชื่อมต่อ และอิงจากความลับร่วมที่เจรจากันไว้เมื่อเริ่มต้นเซสชัน เซิร์ฟเวอร์และไคลเอ็นต์จะเจรจารายละเอียดเกี่ยวกับอัลกอริทึมการเข้ารหัสและคีย์การเข้ารหัสที่จะใช้ก่อนที่จะส่งข้อมูลไบต์แรก (ดูด้านล่าง) การเจรจาความลับร่วมนั้นทั้งปลอดภัย (ความลับที่เจรจากันไว้จะไม่สามารถเข้าถึงได้โดยผู้ดักฟังและไม่สามารถได้รับ แม้แต่โดยผู้โจมตีที่วางตัวเองอยู่ตรงกลางการเชื่อมต่อ) และเชื่อถือได้ (ไม่มีผู้โจมตีคนใดสามารถแก้ไขการสื่อสารระหว่างการเจรจาโดยไม่ถูกตรวจพบ) - การเชื่อมต่อเป็นแบบส่วนตัว (หรือมีความลับ) เนื่องจาก มีการใช้
อัลกอริทึมคีย์แบบสมมาตรในการเข้ารหัสข้อมูลที่ส่ง
คีย์สำหรับการเข้ารหัสแบบสมมาตรนี้จะถูกสร้างขึ้นอย่างเฉพาะเจาะจงสำหรับแต่ละการเชื่อมต่อ
และอิงจากความลับร่วมที่เจรจากันไว้เมื่อเริ่มต้นเซสชัน
เซิร์ฟเวอร์และไคลเอ็นต์จะเจรจารายละเอียดเกี่ยวกับอัลกอริทึมการเข้ารหัสและคีย์การเข้ารหัสที่จะใช้ก่อนที่จะส่งข้อมูลไบต์แรก
(ดูด้านล่าง) การเจรจาความลับร่วมนั้นทั้งปลอดภัย
(ความลับที่เจรจากันไว้จะไม่สามารถเข้าถึงได้โดยผู้ดักฟังและไม่สามารถได้รับ
แม้แต่โดยผู้โจมตีที่วางตัวเองอยู่ตรงกลางการเชื่อมต่อ) และเชื่อถือได้
(ไม่มีผู้โจมตีคนใดสามารถแก้ไขการสื่อสารระหว่างการเจรจาโดยไม่ถูกตรวจพบ)
- การยืนยันตัวตนของฝ่ายที่สื่อสารสามารถยืนยันได้โดยใช้การเข้ารหัสด้วยคีย์สาธารณะการยืนยันตัวตนนี้จำเป็นสำหรับเซิร์ฟเวอร์และเป็นทางเลือกสำหรับไคลเอนต์ - การยืนยันตัวตนของฝ่ายที่สื่อสารสามารถยืนยันได้โดยใช้การเข้ารหัสด้วยคีย์สาธารณะการยืนยันตัวตนนี้จำเป็นสำหรับเซิร์ฟเวอร์และเป็นทางเลือกสำหรับไคลเอนต์
- การเชื่อมต่อมีความน่าเชื่อถือ (หรือมีความสมบูรณ์) เนื่องจากข้อความแต่ละข้อความที่ส่งออกจะมีการตรวจสอบความสมบูรณ์ของข้อความโดยใช้รหัสยืนยันข้อความเพื่อป้องกันการสูญหายหรือการเปลี่ยนแปลงข้อมูลที่ไม่ถูกตรวจพบระหว่างการส่งข้อมูล - การเชื่อมต่อมีความน่าเชื่อถือ (หรือมีความสมบูรณ์)
เนื่องจากข้อความแต่ละข้อความที่ส่งออกจะมีการตรวจสอบความสมบูรณ์ของข้อความโดยใช้รหัสยืนยันข้อความเพื่อป้องกันการสูญหายหรือการเปลี่ยนแปลงข้อมูลที่ไม่ถูกตรวจพบระหว่างการส่งข้อมูล
#i TLS รองรับวิธีการที่หลากหลายสำหรับการแลกเปลี่ยนคีย์ การเข้ารหัสข้อมูล และการตรวจสอบความถูกต้องของข้อความ ดังนั้น การกำหนดค่า TLS อย่างปลอดภัยจึงเกี่ยวข้องกับพารามิเตอร์ที่กำหนดค่าได้มากมาย และตัวเลือกทั้งหมดไม่ได้มีคุณสมบัติที่เกี่ยวข้องกับความเป็นส่วนตัวทั้งหมดที่อธิบายไว้ในรายการด้านบน (ดูตารางด้านล่าง การแลกเปลี่ยนคีย์ ความปลอดภัยของการเข้ารหัสและความสมบูรณ์ของข้อมูล) #iii TLS รองรับวิธีการที่หลากหลายสำหรับการแลกเปลี่ยนคีย์ การเข้ารหัสข้อมูล
และการตรวจสอบความถูกต้องของข้อความ ดังนั้น การกำหนดค่า TLS
อย่างปลอดภัยจึงเกี่ยวข้องกับพารามิเตอร์ที่กำหนดค่าได้มากมาย
และตัวเลือกทั้งหมดไม่ได้มีคุณสมบัติที่เกี่ยวข้องกับความเป็นส่วนตัวทั้งหมดที่อธิบายไว้ในรายการด้านบน
(ดูตารางด้านล่าง การแลกเปลี่ยนคีย์ ความปลอดภัยของการเข้ารหัสและความสมบูรณ์ของข้อมูล)
#i มีการพยายามบ่อนทำลายแง่มุมด้านความปลอดภัยในการสื่อสารที่ TLS มุ่งหวังจะมอบให้ และโปรโตคอลนี้ได้รับการแก้ไขหลายครั้งเพื่อจัดการกับภัยคุกคามด้านความปลอดภัยเหล่านี้ นักพัฒนาเว็บเบราว์เซอร์ได้ปรับปรุงผลิตภัณฑ์ของตนซ้ำแล้วซ้ำเล่าเพื่อป้องกันจุดอ่อนด้านความปลอดภัยที่อาจเกิดขึ้นหลังจากค้นพบจุดอ่อนเหล่านี้ (ดูประวัติการสนับสนุน TLS/SSL ของเว็บเบราว์เซอร์) #iii มีการพยายามบ่อนทำลายแง่มุมด้านความปลอดภัยในการสื่อสารที่ TLS มุ่งหวังจะมอบให้
ความปลอดภัยของเลเยอร์การขนส่งดาต้าแกรม และโปรโตคอลนี้ได้รับการแก้ไขหลายครั้งเพื่อจัดการกับภัยคุกคามด้านความปลอดภัยเหล่านี้
นักพัฒนาเว็บเบราว์เซอร์ได้ปรับปรุงผลิตภัณฑ์ของตนซ้ำแล้วซ้ำเล่าเพื่อป้องกันจุดอ่อนด้านความปลอดภัยที่อาจเกิดขึ้นหลังจากค้นพบจุดอ่อนเหล่านี้
(ดูประวัติการสนับสนุน TLS/SSL ของเว็บเบราว์เซอร์) ความปลอดภัยของเลเยอร์การขนส่งดาต้าแกรม
#i Datagram Transport Layer Security หรือเรียกย่อๆ ว่า DTLS เป็นโปรโตคอลการสื่อสาร ที่เกี่ยวข้องซึ่งให้ความปลอดภัยแก่ แอปพลิเคชันที่ใช้ Datagram โดยอนุญาตให้แอปพลิเคชันสื่อสารในลักษณะที่ออกแบบมาเพื่อป้องกันการดักฟัง การปลอมแปลงหรือการปลอมแปลงข้อความโปรโตคอล DTLS ใช้ โปรโตคอล Transport Layer Security (TLS) ที่เน้น การสตรีมและมีจุดประสงค์เพื่อให้การรับประกันความปลอดภัยที่คล้ายคลึงกัน อย่างไรก็ตาม โปรโตคอลนี้แตกต่างจาก TLS ตรงที่สามารถใช้งานร่วมกับโปรโตคอลที่เน้น Datagram ส่วนใหญ่ ได้แก่ User Datagram Protocol (UDP), Datagram Congestion Control Protocol (DCCP), Control And Provisioning of Wireless Access Points (CAPWAP), Stream Control Transmission Protocol (SCTP) encapsulation และ Secure Real-time Transport Protocol (SRTP) #iii Datagram Transport Layer Security หรือเรียกย่อๆ ว่า DTLS เป็นโปรโตคอลการสื่อสาร
ที่เกี่ยวข้องซึ่งให้ความปลอดภัยแก่ แอปพลิเคชันที่ใช้ Datagram
โดยอนุญาตให้แอปพลิเคชันสื่อสารในลักษณะที่ออกแบบมาเพื่อป้องกันการดักฟัง
การปลอมแปลงหรือการปลอมแปลงข้อความโปรโตคอล DTLS ใช้ โปรโตคอล Transport Layer
Security (TLS) ที่เน้น การสตรีมและมีจุดประสงค์เพื่อให้การรับประกันความปลอดภัยที่คล้ายคลึงกัน
อย่างไรก็ตาม โปรโตคอลนี้แตกต่างจาก TLS ตรงที่สามารถใช้งานร่วมกับโปรโตคอลที่เน้น Datagram
ส่วนใหญ่ ได้แก่ User Datagram Protocol (UDP), Datagram Congestion Control Protocol
(DCCP), Control And Provisioning of Wireless Access Points (CAPWAP), Stream
Control Transmission Protocol (SCTP) encapsulation และ Secure Real-time
Transport Protocol (SRTP)
#i เนื่องจากเดตาแกรมของโปรโตคอล DTLS รักษาความหมายของการขนส่งพื้นฐานไว้ แอปพลิเคชันจึงไม่ประสบปัญหาความล่าช้าที่เกี่ยวข้องกับโปรโตคอลสตรีม อย่างไรก็ตาม แอปพลิเคชันต้องจัดการกับการเรียงลำดับแพ็กเก็ตใหม่ การสูญหายของเดตาแกรม และข้อมูลที่มีขนาดใหญ่กว่าขนาดของแพ็กเก็ตเครือข่าย เดตาแกรม เนื่องจาก DTLS ใช้ UDP หรือ SCTP แทน TCP จึงหลีกเลี่ยงปัญหา TCP ล่มเมื่อนำไปใช้สร้างอุโมงค์ VPN #iii เนื่องจากเดตาแกรมของโปรโตคอล DTLS รักษาความหมายของการขนส่งพื้นฐานไว้
แอปพลิเคชันจึงไม่ประสบปัญหาความล่าช้าที่เกี่ยวข้องกับโปรโตคอลสตรีม อย่างไรก็ตาม
แอปพลิเคชันต้องจัดการกับการเรียงลำดับแพ็กเก็ตใหม่ การสูญหายของเดตาแกรม
และข้อมูลที่มีขนาดใหญ่กว่าขนาดของแพ็กเก็ตเครือข่าย เดตาแกรม เนื่องจาก DTLS ใช้ UDP หรือ SCTP
แทน TCP จึงหลีกเลี่ยงปัญหา TCP ล่มเมื่อนำไปใช้สร้างอุโมงค์ VPN
#i DTLS เวอร์ชัน 1.0 ฉบับดั้งเดิมในปี 2006 ไม่ใช่เอกสารแบบสแตนด์อโลน แต่ได้รับการกำหนดให้เป็นชุดเดลต้าของ TLS 1.1 ทำนองเดียวกัน DTLS เวอร์ชัน 2012 ที่ตามมาก็ถูกกำหนดให้เป็นเดลต้าของ TLS 1.2 โดยได้รับหมายเลขเวอร์ชันของ DTLS 1.2 เพื่อให้ตรงกับเวอร์ชัน TLS สุดท้าย DTLS 1.3 ปี 2022 ก็ถูกกำหนดให้เป็นเดลต้าของ TLS 1.3 เช่นเดียวกับสองเวอร์ชันก่อนหน้า DTLS 1.3 มีวัตถุประสงค์เพื่อให้ "การรับประกันความปลอดภัยที่เทียบเท่า [กับ TLS 1.3] ยกเว้นการป้องกันคำสั่ง/การไม่สามารถเล่นซ้ำได้" #iii DTLS เวอร์ชัน 1.0 ฉบับดั้งเดิมในปี 2006 ไม่ใช่เอกสารแบบสแตนด์อโลน
แต่ได้รับการกำหนดให้เป็นชุดเดลต้าของ TLS 1.1 ทำนองเดียวกัน DTLS เวอร์ชัน 2012
ที่ตามมาก็ถูกกำหนดให้เป็นเดลต้าของ TLS 1.2 โดยได้รับหมายเลขเวอร์ชันของ DTLS 1.2
เพื่อให้ตรงกับเวอร์ชัน TLS สุดท้าย DTLS 1.3 ปี 2022 ก็ถูกกำหนดให้เป็นเดลต้าของ TLS 1.3
เช่นเดียวกับสองเวอร์ชันก่อนหน้า DTLS 1.3 มีวัตถุประสงค์เพื่อให้ "การรับประกันความปลอดภัยที่เทียบเท่า
[กับ TLS 1.3] ยกเว้นการป้องกันคำสั่ง/การไม่สามารถเล่นซ้ำได้"
#i ไคลเอนต์ VPN จำนวนมากรวมถึง Cisco AnyConnect & InterCloud Fabric, OpenConnect, อุโมงค์ ZScaler, F5 Networks Edge VPN Client และ Citrix Systems NetScaler ใช้ DTLS เพื่อรักษาความปลอดภัยการรับส่งข้อมูล UDP นอกจากนี้ เว็บเบราว์เซอร์สมัยใหม่ทั้งหมดยังรองรับ DTLS-SRTP สำหรับ WebRTC #iii ไคลเอนต์ VPN จำนวนมากรวมถึง Cisco AnyConnect & InterCloud Fabric,
OpenConnect, อุโมงค์ ZScaler, F5 Networks Edge VPN Client และ Citrix Systems
NetScaler ใช้ DTLS เพื่อรักษาความปลอดภัยการรับส่งข้อมูล UDP นอกจากนี้
เว็บเบราว์เซอร์สมัยใหม่ทั้งหมดยังรองรับ DTLS-SRTP สำหรับ WebRTC
#include "X509.typ" #include "X509.typ"
#include "x690.typ" #include "x690.typ"
Chapter2/X509.typ
+11 -11
View File
@@ -2,7 +2,7 @@
== X.509 (รูปแบบใบรับรอง TLS/SSL) <x509> == X.509 (รูปแบบใบรับรอง TLS/SSL) <x509>
#i ในการเข้ารหัส X.509 เป็นมาตรฐานของสหภาพโทรคมนาคมระหว่างประเทศ (ITU) #iii ในการเข้ารหัส X.509 เป็นมาตรฐานของสหภาพโทรคมนาคมระหว่างประเทศ (ITU)
ที่กำหนดรูปแบบของใบรับรองคีย์สาธารณะใบรับรอง X.509 ถูกใช้ในโปรโตคอลอินเทอร์เน็ตมากมายรวมถึง ที่กำหนดรูปแบบของใบรับรองคีย์สาธารณะใบรับรอง X.509 ถูกใช้ในโปรโตคอลอินเทอร์เน็ตมากมายรวมถึง
TLS/SSL ซึ่งเป็นพื้นฐานของ HTTPS โปรโตคอลที่ปลอดภัยสำหรับการท่องเว็บ TLS/SSL ซึ่งเป็นพื้นฐานของ HTTPS โปรโตคอลที่ปลอดภัยสำหรับการท่องเว็บ
นอกจากนี้ยังใช้ในแอปพลิเคชันออฟไลน์เช่น ลาย เซ็นอิเล็กทรอนิกส์ ใบรับรอง X.509 นอกจากนี้ยังใช้ในแอปพลิเคชันออฟไลน์เช่น ลาย เซ็นอิเล็กทรอนิกส์ ใบรับรอง X.509
@@ -13,17 +13,17 @@ TLS/SSL ซึ่งเป็นพื้นฐานของ HTTPS โปร
ผู้ถือใบรับรองนั้นสามารถใช้คีย์สาธารณะที่มีอยู่เพื่อสร้างการสื่อสารที่ปลอดภัยกับบุคคลอื่น ผู้ถือใบรับรองนั้นสามารถใช้คีย์สาธารณะที่มีอยู่เพื่อสร้างการสื่อสารที่ปลอดภัยกับบุคคลอื่น
หรือตรวจสอบความถูกต้องของเอกสารที่ลงนามดิจิทัลด้วย คีย์ส่วนตัวที่เกี่ยวข้องได้ หรือตรวจสอบความถูกต้องของเอกสารที่ลงนามดิจิทัลด้วย คีย์ส่วนตัวที่เกี่ยวข้องได้
#i X.509 #iii X.509
ยังกำหนดรายการเพิกถอนใบรับรองซึ่งเป็นวิธีการแจกจ่ายข้อมูลเกี่ยวกับใบรับรองที่ถือว่าไม่ถูกต้องโดยผู้มีอำนาจลงนาม ยังกำหนดรายการเพิกถอนใบรับรองซึ่งเป็นวิธีการแจกจ่ายข้อมูลเกี่ยวกับใบรับรองที่ถือว่าไม่ถูกต้องโดยผู้มีอำนาจลงนาม
ตลอดจนอัลกอริทึมการตรวจสอบเส้นทางการรับรองซึ่งช่วยให้ใบรับรองได้รับการลงนามโดยใบรับรอง CA ตลอดจนอัลกอริทึมการตรวจสอบเส้นทางการรับรองซึ่งช่วยให้ใบรับรองได้รับการลงนามโดยใบรับรอง CA
ตัวกลาง ซึ่งใบรับรองเหล่านี้จะได้รับการลงนามโดยใบรับรองอื่นๆ ต่อไปจนไปถึงจุดยึดที่เชื่อถือได้ในที่สุด ตัวกลาง ซึ่งใบรับรองเหล่านี้จะได้รับการลงนามโดยใบรับรองอื่นๆ ต่อไปจนไปถึงจุดยึดที่เชื่อถือได้ในที่สุด
#i X.509 ถูกกำหนดโดย "Standardization Sector" ของ ITU (SG17 ของ ITU-T) ใน ITU-T #iii X.509 ถูกกำหนดโดย "Standardization Sector" ของ ITU (SG17 ของ ITU-T) ใน ITU-T
Study Group 17 และมีพื้นฐานมาจาก Abstract Syntax Notation One (ASN.1) Study Group 17 และมีพื้นฐานมาจาก Abstract Syntax Notation One (ASN.1)
ซึ่งเป็นมาตรฐานอีกประการหนึ่งของ ITU-T ซึ่งเป็นมาตรฐานอีกประการหนึ่งของ ITU-T
=== โครงสร้างของใบรับรอง === โครงสร้างของใบรับรอง
#i โครงสร้างที่กำหนดไว้โดยมาตรฐานจะแสดงอยู่ในภาษาทางการที่เรียกว่า Abstract Syntax #iiii โครงสร้างที่กำหนดไว้โดยมาตรฐานจะแสดงอยู่ในภาษาทางการที่เรียกว่า Abstract Syntax
Notation One (ASN.1) Notation One (ASN.1)
โครงสร้างของใบรับรองดิจิทัล X.509 v3 มีดังนี้: โครงสร้างของใบรับรองดิจิทัล X.509 v3 มีดังนี้:
@@ -45,34 +45,34 @@ Notation One (ASN.1)
- อัลกอริทึมลายเซ็นใบรับรอง - อัลกอริทึมลายเซ็นใบรับรอง
- ลายเซ็นใบรับรอง - ลายเซ็นใบรับรอง
#i ฟิลด์ส่วนขยาย (ถ้ามี) จะเป็นลำดับของส่วนขยายใบรับรองอย่างน้อยหนึ่งรายการ #iiii ฟิลด์ส่วนขยาย (ถ้ามี) จะเป็นลำดับของส่วนขยายใบรับรองอย่างน้อยหนึ่งรายการ
แต่ละส่วนขยายมีรหัสประจำตัวเฉพาะของตัวเอง ซึ่งแสดงเป็นตัวระบุวัตถุ (OID) แต่ละส่วนขยายมีรหัสประจำตัวเฉพาะของตัวเอง ซึ่งแสดงเป็นตัวระบุวัตถุ (OID)
ซึ่งเป็นชุดค่าพร้อมกับข้อบ่งชี้ที่สำคัญหรือไม่สำคัญ ซึ่งเป็นชุดค่าพร้อมกับข้อบ่งชี้ที่สำคัญหรือไม่สำคัญ
ระบบที่ใช้ใบรับรองต้องปฏิเสธใบรับรองหากพบส่วนขยายที่สำคัญที่ไม่รู้จักหรือส่วนขยายที่สำคัญซึ่งมีข้อมูลที่ไม่สามารถประมวลผลได้ ระบบที่ใช้ใบรับรองต้องปฏิเสธใบรับรองหากพบส่วนขยายที่สำคัญที่ไม่รู้จักหรือส่วนขยายที่สำคัญซึ่งมีข้อมูลที่ไม่สามารถประมวลผลได้
ส่วนขยายที่ไม่สำคัญอาจถูกละเว้นหากไม่รู้จัก แต่จะต้องได้รับการประมวลผลหากรู้จักส่วนขยายใบรับรอง ส่วนขยายที่ไม่สำคัญอาจถูกละเว้นหากไม่รู้จัก แต่จะต้องได้รับการประมวลผลหากรู้จักส่วนขยายใบรับรอง
#i โครงสร้างของเวอร์ชัน 1 มีอยู่ ใน RFC 1422 #iiii โครงสร้างของเวอร์ชัน 1 มีอยู่ ใน RFC 1422
#i รูปแบบภายในของตัวระบุเฉพาะของผู้เผยแพร่และเรื่องที่ระบุไว้ใน X.520 ไดเร็กทอรี:คำแนะนำ #iiii รูปแบบภายในของตัวระบุเฉพาะของผู้เผยแพร่และเรื่องที่ระบุไว้ใน X.520 ไดเร็กทอรี:คำแนะนำ
ประเภทแอตทริบิวต์ที่เลือก ประเภทแอตทริบิวต์ที่เลือก
#i ITU-T ได้นำตัวระบุเฉพาะของผู้ออกหลักทรัพย์และบุคคลมาใช้ในเวอร์ชัน 2 #iiii ITU-T ได้นำตัวระบุเฉพาะของผู้ออกหลักทรัพย์และบุคคลมาใช้ในเวอร์ชัน 2
เพื่ออนุญาตให้นำชื่อผู้ออกหลักทรัพย์หรือบุคคลมาใช้ซ้ำได้หลังจากระยะเวลาหนึ่ง เพื่ออนุญาตให้นำชื่อผู้ออกหลักทรัพย์หรือบุคคลมาใช้ซ้ำได้หลังจากระยะเวลาหนึ่ง
ตัวอย่างหนึ่งของการนำกลับมาใช้ซ้ำคือเมื่อ CA ล้มละลายและชื่อถูกลบออกจากรายชื่อสาธารณะของประเทศ ตัวอย่างหนึ่งของการนำกลับมาใช้ซ้ำคือเมื่อ CA ล้มละลายและชื่อถูกลบออกจากรายชื่อสาธารณะของประเทศ
หลังจากนั้น CA อื่นที่มีชื่อเดียวกันอาจลงทะเบียนตัวเองได้ แม้ว่าจะไม่เกี่ยวข้องกับ CA แรกก็ตาม หลังจากนั้น CA อื่นที่มีชื่อเดียวกันอาจลงทะเบียนตัวเองได้ แม้ว่าจะไม่เกี่ยวข้องกับ CA แรกก็ตาม
อย่างไรก็ตาม IETF แนะนำว่าไม่ควรนำชื่อผู้ออกหลักทรัพย์และบุคคลมาใช้ซ้ำ ดังนั้นเวอร์ชัน 2 อย่างไรก็ตาม IETF แนะนำว่าไม่ควรนำชื่อผู้ออกหลักทรัพย์และบุคคลมาใช้ซ้ำ ดังนั้นเวอร์ชัน 2
จึงยังไม่แพร่หลายในอินเทอร์เน็ต จึงยังไม่แพร่หลายในอินเทอร์เน็ต
#i ส่วนขยายได้รับการแนะนำในเวอร์ชัน 3 CA #iiii ส่วนขยายได้รับการแนะนำในเวอร์ชัน 3 CA
สามารถใช้ส่วนขยายเพื่อออกใบรับรองได้เฉพาะสำหรับจุดประสงค์เฉพาะ (เช่น สามารถใช้ส่วนขยายเพื่อออกใบรับรองได้เฉพาะสำหรับจุดประสงค์เฉพาะ (เช่น
สำหรับการลงนามในวัตถุดิจิทัล เท่านั้น) สำหรับการลงนามในวัตถุดิจิทัล เท่านั้น)
#i ในทุกเวอร์ชันหมายเลขซีเรียลจะต้องไม่ซ้ำกันสำหรับใบรับรองแต่ละใบที่ออกโดย CA เฉพาะ #iiii ในทุกเวอร์ชันหมายเลขซีเรียลจะต้องไม่ซ้ำกันสำหรับใบรับรองแต่ละใบที่ออกโดย CA เฉพาะ
(ดังที่กล่าวถึงใน RFC 5280) (ดังที่กล่าวถึงใน RFC 5280)
=== นามสกุลไฟล์ใบรับรอง === นามสกุลไฟล์ใบรับรอง
#iiii นามสกุลไฟล์ที่ใช้กันทั่วไปสำหรับใบรับรอง X.509 #iiii นามสกุลไฟล์ที่ใช้กันทั่วไปสำหรับใบรับรอง X.509
มีหลายประเภทนามสกุลไฟล์เหล่านี้ยังใช้สำหรับข้อมูลอื่นๆ เช่น คีย์ส่วนตัวด้วย มีหลายประเภทนามสกุลไฟล์เหล่านี้ยังใช้สำหรับข้อมูลอื่น ๆ เช่น คีย์ส่วนตัวด้วย
- `.pem` -- (อีเมลอิเล็กทรอนิกส์ที่เพิ่มความเป็นส่วนตัว) ใบรับรอง DER ที่เข้ารหัส Base64 - `.pem` -- (อีเมลอิเล็กทรอนิกส์ที่เพิ่มความเป็นส่วนตัว) ใบรับรอง DER ที่เข้ารหัส Base64
แนบระหว่าง `-----BEGIN CERTIFICATE-----` และ `-----END CERTIFICATE-----` แนบระหว่าง `-----BEGIN CERTIFICATE-----` และ `-----END CERTIFICATE-----`
Chapter2/x690.typ
+17 -5
View File
@@ -1,19 +1,31 @@
#import "../PageTemplate.typ": i #import "../PageTemplate.typ": *
#set heading(numbering: "1.1", offset: 2) #set heading(numbering: "1.1", offset: 2)
= X.690 (การเข้ารหัส DER) = X.690 (การเข้ารหัส DER)
X.690 เป็น มาตรฐาน ITU-T ที่ระบุรูปแบบการเข้ารหัส ASN.1 หลายรูปแบบ: #iii X.690 เป็น มาตรฐาน ITU-T ที่ระบุรูปแบบการเข้ารหัส ASN.1 หลายรูปแบบ:
- กฎการเข้ารหัสพื้นฐาน (BER) - กฎการเข้ารหัสพื้นฐาน (BER)
- กฎการเข้ารหัสแบบ Canonical (CER) - กฎการเข้ารหัสแบบ Canonical (CER)
- กฎการเข้ารหัสที่โดดเด่น (DER) - กฎการเข้ารหัสที่โดดเด่น (DER)
กฎการเข้ารหัสพื้นฐาน (BER) คือกฎดั้งเดิมที่วางไว้โดยมาตรฐาน ASN.1 สำหรับการเข้ารหัสข้อมูลในรูปแบบไบนารี กฎเหล่านี้ ซึ่งเรียกรวมกันว่าไวยากรณ์การถ่ายโอนในภาษา ASN.1 กำหนดจำนวนอ็อกเท็ต (ไบต์ 8 บิต) ที่ใช้ในการเข้ารหัสข้อมูล กฎการเข้ารหัสพื้นฐาน (BER) คือกฎดั้งเดิมที่วางไว้โดยมาตรฐาน ASN.1
สำหรับการเข้ารหัสข้อมูลในรูปแบบไบนารี กฎเหล่านี้ ซึ่งเรียกรวมกันว่าไวยากรณ์การถ่ายโอนในภาษา ASN.1
กำหนดจำนวนอ็อกเท็ต (ไบต์ 8 บิต) ที่ใช้ในการเข้ารหัสข้อมูล
#i โดยโครงงานนี้ใช้ใบรับรองในรูปแบบการเข้ารหัส DER ซึ่ง DER (Distinguished Encoding Rules) เป็น BER แบบจำกัดรูปแบบหนึ่งสำหรับการสร้างไวยากรณ์การถ่ายโอนข้อมูลที่ชัดเจนสำหรับโครงสร้างข้อมูลที่อธิบายโดย ASN.1 เช่นเดียวกับ CER การเข้ารหัส DER ถือเป็นการเข้ารหัส BER ที่ถูกต้อง DER เหมือนกับ BER โดยตัดตัวเลือกของผู้ส่งออกทั้งหมด ยกเว้นตัวเลือกเดียว #iii โดยโครงงานนี้ใช้ใบรับรองในรูปแบบการเข้ารหัส DER ซึ่ง DER (Distinguished Encoding
Rules) เป็น BER
แบบจำกัดรูปแบบหนึ่งสำหรับการสร้างไวยากรณ์การถ่ายโอนข้อมูลที่ชัดเจนสำหรับโครงสร้างข้อมูลที่อธิบายโดย
ASN.1 เช่นเดียวกับ CER การเข้ารหัส DER ถือเป็นการเข้ารหัส BER ที่ถูกต้อง DER เหมือนกับ BER
โดยตัดตัวเลือกของผู้ส่งออกทั้งหมด ยกเว้นตัวเลือกเดียว
DER เป็นส่วนย่อยของ BER ที่ให้วิธีการเข้ารหัสค่า ASN.1 เพียงวิธีเดียว DER มีไว้สำหรับสถานการณ์ที่จำเป็นต้องมีการเข้ารหัสเฉพาะ เช่น ในการเข้ารหัสลับและช่วยให้มั่นใจว่าโครงสร้างข้อมูลที่จำเป็นต้องมีการลงนามดิจิทัลจะสร้างการแสดงแบบอนุกรมที่ไม่ซ้ำกัน DER ถือเป็นรูปแบบมาตรฐานของ BER ตัวอย่างเช่นใน BER ค่าบูลีน true สามารถเข้ารหัสเป็นค่าไบต์ที่ไม่ใช่ศูนย์ 255 ค่า ในขณะที่ DER มีวิธีการเข้ารหัสค่าบูลีน true เพียงวิธีเดียว #iii DER เป็นส่วนย่อยของ BER ที่ให้วิธีการเข้ารหัสค่า ASN.1 เพียงวิธีเดียว DER
มีไว้สำหรับสถานการณ์ที่จำเป็นต้องมีการเข้ารหัสเฉพาะ เช่น
ในการเข้ารหัสลับและช่วยให้มั่นใจว่าโครงสร้างข้อมูลที่จำเป็นต้องมีการลงนามดิจิทัลจะสร้างการแสดงแบบอนุกรมที่ไม่ซ้ำกัน
DER ถือเป็นรูปแบบมาตรฐานของ BER ตัวอย่างเช่นใน BER ค่าบูลีน true
สามารถเข้ารหัสเป็นค่าไบต์ที่ไม่ใช่ศูนย์ 255 ค่า ในขณะที่ DER มีวิธีการเข้ารหัสค่าบูลีน true เพียงวิธีเดียว
#pagebreak()
ข้อจำกัดการเข้ารหัส DER ที่สำคัญที่สุดคือ: ข้อจำกัดการเข้ารหัส DER ที่สำคัญที่สุดคือ:
Chapter3.typ
-436
View File
@@ -1,436 +0,0 @@
#import "PageTemplate.typ": *
#import "@preview/fletcher:0.5.8" as fletcher: diagram, edge, node
#import fletcher.shapes: circle, diamond, pill
#show: chapter-page
#set heading(numbering: "บทที่ 1")
#heading([#linebreak()วิธีการดำเนินโครงงาน])
#set heading(numbering: "1.1")
#i ในการดำเนินการศึกษาครั้งนี้
คณะผู้จัดทำโครงงานได้ศึกษาข้อมูลเบื้องต้นในการสร้างเครื่องยืนยันตัวตนด้วย NFC
และได้ดำเนินการตามขั้นตอนนี้
+ วางแผนการดำเนินงาน
+ การออกแบบ
+ วัสดุอุปกรณ์
+ ขั้นตอนการประกอบ
+ การทดลอง
+ การวิเคราะห์ข้อมูล
== วางแผนการดำเนินงาน
#show table.cell.where(y: 1): strong
#set par(leading: 0.5em)
#let arrow = [
#place(
left + horizon,
text(weight: "bold", size: 14pt)[#sym.arrow.l],
dx: -5pt,
dy: -0.7pt,
)
#place(
horizon,
line(length: 100%, stroke: (thickness: 1pt)),
dx: 0pt,
dy: 0pt,
)
#place(
right + horizon,
text(weight: "bold", size: 14pt)[#sym.arrow.r],
dx: 5pt,
dy: -0.7pt,
)
]
=== แผนขั้นตอนและวิธีการดำเนินงาน
#table(
columns: 12,
align: (
left + horizon,
center,
center,
center,
center,
center,
center,
center,
center,
center,
center,
center,
),
table.header(
table.cell(
[ขั้นตอนการ\ ดำเนินการ],
rowspan: 2,
),
table.cell(
[พ.ศ.2568],
colspan: 3,
),
table.cell(
[พ.ศ.2569],
colspan: 8,
),
[ต.ค.],
[พ.ย.],
[ธ.ค.],
[ม.ค.],
[ก.พ.],
[มี.ค],
[เม.ย],
[พ.ค.],
[มิ.ย.],
[ก.ค.],
[ส.ค.],
),
[ศึกษาค้นคว้าข้อมูล],
table.cell(arrow, colspan: 3),
[],
[],
[],
[],
[],
[],
[],
[],
[เสนอหัวข้อ], arrow, [], [], [], [], [], [], [], [], [], [],
[เสนอครั้งที่ 1], [], arrow, [], [], [], [], [], [], [], [], [],
[ออกแบบและสร้าง], [], table.cell(arrow, colspan: 5), [], [], [], [], [],
[จัดซื้ออุปกรณ์ทดลอง],
[],
table.cell(arrow, colspan: 3),
[],
[],
[],
[],
[],
[],
[],
[ทดลองการทำงาน], [], [], table.cell(arrow, colspan: 4), [], [], [], [], [],
[ปรับปรุงแก้ไข], [], [], [], [], table.cell(arrow, colspan: 5), [], [],
[เสนอครั้งที่ 2], [], [], [], arrow, [], [], [], [], [], [], [],
[จัดทำรูปเล่ม], table.cell(arrow, colspan: 11),
[นำเสนอโครงงาน], [], [], [], [], [], [], [], [], [], [], [],
)
#show: page-theme
=== ผังการดำเนินงาน
#diagram(
node-stroke: 1pt,
spacing: 2em,
node((0, 0), [เริ่มต้น], shape: pill),
edge("-|>"),
node((0, 1), shape: circle, radius: 1em),
edge("-|>"),
node((0, 2), [ศึกษาข้อมูลและทฤษฏีที่เกี่ยวข้อง], width: 2.5in),
edge("-|>"),
node((0, 3), [ออกแบบและวางแผนการดําเนินงาน], width: 2.5in),
edge("-|>"),
node((0, 4), [เครื่องยืนยันตัวตนด้วย NFC], width: 2.5in),
edge("-|>"),
node((0, 5), [ทดสอบประสิทธิภาพ], shape: diamond),
edge("r,u,u,u,u,l", "-|>", [ไม่ผ่าน]),
edge("-|>", [ผ่าน]),
node((0, 6), [จัดทำเอกสาร], width: 2.5in),
edge("-|>"),
node((0, 7), [นำเสนอ], width: 2.5in),
edge("-|>"),
node((0, 8), [สิ้นสุด], shape: pill),
)
#pagebreak()
=== ผังการทำงาน
#diagram(
node-stroke: 1pt,
spacing: 2em,
node([เริ่มต้น], shape: pill),
edge("-|>"),
node((1, 0), [ตั้งค่า LittleFS]),
edge("-|>"),
node((1, 2), [มี Wi-Fi บันทึก\ ไว้อยู่หรือไม่], shape: diamond),
edge("l", "-|>", [ไม่มี]),
edge((1, 2), (1, 3), "-|>", [มี]),
node((0, 2), [รอรับรายละเอียดเครือข่าย\ (ESP-Touch)]),
edge("d,r", "-|>"),
node((1, 3), [เชื่อมต่อเครือข่าย]),
edge("-|>"),
node((0, 4), [มีอุปกรณ์ควบคุม\ หลักแล้วหรือไม่], shape: diamond),
edge("-|>", [ไม่มี]),
edge("d", "-|>", [มี]),
node((1, 4), [สร้างโทเค็นสำหรับการยืนยัน\ อุปกรณ์ควบคุมหลัก]),
edge("-|>"),
node((1, 5), [รออุปกรณ์ควบคุมหลัก\ แตะเซนเซอร์ NFC]),
edge("-|>"),
node((0, 5), [ตั้งค่าเซิร์ฟเวอร์ HTTPS]),
edge("-|>"),
node((0, 6), shape: circle, radius: 1em),
edge("-|>"),
node((0, 7), [มีการแตะเซนเซอร์\ NFC ขาเข้าหรือไม่], shape: diamond),
edge("-|>", [ไม่มี]),
node((0, 9), [มีคนผ่านเซนเซอร์ PIR\ โดยไม่ได้รับอนุญาตหรือไม่], shape: diamond),
edge((0, 9), (0, 10), [ไม่มี]),
edge((0, 7), (1, 6), "-|>", [มี]),
node((1, 6), [อยู่ในโหมดลงทะเบียน\ หรือไม่], shape: diamond),
edge("-|>", [ใช่]),
edge((1, 6), (2, 7), [ไม่]),
node((1, 7), [นำ ID อุปกรณ์เข้า\ สู่รายการทะเบียน]),
edge((1, 7), (0.6, 7), (0, 9), "-|>"),
node((2, 7), [ID ของอุปกรณ์อยู่\ ในทะเบียนหรือไม่], shape: diamond),
edge("-|>", [อยู่]),
edge((2, 7), (1, 8), "-|>", [ไม่อยู่], label-sep: -5pt),
node((2, 8), [ส่งเสียงคอนเฟิร์ม]),
edge((2, 8), (2, 8.5), (0.4, 8.5), (0, 9), "-|>"),
node((1, 8), [ส่งเสียงแสดงความผิดพลาด]),
edge((1, 8), (0.5, 8), (0, 9), "-|>"),
node((1, 9), [แจ้งเตือนทางเสียง\ และแอพลิเคชัน]),
edge((1, 9), (0, 10), "-|>"),
edge((0, 10), (1, 10), "-|>", [มี]),
node((0, 10), [มีคำขอ HTTPS\ ใหม่หรือไม่], shape: diamond),
edge((0, 10), (-2, 10), "-|>", [ไม่มี], label-pos: 10%),
edge((0, 9), (1, 9), "-|>", [มี], label-anchor: "center", label-sep: -8pt),
node((1, 10), [ประมวลผลคำขอ HTTPS]),
edge((1, 10), (1, 11), (-2, 11), (-2, 10), "-|>"),
node((-2, 10), shape: circle, radius: 1em),
edge((-2, 10), (-2, 6), (0, 6), "-|>"),
)
#pagebreak()
#set par(leading: 1em)
== การออกแบบ
== วัสดุอุปกรณ์
+ บอร์ด ESP32 (NodeMCU)
+ กล่องพลาสติก
+ Buzzer
+ เซนเซอร์ PIR
+ เซนเซอร์ NFC 2 ชิ้น
== ขั้นตอนการประกอบ
โครงงานแบ่งออกเป็น 3 โมดูล
+ โมดูลเซนเซอร์ NFC ขาเข้าและบอร์ด ESP32
+ โมดูลเซนเซอร์ NFC ขาออก
+ โมดูลเซนเซอร์ PIR
#show heading: it => {
if it.level > 2 {
block(
it,
inset: (left: -3em),
)
} else {
it
}
}
=== โมดูลเซนเซอร์ NFC ขาออก
#i ดำเนินการเจาะรูบริเวณตัวกล่องเพื่อใช้เป็นช่องสำหรับสายไฟ
จากนั้นนำสายไฟร้อยผ่านช่องดังกล่าวและต่อเข้ากับเซนเซอร์ NFC ให้เรียบร้อยตามขั้นตอน
=== การติดตั้งอุปกรณ์
=== การเขียนเฟิร์มแวร์
#i โครงงานนี้ใช้ซอฟต์แวร์ PlatformIO ในการสร้างและจัดการโปรเจกต์เฟิร์มแวร์
โดยหากต้องการเพียงแค่เขียนเฟิร์มแวร์ลงไปยังบอร์ด ESP32 คุณจำเป็นต้องใช้ซอฟต์แวร์หลัก ๆ คือ
PlatformIO Core และ Git (ไม่จำเป็น แต่เพื่อความสะดวกสบาย) อย่างไรก็ตาม PlatformIO
จำเป็นต้องใช้ Python เวอร์ชัน 3.6 ขึ้นไปด้วยเช่นกัน ดังนั้นคุณจำเป็นต้องติดตั้ง Python
ด้วยหากคุณยังไม่มี
#i ในขั้นตอนแรก โปรดเปิดเทอร์มินัลของคุณ ซึ่งโดยทั่วไปแล้วคุณสามารถค้นหาแอพลิเคชัน#jb "Terminal"
ได้เลย โดยบน Windows 10 เวอร์ชั่นใหม่ ๆ และ Windows 11 จะมาพร้อมกับแอพลิเคชัน Windows
Terminal อย่างไรก็ตาม เมื่อเปิดแล้ว โปรดตรวจสอบให้แน่ใจว่าคุณกำลังใช้ PowerShell และไม่ใช่
Command Prompt
#i โดยในปัจจุบัน Python เวอร์ชันล่าสุดคือ Python 3.14.2 โดยคุณสามารถติดตั้ง Python และ Git
บน Windows ได้ด้วยการใช้คำสั่งต่อไปนี้
```sh
winget install Python.Python.3.14 Git.Git -e -s winget
```
#i สำหรับระบบปฏิบัติการอื่นนั้น โดยปกติแล้วจะไม่ต้องติดตั้ง Python
เพิ่มเนื่องจากมีติดมากับระบบปฏิบัติการอยู่แล้ว อย่างไรก็ตาม บน Linux อาจต้องมีการติดตั้งการรองรับ
Virtual Environment แยก โดยแต่ละระบบจะมีชื่อแพคเกจไม่เหมือนกัน โดยบน Debian, Fedora,
และ Arch สามารถใช้คำสั่งต่อไปนี้ในการติดตั้งทั้ง Python Virtual Environment และ Git
พร้อมกันได้
#pagebreak()
```sh
# Debian
sudo apt install python3-venv git
# Fedora
sudo dnf install python3-virtualenv git
# Arch
sudo pacman -S python-virtualenv git
```
#show raw.where(block: true): set block(below: 2em)
==== การติดตั้ง PlatformIO Core ผ่านแพคเกจ
#i หากคุณใช้ Fedora Linux หรือ Arch Linux (หรือลูก ๆ ของมัน) คุณสามารถติดตั้งแพคเกจ
PlatformIO ได้โดยตรง โดยมีคำสั่งดังนี้:
```sh
# Fedora Linux
sudo dnf install platformio
# Arch Linux
sudo pacman -S platformio-core
```
- หากคุณติดตั้งแพคเกจ Fedora นั้นแล้ว คุณไม่จำเป็นที่จะต้องติดตั้งกฎ udev ด้วยตนเอง
(ที่จะถูกกล่าวถึงใน@pioudev)
- หากคุณใช้ Arch คุณสามารถติดตั้งแพคเกจกฎ udev ได้โดยตรงโดยไม่ต้องดาวน์โหลดเอง
```sh
sudo pacman -S --asdeps platformio-core-udev
```
==== การติดตั้ง PlatformIO Core ผ่านสคริปต์
#i ถัดไป ในการติดตั้ง PlatformIO Core สามารถทำได้โดยการใช้สคริปต์ติดตั้ง โดยสำหรับ `curl`
สามารถใช้คำสั่งนี้ได้:
```sh
curl -fsSL -o get-platformio.py https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py
```
หรือหากต้องการใช้ `wget`:
```sh
wget -O get-platformio.py https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py
```
หรือสำหรับ PowerShell, สามารถใช้ `iwr` (หรือชื่อเต็มคือ `Invoke-WebRequest`) ได้:
```sh
iwr -OutFile get-platformio.py -Uri https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py
```
(มีการเว้นบรรทัดใหม่เนื่องจากพื้นที่ไม่เพียงพอ โปรดอย่าเว้นบรรทัดเมื่อพิมพ์คำสั่งจริง)
#i แล้วดังนั้นจึงใช้คำสั่ง `python3 get-platformio.py`
ในการรันสคริปต์ติดตั้งที่ได้ทำการดาวน์โหลดมา โดยค่าเริ่มต้นแล้ว PlatformIO
จะไม่เพิ่มตนเองเข้าไปยังตัวแปรสิ่งแวดล้อม PATH
ซึ่งจำเป็นในการใช้คำสั่งจากที่ใหนก็ได้โดยไม่ต้องกล่าวถึงไฟล์พาธ
#pagebreak()
#i โดยสำหรับ Linux แล้วนั้น คุณต้องเพิ่ม `$HOME/.local/bin/` เข้าไปยัง PATH ของคุณ
โดยหากคุณใช้ Bash คุณสามารถแก้ไข `~/.bash_profile` และเพิ่มบรรทัดนี้เข้าไปได้:
```sh
export PATH=$PATH:$HOME/.local/bin
```
#i หากคุณใช้ Zsh สามารถใช้โคดเดียวกันได้ เพียงแต่คุณต้องแก้ไขไฟล์ `~/.zprofile` หรือ
`~/.zshrc` แทน
โดยบน Windows มีขั้นตอนดังนี้:
+ กด Windows + R
+ พิมพ์ `sysdm.cpl` และกด Enter
+ ในหน้าต่าง *System Properties* คลิกไปยังแท็บ *Advanced*
+ คลิกปุ่ม *Environment Variables*
หลังจากนั้น เลือกตัวแปร *Path* ในส่วน *User variables* แล้วจึงกด *Edit* แล้วเพิ่ม
`%USERPROFILE%\.platformio\penv\Scripts\` เข้าไปในรายการ
==== 99-platformio-udev.rules <pioudev>
#i ผู้ใช้ Linux จำเป็นที่จะต้องติดตั้งกฎ udev โดยสามารถดูไฟล์กฎ udev เวอร์ชันล่าสุดได้ที่#jb
https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/system/99-platformio-udev.rules
*หมายเหตุ:* โปรดตรวจสอบว่า PID และ VID ของบอร์ดคุณอยู่ในไฟล์กฎนั้น โดยคุณสามารถดู PID/VID
ของบอร์ดคุณได้ผ่านคำสั่ง `pio device list`
#i โดยไฟล์นั้นต้องถูกวางอยู่ที่ `/etc/udev/rules.d/99-platformio-udev.rules`
(ตำแหน่งที่ดีที่สุด) หรือ `/lib/udev/rules.d/99-platformio-udev.rules`
(อาจจำเป็นสำหรับบางระบบที่พัง)
โปรดใช้คำสั่งต่อไปนี้ในการดาวน์โหลดและวางไฟล์นั้นไว้ในสถานที่ที่ถูกต้อง:
```sh
curl -fsSL https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/system/99-platformio-udev.rules | sudo tee /etc/udev/rules.d/99-platformio-udev.rules
```
หรือคุณก็สามารถดาวน์โหลดไฟล์นั้นด้วยตัวเองและคัดลอกมันไปในโฟลเดอร์ที่หมายได้เช่นกัน
```sh
sudo cp 99-platformio-udev.rules /etc/udev/rules.d/99-platformio-udev.rules
```
หลังจากนั้น รีสตาร์ทบริการ udev:
```sh
sudo service udev restart
```
หรือ:
```sh
sudo udevadm control --reload-rules
sudo udevadm trigger
```
หลังจากติดตั้งไฟล์นี้แล้ว ถอดสายที่เชื่อมต่อระหว่างบอร์ดและคอมพิวเตอร์ของคุณแล้วเสียบมันใหม่
==== การดาวน์โหลดโปรเจกต์
#i สามารถใช้ Git ในการ clone โปรเจกต์ได้ด้วยคำสั่งต่อไปนี้:
```sh
git clone https://gitskette.dailitation.xyz/linesofcodes/liteauth-firmware32.git
```
#i โดย Git นั้นจะทำการโคลนโปรเจกต์ไปที่โฟลเดอร์ `liteauth-firmware32` เนื่องจากเป็นชื่อของ
Git repository หรือหากไม่ต้องการใช้ Git กรุณาไปที่
https://gitskette.dailitation.xyz/linesofcodes/liteauth-firmware32 และทำการคลิกปุ่ม
*Code* แล้วกด *Download ZIP* หรือ *Download TAR.GZ* แล้วทำการแตกไฟล์ได้ตามปกติ
หลังจากนั้น ไปที่โฟลเดอร์ของคุณในเทอร์มินัลโดยใช้คำสั่ง `cd`
==== คำสั่ง PlatformIO เบื้องต้น
#[
#set list(indent: 3em)
- `pio run --list-targets`: ดูรายการเป้าหมายคำสั่งรัน
- `pio run upload`: รันเป้าหมายอัพโหลด
ซึ่งนี่คือคำสั่งที่คุณควรจะใช้ในการเขียนเฟิร์มแวร์ลงบนบอร์ด
- `pio device monitor`: เปิด Serial Monitor
]
#i *หมายเหตุ:* โปรดใช้คำสั่งประเภท `pio run` ในโฟลเดอร์ของโปรเจกต์
== การทดสอบ
== การวิเคราะห์ข้อมูล
Chapter3/Chapter3.typ
+695
View File
@@ -0,0 +1,695 @@
#import "../PageTemplate.typ": *
#import "@preview/tiaoma:0.3.0"
#import "@preview/fletcher:0.5.8" as fletcher: diagram, edge, node
#import fletcher.shapes: circle, diamond, pill
#show: chapter-page
#set heading(numbering: "บทที่ 1")
#heading([#linebreak()วิธีการดำเนินโครงงาน])
#set heading(numbering: "1.1")
#i ในการดำเนินการศึกษาครั้งนี้
คณะผู้จัดทำโครงงานได้ศึกษาข้อมูลเบื้องต้นในการสร้างเครื่องยืนยันตัวตนด้วย NFC
และได้ดำเนินการตามขั้นตอนนี้
+ วางแผนการดำเนินงาน
+ การออกแบบ
+ วัสดุอุปกรณ์
+ ขั้นตอนการประกอบ
+ การทดลอง
+ การวิเคราะห์ข้อมูล
== วางแผนการดำเนินงาน
#show table.cell.where(y: 1): strong
#set par(leading: 0.5em)
#let arrow = [
#place(
left + horizon,
text(weight: "bold", size: 14pt)[#sym.arrow.l],
dx: -5pt,
dy: -0.7pt,
)
#place(
horizon,
line(length: 100%, stroke: (thickness: 1pt)),
dx: 0pt,
dy: 0pt,
)
#place(
right + horizon,
text(weight: "bold", size: 14pt)[#sym.arrow.r],
dx: 5pt,
dy: -0.7pt,
)
]
=== แผนขั้นตอนและวิธีการดำเนินงาน
#table(
columns: 12,
align: (
left + horizon,
center,
center,
center,
center,
center,
center,
center,
center,
center,
center,
center,
),
table.header(
table.cell(
[ขั้นตอนการ\ ดำเนินการ],
rowspan: 2,
),
table.cell(
[พ.ศ.2568],
colspan: 3,
),
table.cell(
[พ.ศ.2569],
colspan: 8,
),
[ต.ค.],
[พ.ย.],
[ธ.ค.],
[ม.ค.],
[ก.พ.],
[มี.ค],
[เม.ย],
[พ.ค.],
[มิ.ย.],
[ก.ค.],
[ส.ค.],
),
[ศึกษาค้นคว้าข้อมูล],
table.cell(arrow, colspan: 3),
[],
[],
[],
[],
[],
[],
[],
[],
[เสนอหัวข้อ], arrow, [], [], [], [], [], [], [], [], [], [],
[เสนอครั้งที่ 1], [], arrow, [], [], [], [], [], [], [], [], [],
[ออกแบบและสร้าง], [], table.cell(arrow, colspan: 5), [], [], [], [], [],
[จัดซื้ออุปกรณ์ทดลอง],
[],
table.cell(arrow, colspan: 3),
[],
[],
[],
[],
[],
[],
[],
[ทดลองการทำงาน], [], [], table.cell(arrow, colspan: 4), [], [], [], [], [],
[ปรับปรุงแก้ไข], [], [], [], [], table.cell(arrow, colspan: 5), [], [],
[เสนอครั้งที่ 2], [], [], [], arrow, [], [], [], [], [], [], [],
[จัดทำรูปเล่ม], table.cell(arrow, colspan: 11),
[นำเสนอโครงงาน], [], [], [], [], [], [], [], [], [], [], [],
)
#show: page-theme
#set par(leading: 0.5em)
=== ผังการดำเนินงาน
#diagram(
node-stroke: 1pt,
spacing: 2em,
node((0, 0), [เริ่มต้น], shape: pill),
edge("-|>"),
node((0, 1), shape: circle, radius: 1em),
edge("-|>"),
node((0, 2), [ศึกษาข้อมูลและทฤษฏีที่เกี่ยวข้อง], width: 2.5in),
edge("-|>"),
node((0, 3), [ออกแบบและวางแผนการดําเนินงาน], width: 2.5in),
edge("-|>"),
node((0, 4), [เครื่องยืนยันตัวตนด้วย NFC], width: 2.5in),
edge("-|>"),
node((0, 5), [ทดสอบประสิทธิภาพ], shape: diamond),
edge("r,u,u,u,u,l", "-|>", [ไม่ผ่าน]),
edge("-|>", [ผ่าน]),
node((0, 6), [จัดทำเอกสาร], width: 2.5in),
edge("-|>"),
node((0, 7), [นำเสนอ], width: 2.5in),
edge("-|>"),
node((0, 8), [สิ้นสุด], shape: pill),
)
#pagebreak()
=== ผังการทำงาน
#diagram(
node-stroke: 1pt,
spacing: 2em,
node([เริ่มต้น], shape: pill),
edge("-|>"),
node((1, 0), [ตั้งค่า LittleFS]),
edge("-|>"),
node((1, 2), [มี Wi-Fi บันทึก\ ไว้อยู่หรือไม่], shape: diamond),
edge("l", "-|>", [ไม่มี]),
edge((1, 2), (1, 3), "-|>", [มี]),
node((0, 2), [รอรับรายละเอียดเครือข่าย\ (ESP-Touch)]),
edge("d,r", "-|>"),
node((1, 3), [เชื่อมต่อเครือข่าย]),
edge("-|>"),
node((0, 4), [มีอุปกรณ์ควบคุม\ หลักแล้วหรือไม่], shape: diamond),
edge("-|>", [ไม่มี]),
edge("d", "-|>", [มี]),
node((1, 4), [สร้างโทเค็นสำหรับการยืนยัน\ อุปกรณ์ควบคุมหลัก]),
edge("-|>"),
node((1, 5), [รออุปกรณ์ควบคุมหลัก\ แตะเซนเซอร์ NFC]),
edge("-|>"),
node((0, 5), [ตั้งค่าเซิร์ฟเวอร์ HTTPS]),
edge("-|>"),
node((0, 6), shape: circle, radius: 1em),
edge("-|>"),
node((0, 7), [มีการแตะเซนเซอร์\ NFC ขาเข้าหรือไม่], shape: diamond),
edge("-|>", [ไม่มี]),
node((0, 9), [มีคนผ่านเซนเซอร์ PIR\ โดยไม่ได้รับอนุญาตหรือไม่], shape: diamond),
edge((0, 9), (0, 10), [ไม่มี]),
edge((0, 7), (1, 6), "-|>", [มี]),
node((1, 6), [อยู่ในโหมดลงทะเบียน\ หรือไม่], shape: diamond),
edge("-|>", [ใช่]),
edge((1, 6), (2, 7), [ไม่]),
node((1, 7), [นำ ID อุปกรณ์เข้า\ สู่รายการทะเบียน]),
edge((1, 7), (0.6, 7), (0, 9), "-|>"),
node((2, 7), [ID ของอุปกรณ์อยู่\ ในทะเบียนหรือไม่], shape: diamond),
edge("-|>", [อยู่]),
edge((2, 7), (1, 8), "-|>", [ไม่อยู่], label-sep: -5pt),
node((2, 8), [ส่งเสียงคอนเฟิร์ม]),
edge((2, 8), (2, 8.5), (0.4, 8.5), (0, 9), "-|>"),
node((1, 8), [ส่งเสียงแสดงความผิดพลาด]),
edge((1, 8), (0.5, 8), (0, 9), "-|>"),
node((1, 9), [แจ้งเตือนทางเสียง\ และแอปพลิเคชัน]),
edge((1, 9), (0, 10), "-|>"),
edge((0, 10), (1, 10), "-|>", [มี]),
node((0, 10), [มีคำขอ HTTPS\ ใหม่หรือไม่], shape: diamond),
edge((0, 10), (-2, 10), "-|>", [ไม่มี], label-pos: 10%),
edge((0, 9), (1, 9), "-|>", [มี], label-anchor: "center", label-sep: -8pt),
node((1, 10), [ประมวลผลคำขอ HTTPS]),
edge((1, 10), (1, 11), (-2, 11), (-2, 10), "-|>"),
node((-2, 10), shape: circle, radius: 1em),
edge((-2, 10), (-2, 6), (0, 6), "-|>"),
)
#pagebreak()
#set par(leading: 1em)
== การออกแบบ
== วัสดุอุปกรณ์
+ บอร์ด ESP32 (NodeMCU)
+ กล่องพลาสติก
+ Buzzer
+ เซนเซอร์ PIR
+ เซนเซอร์ NFC 2 ชิ้น
== ขั้นตอนการประกอบ
โครงงานแบ่งออกเป็น 3 โมดูล
+ โมดูลเซนเซอร์ NFC ขาเข้าและบอร์ด ESP32
+ โมดูลเซนเซอร์ NFC ขาออก
+ โมดูลเซนเซอร์ PIR
#show heading: it => {
if it.level > 2 {
block(
it,
inset: (left: -3em * (it.level - 2)),
)
} else {
it
}
}
=== โมดูลเซนเซอร์ NFC ขาออก
#i ดำเนินการเจาะรูบริเวณตัวกล่องเพื่อใช้เป็นช่องสำหรับสายไฟ
จากนั้นนำสายไฟร้อยผ่านช่องดังกล่าวและต่อเข้ากับเซนเซอร์ NFC ให้เรียบร้อยตามขั้นตอน
=== การติดตั้งอุปกรณ์
=== การเขียนเฟิร์มแวร์ <writingFirmware>
#iii โครงงานนี้ใช้ซอฟต์แวร์ PlatformIO ในการสร้างและจัดการโปรเจกต์เฟิร์มแวร์
โดยหากต้องการเพียงแค่เขียนเฟิร์มแวร์ลงไปยังบอร์ด ESP32 คุณจำเป็นต้องใช้ซอฟต์แวร์หลัก ๆ คือ
PlatformIO Core และ Git (ไม่จำเป็น แต่เพื่อความสะดวกสบาย) อย่างไรก็ตาม PlatformIO
จำเป็นต้องใช้ Python เวอร์ชัน 3.6 ขึ้นไปด้วยเช่นกัน ดังนั้นคุณจำเป็นต้องติดตั้ง Python
ด้วยหากคุณยังไม่มี
#iii ในขั้นตอนแรก โปรดเปิดเทอร์มินัลของคุณ ซึ่งโดยทั่วไปแล้วคุณสามารถค้นหาแอปพลิเคชัน#jb
"Terminal" ได้เลย โดยบน Windows 10 เวอร์ชั่นใหม่ ๆ และ Windows 11 จะมาพร้อมกับแอปพลิเคชัน
Windows Terminal อย่างไรก็ตาม เมื่อเปิดแล้ว โปรดตรวจสอบให้แน่ใจว่าคุณกำลังใช้ PowerShell
และไม่ใช่ Command Prompt
#iii โดยในปัจจุบัน Python เวอร์ชันล่าสุดคือ Python 3.14.2 โดยคุณสามารถติดตั้ง Python และ Git
บน Windows ได้ด้วยการใช้คำสั่งต่อไปนี้
```sh
winget install Python.Python.3.14 Git.Git -e -s winget
```
#iii สำหรับระบบปฏิบัติการอื่นนั้น โดยปกติแล้วจะไม่ต้องติดตั้ง Python
เพิ่มเนื่องจากมีติดมากับระบบปฏิบัติการอยู่แล้ว อย่างไรก็ตาม บน Linux อาจต้องมีการติดตั้งการรองรับ
Virtual Environment แยก โดยแต่ละระบบจะมีชื่อแพคเกจไม่เหมือนกัน โดยบน Debian, Fedora,
และ Arch สามารถใช้คำสั่งต่อไปนี้ในการติดตั้งทั้ง Python Virtual Environment และ Git
พร้อมกันได้
#pagebreak()
```sh
# Debian
sudo apt install python3-venv git
# Fedora
sudo dnf install python3-virtualenv git
# Arch
sudo pacman -S python-virtualenv git
```
#show raw.where(block: true): set block(below: 2em)
==== การติดตั้ง PlatformIO Core ผ่านแพคเกจ
#iiii หากคุณใช้ Fedora Linux หรือ Arch Linux (หรือลูก ๆ ของมัน) คุณสามารถติดตั้งแพคเกจ
PlatformIO ได้โดยตรง โดยมีคำสั่งดังนี้:
```sh
# Fedora Linux
sudo dnf install platformio
# Arch Linux
sudo pacman -S platformio-core
```
- หากคุณติดตั้งแพคเกจ Fedora นั้นแล้ว คุณไม่จำเป็นที่จะต้องติดตั้งกฎ udev ด้วยตนเอง
(ที่จะถูกกล่าวถึงใน@pioudev)
- หากคุณใช้ Arch คุณสามารถติดตั้งแพคเกจกฎ udev ได้โดยตรงโดยไม่ต้องดาวน์โหลดเอง
```sh
sudo pacman -S --asdeps platformio-core-udev
```
==== การติดตั้ง PlatformIO Core ผ่านสคริปต์
#iiii ถัดไป ในการติดตั้ง PlatformIO Core สามารถทำได้โดยการใช้สคริปต์ติดตั้ง โดยสำหรับ `curl`
สามารถใช้คำสั่งนี้ได้:
```sh
curl -fsSL -o get-platformio.py https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py
```
หรือหากต้องการใช้ `wget`:
```sh
wget -O get-platformio.py https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py
```
#pagebreak()
หรือสำหรับ PowerShell, สามารถใช้ `iwr` (หรือชื่อเต็มคือ `Invoke-WebRequest`) ได้:
```sh
iwr -OutFile get-platformio.py -Uri https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py
```
(มีการเว้นบรรทัดใหม่เนื่องจากพื้นที่ไม่เพียงพอ โปรดอย่าเว้นบรรทัดเมื่อพิมพ์คำสั่งจริง)
#iiii แล้วดังนั้นจึงใช้คำสั่ง `python3 get-platformio.py`
ในการรันสคริปต์ติดตั้งที่ได้ทำการดาวน์โหลดมา โดยค่าเริ่มต้นแล้ว PlatformIO
จะไม่เพิ่มตนเองเข้าไปยังตัวแปรสิ่งแวดล้อม PATH
ซึ่งจำเป็นในการใช้คำสั่งจากที่ใหนก็ได้โดยไม่ต้องกล่าวถึงไฟล์พาธ
#iiii โดยสำหรับ Linux แล้วนั้น คุณต้องเพิ่ม `$HOME/.local/bin/` เข้าไปยัง PATH ของคุณ
โดยหากคุณใช้ Bash คุณสามารถแก้ไข `~/.bash_profile` และเพิ่มบรรทัดนี้เข้าไปได้:
```sh
export PATH=$PATH:$HOME/.local/bin
```
#iiii หากคุณใช้ Zsh สามารถใช้โคดเดียวกันได้ เพียงแต่คุณต้องแก้ไขไฟล์ `~/.zprofile` หรือ
`~/.zshrc` แทน
โดยบน Windows มีขั้นตอนดังนี้:
+ กด Windows + R
+ พิมพ์ `sysdm.cpl` และกด Enter
+ ในหน้าต่าง *System Properties* คลิกไปยังแท็บ *Advanced*
+ คลิกปุ่ม *Environment Variables*
หลังจากนั้น เลือกตัวแปร *Path* ในส่วน *User variables* แล้วจึงกด *Edit* แล้วเพิ่ม
`%USERPROFILE%\.platformio\penv\Scripts\` เข้าไปในรายการ
==== 99-platformio-udev.rules <pioudev>
#iiii ผู้ใช้ Linux จำเป็นที่จะต้องติดตั้งกฎ udev โดยสามารถดูไฟล์กฎ udev เวอร์ชันล่าสุดได้ที่
https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/system/99-platformio-udev.rules
*หมายเหตุ:* โปรดตรวจสอบว่า PID และ VID ของบอร์ดคุณอยู่ในไฟล์กฎนั้น โดยคุณสามารถดู PID/VID
ของบอร์ดคุณได้ผ่านคำสั่ง `pio device list`
#iiii โดยไฟล์นั้นต้องถูกวางอยู่ที่ `/etc/udev/rules.d/99-platformio-udev.rules`
(ตำแหน่งที่ดีที่สุด) หรือ `/lib/udev/rules.d/99-platformio-udev.rules`
(อาจจำเป็นสำหรับบางระบบที่พัง)
โปรดใช้คำสั่งต่อไปนี้ในการดาวน์โหลดและวางไฟล์นั้นไว้ในสถานที่ที่ถูกต้อง:
```sh
curl -fsSL https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/system/99-platformio-udev.rules | sudo tee /etc/udev/rules.d/99-platformio-udev.rules
```
หรือคุณก็สามารถดาวน์โหลดไฟล์นั้นด้วยตัวเองและคัดลอกมันไปในโฟลเดอร์ที่หมายได้เช่นกัน
```sh
sudo cp 99-platformio-udev.rules /etc/udev/rules.d/99-platformio-udev.rules
```
หลังจากนั้น รีสตาร์ทบริการ udev:
```sh
sudo service udev restart
```
หรือ:
```sh
sudo udevadm control --reload-rules
sudo udevadm trigger
```
หลังจากติดตั้งไฟล์นี้แล้ว ถอดสายที่เชื่อมต่อระหว่างบอร์ดและคอมพิวเตอร์ของคุณแล้วเสียบมันใหม่
==== การดาวน์โหลดโปรเจกต์
#iiii สามารถใช้ Git ในการ clone โปรเจกต์ได้ด้วยคำสั่งต่อไปนี้:
```sh
git clone https://gitskette.dailitation.xyz/linesofcodes/liteauth-firmware32.git
```
#iiii โดย Git นั้นจะทำการโคลนโปรเจกต์ไปที่โฟลเดอร์ `liteauth-firmware32`
เนื่องจากเป็นชื่อของ Git repository หรือหากไม่ต้องการใช้ Git กรุณาไปที่
https://gitskette.dailitation.xyz/linesofcodes/liteauth-firmware32 และทำการคลิกปุ่ม
*Code* แล้วกด *Download ZIP* หรือ *Download TAR.GZ* แล้วทำการแตกไฟล์ได้ตามปกติ
หลังจากนั้น ไปที่โฟลเดอร์ของคุณในเทอร์มินัลโดยใช้คำสั่ง `cd`
#pagebreak()
==== คำสั่ง PlatformIO เบื้องต้น
#[
#set list(indent: 9.25em)
- `pio run --list-targets`: ดูรายการเป้าหมายคำสั่งรัน
- `pio run upload`: รันเป้าหมายอัพโหลด
ซึ่งนี่คือคำสั่งที่คุณควรจะใช้ในการเขียนเฟิร์มแวร์ลงบนบอร์ด
- `pio device monitor`: เปิด Serial Monitor
]
#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 ออกมาได้ และไม่ใช่เป้าหมายของโครงงานนี้เช่นกัน
== การทดสอบ
== การวิเคราะห์ข้อมูล
PageTemplate.typ
+23 -7
View File
@@ -27,16 +27,16 @@
/// Insane shit forced upon by my teacher /// Insane shit forced upon by my teacher
/// For indenting in 3rd level subheadings /// For indenting in 3rd level subheadings
#let iii = h(3em) // #let iii = h(3em)
// #let iii = h(5.5em) #let iii = h(5.5em)
/// For indenting in 4th level subheadings /// For indenting in 4th level subheadings
#let iiii = h(6em) // #let iiii = h(6em)
// #let iiii = h(9.25em) #let iiii = h(9.25em)
#let iiiii = h(9em) #let iiiii = h(13em)
#let iiiiii = h(12em) #let iiiiii = h(16.85em)
#let page-theme(doc) = { #let page-theme(doc) = {
set page( set page(
@@ -65,6 +65,14 @@
leading: 1em, leading: 1em,
) )
set list(indent: 1em) 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 raw(theme: "Dracula.tmTheme")
show raw.where(block: true): set text(
fill: rgb("#F8F8F2"),
font: "Cascadia Code",
size: 10pt,
)
show heading: set text(size: 10.5pt, weight: "regular") show heading: set text(size: 10.5pt, weight: "regular")
show heading: set block(below: 1em) show heading: set block(below: 1em)
show heading.where(level: 1): set text(size: 12pt, weight: "bold") show heading.where(level: 1): set text(size: 12pt, weight: "bold")
@@ -81,8 +89,16 @@
} }
} }
show math.equation: set text(font: "Laksaman") show math.equation: set text(font: "Laksaman")
show raw: set text(font: "Cascadia Code", size: 10pt)
show table.cell.where(y: 0): strong show table.cell.where(y: 0): strong
show figure.caption: it => {
text(weight: "bold")[
#it.supplement
#it.counter.display(it.numbering)
#it.separator
]
it.body
}
set figure.caption(separator: "")
set enum(number-align: start + top) set enum(number-align: start + top)
set ref(supplement: "หัวข้อ") set ref(supplement: "หัวข้อ")
doc doc
References.yaml
+26 -6
View File
@@ -11,22 +11,32 @@ wkNodeMcu:
wkEsp32: wkEsp32:
type: Web type: Web
title: ESP32 title: ESP32
date: 2025-11-2 date: 2025-12-27
language: en language: en
publisher: มูลนิธิวิกิมีเดีย (ภายใต้ CC BY-SA 4.0) publisher: มูลนิธิวิกิมีเดีย (ภายใต้ CC BY-SA 4.0)
url: url:
date: 2025-12-8 date: 2025-12-28
value: https://en.wikipedia.org/w/index.php?title=ESP32&oldid=1320113248 value: https://en.wikipedia.org/w/index.php?title=ESP32&oldid=1329754183
wkEspressif: wkEspressif:
type: Web type: Web
title: Espressif Systems title: Espressif Systems
date: 2025-10-6 date: 2025-11-28
language: en language: en
publisher: มูลนิธิวิกิมีเดีย (ภายใต้ CC BY-SA 4.0) publisher: มูลนิธิวิกิมีเดีย (ภายใต้ CC BY-SA 4.0)
url: url:
date: 2025-12-8 date: 2025-12-29
value: https://en.wikipedia.org/w/index.php?title=Espressif_Systems&oldid=1315427960 value: https://en.wikipedia.org/w/index.php?title=Espressif_Systems&oldid=1324514195
wkMicrocontroller:
type: Web
title: Microcontroller
date: 2025-12-21
language: en
publisher: มูลนิธิวิกิมีเดีย (ภายใต้ CC BY-SA 4.0)
url:
date: 2025-12-28
value: https://en.wikipedia.org/w/index.php?title=Microcontroller&oldid=1328645390
wkFlutter: wkFlutter:
type: Web type: Web
@@ -240,6 +250,16 @@ flLinuxBuild:
date: 2025-12-6 date: 2025-12-6
value: https://docs.flutter.dev/platform-integration/linux/building value: https://docs.flutter.dev/platform-integration/linux/building
flArchOverview:
type: Web
title: Flutter architectural overview
date: 2025-12-8
language: en
publisher: Flutter (ภายใต้ CC BY 3.0 และ BSD License)
url:
date: 2025-12-30
value: https://docs.flutter.dev/resources/architectural-overview
archPkgs: archPkgs:
type: Web type: Web
title: Arch Linux - Package Search title: Arch Linux - Package Search
main.typ
+11 -3
View File
@@ -45,10 +45,12 @@
title: [สารบัญภาพ], title: [สารบัญภาพ],
) )
#include "Chapter1.typ" #show heading: i-figured.reset-counters
#show figure: i-figured.show-figure
#include "Chapter1.typ"
#include "Chapter2/Chapter2.typ" #include "Chapter2/Chapter2.typ"
#include "Chapter3.typ" #include "Chapter3/Chapter3.typ"
#include "Chapter4.typ" #include "Chapter4.typ"
#include "Chapter5.typ" #include "Chapter5.typ"
@@ -69,21 +71,27 @@
let offset = 0 let offset = 0
for (idx, f) in figures.enumerate() { for (idx, f) in figures.enumerate() {
if (idx >= attributions.len()) { if idx >= attributions.len() {
return return
} }
if attributions.at(idx).body.body == [] { if attributions.at(idx).body.body == [] {
offset += 1 offset += 1
if idx + offset >= attributions.len() {
return
}
if attributions.at(idx + offset).body.body == [] { if attributions.at(idx + offset).body.body == [] {
continue continue
} }
} }
f.caption f.caption
linebreak()
h(2.2em) h(2.2em)
attributions.at(idx + offset).body.body attributions.at(idx + offset).body.body
linebreak()
} }
} }