TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI
VIỆN ĐIỆN
----------
Báo cáo
Môn: Các hệ thống thời gian thực
Đề tài: Tìm hiểu hệ điều hành Contiki
Giảng viên hướng dẫn: PGS.TS Nguyễn Quốc Cường
Sinh viên thực hiện:
Lê Hồng Nhật
20122197
Lê Anh Phương
20122245
Nguyễn Minh Sang
20122325
Bùi Đức Thắng
20122466
Hà Nội - 2016
Mục lục
Mục lục .......................................................................................................................... 0
Danh mục hình vẽ .......................................................................................................... 3
I.
Contiki ................................................................................................................ 5
1. Contiki và giấy phép ........................................................................................... 5
2. Tìm hiểu giấy phép BSD .................................................................................... 6
a.
Nhà phát hành .............................................................................................. 6
b. Nội dung ...................................................................................................... 6
Kiến trúc hệ điều hành Contiki ........................................................................... 8
II.
1. Giới thiệu contiki ................................................................................................ 8
2. Kiến trúc Contiki ................................................................................................ 8
a.
Nhân Kernel ................................................................................................. 8
b. Process ......................................................................................................... 9
c.
Preemptive Multi-threading ....................................................................... 10
3. Đặc điểm hệ điều hành Contiki ........................................................................ 10
III.
Cài đặt Contiki cho một phần cứng .................................................................. 12
1. Các thành phần của Contiki .............................................................................. 12
2. Build System của Contiki ................................................................................. 15
3. Các bước port Contiki lên một phần cứng........................................................ 16
4. Cài đặt Contiki lên Kit MSP430 ....................................................................... 17
IV.
Lập trình ứng dụng trên hệ điều hành Contiki.................................................. 22
1. Yêu cầu của bài toán ......................................................................................... 22
2. Các công cụ của hệ điều hành Contiki ............................................................. 22
a.
Process ....................................................................................................... 22
b. Event .......................................................................................................... 24
c.
Các module Timer ..................................................................................... 26
d. Mức ưu tiên trong Contiki ......................................................................... 29
e.
Semaphore ................................................................................................. 30
3. Tìm giải pháp cho bài toán ............................................................................... 30
4. Lập trình............................................................................................................ 30
a.
Code ........................................................................................................... 30
1
b. Chỉnh các thông số liên quan đến Tần số, Cấu hình thạch anh ................. 34
c.
Biên dịch và nạp code ................................................................................ 34
2
Danh mục hình vẽ
Hình 1. Giấy phép BSD ................................................................................................. 6
Hình 2: Danh sách phần cứng được Contiki hỗ trợ ..................................................... 14
Hình 3: Giao diện phần mềm Instant Contiki .............................................................. 16
Hình 4: Giao diện kiểm tra kích hoạt MSP430 ............................................................ 17
Hình 5: Giao diện dòng lệnh Terminal ........................................................................ 17
Hình 6: Đánh lệnh vào Terminal ................................................................................. 18
Hình 7: File tạo ra sau khi chạy câu lệnh make TARGET=Launchpad ...................... 18
Hình 8: File hex tạo ra sau lệnh make blink.upload .................................................... 19
Hình 9: Giao diện Terminal khi upload thành công .................................................... 19
3
LỜI NÓI ĐẦU
Hệ điều hành contiki là hệ điều hành mã nguồn mở, được nghiên cứu, thiết kế và phát
triển bởi một nhóm các nhà phát triển từ viện khoa học máy tính Thụy Điển, người
đứng đầu là Adam Dunkels. Nhóm phát triển Contiki gồm nhiều thành viên đến từ
SICS, CISCO, cùng nhiều tổ chức và các trường đại học khác trên thế giới. Hệ điều
hành Contiki được thiết kế cho các vi điều khiển có bộ nhớ nhỏ, với thông số 2KB
RAM và 40KB ROM. Nhờ đó, Contiki được sử dụng cho các hệ thống nhúng và các
ứng dụng trong mạng cảm biến không dây. Contiki bắt đầu được nghiên cứu từ năm
2001 và phát hành phiên bản đầu tiên Contiki 1.0 năm 2003. Hình 3.1 cho thấy lịch sử
phát triển của Contiki trong những năm qua. Phiên bản hiện nay của Contiki là 2.4,
với nhiều thay đổi, bổ sung và phát triển vượt bậc. Trong thực tế, Contiki đã được ứng
dụng trong nhiều dự án như giám sát đường hầm xe lửa, theo dõi nước trong biển
Baltic,… Nhiều cơ chế, ý tưởng trong Contiki đã được ứng dụng rộng rãi trong công
nghiệp. Điển hình như mô hình uIP được phát hành năm 2001 đã được sử dụng trong
hệ thống ứng dụng của hàng trăm công ty trong các lĩnh vực hàng hải, thông tin vệ
tinh, khai thác dầu mỏ,…; mô hình Protothreads được công bố lần đầu tiên năm 2005,
đến nay đã được sử dụng trong nhiều ứng dụng như bộ giải mã kỹ thuật số và thiết bị
cảm biến rung không dây.
4
I. Contiki
Contiki và giấy phép
Các mã nguồn Contiki được phát hành theo giấy phép BSD 3 khoản. Theo giấy phép
này, Contiki có thể được sử dụng một cách tự do trong cả hai hệ thống thương mại và
phi thương mại miễn là tiêu đề bản quyền trong các tập tin mã nguồn được giữ lại.
Bản quyền đối với mã nguồn Contiki được sở hữu bởi cá nhân hoặc tổ chức có đóng
góp cho Contiki, nhưng tất cả mọi người đã góp phần nó theo cùng các điều kiện giấy
phép BSD 3 khoản.
Mã của bạn là của riêng bạn
Các Contiki giấy phép mã nguồn mở không đòi hỏi bất kỳ mã để được chia sẻ với
những người khác. Nếu bạn sử dụng Contiki để phát triển mã, mã của bạn là của riêng
bạn và bạn không cần phải chia sẻ nó với bất cứ ai.
Điều đó nói rằng, họ thực sự đánh giá cao những đóng góp mã cho Contiki. Nếu bạn
muốn đóng góp mã nguồn cho dự án Contiki, tuy nhiên, họ yêu cầu mã này được
kèm theo bởi giấy phép tương tự như phần còn lại của Contiki.
Tái phân phối và sử dụng trong mã nguồn và các dạng nhị phân, có hoặc không có sửa
đổi, được cho phép cung cấp các điều kiện sau được đáp ứng:
1. Việc phân phối lại mã nguồn phải giữ lại bản quyền trên thông báo, danh sách điều
kiện và khuyến cáo kèm theo.
2. Việc phân phối lại dưới dạng nhị phân phải tạo lại được bản quyền trên thông báo,
danh sách điều kiện và khuyến cáo kèm theo trong tài liệu và / hoặc các tài liệu khác
được cung cấp với sự phân bố.
3. Tên của các tác giả có thể không được sử dụng để nhận hoặc quảng bá các sản
phẩm có nguồn gốc từ phần mềm này mà không có trước sự cho phép khi cụ thể nào
bằng văn bản.
Phần mềm này được cung cấp của tác giả `` as is '' và bất cứ sự trình bày hoặc sự đảm
bảo, sự kèm theo nhưng không giới hạn hay các đảm bảo đảm thương mại và phù hợp
cho một mục đích cụ thể thể đều bị bác bỏ. Trong bất cứ trường hợp tác giả sẽ không
chịu trách nhiệm cho bất cứ hành vi trực tiếp, gián tiếp, đặc biệt, hay quả tổn hại (các
khoản kèm theo nhưng không giới hạn, sử dụng sản phẩm thay thế hoặc dịch vụ; mất
mát về sử dụng, dữ liệu hay lợi nhuận; hoặc kinh doanh gián đoạn) gây ra và về trách
nhiệm pháp lý, dù trong hợp đồng, trách nhiệm pháp lý nghiêm ngặt hoặc lỗi (bao
gồm cẩn hoặc khác) phát sinh trong bất cứ cách nào ngoài việc sử dụng này phần
mềm, ngay cả khi được khuyến cáo về khả năng thiệt hại.
5
Tìm hiểu giấy phép BSD
Hình 1. Giấy phép BSD
a. Nhà phát hành
Giấy phép BSD (Berkeley Software Distribution License) là một giấy phép phần mềm
tự do với các điều kiện rất đơn giản được sử dụng rộng rãi cho phần mềm máy tính.
Ban đầu giấy phép BSD được thiết kế bởi Đại học California tại Berkeley năm 1980
cho dự án BSD (Berkeley Source Distribution).
b. Nội dung
Quyền lợi:
Giấy phép BSD cho phép sử dụng và phân phối lại mã nguồn và sản phẩm, có hoặc
không có sửa đổi, miễn là tuân thủ các yêu cầu sau
Nghĩa vụ:
Phải giữ nguyên thông báo bản quyền của sản phẩm. Yêu cầu này nhằm đảm bảo một
người dùng bất kì không thể tuyên bố anh ta đã viết ra một phần mềm nếu thực sự anh
ta không viết ra nó.
Phải kèm theo 2 thông báo: Danh sách các điều kiện và từ chối trách nhiệm.
Không được sử dụng tên dự án hay tên nhà phân phối vào mục đích quảng bá bản
thân nếu không được cho phép.
6
Như vậy, có thể thấy đặc điểm lớn nhất của BSD là nó cho phép các nhà phát triển
phần mềm có thể thương mại hóa một cách thực sự các sản phẩm phần mềm có sử
dụng mã nguồn mở dùng giấy phép BSD, tức kiếm tiền dựa trên mã nguồn của
chương trình (chủ yếu là mã nguồn do họ viết thêm và giữ lại mã nguồn đã được sửa
đổi đó cho bản thân mà không công bố) thay vì chỉ có thể kiếm tiền từ các hoạt động
không trực tiếp gắn với phần mềm như bảo hành, phát hành, đào tạo hướng dẫn sử
dụng … Ngoài ra, giấy phép BSD còn cho phép các nhà phát triển thay thế, bổ sung
thêm các điều khoản vào trong giấy phép cho phù hợp với mình, hoặc thậm chí sử
dụng một giấy phép khác.
7
II. Kiến trúc hệ điều hành Contiki
Giới thiệu contiki
Contiki OS được lập trình bằng ngôn ngữ C, hoạt động dựa trên cơ chế event-driven (
hướng sự kiện) và có những đặc điểm phù hợp với các hệ thống nhúng và mạng cảm
biến không dây:
+ Contiki được chia thành nhiều module hoạt động độc lập. Nhờ đó các ứng
dụng có thể sử dụng các module một cách linh động và chỉ load những module
cần thiết
+ Cơ chế hoạt động điều khiển event-driven làm giảm năng lượng tiêu hao và
hạn chế dung lượng bộ nhớ cần sử dụng
+ Có thể sử dụng IP trong mạng cảm biến thông qua uIP stack được xây dựng
dựa trên nền TCP/IP
+ Có những module cho phép ước lượng và quản lý năng lượng một cách hiệu
quả
+ Các giao thức tương tác giữa các lớp và các node trong mạng dễ dàng hơn
+ Sử dụng RIME stack phục vụ các giao thức dành cho mạng năng lượng thấp
một cách hiệu quả.
Bên cạnh đó, Contiki còn cung cấp những công cụ hỗ trợ mô phỏng với giao diện đơn
giản, dễ sử dụng và hỗ trợ tốt những thiết bị trong thực tế, phục vụ những mục đích
nghiên cứu, mô phỏng và triển khai những giao thức mới.
Kiến trúc Contiki
Hệ điều hành Contiki được xây dựng theo kiểu kiến trúc module. Tức là chia nhỏ các
yêu cầu của phần mềm thành các phần hầu như không trùng lặp, và do đó hỗ trợ làm
việc song song trên các module và dễ bảo trì hơn. Kiến trúc module giúp cho việc tái
sử dụng các thành phần của hệ thống và khả năng mở rộng tốt hơn
Hệ điều hành Contiki được chia thành 2 phần :
Loaded Program: Chứa các chương trình đã được nạp
Core: bao gồm
+ Nhân kernel
+ Tập các process
+ Các thư viện : Chứa các hàm C cho việc thực thi hệ thống
+ Program loader : Nạp các chương trình vào hệ thống
a. Nhân Kernel
Theo mô hình điều khiển Event-driven. Các Process được thực thi như các xử lý
event, chạy đến khi hoàn thành event đó. Trong mô hình Event-driven, các process
thay vì mỗi process một stack như một số mô hình khác thì các process sử dụng cùng
8
một stack, giúp cho hiệu quả chia sẻ của bộ nhớ hạn chế giữa tất cả các process. Hai
xử lý sự kiện sẽ không bao giờ chạy đồng thời với nhau
Nhân Contiki bao gồm một bộ lập lịch event làm nhiệm vụ gửi đi các event tới các
process đang chạy, và định kì gọi các xử lý polling của process.
i.
Event được chia thành 2 loại:
Event đồng bộ : được gửi ngay lập tức đến target process để lập lịch
Event không đồng bộ : được xếp hàng bởi nhân và được gửi đến các target
process sau đó.
Process chỉ chạy event tiếp theo khi event trước đó được hoàn thành.
ii.
iii.
Lập lịch event
Các event được gửi đến các process
Việc lập lịch event được hoàn thành trong 1 level duy nhất
Các event không chen hàng lẫn nhau. Chỉ bị chen hàng bởi ngắt
Không cho phép vô hiệu hóa ngắt
Do đó, không cho phép các event được gửi bởi các xử lý ngắt.
Cơ chế polling
Contiki cung cấp 1 cờ polling, sử dụng để yêu cầu 1 event poll
Là các event ưu tiên cao, được lập lịch giữa các event không đồng bộ
Khi có yêu cầu polling, cờ cung cấp xử lý ngắt để thực thi event poll đó
Một process được yêu cầu poll bởi hàm process_poll()
Khi được gọi process sẽ được lập lịch nhanh nhất có thể
Khi một event poll được lập lịch, các process mà thực thi xử lý poll, sẽ được
gọi, theo thứ tự ưu tiên của chúng.
Polling là cách để process chạy từ một ngắt.
b. Process
Process có thể là một service hoặc 1 chương trình ứng dụng.
Các đặc điểm của process:
Thường bắt đầu khi khởi động hệ thống
Được định nghĩa bởi 1 hàm xử lý event và một tùy chọn hàm xử lý poll
Process chạy khi có các event được gửi tới
Tất cả các process chia sẻ cùng không gian địa chỉ
Truyền thông interprocess thông qua Nhân, bởi việc gửi các event
Gồm 2 phần :
Process control block : lưu trong RAM, chứa thông tin như: tên, trạng thái, con
trỏ…
Process thread : là code của process, lưu trong ROM
Trạng thái của process được chứa trong bộ nhớ riêng biệt
Trạng thái process chiếm khoảng 23 bytes ( trên ESB platform)
9
Mỗi process có thể chỉ có 1 thread thực thi
Thread trong Contiki được gọi là protothread.
Các đặc điểm của protothreads :
Thread trong Contiki được gọi là Protothreads
Là stackness threads tối ưu hóa cho hệ điều hành event-driven
Prototheads hoạt động ít bộ nhớ ( khoảng 2 byte RAM)
Không yêu cầu stack riêng. Tất cả các protothreads chạy trên cùng stack.
c. Preemptive Multi-threading
Có thể được áp dụng trên nền tảng mỗi process
Thực hiện như một thư viện
Tùy chọn liên kết với các ứng dụng yêu cầu mô hình hoạt động đa luồng một
cách rõ rang
Sử dụng Protothreads.
Đặc điểm hệ điều hành Contiki
a) Quản lý tác vụ
Hoạt động trong Contiki dựa trên thực thi các process.
Các process có thể sử dụng cùng một stack. Do đó giúp cho hiệu quả sử dụng
bộ nhớ tốt hơn, tiết kiệm tài nguyên bộ nhớ hơn.
Mỗi process có thể chỉ chứa 1 protothread( 2 byte RAM)
Đo đó với 2KB RAM bộ nhớ có thể chạy cùng lúc tối đa tới 1000 process ( thực tế
thì rất ít các process chỉ chứa 1 protothread)
b) Cơ chế ngắt
Event chỉ bị chen hàng bởi ngắt. Contiki không bao giờ vô hiệu hóa ngắt
Ngắt có thể được thực thi khi sử dụng ngắt phần cứng hoặc điều hành quá trình
real-time.
Thư viện rtime cung cấp lập lịch các tác vụ real-time, ưu tiên các tác vụ thực
thi đúng thời gian đã lập lịch bất kể khi các process đang chạy
c) Cơ chế ưu tiên
Sử dụng cơ chế polling
Ưu tiên thực thi các tác vụ thời gian thực đã được lập lịch
d) Quản lý bộ nhớ
Nhân Contiki không tham gia quản lý bộ nhớ
Contiki hỗ trợ quản lý bộ nhớ đông
Cơ chế chống phân mảnh bộ nhớ
Sử dụng các hàm Memb()
e) Hỗ trợ truyền thông
Contiki hỗ trợ 2 stack truyền thông
10
uIP stack : uIP được thiết kế dựa trên ngôn ngữ C với mục tiêu tối ưu hóa tuyệt đối
các đặc tính cần thiết của một stack TCP/IP đầy đủ. uIP chỉ có thể hoạt động với một
giao diện mạng duy nhất và bao gồm các giao thức: IP, ICMP, UDP, TCP
Một số hàm trong API - uIP:
Khởi tạo kết nối: tcp_connect(), tcp_listen(0, udp_new()
Ngắt một kết nối: uip_close(), uip_abort()
Gửi một gói kiểu TCP: uip_send()
Gửi một gói kiểu UDP: uip_udp_packet_send()
Nhận một gói từ mạng: uip_newdata(), uip_datalen()
Gửi lại một gói dữ liệu: uip_rexmit()
Mở một cổng kết nối: uip_listen()
Kiểm tra kết nối: uip_connected()
Rime stack : Rime stack cung cấp một cấu trúc phân tầng của giao thức mạng cảm
biến không dây, từ một bộ phát quảng bá đơn giản tới việc định tuyến rắc rối trong
toàn mạng. Rime triển khai một giao thức phức tạp, với nhiều phần, mỗi phần lại gồm
những module phức tạp được tạo nên từ những module nhỏ lẻ đơn giản hơnSử dụng
tài nguyên
Một số module trong Rime stack:
Abc: Phát sóng quảng bá
Broadcast : phát sóng xác định
Unicast : cho biết thêm một địa chỉ đích cho các gói tin được truyền cho khối phát
sóng
Stunicast, Runicast, Polite…
f) Sử dụng tài nguyên
• Một cấu hình Contiki điển hình : 2KB RAM và 40KB ROM
• Một hệ thống cơ bản, cung cấp đa tác vụ và giao thức TCP/IP, có thể được
biên dịch trong khoảng 32KB
• 1 hệ thống với đầy đủ IPv6, sleepy router, RPL cần không quá 10KB RAM
và 30KB ROM
g) Platform
11
Contiki hỗ trợ các platform như trong bảng dưới đây
III. Cài đặt Contiki cho một phần cứng
Các thành phần của Contiki
12
Contiki là hệ điều hành mã nguồn mở, được sử dụng chủ yếu cho các hệ thống
mạng cảm biến (Wireless Sensor Networks).
Contiki luôn bao gồm 7 forder:
Apps
Core
CPU
Doc
Examples
Lib
Platform
Tools
Trong 7 forder này, các forder chính là: Core, CPU, Platform
a) Core:
Chứa các thành phần chính của hệ điều hành
Contiki
Chứa khoảng 300 file, trong đó:
o Tập tin tiêu đề chứa các khai báo
o Tập tin nguồn chứa cài đặt
13
b) CPU:
Chứa các bộ xử lý cụ thể cho việc
thực hiện các chức năng khác nhau
được sử dụng trong hệ điều hành
c) Platform:
Chứa thông tin cụ thể liên quan đến nền tảng phần cứng cho các nút cảm biến
như ESB, Sky mote…
d) Apps
Chứa các tập tin nguồn của các tiện ích phát triển cho Contiki.
Vd:
o Máy chủ web
o FTP
o Email
14
e) Doc
Sử dụng cho việc chuẩn bị tài liệu cho Contiki.
f) Example
Chứa các chương trình ví dụ.
g) Tool
Chứa các công cụ phần mềm đặc biệt.
Vd: Công cụ mô phỏng Cooja
Build System của Contiki
Contiki có cách thức xây dựng hệ thống (build system) được thiết kế để người
dùng dễ dàng chạy Contiki trực tiếp trên phần cứng.
Việc xây dựng hệ thống được thiết kế giống nhau trên các nền tảng phần cứng
khác nhau, do đó khi chuyển đổi phần cứng các lệnh sẽ giống nhau
Các file của Contiki được viết bằng ngôn ngữ C.
Có thể lựa chọn nhiều trình biên dịch khác nhau để viết chương trình như:
o KeilC
o CodeBlock
Khi cài đặt Contiki cho một phần cứng, chúng ta cần port:
o Hardware Libraries
o Clock module
o Rtimer
o Interrupt
o I/O (network driver, sensor, serial driver...)
o Makefile
Trong các thành phần này, Makefile sẽ chịu trách nhiệm quản lý các thành
phần.
Đối với Contiki, việc xây dựng hệ thống bao gồm một tập hợp các Makefile.
a. Makefile: makefile của project.
b. Makefile.include: makefile tổng thể của toàn bộ hệ thống Contiki
c. Makefile.$(TARGET) (trong đó $(TARGET) là tên của nền tảng hiện đang
được xây dựng): các quy tắc cho các nền tảng cụ thể, nằm trong thư mục
platform/ .Khi cài đặt cho 1 platform cụ thể, ta cần gán tên của platform đó vào
biến TARGET.
d. Makefile.$(CPU) (trong đó $(CPU) là tên của CPU hoặc vi điều khiển được sử
dụng trong nền tảng mà Contiki được xây dựng): các quy tắc cho kiến trúc
CPU, nằm trong thư mục cpu/ .
e. Makefile.$(APP) (trong đó $(APP) là tên của một ứng dụng trong thư mục
app/ ): Quy tắc cho các ứng dụng trong các app/. Mỗi app có makefile riêng
của mình.
15
Một số phần cứng được hỗ trợ:
Hình 2: Danh sách phần cứng được Contiki hỗ trợ
Các bước port Contiki lên một phần cứng
a. Để port Contiki lên một phần cứng, chúng ta quan tâm đến 2 thư mục:
o CPU
o Platform
b. Để cấu hình cho một CPU, chúng ta có thể chỉnh sửa những file đã có sẵn trong
thư mục cpu/native cho phù hợp với phần cứng hiện có:
o RealTime
o WatchDog
o MultiThreading
c. Sau khi chinh file cpu/native, ta nên đổi tên file thành tên phần cứng đang sử
dụng.
d. Mỗi một CPU cần có một file clock.c, trong đó có 3 hàm quan trọng:
o clock_init()
o clock_delay()
o clock_time()
e. Ta có thể viết thêm các thư viện cho phần cứng:
o Timer
o UART
o Config
f. Chỉnh sửa file makefile.cpu-name cho phù hợp với phần cứng:
o Họ CPU sử dụng
16
g.
h.
i.
j.
k.
o Các trình biên dịch có thể sử dụng
Để cấu hình cho platform cụ thể, chúng ta cần chỉnh sửa các file trong thư mục
platform/native.
Chỉnh sửa file platform-conf.h để cấu hình tần số của CPU, baudrate cho UART,
xác định platform có nút bấm, pin, radio… hay không.
Chỉnh sửa file contiki-conf.h để cấu hình cho Contiki như: µIP…
Chỉnh sửa file contiki-platform name-main.c để khởi tạo phần cứng, lập lịch và
chạy các process.
Có thể viết thêm các thư viện cho platform như thư viện mạng …
Cài đặt Contiki lên Kit MSP430
a. Giới thiệu Kit MSP430
Sử dụng MSP430G2553 16-bit MCU
16KB bộ nhớ
512B RAM
Tốc độ CPU có thể lên đến 16-MHz
Hỗ trợ ADC 10 bit, UART
b. Cài đặt lên Kit MSP430
trang chủ của Contiki cung cấp sẵn phần mềm Instant Contiki. Phần mềm này
sẽ tạo ra một hệ điều hành ubuntu ảo và có sẵn các thư mục của Contiki. Từ
bây giờ, ta sẽ chạy contiki theo các câu lệnh.
Giao diện phần mềm Íntant Contiki
17
Hình 3: Giao diện phần mềm Instant Contiki
Kết nối Kit MSP430 với cổng USB của máy tính của bạn. Đầu tiên chúng ta
cần phải kích hoạt MSP430 trong Instant Contiki, để Instant Contiki thì có thể
giao tiếp với nó. Điều này được thực hiện thông qua menu máy ảo
Player/Removable Devices.
18
Hình 4: Giao diện kiểm tra kích hoạt MSP430
Mở cửa sổ terminal
Hình 5: Giao diện dòng lệnh Terminal
Sử dụng lệnh cd để đi đến thư mục chứa code, ví dụ với thư mục “blink”:
19
- Xem thêm -