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



o cd contiki-launchpad/examples/launchpad/blink

Hình 6: Đánh lệnh vào Terminal
 Bây giờ chúng ta có thể biên dịch ứng dụng này cho nền tảng phần cứng:
o make TARGET=launchpad

Hình 7: File tạo ra sau khi chạy câu lệnh make TARGET=launchpad
 Nếu muốn biên dịch nhiều lần cho nền tảng đã chọn, bạn có thể yêu cầu
Contiki để nhớ lựa chọn của phần cứng với lệnh make savetarget:
o make TARGET=launchpad savetarget
 Lệnh này sẽ tạo một file có tên «makefile.target», file này sẽ lưu lại tên của
platform, trong trường hợp này là ‘launchpad’
 Để tải Contiki đến phần cứng, ta sử dụng lệnh:
o make blink.upload

20


Hình 8: File hex tạo ra sau lệnh make blink.upload
 Lệnh make blink.upload tự động biên dịch các ứng dụng và Contiki trước khi
tải nó vào phần cứng.

Hình 9: Giao diện Terminal khi upload thành công

21


IV. Lập trình ứng dụng trên hệ điều hành Contiki

Yêu cầu của bài toán
5 tác vụ độc lập:
1. Đọc nhiệt độ - 50ms
2. Kiểm tra bàn phím – 30ms
3. Hiển thị lên LCD – 50ms
4. Truyền tin lên cổng nối tiếp – 50ms
5. Báo động 50ms
Các công cụ của hệ điều hành Contiki
a. Process

Các chương trình trong Contiki là các process. Một process là một đoạn code được
thực hiện một cách đều đặn bởi hệ điều hành. Process có thể được kích hoạt khi khởi
động hệ thống hoặc là khi module chức process đó được nạp vào hệ thống. Các
process giao tiếp với nhau thông qua việc post các event.
Code trong hệ điều hành Contiki có thể được thực hiện theo một trong hai ngữ cảnh:
cooperative và preemptive. Code cooperative được thực hiện tuần tự, trong khi code
preemptive sẽ dừng tạm thời code cooperative để chiếm dụng tài nguyên cpu. Các
process Contiki chạy trong ngữ cảnh cooperative, còn các ngắt và real – time task
được lập lịch cùng với một deadline sẽ chạy trong ngữ cảnh preemptive.
Code cooperative (process) phải chạy cho đến khi hoàn thành, trước khi code
cooperative tiếp theo được phép chạy. Code preemptive có thể dừng code cooperative
bất cứ lúc nào. Khi bị dừng, code cooperative sẽ không được tiếp tục chạy cho đến
khi code preemptive hoàn thành.
Cấu trúc của Process
22


Một process Contiki bao gồm hai phần: khối điều khiển và thread. Khối điều khiển
được lưu trữ trong RAM, chứa các thông tin run – time về process như tên, trạng thái
và một con trỏ tới thread của process. Thread là code của process được lưu trữ trên

ROM.
 Process Control Block
Khối điều khiển process chứa các thông tin về mỗi process như tên, trạng thái và một
con trỏ tới thread của process. Khối điều khiển chỉ được sử dụng bởi nhân HĐH và
không bao giờ được truy cập trực tiếp bởi các process.
struct process {
struct process *next;
const char *name;
int (* thread)(struct pt *,
process_event_t,
process_data_t);
struct pt pt;
unsigned char state, needspoll;
};
Khối điều khiển chỉ chiếm một vài byte bộ nhớ. Cấu trúc của khối điều khiển process
được trình bày như trên. Lưu ý, không có bất cứ trường nào của khối điều khiển có
thể được truy cập trực tiếp bởi code người dùng. Trường next trỏ đến khối điều khiển
process tiếp theo trong danh sách liên kết của các process đang hoạt động. Trường
name trỏ đến tên văn bản của process. Trường thread là một con trỏ hàm, trỏ đến
thread của process. Trường pt giữ trạng thái của protothread. Trường state và
needspoll là các cờ giữ trạng thái của process. Cờ needspoll được set bởi hàm
process_poll() khi process được hỏi vòng.
Khối điều khiển process không được khai báo trực tiếp, mà gián tiếp thông qua macro
PROCESS(). Ví dụ:
PROCESS(hello_world_process, "Hello world process");

Trong đó, tham số đầu tiên là tên biến của khối điều khiển, được dùng khi truy cập
process. Tham số thứ hai là tên của process.
 Process Thread


23


Chứa code của mỗi process. Mỗi process thread bản chất là một protothread, được gọi
bởi bộ lập lịch các process. Ví dụ về process thread:
PROCESS_THREAD(hello_world_process, ev, data)

{
PROCESS_BEGIN();

printf("Hello, world\n");

PROCESS_END();
}
Protothread
Protothread là một giải pháp tổ chức code, cho phép hệ thống thực hiện các hoạt động
khác khi đang chờ đợi một sự kiện nào đó. Ý tưởng của protothread không chỉ được
sử dụng trong HĐH Contiki mà có thể bắt gặp ở nhiều hệ thống khác. Protothread
giúp cho các hàm ngôn ngữ C hoạt động như các thread, nhưng lại không tốn dung
lượng bộ nhớ như các thread.
Protothread là các hàm chuẩn ngôn ngữ C. Các hàm này bắt đầu và kết thúc bởi hai
macro đặc biệt, PT_BEGIN() và PT_END().
Process trong Contiki là sự bổ sung thêm từ protothread của chính nó, điều này cho
phép process đợi một sự kiện nào đó xảy ra. Các câu lệnh của protothread sử dụng
trong process Contiki bao gồm:
PROCESS_BEGIN(); // Declares the beginning of a process' protothread.
PROCESS_END(); // Declares the end of a process' protothread.
PROCESS_EXIT(); // Exit the process.
PROCESS_WAIT_EVENT(); // Wait for any event.
PROCESS_WAIT_EVENT_UNTIL(); // Wait for an event, but with a

condition.
PROCESS_YIELD();
//
Wait
for
any
event,
equivalent
to
PROCESS_WAIT_EVENT().
PROCESS_WAIT_UNTIL(); // Wait for a given condition; may not yield the
process.
PROCESS_PAUSE(); // Temporarily yield the process.

b. Event
Trong Contiki, một process có thể được khởi chạy khi nhận được một event. Có hai
loại event: không đồng bộ và đồng bộ.

24