Embed Size (px)
Citation preview
TRƯỜNG ĐẠI HỌC PHAN THIẾT
KHOA CÔNG NGHỆ THÔNG TIN
TÌM HIỂU VỀ MÁY TÍNH
RASPBERRY PI
Tác giả: Nguyễn Ngọc Hoàng
MỤC LỤC 1. Tổng quan về Raspberry Pi.................................................................................................................... 1
1.1. Raspberry Pi là gì? ........................................................................................................................... 2
1.2. Các mẫu Raspberry Pi. .................................................................................................................... 5
1.3. Cấu trúc của các mẫu Raspberry Pi. .............................................................................................. 8
1.3.1. Cấu trúc của Raspberry Pi mẫu B. .............................................................................................. 9
1.3.1. Cấu trúc của Raspberry Pi mẫu A. ............................................................................................ 12
1.3.3. Cấu trúc của Raspberry Pi mẫu B+. .......................................................................................... 13
2. Cài đặt và sử dụng Rapsberry Pi. ........................................................................................................ 14
2.1. Cài đặt hệ điều hành cho Raspberry Pi. ...................................................................................... 14
2.2. Lệnh Linux cơ bản để sử dụng Raspberry Pi. ............................................................................. 23
2.3. Sử dụng giao diện. .......................................................................................................................... 26
2.4. Điều khiển Raspberry Pi từ xa với phần mềm Putty và SSH Secure Shell Client. .................. 26
3. Tìm hiểu về các chân GPIO của Raspberry Pi. .................................................................................. 32
3.1. GPIO là gì? ..................................................................................................................................... 32
3.2. Sơ đồ chân GPIO của Raspberry Pi. ............................................................................................ 33
3.3. Sử dụng chân GPIO của Raspberry Pi như thế nào? ................................................................. 35
4. Một số ngôn ngữ và thư viện lập trình cho Raspberry Pi. ................................................................ 42
4.1. Ngôn ngữ lập trình Python và thư viện lập trình RPi.GPIO. .................................................... 42
4.1.1. Ngôn ngữ lập trình Python. ....................................................................................................... 42
4.1.2. Thư viện lập trình RPi.GPIO. ................................................................................................... 52
4.2. Ngôn ngữ lập trình C và thư viện lập trình wiringPi. ................................................................ 59
4.2.1. Ngôn ngữ lập trình C. ............................................................................................................... 59
4.2.2. Thư viện lập trình wiringPi. ...................................................................................................... 71
5. Một số bài thực hành ứng dụng Raspberry Pi. .................................................................................. 78
5.1. Bật và tắt đèn LED khi nhấn công tắc điện. ................................................................................ 78
5.2. Nhấp nháy đèn led với số lần nháy và khoảng cách giữa mỗi lần nhấp nháy cho trước. ........ 81
5.3. Tạo ứng dụng đo nhiệt độ và độ ẩm môi trường, sử dụng Raspberry Pi và cảm biến nhiệt độ,
độ ẩm - DHT11. ..................................................................................................................................... 84
5.3.1. Một số lý thuyết. ....................................................................................................................... 84
5.3.2. Thực hành. ................................................................................................................................ 91
1
LỜI MỞ ĐẦU
Hiện nay, có nhiều mẫu máy tính kích thước rất nhỏ, thậm chí chỉ bằng kích thước
một tấm thẻ tín dụng như Raspberry Pi, Hummingboard hay Arduino. Tuy cấu hình
thấp nhưng các máy tính này có thể thực hiện hầu hết các công việc mà một máy tính
thông thường có thể làm được, có thể chơi game, nghe nhạc, xem phim hay lập trình,
thậm chí có thể liên kết với nhiều máy tính cùng loại để tạo thành một siêu máy tính.
Phổ biến nhất trong các mẫu máy tính nhỏ gọn này có thể kể đến Raspberry Pi với
giá chỉ từ 35 đến 60 USD. Chúng ta có thể sử dụng Raspberry Pi để giải trí, học tập hoặc
nghiên cứu. Với RAM 512M, Raspberry Pi có thể cài đặt và vận hành ổn định hệ điều
hành Linux, bộ xử lý đồ họa hỗ trợ chơi game rất tốt và có thể trình chiếu video ở độ
phân giải full HD, 26 chân GPIO có thể sử dụng để lập trình điều khiển các thiết bị cơ
khí, điện tử, phục vụ nghiên cứu các dự án khoa học.
Bộ tài liệu này sẽ giúp các bạn tìm hiểu và làm quen với máy tính Raspberry Pi,
giúp các bạn có kiến thức cơ bản và cái nhìn tổng quan với Raspberry Pi. Các phần trong
tài liệu sẽ giúp các bạn nắm được lý thuyết về cấu trúc, phân loại, cách cài đặt và sử dụng
Raspberry Pi, tài liệu còn hướng dẫn các bạn thực hành một các bài tập sử dụng các chân
GPIO để để điều khiển thiết bị điện tử, giúp các bạn có cơ sở để nghiên cứu khoa học.
Nội dung tài liệu được trích dẫn, sưu tầm và trình bày theo quá trình nghiên cứu,
tìm hiểu của tác giả, do đó sẽ không tránh khỏi sai xót, rất mong nhận được ý kiến đóng
góp của các bạn độc giả! Mọi ý kiến đóng góp, xin vui lòng gửi về địa chỉ email
Xin chân thành cảm ơn!
2
1. Tổng quan về Raspberry Pi.
1.1. Raspberry Pi là gì?
Raspberry Pi (viết tắt là RPi) là một máy vi tính nhỏ, giá rẻ, kích thước chỉ bằng
một thẻ tín dụng, tiết kiệm điện năng (vì nguồn điện cung cấp cho RPi chỉ có 5V). RPi
được sử dụng giống như một máy vi tính thông thường khi đã được kết nối với một màn
hình máy vi tính hay màn hình tivi qua cáp HDMI hoặc jack video analog, người dùng
tương tác với RPi thông qua bàn phím và chuột usb.
Hình 1.1: Máy tính Raspberry Pi với kích thước chỉ bằng kích thước của thẻ tín dụng.
3
Hình 1.4: Đầu sạc microUSB dùng để nạp nguồn điện cho RPi.
Hình 1.3: Jack cắm Vedeo Analog để
kết nối RPi với màn hình tivi đời cũ,
không có hỗ trợ cổng HDMI.
Hình 1.2: Cáp HDMI to HDMI
dùng để kết nối RPi với màn hình
tivi LCD có hỗ trợ cổng HDMI.
4
Máy tính RPi khi mới mua về chỉ là một bo mạch, muốn RPi trở thành máy tính
thực thụ, chúng ta phải kết nối RPi với các thiết bị ngoại vi như màn hình, bàn phím và
chuột thông qua các cổng kết nối trên bo mạch, sau đó cung cấp nguồn điện cho RPi bằng
cách cắm sạc microUSB 5V vào RPi. Trong phần cấu trúc RPi, sẽ trình bày chi tiết về các
cổng kết nối của RPi. Khi đã được kết nối đầy đủ các thiết bị ngoại vi, RPi sẽ trở thành
một máy tính giống như trong hình bên dưới.
Hình 1.5: RPi được kết nối đầy đủ với bàn phím, chuột, mà hình tạo thành một bộ vi tính
nhỏ gọn chỉ với nguồn điện 5V.
RPi là một thiết bị nhỏ cho phép mọi người ở mọi lứa tuổi có thể tìm hiểu, khám
phá máy vi tính, học lập trình với các ngôn ngữ lập trình như Python hoặc C. RPi sử dụng
hệ điều hành Linux và có thể làm được gần như tất cả mọi thứ mà một máy vi tính thông
thường có thể làm.
RPi được sử dụng cho rất nhiều các dự án khoa học và học tập. RPi có thể kết nối
với nhiều loại thiết bị ngoại vi và tương tương tác với thế giới bên ngoài. Chẳng hạn như
RPi được sử dụng để tạo thành một trạm đo thời tiết thông qua các cảm biến nhiệt độ,
cảm biến đo độ ẩm, máy đo mưa được kết nối với các chân GPIO trên bo mạch của RPi.
RPi có thể sử dụng để học tập, nghe nhạc, chơi game và RPi có thể tạo ra một siêu máy
tính bằng cách ghép nhiều RPi lại với nhau…
5
1.2. Các mẫu Raspberry Pi.
Cho đến thời điểm hiện tại (08/2014), RPi có 3 mẫu chính, đó là: RPi model A,
RPi model B và RPI model B+.
Về cơ bản, phần lớn cấu trúc của 3 mẫu này giống nhau. Tuy nhiên, mỗi mẫu RPi
lại có một số điểm khác biệt:
- RPi model A: RAM chỉ có dung lượng 256MB, chỉ có một cổng USB,
không có cổng Ethernet (dùng để kết nối dây cáp mạng), có 26 chân GPIO.
- RPi model B: Có 2 cổng USB và một cổng Ethernet (kết nối mạng LAN),
có 26 chân GPIO. Model B lại có 2 phiên bản khác nhau. Về cơ bản, 2 phiên bản này
giống nhau, chỉ khác ở dung lượng bộ nhớ RAM.
+ RPi model B v1: RAM có dung lượng 256MB.
+ RPi model B v2: RAM có dung lượng 512MB.
- RPi model B+: Mẫu B+ có sự cải tiến về cổng kết nối cũng như số lượng
chân GPIO. Ở mẫu B+ này, RPi có 4 cổng USB (nhiều hơn model B 2 cổng, nhiều hơn
model A 3 cổng) giúp tăng khả năng kết nối thiết bị ngoại vi, có đến 40 chân GPIO
(nhiều hơn 13 chân so với model A và model B). Ngoài ra, mẫu B+, ngõ video và ngõ
audio được tích hợp thành một cổng duy nhất (thay vì hai cổng riêng biệt như model A và
model B).
Hình 1.6: Tạo mạch đèn LED
nhấp nháy với RPi.
Hình 1.7: Robot mini đơn giản
vận hành bởi máy tính RPi.
6
Hình 1.8: Raspberry model A và Raspberry model B.
Hình 1.9: Raspberry model B+ và Raspberry model B.
7
RPi được sản xuất ở hai nước chính là Anh và Trung Quốc, để phân biệt được xuất
xứ của RPi có thể dựa trên hình dạng, giao diện cũng như thông tin trên bo mạch để nhận
dạng. Trên các con RPi model B v2, với xuất xứ khác nhau sẽ có hình dạng khác nhau.
Ngoài ra, có thể nhận biết thông tin xuất xứ trên bo mạch, nếu trên bo mạch có in
dòng chữ “Made in the UK” thì RPi được sản xuất ở Anh, nếu không có thông tin này
hoặc có in thông tin “Made in China” nghĩa là RPi được sản xuất ở Trung Quốc. Có thể
phân biệt qua hình bên dưới.
Hình 1.10: Phân biệt Raspberry Pi model B v2 xuất xứ ở Anh hoặc Trung Quốc.
8
Với các RPi với bo mạch có màu đỏ cũng là RPi Trung Quốc.
Hình 1.11: RPi xuất xứ Trung Quốc.
1.3. Cấu trúc của các mẫu Raspberry Pi.
Như đã trình bày trong phần “các dòng RPi”, mỗi dòng đều có một cấu trúc riêng,
tuy nhiên, về căn bản, chúng khác nhau không nhiều, gần như có cấu trúc giống nhau.
9
1.3.1. Cấu trúc của Raspberry Pi mẫu B.
Hình 1.12: Cấu trúc Raspberry Pi model B v2.
Cấu trúc của một RPi model B v2 gồm các thành phần:
- Trung tâm xử lý, chip SOC (System On Chip - hệ thống với nhiều bộ
phận tích hợp trên một con chip) Broadcom BCM2835 tích hợp một CPU (bộ xử lý
trung tâm), một GPU (Bộ xử lý đồ họa) và một RAM dung lượng 512MB, có thể chạy hệ
điều hành Linux. Bộ phận xử lý đồ họa GPU được tích hợp trên chip có thể hỗ trợ chơi
game rất mạnh và phát được video ở độ phân giải Full HD.
- Cổng HDMI được sử dụng để để kết nối mới màn hình tivi hay màn hình
máy tính có hỗ trợ cổng HDMI thông qua một dây cáp HDMI. Kết nối qua cổng HDMI
truyền cả hình ảnh và âm thanh.
10
- Cổng RCA Video được sử dụng để kết nối RPi với các màn hình tivi đời
cũ không hỗ trợ cổng HDMI. Kết nối qua cổng RCA video chỉ truyền hình ảnh.
- Cổng nguồn micro USB là nơi tiếp nhận nguồn điện từ bên ngoài để
cung cấp điện cho hệ thống hoạt động. Nguồn điện cung cấp cho RPi được khuyến cáo ở
mức 5V, đối với RPi model B nguồn điện cung cấp tối thiểu phải ở mức 700-1200mV.
Có thể sử dụng sạc điện thoại để cung cấp điện cho RPi.
- Khe cắm thẻ SD dùng để kết nối thẻ nhớ SD. RPi không ở đĩa cứng tích
hợp sẵn trên bo mạch như máy tính thông thường, do đó, hệ điều hành của RPi sẽ được
cài đặt trên một thẻ SD, và mọi dữ liệu của RPi cũng được lưu trữ trên thẻ SD này. Hệ
điều hành Linux hoạt động trên thẻ SD, do đó, thẻ SD cần có kích thước tối thiểu là 4GB,
và dung lượng hỗ trợ tối đa là 32GB.
- Cổng Ethernet dùng để kết nối internet thông qua cáp RJ45, chỉ cần cắm
cáp vào cổng, chúng ta đã có thể truy cập internet dễ dàng.
- Cổng USB. RPi model B tích hợp sẵn 2 cổng USB 2.0, có thể sử dụng để
kết nối với bàn phím, chuột usb hoặc có thể kết nối USB 3G để truy cập internet. Vì RPi
chạy hệ điều hành Linux, nên chỉ cần cắm bàn phím và chuột vào là có thể sử dụng mà
không cần cài thêm driver.
- Ngõ audio 3.5mm có thể kết nối với headphone (tai nghe) hoặc loa ngoài
quấ jack cắm. Khi sử dụng kết nối qua cổng HDMI, chúng ta không cần sử dụng ngõ
audio vì ngõ âm thanh đã được tích hợp theo đường tín hiệu HDMI.
- Các đèn LED thể hiện trạng thái hoạt động của RPi. Các đèn LED trên
RPi có ý nghĩa như sau:
+ ACT - D5 (xanh lá): Đã truy cập thẻ nhớ SD.
+ PWR - D6 (màu đỏ): Nguồn điện 3.3V sẵn sàng.
+ FDX - D7 (xanh lá): Đã kết nối internet (LAN).
+ LNK - D8 (xanh lá): Các liên kết, kết nối (LAN).
+ 100 - D9 (màu vàng): Đã kết nội mạng 100Mbit (LAN).
- Các ngõ GPIO (Genaral Purpose Input Output) dùng để kết nối với các
thiết bị cơ khí, điện tử phục vụ cho nhiều mục đích khác nhau. (Trong phần sơ đồ chân
GPIO sẽ trình bày rõ hơn về vấn đề này).
11
Hình 1.13: Raspberry Pi model B v2.
12
1.3.1. Cấu trúc của Raspberry Pi mẫu A.
Về cơ bản, cấu trúc của RPi mẫu A giống như RPi mẫu B, chỉ khác ở chỗ RPi mẫu
A không có cổng kết nối cáp mạng LAN, muốn truy cập internet phải thông qua USB 3G.
Một điểm khác biệt nữa là, bộ nhớ RAM của RPi mẫu A chỉ có 256MB, còn RPi mẫu B
có dung lượng bộ nhớ RAM là 512MB.
Hình 1.14: Raspberry Pi model A chỉ có 1 cổng USB và không có cổng kết nối cáp RJ45.
13
1.3.3. Cấu trúc của Raspberry Pi mẫu B+.
Nhìn chung, RPi mẫu B+ cũng có các thành phần tương tự như RPi mẫu B. Tuy
nhiên, như đã trình bày trong phần các mẫu RPi, cấu trúc của RPi mẫu B+ có cải tiến về
cổng kết nối và số lượng chân GPIO. RPi mẫu B+ có thêm 2 cổng kết nối USB, có đến
40 chân GPIO (nhiều hơn 14 chân so với các mẫu RPi trước đó). Ngõ audio và ngõ
video đã được tích hợp lại thành một ngõ duy nhất trên RPi mẫu B+, thay vì hai ngõ riêng
biệt trên như trên RPi mẫu A và mẫu B. Ngoài ra, khe cắm thẻ nhớ SD được thay đổi
thành khe cắm thẻ microSD dạng nhấn thả để cắm thẻ vào hoặc lấy thẻ ra.
Hình 1.15: RPi mẫu B+ có sự cải tiển về cổng kết nối và số lượng chân GPIO.
14
2. Cài đặt và sử dụng Rapsberry Pi.
Như đã trình bày trong phần cấu trúc RPi, các RPi không có ổ cứng tích hợp trên
bo mạch, do đó, hệ điều hành (viết tắt HĐH) của RPi được cài đặt trên một thẻ nhớ SD.
Để cài đặt HĐH cho RPi, chúng ta sử dụng NOOBS (New Out Of the Box Software), là
một trình quản lý cài đặt HĐH cho RPi.
Hiểu một cách nôm na, NOOBS là một gói, trong gói này có chứa các HĐH để cài
đặt cho RPi. Cụ thể, trong NOOBS có chứa các HĐH là Raspbian (dựa trên HĐH
Debian), Pidora (dựa trên HĐH Fedora), Openelec, Raspbmc, Risc OS và Arch Linux.
Thông thường, người mới sử dụng RPi nên cài đặt HĐH Raspbian hoặc Pidora, vì hai
HĐH này dễ tiếp cận nhất.
2.1. Cài đặt hệ điều hành cho Raspberry Pi.
Trong phần này, chúng ta sẽ cài đặt HĐH Raspbian lên RPi model B v2.
Để cài đặt HĐH cho RPi, chúng ta phải sử dụng gói NOOBS. Cách dễ dàng nhất
để sử dụng NOOBS là mua một thẻ SD đã cài đặt sẵn NOOBS từ nhà phân phối. Nếu
không mua thẻ SD đã cài đặt NOOBS, với một thẻ SD trống (tối thiều 4GB, tốt nhất là
8GB), chúng ta có thể tải miển phí và cài đặt NOOBS lên thẻ.
Để cài đặt hệ điều hành cho RPi, thực hiện theo quy trình sau:
- Tải NOOBS từ internet.
1. Truy cập địa chỉ web http://www.raspberrypi.org/downloads/
2. Click vào nút Download ZIP bên dưới NOOBS (Offline and
network install). Chọn vị trí và lưu tập tin.
Lưu ý: có 2 gói NOOBS khác nhau, một gói NOOBS và NOOBS
LITE. Gói NOOBS có thể cài đặt HĐH cho RPi mà không cần đến kết nối internet, vì
bản thân NOOBS đã có đầy đủ các phiên bản mỗi HĐH nằm trong nó. Còn gói NOOBS
LITE yêu cầu phải có kết nối internet để tải HĐH được chọn cài đặt.
15
Hình 2.1: Tải NOOBS từ internet.
3. Sau khi tải về hoàn tất, chúng ta có gói NOOBS_version.zip
(trong đó, version là phiên bản của gói NOOBS, ở đây version là v1_3_8). Giải nén gói
zip này, ta sẽ có các thư mục và tập tin con như trong hình 2.2.
Hình 2.2: Các thư mục và tập tin con được giải nén từ gói NOOBS_v1_3_8.zip.
16
- Định dạng (format) thẻ nhớ SD.
1. Truy cập địa chỉ web
https://www.sdcard.org/downloads/formatter_4/eula_windows/
Kéo màn hình xuống cuối trang, sau đó click nút I Accept chọn vị trí lưu (Ví dụ
D:\software\) nhấn Save để lưu tập tin.
2. Sau khi tải về hoàn tất, chúng ta có gói SDFormatterv4.zip, giải
nén gói zip này sẽ được một tập tin setup.exe. Cài đặt SD Formatter 4.0 cho desktop
(hoặc laptop) bằng cách nhấp đúp vào tập tin setup.exe vừa giải nén xong. Sau khi cài
đặt xong SD Formatter 4.0, khởi chạy chương trình.
3. Kết nối thẻ SD với máy vi tính qua đầu đọc thẻ SD, chú ý ký tự
đại diện cho thẻ (ví dụ như D, G hay H …).
4. Từ chương trình SD Formatter, chọn ký tự đại diện cho thẻ SD từ
danh sách chọn Drive và nhấn Format để định dạng thẻ SD đó, tiếp theo, hai hộp thoại
sẽ xuất hiện, tất cả đều chọn OK.
Hình 2.3: Format thẻ SD với SD Formatter 4.0.
- Sao chép các tập tin của NOOBS vào thẻ SD.
1. Sau khi thẻ SD đã được định dạng, sao chép tất cả các tập tin đã
được giải nén từ gói NOOBS_v1_3_8.zip vào thẻ nhớ SD.
17
2. Sau khi sao chép hoàn tất các tập tin, tắt thẻ nhớ SD bằng cách
nhấn chuột phải lên ký tự đại diện thẻ SD, sau đó nhấn Eject, lấy thẻ nhớ khỏi máy tính
và kết nối thẻ nhớ với RPi qua khe cắm thẻ SD.
- Cài đặt HDDH Raspbian.
1. Chuẩn bị một sạc điện thoại microUSB, một cáp HDMI (hoặc
jack cắm RCA) một bàn phím và một chuột usb. Kết nối bàn phím và chuột qua 2 cổng
usb 2.0 trên RPi, kết nối RPi đến một màn hình TV qua cáp HDMI hoặc jack cắm RCA.
* Lưu ý: Chưa được cắm sạc vào thời điểm này. RPi không có nút
bật tắt nguồn giống máy vi tính thông thường. RPi được bật và khởi động khi bắt đầu
được cắm nguồn vào. Khi nguồn vừa cắm RPi, máy tính sẽ khởi động ngay, do đó, nên
kết nối đầy đủ các thiết bị cần thiết (quan trọng nhất là thẻ SD) trước cắm nguồn vào.
2. Sau khi chuẩn bị đầy đủ các thiết bị, kết nối chúng với RPi. Trước
tiên, kết nối RPi với một màn hình tivi hoặc một màn hình máy tính bàn.
- Để kết nối RPi với màn hình tivi có hỗ trợ ngõ HDMI (hình 2.4),
sử dụng một cáp HDMI to HDMI (hình 2.5), một đầu cáp cắm vào ngõ HDMI trên tivi,
đầu còn lại cắm và khe cắm HDMI trên RPi.
- Nếu không có màn hình tivi hỗ trợ ngõ HDMI, chúng ta có thể
dùng một màn hình máy tính bàn (hình 2.6), nhưng chúng ta cần một cáp chuyển đổi
HDMI to VGA (hình 2.7).
Hình 2.4: Màn hình tivi có hỗ trợ
khe cắm HDMI, kết nối một đầu
cáp HDMI với khe này.
Hình 2.5: Cáp HDMI to HDMI
dùng để kết nối RPi vơi màn hình
tivi hỗ trợ khe cắm HDMI .
18
- Kết nối đầu HDMI của cáp chuyển đổi đến RPi, đầu còn lại của
cáp chuyển đổi kết nối với một đầu của cáp VGA (hình 2.8), đầu còn lại của cáp VGA
được kết nối với màn hình máy tính bàn.
Hình 2.6: Màn hình máy tính bàn,
có thể kết nối với RPi thông qua
cáp chuyển đổi HDMI to VGA.
Hình 2.7: Cáp chuyển đổi từ ngõ
HDMI sang VGA, dùng để kết nối
RPi với màn hình máy tính bàn.
Hình 2.8: Cáp VGA dùng để kết
nối với màn hình máy tỉnh để bàn.
Hình 2.9: Cáp chuyển đối HDMI
to VGA và cáp VGA dùng để kết
nối màn hình máy tính bàn.
19
Hình 2.10: Kết nối RPi tới màn hình máy tính bàn thông cáp chuyển đổi HDMI to VGA
và cáp VGA.
- Sau khi kết nối xong RPi với màn hình, tiếp theo, chúng ta kết nối
bàn phím và chuột USB với RPi qua 2 cổng USB trên RPi và kết nối cáp mạng vào cổng
mạng trên RPi. Kết nối xong, chúng ta sẽ có được bộ máy tính hoàn chỉnh như hình 2.11.
20
Hình 2.11: RPi đã được kết nối hoàn tất, chỉ cần cắm sạc điện 5V là có thể hoạt động.
3. Cắm sạc microUSB để cung cấp nguồn điện và khởi động RPi.
Khi RPi khởi động, một cửa sổ hiện ra với danh sách các hệ điều hành có thể cài đặt cho
RPi, chọn Raspbian click Install chọn Yes chờ đến khi cài đặt hoàn tất.
21
Hình 2.12: Chọn hệ điều hành Raspbian và click Install để cài đặt HĐH cho RPi.
4. Khi HĐH Raspbian được cài đặt xong, một hộp thoại thông báo
hiện ra báo cài đặt thành công, nhấn OK để tiếp tục thiết lập cho RPi.
Hình 2.13: Hộp thoại báo cài đặt thành công, nhấn OK để tiếp tục.
22
5. Sau khi nhấn OK, RPi tự động chạy một số thiết lập mặc định của
hệ thống, sau đó, một danh sách các danh mục cấu hình cho RPi sẽ hiện ra.
Hình 2.14: RPi tự thiết lập các cấu hình mặc định.
Hình 2.15: Danh mục cấu hình hệ thống cho RPi.
6. Trong danh sách các thiết lập này, chúng ta có thể thiết lập ngày
giờ, kích hoạt RPi camera, thay đổi mật khẩu của người dùng. Mặc định, sau khi cài đặt
23
xong HĐH Raspbian có người dùng là pi và mật khẩu là raspberry, để thay đổi mật
khẩu cho người dùng pi, chọn Change User Password nhấn phím Enter nhấn
phím Enter lần nữa nhập mật khẩu mới lần 1 nhập mật khẩu mới lần 2 và nhấn
phím Enter.
* Lưu ý: Khi nhập mật khẩu, sẽ không có bất cứ ký tự nào hiện lên
màn hình khi nhấn phím, vì mặc định linux sẽ không hiển thị mật khẩu khi người dùng
nhập ký tự (đây là một trong số những tính năng bảo mật của Linux). Do đó, khi nhập
mật khẩu phải đảm bảo tính chính xác của mỗi ký tự nhập vào.
7. Sau khi thiết lập tất cả cho RPi, chọn Finish để kết thúc quá trình
cài đặt. RPi sẽ tự động đăng nhập vào hệ thống với người dùng pi và mật khẩu là
raspberry (chỉ duy nhất lần đầu tiên sau khi cài đặt hệ thống, từ lần thứ hai, người dùng
phải đăng nhập bằng tay).
Hình 2.16: Màn hình sau khi kết thúc cài đặt.
Như vậy, chúng ta đã cài đặt xong hệ điều hành Raspbian cho RPi model B v2.
Để xóa màn hình và thiết lập lại màn hình, gõ lệnh reset.
Để chuyển sang giao diện đồ họa từ giao diện dòng lệnh, gõ lệnh startx. (Đối với
HĐH Pidora, gõ lệnh startxfce4)
Để khởi động lại RPi, gõ lệnh sudo reboot.
Để tắt hẳn RPi, gõ lệnh sudo shutdown –h now.
2.2. Lệnh Linux cơ bản để sử dụng Raspberry Pi.
Dòng lệnh là một thế mạnh của HĐH Linux, vì nếu chúng ta thành thạo lệnh
Linux, sử dụng lệnh giúp hệ thống chay nhanh, mạnh mẽ (vì hệ thống ít tiêu tốn tài
24
nguyên cho các giao diện, hình ảnh …) hơn nhiều so với sử dụng giao diện đồ họa, đồng
thời, thể hiện sự chuyên nghiệp của người dùng.
Trong phần này, chúng ta sẽ tìm hiểu một số lệnh cơ bản, thông dụng trên Linux
để có thể thao tác, thực hiện công việc. Để biết thêm các lệnh linux khác, có thể tìm kiếm
trên internet.
Lệnh Ý nghĩa và ví dụ
man - manual guide Hiển thị thông tin hướng dẫn sử dụng lệnh trên Linux.
Ví dụ: Để xem cách sử dụng lệnh shutdown, ta gõ lệnh
man shutdown
startx Khởi chạy giao diện đồ họa từ giao diện dòng lệnh.
ls - listing Liệt kê tất cả tập tin và thư mục tại vị trí hiện hành.
Ví dụ: Trong thư mục hiện tại là /opt có 2 tập tin excel, để
liệt 2 tập tin này lên giao diện dòng lệnh, gõ lệnh ls - la
cd - change directory Chuyển đến vị trí thư mục khác.
Ví dụ: Đang ở vị trí root / muốn chuyển sang thư mục
/opt, gõ lệnh cd /opt
mkdir - make directory Tạo thư mục, giống New Folder trong Windows
Ví dụ: Muốn tạo một thư mục mới tên hoang, gõ lệnh
mkdir hoang
rmdir - remove directory Xóa một thư mục.
Ví dụ: Muốn xóa thư mục /opt/hoang đã tạo, gõ lệnh
rmdir hoang
* Lưu ý, lệnh rmdir chỉ xóa được thư mục trống, với các
thư mục có chứa thư mục con hoặc tập tin, để xỏa được
thư mục, gõ lệnh rm - rf tenthumuc
mv - move Di chuyển hoặc đổi tên thư mục hay tập tin.
Ví dụ: Để di chuyển tập tin test.txt từ thư mục /opt sang
thư mục /user/hoang, gõ lệnh
move /opt/test.txt /user/hoang/test.txt
Nếu muốn vừa di chuyển vừa đổi tên thư mục, gõ lệnh
move /opt/test.txt /user/hoang/ten_moi.txt
25
rm - remove Xóa một tập tin.
Ví dụ: Để xóa tập tin test.txt trong thư mục /user/hoang/
gõ lệnh rm /user/hoang/test.txt
pwd - print working directory In ra màn hình đường dẫn vị trí hiện tại mà người dùng
đang ở đó.
gedit Mở một tập tin với trình soạn thảo gedit hoặc tạo mới tập
tin văn bản.
Ví dụ: Muốn chỉnh sửa file test.txt trong thư mục
/user/hoang/ gõ lệnh gedit /user/hoang/test.txt
sudo shutdown -h now Tắt hệ điều hành ngay lập tức, không quan tâm đến các
tiến trình đang hoạt động. Với tính bảo mật của Linux,
một số lệnh phải có quyền root mới có thể thực thi. Trong
Raspbian, để thực thi với quyền root, sử dụng lệnh sudo
trước đầu mỗi dòng lệnh, sau khi enter, hệ thống sẽ yêu
cầu mật khẩu. Ví dụ sudo reboot. Sau khi gõ lệnh sudo
một lần, trong khoản thời gian 15 phút, có thể sử dụng các
lệnh với quyền root mà không cần sử dụng lệnh sudo nữa.
sudo reboot Khởi động lại hệ điều hành, giống restart trong Windows
sudo apt-get install Cài đặt một gói ứng dụng từ internet. Hệ thống sẽ tự tìm
đến các kho chứa gần nhất để tải và cài đặt ứng dụng.
Ví dụ: Để cài đặt trính soạn thảo văn bản vim cho hệ điều
hành, gõ lệnh sudo apt-get install vim
sudo apt-get remove Gỡ bỏ một gói ứng dụng.
Ví dụ: Để gỡ bỏ trình soạn thảo văn bản vim đã cài đặt, gõ
lệnh sudo apt-get remove vim
sudo apt-get purge Gỡ bỏ hoàn toàn gói ứng dụng, kể cả các cấu hình và nhật
ký (log) trên hệ điều hành.
Ví dụ: Để gỡ bỏ hoàn toàn trình soạn thảo văn bản vim,
gồm cả setting và log, gõ lệnh sudo apt-get remove vim
sudo apt-get update Cập nhật các gói ứng dụng mới nhất cho hệ điều hành.
sudo apt-get upgrade Nâng cấp các gói ứng dụng lên phiên bản mới nhất.
sudo apt-get autoremove Quét và xóa những gói ứng dụng không dùng đến.
Bảng 2.1: Các lệnh Linux thông dụng.
26
2.3. Sử dụng giao diện.
Ở giao diện đồ họa, mọi thứ sẽ trở nên trực quan, dễ nhìn hơn rất nhiều so với
dong lệnh. Đối với những người dùng mới, nên sử dụng giao diện dòng lệnh.
Từ giao diện dòng lệnh, để vào được giao diện đồ họa, chúng ta gõ lệnh startx (với
HĐH Pidora, gõ lệnh startxfce4), hệ thống sẽ tải giao diện đồ họa và người dùng có thể
tương tác với RPi bằng chuột bằng cách click lên các giao diện, cửa sổ.
Hình 2.17: Giao diện đồ họa, màn hình Desktop của hệ điều hành Raspbian trên RPi.
2.4. Điều khiển Raspberry Pi từ xa với phần mềm Putty và SSH Secure Shell Client.
Vì RPi là một máy tính không hoàn chỉnh, nghĩa là, muốn vận hành được RPi,
phải kết nối RPi với đầy đủ các thiết bị cần thiết, đôi khi tạo sự bất tiện khi muốn thao tác
với RPi vì người thường xuyên di chuyển.
Để có thể thao tác với RPi mọi lúc, mọi nơi mà không cần phải di chuyển RPi,
chúng ta có thể sử dụng một trong hai phần mềm là Putty hoặc SSH Secure Shell Client
để kết nối và điều khiển RPi, chỉ cần chúng ta biết địa chi IP, user và password để kết
nối RPi.
27
Để biết được địa chỉ IP của của RPi, từ cửa sổ dòng lệnh, gõ lệnh sudo ifconfig,
sau đó nhấn phím Enter trên bàn phím.
Hình 2.18: Sử dụng lệnh sudo ifconfig để kiểm tra địa chỉ IP của RPi.
Sau khi dùng lệnh ifconfig, ta có được địa chỉ IP của RPi, sử dụng địa chỉ IP này
nhập vào phần mềm Putty hoặc SSH Secure Shell Client để kế nối đế RPi từ máy tính
khác.
Để điều khiển RPi bằng phần mềm Putty, chạy phần mềm Puty nhập địa chỉ IP
của RPi chọn Open nhập user và password của RPi.
28
Hình 2.19: Kết nối tới RPi với phần mềm Putty.
Hình 2.20: Putty đã kết nối với RPi sau khi nhập user và password.
Khi đã kết nối tới RPi, từ giao diện dòng lệnh của phần mềm Putty, chúng ta có
thể điểu khiển RPi bằng lệnh giống như khi thao tác trên RPi thực sự.
Để sử dụng Putty trên desktop (hoặc lapop), tải Putty tại địa chỉ :
http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html
29
Sau đó, chọn putty.exe để tải putty về máy. Khi đã tải xuống hoàn tất, chỉ cần
nhấp đúp chuột lên tập tin putty.exy để chạy putty mà không cần phải cài đặt.
Nếu không dùng Putty, chúng ta có thể dùng phần mềm SSH Secure Shell Client.
Phần mềm này cũng tương tự như Putty, chỉ cần nhập IP, user và password của RPi vào
và kết nối tương tự. Tuy nhiên, để sử dụng được SSH Secure Shell Client, phải cài đặt lên
máy tính.
Có thể tải SSH Secure Shell Client tại địa chỉ:
ftp://ftp.nl.freebsd.org/vol/2/ssh/SSHSecureShellClient-3.2.9.exe
Sau khi tải về, nhấp đúp lên tập tin SSHSecureShellClient-3.2.9.exe để cài đặt.
Khi cài đặt xong, SSH Secure Shell Client sẽ gồm hai chương trình, một chương trình là
SSH Secure Shell– dùng để điều khiển RPi bằng thao tác lệnh, một chương trình là SSH
Secure File Transfer– dùng để chép dữ liệu từ RPi vào desktop (hoặc laptop) và ngược
lại.
Để điều khiển RPi bằng SSH Secure Shell Client, mở chương trình SSH Secure
Shell Cient chọn Quick Connect.
Hình 2.21: Chương trình SSH Secure Shell dùng để điều khiển RPi bằng lệnh.
Một hộp thoại hiện ra, nhập địa chỉ IP vào ô Host Name nhập user của RPi
vào ô User Name chọn Connect để bắt đầu kết nối đến RPi.
Hình 2.22: Nhập IP và user của RPi để kết nối đến RPi.
30
Một hộp thoại mới hiện ra, chọn Yes Chọn Yes thêm lần nữa nhập
password vào ô Password nhấn OK đề hoàn tất kết nối.
Hình 2.23: Nhập mật khẩu để xác nhận kết nối.
Hình 2.24: SSH Secure Shell đã kết nối đến RPi.
Khi đã kết nối tới RPi, từ giao diện dòng lệnh của phần mềm SSH Secure Shell,
chúng ta có thể điểu khiển RPi bằng lệnh giống như khi thao tác trên RPi thực sự.
Để chép dữ liệu từ RPi sang desktop (hoặc laptop) và ngược lại, chúng ta sử dụng
chương trình SSH Secure File Transfer, cách kết nối đến RPi cũng giống hệt như cách
kết nối đến RPi của chương trình SSH Secure Shell.
Sau khi kết nối đến RPi, một cửa sổ hiển thị, cửa sổ này chia làm hai bên, bên trái
là hệ thống tập tin, thư mục của desktop (hoặc laptop), bên phải là hệ thống tập tin, thư
mục của RPi. Chỉ cần chọn thư mục hoặc tập tin từ bên này, sau đó, giữ chuột và kéo
sang bên kia và thả ra là có thể chép dữ liệu sang bên kia, và ngược lại.
31
Hình 2.25: SSH Secure File Transfer dùng để chuyển dữ liệu giữa RPi với desktop.
Trong hình 2.25 ở trên, để chọn nơi chứa dữ liệu trên RPi hoặc trên desktop
(laptop), trong hai ô được tô viền đỏ, chúng ta có thể chọn đường dẫn đến nơi chứa dữ
liệu cần thiết. Ô viền đỏ bên phải dùng để chọn đường dẫn trên desktop (hoặc laptop). Ô
viền đỏ bên phải dùng để chọn đường dẫn trên RPi.
Như vậy, với phần mềm Putty và phần mềm SSH Secure Shell Client, chúng ta có
thể kết nối và thao tác trên RPi mà không cần phải làm việc trực tiếp trên RPi, giúp công
việc tiện lợi hơn rất nhiều.
32
3. Tìm hiểu về các chân GPIO của Raspberry Pi.
3.1. GPIO là gì?
Hình 3.1: Các chân GPIO trên Raspberry Pi model B v2.
GPIO là từ viết của General Purpose Input/Output, là các chân (pin) trên một
header có thể dùng làm ngõ vào – input pin hoặc ngõ ra – output pin, phụ thuộc vào
cách thiết lập của người điều khiển, có thể được điều khiển thông qua phần mềm.
Ví dụ: Khi thực hiện bật/tắt đèn led, một chân GPIO (chẳng hạn chân
GPIO7) của RPi được kết nối chân dài của đèn led, chân này có nhiệm vụ truyền một
nguồn điện 3V vào đèn led, làm đèn led phát sáng. Như vậy, chân GPIO này (GPIO7)
được thiết lập là ngõ ra – output.
Ví dụ: Khi kết nối cảm biến đo nhiệt độ và độ ẩm ASONG DHT22 với RPi,
chân thứ nhất của DHT22 kết nối với chân 3.3V của RPi (như trong hình 3.2), chân thứ
hai của DHT22 kết nối với chân GPIO (chẳng hạn chân GPIO7) của RPi, chân thứ tư của
DHT22 kết nối với chân Ground (0V) của RPi. Khi chương trình lập trình trước cho cảm
biến DHT22 hoạt động, chân GPIO7 sẽ nhận dữ liệu nhiệt độ, độ ẩm từ chân thứ hai
DHT22 dưới dạng bit dữ liệu. Như vậy, trong trường hợp này, chân GPIO7 lại được thiết
lập là ngõ vào – input.
33
Trên bo mạch của máy tính RPi mẫu A và RPi mẫu B, có 26 chân GPIO nằm trên
một header (ngay bên cạnh cổng cắm RCA video – cổng có màu vàng hoặc xanh da trời),
được chia thành hai hàng, mỗi hàng có 13 chân.
Trên bo mạch của máy tính RPi mẫu B+, có đến 40 chân GPIO (nằm sau hai cổng
cắm usb), cũng được chia thành hai hàng, mỗi hàng 20 chân.
RPi cho phép các thiết bị ngoại vi (như các cảm biến – nhiệt độ, độ ẩm hay thiết bị
điện tử như công tắc, đèn led…) và cách bo mạch mở rộng (như mạch RPi Gertboard)
kết nối và truy xuất CPU thông qua các chân GPIOs.
GPIO là nơi RPi giao tiếp với thế giới bên ngoài thông qua các thiết bị điện tử,
điều khiển được kết nối với các chân GPIO.
3.2. Sơ đồ chân GPIO của Raspberry Pi.
Các mẫu RPi có sơ đồ chân GPIO khác nhau, ở đây, chúng ta chỉ đề cập đến sơ đồ
chân GPIO của RPi mẫu B v2. RPi mẫu B v2 có sơ đồ chân của GPIO được quy định như
trong hình 3.3 bên dưới.
Hình 3.2: Sơ đồ kết nối cảm
biến đo nhiệt độ và độ ẩm
ASONG DHT22 với các chân
GPIO của RPi.
34
Hình 3.3: Sơ đồ chân GPIO của RPi mẫu B v2.
Có nhiều cách đánh số, ký hiệu cho các chân GPIO của RPi. Ở đây, chúng ta chỉ
đề cập đến hai cách đánh số chính, là kiểu BCM và kiểu BOARD.
- Đánh số theo kiểu BCM là cách ký hiệu các chân theo đúng chức năng
của nó. Trong hình 3.3 ở trên, hai cột dọc, ngoài cùng ở hai bên với các ô như GPIO2,
GPIO3, GPIO14, GPIO15, 3V3, Ground… đó là cách đánh số theo kiểu BCM.
+ Ở cách đánh số theo kiểu BCM, như trong hình 3.3, chúng ta thấy
một số chân GPIO được bao lại bởi một viền đỏ và có ký hiệu là I2C, UART, SPI, đó
chính là các chân GPIO có chức năng thay thế (nghĩa là, ngoài khả năng là các ngõ vào
hoặc ngõ ra, các chân này còn có dùng để thực hiện các chức năng khác). Các chức năng
thay thế, chúng ta không thảo luận trong tài liệu này, do đó, các chức năng thay thế này,
chúng ta chỉ cần lướt sơ qua để có cái nhìn tổng quan về GPIO chứ không đi sâu.
- Đánh số theo kiểu BOARD là cách đánh số các chân GPIO dựa trên vị trí
của chân trên header. Trên header của RPi, các chân GPIO được chia làm hai hàng, mỗi
hàng 13 chân. Trong hình 3.3, cột ở giữa có viền đỏ, nền đen, có các vòng tròn đánh số
từ 1 đến 26 chính là cách đánh số theo kiểu BOARD. Mười ba chân hàng bên trái đánh
số là 1, 3, 5, 7, 9, …, 25. Mười ba chân còn lại, hàng bên phải đánh số là 2, 4, 6, 8, 10 …,
26. Trong phần này, chúng ta dùng cách đánh số theo kiểu BOARD.
35
* Lưu ý: Chúng ta cần hiểu được các quy tắc đánh số, ký hiệu chân này để có thể
lập trình và điều khiển chính xác các chân GPIO, đúng với yêu cầu sử dụng.
GPIO của RPi mẫu B v2 có 26 chân, được chia làm hai dãy, mỗi dãy 13 chân, một
dãy gồm các chân đánh số lẽ từ 1–25, một dãy gồm các chân đánh số chẵn từ 2–26 (đánh
số theo mạch – BOARD number).
RPi GPIO gồm có:
- 2 chân có mức điện áp 3.3V (chân 3.3V hoặc chân số 1, chân số 17).
- 2 chân có mức điện áp 5V (chân 5V hoặc chân số 2, chân số 4).
- 5 chân 0V – Ground (chân số 6, 9, 14, 20 và chân số 25).
- 17 chân GPIO (chân số 3, 5, 7, 8, 10, 11, 12, 13, 15, 16, 18, 19, 21, 22, 23,
24, và chân số 26). Trong đó có 8 chân GPIO thường (chân số 7, 11, 12, 13, 15, 16, 18 và
chân số 22) và 9 chân GPIO có chức năng thay thế (chân số 3, 5, 8, 10, 19, 21, 23, 24 và
chân số 26). 9 chân GPIO đặc biệt có chức năng thay thế như sau:
+ I2C: Gồm chân số 3 (GPIO2) và chân số 5 (GPIO3). Đối với RPi
mẫu B v1, thay thế chân số 3 thành GPIO0, chân số 5 thành GPIO1. I2C (Inter-
Integrated Circuit) là một bus nối tiếp 2 dây 2 chiều cung cấp một liên kết truyền thông
giữa các thành phần trên các mạch tích hợp.
+ UART: Gồm chân số 8 và chân số 10. UART (Universal
Asynchronous Receiver/Transmitter - Thu/phát phổ quát không đồng bộ) là một mẫu
phần cứng máy tính phiên dịch dữ liệu giữa hai hình thức truyền tải dữ liệu song song và
tuần tự. Một UART thường là một mạch tích hợp riêng rẽ được sử dụng cho các giao tiếp
tuần tự trên một máy vi tính hoặc cổng nối tiếp thiết bị ngoại vi.
+ SPI: Gồm các chân số 19, 21, 23, 24. SPI (Serial Peripheral
Interface) hay còn gọi là SPI bus (hay bus nối tiếp 4 dây, là giao tiếp cho phép trao đổi
dữ liệu tuần tự giữa hai thiết bị, một thiết bị gọi là master và thiết bị còn lại là slave. SPI
là một bus giao tiếp thường được sử dụng để trao đổi dữ liệu giữa vi điều khiển và những
thiết bị ngoại vi nhỏ như các thanh ghi thay đổi, các cảm biến và các thẻ SD.
Các chân GPIO chịu mức điện áp tối thiểu là 3V, tối đa là 5V. Nếu mức điện áp
nằm ngoài giới hạn này sẽ làm hỏng mạch. Thông thường, chúng ta nên sử dụng một
mạch mở rộng để kết nối với các thiết bị ngoại vi, không nên kết nối trực tiếp các thiết bị,
linh kiện điện tử vào GPIO trên RPi.
3.3. Sử dụng chân GPIO của Raspberry Pi như thế nào?
Các chân GPIO được sử dụng để kết nối với các thiết bị, linh kiện điện tử như điện
trở, đèn led, công tắc, cảm biến…, là nơi RPi giao tiếp với thế giới bên ngoài.
36
Ví dụ: Chúng ta có thể kết nối RPi với một cảm biến nhiệt độ và độ ẩm ASONG
DHT11cùng một điện trở để tạo ứng dụng đo nhiệt độ, độ ẩm môi trường. Ứng dụng này
sẽ được trình bày chi tiết trong bài thực hành phần 5.
Hình 3.4: Sơ đồ lắp ráp RPi với DHT11 và điện trở 10000Ω (Ohm).
Trong phần 5 của tài liệu này, sẽ trình bày một số bài thực hành giúp chúng ta hiểu
rõ hơn và có thể thao tác với các chân GPIO của RPi. Trong phần này, chỉ giới thiệu đến
mọi người một bài thực hành nhỏ, đó là, in ra màn hình một câu thông báo khi chúng ta
nhấn công tắc điện.
Để thực hiện bài này, chúng ta cần chuẩn bị các thiết bị sau:
- 1 máy tính RPi mẫu B v2, 1 sạc nguồn microUSB 5V.
- 1 màn hình desktop, 1 bàn phím usb, 1 chuột usb.
37
- 1 cáp chuyển đổi HDMI sang VGA.
- 1 công tắc điện mini, 2 dây dẫn điện (jumper wire)
Sau khi chuẩn bị đầy đủ, sử dụng dây dẫn điện jumper wire kết nối công tắc mini
với RPi như hình 3.9. Nối một chân của công tắc với chân GPIO số 1 của RPi, chân còn
lại của công tắc nối với chân GPIO số 16 của RPi (theo BOARD numbers).
Hình 3.5: Sạc nguồn microUSB 5V. Hình 3.6: Cáp chuyển HDMI sang VGA.
Hình 3.7: Dây dẫn điện jumper wire. Hình 3.8: Công tắc điện mini.
38
Tiếp theo, chúng ta tiếp tục kết nối nối RPi với màn hình máy tính bàn, bàn phím
usb, chuột usb. Cuối cùng, cắm nguồn điện cho RPi sử dụng sạc điện thoại microUSB 5V
để khởi động RPi.
Hình 3.10: Kết nối RPi với màn hình, chuột usb và bàn phím usb, sạc microUSB 5V.
Hình 3.9: Kết nối công tắc mini với
RPi bằng dây dẫn điện jumer wire.
39
Khi RPi khởi động xong, nhập người dùng là pi rồi nhấn phím Enter, tiếp tục
nhập mật khẩu là raspberry (hoặc mật khẩu của RPi), nhấn phím Enter để đăng nhập
vào hệ thống. Sau đó gõ lệnh reset rồi nhấn phím Enter để xóa màn hình.
Gõ lệnh cd Desktop rồi nhấn phím Enter để chuyển vị trí đến desktop của người
dùng pi trên RPi.
Hình 3.11: Sử dụng lệnh cd để chuyển vị trí đến Desktop của người dùng pi trên RPi.
Gõ lệnh vi congtac.py rồi nhấn Enter để tạo mới tập tin congtac.py.
Hình 3.12: Sử dụng lệnh vi để tạo mới tập tin congtac.py.
Sau khi thực hiện lệnh vi congtac.py, chúng ta đang ở trong tập tin congtac.py, để
có thể nhập ký tự cho tập tin, nhấn phím i trên bàn phím. Sau đó, nhập đoạn mã lệnh
Python sau vào tập tin congtac.py:
import RPi.GPIO as GPIO
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(23,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
print "Xin chao ban! Vui long nhan cong tac dien"
while True:
if(GPIO.input(23)==1):
print "Ban vua nhan cong tac dien "
break
* Lưu ý: Khoảng cách và xuống dòng phải chính xác như trong đoạn mã trên, nếu
khoảng cách và xuống dòng viết sai, chương trình sẽ bị lỗi.
40
Hình 3.13: Nhập đoạn mã lập trình Python vào trong tập tin congtac.py.
Sau khi nhập xong mã lập trình Python cho tập tin congtac.py, nhấn phím Esc
trên bàn phím để thoát chế độ nhập ký tự cho tập tin, tiếp theo gõ lệnh :x để lưu nội của
tập tin congtac.py và thoát khỏi tập tin.
Từ giao diện dòng lệnh, gõ lệnh sudo python congtac.py rồi nhấn phím Enter,
chương trình chúng ta vừa viết cho tập tin congtac.py sẽ thực thi và yêu cầu chúng ta
nhấn công tắc điện.
Hình 3.14: Thực thi mã lệnh Python trong tập tin congtac.py.
41
Khi nhấn công tắc điện, màn hình sẽ in ra câu “Ban vua nhan cong tac dien”.
Hình 3.15: Màn hình ra câu “Ban vua nhan cong tac dien” khi nhấn công tắc.
Như vậy, chúng ta vừa thực hành xong một bài đơn giản về cách sử dụng chân
GPIO của RPi. Qua ví dụ này, chúng ta cũng có cái nhìn tổng quan và hiểu hơn về GPIO
và cách sử dụng các chân GPIO. Trong phần 5, chúng ta sẽ thực hành thêm nhiều bài mới
để hiểu sâu hơn về GPIO.
42
4. Một số ngôn ngữ và thư viện lập trình cho Raspberry Pi.
Hiện nay, có rất nhiều ngôn ngữ lập trình cho Raspberry Pi, như Python, Scratch,
Java, C… Trong phần này, chúng ta chỉ tìm hiểu hai ngôn ngữ là Python và C. Với ngôn
ngữ lập trình Python, chúng ta có bộ thư viện lập trình cho GPIO của RPi là RPi.GPIO.
Với ngôn ngữ lập trình C, chúng ta sẽ tìm hiểu bộ thư viện lập trình cho GPIO của RPi là
wiringPi. Hai bộ thư viện này sẽ giúp chúng ta lập trình điều khiển các chân GPIO của
RPi.
4.1. Ngôn ngữ lập trình Python và thư viện lập trình RPi.GPIO.
4.1.1. Ngôn ngữ lập trình Python.
4.1.1.1. Tổng quan.
Python là một ngôn ngữ lập trình bậc cao, thông dịch, tương tác và hướng đối
tượng.
- Python là ngôn ngữ lập trình dạng thông dịch: Bởi vì người lập trình
không cần phải biên dịch toàn bộ chương trình trước khi thực thi, mã lệnh sẽ được xử lý
tại thời gian chạy bởi trình thông dịch.
+ Biên dịch nghĩa là, khi chúng ta đã viết xong tất cả các mã lệnh
của chương trình, trình biên dịch sẽ biên dịch toàn bộ mã lệnh đó thành mã máy (là ngôn
ngữ mà máy tính có thể hiểu được ở dạng bit 0101) một lần duy nhất và chạy những mã
lệnh đó.
* Ví dụ: Để tính tổng của số a cộng số b (a+b=?), sau đó in
kết quả ra màn hình dạng là “Kết quả là …”, chúng ta có đoạn lệnh sau:
soA = raw_input("Nhập số a")
soB = raw_input("Nhập số b")
tong = int(soA) + int(soB)
print "Kết quả là" + tong
Với trình biên dịch, khi chạy chương trình, tất cả các mã lệnh
được biên dịch một lần thành mã máy và thực thi, chúng ta nhập số a = 2, nhập số b = 3,
chương trình sẽ in ra màn hình “Kết quả là 5”.
+ Thông dịch không giống như biên dịch, khi chúng ta viết chương
trình đến đâu, trình thông dịch sẽ thông dịch mã lệnh sang mã máy đến đó, không cần
phải viết xong chương trình mới dịch sang mã máy. Với trình viết mã lệnh của Python,
khi chúng ta viết xong một câu lệnh và nhấn phím Enter, ngay lập tức, lệnh đó được
chuyển thành mã máy và thực thi ngay.
43
* Ví dụ: Cũng với đoạn chương trình tính tổng ở trên, với trình
thông dịch, khi nhập một câu lệnh trong chuong trình, trình thông dịch sẽ dịch sang mã
máy và thực thi ngay mã lệnh, cứ như vậy từng câu lệnh một cho đến khi kết thúc chương
trình. Khi gõ lệnh tong = soA + soB, trình thông dịch gán ngay tổng của soA và soB cho
tong, khi gõ lệnh print “Kết quả là” + tong, trình thông dịch sẽ in ngay ra màn hình
“Kết quả là 5”.
- Python là ngôn ngữ lập trình tương tác: Chính vì Python là ngôn ngữ lập
trình dạng thông dich, cho nên người lập trình có thể tương tác trực tiếp với trình thông
dịch thông qua cửa sổ lập trình Python để viết chương trình.
- Python là ngôn ngữ lập trình hướng đối tượng: Python hỗ trợ kỹ thuật
hướng đối tượng, người lập trình có thể đóng gói mã lệnh trong một đối tượng để sử
dụng.
+ Có hai kiểu lập trình phổ biến, là lập trình tuần tự và lập trình
hướng đối tượng. Khi bạn đã làm quen với một ngôn ngữ lập trình và việc lập trình, bạn
sẽ hiểu và có cái nhìn trực quan hơn về hai kiểu lập trình này. Ở đây, chúng ta chỉ trình
bày tổng quan ý niệm lập trình tuần tự và lập trình hướng đối tượng.
* Lập trình tuần tự: Là kiểu lập trình theo thứ tự, từ trên
xuống dưới cho đến khi giải quyết xong bài toán, kết thúc chương trình. Dạng lập trình
này không định hướng trước các công việc được thực hiện trong chương trình, mã lệnh
không được sử dụng lại.
* Lập trình hướng đối tượng: Là kiểu lập trình mà các công
việc thực hiện trong một chương trình được định hướng trước, các phần tử có chung các
thuộc tính và hành động được gom thành một đối tượng. Khi muốn sử dụng đến một
hành động nào đó, chỉ cần truy xuất đến đối tượng đó. Dạng lập trình này có tổ chức bài
bản, mã lệnh có thể dùng lại nhiều lần trong chương trình mà không cần phải viết lại.
4.1.1.2. Cài đặt môi trường lập trình Python.
Trên HĐH Raspbian, Python được được tích hợp sẵn, do đó, người lập trình
Python không cần cài đặt Python. Với các phiên bản Linux khác, nếu chưa cài đặt
Python, có thể tải Python từ website và cài đặt.
Các bản phân phối Python có sẵn trên nhiều nền tảng HĐH khác nhau, chỉ cần tải
gói Python phù hợp với nền tảng đó và cài đặt là có thể lập trình Python.
Để cài đặt Python trên Linux, thực hiện như sau:
- Tải gói Python từ địa chỉ https://www.python.org/downloads/ .
- Giải nén gói vừa tải về và di chuyển vào thư mục đó.
- Thực thi lệnh run ./configure script.
44
- Thực thi lệnh make.
- Thực thi lệnh make install.
- Sau khi cài đặt Python, thiết lập biến môi trường PATH cho python với
lệnh export PATH="$PATH:/usr/local/bin/python".
Để cài đặt Python trên Windows, thực hiện như sau:
- Tải gói Python từ địa chỉ https://www.python.org/downloads/ .
- Chạy tập tin python-XYZ.msi vừa tải về để cài đặt Python. Với XYZ là
phiên bản Python tải về.
- Sau khi cài đặt Python, thiết lập biến môi trường PATH cho python với
lệnh path %path%;C:\PythonXYZ . Với XYZ là một số nguyên.
4.1.1.3. Cú pháp căn bản.
Có 2 cách để chạy một chương trình Python.
- Cách 1: Từ giao diện dòng lệnh, gõ lệnh python, sau đó có thể viết mã
lệnh và mã lệnh sẽ được thực thi ngay sau khi nhấn phím Enter.
Hình 4.1: Vào Python shell bằng cách gõ lệnh python.
Ví dụ: Để in câu “Hello World” ra màn hình, nhập mã lệnh và nhấn Enter.
Hình 4.2: In câu “Hello World” ra màn hình.
- Cách 2: Viết mã lệnh trong một tập tin văn bản, sau đó lưu lại tập
tin với định dạng .py, ví dụ, lưu với tên test.py. Từ giao diện dòng lệnh, di chuyển đến vị
trí thư mục lưu tập tin test.py, sau đó gõ lệnh python test.py để chạy tập tin và thực thi
mã lệnh.
45
Hình 4.3: Chạy mã lệnh từ tập tin test.py.
Một số từ dành riêng (từ khóa) trong Python:
and else global pass
assert elif import print
break except in return
class exce is try
continue finally lambda while
def for root raise
del from or not
Bảng 4.1: Một số từ khóa trong Python.
Dòng và thụt đầu dòng: trong Python không sử dụng dấu ngoặc đơn () để bao
bọc một khối lệnh, thay vào đó là xuống hàng và thụt đầu dòng. Số lượng khoảng trắng
dùng cho thụt đầu dòng là tùy biến, nhưng các phát biểu trong cùng một khối mã lệnh
phải được thụt đầu dòng với cùng một lượng khoảng trắng như nhau.
Hình 4.4: Sử dụng dòng và thụt đầu dòng để định nghĩa khối mã lệnh.
Đoạn mã lệnh dưới đây sẽ phát sinh lỗi vì số lượng khoảng trắng dùng cho thụt
đầu dòng cho các dòng lệnh trong khối lệnh else không đồng bộ.
Hình 4.5: Khối lệnh else sai vì số lượng khoảng trắng của dòng lệnh không đồng bộ.
Dấu nháy trong Python: Để khai báo một chuỗi trong Python, có thể dùng dấu
nháy đơn (‘ ’) hoặc dấu nháy kép (“ ”).
Ví dụ: chuoi = "A string" chuoi = 'A string'.
46
Tuy nhiên, sử dụng dấu nháy kép có thể giúp chuỗi chứa được dấu nháy đơn. Ví
dụ: chuoi = "He’s 20 years old".
Ghi chú trong Python: Sử dụng dấu thắng (#) đặt ở đầu dòng sẽ ghi chú dòng đó.
Ví dụ: #Follow statement will print a string
print "Hello, my name is Hoang"
Nếu trên một dòng, có nhiều câu lệnh trên đó, mỗi câu lệnh phải phân cách nhau
bằng một dấu chấm phẩy (;). Ví dụ: print "hello "; print "world" .
4.1.1.4. Biến trong Python.
Biến là một vùng nhớ để lưu trữ các giá trị thay đổi. Điều này có nghĩa là, khi tạo
ra một biến, nó sẽ chiếm một khoảng không gian trong bộ nhớ.
Gán giá trị cho biến: Biến trong Python không cần phải được khai báo trước.
Khai báo xảy ra khi ta gán giá trị cho biến. Sử dụng dấu bằng (=) để gán giá trị cho một
biến.
Ví dụ: name = "hoang"; age = 23; height = 1.7
Python cho pheo gán cùng lúc một giá trị cho nhiều biến.
Ví dụ: myAge = yourAge = herAge = 24
Các loại dữ liệu chuẩn: Python có 5 loại dữ liệu chuẩn là Numbers, String, List,
Tuple và Dictionary.
Dữ liệu Numbers gồm 4 loại khác nhau là số nguyên ngắn (int), số nguyên dài
(long), số thực (float) và số phức hợp (complex).
int long float complex
10 51924361L 0.0 3.14j
100 -0x19323L 15.20 45.j
-786 0122L -21.9 9.322e-36j
Bảng 4.2: Dữ liệu kiểu Numbers trong Python.
Dữ liệu kiểu String là một tập hợp các ký tự nằm giữa hai dấu nháy đơn (hoặc
nháy kép). Có thể dùng toán tử [] hoặc [:] để lấy tập con của chuỗi, dùng toán tử + để nối
chuỗi và dấu * để lặp lại chuỗi nhiều lần.
Ví dụ: str = "Hello World"
print str Hello World
print str[0] H
47
print str[2:5] llo
print str[2:] llo World
print str * 2 Hello WorldHello World
print str + " Test" Hello World Test
Dữ liệu kiểu List là một tập hợp các phần tử được phân cách nhau bởi dấu phẩy (,)
và được bao bọc bởi một cặp dấu ngoặc vuông []. Các phần tử trong mảng không bắt
buộc phải có cùng kiểu dữ liệu. Có thể truy xuất thành phần trong mảng với các toán tử
tương tự như các toán tử áp dụng trên kiểu dữ liệu String.
Ví dụ: array = [1, 2.5, "hoang"]
print array [1, 2.5, "hoang"]
print array[0:2] [1, 2.5]
Dữ liệu kiểu Tuple là một dạng dữ liệu khác của List. Tuy nhiên, dữ liệu kiểu List
được bao bọc với hai dấu ngoặc vuông [], các phần tử trong List và kích thước của List
có thể thay đổi, còn với dữ liệu kiểu Tuple, được bao bọc bởi hai dấu ngoặc đơn và
không thể được cập nhật.
Ví dụ: tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 #Cú pháp không hợp lệ với Tuple
list[2] = 1000 #Cú pháp hợp lệ với List
Dữ liệu kiểu Dictionary là kiểu dữ liệu giống như mảng dạng key:value trong
PHP. Key có thể là bất kiểu dữ liệu gì trong Python, nhưng thường là số và chuỗi. Dữ
liệu Dictionary được bao đóng bởi hai dấu ngoặc nhọn , giá trị của phần tử có thể được
gán hoặc truy xuất qua toán tử [].
Ví dụ: dict = ; dict['one'] = "This is one";
dict[2] = "This is two"
tinydict = 'name': 'john', 'code':6734, 'dept':
'sales'
print dict['one'] This is one
print dict[2] This is two
print tinydict 'dept': 'sales', 'code': 6734,
'name': 'john'
print tinydict.keys() ['dept', 'code', 'name']
print tinydict.values() ['sales', 6734, 'john']
48
4.1.1.5. Toán tử cơ bản trong Python.
Python có các dạng toán tử: Toán tử toán học, toán tử so sánh, toán tử gán, toán tử
logic, toán tử bitwise, toán tử thành viên và toán tử định danh.
Toán tử toán học. Giả sử biến a có giá trị 10, biến b mang giá trị 20, thì:
Toán tử Giải thích Ví dụ
+ Cộng giá trị của hai bên toán tử a + b 20
- Giá trị bên trái trừ cho bên phải a – b -10
* Nhân giá trị của hai bên toán tử a * b 200
/ Giá trị bên trái chia cho bên phải b / a 2
% Chia lấy số dư b % a 0
** Giá trị bên trái lũy thừa mũ giá trị bên
phải của toán tử. a ** b 10
^20
// Chia lấy phần nguyên 9 // 2 4
Bảng 4.3: Toán tử toán học.
Toán tử so sánh. Giả sử biến a có giá trị 10, biến b mang giá trị 20, thì:
Toán tử Giải thích Ví dụ == So sánh bằng nhau hay không a == b false
!= So sánh khác nhau hay không a != b true
<> So sánh khác, tương tự như toán tử != a <> b true
> So sánh a có lớn hơn b hay không a > b false
< So sánh a có nhỏ hơn b hay không a < b true
>= So sánh a lớn hơn hoặc bằng b không a >= b false
<= So sánh a nhỏ hơn hoặc bằng b không a <= b true
Bảng 4.4: Toán tử so sánh.
Toán tử gán. Giả sử biến a có giá trị 10, biến b mang giá trị 20, thì:
Toán tử Giải thích Ví dụ = Gán giá trị của vế phải cho vế trái c = a + b
+= Giá trị vế trái bằng giá trị vế trái cộng
với giá trị vế phải c += a c = c + a
-= Giá trị vế trái bằng giá trị vế trái trừ đi
giá trị vế phải c -= a c = c - a
*= Giá trị vế trái bằng giá trị vế trái nhân
với giá trị vế phải c *= a c = c * a
/= Giá trị vế trái bằng giá trị vế trái chia
cho giá trị vế phải c += a c = c + a
%= Giá trị vế trái bằng giá trị vế trái chia
cho giá trị vế phải rồi lấy số dư c %= a c = c % a
49
**= Giá trị vế trái bằng giá trị vế trái lũy
thừa với số mũ bằng giá trị vế phải c **= a c = c ** a
//= Giá trị vế trái bằng giá trị vế trái chia
cho giá trị vế phải và lấy phần nguyên c //= a c = c // a
Bảng 4.5: Toán tử gán.
Toán tử bitwise. Giả sử a = 60 (nhị phân là 00111100), b = 13 (nhị phân là
00001101), thì:
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Toán tử Giải thích Ví dụ
&
Với toán tử AND, hai bit bằng 1 cộng
nhau bằng 1, những bít khác cộng
nhau = 0
a & b 0000 1100 = 12
| Với toán tử OR, bit 1 + bit 1 hoặc bit
0 + bit 0 bằng 1, bit 0 + bit 0 bằng 0 a | b 0011 1101 = 61
^
Với toán tử XOR, hai bit giồn nhau
cộng lại bằng 0, hai bit khác nhau
cộng lại bằng 1
a ^ b 0011 0001 = 49
~
Với toán tử NOT, tất cả các bít sẽ
được đảo ngược từ 0 sang 1 hoặc từ 1
sang 0
~a 1100 0011 = -61
<< Với toán tử dịch bit về bên trái, dãy
nhị phân sẽ dịch về bên trái n bit << a 1111 0000 = 240
>> Với toán tử dịch bit về bên phải, dãy
nhị phân sẽ dịch về bên phải n bit >>a 0000 1111 = 15
Bảng 4.6: Toán tử bitwise.
Toán tử logic. Giả sử biến a có giá trị 10, biến b mang giá trị 20, thì:
Toán tử Giải thích Ví dụ
and Nếu a và b đều đúng thì điều kiện
đúng, ngược lại là sai. a and b true
or Nếu a hoặc b đúng thì điều kiện đúng. a or b true
50
Cả a và b đều sai thì điệu kiện sai.
not
Đảo ngược trạng thái logic. Nếu a
đúng sẽ bị đảo thành sai, a sai sẽ bị
đảo thành trạng thái đúng.
not (a and b) false
Bảng 4.7: Toán tử logic.
Toán tử thành viên. Ngoài các toán tử nêu trên, Python còn có thêm toán tử
thành viên, phục vụ cho việc kiểm tra một thành viên có thuộc một String, List hay Tuple
hay không. Có 2 toán tử thành viên như sau. Giả sử có một mảng z = 1, 3, 5, 8, 10, x =
3, y = 4, thì:
Toán tử Giải thích Ví dụ
in Trả về true nếu tìm thấy phần tử cho
trước trong danh sách, ngược lại trả
về false
x in z true
not in Trả về true nếu không tìm thấy phần
tử cho trước trong danh sách, ngược
lại trả về true
y in z false
Bảng 4.8: Toán tử thành viên.
Toán tử định danh. Ngoài ra, Python còn có toán tử định danh dùng để so sánh
vùng nhớ của hai đối tượng. Có hai loại toán tử định danh sau:
Toán tử Giải thích Ví dụ
is Trả về 1 nếu hai đối tượng cùng trỏ
đến một vùng nhớ.
x is z trả về 1 nếu
id(y) bằng id(y)
is not Trả về 1 nếu hai đối tượng không
cùng trỏ đến một vùng nhớ.
x is not y trả về 1
id(x) không bằng id(y)
Bảng 4.9: Toán tử định danh.
4.1.1.6. Cấu trúc rẽ nhánh.
Cấu trúc rẽ nhánh dùng để kiểm tra một hoặc một khối điều kiện cho trước, nếu
điều kiện đúng, thực thi lệnh cho điều kiện đúng, ngược lại, thực thi lệnh cho điều kiện
sai. Trong Python, bất cứ giá trị gì khác 0 hoặc khác null là true, giá trị bằng 0 hoặc bằng
null là false.
Phát biểu Giải thích Ví dụ
if
Nếu điều kiện đúng thì thực thi
khối lệnh thuộc biểu thức if,
ngược lại, bỏ quả khối lệnh của if.
x = 2; y = 3;
if x == y:
print "x = y"
if..else
Nếu điều kiện đúng, thực thi khối
lệnh của if, nếu sai, thực thi khối
lệnh của else.
x = 2; y = 3;
if x == y:
print "x = y"
51
else:
print "x khác y"
if..elif
dk
..else
Nếu điều kiện đúng, thực thi khối
lệnh của if, nếu sai, tiếp tục kiểm
tra điều kiện của các else tiếp
theo, nếu đúng thì thực thi khối
lệnh trong else, sai thì bỏ qua.
x = 2; y = 3;
if x == y:
print "x = y"
elif x > y:
print "x lớn hơn y"
else:
print "x nhỏ hơn y"
Bảng 4.10: Phát biểu của cấu trúc rẽ nhánh.
4.1.1.7. Vòng lặp.
Python có các dạng vòng lặp là while, for và vòng lặp lồng nhau.
Vòng lặp while: lặp lại việc thực thi khối lệnh bên trong while cho đến khi biểu
thức điều kiện của while không còn đúng nữa.
Ví dụ: a = 0
while a < 10:
print a;
a++;
print “Bạn vừa in ra dãy số tự nhiên”
Vòng lặp for: Lặp lại việc thực thi khối lệnh bên trong for theo một số lần nhất
định.
Ví dụ: a = 1
for kytu in “Hello”:
print “ký tự thứ ” + a + “ là ” kytu
print “Bạn vừa in ra các ký tự trong từ Hello”
Vòng lặp lồng nhau: Python cho phép một vòng lặp có thể nằm trong một vòng lặp
khác hoặc có thể chứa vòng lặp khác.
Ví dụ: i = 2
while(i < 100):
j = 2
while(j <= (i/j)):
if not(i%j): break
j = j + 1
52
if (j > i/j) : print i + " is prime"
i = i + 1
print "Bạn vừa in một dãy số nguyên tố nhỏ hơn
100!"
4.1.1.8. Hàm trong Python.
Hàm là một khối lênh xây dựng sẵn, có thể sử dụng lại nhiều lần để thực hiện một
công việc, một chức năng nào đó trong chương trình. Python xây dựng sẵn rất nhiều hàm
trong nó, chẳng hạn như hàm print dùng để in một chuỗi ký tự ra màn hình. Tuy nhiên,
người lập trình có thể tự tạo ra các hàm cho riêng mình bằng cách sử dụng từ khóa def.
Cú pháp: def tên_hàm ( tham số ):
khối_lệnh_ở đây
return giá_trị_trả_về.
Ví dụ: def congHaiSo(soA, soB):
ketQua = soA + soB
return ketQua
Khai báo hàm chỉ là tạo ra một khối lệnh dựng sẵn và chưa được sử dụng. Để sử
dụng được chức năng của hàm, ta phải gọi đến hàm đó.
Ví dụ: print "Chương trình toán học mini"
a = 4; b = 5
print "Số a = 4 \n Số b = 5"
tong = congHaiSo( a, b )
print "Tổng hai sô a + b = " + tong
4.1.2. Thư viện lập trình RPi.GPIO.
RPi.GPIO là một gói thư viện dùng để điều khiển các chân GPIO của RPi. Gói này
cung cấp một lớp chứa các chức năng điều khiển GPIO. Lưu ý, ở thời điểm viết tài liệu
này, sử dụng thư viện RPi.GPIO phiên bản 0.5.6 (gói RPi.GPIO-0.5.6.tar.gz), có thể
tham khảo các phiên bản khác tại địa chỉ: https://pypi.python.org/pypi/RPi.GPIO.
Nhắc lại một chút về GPIO, RPi có 17 chân GPIO trên mạch, tất cả các chân này
đều có thể dùng làm ngõ vào hoặc ngõ ra. Trong số đó, 9 chân con có chức năng thay thế
chứ không chỉ là ngõ ra/vào, có 2 chân UART, 2 chân I2C và 5 chân SPI.
Muốn sử dụng được thư viện RPi.GPIO để lập trình điều khiển GPIO, chúng ta
cần phải nắm được sơ đồ chân GPIO của RPi để có thể thao tác chính xác. Nếu chưa nắm
53
được sơ đồ chân GPIO của RPi, hãy tham khảo lại phần 3 trong tài liệu này, nếu muốn
tìm hiểu sâu hơn, tham khảo tại địa chỉ http://elinux.org/RPi_Low-level_peripherals.
Để sử dụng thư viện RPi.GPIO, phải tải và cài đặt trên RPi. Để cài đặt, chúng ta
có 2 cách, cách thứ nhất là sử dụng lệnh linux, tải và cài đặt tự động, cách thứ hai là tải
và cài đặt bằng tay, thực hiện tuần tự từng lệnh.
- Cách thứ nhất: Tải và cài đặt tự động.
sudo apt-get update Lệnh này để cập nhật kho chứa của RPi.
sudo apt-get install python-rpi.gpio Tải và cài đặt RPi.GPIO.
- Cách thứ hai: Tải và cài đặt bằng tay, thực hiện tuần tự các bước sau.
+ B1: Tải gói RPi.GPIO-0.5.6.tar.gz từ website của Python về máy.
wget https://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.5.6.tar.gz
+ B2: Giải nén gói RPi.GPIO-0.5.6.tar.gz vừa mới tải về.
tar zxf RPi.GPIO-0.5.5.tar.gz
+ B3: Di chuyển đến đường dẫn của thư mục RPi.GPIO-0.5.6 vừa
giải nén xong.
cd RPi.GPIO-0.5.5
+ B4: Cài đặt thư viện.
sudo python setup.py install
+ B5: Xóa thư mục RPi.GPIO-0.5.6.
cd ..
sudo rm -rf RPi.GPIO-0.5.5/
Như vậy, chúng ta đã cài đặt xong RPi.GPIO và có thể sử dụng.
Để kiểm tra, các bạn có thể thực hiện lại ví dụ bật công tắc trong phần 3 – tìm hiểu về
GPIO.
Trong phần này, chúng ta sẽ tìm hiểu cách sử dụng cơ bản RPi.GPIO và thực hành
sử dụng RPi.GPIO để lập trình chương trình bật đèn led.
Sử dụng căn bản RPi.GPIO.
* Nhập (đính kèm) thư viện RPi.GPIO vào chương trình Python.
- Để đính kèm RPi.GPIO vào chương trình Python, viết mã lệnh
Pyton như sau:
import RPi.GPIO as GPIO
54
- Mục đích đính kèm thư viện RPi.GPIO vào chương trình Python là
để tham khảo đến các chức năng của nó từ chương trình của chúng ta. Để kiểm tra hoạt
động của RPi.GPIO, viết đoạn mã lệnh Python sau và một tập tin gpio.py và lưu lại:
try:
import RPi.GPIO as GPIO
except RuntimeError:
print("Lỗi đính kèm RPi.GPIO! Bạn
cần phải thực thi tập tin này với quyền cao nhất là root.
Sử dụng lệnh 'sudo' để thực thi tập tin với quyền root")
- Thực thi tập tin gpio.py bằng cách gõ lệnh:
python gpio.py.
- Nếu câu thông báo trong đoạn lệnh trên được in ra, nghĩa là chúng
ta phải thực thi tập tin với quyền root. Gõ lệnh:
sudo python gpio.py.
- Nếu không có thông báo gì được in ra, nghĩa là thư viện RPi.GPIO
đã hoạt động, như vậy, chúng ta đã có thể sử dụng thư viện RPi.GPIO để lập trình.
* Thiết lập chế độ đánh số chân GPIO.
- Trong phần 3 – tìm hiểu về GPIO đã có trình bày về hai kiểu đánh
số chân GPIO là kiểu BCM và kiểu BOARD. Ở đây sẽ không trình bày lại mà sẽ hướng
dẫn cách thiết lập để sử dụng sơ đồ chân theo kiểu BCM hay kiểu BOARD.
- Để sử dụng kiểu đánh số chân BCM, sử dụng mã lệnh sau:
GPIO.setmode(GPIO.BOARD)
- Để sử dụng kiểu đánh số chân BOARD, sử dụng mã lệnh sau:
GPIO.setmode(GPIO.BCM)
* Bật/tắt cảnh báo – thông báo của hệ thống.
- Có thể có nhiều hơn một script chạy trên RPi sử dụng các chân
GPIO. Nếu RPi.GPIO phát hiện một chân đã được cấu hình cho một chức năng nào đó
bởi một script khác, RPi.GPIO sẽ phát ra một thông báo, và chúng ta cần phải cấu hình
lại script hiện tại.
- Để tắt chức năng thông báo, sử dụng mã lệnh:
GPIO.setwarnings(False)
- Để bật lại chức năng thông báo, chỉ cần đổi False thành True.
GPIO.setwarnings(True)
55
* Thiết lập mode (chế độ - là ngõ vào hay ngõ ra) cho một chân GPIO.
- Mỗi chân GPIO được sử dụng trong chương trình, chúng ta đều
phải thiết lập cho nó là ngõ vào hoặc ngõ ra, nếu không, chương trình sẽ xuất ra thông
báo lỗi rằng chúng ta chưa thiết lập cho chân GPIO được sử dụng đó.
- Để thiết lập một chân GPIO là ngõ vào:
GPIO.setup(so_chan, GPIO.IN)
(so_chan là đánh số chân của chân GPIO theo kiểu BCM hoặc BOARD)
- Để thiết lập một chân GPIO là ngõ ra:
GPIO.setup(so_chan, GPIO.OUT)
(so_chan là đánh số chân của chân GPIO theo kiểu BCM hoặc BOARD)
- Có thể thiết lập giá trị ban đầu cho một ngõ ra (output):
GPIO.setup(so_chan,GPIO.OUT,initial=GPIO.high)
* Đọc giá trị của chân GPIO được thiết lập là ngõ vào (input).
- Để đọc giá trị của ngõ vào:
GPIO.input(so_chan)
- Giá trị trả về sẽ là 0 hoặc GPIO.LOW, 1 hoặc GPIO.HIGH.
Thiết lập giá trị cho chân GPIO được thiết lập là ngõ ra (output).
- Để thiết lập giá trị cho ngõ ra:
GPIO.output(so_chan, trang_thai)
(trang_thai là một trong các giá trị 0 hoặc GPIO.LOW, 1 /
GPIO.HIGH)
* Xác lập lại trạng thái mặc định cho các chân GPIO.
- Có thể một chân hoặc một số chân GPIO đã được sử dụng bởi một
script khác, các chân này có thể đã được thiết lập lập là output với giá trị GPIO.HIGH.
Khi thực script hiện tại cũng có dùng đến chân GPIO đó, chương trình sẽ xuất ra cảnh
báo rằng chân GPIO đã được sử dụng. Nếu hai script cùng sử dụng một chân GPIO với
hai chế độ khác nhau có thể tổn hại đến RPi.
- Để tránh đụng độ xảy ra, viết hàm cleanup() ở cuối chương trình:
GPIO.cleanup()
56
- Hàm GPIO.cleanup() sẽ thiết lập tất cả các chân GPIO trở về trạng
thái mặc định ban đầu của nó, nghĩa là tất cả các chân GPIO sẽ chưa được sử dụng cho
bất cứ chức năng nào (ngõ vào hoặc ngõ ra).
- Tuy nhiên, trong một số trường hợp, chúng ta chỉ muốn thiết lập lại
trạng thái mặc định cho một chân, cũng sử dụng hàm GPIO.cleanup() nhưng truyền thêm
tham số cho hàm, là số chân của GPIO:
GPIO.cleanup(so_chan)
Bài thực hành: Sử dụng RPi.GPIO để lập lập trình chương trình bật đèn led.
* Chuẩn bị:
- 1 máy tính RPi, 1 bàn phím, 1 chuột usb, 1 mà hình hình desktop.
- 1 sạc microUSB 5V, cáp chuyển đổi HDMI sang VGA,
- 1 đèn led nhỏ.
- 1 điện trở 56Ω (Ohm).
- 3 dây dẫn điện (female to female jumper wire).
Hình 4.6: Đèn led. Hình 4.7: Điện trở 56Ω. Hình 4.8: Dây dẫn điện.
* Thực hành:
- Sử dụng một dây dẫn điện (female to female jumper wire) để nối
chân ngắn của đèn led với một đầu của điện trở (đầu có vòng màu xanh lá cây). Sử dụng
một dây dẫn điện khác nối chân dài của đèn led với chân GPIO số 7 (theo kiểu BOARD)
của RPi. Sử dụng một dây dẫn khác nối chân còn lại của điện trở với chân số 6 (theo kiểu
BOARD) của RPi.
57
Hình 4.8: Mạch được lắp ráp hoàn tất.
- Sau khi lắp ráp hoàn tất, chúng ta có sơ đồ mạch điện như hình 4.8.
Khởi động RPi, đăng nhập với người dùng pi và mật khẩu raspberry (hoặc mật khẩu của
RPi mà chúng ta cài đặt).
- Tạo mới tập tin batdenled.py bằng cách gõ lệnh vi batdenled.py
rồi nhấn phím Enter:
Hình 4.9: Tạo mới tập tin batdenled.py.
- Nhấn phím i trên bàn phím để kích hoạt chức năng nhập ký tự cho
tập tin batdenleb.py.
- Nhập đoạn mã lệnh sau vào tập tin batdenled.py:
import RPi.GPIO as GPIO
## Đính kèm thư viện RPi.GPIO
GPIO.setmode(BOARD)
## Sử dụng kiểu đánh số BOARD
GPIO.setup(7, GPIO.OUT)
## Thiết lập chân số 7 là ngõ ra
GPIO.output(7, True)
## Bật nguồn 3V cho chân số 7
58
Hình 4.10: Nhập mã lệnh Python cho tập tin batdenled.py.
- Nhấn phím Esc trên bàn phím để thoát chế độ nhập ký tự cho tập
tin batdenled.py.
- Gõ lệnh :x và nhấn phím Enter để lưu và thoát khỏi tập tin
batdenled.py.
Hình 4.11: Lưu và thoát khỏi tập tin batdenled.py với lệnh :x.
- Thực thi tập tin batdenled.py bằng cách gõ lệnh:
sudo python batdenled.py
Hình 4.12: Thực thi mã lệnh của tập tin batdenlen.py.
59
- Sau khi gõ lệnh sudo python batdenled.py rồi nhấn phím Enter, đèn
led sẽ phát sáng.
Hình 4.13: Đèn led phát sáng khi thực thi tập tin batdenled.py.
Như vậy là chúng ta đã hoàn thành bài thực hành bật đèn led sử dụng
thư viện RPi.GPIO. Trong phần 5, chúng ta sẽ tiếp tục thực hành với thư viện này.
4.2. Ngôn ngữ lập trình C và thư viện lập trình wiringPi.
4.2.1. Ngôn ngữ lập trình C.
Khi bạn đã quen với một ngôn ngữ lập trình, bạn sẽ dễ dàng tiếp thu một ngôn ngữ
lập trình khác. Về cơ bản, hầu hết các ngôn ngữ lập trình đều có các quy luật và cách
định nghĩa rất giống nhau, còn khác nhau ở chỗ, mỗi ngôn ngữ lập trình có một bộ quy
tắc và cú pháp riêng.
Ví dụ: In ra màn hình các số tự nhiên từ 1 đến 5. Ở đây, chúng ta sẽ sử dụng 2
ngôn ngữ lập trình để thực hiện bài tập này, đó là Python và C. Cả hai ngôn ngữ đều sử
dụng vòng lặp while để in ra các số tự nhiên như yêu cầu.
60
- Với ngôn ngữ Python, ta có đoạn mã lệnh sau:
dem = 1
while (dem <= 5):
print(dem)
dem = dem +1
print "Đã in xong"
- Với ngôn ngữ lập trình C, ta có đoạn mã lệnh sau:
int dem = 1;
while (dem <= 5)
print(dem) ; dem = dem +1 ;
print "Đã in xong" ;
- Nhìn qua hai đoạn mã lệnh trên, cách thực hiện bài toán trong cả hai ngôn
ngữ là giống nhau, đều tạo một biến dem với giá trị ban đầu là 1, sử dụng vòng lặp
while để in biến đếm ra màn hình. Sau mỗi lần in, biến dem tăng lên 1 đơn vị, vòng lặp
sẽ làm việc cho đến khi nào biến dem lớn hơn 5 mới dừng lại và kết thúc công việc.
- Hai đoạn mã lệnh trên chỉ khác nhau một chút về cú pháp, với Python,
khai báo một biến không cần phải khai báo kiểu dữ liệu của biến (là kiểu số nguyên –
int hay kiểu số thực - float), còn với C, khai báo biến cần phải khai báo kiểu dữ liệu
phía trước tên biến (int dem ).
- Với Python, vòng lặp while được mở bằng dấu hai chấm (:), các dòng
lệnh liên tục phía dưới và thụt đầu dòng xa hơn so với từ khóa while là khối lệnh thuộc
while. Với C, vòng lặp while mở ra bằng dấu mở ngoặc nhọn () và đóng lại bằng dấu
mở ngoặc đơn (), các lệnh nằm giữa cặp dấu ngoặc đơn là khối lệnh thuộc while, còn
lệnh print nằm ngoài không thuộc while mà ngang hàng với while.
- Với Python, cuối mỗi câu lệnh, không cần đóng dấu chấm phẩy (;), mỗi
dòng là một câu lệnh. Với C, mỗi câu lệnh phải kết thúc bằng một dấu chấm phẩy (;), và
nhiều câu lệnh có thể nằm trên cùng một dòng, chỉ cần cách nhau bởi dấu chấm phẩy (;).
Như vậy, chúng ta có thể nhận ra một điều, hai ngôn ngữ khác nhau về cú pháp,
quy tắc nhưng nguyên lý làm việc thì giống nhau. Do đó, chỉ cần nắm một ngôn ngữ lập
61
trình nhất định thì các ngôn ngữ lập trình khác sẽ dễ tiếp cận và nắm bắt. Vì vậy, trong tài
liệu này sẽ không trình bày chi tiết ngôn ngữ C.
Để học lập trình C, có thể tham khảo địa chỉ web sau:
http://www.tutorialspoint.com/cprogramming/index.htm
Các bạn có thể tìm hiểu kỹ về Python, từ đó vận dụng cho ngôn ngữ C. Trong
phần này, chỉ trình bày một số kiến thức cơ bản về C và lập trình C để hỗ trợ các bạn làm
việc với GPIO của RPi.
4.2.1.1. Tổng quan.
C là một ngôn ngữ lập trình bậc cao, với các đặc điểm:
- Dễ học: C được khuyến khích dành cho những người mới học lập trình
thay vì các ngôn ngữ khác, bởi vì C là một ngôn ngữ lập trình bậc cao, có bộ cú pháp và
từ khóa quen thuộc, dễ hiểu.
- Ngôn ngữ có cấu trúc: C là một ngôn ngữ lập trình cấu trúc, có nghĩa là,
các công việc được gom nhóm, cấu trúc vào trong một khối gọi là hàm (hoặc phương
thức) để có thể sử dụng khi cần. Các hàm này có thể dùng lại nhiều lần trong chương
trình mà không cần phải viết lại mã lệnh.
- Ngôn ngữ lập trình C có thể được biên dịch trên nhiều nền tảng máy tính
khác nhau. Chẳng hạn như, C vừa có thể biên dịch trên HĐH Windows, vừa có thể biên
dịch trên HĐH Linux hay Unix…
Một chương trình được viết bằng ngôn ngữ C có thể chứa từ ba dòng đến hàng
triệu dòng mã lệnh và những mã lệnh này có thể được viết trong một hoặc nhiều tập tin
văn bản với phần mở rộng (phần đuôi) “.c”, ví dụ xinchao.c. Chúng ta có thể dùng bất cứ
trình soạn thảo văn bản đơn giản nào để viết một chương trình C, chẳng hạn như “vi”,
hay “gedit” của HĐH Linux hoặc “wordpad”, “notepad” trên HĐH Windows.
Mọi chương trình C đầy đủ được bắt đầu trong một hàm gọi là “main”. Một hàm
là một tập hợp các mã lệnh nhằm thực hiện một công việc gì đó và trả về một kết quả, kết
quả có thể là một số, một chuỗi ký tự hoặc không gì cả. Hàm main luôn được gọi thực thi
trước tiên khi một chương trình thực thi, từ hàm main, chúng ta có thể gọi đến các hàm
khác trong chương trình để thực thi công việc.
Ví dụ: Viết tập tin xinchao.c chứa mã lệnh lập trình C, in ra màn hình câu
“Xin chao moi nguoi”, có nội dung:
#include <stdio.h>
void printBye()
printf("Xin chao moi nguoi \n");
62
void main()
printBye();
Như vậy, từ hàm main, hàm printHello() sẽ được gọi thực thi và in
câu xin chào ra màn hình.
Trên giao diện dòng lệnh, gõ lệnh vi xinchao.c để tạo tập tin xinchao.c.
Hình 4.14: Tạo mới tập tin xinchao.c.
Nhấn phím i trên bàn phím để kích hoạt chức năng nhập ký tự cho tập tin,
sau đó nhập nội dung mã lệnh cho tập tin xinchao.c.
Hình 4.15: Nhập nội dung mã lệnh cho tập tin xinchao.c.
Nhấn phím Esc để thoát chế độ nhập ký tự, sau đó gõ lệnh :x để lưu và
thoát khỏi tập tin xinchao.c.
Để thực thi một chương trình xinchao.c, phải biên dịch tập tin thành mã
máy để máy tính có thể hiểu được. Từ giao diện dòng lệnh, gõ lệnh gcc xinchao.c để
biên dịch tập tin xinchao.c.
63
Hình 4.16: Biên dịch tập tin xinchao.c thành mã máy.
Sau khi biên dịch tập tin xinchao.c, chúng ta sẽ co tập tin a.out, gõ lệnh
ls –la để kiểm tra.
Hình 4.17: Tập tin a.out được tạo ra sau khi biên dịch tập tin xinchao.c.
Để thực thi chương trình, gõ lệnh ./a.out, như vậy, màn hình sẽ in ra câu
“Xin chao moi nguoi”.
Hình 4.18: Thực thi chương trình C và in ra câu “Xin chao moi nguoi”.
4.2.1.2. Một số kiến thức cơ bản về lập trình C.
* Một số cú pháp căn bản.
- Dấu chấm phẩy (;) : Trong C, dấu chấm phẩy là một phát biểu để kết
thúc một câu lệnh.
64
Ví dụ: printf(“Xin chao moi nguoi”);
Một câu lệnh có thể là một phát biểu khai báo biến, một câu lệnh in, một
phép tính tổng của hai sô …
Ví dụ: int dem = 1;
/*Khai báo một biến dem kiểu số nguyên*/
printf(“Xin chao moi nguoi”);
/*In một câu ra màn hình*/
tong = soA + soB;
/*Tính tổng của hai số*/
Mỗi câu lệnh bắt buộc phải kết thúc bằng một dấu chấm phẩy, nếu
không, chương trình sẽ bị lỗi.
- Ghi chú: Là những câu văn bản nhằm ghi chú thông tin hỗ trợ cho mã
lệnh, các ghi chú sẽ được trình biên dịch bỏ qua khi biên dịch. Ghi chú bắt đầu với dấu /*
và kết thúc với dấu */.
Ví dụ: /*In câu chào ra màn hình*/
printf(“Xin chao moi nguoi”);
Câu văn bản nằm giữa hai dấu ghi chú /* */ giúp người đọc mã lệnh
dễ hiểu hơn ý đồ của mã lệnh được viết, cho người đọc biết, câu lệnh dưới sẽ in một câu
ra màn hình.
- Định danh: Là khai báo của một biến hoặc của một hàm khải báo bởi
người dùng. Mỗi ngôn ngữ sẽ có bộ quy tắc định danh khác nhau. Với C, định danh bắt
đầu với ký từ từ A-Z hoặc từ a-z hoặc dấu gạch dưới _, tiếp theo là các số tự nhiên từ 0-
9, dấu gạch dưới _ hay các ký tự từ A-Z hoặc từ a-z.
- Định danh không được chứa các ký tự đặc biệt như ! , @, #, $, %, ^,
&, * …, không được bắt đầu với chữ số và không được trùng với từ khóa. Định danh
trong C có phân biệt giữa chữ hoa và chữ thường nên cần chú ý khi đặt tên.
Ví dụ: Một số định danh hợp lệ:
ketQua, TinhTong, a_123, _temp …
Một số đinh dạnh không hợp lệ:
1chuoi, doi-ten, 123_tinh, printf …
65
- Từ khóa: Là những từ dành riêng của cho ngôn ngữ lập trình, khi khai
báo định danh cho biến hoặc hàm, không được đặt tên trùng với từ khóa. Dưới đây là bộ
từ khóa của ngôn ngữ lập trình C.
auto else long switch
break enum register typedef
case extern return union
char float short unsigned
const for signed void
continue goto sizeof volatile
default if static while
do int struct _Packed
double
Bảng 4.11: Bộ từ khóa dành riêng của ngôn ngữ lập trình C.
- Khoảng trắng: Một dòng chỉ chứa khoảng trắng hoặc ghi chú, được C
hiểu là một dòng trống, và C bỏ qua tất cả các dòng trống này.
- Khoảng trắng là một quy định được sử dụng để mô tả khoảng trống, tab,
dòng mới hoặc ghi chú. Khoảng trắng được dùng để tách biệt một phát biểu với một phát
biểu khác.
Ví dụ: int tuoi;
- Khoảng trắng giữa phát biểu khai báo kiểu dữ liệu int và phát biểu tên
biến tuoi sẽ tách biệt hai phát biểu này, giúp trình biên dịch hiểu rằng đây là hai phát
biểu khác nhau.
* Một số kiểu dữ liệu.
- Kiểu dữ liệu của một biến là dung lượng mà biến đó chiếm giữ trong bộ
nhớ. Trong C có các kiểu dữ liệu như kiểu số nguyên (integer), kiểu số thực (floating-
point) và kiểu không kiểu (void).
+ Kiểu số nguyên (integer).
Loại dữ liệu Kích thước lưu trữ Dãy giá trị
char 1 byte -128 đến 127 hoặc 0 đến 255
unsigned char 1 byte 0 đến 255
signed char 1 byte -128 đến 127
66
int 2 hoặc 4 byte -32,768 đến 32,767 hoặc -2,147,483,648
đến 2,147,483,647
unsigned int 2 hoặc 4 byte 0 đến 65,535 hoặc 0 đến 4,294,967,295
short 2 byte -32,768 đến 32,767
unsigned short 2 byte 0 đến 65,535
long 4 byte -2,147,483,648 đến 2,147,483,647
unsigned long 4 byte 0 đến 4,294,967,295
Bảng 4.12: Dữ liệu kiểu số nguyên – integer.
+ Kiểu số thực (floating-point).
Kiểu dữ liệu Kích thước lưu trữ Dãy giá trị Phần thập phân
float 4 byte 1.2E-38 đến 3.4E+38 6 số thập phân
double 8 byte 2.3E-308 đến 1.7E+308 15 số thập phân
long double 10 byte 3.4E-4932 đến 1.1E+4932 19 số thập phân
Bảng 4.13: Dữ liệu kiểu số thực – floating-point.
+ Kiểu không kiểu (kiểu void): Không trả về bất cứ kiểu dữ liệu nào.
Kiểu void được sử dụng trong ba trường hợp sâu.
STT Kiểu và mô tả
1
Hàm trả về kiểu void Có nhiều hàm trong C không trả về giá trị hoặc chúng ta có thể làm chúng trả
về kiểu void. Một hàm không trả về giá trị thì có kiểu trả về là void.
Ví dụ: void exit (int trangthai);
2
Tham số của hàm có kiểu void Có nhiều hàm trong C không có tham số. Một hàm không có tham số được
hiểu là hàm có tham số kiểu void.
Ví dụ: int rand(void);
3
Con trỏ kiểu void Một con trỏ kiểu void * đại diện cho địa chỉ của một đối tượng, nhưng đối
tượng đó không có kiểu dữ liệu.
Ví dụ: Hàm cấp phát vùng nhớ void *malloc( size_t size ); trả
về một con trỏ đến kiểu void có thể nhận bất kỳ kiểu dữ liệu nào.
Bảng 4.14: Dữ liệu kiểu void.
67
* Biến và hằng.
- Biến là một cái tên được đặt cho một vùng nhớ mà chương trình của
chúng ta có thể thao tác với nó. Biến dược dùng để lưu trữ nhứng giá trị thay đổi, nghĩa
là, có lúc biến mang giá trị này, nhưng đến lúc khác, nó lại mang một giá trị khác.
- Tên đặt cho biến phải tuân thủ theo quy tắc định danh đã được trình bày
trong phần cú pháp căn bản. Dựa trên các kiểu dữ liệu đã trình bày, chúng ta sẽ có các
biến mang các kiểu dữ liệu đó.
Ví dụ: int i, j, k;
char c, ch;
float f, salary;
double d;
- Hằng là một thành phần của C, dùng để lưu trữ những giá trị không thay
đổi trong suốt quá trình thực thi chương trình. Hằng có thể mang các kiểu dữ liệu tương
tự như biến, chẳng hạn như hằng kiểu số nguyên, hằng kiểu số thực.
- Để khai báo và sử dụng hằng, chúng ta có hai cách như sau:
+ Sử dụng chỉ thị #define
Ví dụ: #define hangSoNguyen 1
+ Sử dụng từ khóa const:
Ví dụ: const hangSoThuc 1.5
* Cấu trúc rẽ nhánh if .. else, switch ... case.
- Để điều khiển dòng chảy của chương trình, cần phải kiểm soát các điều
kiện để thực thi công việc. Phát biểu if cho kiểm tra điều kiện đúng hay sai để tiếp tục
thực thi công việc.
Ví dụ: Đoạn mã lệnh dưới đây sẽ kiểm tra số nguyên nhập vào có
bằng 5 hay không, nếu đúng là bằng 5 sẽ in ra màn hình thông báo “số nhập vào bằng 5”,
nếu không bằng 5, in ra câu thông báo “số nhập vào khác 5”.
void main()
char sSoNhap;
printf("Nhập số:");
scanf("%s", sSoNhap);
if(int(sSoNhap) == 5)
printf("số %s bằng số 5", sSoNhap);
68
if(int(sSoNhap) != 5)
printf("số %s khác số 5", sSoNhap);
Hai phát biểu if trong đoạn mã lệnh trên có thể thay thế bằng phát
biểu if…else như sau.
void main()
char sSoNhap;
printf("Nhập số: ");
scanf("%s", sSoNhap);
if(int(sSoNhap) == 5)
printf("số %s bằng số 5", sSoNhap);
else
printf("số %s khác số 5", sSoNhap);
Phát biểu if(int(sSoNhap) != 5)đã được thay thế bằng phát
biểu else. Như vậy với khối lệnh if … else giúp dòng chảy của chương trình logic
và ngắn gọn hơn.
- Thay vì sử dụng phát biểu if…else, chúng ta có thể sử dụng phát biểu
switch…case như sau:
void main()
char sSoNhap;
printf("Nhập số: ");
scanf("%s", sSoNhap);
switch(int(sSoNhap))
case 5:
printf("số %s bằng 5", sSoNhap);
break;
69
default: printf("số %s khác số 5",
sSoNhap);
- Các phát biểu if…else hay switch…case đều có các chức năng giống
nhau, nhưng tùy vào từng trường hợp cụ thể để sử dụng phát biểu nào cho phù hợp
* Vòng lặp for, while và do while.
Có những công việc xảy ra trong chương trình và lặp lại nhiều lần, khi đó,
chúng ta phải sử dụng đến vòng lặp để thực thi công việc, thay vì phải viết đi viết lại mã
lệnh.
Ví dụ: In ra màn hình các số từ 1 đến 3. Để thực hiện công việc,
chúng ta có thể làm theo hai cách sau:
Viết lại mã lệnh nhiều lần.
void main()
int dem = 0;
dem = dem + 1;
printf("%d", dem);
dem = dem + 1;
printf("%d", dem);
dem = dem + 1;
printf("%d", dem);
Chúng ta có thể để ý thấy hai câu lệnh dem = dem + 1;
printf("%d", dem); được viết lại đến ba lần trong đoạn mã lệnh trên, rất dài dòng
và khó nhìn. Nếu phải in đến số 1000 thì đồng nghĩa hai câu lệnh trên phải được viết đến
1000 lần. Thay vì viết lại lại mã lệnh thực thi cùng một công việc nhiều lần như vậy,
chúng ta có thể sử dụng vòng lặp để rút ngắn mã lệnh như sau:
void main()
int dem = 0;
for(int i = 0; i < 3; i++)
dem = dem + 1;
printf("%d", dem);
70
Đoạn mã lệnh sử dụng vòng lặp for thực hiện công việc hoàn toàn
tương tự đoạn mã lệnh ở trên, nhưng hai câu lệnh dem = dem + 1;
printf("%d", dem); chỉ được viết có một lần, mã lệnh rất ngắn gọn và dễ đọc.
Nếu phải in đến số 1000 hay thậm chí 1000000, chỉ cần thay đổi số lần lặp của vòng lặp,
rất đơn giản và ngắn gọn,
for(int i = 0; i < 1000; i++)
...
Có thể thay vòng lặp for thành vòng lặp while như sau:
void main()
int dem = 0;
while(dem < 5)
dem = dem + 1;
printf("%d", dem);
Sự khác nhau giữa vòng lặp for và vòng lặp while ở đây là vòng lặp
for lặp lại công việc với số lần biết trước (được cho trước, ở trên là 3 lần hoặc 1000
lần), còn vòng lặp while lặp lại công việc cho đến khi điều kiện không còn đúng nữa
(điều kiện trong vòng lặp while ở trên là công việc sẽ ngừng thực thi cho đến khi biến
đếm không còn nhỏ hơn 5 nữa).
Ngoài ra, còn có vòng lặp do..while, cũng tương tư như vòng lặp while,
chỉ khác ở chỗ, không cần biết điều kiện đúng/sai, mã lệnh trong vòng lặp do…while
luôn thực được thực hiện ít nhất một lần. Tùy vào trường hợp cụ thể mà chúng ta lựa
chọn vòng lặp cho phù hợp.
* Hàm.
Hàm hay còn gọi là phương thức hay hành động, là một tập hợp các câu
lệnh được xây dựng nhằm thực hiện một công việc gì đó. Chương trình có thể sử dụng
hàm để thực hiện công việc nhiều lần mà không cần phải viết lại mã lệnh, giúp tối ưu
thực thi công việc, Mỗi hàm đều có kiểu và giá trị trả về, nếu không trả về gì nghĩa là
hàm đó trả về kiể void.
71
Ví dụ: Hàm tính tổng trong đoạn mã lệnh bên dưới được xây
dựng sẵn và được sử dụng hai lần.
int TinhTong(int a, int b)
return a + b;
void main()
int a = 5, b = 5, c = 10;
printf("a+b = %d", TinhTong(a,b));
printf("b+c = %d", TinhTong(b+c));
Như vậy, việc xác định trước công việc có thể thực hiện và xây dựng thành
một hàm, giúp chương trình thực hiện công việc logic và mã lệnh sẽ ngắn gọn hơn.
4.2.2. Thư viện lập trình wiringPi.
4.2.2.1. Sơ lượt về WiringPi.
WiringPi (viết tắt là WP) là một thư viện dùng để truy xuất GPIO của RPi được
viết bằng ngôn ngữ C cho BCM2835 (là bộ vi xử lý SoC được sử dụng trong RPi). WP
được thiết kế cho người dùng từng sử dụng hệ thống “wiring” của Arduino(1)
.
RPi có 26 chân kết nối GPIO. Trong đó có 8 chân general purpose I/O – những
chân này có thể được thiết lập là ngõ vào hoặc ngõ ra. Một trong những chân này có thể
được thiết kế cho đầu ra PWM. Thêm vào đó, RPi có 2 giao tiếp I2C, 5 giao tiếp SPI và 2
chân nối tiếp UART.
Các giao tiếp I2C, SPI, UART có thể được dùng như những chân general purpose
I/O khi chúng không được sử dụng trong chế độ bus của chúng, từ đó ta có tổng số chân
gpio trên RPi là 8 + 2 + 5 + 2 = 17 trên bộ kết nối P1 (ngoài ra, trên RPi revision 2 còn có
thêm bộ kết nối P5 với thêm 4 chân gpio).
WP có tiện ích dòng lệnh gpio có thể được sử dụng để lập trình và thiết lập các
chân GPIO. Chúng ta có thể sử dụng tiện ích này để đọc và ghi các tín hiệu của các chân,
thậm chí điều khiển hoạt động của chúng qua các shell script.
Để cài đặt WP, thực hiện tuần tự các bước sau:
- Cài đặt GIT, gõ lệnh:
sudo apt-get install git-core
72
- Nếu bước cài đặt GIT ở trên có thông báo lỗi, cần phải cập nhật phiên bản
mới nhất của HĐH Raspbian, sau đó, cài đặt lại GIT một lần nữa. Gõ các lệnh sau:
sudo apt-get update
sudo apt-get upgrade
- Sử dụng GIT để tải thư viện wiringPi về máy tính:
git clone git://git.drogon.net/wiringPi
- Chuyển vị trí đến thư mục của wiringPi:
cd wiringPi
- Để thiết lập wiringPi cho lần đầu tiên sử dụng, gõ lệnh:
git pull origin
- Để cài đặt wiringPi, chạy build script bằng cách gõ lệnh:
./build
Thực hiện tuần tự các bước trên, chúng ta đã cài đặt hoàn tất thư viện wiringPi, có
thể đính kèm vào trong các tập tin lập trình C để sử dụng cho lập trình điều khiển GPIO.
4.2.2.2. Lượt đồ chân của WiringPi.
Các chân GPIO mặc định có thể sử dụng bằng cách tham chiếu đơn giản bởi các
số từ GPIO0 đến GPIO7. Ngoài ra, còn có các chân được sử dụng cho nhũng mục đích
khác như SPI, I2C và UART.
WP chọn cách đánh số chân mặc bằng các số tự nhiên từ 0 đến 16. Các định nghĩa
phần cứng cơ bản được ẩn đi với lượt đồ đánh số đơn giản này. Ví dụ, trên Pi, sử dụng
WiringPi, chân số 0 là chân BCM_GPIO 17. Có một số bất cập với cách đánh số này, ví
dụ như một chương trình sử dụng wiringPi chân 2 trên RPi Rev 1 sẽ không thay đổi trên
RPi Rev 2, tuy nhiên, một số người sử dụng BCM_GPIO chân 21 trên RPi Rev 1 cần
thay đổi chương trình của họ sang sử dụng BCM_GPIO chân 27 trên RPi Rev 2.
WP cũng hỗ trợ lượt đồ đánh số của riêng mình theo lượt đồ đánh số chân của
BCM_GPIO, và theo RPi Rev 2, nó cũng hỗ trợ cách đánh số chân theo phần cứng vật lý
(chỉ dành cho bộ kết nối P1), nhưng khuyến khích sử dụng cách đánh số wiringPi đơn
giản (từ 0 đến 16).
Bảng dưới đây sẽ cho thấy sự ánh xạ của các chân RPi GPIO đến bộ kết nối (P1
và P5) GPIO liên quan đến số chân và vị trí vật lý trên bộ kết nối.
73
Hình 4.19: Lượt đồ chân của bộ kết nối (P1) GPIO trên RPi.
Hình 4.20: Lượt đồ chân của bộ kết nối (P5) GPIO trên RPi.
4.2.2.3. Một số hàm chức năng của WiringPi.
Các chức năng thiết lập: Có 4 cách để thiết lập wiringPi.
int wiringPiSetup (void) ;
int wiringPiSetupGpio (void) ;
int wiringPiSetupPhys (void) ;
int wiringPiSetupSys (void) ;
Một trong bốn hàm thiết lập trên phải được gọi thực thi khi bắt đầu chương trình,
nếu không, chương trình có thể hoạt động không đúng.
Chức năng Mô tả
wiringPiSetup(void)
Thiết lập này quy định chương trình sử dụng lượt
đồ đánh số chân mặc định của wiringPi. Lượt đồ
đánh số chân đơn giản hóa này cung cấp một sự
ánh xạ các số chân ảo từ 0 đến 16 với số chân thật
74
cảu Broadcom GPIO. Phương thức này phải được
thực thi với phân quyền root.
wiringPiSetupGpio(void)
Phương thức này giống phương thức trên, tuy
nhiên, chương trình có thể dùng số chân Broadcom
GPIO trực tiếp mà không cần phải ánh xạ lại.
Phương thức này cũng phải được gọi với quyền
root.
* Chú ý: Một số chân khác biệt giữa mạch Rev 1
và Rev2.
wiringPiSetupPhys(void)
Giống với ở trên, tuy nhiên, chương trình cho phép
sử dụng số chân vật lý chỉ trên bộ kết nối P1.
Phương thức này cũng phải gọi với quyền root.
wiringPiSetupSys(void)
Phương thức này cũng thiết lập wiringPi nhưng sử
dụng /sys/class/gpio hơn là truy xuất trực tiếp
phần cứng. Cách đánh số chân ở chế độ này thuần
khiết là số chân của Broadcom GPIO, vì vậy, phải
nhận ra được sự khác nhau giữa mạch Rev 1 và
Rev 2.
Bảng 4.15: Các phương thức thiết lập wiringPi.
Các chức năng cốt lõi: Các chức năng này làm việc trực tiếp trên Raspberry Pi
cũng như các mô-đun GPIO bên ngoài như mạch mở rộng GPIO và những thành phần
khác. Mặc dù vậy, không phải tất cả các mô-đun đều hỗ trợ tất cả các chức năng - ví dụ
các PiFace được cấu hình trước cho các đầu vào và đầu ra cố định của nó, và Raspberry
Pi không có phần cứng on-board tương tự.
Chức năng Mô tả
void pinMode(int pin, int
mode)
Phương thức này thiết lập chế độ của một
chân là INPUT, OUTPUT, PWM_OUTPUT
hay GPIO_CLOCK.
* Chú ý: wiringPi chân 1 (BCM_GPIO 18)
hỗ trợ PWM output và chỉ có wiringPi chân
7 (BCM_GPIO 4) hỗ trỡ CLOCK output
mode.
Phương thức này không có tác dụng khi ở
75
chế độ Sys mode. Nếu muốn thay đổi chể độ
của một chân, có thể sử dụng script gpio
trước khi bắt đầu chương trình.
void pullUpDnControl(int
pin, int pud)
Thiết lập chế độ điện trở pull-up hay pull-
down trên một chân nhất định, chân cần
được thiết lập là một đầu vào.
Chức năng này không có tác dụng trên RPi
GPIO khi ở chế độ Sys mode. Nếu muốn
kích hoạt pul-up/pull-down, có thể sử dụng
script gpio trước khi bắt đầu chương trình.
void digitalWrite(int pin,
int value)
Ghi giá trị HIGH hoặc LOW (1 hoặc 0) đến
chân nhất định, chân mà trước đó đã được
thiết lập là một ngõ ra.
WiringPi xem bất kỳ số khác 0 như HIGH,
tuy nhiên 0 là đại diện duy nhất của LOW.
void pwmWrite(int pin, int
value)
Ghi giá trị đến thanh ghi PWM cho một nhất
định.
Chức năng này là không thể kiểm soát PWM
on-board của RPi khi ở chế độ Sys mode.
int digitalRead(int pin)
Chức năng này trả về giá trị đọc tại một chân
nhất định. Giá trị này sẽ là HIGH hay LOW
phụ thuộc vào mức logic tại chân đó,
analogRead(int pin) Chức năng này trả về giá trị đọc trên chân
đầu vào analog được cung cấp.
analogWrite(int pin, int
value)
Ghi giá trị cho sẵn đến một chân analog. Cần
phải đăng ký mô-đun analog để cho phép
thêm chức năng này cho các thiết bị như
Gertboard.
Bảng 4.16: Các chức năng cốt lõi của wiringPi.
4.2.2.4. Thực hành bật đèn led với Raspberry sử dụng thư viện wiringPi.
Bài thực hành này cũng giống như bài bật đèn led sử dụng thư viện RPi.GPIO
trong phần 4.1.2, cũng cần chuẩn bị các thiết bị, linh kiện và lắp mạch điện tương tự. Tuy
nhiên, bài này sẽ sử dụng thư viện wiringPi để lập trình điều khiển chân GPIO, kích hoạt
nguồn điện 3V vào chân GPIO để làm đèn led phát sáng.
76
Hình 4.21: Mạch điện đã lắp ráp xong.
- Tạo mới tập tin batdenled.c bằng cách gõ lệnh vi batdenled.
Hình 4.22: Tạo mới tập tin batdenled.c.
- Nhấn phím i trên bàn phím để kích hoạt chức năng nhập ký tự cho tập tin
batdenleb.c.
- Nhập đoạn mã lệnh sau vào tập tin batdenled.c:
#include <stdio.h>
#include <wiringpi.h>
const int chanDenLed = 7;
void main()
/* Thiết lập sử dụng cấu hình của wiringPi */
wiringPiSetup();
/* Thiết lập chân số 7 là ngõ ra */
pinMode(chanDenLed, OUTPUT);
/* Bật nguồn 3V cho chân số 7 */
digitalWrite(chanDenLed, HIGH);
77
Hình 4.23: Nhập mã lệnh Python cho tập tin batdenled.c.
- Nhấn phím Esc trên bàn phím để thoát chế độ nhập ký tự cho tập
tin batdenled.c.
- Gõ lệnh :x và nhấn phím Enter để lưu và thoát khỏi tập tin
batdenled.c.
- Biên dịch tập tin batdenled.c bằng cách gõ lệnh:
sudo gcc -o batdenled batdenled.c -l wiringPi
Hình 4.24: Biên dịch tập tin batdenlen.c thành mã máy.
- Lệnh biên dịch trên sẽ tạo ra một tập tin batdenled, có thể kiểm tra
bằng lệnh ls –la. Thực thi mã lệnh đã biên dịch, gõ lệnh:
sudo ./batdenled
Hình 4.25: Thực thi mã lệnh C của tập tin batdenled vừa được biên dịch từ batdenled.c.
Sau khi thực thi lệnh sudo ./batdenled, nguồn điện 3V sẽ được kích hoạt cho chân
số 7 (theo sơ đồ chân wiring đánh số đơn giản từ 0 đến 16), đèn led nhận được nguồn
điện cung cấp từ chân số 7 và phát sáng.
78
5. Một số bài thực hành ứng dụng Raspberry Pi.
5.1. Bật và tắt đèn LED khi nhấn công tắc điện.
Bài thực hành này là sự kết hợp giữa bài thực hành bật công tắc điện trong phần
3.3 – sử dụng chận GPIO và bài thực hành bật đèn led trong phần 4.1.2 – thư viện lập
trình GPIO. Khi nhấn công tắc, nếu đèn led đang sáng, thì sẽ tắt dèn led. Ngược lại, khi
đèn led đang tắt, nhấn công tắc điện, đèn led sẽ sáng.
Chuẩn bị:
- RPi và các thiết bị kết nối cho RPi.
- 1 đèn led, 1 điện trở 50Ω, 1 công tắc điện mini.
- 5 dây dẫn điện (female to female jumper wire).
Thực hành:
- Lắp ráp mạch điện như trong hình 5.1.
Hình 5.1: Sơ đồ mạch điện lắp điện trở, đèn led và công tắc với RPi.
79
- Khởi động và đăng nhập vào RPi với người dùng pi và mật khẩu
raspberry (hoặc mật khẩu của RPi).
- Tạo mới tập tin battatdenled.py bằng cách gõ lệnh:
vi battatdenled.py
- Nhấn phím i trên bàn phím để bật chức năng nhập ký tự cho tập tin
battatdenled.py, sau đó nhập nội dung như bên dưới vào tập tin battatdenled.py:
import RPi.GPIO as GPIO
import time
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(23,GPIO.IN,pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(4, GPIO.OUT)
status = 1
print "Xin chao ban! Nhan cong tac dien"
while True:
if(GPIO.input(23)==1):
if status == 0:
GPIO.output(4, False)
print "OFF"
status = 1
time.sleep(0.5)
continue
if status == 1:
GPIO.output(4, True)
print "ON"
status = 0
time.sleep(0.5)
continue
80
Hình 5.2: Nhập mã lệnh Python cho tập tin battatdenled.py.
- Nhấn phím Esc trên bàn phím để thoát chế độ nhập ký tự, sau đó gõ lệnh
:x để lưu và thoát khỏi tập tin battatdenled.py.
- Thực thi tập tin battatdenled.py bằng cách gõ lệnh:
sudo python battatdenled.py
Hình 5.3: Thực thi tập tin battatdenled.py sẽ yêu câu nhấn công tắc điện.
81
- Sau khi thực thi tập tin battatdenled.py, chương trình sẽ yêu cầu chúng ta
nhấn công tắc. Khi chúng ta nhấn công tắc lần thứ nhất, nếu đèn led đang tắt sẽ bật sáng
và màn hình in ra từ “ON”, nhấn lần thứ hai, đèn led sẽ tắt và màn hình in ra từ “OFF”.
Hình 5.4: Màn hình in ra trạng thái của đèn led khi nhấn công tắc.
5.2. Nhấp nháy đèn led với số lần nháy và khoảng cách giữa mỗi lần nhấp nháy cho
trước.
Bài thực hành này tương tự như bài thực hành bật đèn led trong phần 4.1.2 – thư
viện lập trình GPIO, tuy nhiên, chúng ta sẽ cải tiến chương trình Python, thay vì bật đèn
led, chúng ta sẽ làm cho đèn led nhấp nháy với số lần nhấp nháy và khoảng cách giữa
mỗi lần nhấp nháy được ta nhập vào từ bàn phím.
Chuẩn bị:
- RPi và các thiết bị kết nối cho RPi.
- 1 đèn led, 1 điện trở 50Ω.
- 3 dây dẫn điện (female to female jumper wire).
Thực hành:
- Lắp mạch điện như trong hình 5.5.
82
Hình 5.5: Sơ đồ mạch điện lắp điện trở, đèn led với RPi.
- Khởi động và đăng nhập vào RPi với người dùng pi và mật khẩu
raspberry (hoặc mật khẩu của RPi).
- Tạo mới tập tin nhapnhayled.py bằng cách gõ lệnh:
vi nhapnhayled.py
- Nhấn phím i trên bàn phím để bật chức năng nhập ký tự cho tập tin
nhapnhayled.py, sau đó nhập nội dung như bên dưới vào tập tin nhapnhayled.py:
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(7, GPIO.OUT)
def Blink(numTimes, speed):
for i in range(0, numTimes):
83
print "Iteration " + str(i+1)
GPIO.output(7, True)
time.sleep(speed)
GPIO.output(7, False)
time.sleep(speed)
print "Done"
GPIO.cleanup()
iterations = raw_input("Nhap so lan nhap nhay
cho den led: ")
speed = raw_input("Nhap khoang cach giua moi
lan nhap nhay ( don vi : ms): ")
Blink(int(iterations),float(speed))
Hình 5.6: Nhập mã lệnh Python cho tập tin nhapnhayled.py.
- Nhấn phím Esc trên bàn phím để thoát chế độ nhập ký tự, sau đó gõ lệnh
:x để lưu và thoát khỏi tập tin nhapnhayled.py.
84
- Thực thi tập tin nhapnhayled.py bằng cách gõ lệnh:
sudo python nhapnhayled.py
Hình 5.7: Chương trình Python hoạt động, nhập vào số lần nháy và khoảng cách giữa
mỗi lần nhấp nháy, đèn led sẽ nhấp nháy và màn hình sẽ in ra trạng thái của đèn led.
- Sau khi gõ lệnh sudo python nhapnhayled.py, chương trình hoạt động và
yêu cầu nhập vào số lần nhấp nháy và khoảng cách giữa mỗi lẫn nhấp nháy cho đèn led.
Sau khi nhập đủ hai giá trị trên, chương trình sẽ bắt đầu nhấp nháy đèn led và số lần nháy
của đèn led sẽ được chương trình in ra màn hình (như trong hình 5.7 ở trên).
5.3. Tạo ứng dụng đo nhiệt độ và độ ẩm môi trường, sử dụng Raspberry Pi và cảm
biến nhiệt độ, độ ẩm - DHT11.
5.3.1. Một số lý thuyết.
5.3.1.1. Sơ lượt về Crontab trong Linux.
Lệnh crontab là một lệnh trên hệ điều hành Unix hoặc Linux, dùng để sắp xếp
cách lệnh thực thi theo định kì . Để xem crontabs đang chạy như thế nào trên hệ thống, có
thể mở terminal (giao diện dòng lệnh) và gõ lệnh:
sudo crontab -l
Để chỉnh sửa danh sách công việc trong crontab, gõ lệnh:
sudo crontab -e
85
Lệnh sudo crontab -e sẽ mở một trình soạn thảo mặc định để chúng ta chỉnh sửa
crontab. Nếu lưu và thoát trình soạn thảo (với lệnh :x), tất cả các cronjobs (danh sách
công việc trong crontab) được lưu vào crontab. Cronjobs được viết theo định dạng:
* * * * * /root/Desktop/test.sh
Năm dấu hoa thị đại diện cho các thành phần ngày giờ như sau:
Dấu * thứ nhất đại diện cho phút (từ 0 đến 59)
Dấu * thứ hai đại diện cho giờ (từ 0 đến 23)
Dấu * thứ ba đại diện cho ngày của tháng (từ 1 đến 31)
Dấu * thứ tư đại diện cho tháng (từ 1 đến 12)
Dấu * thứ năm đại diện cho ngày trong tuần (0 = Chủ nhật)
Với cronjob như trên (* * * * * /root/Desktop/test.sh), công việc sẽ được thực thi
mỗi phút một lần:
* mỗi phút
* của mỗi giờ
* của mỗi ngày trong tháng
* của mỗi tháng
* của mỗi ngày trong tuần
Nếu muốn thực thi công việc mỗi 1 giờ sáng thứ 6 một lần, ta có định dạng như
sau: 0 1 * * 5 /root/Desktop/test.sh
- phút: 0
- của giờ: 1
- của ngày trong tháng: * (mỗi ngày trong tháng)
- của tháng: * (mỗi tháng)
- ngày trong tuần: 5 (= thứ 6)
Nếu muốn thực thi công việc mỗi 1 giờ sáng từ thứ 2 đến thứ 6 một lần, ta có định
dạng như sau: 0 1 * * 1-5 /root/Desktop/test.sh
- phút: 0
- của giờ: 1
- của ngày trong tháng: * (mỗi ngày trong tháng)
- của tháng: * (mỗi tháng)
86
- ngày trong tuần: 1-5 (= thứ 2 đến thứ 6)
Nếu muốn thực thi công việc mỗi 10 phút một lần, định dạng như sau:
0,10,20,30,40,50 * * * * /root/Desktop/test.sh
hoặc
*/10 * * * * /root/Desktop/test.sh
Để lưu trữ thông tin đầu ra của crontab, sử dụng toán tử >> để ghi nội dung thông
tin đầu ra vào một tập tin tùy ý:
*/10 * * * * /root/Desktop/test.sh >> /root/Desktop/test.log 2>&1
Linux có thể report ở nhiều mức khác nhau. Có chuẩn đầu ra (STDOUT) và
chuẩn lỗi (STDERR). STDOUT được đánh dấu là 1, STDERR được đánh dấu là 0. Vì
thế, phát biểu bên dưới sẽ bảo Linux lưu trữ STDERR trong STDOUT, tạo thành một
dòng dữ liệu chung cho tin nhắn và lỗi:
2>&1
Như vậy, chúng ta có một dòng dữ liệu, và chúng ta có thể cho nó vào một
tập tin để lưu trữ. Toán tử > sẽ ghi đè tập tin, còn toán tử >> sẽ mở rộng tập tin. Ở đây,
chúng ta dùng toán tử mở rộng.
>> /root/Desktop/test.log
5.3.1.2. Tổng quan về Dygraphs - thư viện vẽ biểu đồ bằng javascript.
Dygraphs là một thư viện javascript mã nguồn mở giúp vẽ các biểu đồ phức tạp
một cách nhanh chóng. Dygraphs cho phép người dùng truy xuất các tập tin chứa dữ liệu
để vẽ biểu đồ.
Hình 5.8: Biểu đồ nhiệt độ vẽ bằng dygraphs với dữ liệu lấy từ tập tin my-vs-sf.txt.
87
Biểu đồ có tính tương tác với người dùng.
- Khi rê chuột lên biểu đồ, các giá trị sẽ hiển thị nổi bật lên.
- Có thể nhấn giữ chuột và kéo để phóng to vùng biểu đồ.
- Nháy đúp chuột để đưa biểu đồ trở lại trạng thái ban đầu (chưa zoom).
Một số đặc điểm của dygraphs:
- Xử lý tập dữ liệu lớn: Dygraphs có thể vẽ hàng triệu điểm trên bản đồ mà
không có vấn đề gì.
- Tính tương tác: Phóng to, thu nhỏ mặc định, nổi bật dữ liệu.
- Tính tương thích cao: Dygraphs hoạt động tốt trên hầu hết các trình duyệt
(bao gồm cả IE8), thậm chí có thể hoạt động tốt trên thiết bị di động hay máy tính bảng.
- Có cộng động phát triển và hỗ trợ dygraphs lớn.
Để sử dụng được thư viện dygraphs, tải thư viện dygraph-combined.js, đính kèm
vào tập tin HTML và thiết lập một dygraphs object.
- Đính kèm thư viện dygraphs vào html.
<script type="text/javascript" src="dygraphs-combined.js">
</script>
- Khởi tạo một dygraphs object mới với tham số thứ nhất là id của thẻ div
(khung chứa biểu đồ), tham số thứ 2 là dữ liệu cho biểu đồ.
g = new Dygraph(
<!--Thẻ div chứa biểu đồ-->
document.getElementById("graphdiv"),
<!--Dữ liệu CSV hoặc đường dẫn đến tập
tin CSV. -->
"Date,Temperature\n" +
"2008-05-07,75\n" +
"2008-05-08,70\n" +
"2008-05-09,80\n"
);
88
Hình 5.9: Ví dụ cơ bản sử dụng thư viện dygraps.
Trong ví dụ trên, dữ liệu để vẽ biểu đồ là dữ liệu gán bằng tay. Trong ví dụ sau,
chúng ta sẽ lấy dữ liệu từ tập tin lưu trữ dạng cvs bằng cách đưa đường dẫn đến tập tin
CVS, thay vì dữ liệu gán tĩnh. Thư viện dygraphs sẽ chuyển đổi dữ liệu này, điều chỉnh
khung chứa biểu đồ để hợp lý với lượng dữ liệu, tính toán phạm vi trục tạo độ và đánh
dấu điểm để vẽ biểu đồ.
Hình 5.10: Vẽ biểu đồ với dữ liệu lấy từ tập tin CVS – temperature.cvs.
89
Hình 5.11: Nội dung tập tin temperature.cvs.
Tìm hiểu thêm về dygraphs có thể tham khảo tại website:
http://dygraphs.com/tutorial.html
5.3.1.3. Sơ lượt về cảm biển nhiệt độ và độ ẩm – AOSONG DHT11.
DHT11 là cảm biến nhiệt độ và độ ẩm kỹ thuật số. Ứng dụng được dành riêng
công nghệ mô-đun kỹ thuật số và công nghệ cảm biến nhiệt độ và độ ẩm, để đảm bảo sản
phẩm có độ tin cậy cao và ổn định lâu dài, chi phí thấp, đo lường nhiệt độ và độ ẩm tương
đối, phản hồi nhanh, khả năng chống nhiễu mạnh, khoảng cách truyền dẫn tín hiệu siêu
dài, một đầu ra tín hiệu kỹ thuật với độ hiệu chỉnh chính xác.
90
Hình 5.12: Một số thông tin về DHT11.
DHT11 có 4 chân, một chân VCC dẫn nguồn điện từ 3.3 đến 5V, chân GND
(ground) 0V, chân data truyền tín hiệu dữ liệu nhiệt độ và độ ẩm, cuối cùng là 1 chân
N/A (hay NC – not connect) không sử dụng.
Hình 5.13: Các chân của cảm biến DHT11.
Chân Tên Mô tả
1 VCC Nguồn điện cung cấp 3 - 5.5 V DC
2 DATA Serial data output
3 NC Not connected
4 GND Ground
Bảng 5.1: Các chân của cảm biến DHT11.
91
5.3.2. Thực hành.
5.3.2.1. Các thiết bị, lắp ráp mạch.
Các thiết bị, linh kiện cần thiết:
- 1 RPi Model B version 2 và các thiết bị kết nối cho RPi.
- 1 cảm biến nhiệt độ, độ ẩm DHT11.
- 1 điện trở 10000 Ohm.
- 1 số dây dẫn điện jumper wire.
- 1 mạch ráp thử breadboard (có thể không dùng).
Sử dụng breadboard và các dây nhảy kết nối RPi với DHT11 như sau:
RPi VCC (chân số 1) DHT11 chân 1
RPi GPIO4 (chân số 7) DHT11 chân 2
RPi GND (chân số 6) DHT11 chân 4
Kết nối DHT11 chân 1 với DHT11 chân 2 bằng 1 con điện trở 10000 Ohm.
DHT11 chân 1 nối với chân phía bắt đầu vòng màu điện trở.
DHT11 chân 2 nối với chân còn lại của điện trở.
92
Sau khi kết nối hoàn tất, ta được sơ đồ mạch điện như sau:
Hình 5.14: Sơ đồ lắp ráp RPi với DHT11 và điện trở 10000Ω.
5.3.2.2. Giao tiếp giữa Raspberry Pi và DHT11.
RPi có thể giao tiếp với DHT11 thông qua serial interface, kết nối bằng các dây
dẫn điện jumper wire và sử dụng thư viện lập trình wiringPi. Nếu chưa cài đặt thư viện
wiringPi, có thể sử dụng các lệnh sau để cài đặt:
sudo apt-get install git-core build-essential
git clone git://git.drogon.net/wiringPi
cd wiringPi
./build
93
Sử dụng mã lệnh lập trình C bên dưới đây, lưu vào một tập đặt tên là dht11.c, lưu
vào thư mục /home/pi/Desktop.
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#define MAX_TIME 85
#define DHT11PIN 7
#define ATTEMPTS 5
int dht11_val[5]=0,0,0,0,0;
int dht11_read_val()
uint8_t lststate=HIGH;
uint8_t counter=0;
uint8_t j=0,i;
for(i=0;i<5;i++)
dht11_val[i]=0;
pinMode(DHT11PIN,OUTPUT);
digitalWrite(DHT11PIN,LOW);
delay(18);
digitalWrite(DHT11PIN,HIGH);
delayMicroseconds(40);
pinMode(DHT11PIN,INPUT);
for(i=0;i<MAX_TIME;i++)
counter=0;
while(digitalRead(DHT11PIN)==lststate)
counter++;
delayMicroseconds(1);
94
if(counter==255)
break;
lststate=digitalRead(DHT11PIN);
if(counter==255)
break;
// Top 3 transistions are ignored
if((i>=4)&&(i%2==0))
dht11_val[j/8]<<=1;
if(counter>16)
dht11_val[j/8]|=1;
j++;
// Verify checksum and print the verified data
if((j>=40)&&(dht11_val[4]==((dht11_val[0]+dht1
1_val[1]+dht11_val[2]+dht11_val[3])& 0xFF)))
printf("%d.%d,%d.%d\n",dht11_val[0],dht11_val[
1],dht11_val[2],dht11_val[3]);
return 1;
else
return 0;
int main(void)
int attempts=ATTEMPTS;
if(wiringPiSetup()==-1)
exit(1);
while(attempts)
95
int success = dht11_read_val();
if (success)
break;
attempts--;
delay(500);
return 0;
Biên dịch và thực thi mã nguồn với các lệnh sau:
gcc -o dht11 dht11.c -L/usr/local/lib -lwiringPi -lpthread
sudo ./dht11
Chương trình được thực thi sẽ trả về cho chúng ta 2 con số, số thứ nhất là dữ liệu
độ ẩm, số thứ là dữ liệu nhiệt độ.
Hình 5.15: Thực thi tập tin dht11.c sẽ trả về giá trị nhiệt độ và độ ẩm.
5.3.2.3. Ghi tập tin log lưu dữ liệu nhiệt độ và độ ẩm.
Cách đơn giản nhất để ghi nhật ký dữ liệu nhiệt độ và độ ẩm cho chương trình là
sử dụng cronjob. Chương trình phải chạy với quyền root, vì vậy, sử dụng lệnh sau:
sudo crontab -e
96
Nhập nội dung bên dưới ở cuối crontab. Crontab sẽ lưu lại mốc thời gian và nhiệt
độ cũng như độ ẩm mỗi phút vào một tập tin có tên là temp.log trong thư mục /var/www.
* * * * * echo `date +\%Y\%m\%d\%H\%M\%S`,`/home/pi/Desktop/dht11` >> /var/www/tempss.log
Để lưu thay đổi crontab, nhấn đồng thời hai phím Cttrl + X, sau đó nhấn Y rồi
nhấn phím Enter.
Nếu crontjob không làm việc, nghĩa là crontab hiện tại không hoạt động. Để khởi
động crontab, sử dụng lệnh sau:
sudo service cron start
hoặc
/etc/init.d/cron start
5.3.2.4. Hiển thị dữ liệu nhiệt độ và độ ẩm.
Khi đã ghi nhật ký dữ liệu vào tập tin temp.log, cứ kiểm tra thông tin bằng cách
mở tập tin temp.log lên xem thì không phải là một cách hay. Thay vào đó, chúng ta sử
dụng thư viện dygraphs để vẽ biểu đồ lên trình duyệt web dựa trên dữ liệu của tập tin
temp.log. Lưu mã nguồn web bên dưới vào trong tập tin temp.html và lưu tập tin vào
trong thư mục /var/www/.
<html>
<head>
<script type="text/javascript" src="dygraph-
combined.js"></script>
</head>
<body>
<div id="graphdiv" style="width:750px;
height:400px;"></div>
<script type="text/javascript">
function addZero(num)
var s=num+"";
if (s.length < 2) s="0"+s;
return s;
function dateFormat(indate)
var hh = addZero(indate.getHours());
var MM = addZero(indate.getMinutes());
//var ss = addZero(indate.getSeconds());
97
var dd = addZero(indate.getDate());
var mm = addZero(indate.getMonth()+1);
var yyyy = addZero(indate.getFullYear());
return dd+'/'+mm+' '+hh+':'+MM;
g = new Dygraph(
document.getElementById("graphdiv"),
"temp.log",
xValueParser: function(x)
var date = new Date(x.replace(
/^(\d4)(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)$/,
'$4:$5:$6 $2/$3/$1'
));
return date.getTime();
,
axes:
x:
ticker: Dygraph.dateTicker,
axisLabelFormatter: function(x)
return dateFormat(new Date(x));
,
valueFormatter: function(x)
return dateFormat(new Date(x));
,
labelsDivWidth: 310,
rollPeriod: 30,
strokeWidth: 2.0,
labels: ['Date','Độ ẩm: (%)',Nhiệt độ: (°C)']
);
</script>
</body>
</html>
Tải thư viện dygraphs và lưu vào thư mục /var/www/ dùng lệnh:
wget -P /var/www http://dygraphs.com/dygraph-combined.js
Cuối cùng, chỉ cần mở trình duyệt và truy cập vào http://localhost/temp.html,
(trong hình 5.16, địa chỉ IP của RPi là 192.168.1.118, được dùng thay localhost) chúng ta
sẽ có biểu đồ nhiệt độ, và độ ẩm theo thời gian, giống như hình bên dưới.
98
Hình 5.16: Biểu đồ nhiệt độ, độ ẩm được vẽ bằng thư viện dygraphs và lấy dữ liệu từ tập
tin temp.log.
Nếu trang web không hoạt động, nghĩa là máy chủ web chưa được cài đặt trên RPi
của bạn. Để cài đặt máy chủ web cho RPi, từ giao diện dòng lệnh, gõ lệnh:
sudo apt-get install apache2 -y
Để kiểm tra máy chủ web apache đã được cài đặt cho RPi hay chưa, mở trình
duyệt web và gõ localhost, sau đó nhân phím Enter.
Hình 5.17: Máy chủ web đã được cài đặt trên RPi và hoạt động.
Khi máy chủ web đã cài đặt, truy cập lại địa chỉ web http://localhost/temp.html để
xem biểu đồ nhiệt độ và độ ẩm.
99
PHỤ LỤC
DANH MỤC TỪ VIẾT TẮT
1. RPi: Raspberry Pi.
2. GPIO: General Purpose Input/Output.
3. HĐH: Hệ Điều Hành
4. WP: WiringPI
DANH MỤC BIỂU
Bảng 2.1: Các lệnh Linux thông dụng.
Bảng 4.1: Một số từ khóa trong Python.
Bảng 4.2: Dữ liệu kiểu Numbers trong Python.
Bảng 4.3: Toán tử toán học.
Bảng 4.4: Toán tử so sánh.
Bảng 4.5: Toán tử gán.
Bảng 4.6: Toán tử bitwise.
Bảng 4.7: Toán tử logic.
Bảng 4.8: Toán tử thành viên.
Bảng 4.9: Toán tử định danh.
Bảng 4.10: Phát biểu của cấu trúc rẽ nhánh.
Bảng 4.11: Bộ từ khóa dành riêng của ngôn ngữ lập trình C.
Bảng 4.12: Dữ liệu kiểu số nguyên – integer.
Bảng 4.13: Dữ liệu kiểu số thực – floating-point.
Bảng 4.14: Dữ liệu kiểu void.
Bảng 4.15: Các phương thức thiết lập wiringPi.
Bảng 4.16: Các chức năng cốt lõi của wiringPi.
Bảng 5.1: Các chân của cảm biến DHT11.
100
DANH MỤC HÌNH ẢNH
Hình 1.1: Máy tính Raspberry Pi với kích thước chỉ bằng kích thước của thẻ tín dụng.
Hình 1.2: Cáp HDMI to HDMI dùng để kết nối RPi với màn hình tivi LCD có hỗ trợ
cổng HDMI.
Hình 1.3: Jack cắm Vedeo Analog để kết nối RPi với màn hình tivi đời cũ, không có hỗ
trợ cổng HDMI.
Hình 1.4: Đầu sạc microUSB dùng để nạp nguồn điện cho RPi.
Hình 1.5: RPi được kết nối đầy đủ với bàn phím, chuột, mà hình tạo thành một bộ vi tính
nhỏ gọn chỉ với nguồn điện 5V.
Hình 1.6: Tạo mạch đèn LED nhấp nháy với RPi.
Hình 1.7: Robot mini đơn giản vận hành bởi máy tính RPi.
Hình 1.8: Raspberry model A và Raspberry model B.
Hình 1.9: Raspberry model B+ và Raspberry model B.
Hình 1.10: Phân biệt Raspberry Pi model B v2 xuất xứ ở Anh hoặc Trung Quốc.
Hình 1.11: RPi xuất xứ Trung Quốc.
Hình 1.12: Cấu trúc Raspberry Pi model B v2.
Hình 1.13: Raspberry Pi model B v2.
Hình 1.14: Raspberry Pi model A không có cổng kết nối cáp mạng RJ45.
Hình 1.15: RPi mẫu B+ có sự cải tiển về cổng kết nối và số lượng chân GPIO.
Hình 2.1: Tải NOOBS từ internet.
Hình 2.2: Các thư mục và tập tin con được giải nén từ gói NOOBS_v1_3_8.zip.
Hình 2.3: Format thẻ SD với SD Formatter 4.0.
Hình 2.4: Màn hình tivi có hỗ trợ khe cắm HDMI, kết nối một đầu cáp HDMI với khe
này.
Hình 2.5: Cáp HDMI to HDMI dùng để kết nối RPi vơi màn hình tivi hỗ trợ khe cắm
HDMI .
Hình 2.6: Màn hình máy tính bàn, có thể kết nối với RPi thông qua cáp chuyển đổi
HDMI to VGA.
101
Hình 2.7: Cáp chuyển đổi từ ngõ HDMI sang VGA, dùng để kết nối RPi với màn hình
máy tính bàn.
Hình 2.8: Cáp VGA dùng để kết nối với màn hình máy tỉnh để bàn.
Hình 2.9: Cáp chuyển đối HDMI to VGA và cáp VGA dùng để kết nối màn hình máy
tính bàn.
Hình 2.10: Kết nối RPi tới màn hình máy tính bàn thông cáp chuyển đổi HDMI to VGA
và cáp VGA.
Hình 2.11: RPi đã được kết nối hoàn tất, chỉ cần cắm sạc điện 5V là có thể hoạt động.
Hình 2.12: Chọn hệ điều hành Raspbian và click Install để cài đặt HĐH cho RPi.
Hình 2.13: Hộp thoại báo cài đặt thành công, nhấn OK để tiếp tục.
Hình 2.14: RPi tự thiết lập các cấu hình mặc định.
Hình 2.15: Danh mục cấu hình hệ thống cho RPi.
Hình 2.16: Màn hình sau khi kết thúc cài đặt.
Hình 2.17: Giao diện đồ họa, màn hình Desktop của hệ điều hành Raspbian trên RPi.
Hình 2.18: Sử dụng lệnh sudo ifconfig để kiểm tra địa chỉ IP của RPi.
Hình 2.19: Kết nối tới RPi với phần mềm Putty.
Hình 2.20: Putty đã kết nối với RPi sau khi nhập user và password.
Hình 2.21: Chương trình SSH Secure Shell dùng để điều khiển RPi bằng lệnh.
Hình 2.22: Nhập IP và user của RPi để kết nối đến RPi.
Hình 2.23: Nhập mật khẩu để xác nhận kết nối.
Hình 2.24: SSH Secure Shell đã kết nối đến RPi.
Hình 2.25: SSH Secure File Transfer dùng để chuyển dữ liệu giữa RPi với desktop.
Hình 3.1: Các chân GPIO trên Raspberry Pi model B v2.
Hình 3.2: Sơ đồ kết nối cảm biến đo nhiệt độ và độ ẩm ASONG DHT22 với các chân
GPIO của RPi.
Hình 3.3: Sơ đồ chân GPIO của RPi mẫu B v2.
Hình 3.4: Sơ đồ lắp ráp RPi với DHT11 và điện trở 10000Ω (Ohm).
Hình 3.5: Sạc nguồn microUSB 5V.
102
Hình 3.6: Cáp chuyển HDMI sang VGA.
Hình 3.7: Dây dẫn điện jumper wire.
Hình 3.8: Công tắc điện mini.
Hình 3.9: Kết nối công tắc mini với RPi bằng dây dẫn điện jumer wire.
Hình 3.10: Kết nối RPi với màn hình, chuột usb và bàn phím usb, sạc microUSB 5V.
Hình 3.11: Sử dụng lệnh cd để chuyển vị trí đến Desktop của người dùng pi trên RPi.
Hình 3.12: Sử dụng lệnh vi để tạo mới tập tin congtac.py.
Hình 3.13: Nhập đoạn mã lập trình Python vào trong tập tin congtac.py.
Hình 3.14: Thực thi mã lệnh Python trong tập tin congtac.py.
Hình 3.15: Màn hình ra câu “Ban vua nhan cong tac dien” khi nhấn công tắc.
Hình 4.1: Vào Python shell bằng cách gõ lệnh python.
Hình 4.2: In câu “Hello World” ra màn hình.
Hình 4.3: Chạy mã lệnh từ tập tin test.py.
Hình 4.4: Sử dụng dòng và thụt đầu dòng để định nghĩa khối mã lệnh.
Hình 4.5: Khối lệnh else sai vì số lượng khoảng trắng của dòng lệnh không đồng bộ.
Hình 4.6: Đèn led.
Hình 4.7: Điện trở 56Ω.
Hình 4.8: Dây dẫn điện
Hình 4.9: Tạo mới tập tin batdenled.py.
Hình 4.10: Nhập mã lệnh Python cho tập tin batdenled.py.
Hình 4.11: Lưu và thoát khỏi tập tin batdenled.py với lệnh :x.
Hình 4.12: Thực thi mã lệnh của tập tin batdenlen.py.
Hình 4.13: Đèn led phát sáng khi thực thi tập tin batdenled.py.
Hình 4.14: Tạo mới tập tin xinchao.c.
Hình 4.15: Nhập nội dung mã lệnh cho tập tin xinchao.c.
Hình 4.16: Biên dịch tập tin xinchao.c thành mã máy.
Hình 4.17: Tập tin a.out được tạo ra sau khi biên dịch tập tin xinchao.c.
103
Hình 4.18: Thực thi chương trình C và in ra câu "Xin chao moi nguoi".
Hình 4.19: Lượt đồ chân của bộ kết nối (P1) GPIO trên RPi.
Hình 4.20: Lượt đồ chân của bộ kết nối (P5) GPIO trên RPi.
Hình 4.21: Mạch điện đã lắp ráp xong.
Hình 4.22: Tạo mới tập tin batdenled.c.
Hình 4.23: Nhập mã lệnh Python cho tập tin batdenled.c.
Hình 4.24: Biên dịch tập tin batdenlen.c thành mã máy.
Hình 4.25: Thực thi mã lệnh C của tập tin a.out vừa được biên dịch từ batdenled.c.
Hình 5.1: Sơ đồ mạch điện lắp điện trở, đèn led và công tắc với RPi.
Hình 5.2: Nhập mã lệnh Python cho tập tin battatdenled.py.
Hình 5.3: Thực thi tập tin battatdenled.py sẽ yêu câu nhấn công tắc điện.
Hình 5.4: Màn hình in ra trạng thái của đèn led khi nhấn công tắc.
Hình 5.5: Sơ đồ mạch điện lắp điện trở, đèn led với RPi.
Hình 5.6: Nhập mã lệnh Python cho tập tin nhapnhayled.py.
Hình 5.7: Chương trình Python hoạt động, nhập vào số lần nháy và khoảng cách giữa
mỗi lần nhấp nháy, đèn led sẽ nhấp nháy và màn hình sẽ in ra trạng thái của đèn led.
Hình 5.8: Biểu đồ nhiệt độ vẽ bằng dygraphs với dữ liệu lấy từ tập tin my-vs-sf.txt.
Hình 5.9: Ví dụ cơ bản sử dụng thư viện dygraps.
Hình 5.10: Vẽ biểu đồ với dữ liệu lấy từ tập tin CVS – temperature.cvs.
Hình 5.11: Nội dung tập tin temperature.cvs.
Hình 5.12: Một số thông tin về DHT11.
Hình 5.13: Các chân của cảm biến DHT11.
Hình 5.14: Sơ đồ lắp ráp RPi với DHT11 và điện trở 10000Ω.
Hình 5.15: Thực thi tập tin dht11.c sẽ trả về giá trị nhiệt độ và độ ẩm.
Hình 5.16: Biểu đồ nhiệt độ, độ ẩm được vẽ bằng thư viện dygraphs và lấy dữ liệu từ tập
tin temp.log.
Hình 5.17: Máy chủ web đã được cài đặt trên RPi và hoạt động.
